Constructores de Java

Estoy tratando de aprender cómo especificar constructores de clase en Java. Estoy empezando a comprender que especifican los tipos de variables de instancia de los objetos elaborados a partir de esa clase. También se pueden usar para establecer los valores iniciales de la variable de instancia. El siguiente ejemplo es del tutorial de Java en el sitio web de Sun:

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

¿En qué parte del código fuente de tu clase deberías poner el constructor (es)?

¿Son estos argumentos los nombres de las variables ?: (int startCadence, int startSpeed, int startGear) o son gear, cadence y speed los nombres de las variables?

¿Cuál es la diferencia entre (int startCadence, int startSpeed, int startGear) y gear, cadence y speed?

En el caso improbable de que mi instructor o cualquier administrador de Salt Lake Community College alguna vez se encuentre con esta pregunta, permítanme aclarar mis intenciones. Esta pregunta se publica con el mayor espíritu de honestidad académica. Hago esta pregunta para buscar consejos generales y ayuda para comprender la forma correcta de usar el lenguaje de progtwigción Java. De ninguna manera utilizo el trabajo de otros y lo represento como mi propio trabajo. Utilizo las respuestas proporcionadas aquí como una ayuda general en mi comprensión. Hago todo mi trabajo y no copio el trabajo proporcionado por personas que responden mi pregunta.

Los constructores pueden aparecer en cualquier parte del código de la clase. Sin embargo, por convención, la mayoría de la gente los pone antes de cualquier otra función que no sea constructora.

En cuanto a los nombres de las variables, los 6 son en realidad nombres de variables, pero el scope es differnet. Los que se especifican como parámetros para el constructor (startCadence, startSpeed, startGear) solo están disponibles dentro del constructor. Los otros 3 (engranaje, cadencia, velocidad) son probablemente variables de toda la clase, disponibles para todos los métodos. Sin embargo, la definición no se muestra en su fragmento de código. La clase completa se vería así:

 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. } } 

¡Espero que ayude!

engranaje, cadencia y velocidad son variables miembro de la clase (declaradas en otro lugar) y startCadence, startSpeed ​​y startGear son parámetros de función.

 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; } } 

¿En qué parte del código fuente de tu clase deberías poner el constructor (es)?

Yo uso lo siguiente:

 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 } 

Pero pueden ir a cualquier lado. Siento que es mejor poner las cosas en orden de visibilidad. Por ejemplo, prefiero tener los métodos públicos antes que los métodos privados (por lo que si estoy buscando un método público específico, sé que está en la parte superior del archivo) Por la misma razón, suelo poner el constructor en la parte superior.

¿Son estos argumentos los nombres de las variables ?:

No es necesario, puedes nombrarlos como quieras. Usualmente uso el mismo nombre.

… o son engranaje, cadencia y velocidad los nombres de las variables?

Son los nombres de las variables de instancia

¿Cuál es la diferencia entre (int startCadence, int startSpeed, int startGear) y gear, cadence y speed?

Los primeros son los nombres de los parámetros para el constructor y los primeros son los nombres de los atributos del objeto en sí mismo.

Toma esta otra muestra:

  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" } } 

Como puede ver, cuando le pasa un valor al constructor está utilizando un argumento, y cuando ve el código del constructor, ve el nombre del parámetro (que recibe ese argumento) y luego se lo asigna al atributo de la instancia.

Generalmente pongo mis constructores cerca de la parte superior de mi archivo, después de las secciones de paquete, importación, Javadoc y statement de variable estática / de instancia.

engranaje, cadencia y velocidad son las variables de clase, presumiblemente definidas fuera del constructor en alguna parte. startCadence, startSpeed ​​y startGear también son variables, pero son los parámetros que se pasan al constructor.

También puede ver algo como esto:

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

