But d'un constructeur en Java?

Un constructeur est fondamentalement une méthode que vous pouvez utiliser pour assurer que les objets de votre classe sont nés valide. C'est la principale motivation d'un constructeur.

Disons que vous voulez que votre classe ait un seul champ entier qui devrait être toujours plus grand que zéro. Comment faites - vous cela d'une manière fiable?

public class C {
     private int number;

     public C(int number) {
        setNumber(number);
     }

     public void setNumber(int number) {
        if (number < 1) {
            throws IllegalArgumentException("C cannot store anything smaller than 1");
        }
        this.number = number;
     }
}

Dans le code ci-dessus, il peut sembler que vous faites quelque chose de redondant, mais en fait, vous vous assurez que le nombre est toujours valide, peu importe quel.

"initialiser les instances d'une classe" est ce un constructeur, mais pas la raison pourquoi, nous avons des constructeurs. La question concerne le but d'un constructeur. Vous pouvez également initialiser des instances d'une classe en externe, en utilisant c.setNumber(10) dans l'exemple ci-dessus. Un constructeur n'est donc pas le seul moyen d'initialiser les instances.

Le constructeur le fait mais d'une manière qui est sûre. En d'autres termes, une classe seule résout tout le problème d'assurer leurs objets sont toujours dans des états valides. Ne pas utiliser un constructeur laissera une telle validation au monde extérieur, ce qui est une mauvaise conception.

Voici un autre exemple:

public class Interval {
    private long start;
    private long end;

    public Interval(long start, long end) {
        changeInterval(start, end);
    }

    public void changeInterval(long start, long end) {
        if (start >= end) {
            throw new IllegalArgumentException("Invalid interval.");
        }
        this.start = start;
        this.end = end;
    }
    public long duration() {
        return end - start;
    }
}

La classe Interval représente un intervalle de temps. Le temps est stocké en utilisant long. Cela n'a aucun sens d'avoir un intervalle qui se termine avant de commencer. En utilisant un constructeur comme celui ci dessus il est impossible d'avoir une instance d'intervalle à un moment donné n'importe où dans le système qui stocke un intervalle qui n'a pas de sens.

Comme mentionné dans la réponse LotusUNSW Les constructeurs sont utilisés pour initialiser les instances d'une classe.

Exemple:

Dites que vous avez une classe Animal quelque chose comme

class Animal{
   private String name;
   private String type;
}

Permet de voir ce qui se passe lorsque vous essayez de créer une instance de classe Animal, disons un Dog nommé Puppy. Maintenant, vous devez initialiser name = Puppy et type = Dog. Alors, comment pouvez-vous faire. Une façon de le faire est d'avoir un constructeur comme

    Animal(String nameProvided, String typeProvided){
         this.name = nameProvided;
         this.type = typeProvided;
     }

Maintenant, lorsque vous créez un objet de classe Animal, quelque chose comme Animal dog = new Animal("Puppy", "Dog"); votre constructeur est appelé et initialise name et type aux valeurs que vous avez fournies, c'est-à-dire Puppy et Dog respectivement.

Maintenant, vous pourriez demander si je ne fournissais pas d'argument à mon constructeur quelque chose comme

Animal xyz = new Animal();

Il est un default Constructor, qui initialise l'objet avec les valeurs par défaut c'est à dire dans notre Animal classe name et type valeurs correspondant à xyz objet serait name = null et type = null

Un constructeur initialise un objet lors de sa création . Il a le même nom que sa classe et est syntaxiquement similaire à une méthode , mais le constructeur n'a pas de type de retour expicit.Typiquement , nous utilisons le constructeur pour donner une valeur initiale aux variables d'instance définies par la classe , ou pour effectuer toute autre procédure de démarrage requise pour créer un objet entièrement formé.

Voici un exemple de constructeur:

class queen(){
   int beauty;

   queen(){ 
     beauty = 98;
   }
 }


class constructor demo{
    public static void main(String[] args){
       queen arth = new queen();
       queen y = new queen();

       System.out.println(arth.beauty+" "+y.beauty);

    }
} 

La sortie est:

98 98

Ici le constructeur est :

queen(){
beauty =98;
}

Maintenant le tour du constructeur paramétré.

  class queen(){
   int beauty;

   queen(int x){ 
     beauty = x;
   }
 }


class constructor demo{
    public static void main(String[] args){
       queen arth = new queen(100);
       queen y = new queen(98);

       System.out.println(arth.beauty+" "+y.beauty);

    }
} 

La sortie est:

