La principale différence est

1.Constructeur sont utilisés pour initialiser l'état de l'objet,où méthode c'est l'exposer le comportement de l'objet.

2.Constructeur ne doit pas avoir de type de retour où méthode doit avoir le type de retour.

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

4.Constructeur invoque implicitement où méthode invoque explicitement.

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

D'autres instructeurs et assistants d'enseignement me disent parfois que les constructeurs sont des méthodes spécialisées. J'ai toujours argumenter que en Java, les constructeurs ne sont PAS spécialisés méthodes.

si les constructeurs étaient des méthodes, Je m'attendrais à ce qu'ils aient les mêmes capacités que les méthodes. Qu'elles seraient au moins similaires à plus d'un titre que différentes.

en quoi les constructeurs diffèrent-ils des méthodes? Laissez-moi compter les façon...

1. les constructeurs doivent être appelés avec le new opérateur alors que les méthodes ne peuvent pas être invoquées à l' new opérateur. Related: les constructeurs ne peuvent pas être appelés par leur nom alors que les méthodes doivent être appelées par leur nom.

2. les constructeurs peuvent ne pas avoir un 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, il doit avoir un type de retour. Sinon, c'est un constructeur. Le fait que vous pouvez avoir deux Maclasse() les signatures dans la même définition de classe qui sont traitées différemment devraient 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 alors que les méthodes peuvent ne pas le faire.

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ériter.

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

alors, qu'est-ce qui est similaire à propos des méthodes et des 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 invoqué via new (constructeur.)

Comme pour les constructeurs et méthodes ayant les mêmes modificateurs de visibilité... les champs et les méthodes ont plus modificateurs de visibilité en commun.

1. les constructeurs peuvent être:privé, protégé, public.

2. les méthodes peuvent être: privé, protégé, public,résumé, statique, final,synchronisé,maternelle, strictfp.

3. champs de Données peuvent être: privé, protégé, public,statique, final,transitoire, volatile.

En Conclusion

En Java, la forme et la fonction des constructeurs est significativement différent que pour les méthodes. Ainsi, les appeler des méthodes spécialisées rend plus difficile pour les nouveaux programmeurs d'apprendre les différences. Ils sont beaucoup plus différents que similaires et leur apprentissage comme des entités différentes est critique en Java.

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

même javadoc reconnaît que les différences entre les constructeurs et les méthodes l'emportent sur les similitudes; et fournit une section séparée pour les constructeurs.

Un constructeur est une méthode spéciale qui vous permet de créer une nouvelle instance d'une classe. Il s'intéresse à la logique d'initialisation.

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 que j'ai tout expliqué dans les commentaires du code, mais voici un résumé: Les constructeurs de "construire" un objet du type de la classe. Le nom du constructeur doit être identique à celui de la classe. Ils sont principalement utilisés pour l'initialisation d'instance varibales Les méthodes sont des fonctionnalités des objets.

Une "méthode" est une "routine" 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 fondamentalement est un segment nommé de code que vous pouvez "appeler" à partir d'un autre code. En général, le code est correctement empaqueté, avec un " en-tête "quelconque qui donne son nom et ses paramètres et un" corps " activé par BEGIN& END ou ou quelque chose du genre.

un "constructeur" 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 un corps de méthode est encadré par {}.

et vous pouvez dire à un constructeur d'autres méthodes parce que le constructeur a le nom de classe pour son <method name> et n'a pas déclaré <return type>.

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

la différence r:

1. Constructeur doit avoir le même nom que la classe, mais la méthode peut être faite par n'importe quel nom.
2. les constructeurs ne sont pas hérités automatiquement par les classes d'enfant tandis que la méthode d'enfant hérite de leur classe de parent à moins qu'ils R protégés par mot-clé privé.
3. Constructeur r appelées explicitement alors que les méthodes impliquent implicitement.
4. le constructeur n'a pas de type de retour alors que la méthode A.

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

Constructeur nom est le même nom que le nom de la classe, d'où le nom de la méthode peut ou ne peut pas ou nom de la classe.

le constructeur ne permet aucun type de retour, où les méthodes permettent le type de retour.

le constructeur est typiquement Méthode.

Quand on crée un objet d'une classe de nouveaux opérateur puis nous avons invoqué une méthode spéciale appelée constructeur.

Constructeur utilisé pour effectuer l'initialisation de la 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 le constructeur: Contructor Print me

Donc,n'afficher que les ici, L'instruction diff() de méthode du constructeur car nous créons L'objet Diff class. Dans ce cas, le constructeur vient toujours en premier pour instancier Class here class Diff().

généralement

le constructeur est configuré.

tout commence ici, quand nous appelons ob object dans le constructeur de la méthode principale prend cette classe et crée la copie et elle est chargée dans le "Java Virtual Machine Class loader".

ce chargeur de classe prend cette copie et charge dans mémoire, donc nous pouvons maintenant l'utiliser par référencement.

le constructeur a fait son travail puis la méthode est venue et a fait sa mise en œuvre réelle.

dans ce programme quand nous appelons

ob.print();

ensuite, la méthode va venir.

Merci

Arindam

La différence Majeure est Donnée ci-Dessous -

1: Le constructeur doit avoir le même nom que le nom de 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. Méthodes effectue des opérations sur des objets qui existent déjà. 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");
    }
}