que establece las variables de clase a partir de los parámetros del mismo nombre.

  1. Depende totalmente de usted. Normalmente comienzo con todas las variables, luego con los constructores, luego con los métodos, pero es solo una preferencia personal.
  2. Los nombres de los argumentos son completamente irrelevantes, siempre y cuando no los nombre de la misma manera que sus variables. En este ejemplo, gear , cadence y speed son las variables.
  3. Estás (o alguien está) pasando tres ints al constructor. Los nombres ( startCadence , startSpeed y startGear se llaman parámetros formales , y son la forma en que puede identificar los argumentos. Consulte http://en.wikipedia.org/wiki/Parameter_(computer_science) .
    gear , cadence y speed se definen en otro lugar de la clase. Cualquier método en la clase puede referirse a ellos.

No te preocupes, si trabajas en ello, este tipo de cosas serán muy naturales muy pronto.

Ah, y ¿puedo sugerir que obtengas un buen IDE? Se supone que BlueJ es bueno para los principiantes, y NetBeans y Eclipse para los progtwigdores más experimentados. El resaltado del código fuente puede ser invaluable.

Realmente necesitas una copia de Head First Java

En realidad, los argumentos para un constructor no tienen que almacenarse como las variables de miembro del objeto. Aquí hay un ejemplo:

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

En este ejemplo, el argumento constructor no se almacena en realidad en ningún lugar, pero su valor es necesario para el cálculo de uno o más valores de variables miembro.

El comportamiento que ha visto, donde todos los argumentos se almacenan directamente como variables miembro, es bastante común. Especialmente para ciertos tipos de clases que simplemente proporcionan métodos “getter” y “setter” para sus variables miembro (sin ofrecer funciones de cálculo o transformación). En el mundo de Java, este tipo de clases se conocen comúnmente como “beans”. (Lo cual, sí, es un nombre muy estúpido)

La diferencia básica entre int startCadence y cadence no está en las variables, sino en su scope. Si una variable se define dentro de un método, como un constructor, solo existirá dentro de este método, pero no en el exterior. Si una variable se define en una clase, existirá en todas partes de esa clase, tal variable tiene un scope global. La variable startCadence solo existirá dentro del constructor, por lo que si desea usar su valor en otro lugar, puede pasarlo a otra variable con un scope global. Esto es lo que sucede aquí: cadence = startCadence;

1) La ubicación del constructor no importa en lo más mínimo. Sin embargo, por convención, personalmente lo ubicaría de la siguiente manera:

 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) engranaje, cadencia y velocidad son variables miembro de la clase; pertenecen a cada bicicleta, y son variables diferentes para cada bicicleta. startCadence, startSpeed ​​y startGear, sin embargo, son variables locales, que solo pertenecen a esa función. Cuando llamo por un

 new Bicycle(10, 15, 5); 

startCadence se establece en 10, startSpeed ​​se establece en 15 y startGear se establece en 5. Luego, el constructor inicializa las variables de los miembros a sus variables correspondientes de “inicio”.

Los (int startCadence, int startSpeed, int startGear) son los argumentos del constructor y configuran la cadence , speed y speed campos de bicicleta. Están disponibles solo dentro del constructor. gear , cadence y speed son variables de instancia únicas para cada instancia de Bicycle y referenciables desde otros métodos. Los argumentos del constructor le permiten proporcionar parámetros para la inicialización de un objeto. En este ejemplo, puede crear un objeto Bicycle con un engranaje de 1, cadencia de 0 y una velocidad de 0 similar a este:

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

O puede crear una bicicleta en movimiento donde la cadencia es de 60 rpm, y la velocidad es de 10 mph, en la 3ª marcha, así:

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

La ubicación del constructor es irrelevante, pero generalmente los constructores se colocan al principio de la definición de la clase.

 public class Account { private static final Exception InsufficientFundsException = null; private int accountNumber; private double availableBalance; private int pin; public Account(int account, int pin,double amount ) { this.accountNumber = account; this.pin = pin; this.availableBalance = amount; } public void credit(double amount) { this.availableBalance= this.availableBalance+amount; } public void debit(double amount) throws Exception { if(this.availableBalance>=amount) { this.availableBalance= this.availableBalance-amount; } else { throw new InsufficientFundsException(); } } public int getAccountNumber() { return accountNumber; } public double getAvailableBalance() { return availableBalance; } public String toString() { return "Account="+accountNumber+"pin="+pin+"balance"+availableBalance; } public boolean validatePIN(int pin) { if(this.pin==pin) return true; else return false; } }