100 98

• Via un constructeur (avec des paramètres), vous pouvez "demander" à l'utilisateur de cette classe les dépendances requises.
• , Il est utilisé pour initialiser les variables d'instance
• et de transmettre des arguments au constructeur d'une super classe (super(...)), qui fait fondamentalement la même chose
• Il peut initialiser des variables d'instance (finales) avec du code, qui peut lever des exceptions, par opposition à initializer d'instance scopes
• Il faut pas appeler aveuglément des méthodes de l'intérieur le constructeur, car l'initialisation peut ne pas être terminée / suffisante dans la classe locale ou une classe dérivée.

Il est utilisé pour configurer le contenu et l'état de votre classe. Bien qu'il soit vrai que vous pouvez faire l'exemple le plus simple avec la méthode principale, vous n'avez qu'une seule méthode principale par application, donc cela ne reste pas une approche raisonnable.

Considérez la méthode principale pour démarrer simplement votre programme et ne devrait pas savoir plus que comment le faire. Notez également que main () est statique et ne peut donc pas appeler les fonctions nécessitant une instance de classe et l'état associé. La méthode principale devrait appeler new Program ().la fonction() et la Le constructeur du programme ne doit pas appeler function() à moins qu'il ne soit requis pour la configuration de la classe.

La définition de classe définit l'API de votre classe. En d'autres termes, c'est un plan qui définit le contrat qui existe entre la classe et ses clients-tout l'autre code qui utilise cette classe. Le contrat indique quelles méthodes sont disponibles, comment les appeler et à quoi s'attendre en retour.

Mais la définition de la classe est une spécification. Jusqu'à ce que vous ayez un objet réel de cette classe, le contrat est juste "un morceau de papier."C'est là que le constructeur entre en jeu.

Un le constructeur est le moyen de créer une instance de votre classe en créant un objet en mémoire et en lui renvoyant une référence. Quelque chose que devrait se produire dans le constructeur est que l'objet est dans un état initial approprié pour que les opérations ultérieures sur l'objet aient un sens.

Cet objet renvoyé par le constructeur honorera désormais le contrat spécifié dans la définition de classe, et vous pouvez utiliser cet objet pour effectuer un travail réel.

Pensez-y de cette façon. Si vous regardez le site Web de Porsche, vous verrez ce qu'il peut faire the la puissance, le couple, etc. Mais ce n'est pas amusant tant que vous n'avez pas une vraie Porsche à conduire.

J'espère que cela aide.

Constructeur est fondamentalement utilisé pour initialiser les variables au moment de la création de l'objet

Java constructeur a le même nom que le nom de la classe à laquelle il appartient.

La syntaxe du constructeur n'inclut pas de type de retour, car les constructeurs ne renvoient jamais de valeur.

Le constructeur est toujours appelé lorsque l'objet est créé. exemple:- constructeur par Défaut

class Student3{  
    int id;  
    String name;  
    void display(){System.out.println(id+" "+name);}  
    public static void main(String args[]){  
        Student3 s1=new Student3();  
        Student3 s2=new Student3();  
        s1.display();  
        s2.display();  
    }  
} 

Sortie:

0 null
0 null

Explication: Dans la classe ci-dessus, vous ne créez aucun constructeur, donc le compilateur vous fournit un constructeur par défaut.Ici les valeurs 0 et null sont fournies par constructeur par défaut.

Exemple de constructeur paramétré

Dans cet exemple, nous avons créé le constructeur de la classe Student qui a deux paramètres. Nous pouvons avoir n'importe quel nombre de paramètres dans le constructeur.

class Student4{  
    int id;  
    String name;  
    Student4(int i,String n){  
        id = i;  
        name = n;  
    }  
    void display(){System.out.println(id+" "+name);}  
    public static void main(String args[]){  
        Student4 s1 = new Student4(111,"Karan");  
        Student4 s2 = new Student4(222,"Aryan");  
        s1.display();  
        s2.display();  
    }  
}  

Sortie:

111 Karan
222 Aryan

Je pensais qu'un constructeur pourrait fonctionner comme une base de données dans laquelle il ne définit que des variables et des méthodes pour les contrôler

Ensuite, j'ai vu des objets qui utilisent des variables et des méthodes non définies dans son constructeur. Donc, la discussion qui me semble la plus logique est celle qui teste la validité des valeurs des variables, mais la classe peut créer des variables et des méthodes qui ne sont pas définies dans le constructeur - moins comme une base de données et plus comme une soupape de surpression sur une locomotive à vapeur. Il ne contrôle pas les roues,etc.

