Java: Setter Getter et constructor

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, il s'agit d'un non-arg constructeur ) Seulement si il n'existe aucun autre constructeur défini dans la classe

pourquoi nous utilisons constructor avec des paramètres pour initialiser les valeurs au lieu de set get

parce Qu'il pourrait y avoir une condition qu'un objet peut toujours être créé seulement lorsque toutes les valeurs sont fournies au moment de l'initialisation elle-même et qu'il n'y a pas de valeur par défaut. Toutes les valeurs doivent donc être fournies, sinon le code ne sera pas compilé.

Considérer ce Book classe

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 
}

Envisager une situation où un livre ne peut être créée que si elle a title et author.

• Vous ne pouvez pas faire new Book() parce que le constructeur no-arg est absent et que le compilateur n'en fournira pas un parce qu'un constructeur est déjà définir.
• vous ne pouvez pas non plus faire new Book() parce que notre condition n'est pas remplie car chaque livre a besoin d'un titre et d'un auteur.

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

parfois, lors de la création d'un nouvel objet d'une classe, certaines valeurs doivent être fournies. Par exemple, lorsque vous vous connectez à un objet database et creating Connection class, vous devez fournir une chaîne de connexion, de sorte qu'elle sache à quoi vous vous connectez. Créer une nouvelle connexion sans specyfing base de données de cible serait plutôt inutile, non?

aussi, jetez un coup d'oeil à ceci

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

et

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 a l'air mieux, Non?

ma question Est que si le constructeur est le point d'initialisation et constructeur par défaut est toujours là, alors pourquoi nous utilisons constructeur paramètres pour initialiser les valeurs, plutôt que de définir obtenir.

si vous pensez à un objet en transition dans des états différents, alors il est logique d'avoir un constructeur paramétré avec des setters et des getters. Permettez-moi de mettre un scénario de la vie réelle: pensez à une classe D'employé, un nouvel employé se joint, vous ne savez pas beaucoup de détails mais peu et vous créez l'objet de L'employé avec defualt et la valeur de base de ses attributs. Vous devez enregistrer l'employé dans le système et donc vous avez utilisé le constructeur paramétrisé. Une fois que vous obtenez plus de détails sur l'employé, vous utilisez getters et setters pour mettre à jour les attributs.

ceci est purement à la hauteur de votre style de codage. Mais IMO, j'utiliserais le constructeur paramétré:

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

2. pour initialiser ces valeurs, sans paramètre, l'objet sera en état non valide.

par exemple, vous envoyez des paramètres de connexion à une méthode. Vous pouvez utiliser ces moyens

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");

alors que vous pouvez envoyer l'objet Login juste après avoir défini le nom d'utilisateur dans le premier cas, il serait invalide à recieving end. mais la deuxième méthode est moins sujette aux bugs, bcz, il devient nécessaire de passer tous les paramètres requis.

Parfois, vous n'avez pas besoin de tous les champs à valeurs spécifiques au moment de la création. Par exemple, quand vous faites une rangée. En outre, comme déjà dit, il est plus sûr quand vous utilisez getters -- vous ne pouvez pas obtenir nullpointer.

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

juste pour faciliter les choses. Il faut moins de code pour utiliser un constructeur que pour créer un objet et utiliser les setters.

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

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 pourriez obtenir une exception nullpointer à l'exécution parce que vous avez oublié de définir manuellement sa valeur.

sur le côté de cela, si vous initialisez toujours vos variables objet dans votre constructeur par défaut, vous avez un sérieux réduction du risque d'obtenir des exceptions nullpointer pendant l'exécution parce qu'aucune de vos variables ne peut être nulle sauf si vous les définissez spécifiquement via un setter (ce qui n'est pas recommandé).

constructeur avec arguments vous permet d'obtenir l'objet entièrement construit. Si vous voulez utiliser une valeur par défaut, vous devez vous assurer que les champs sont définis en utilisant des setters. Pendant l'ensemble de quelque propriété, supposons que l'exception est lancée, maintenant vous avez un objet qui n'est pas utilisable. Dans plusieurs cas, setter ne serait pas exposé, mais getter. Dans ces cas, avoir un constructeur avec des arguments ou un constructeur nommé est la bonne option. En un mot, getters et setters ont leur propre importance. plutôt que de l'initialisation de l'objet.

Pourquoi utiliser getters et setters?

parce que vous l'écrivez en utilisant moins de code, plus élégant et mieux lisible lorsque vous définissez les valeurs comme paramètres dans un constructeur. De plus, parfois, certains champs sont indispensables pour l'objet, de sorte qu'un constructeur de paramètres empêche l'utilisateur de créer un objet en omettant les champs nécessaires à la fonctionnalité de l'objet. On n'est cependant pas "bloqué" à appeler les setters.

tout d'abord, les deux méthodes: Constructor et Setter sont des façons sûres de changer les attributs d'un objet. Sont attendus de la part de L'auteur de classe pour exposer ou non des façons sûres de modifier une instance.

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

   // 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. A propos de ce qui est mieux: utiliser un constructeur ou via setter, cela dépend de ce que vous voulez. Si vous ne modifiez un attribut d'un objet existant, u peut utilisez 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");

        }
    }