web-dev-qa-db-fra.com

Java Constructeurs

J'essaie d'apprendre à spécifier les constructeurs de classe en Java. Je commence à comprendre qu'ils spécifient les types de variables d'instance d'objets fabriqués à partir de cette classe. Ils peuvent également être utilisés pour définir les valeurs initiales de la variable d'instance. L'exemple suivant provient du tutoriel Java sur le site Web de Sun:

public Bicycle(int startCadence, int startSpeed, int startGear) {
    gear = startGear;
    cadence = startCadence;
    speed = startSpeed;
}

À quel endroit du code source de vos classes devez-vous placer le ou les constructeurs?

Ces arguments sont-ils les noms des variables?: (Int startCadence, int startSpeed, int startGear) ou gear, cadence et speed sont-ils les noms des variables?

Quelle est la différence entre (int startCadence, int startSpeed, int startGear) et la vitesse, la cadence et la vitesse?

Dans le cas peu probable où mon instructeur ou tout administrateur du Salt Lake Community College tomberait sur cette question, permettez-moi de préciser mes intentions. Cette question est publiée dans le plus grand esprit d'honnêteté académique. Je pose cette question pour obtenir des conseils généraux et de l'aide pour comprendre la bonne façon d'utiliser le langage de programmation Java. Je n'utilise en aucun cas le travail des autres et le représente comme mon propre travail. J'utilise les réponses fournies ici comme une aide générale à ma compréhension. Je fais tout mon propre travail et ne copie pas le travail fourni par des personnes répondant à ma question.

javaconstructor
28
Patrick Cassell

Les constructeurs peuvent apparaître n'importe où dans le code de la classe. Cependant, par convention, la plupart des gens les mettent avant toutes autres fonctions qui ne sont pas des constructeurs.

Quant aux noms de variables, les 6 sont en fait des noms de variables, mais la portée est différente. Ceux spécifiés en tant que paramètres au constructeur (startCadence, startSpeed, startGear) ne sont disponibles que dans le constructeur. Les 3 autres (vitesse, cadence, vitesse) sont probablement des variables à l'échelle de la classe, disponibles pour toutes les méthodes. Cependant, la définition n'est pas affichée dans votre extrait de code. La classe complète ressemblerait à mroe:

class Bicycle
{
    // class-level variables
    private int gear;
    private int cadence;
    private int speed;

    // constructor
    public Bicycle(int startCadence, int startSpeed, int startGear) {
        gear = startGear;
        cadence = startCadence;
        speed = startSpeed;
    }

    // another method (not a constructor)
    public void ShiftUp() {
        gear = gear + 1; // notice the 'gear' variable is available here too.
    }
}

J'espère que cela pourra aider!

35
CodingWithSpike

gear, cadence et speed sont des variables membres de la classe (déclarées ailleurs) et startCadence, startSpeed ​​et startGear sont des paramètres de fonction.

class Bicycle
{
    private int gear, cadence, speed;

    public Bicycle(int startCadence, int startSpeed, int startGear)
    {
        // set the value of member variables from passed parameters
        gear = startGear;
        cadence = startCadence;
        speed = startSpeed;

    }
}
6
basszero

Où dans votre code source de classes devriez-vous mettre le constructeur (s)?

J'utilise ce qui suit:

package statement ....
import statements....


public class MyClass { 
     // instance attributes
     private int i;

     // class attribute 
     private static int MAX;

     // static methods 
     public static int getClassCount() { 
     }

     // Constructor!! 
     public MyClass() {  // constructor.
     }

     // public methods 
     // protected methods
     // private methods 

     // public static void main
 }

Mais ils peuvent aller n'importe où. Je pense qu'il vaut mieux mettre les choses par ordre de visibilité. Par exemple, j'ai plutôt les méthodes publiques avant les méthodes privées (donc si je recherche une méthode publique spécifique, je sais qu'elle est en haut du fichier) Pour la même raison, je place généralement le constructeur en haut.

Ces arguments sont-ils les noms des variables?:

Pas nécessaire, vous pouvez les nommer comme vous le souhaitez. J'utilise habituellement le même nom.

... ou la vitesse, la cadence et la vitesse sont-elles les noms des variables? ...

Ce sont les noms de variables instance

Quelle est la différence entre (int startCadence, int startSpeed, int startGear) et la vitesse, la cadence et la vitesse?

Les premiers sont les noms des paramètres du constructeur et les premiers sont les noms des attributs de l'objet lui-même.

Prenez cet autre échantillon:

 public class Person { 
     private String name; // a person has a name.

     public Person( String nameParameter ) {  
        this.name = nameParameter;
     }
     public String toString() { 
         return "My name is : " + this.name;
     }

     public static void main( String [] args )  { 

          // creates a new "instance" and assign "Patrick" as its name.
         Person one = new Person("Patrick");
         System.out.println( one ); // prints "My name is: Patrick"

         // each person have its own name. 
         Person two = new Person("Oscar");
         System.out.println( two ); // prints "My name is: Oscar"         


     } 
 }

Comme vous le voyez, lorsque vous transmettez une valeur au constructeur, vous utilisez un argument, et lorsque vous voyez le code du constructeur, vous voyez le nom du paramètre (qui reçoit cet argument), puis il est attribué à l'attribut d'instance.

