[GO] Seien Sie vorsichtig mit einfachen Methodenreferenzen

Einführung

Hallo. Es ist Kecho. ** Verwendet ihr Methodenreferenzen? ** ** ** Es ist bequem und lesbar. Mit einer solchen Methode Referenz. Ich werde einige Spezifikationen einführen, bei denen ich vorsichtig sein sollte.

Häufig benutzt

public class Main {
	public static void main(String[] args) throws Exception {
		Arrays.asList("test1", "test2").stream().forEach(System.out::println);
	}
}
// test1
// test2

Sie verweisen auf eine statische Methode. Sie können es auch so verwenden.

public class Main {
	public static void main(String[] args) throws Exception {
		Arrays.asList("test1", "test2").stream().map(String::toUpperCase).forEach(System.out::println);
	}
}
// TEST1
// TEST2

Sie rufen toUpperCase der String-Klasse auf. Leicht zu sehen und bequem.

So rufen Sie eine Instanzmethode auf

Obwohl die statische Methode oben eingeführt wurde, können Sie auch die Instanzmethode verwenden.

class Customer {
	public String getName() {
		return "which1";
	}
}

public class Main {
	public static void main(String[] args) throws Exception {
		Arrays.asList(new Customer(), new Customer()).stream().map(Customer::getName).forEach(System.out::println);
	}
}
// which1
// which1

Sie können in derselben Notation schreiben.

Mit anderen Worten

Das Folgende kann mit demselben `` `Customer :: getName``` geschrieben werden.

map(e -> Customer.getName(e)) //Beim Aufruf einer statischen Methode

map(e -> e.getName()) //Beim Aufruf der Instanzmethode der gespeicherten Instanz

Frage hier

Was ist, wenn ich beide Methoden habe, auf die ich verweisen kann? Ich habe erwähnt, dass Sie statische und Instanzmethoden in derselben Notation aufrufen können, aber wenn Sie beide haben, welche wird verwendet?

class Customer {
	public String getName() {
		return "which1";
	}

	static public String getName(Customer customer) {
		return "which2";
	}
}

public class Main {
	public static void main(String[] args) throws Exception {
		Arrays.asList(new Customer(), new Customer()).stream().map(Customer::getName).forEach(System.out::println);
	}
}

1. statische Methode
2. Instanzmethode
3. Kompilierungsfehler
4. Laufzeitfehler

↓ ↓ ↓ ↓ ↓ Die richtige Antwort ist 3 Kompilierungsfehler! Ich bekomme eine solche Fehlererklärung.

both getName() and getName(Customer) from the type Customer are eligible

 Japanische Übersetzung:
```Mehrdeutige Methodenreferenz: Sowohl getname () als auch getname (customer) vom Typ customer sind berechtigt```

 Sie erhalten einen Kompilierungsfehler, weil Sie nicht wissen, welchen Sie sich ansehen sollen.

# Worauf sollte ich schließlich achten?
 Diesmal habe ich einen Kompilierungsfehler ausgegeben, da auf beide Methoden verwiesen werden kann.
 Es gibt jedoch einige Muster, die auf einen Blick schwer zu verstehen sind und auf die nicht verwiesen werden kann, wie unten gezeigt.
 1. Wenn die Methode aufgrund der Sichtbarkeit nicht referenziert werden kann
 2. Wenn der Methodenname etwas anders ist
 3. Wenn die Methodenargumente unterschiedlich sind
 etc
 Auf welche Methode verwiesen wird, kann zu unerwartetem Verhalten des Entwicklers führen.

# Zusammenfassung
 Bei Objekten, die vom Entwickler implementierte Typen verwenden, ist es sicherer, keine Methodenreferenzen zu verwenden.