Наследование в Java - создание объекта подкласса вызывает также конструктора суперкласса. Почему точно?

Это не создает два объекта, только один: B.

При наследовании другому классу, Вы должны вызов супер () в Вашем конструкторе. Если Вы не сделаете, то компилятор вставит тот призыв к Вам, как можно явно видеть.

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

Ваш подкласс на самом деле похож на это после того, как компилятор вставит вызов super:

public class B extends A {
    public B() {
        super();
        System.out.println("Bye!");
    }
}

Создание B не создает дополнительный A.

, Но путем создания B, Вы создаете своего рода, потому что B А.

вызов Java/C++ конструктор для Вашего неявно. Почему? Дизайн языка. Но выполнение так прекрасно, потому что конструктор A мог бы содержать некоторые инициализации. И поскольку B использует все функции и ошибки A, эти функции лучше быть инициализированным правильно.

Конструктор класса является очень важным понятием в большей части ООП

Классы, путем обеспечения состояния и средств управлять тем состоянием, позволить более легкое обслуживание инвариантов. Роль конструкторов должна получить класс в состояние, которое соответствует тем инвариантам (или бросает таким образом запрещающее использование объекта invliad). это несколько более свободно, чем предназначенный на многих языках, так как конструктору разрешают передать его собственное 'эта' ссылка в другое место, но это, по крайней мере, находится под контролем класса (как таковой, это может знать, что находится в достаточно стабильном и допустимом состоянии для него, чтобы быть доступным для остальной части мира)

, Наследование делает этот комплекс, так как B - в очень реальном смысле и таким образом может вызвать любой из методов, предоставленных A. Части B, которые являются A, должны поэтому получить свой шанс инициализировать себя, прежде чем B вложит взгляд, таким образом конструктора для A вызывают, прежде чем реальная работа конструктора B начинается.

Конструктор содержит всю инициализацию для A. Вы не создаете два объекта. Вы создаете один объект, затем выполняя инициализатор для суперкласса для инициализации его участников, и затем выполняя инициализатор для происходящего класса для инициализации его участников.

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

Это не создает два объекта, это просто создает один объект b. b, имеет тип B и типа A. Конструктор в основном говорит, вот то, что необходимо сделать для построения меня. Таким образом, при создании нового "B" экземпляра Вы создаете объект, который является оба B () и (). Вообразите следующий сценарий:

class Q {
  int i;
  public Q() {
    // set default value
    i= 99;
  }
}

class Z extends Q {
  public Z() {
  }
}

, Если бы конструктора для Q НЕ вызвали, как я получил бы его значение по умолчанию?

Это сделано, потому что конструктор используется для инициализации объекта. Так как B является также A, он вызывает конструктора для первого, затем конструктора для B.

Как примечание стороны, можно использовать super(arg1, etc) для выбора, какого конструктора A вызывают на основе параметра, вводит Вас передача..., но это должна быть первая строка в конструкторе.

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

Кроме того, думают о том, что произошло бы, если Вы разделяете на подклассы, зависел от некоторого внутреннего состояния базового класса. Разве Вы не хотели бы, чтобы экземпляр базового класса был инициализирован затем?

Это не создает 2 объекта, это только создает один экземпляр B. Причина конструктор суперкласса вызывается, состоит в том, потому что, как Вы сказал, B имеет все поля A, и эти поля должны быть инициализированы.

Только один объект создается, оба подрядчика работают на том же объекте.

причина проста, поскольку Вы знаете, что B имеет все переменные и методы A, поэтому если некоторая переменная потребности, инициализирующие так методы A, могут работать, кто-то должен инициализировать его - и что кто-то - конструктор A.

, например:

public class A {
     public A() {
        x = 1;
     }
     private int x;
     public int getX() {
        return x;
     }
}


public class B extends A {
     public B() {
     }

     public static void main(String[] args) {
         B b = new B();
         System.out.println(b.getX()); // should print 1 
     }
}