5
OscarRyz
  1. Cela dépend entièrement de vous. Je commence généralement par toutes les variables, puis les constructeurs, puis les méthodes, mais c'est juste une préférence personnelle.
  2. Les noms des arguments sont complètement hors de propos, tant que vous ne les nommez pas la même chose que vos variables. Dans cet exemple, gear, cadence et speed sont les variables.
  3. Vous passez (ou quelqu'un passe) trois ints au constructeur. Les noms (startCadence, startSpeed et startGear sont appelés les paramètres formels , et ils sont la façon dont vous pouvez identifier les arguments. Voir http://en.wikipedia.org/wiki/Parameter_ (computer_science) .
    gear, cadence et speed sont définis ailleurs dans la classe. Toute méthode de la classe peut s'y référer.

Ne vous inquiétez pas - si vous y travaillez, ce genre de chose sera bientôt une seconde nature.

Oh, et puis-je suggérer que vous obteniez un bon IDE? BlueJ est censé être bon pour les débutants, et NetBeans et Eclipse pour les programmeurs plus expérimentés. La mise en évidence du code source peut être inestimable.

3
Michael Myers

Je place généralement mes constructeurs vers le haut de mon fichier, après les sections de déclaration de variable de package, d'importation, de Javadoc et de variable statique/instance.

vitesse, cadence et vitesse sont les variables de classe, probablement définies quelque part en dehors du constructeur. startCadence, startSpeed ​​et startGear sont également des variables, mais ce sont les paramètres passés au constructeur.

Vous pouvez également voir quelque chose comme ceci:

public Bicycle(int cadence, int speed, int gear) {
    this.gear = gear;
    this.cadence = cadence;
    this.speed = speed;
}

qui définit les variables de classe à partir des paramètres du même nom.

3
Powerlord

Vous avez vraiment besoin d'une copie de Head First Java

1
Fortyrunner

1) L'emplacement du constructeur n'a aucune importance. Par convention, cependant, je voudrais personnellement le placer comme suit:

public class Bicycle {

    public int gear, cadence speed;

    public Bicycle(int startCadence, int startSpeed, int startGear) {
        gear = startGear;
        cadence = startCadence;
        speed = startSpeed;
    }

    public void otherFunction1() {}
    public void otherFunction2() {}
    public void otherFunction3() {}

}

2) l'engrenage, la cadence et la vitesse sont des variables membres de la classe; ils appartiennent à chaque vélo et sont des variables différentes pour chaque vélo. startCadence, startSpeed ​​et startGear, cependant, sont des variables locales, qui n'appartiennent qu'à cette fonction. Quand j'appelle un

new Bicycle(10, 15, 5);

startCadence est défini sur 10, startSpeed ​​est défini sur 15 et startGear est défini sur 5. Ensuite, le constructeur initialise les variables membres à leurs variables correspondantes "start".

0
Allan S

En fait, les arguments d'un constructeur n'ont pas à être stockés en tant que variables membres de l'objet. Voici un exemple:

class NumberAsString {

   private String numAsStr;

   public NumberAsString(double number) {
      this.numAsStr = Double.toString(number);
   }

}

Dans cet exemple, l'argument constructeur n'est en fait stocké nulle part, mais sa valeur est nécessaire pour le calcul d'une ou plusieurs valeurs de variable membre.

Le comportement que vous avez vu, où tous les arguments sont stockés directement en tant que variables membres, est assez courant. Surtout pour certains types de classes qui fournissent simplement des méthodes "getter" et "setter" pour leurs variables membres (sans offrir de fonctions de calcul ou de transformation). Dans le monde Java Java, ces types de classes sont communément appelés "beans". (Ce qui, oui, est un nom très stupide.)

0
benjismith

La différence fondamentale entre int startCadence et cadence n'est pas dans les variables, mais dans leur portée. Si une variable est définie à l'intérieur d'une méthode, comme un constructeur, elle n'existera qu'à l'intérieur de cette méthode, mais pas à l'extérieur. Si une variable est définie dans une classe, elle existera partout dans cette classe, une telle variable a une portée globale. La variable startCadence n'existera qu'à l'intérieur du constructeur, donc si vous voulez utiliser sa valeur ailleurs, vous pouvez la passer à une autre variable avec une portée globale. C'est ce qui se passe ici: cadence = startCadence;

0
Berend Vervelde

Le (int startCadence, int startSpeed, int startGear) Les paramètres sont les arguments du constructeur et ils définissent les champs Bicycle cadence, speed et gear. Ils sont disponibles uniquement dans le constructeur. gear, cadence et speed sont des variables d'instance uniques pour chaque instance Bicycle et pouvant être référencées à partir d'autres méthodes. Les arguments du constructeur vous permettent de fournir des paramètres pour l'initialisation d'un objet. Dans cet exemple, vous pouvez créer un objet Bicycle avec un engrenage de 1, une cadence de 0 et une vitesse de 0 comme ceci:

Bicycle bike = new Bicycle(0, 0, 1);

Ou vous pouvez créer un vélo en mouvement où la cadence est de 60 tr/min et la vitesse est de 10 mph, en 3e vitesse comme suit:

Bicycle bike = new Bicycle(60, 10, 3);

Le placement du constructeur n'est pas pertinent mais généralement les constructeurs sont placés au début de la définition de classe.

0
bouncing_elephant