Différence entre les constructeurs et les méthodes

Je suppose que votre question est pourquoi le constructeur est créé à l'aide de...

public Puppy(String name)

...au lieu de...

public static void Puppy(String name)

..., non?

Si elle l'est, tout d'abord, vous devez maintenant qu'un constructeur est une méthode spéciale détenu par une classe qui est appelée à chaque fois que vous créez une nouvelle instance de cette classe. Donc, si, par exemple, vous avez cette classe...

public class Clazz {
    public Clazz (String s) {
         System.out.println(s);
    }
}

..., alors à chaque fois que vous créez une nouvelle instance de cette classe comme...

Clazz c = new Clazz("Hello World");

..., le constructeur sera appelé et que la méthode sera exécutée. (Dans cet exemple, il devrait afficher "Hello World" sur l'écran.)

Cela dit, vous pouvez voir que le constructeur est une méthode, mais c'est une méthode spéciale appelée lorsque la classe est instanciée. Donc, pour répondre à votre question, la raison pour laquelle le constructeur est de cette manière plutôt que d'une méthode régulière de l'en-tête est pour indiquer au compilateur que c'est un constructeur et pas d'une méthode régulière. Si vous écrivez public void Clazz () au lieu de public Clazz (), alors le compilateur ne reconnaîtra pas votre constructeur, et pense que c'est juste une méthode régulière.

Remarque que les constructeurs ne reviennent jamais rien, donc il ne serait pas nécessaire d'utiliser la vide mot-clé. Aussi, il n'y a pas de sens d'en faire un constructeur statique, puisque le constructeur est appelé lorsqu'un objet est instancié.

OriginalL'auteur

Indiqué dans le Java Spec pour les Constructeurs:

• Constructeurs ne retourne rien, donc ils n'ont pas de type de retour.

  Dans tous les autres égards, le constructeur déclaration ressemble à une déclaration de méthode qui n'a pas de résultat (§8.4.5).

• Vous ne pouvez pas remplacer un constructeur.

  Constructeur déclarations ne sont pas membres. Ils ne sont jamais hérité et, par conséquent, ne sont pas soumis à la clandestinité ou de la transgression.

• Ils ne peuvent accéder aux variables d'instance directement, au lieu de cela, ils doivent utiliser this et super à déléguer à des classes de variables.

  Explicitement un constructeur invocation de la déclaration d'un constructeur de corps peut ne pas se référer à une instance quelconque des variables ou des méthodes d'instance ou à l'intérieur des classes déclarées dans cette classe ou tout super-classe, ou de l'utiliser ou de super dans toute expression; sinon, une erreur de compilation se produit.

OriginalL'auteur

plusieurs bonnes réponses sur les constructeurs déjà.

Un point mineur; vous ne pouvez pas avoir une méthode statique avec le même nom que la classe. Ce nom est réservés pour les constructeurs.

OriginalL'auteur

Pour cet exemple, vous n'avez pas besoin d'un constructeur. C'est un assez mauvais exemple. Une méthode pourrait fonctionner tout aussi bien.

(Toutes les classes Java avoir un constructeur par défaut si vous n'ajoutez pas un, de sorte que vous pouvez toujours appeler new Puppy() pour obtenir un exemple.)

OriginalL'auteur

Un Constructor c'est juste que, il "construit" l'objet que vous créez, il est techniquement un type spécifique de Method. Un Method est utilisé pour modifier l'objet, surtout pour faire un seul morceau de la logique. Voir: single responsibility principle.

Classes/méthodes doivent être simples et poignée exacte des éléments d'information, par exemple, un Shape objet, si vous voulez c'est d'attributs longueur, largeur, hauteur, volume, surface, ect... votre constructeur aurait du être:

public Shape (double length, double width, double height, double volume, double area, ect...) {
    //code here
} 

(notez le nom de cette méthode doit être le même que le nom de la classe, qui signifie une "Constructor")

c'est ce qui est connu comme une code smell, en particulier: trop de paramètres. Il est difficile à lire, pas très organisé, et une mauvaise manière d'écrire du code. Donc, au lieu de cela, des méthodes sont utilisées pour définir ces variables:

public void setLength(double length) {
    //code here
} 

Alors votre constructeur ne seraient:

public Shape() {
    //code here
}

Ce n'est qu'un simple exemple. Dans de nombreux cas, vous souhaitez passer un paramètre (ou un peu plus) dans le constructeur, selon le cas.

OriginalL'auteur

constructeur est
public Class(){
définir la variable qui doivent être utilisés dans l'ensemble de la classe
la méthode est d'aller en vertu de constructeur
public void methodName(){}
u peut changer vide de type de variable que tu veux que la méthode renvoie le type spécifique.

OriginalL'auteur

Votre premier exemple est un constructeur public qui est appelé lorsque vous créez un Chiot. Généralement, le constructeur enregistrer le nom au lieu de l'afficher et de le jeter, donc vous pouvez vous y référer plus tard, par exemple:

public class Puppy{
    private String puppyName;

    public Puppy(String name){
        puppyName = name;
    }
    public void bark(){
        System.out.println(puppyName + ": woof!");
    }
    ...
}
...
public static void main(){
    Puppy Spot = new Puppy("Spot"); //here, the constructor is called, which saves the name
                                    //"Spot" into the variable Spot.puppyName.

    Puppy Fido = new Puppy("Fido"); //on this line, the constructor is called again, but this time, the string
                                    //"Fido" is saved into Fido.puppyName.

    Spot.bark();                    //output: "Spot: woof!"
}

Je pense à un constructeur comme une méthode qui "renvoie" un Chiot objet, c'est pourquoi il n'a pas de type de retour. Les méthodes et les variables qui sont déclarées statiques, à la différence de la chiot de nom, ne leur "appartiennent" à n'importe quel objet en particulier, mais sont partagés entre tous les membres de la classe.

public class Puppy{
    ...
    private static String latinName;
    public static void setLatinName(String newLatinName){
        latinName = newLatinName;
    }
    public static void printLatinName(){
        System.out.println("I am a " + latinName + ".");
    }
};
...
static void main(){
    Puppy Spot("Spot");
    Puppy Fido("Spot");
    Spot.setLatinName("Canis Lupus");
    Fido.setLatinName("Canis Lupus Familiaris");

    Spot.printLatinName();    //output: "I am a Canus Lupus Familiaris."
    //even though we used the Fido object to change the latinName string,
    //the output of Spot's non-static method still reflects the change because
    //latinName is a static field: there is only one String latinName 
    //shared among all members of the class.
}

Alors que vous pouvez utiliser un Chiot objet à appeler des méthodes statiques (qui pourrait être particulièrement utile si le Chiot ont été polymorphe Canine), l'inverse n'est pas vrai!

public class Puppy{
    ...
    public static void bark(){
        System.out.println( puppyName + ": woof!"); //this will not compile!
    }
}

Il est invalide (et ne fait pas de sens) pour faire référence à des non-membres de données statiques dans le contexte d'une fonction statique! Une fonction statique est similaire à une variable statique: il y a une seule copie de la fonction partagée entre tous les objets. Cela signifie que vous pouvez appeler le Chiot.setLatinName() (au lieu de Spot.setLatinName()). Vous n'avez pas besoin d'utiliser un Chiot objet de l'appel d'une fonction statique: une fonction statique est la garantie de ne pas dépendre d'un non-membre statique des variables (car il n'a pas tout). L'Appel De Chiot.l'écorce() n'a aucun sens parce que la classe "Chiot" n'a pas un puppyName; chaque Chiot a son propre puppyName.

J'espère que cette aide. La programmation orientée objet est très puissant et il est important de comprendre les bases bien! Bonne chance.

OriginalL'auteur