Zusammenfassend lässt sich sagen, dass die Schnittstelle Getter und Setter nicht automatisch generiert. Es ist natürlich, wenn Sie die Art der Benutzeroberfläche verstehen, aber ich persönlich bin verwirrt, also werde ich es zusammenfassen.
Die Entwicklungsumgebung ist wie folgt.
Ich denke, Sie erstellen häufig Klassen in Java-Codierung. Ich denke, es gibt viele Leute, die jedes Mal die folgenden Getter und Setter definieren. (Zumindest war ich)
//Gewöhnliche Klasse
public class SampleClass {
//Mitgliedsvariablen
private String foo;
// Getter
public String getFoo() {
return this.foo;
}
// Setter
public void setFoo(String foo) {
this.foo = foo;
}
}
//Anrufer
public void SampleMethod {
//Gewöhnliche Klasse
SampleClass sample1 = new SampleClass();
sample1.setFoo("hoge");
System.out.println("sample1.getFoo(): " + sample1.getFoo());
}
Wenn Sie zum Beispiel viele Klassen und Mitgliedsvariablen (Felder) haben und viele einfache Methoden wie diesen Getter codieren müssen, werden wahrscheinlich viele Leute kopieren und einfügen.
Selbst wenn Sie einen Fehler machen, ist es schwierig, diese Art des Kopierens und Einfügens zu bemerken. Ich denke, es ist einfach, eine Brutstätte für Fehler zu werden.
Lombok löst dieses Problem. Schreiben Sie einfach Folgendes und es werden automatisch Getter und Setter generiert. (So etwas wie C # -Eigenschaften)
import lombok.Data;
//Im Unterricht@Daten hinzufügen
@Data
public class SampleClassWithLombok {
//Mitgliedsvariablen
private String foo;
}
//Anrufer
public void SampleMethod {
// @Klasse mit Daten
SampleClassWithLombok sample2 = new SampleClassWithLombok();
sample2.setFoo("hoge");
System.out.println("sample2.getFoo(): " + sample2.getFoo());
}
Auf diese Weise konnte ich die Menge an Code reduzieren und die Brutstätte der Fehler zerstören.
Bitte beziehen Sie sich auf die Einführungsmethode von Lombok, die hier zuvor zusammengefasst wurde.
Ich habe mich gefragt, was passiert, wenn ich der Schnittstelle "@ Data" hinzufüge. darüber.
Da für die Mitgliedsvariablen der Schnittstelle kein "privat" angegeben werden kann, möchte ich den "öffentlichen" Mitgliedsvariablen Getter und Setter hinzufügen. (Es macht keinen Sinn)
Fügen wir einer solchen Schnittstelle @Data hinzu.
//Auf der Schnittstelle@Daten hinzufügen
@Data
public interface SampleInterface {
//Mitgliedsvariablen
public String bar = "bar";
}
Sobald ich es eingeschaltet habe, hat Eclipse den Fehler "@Data wird nur für eine Klasse unterstützt" ausgegeben.
Da die Mitgliedsvariablen der Schnittstelle in erster Linie Konstanten sind, liegt der Grund meiner Meinung nach darin, dass wir keinen Setter definieren können.
Was ist mit der Implementierungsklasse? Angenommen, Sie haben eine Schnittstelle und eine Implementierungsklasse wie diese:
//Schnittstelle
public interface SampleInterface {
}
import lombok.Data;
//In der Implementierungsklasse@Daten hinzufügen
@Data
public class SampleImpl implements SampleInterface {
//Mitgliedsvariablen
private String foo;
}
//Anrufer
public void SampleMethod {
// @Implementierungsklasse mit Daten
SampleInterface sample3 = new SampleImpl();
sample3.setFoo("hoge");
System.out.println("sample3.getFoo(): " + sample3.getFoo());
}
Als ich Code wie diesen schrieb, bekam ich keinen Fehler in der Schnittstellenimplementierungsklasse, aber ich bekam einen Fehler im Aufrufer, dass die Methode setFoo (String) im Typ SampleInterface undefiniert ist.
Es scheint, dass Getter und Setter in der Implementierungsklasse definiert sind, aber es scheint, dass ein Fehler aufgetreten ist, weil die Schnittstelle nicht über die Definition verfügt.
Hier habe ich Getter und Setter zur Schnittstelle hinzugefügt.
//Getter auf der Schnittstelle,Setter definieren
public interface SampleInterface {
// Getter
public String getFoo();
// Setter
public void setFoo(String foo);
}
Jetzt ist der Fehler weg. Am Ende habe ich jedoch Getter und Setter in der Schnittstelle definiert. Damit können Sie Copy-Pemis nicht unterdrücken.
Was ist mit abstrakten Klassen? Angenommen, Sie haben eine solche abstrakte Klasse und eine geerbte Klasse.
import lombok.Data;
//In der abstrakten Klasse@Daten hinzufügen
@Data
public abstract class SampleAbstract {
//Mitgliedsvariablen
private String foo;
}
//Vererbungsklasse
public class SampleExtends extends SampleAbstract {
}
//Anrufer
public void SampleMethod {
// @Abstrakte Klasse mit Daten
SampleAbstract sample4 = new SampleExtends();
sample4.setFoo("hoge");
System.out.println("sample4.getFoo(): " + sample4.getFoo());
}
Als ich einen solchen Code schrieb, trat kein Fehler auf. Im Gegensatz zur Schnittstelle können abstrakte Klassen "private" Mitgliedsvariablen haben, sodass Getter und Setter auch automatisch definiert werden können.
Für gewöhnliche Klassen, Implementierungsklassen und abstrakte Klassen können der Getter und der Setter von Mitgliedsvariablen automatisch durch Hinzufügen von "@ Data" definiert werden.
Ich stellte jedoch fest, dass die Schnittstelle Getter und Setter manuell definieren musste.
Ich denke, dass Sie es leicht vermeiden können, indem Sie zur abstrakten Klasse wechseln, aber es ist möglicherweise besser, das Design der Schnittstelle einmal zu überprüfen, wenn Sie Getter und Setter für die Schnittstelle benötigen.
Recommended Posts