web-dev-qa-db-fra.com

Java: Setter Getter et constructeur

Je suis un peu confus à propos de l'utilisation de getter/setters et de constructeurs (voir le code ci-dessous pour un exemple)

    public class ExampleClass {

        private int value = 0; 

        public ExampleClass () {
            value = 0; 
        }

        public ExampleClass (int i) {
            this.value = i;
        }

        public int getValue() {
            return value; 
        }

        public void setValue(int val) {
            this.value = val; 
        }

        public static void main(String[] args) {     
            ExampleClass example = new ExampleClass (20);
            example.setValue(20); 
            //Both lines above do same thing - why use constructor? 
            System.out.println(example.getvalue());
        }
   }

Tout ce que j'ai appris, c'est que nous avons besoin de getters/setters pour la sécurité et qu'ils peuvent également être utilisés pour changer ou éditer des valeurs plus tard.

Ma question est que si le constructeur est le point d'initialisation et qu'un constructeur par défaut est toujours présent, pourquoi utiliser un constructeur avec des paramètres pour initialiser des valeurs au lieu de getters/setters?. L'utilisation du getter et du setter n'apporterait pas de sécurité et pourrait facilement changer les valeurs à n'importe quelle étape. Veuillez clarifier ce point pour moi.

javaclassconstructorsettergetter
22
Java Student

le constructeur par défaut est toujours là

En fait, ce n'est pas toujours là. Un constructeur par défaut est celui qui est fourni par le compilateur (bien sûr c'est un constructeur sans argument) Seulement s'il n'y a pas d'autre constructeur défini dans la classe

pourquoi nous utilisons un constructeur avec des paramètres pour initialiser les valeurs au lieu de définir get

Parce qu'il pourrait y avoir une condition selon laquelle un objet ne peut toujours être créé que lorsque toutes les valeurs sont fournies au moment de l'initialisation lui-même et qu'il n'y a pas de valeur par défaut. Donc toutes les valeurs doivent être fournies sinon le code ne sera pas compilé.

Considérez cette classe Book

public class Book {

    private String title;
    private String author;

    public Book(String title, String author){
        this.title = title;
        this.author = author;
    }
     //getters and setters here 
}

Considérons une condition dans laquelle un livre ne peut être créé que s'il a title et author.

  • Vous ne pouvez pas faire new Book() car le constructeur sans argument est absent et le compilateur n'en fournira pas car un constructeur est déjà défini.
  • De plus, vous ne pouvez pas faire new Book() car notre condition ne remplit pas car chaque livre nécessite un titre et un auteur.

C'est la condition où le constructeur paramétré est utile.

22
Prasad Kharkar

Parfois, lors de la création d'un nouvel objet d'une classe, certaines valeurs DOIVENT être fournies. Par exemple, lorsque vous vous connectez à une base de données et créez un objet de classe Connection, vous devez fournir une chaîne de connexion, afin qu'il sache à quoi vous vous connectez. Créer une nouvelle connexion sans spécifier la base de données cible serait assez inutile, non?

Jetez également un œil à ce

Foo foo=new Foo(1,2,3,4,5,6,7);

et ça

Foo foo=new Foo();
foo.setP1(1);
foo.setP2(2);
foo.setP3(3);
foo.setP4(4);
foo.setP5(5);
foo.setP6(6);
foo.setP7(7);

Le premier est meilleur, non?

9
Zibi

Ma question est que si le constructeur est le point d'initialisation et que le constructeur par défaut est toujours là, alors pourquoi utiliser un constructeur avec des paramètres pour initialiser des valeurs au lieu de définir get.

Si vous pensez à un objet en transition vers différents états, il est logique d'avoir un constructeur paramétré avec des setters et des getters. Permettez-moi d'essayer de mettre un scénario réel: pensez à une classe Employé, un nouvel employé rejoint, vous ne connaissez pas beaucoup de détails mais peu et vous créez l'objet Employé avec la valeur par défaut et la valeur de base de ses attributs. Vous devez enregistrer l'employé dans le système et vous avez donc utilisé le constructeur paramétré. Une fois que vous obtenez plus de détails sur l'employé, vous utilisez des getters et setters pour mettre à jour les attributs.

6
Juned Ahsan