Beaucoup moins d'une définition que je pensais.

Le constructeur sera utile pour empêcher les instances d'obtenir des valeurs irréelles. Pour un exemple, définissez une classe de personne avec la taille, le poids. Il ne peut pas y avoir une personne avec 0m et 0kg

Eh bien, je vais d'abord dire les erreurs dans deux extraits de code.

Premier extrait de code

public class Program
{
    public constructor() // Error - Return type for the method is missing
    {
        function();
    }        
    private void function()
    {
        //do stuff
    }   

    public static void main(String[] args)
    {
        constructor a = new constructor(); // Error - constructor cannot be resolved to a type
    }
}

Comme vous pouvez le voir le code ci-dessus, le nom du constructeur n'est pas le même que le nom de la classe. Dans la méthode main(), vous créez un objet à partir d'une méthode qui n'a pas de type de retour.

Deuxième extrait de code

public class Program
{
    public static void main(String[] args)
    {
        function(); // Error - Cannot make a static reference to the non-static method function() from the type Program
    }

    private void function()
    {
        //do stuff
    } 
}

Maintenant, dans cet extrait de code, vous essayez de créer une référence statique à la méthode non statique function() à partir du type Program, ce qui n'est pas possible.

Donc le possible la solution est la suivante,

Premier extrait de code

public class Program
{
    public Program()
    {
        function();
    }        
    private void function()
    {
        //do stuff
    }   

    public static void main(String[] args)
    {
        Program a = new Program();
        a.function();
    }
}

Deuxième extrait de code

public class Program
{
    public static void main(String[] args)
    {
        Program a = new Program();
        a.function();
    }

    private void function()
    {
        //do stuff
    } 
}

Enfin, la différence entre les extraits de code est que, dans le premier extrait de code, le nom de classe n'est pas le même que le nom de classe

Alors que dans le deuxième extrait de code, aucun constructeur n'est défini.

Pendant ce temps, pour comprendre le but du constructeur, référez-vous aux ressources ci-dessous,

Https://docs.oracle.com/javase/7/docs/api/java/lang/reflect/Constructor.html

Http://www.flowerbrackets.com/learn-constructor-in-java/

Http://www.flowerbrackets.com/java-constructor-example/

Considérons que nous stockons les détails des étudiants de 3 étudiants. Ces 3 étudiants ont des valeurs différentes pour sno, sname et sage, mais tous les 3 étudiants appartiennent au même département CSE. Il est donc préférable d'initialiser la variable "dept" dans un constructeur afin que cette valeur puisse être prise par tous les 3 objets étudiants.

Pour comprendre clairement, voir l'exemple simple ci-dessous:

class Student
{
    int sno,sage;
    String sname,dept;
    Student()
    {
        dept="CSE";
    }
    public static void main(String a[])
    {
        Student s1=new Student();
        s1.sno=101;
        s1.sage=33;
        s1.sname="John";

        Student s2=new Student();
        s2.sno=102;
        s2.sage=99;
        s2.sname="Peter";


        Student s3=new Student();
        s3.sno=102;
        s3.sage=99;
        s3.sname="Peter";
        System.out.println("The details of student1 are");
        System.out.println("The student no is:"+s1.sno);
        System.out.println("The student age is:"+s1.sage);
        System.out.println("The student name is:"+s1.sname);
        System.out.println("The student dept is:"+s1.dept);


        System.out.println("The details of student2 are");`enter code here`
        System.out.println("The student no is:"+s2.sno);
        System.out.println("The student age is:"+s2.sage);
        System.out.println("The student name is:"+s2.sname);
        System.out.println("The student dept is:"+s2.dept);

        System.out.println("The details of student2 are");
        System.out.println("The student no is:"+s3.sno);
        System.out.println("The student age is:"+s3.sage);
        System.out.println("The student name is:"+s3.sname);
        System.out.println("The student dept is:"+s3.dept);
    }
}

Sortie:

Les détails de student1 sont
Le numéro d'étudiant est: 101
L'âge de l'étudiant est: 33
Le nom de l'étudiant est:John
Le département étudiant est: CSE
Les détails de student2 sont
Le numéro d'étudiant est: 102
L'âge de l'étudiant est: 99
Le nom de l'étudiant est:Peter
Le département étudiant est: CSE
Les détails de student2 sont
Le numéro d'étudiant est: 102
L'âge de l'étudiant est: 99
Le nom de l'étudiant est:Peter
Le département étudiant est: CSE