[JAVA] Lassen Sie den Code sprechen anstatt zu kommentieren (möglicherweise Rückgabewert)

Inhaltsverzeichnis

1. Zuallererst
2. Lassen Sie einzelne Typen sprechen
3. Lassen Sie einen Allzwecktyp sprechen
4. Schließlich

Einführung

Ich bin sicher, Sie haben die folgenden Funktionen mit der Kommentardokumentation verwendet.

java:java.lang.String

 * ...
 *Rückgabewert:
 *Der Index der Position, an der das angegebene Zeichen zum ersten Mal in der von diesem Objekt dargestellten Zeichenfolge angezeigt wird. Wenn es keine Buchstaben gibt-1。
 */
public int indexOf(int ch);

Der Rückgabewert dieser Funktion versucht, gleichzeitig einen Erfolgswert von "Positionsindex" und einen Fehlerwert von "-1" darzustellen. Hier ist der Fehlerwert = -1 wahrscheinlich kein besonders gültiger Wert, und alles, was sich nicht mit dem Erfolgswert> = 0 überschneidet, ist in Ordnung. Daher müssen Sie ** in der Dokumentation ** nachsehen, ob diese Art von IF-Funktion erfolgreich war oder fehlgeschlagen ist. Mit anderen Worten, diese Funktion wird vom Code nicht angegeben. Den Code sprechen zu lassen bedeutet, Code zu schreiben, der leicht zu verstehen und zu verwenden ist, ohne auf Kommentare oder Dokumentation zu achten. Das Folgende ist ein Beispiel dafür, wie der Code über dieselbe Funktion spricht.

Lassen Sie einzelne Typen sprechen

Dies bedeutet, dass der Rückgabewert ein Objekt Ihrer eigenen definierten Klasse ist.

StringUtil

class StringUtil {
	public static ResultOfIndexOf indexOf(String haystack, char needle) {
		for (int i = 0; i < haystack.length(); ++i)
			if (haystack.charAt(i) == needle)
				return new ResultOfIndexOf(i);
		return new ResultOfIndexOf();
	}
}

class ResultOfIndexOf {
	private final boolean isFound;
	private final int foundIndex;
	ResultOfIndexOf() {
		this(false, 0);
	}
	ResultOfIndexOf(int foundIndex) {
		this(true, foundIndex);
	}
	private ResultOfIndexOf(boolean isFound, int foundIndex) {
		this.isFound = isFound;
		this.foundIndex = foundIndex;
	}
	public boolean isFound() {
		return isFound;
	}
	public int foundIndex() {
		if (!isFound)
			throw new RuntimeException("index not found");
		return foundIndex;
	}
}

Der Code auf der Seite, die dies verwendet, lautet wie folgt. (ideone)

Main

class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		ResultOfIndexOf result = StringUtil.indexOf("hello, world", 'l');
		if (result.isFound())
			System.out.println(String.format("index=%d", result.foundIndex()));
	}
}

Wenn die Zwischenvariable im Weg ist, übergeben Sie einen Rückruf und lassen Sie ihn nur bei Erfolg aufrufen. (ideone)

Main

import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.function.*;

class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		StringUtil.indexOf("hello, world", 'l')
			.DoIfSuccess(foundIndex -> {
				System.out.println(String.format("index=%d", foundIndex));
			});
	}
}

class StringUtil {
	public static ResultOfIndexOf indexOf(String haystack, char needle) {
		for (int i = 0; i < haystack.length(); ++i)
			if (haystack.charAt(i) == needle)
				return new ResultOfIndexOf(i);
		return new ResultOfIndexOf();
	}
}

class ResultOfIndexOf {
	private final boolean isFound;
	private final int foundIndex;
	ResultOfIndexOf() {
		this(false, 0);
	}
	ResultOfIndexOf(int foundIndex) {
		this(true, foundIndex);
	}
	private ResultOfIndexOf(boolean isFound, int foundIndex) {
		this.isFound = isFound;
		this.foundIndex = foundIndex;
	}
	public void DoIfSuccess(Consumer<Integer> postAction) {
		if (isFound && postAction != null)
			postAction.accept(foundIndex);
	}
}

Lassen Sie einen Allzwecktyp sprechen

Im obigen Beispiel erhöht sich der Typ für jede Funktion. Erstellen Sie daher eine Generics-Klasse und nennen Sie sie "Vielleicht". (ideone)

Maybe

import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.function.*;

class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		StringUtil.indexOf("hello, world", 'l')
			.DoIfSuccess(foundIndex -> {
				System.out.println(String.format("index=%d", foundIndex));
			});
	}
}

class StringUtil {
	public static Maybe<Integer> indexOf(String haystack, char needle) {
		for (int i = 0; i < haystack.length(); ++i)
			if (haystack.charAt(i) == needle)
				return Maybe.<Integer>just(i);
		return Maybe.<Integer>nothing();
	}
}

class Maybe<ResultType> {
	public static <R> Maybe<R> nothing() {
		return new Maybe(false, null);
	}
	
	public static <R> Maybe<R> just(R resultValue) {
		return new Maybe(true, resultValue);
	}
	
	private final boolean isSucceeded;
	private final ResultType resultValue;
	
	private Maybe(boolean isSucceeded, ResultType resultValue) {
		this.isSucceeded = isSucceeded;
		this.resultValue = resultValue;
	}
	
	public void DoIfSuccess(Consumer<ResultType> postAction) {
		if (isSucceeded && postAction != null)
			postAction.accept(resultValue);
	}
}

schließlich

Persönlich bevorzuge ich den Rückgabewert "Vielleicht ". Wenn es sich in der Standardbibliothek befindet, ist es natürlich besser, es zu verwenden (optional für Java8). Wenn Sie keinen haben, lassen Sie den Code sprechen, auch wenn Sie ihn selbst erstellt haben.