introduction

En conclusion, l'interface ne génère pas automatiquement des Getters et Setters. C'est naturel si vous comprenez la nature de l'interface, mais je suis personnellement confus, donc je vais le résumer.

L'environnement de développement est le suivant.

jdk 1.8.0_172
Lombok 1.18.2

Le copier-coller de getter et setter est un foyer de bugs

Je pense que vous créez souvent des classes en codage Java. Je pense qu'il y a beaucoup de gens qui définissent les getters et setters suivants à chaque fois. (Au moins j'étais)

//Classe ordinaire
public class SampleClass {
	//Variables de membre
	private String foo;

	// Getter
	public String getFoo() {
		return this.foo;
	}

	// Setter
	public void setFoo(String foo) {
		this.foo = foo;
	}
}

//Votre interlocuteur
public void SampleMethod {
	//Classe ordinaire
	SampleClass sample1 = new SampleClass();
	sample1.setFoo("hoge");
	System.out.println("sample1.getFoo(): " + sample1.getFoo());
}

Par exemple, si vous avez beaucoup de classes et de variables membres (champs) et que vous devez coder beaucoup de méthodes simples comme ce getter, je pense que beaucoup de gens vont copier et coller.

Ce genre de copie est difficile à remarquer même si vous faites une erreur, donc je pense qu'il est facile de devenir un foyer de bugs.

Et si vous ajoutez @Data à une classe?

Lombok résout ce problème. Écrivez simplement ce qui suit et cela générera automatiquement des getters et des setters. (Quelque chose comme les propriétés C #)

import lombok.Data;

//En classe@Ajouter des données
@Data
public class SampleClassWithLombok {
	//Variables de membre
	private String foo;
}

//Votre interlocuteur
public void SampleMethod {
	// @Classe avec données
	SampleClassWithLombok sample2 = new SampleClassWithLombok();
	sample2.setFoo("hoge");
	System.out.println("sample2.getFoo(): " + sample2.getFoo());
}

Avec cela, j'ai pu réduire la quantité de code et écraser le foyer de bogues.

Veuillez vous référer à la méthode d'introduction de Lombok, qui a été résumée ici auparavant.

Et si vous ajoutez @Data à l'interface?

Je me demandais ce qui se passe si j'ajoute @ Data à l'interface? à propos de ça.

Puisque «private» ne peut pas être spécifié pour les variables membres de l'interface, je voudrais ajouter un getter et un setter aux variables membres «public». (Cela n'a pas de sens)

Ajoutons @Data à une interface comme celle-ci.

//Sur l'interface@Ajouter des données
@Data
public interface SampleInterface {
	//Variables de membre
	public String bar = "bar";
}

Dès que je l'ai allumé, Eclipse a lancé l'erreur @Data n'est pris en charge que sur une classe..

Étant donné que les variables membres de l'interface sont des constantes en premier lieu, je pense que la raison en est que nous ne pouvons pas définir de setter.

Et si j'ajoute @Data à la classe d'implémentation?

Qu'en est-il de la classe d'implémentation? Supposons que vous ayez une interface et une classe d'implémentation comme celle-ci:

//interface
public interface SampleInterface {
}

import lombok.Data;

//Dans la classe d'implémentation@Ajouter des données
@Data
public class SampleImpl implements SampleInterface {
	//Variables de membre
	private String foo;
}

//Votre interlocuteur
public void SampleMethod {
	// @Classe d'implémentation avec données
	SampleInterface sample3 = new SampleImpl();
	sample3.setFoo("hoge");
	System.out.println("sample3.getFoo(): " + sample3.getFoo());
}

Quand j'ai écrit un code comme celui-ci, je n'ai pas eu d'erreur dans la classe d'implémentation de l'interface, mais j'ai eu une erreur dans l'appelant indiquant que method setFoo (String) n'est pas défini dans le type SampleInterface.

Il semble que getter et setter sont définis dans la classe d'implémentation, mais il semble qu'une erreur s'est produite car l'interface n'a pas la définition.

Ici, j'ai ajouté getter et setter à l'interface.

//Obtenir sur l'interface,Définir le passeur
public interface SampleInterface {
	// Getter
	public String getFoo();

	// Setter
	public void setFoo(String foo);
}

Maintenant, l'erreur a disparu. Cependant, j'ai fini par définir getter et setter dans l'interface. Avec cela, vous ne pouvez pas supprimer la copie-pemis.

Et si vous ajoutez @Data à une classe abstraite?

Et les classes abstraites? Supposons que vous ayez une telle classe abstraite et une classe héritée.

import lombok.Data;

//En classe abstraite@Ajouter des données
@Data
public abstract class SampleAbstract {
	//Variables de membre
	private String foo;
}

//Classe d'héritage
public class SampleExtends extends SampleAbstract {
}

//Votre interlocuteur
public void SampleMethod {
	// @Classe abstraite avec données
	SampleAbstract sample4 = new SampleExtends();
	sample4.setFoo("hoge");
	System.out.println("sample4.getFoo(): " + sample4.getFoo());
}

Lorsque j'ai écrit un code comme celui-ci, aucune erreur ne s'est produite. Contrairement à l'interface, les classes abstraites peuvent avoir des variables membres private, donc les getters et les setters peuvent également être définis automatiquement.

à la fin

Pour les classes ordinaires, les classes d'implémentation et les classes abstraites, le getter et le setter des variables membres peuvent être automatiquement définis en ajoutant @ Data.

Cependant, j'ai trouvé que l'interface devait définir manuellement les getters et les setters.

Je pense que vous pouvez facilement l'éviter en passant à la classe abstraite, mais il peut être préférable de revoir la conception de l'interface une fois lorsque getter et setter sont nécessaires pour l'interface en premier lieu.

Est-il possible de générer automatiquement Getter / Setter avec l'interface Java?