Java :Poseur de lecture et de constructeur

Parfois, lors de la création d'un nouvel objet de la classe, certaines valeurs doivent être fournies. Pour un exemple, lors de la connexion à la base de données et la création de la classe de Connexion de l'objet, vous devez fournir une chaîne de connexion, de sorte qu'il sait de quoi vous vous connectez. La création de nouvelles connexions sans specyfing base de données cible serait assez inutile, non?

Aussi, jetez un oeil à ce

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

et ce

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

D'abord on regarde mieux, pas vrai?

OriginalL'auteur Zibi

c'est purement jusqu'à votre style de codage. Mais IMO, je voudrais utiliser paramétrées constructeur:

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

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

Dire, vous envoyez les 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 de l'objet de Connexion juste après la définition du nom d'utilisateur dans le 1er cas, il serait non valide à la réception de fin. mais la deuxième méthode est moins sujette aux bugs, bcz, il devient nécessaire de passer tous les paramètres requis.

OriginalL'auteur Ankit

Tout d'abord, les deux méthodes: Constructeur et de définition sont des moyens sûrs pour modifier les attributs de l'objet. Sont attendus à partir de la Classe de l'auteur pour exposer ou pas de moyens sûrs pour 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. À propos de ce qui est mieux: à l'Aide d'un constructeur ou via setter, cela dépend de ce que tu veux. Si vous ne modifiez un attribut d'un objet existant, u peut utiliser le setter, ou d'un objet rempli vous préférez peut-être le constructeur de 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");

        }
    }

OriginalL'auteur César Barbosa

Il est plus facile et plus sûr pour initialiser vos variables d'objet par l'intermédiaire de votre constructeur pour éviter nullpointers.

Si vous instanciez votre objet sans l'initialiser vos variables d'abord et vous faire une opération sur l'un de vos variables nulles, vous pourriez obtenir un nullpointer exception à l'exécution parce que vous avez oublié de définir manuellement sa valeur.

Sur le revers de la médaille, si vous avez toujours initialiser vos variables d'objet dans votre constructeur par défaut, vous avez un sérieux risque réduit d'obtenir nullpointer exceptions lors de l'exécution, car aucun de vos variables peuvent être null sauf si vous définissez spécifiquement par le biais d'un setter (qui n'est pas recommandé).

OriginalL'auteur JREN

Parce que vous écrivez à l'aide de moins, plus élégant et mieux lisible le code lorsque vous définissez les valeurs des paramètres dans un constructeur. En outre, parfois, certains champs sont indispensables pour l'objet, pour 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 est pas si "oblidged" pour appeler les organismes de normalisation.

OriginalL'auteur arjacsoh