c'est purement jusqu'à votre style de codage. Mais IMO, j'utiliserais un constructeur paramétré:

  1. pour initialiser les valeurs qui ne doivent pas être modifiées. (comme le paramètre de nom d'utilisateur pour un objet personne)

  2. pour initialiser ces valeurs, sans définir lesquelles, l'objet sera dans un état non valide.

Disons que vous envoyez des paramètres de connexion à une méthode. Vous pouvez utiliser de ces façons

Login obj = new Login();
obj.setUsername("user");
obj.setPassword("pw")// what if someone commented this out, or you forget to call it


and otherway,
Login obj = new Login("user", "pw");

bien que vous puissiez envoyer un objet de connexion juste après avoir défini le nom d'utilisateur dans le premier cas, il ne serait pas valide à la fin de la réception. mais la seconde méthode est moins sujette aux bugs, bcz il devient nécessaire de passer tous les paramètres requis.

5
Ankit

Parfois, vous n'avez pas besoin de définir tous les champs sur des valeurs spécifiques au moment de la création. Par exemple, lorsque vous créez un tableau. En outre, comme déjà dit, il est plus sûr d'utiliser des getters - vous ne pouvez pas obtenir nullpointer.

N'oubliez pas d'écrire le constructeur par défaut lorsque vous avez défini le constructeur avec des paramètres. Ou assurez-vous de ne pas l'utiliser.

3
ba3a

Juste pour le rendre plus facile. Il faut moins de code pour utiliser un constructeur que pour créer un objet et utiliser les setters.

3
tbodt

Tout d'abord, les deux méthodes: Constructor et Setter sont des moyens sûrs de modifier les attributs d'un objet. Sont attendus de l'auteur de la classe pour exposer ou non des moyens sûrs de modifier une instance.

  1. Le constructeur par défaut est toujours fourni si vous n'en avez pas écrit un:

    // Example of a Class with a Default Constructor 
public class GetSet {

    private String value;

    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }


    public static void main(String[] args) {
        // Theres a implicit Default Constructor here
        // Its ok to do that
        // GetSet obj = new GetSet();
        GetSet obj = new GetSet();
    }

}


// Example of a Class without a Default Constructor 
public class GetSet2 {

    public GetSet2(String value) {
        this.value = value;
    }

    private String value;

    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }

    public static void main(String[] args) {
        // GetSet2 obj = new GetSet2(); // compile time error
        // Default constructor is not provided, since u wrote one
    }

}


2. À propos de ce qui est mieux: en utilisant un constructeur ou via setter, cela dépend de ce que vous voulez. Si vous ne souhaitez modifier qu'un attribut d'un objet existant, vous pouvez utiliser le setter, ou pour un objet complètement rempli, vous pouvez préférer le constructeur à la place.

    // Example of modifing an obj via Setter and Constructor
    public class GetSet3 {

        public GetSet3(String value1, String value2, String value3, String value4) {
            this.value1 = value1;
            this.value2 = value2;
            this.value3 = value3;
            this.value4 = value4;
        }

        private String value1;
        private String value2;
        private String value3;
        private String value4;


        // ... Getters and Setters



        public static void main(String[] args) {

            // Its easier to this
            GetSet3 obj;

            obj= new GetSet3("j", "a", "v", "a");

            // instead that
            // its also easy to forget or do something wrong
            // when u have a lot of attributes to set
            obj.setValue1("j");
            obj.setValue2("a");
            obj.setValue3("v");
            obj.setValue4("a");

        }
    }
3
César Barbosa

Le constructeur avec des arguments vous permet d'obtenir l'objet entièrement construit. Si vous souhaitez utiliser celui par défaut, vous devrez vous assurer que les champs sont définis à l'aide de setters. Lors de la définition de certaines propriétés, supposez que l'exception est levée, vous avez maintenant un objet qui n'est pas utilisable. Dans plusieurs cas, le setter ne serait pas exposé mais deviendrait. Dans ces cas, avoir un constructeur avec des arguments ou un constructeur nommé est la bonne option. En résumé, les getters et setters ont leur propre importance plutôt que d'initialiser l'objet.

Pourquoi utiliser des getters et setters?

2
Karthikeyan

Parce que vous l'écrivez en utilisant un code moins, plus élégant et plus lisible lorsque vous définissez les valeurs en tant que paramètres dans un constructeur. De plus, parfois certains champs sont indispensables pour l'objet, donc un constructeur de paramètre empêche l'utilisateur de créer un objet en omettant les champs nécessaires pour la fonctionnalité de l'objet. On n'est pourtant pas "oblitéré" pour appeler les colons.

2
arjacsoh

Il est plus facile et plus sûr d'initialiser vos variables d'objet via votre constructeur pour éviter les pointeurs nuls.

Si vous instanciez votre objet sans initialiser d'abord vos variables et que vous effectuez une opération get sur l'une de vos variables nulles, vous pouvez obtenir une exception nullpointer lors de l'exécution car vous avez oublié de définir manuellement sa valeur.

D'un autre côté, si vous initialisez toujours vos variables d'objet dans votre constructeur par défaut, vous avez un risque sérieusement réduit d'obtenir des exceptions nullpointer pendant l'exécution car aucune de vos variables ne peut être nulle à moins que vous ne les définissiez spécifiquement via un setter (qui n'est pas conseillé).

2
JREN