[JAVA] Laissez le code parler plutôt que commenter (peut-être une valeur de retour)

table des matières

1.Tout d'abord 2. Laisser parler les types individuels 3. Laisser parler un type polyvalent 4. Enfin

introduction

Je suis sûr que vous avez utilisé les fonctions suivantes avec la documentation des commentaires.

java:java.lang.String

 * ...
 *Valeur de retour:
 *Index de la position où le caractère spécifié apparaît en premier dans la séquence de caractères représentée par cet objet. S'il n'y a pas de lettres-1。
 */
public int indexOf(int ch);

La valeur de retour de cette fonction essaie de représenter une valeur de succès de «index de position» et une valeur d'échec de «-1» en même temps. Ici, la valeur d'échec = -1 n'est probablement pas une valeur particulièrement valide, et tout ce qui ne chevauche pas la valeur de succès> = 0 convient. Par conséquent, vous devez ** vous référer à la documentation ** pour vérifier si ce type de fonction IF a réussi ou échoué. En d'autres termes, cette fonction n'est ** pas indiquée par le code **. Laisser parler le code signifie écrire du code qui est facile à comprendre et à utiliser sans regarder les commentaires ou la documentation. Ce qui suit est un exemple de laisser le code parler de la même fonction.

Laisser parler les types individuels

Cela signifie que la valeur de retour sera un objet de votre propre classe définie.

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;
	}
}

Le code du côté qui l'utilise est le suivant. (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()));
	}
}

Si la variable intermédiaire vous gêne, passez un rappel et faites-le appeler uniquement en cas de succès. (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);
	}
}

Laisser parler un type polyvalent

Dans l'exemple ci-dessus, le type augmente pour chaque fonction, alors créez une classe Generics et nommez-la Maybe. (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);
	}
}

à la fin

Personnellement, je préfère la valeur de retour Maybe . Bien sûr, s'il est dans la bibliothèque standard, je pense qu'il vaut mieux l'utiliser (facultatif pour java8). Si vous n'en avez pas, laissez le code parler même si vous le créez vous-même.