Java >> Tutoriel Java >  >> Java

Différences entre les constructeurs et les méthodes en Java

Java

Méthodes Java

  • Une méthode est utilisée pour explorer le comportement d'un objet.
  • Nous pouvons préfixer les modificateurs d'accès avec des méthodes.
  • Une méthode doit avoir un type de retour comme un void, n'importe quel type de primitives (int, char, float, etc.), n'importe quel type d'objet (Integer, Float, String, etc).
  • Le compilateur Java n'appelle pas la méthode implicitement, nous devons l'appeler explicitement.
  • Supposons que si nous avons une classe et dans cette classe, nous n'avons pas de méthode unique, donc dans ce cas, le compilateur Java n'inclut aucune méthode par défaut.
  • Il n'est pas obligatoire d'avoir le même nom de méthodes que son nom de classe ou en d'autres termes, le nom de la méthode peut ou non être le même que le nom de la classe.
  • Les méthodes sont de deux types :
    1. Aucune méthode d'argument
    2. Méthodes paramétrées

i) Méthode sans argument

Une méthode qui n'a ni paramètre ni argument ou en d'autres termes ce type de méthode ne prend aucun argument est connue sous le nom de méthode sans argument.

Exemple : 

class NoArgumentMethod {
    // No argument method definition
    void display() {
        System.out.println("We are in no argument method");
    }
}

class Main {
    public static void main(String[] args) {
        // creating an object of NoArgumentMethod class
        NoArgumentMethod nam = new NoArgumentMethod();
        // calling display() method 
        nam.display();
    }
}

Sortie : 

E:\Programs>javac Main.java

E:\Programs>java Main
We are in no argument method

ii) Méthode paramétrée

Une méthode qui a des paramètres ou en d'autres termes ce type de méthode prend n'importe quel argument est appelée méthode paramétrée.

Exemple : 

class ParameterizedMethod {
    String name;
    // Parameterized method definition
    void display(String name) {
        System.out.println("The name is " + name);
    }
}

class Main {
    public static void main(String[] args) {
        // creating an object of ParameterizedMethod class
        ParameterizedMethod pm = new ParameterizedMethod();

        // calling display() method 
        pm.display("Rahul");
    }
}

Sortie 

E:\Programs>javac Main.java

E:\Programs>java Main
The name is Rahul

Constructeurs Java

  • Un constructeur est une méthode spéciale qui appelle implicitement par JVM (Java Virtual Machine) au moment de la création d'un objet.
  • Le but d'un constructeur est d'initialiser une variable d'instance de l'objet.
  • Nous pouvons également préfixer les spécificateurs d'accès avec le constructeur.
  • Un constructeur ne doit pas avoir de type de retour, c'est-à-dire qu'il ne renvoie rien.
  • Un constructeur est une fonction spéciale qui appelle implicitement (c'est-à-dire qu'il est bon pour l'utilisateur que nous n'ayons pas besoin d'appeler explicitement).
  • Supposons que nous ayons une classe nommée "Constructor" et dans cette classe, nous n'incluons aucun constructeur. Dans ce cas, le compilateur Java inclura un constructeur par défaut.
  • Il est obligatoire d'avoir le même nom que le constructeur comme nom de classe ou en d'autres termes, le nom du constructeur doit être le même que le nom de la classe.
  • Nous avons trois types de constructeurs :
    1. Constructeur par défaut
    2. Constructeur paramétré
    3. Copier le constructeur

i) Constructeur par défaut

Ce constructeur par défaut est appelé implicitement par le compilateur si nous n'incluons aucun constructeur dans la classe. Le constructeur par défaut n'a pas de paramètre ou, en d'autres termes, un constructeur sans argument.

Exemple : 

class DefaultConstructor {
    // Constructor defined
    DefaultConstructor() {
        System.out.println("We are in default constructor");
    }
}

class Main {
    public static void main(String[] args) {
        // Calling Default constructor
        DefaultConstructor dc = new DefaultConstructor();
    }
}

Sortie 

E:\Programs>javac Main.java
E:\Programs>java Main
We are in default constructor

ii) Constructeur paramétré

Le constructeur qui a un paramètre est appelé constructeur paramétré. Si nous voulons initialiser la variable d'instance avec nos valeurs et que ce constructeur n'appelle pas implicitement par le compilateur.

Exemple : 

class ParameterizedConstructor {
    String name;
    // Constructor defined
    ParameterizedConstructor(String name) {
        this.name = name;
    }
}

class Main {
    public static void main(String[] args) {
        // Calling Parameterized constructor
        ParameterizedConstructor pc = new ParameterizedConstructor("Preeti");
        System.out.println("The name is :" + pc.name);
    }
}

Sortie 

E:\Programs>javac Main.java

E:\Programs>java Main
The name is : Preeti

iii) Copier le constructeur

Un constructeur qui a un paramètre et le paramètre est la référence de la même classe.

Exemple : 

class CopyConstructor {
    String name;
    // Constructor defined
    CopyConstructor(String name) {
        this.name = name;
    }
}

class Main {
    public static void main(String[] args) {
        // Calling constructor
        CopyConstructor cc1 = new CopyConstructor("Preeti");

        // Copied cc1 constructor 
        CopyConstructor cc2 = cc1;

        System.out.println("The value of cc1 is :" + cc1.name);
        System.out.println("The value of cc2 is :" + cc2.name);
    }
}

Sortie 

E:\Programs>javac Main.java

E:\Programs>java Main
The value of cc1 is :Preeti
The value of cc2 is :Preeti

Balise Java