Конструкторы Java

Я пытаюсь узнать, как указать конструкторы классов в Java. Я начинаю понимать, что они определяют типы переменных экземпляра объектов, созданных из этого класса. Их также можно использовать для установки начальных значений переменных экземпляра. Следующий пример взят из руководства по Java на веб-сайте Sun:

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

Где в исходном коде ваших классов следует разместить конструктор (ы)?

Являются ли эти аргументы именами переменных ?: (int startCadence, int startSpeed, int startGear) или являются именами переменных gear, cadence и speed?

В чем разница между (int startCadence, int startSpeed, int startGear) и передачей, каденцией и скоростью?

В том маловероятном случае, если мой преподаватель или какой-либо администратор из Общественного колледжа Солт-Лейк-Сити когда-либо столкнется с этим вопросом, позвольте мне прояснить свои намерения. Этот вопрос задан в духе высшей академической честности. Я задаю этот вопрос, чтобы получить общий совет и помочь понять, как правильно использовать язык программирования Java. Я никоим образом не использую чужие работы и не представляю их как свои собственные. Я использую ответы, представленные здесь, как общую помощь в моем понимании. Я делаю всю свою работу и не копирую работы, предоставленные людьми, отвечающими на мой вопрос.

Ответов (10)

Решение

Конструкторы могут появляться в любом месте кода класса. Однако по соглашению большинство людей ставят их перед любыми другими функциями, не являющимися конструкторами.

Что касается имен переменных, все 6 на самом деле являются именами переменных, но область видимости различается. Те, которые указаны в качестве параметров конструктора (startCadence, startSpeed, startGear), доступны только внутри конструктора. Остальные 3 (передача, частота вращения педалей, скорость), вероятно, являются общеклассовыми переменными, доступными для всех методов. Однако определение не отображается в вашем фрагменте кода. Полный класс будет выглядеть примерно так:

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

Надеюсь, это поможет!

Где в исходном коде ваших классов следует разместить конструктор (ы)?

Я использую следующее:

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
 }

Но они могут пойти куда угодно. Я чувствую, что тебе лучше расставить все по порядку. Например, я предпочитаю общедоступные методы перед частными (поэтому, если я ищу конкретный общедоступный метод, я знаю, что он находится в верхней части файла). По той же причине я обычно помещаю конструктор вверху.

Являются ли эти аргументы именами переменных ?:

Не обязательно, можете называть их как хотите. Я обычно использую то же имя.

... или шестеренка, частота вращения педалей и скорость - это имена переменных? ...

Это имена переменных экземпляра

В чем разница между (int startCadence, int startSpeed, int startGear) и передачей, каденсом и скоростью?

Первые - это имена параметров для конструктора, а первые - имена атрибутов самого объекта.

Возьмите этот другой образец:

 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"         


     } 
 }

Как видите, когда вы передаете значение конструктору, вы используете аргумент, и когда вы видите код конструктора, вы видите имя параметра (который получает этот аргумент), а затем оно присваивается атрибуту экземпляра.

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

Эти (int startCadence, int startSpeed, int startGear) параметры являются аргументами конструкторы , и они будут устанавливать поля для велосипеда cadence, speed и gear . Они доступны только в конструкторе. gear, cadence и speed - переменные экземпляра, уникальные для каждого экземпляра Bicycle и на которые можно ссылаться из других методов. Аргументы конструктора позволяют указать параметры для инициализации объекта. В этом примере вы можете создать объект Bicycle с передачей 1, каденсом 0 и скоростью 0 следующим образом:

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

Или вы можете создать движущийся велосипед с частотой вращения педалей 60 об / мин и скоростью 10 миль в час на 3-й передаче, например:

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

Размещение конструктора не имеет значения, но обычно конструкторы размещаются в начале определения класса.

  1. Это полностью зависит от вас. Обычно я начинаю со всех переменных, затем конструкторов, затем методов, но это просто личные предпочтения.
  2. Имена аргументов не имеют значения, если вы не называете их так же, как ваши переменные. В этом примере gear, cadenceи speedявляются переменными.
  3. Вы (или кто-то) передаете конструктору три ints. Имена ( startCadence, startSpeedи startGearназываются формальными параметрами , и они, как вы можете определить аргументы см. http://en.wikipedia.org/wiki/Parameter_(computer_science) .
    gear, cadenceИ speedопределены где - нибудь еще в Класс. Любой метод в классе может ссылаться на них.

Не волнуйтесь - если вы будете работать над этим, такие вещи очень скоро станут вашей второй натурой.

О, и могу я предложить вам хорошую IDE? Предполагается, что BlueJ подойдет новичкам, а NetBeans и Eclipse - для более опытных программистов. Выделение исходного кода может быть бесценным.

Основное различие между int startCadence и cadence не в переменных, а в их области действия. Если переменная определена внутри метода, например конструктор, она будет существовать только внутри этого метода, но не снаружи. Если переменная определена в классе, она будет существовать везде в этом классе, такая переменная имеет глобальную область видимости. Переменная startCadence будет существовать только внутри конструктора, поэтому, если вы хотите использовать ее значение в другом месте, вы можете передать ее другой переменной с глобальной областью видимости. Вот что здесь происходит: cadence = startCadence;

Я обычно помещаю свои конструкторы в верхнюю часть моего файла после разделов package, import, Javadoc и статических переменных / переменных экземпляра.

gear, cadence и speed - это переменные класса, предположительно определенные где-то вне конструктора. startCadence, startSpeed ​​и startGear также являются переменными, но являются параметрами, передаваемыми конструктору.

Вы также можете увидеть что-то вроде этого:

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

который устанавливает переменные класса из одноименных параметров.

gear, cadence и speed - это переменные-члены класса (объявленные в другом месте), а startCadence, startSpeed ​​и startGear - параметры функций.

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;

    }
}

Фактически, аргументы конструктора не обязательно должны храниться как переменные-члены объекта. Вот пример:

class NumberAsString {

   private String numAsStr;

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

}

В этом примере аргумент конструктора фактически нигде не хранится, но его значение необходимо для вычисления одного или нескольких значений переменных-членов.

Поведение, которое вы видели, когда все аргументы хранятся непосредственно как переменные-члены, довольно распространено. Особенно для определенных типов классов, которые просто предоставляют методы «получения» и «установки» для своих переменных-членов (без предоставления каких-либо функций вычисления или преобразования). В мире Java такие классы обычно называют «beans». (Что, да, очень глупое имя.)

1) Расположение конструктора не имеет ни малейшего значения. Однако, следуя условию, я бы лично поместил его следующим образом:

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) передача, частота вращения педалей и скорость являются переменными-членами класса; они принадлежат каждому велосипеду и являются разными переменными для каждого велосипеда. Однако startCadence, startSpeed ​​и startGear являются локальными переменными, которые принадлежат только этой функции. Когда я призываю

new Bicycle(10, 15, 5);

Для startCadence установлено значение 10, для startSpeed ​​установлено значение 15, а для startGear установлено значение 5. Затем конструктор инициализирует переменные-члены их «начальными» соответствующими переменными.