web-dev-qa-db-fra.com

Méthodes vs constructeurs en Java

Je viens de commencer à programmer avec Java. Le texte que nous utilisons fait défaut lorsqu'il est question de méthodes et de constructeurs. Je ne sais pas ce qu'est exactement une méthode ou un constructeur et ce qui les rend uniques. Quelqu'un peut-il m'aider s'il vous plaît à les définir et à différencier les deux? 

javamethodsconstructor
19
nckbrz

La différence importante entre les constructeurs et les méthodes réside dans le fait que les constructeurs initialisent les objets créés avec l'opérateur new, tandis que les méthodes effectuent des opérations sur des objets existants.

Les constructeurs ne peuvent pas être appelés directement; ils sont appelés implicitement lorsque le mot clé new crée un objet. Les méthodes peuvent être appelées directement sur un objet déjà créé avec new.

Les définitions des constructeurs et des méthodes se ressemblent dans le code. Ils peuvent prendre des paramètres, ils peuvent avoir des modificateurs (par exemple, public) et ils ont des corps de méthodes entre accolades.

Les constructeurs doivent porter le même nom que le nom de la classe. Ils ne peuvent rien retourner, même void (l'objet lui-même est le retour implicite).

Les méthodes doivent être déclarées pour renvoyer quelque chose, bien qu'il puisse être void.

54
rgettman

La principale différence est

1. Constructeur sont utilisés pour initialiser l’état de l’objet, où en tant que méthode est exposé le comportement de l’objet. 

2. Le constructeur ne doit pas avoir de type de retour où, comme la méthode doit avoir un type de retour. 

3. Constructor name identique au nom de la classe où méthode peut ou ne pas avoir le même nom de classe. 

4. Constructor invoke implicitement où en tant que méthode invoke explicitement. 

5. Constructeur compilateur fournit le constructeur par défaut là où méthode compilateur ne fournit pas. 

7
murthy naika k

D'autres instructeurs et assistants d'enseignement me disent parfois que les constructeurs sont des méthodes spécialisées. Je soutiens toujours que dans Java, les constructeurs ne sont PAS des méthodes spécialisées .

Si les constructeurs étaient des méthodes, je m'attendrais à ce qu'ils aient les mêmes capacités que les méthodes. Qu'ils seraient au moins similaires à bien des égards.

En quoi les constructeurs sont-ils différents des méthodes? Laisse moi compter les chemins ...

  1. Les constructeurs doivent être appelés avec l'opérateur new, tandis que les méthodes ne peuvent pas être appelés avec l'opérateur new. Connexes: les constructeurs ne peuvent pas être appelés par nom, alors que les méthodes doivent être appelées par nom.

  2. Les constructeurs peuvent ne pas avoir de type de retour alors que les méthodes doivent avoir un type de retour.

  3. Si une méthode a le même nom que la classe, elle doit avoir un type de retour. Sinon, c'est un constructeur. Le fait que vous puissiez avoir deux signatures MyClass () dans la même définition de classe traitées différemment devrait convaincre tous que les constructeurs et les méthodes sont des entités différentes:

    public class MyClass {
   public MyClass() { }                                   // constructor
   public String MyClass() { return "MyClass() method"; } // method
}

  4. Les constructeurs peuvent initialiser les constantes d'instance, contrairement aux méthodes.

  5. Les constructeurs publics et protégés ne sont pas hérités, alors que les méthodes publiques et protégées sont héritées.

  6. Les constructeurs peuvent appeler les constructeurs de la super-classe ou de la même classe, tandis que les méthodes ne peuvent appeler ni super () ni this ().

Alors, quelle est la similitude entre les méthodes et les constructeurs?

  1. Ils ont tous les deux des listes de paramètres.

  2. Ils ont tous les deux des blocs de code qui seront exécutés lorsque ce bloc est appelé directement (méthodes) ou appelé via new (constructeurs).

En ce qui concerne les constructeurs et les méthodes ayant les mêmes modificateurs de visibilité ... les champs et les méthodes ont plus de modificateurs de visibilité en commun.

  1. Les constructeurs peuvent être: private, protected, public.

  2. Les méthodes peuvent être: private, protected, public, abstract, static, final, synchronized, native, strictfp.

  3. Les champs de données peuvent être: private, protected, public, static, final, transient, volatile.

En conclusion

En Java, la forme et la fonction des constructeurs sont significativement différentes de celles des méthodes. Ainsi, en les appelant des méthodes spécialisées, il est en réalité plus difficile pour les nouveaux programmeurs d’apprendre les différences. Ils sont beaucoup plus différents que similaires et leur apprentissage en tant qu'entités différentes est essentiel en Java. 

Je reconnais que Java est différent des autres langages à cet égard, à savoir C++, où le concept de méthodes spécialisées trouve son origine et est pris en charge par les règles de langage. Mais, en Java, les constructeurs ne sont pas du tout des méthodes, encore moins des méthodes spécialisées.

Même javadoc reconnaît que les différences entre constructeurs et méthodes dépassent les similitudes; et fournit une section séparée pour les constructeurs.

5
OrangeDeb

En Java, les classes que vous écrivez sont des objets. Les constructeurs construisent ces objets. Par exemple si j'ai un Apple.class comme ceci:

public class Apple {
    //instance variables
    String type; // Macintosh, green, red, ...

    /**
     * This is the default constructor that gets called when you use
     * Apple a = new Apple(); which creates an Apple object named a.
     */

    public Apple() {
        // in here you initialize instance variables, and sometimes but rarely
        // do other functionality (at least with basic objects)
        this.type = "Macintosh"; // the 'this' keyword refers to 'this' object. so this.type refers to Apple's 'type' instance variable.
    }

    /**
     * this is another constructor with a parameter. You can have more than one
     * constructor as long as they have different parameters. It creates an Apple
     * object when called using Apple a = new Apple("someAppleType");
     */
    public Apple(String t) {
        // when the constructor is called (i.e new Apple() ) this code is executed
        this.type = t;
    }

    /**
     * methods in a class are functions. They are whatever functionality needed
     * for the object
     */
    public String someAppleRelatedMethod(){
        return "hello, Apple class!";
    }

    public static void main(String[] args) {
        // construct an Apple
        Apple a = new Apple("green");
        // 'a' is now an Apple object and has all the methods and
        // variables of the Apple class.
        // To use a method from 'a':
        String temp = a.someAppleRelatedMethod();
        System.out.println(temp);
        System.out.println("a's type is " + a.type);
    }
}

J'espère avoir tout expliqué dans les commentaires du code, mais voici un résumé: Les constructeurs 'construisent' un objet de type de la classe. Le constructeur doit porter le même nom que la classe. Elles sont principalement utilisées pour initialiser des varibales d’instance Les méthodes sont des fonctionnalités des objets.

4
Alex Mohr

Un constructeur est un type de méthode spécial qui vous permet de créer une nouvelle instance d'une classe. Cela concerne la logique d'initialisation.

3
Willie Wheeler

la différence r:

  1. Le constructeur doit avoir le même nom que la classe mais la méthode peut être faite avec n'importe quel nom.
  2. Les constructeurs n'héritent pas automatiquement des classes enfants tandis que ceux-ci héritent d'une méthode de leur classe parente à moins d'être protégés par un mot clé privé.
  3. Le constructeur r a appelé explicitement les méthodes implicitement.
  4. Le constructeur n'a pas de type de retour alors que la méthode a.
1
naved

Le constructeur est une fonction spéciale utilisée pour initialiser le membre de données, où les méthodes sont des fonctions pour effectuer des tâches spécifiques.

Le nom du constructeur est le même nom que le nom de la classe, le nom de la méthode pouvant ou non être le nom de la classe.

Le constructeur n'autorise aucun type de retour, alors que les méthodes autorisent le type de retour.

1
geetha

Une "méthode" est un "sous-programme" est une "procédure" est une "fonction" est un "sous-programme" est un ... Le même concept va sous beaucoup de noms différents, mais est fondamentalement un segment de code nommé que vous pouvez " call "depuis un autre code. Généralement, le code est soigneusement empaqueté, avec un "en-tête" qui indique son nom et ses paramètres, et un "corps" défini par BEGIN & END ou { & } ou autre.

Un "développeur" est une forme spéciale de méthode dont le but est d'initialiser une instance d'une classe ou d'une structure.

En Java, l'en-tête d'une méthode est <qualifiers> <return type> <method name> ( <parameter type 1> <parameter name 1>, <parameter type 2> <parameter name 2>, ...) <exceptions> et le corps d'une méthode est encadré par {}. 

Et vous pouvez distinguer un constructeur d'autres méthodes, car le constructeur a le nom de classe pour son <method name> et n'a pas de <return type> déclaré.

(En Java, bien sûr, vous créez une nouvelle instance de classe avec l'opérateur new - new <class name> ( <parameter list> ).) 

1
Hot Licks

La différence majeure est donnée ci-dessous - 

1: Le constructeur doit avoir le même nom que le nom de la classe alors que ce n'est pas le cas des méthodes 

class Calendar{
    int year = 0;
    int month= 0;

    //constructor
    public Calendar(int year, int month){
        this.year = year;
        this.month = month;
        System.out.println("Demo Constructor");
    }

    //Method
    public void Display(){

        System.out.println("Demo method");
    }
}

2: Le constructeur initialise les objets d'une classe alors que la méthode ne le fait pas. Les méthodes effectuent des opérations sur des objets existants. En d'autres termes, pour appeler une méthode, nous avons besoin d'un objet de la classe. 

public class Program {

    public static void main(String[] args) {

        //constructor will be called on object creation
        Calendar ins =  new Calendar(25, 5);

        //Methods will be called on object created
        ins.Display();

    }

}

3: le constructeur n'a pas de type de retour mais une méthode doit avoir un type de retour 

class Calendar{

    //constructor – no return type
    public Calendar(int year, int month){

    }

    //Method have void return type
    public void Display(){

        System.out.println("Demo method");
    }
}
0
sachin dubey

Le constructeur est généralement Méthode .

Lorsque nous créons un objet d'un nouvel opérateur de classe à utiliser, nous invoquons un type spécial de méthode appelé constructeur.

Constructeur utilisé pour l'initialisation d'une variable d'instance.

Code:

public class Diff{

public Diff() { //same as class name so constructor 

        String A = "Local variable A in Constructor:";
        System.out.println(A+ "Contructor Print me");
    }
   public void Print(){
        String B = "Local variable B in Method";
        System.out.println(B+ "Method print me");
    } 


    public static void main(String args[]){
        Diff ob = new Diff();

        }
}

`

  • Sortie:

    Variable locale A dans Constructeur: Contrôleur Imprimez-moi

Donc, montrez seulement ici l'instruction Diff () de la méthode constructeur parce que nous créons un objet de la classe Diff. Dans ce cas, le constructeur vient toujours en premier pour instancier Class ici class Diff ().

typiquement,

Constructor est mis en place fonctionnalité.

Tout commence par ici, lorsque nous appelons objet ob dans le constructeur de la méthode main, prend cette classe et crée une copie, qui est chargée dans le "chargeur de classes de machine virtuelle Java".

Ce chargeur de classe prend cette copie et la charge en mémoire, nous pouvons donc l'utiliser par référencement.

Le constructeur a fait son travail puis la méthode sont venus et sa mise en œuvre réelle.

Dans ce programme quand on appelle

ob.print();

alors la méthode viendra.

Merci 

Arindam

0
Arindam Sarkar