Используя конструктор из суперкласса

Как вы говорите, конструктор C вызывает конструктор B, который вызывает конструктор A. Вы можете вызывать любые методы «A» для объекта C, и объект C может видеть неприкосновенные поля в A.

Даже если вы переопределите метод A «foo» в C, вы можете получить версию A с помощью «super.foo ()», при условии, что B также не отменяет его.

Вы должны вызвать конструктор некоторый в вашем непосредственном базовом классе. Это может быть

public class A {
     public A() { 
      .... 
     }
    public A(String foo) { 
      .... 
    }
}

public class B extends A {
    public B() {
        super();
        .. or ..
        super("ThisIsAB")
    }
}

public class C extends B {
    public C() {
      super();
      ....
   }
}

Таким образом, для конструкторов вы не можете ИЗБЕЖАТЬ создания промежуточных базовых классов, но вы можете выбрать, какой конструктор использовать. Если есть только конструктор без аргументов, он все обрабатывается за вас с помощью неявного вызова super. С несколькими конструкторами у вас есть еще несколько вариантов.

super может ссылаться на любую неприкосновенную переменную или метод в любом базовом классе. Таким образом, в этом отношении методы и переменные не то же самое, что конструкторы.

Называются конструкторы для всех родителей. Фактически, в глубине души C знает об A, потому что B расширяет A. Например, если класс A содержит метод foo (), тогда вы можете вызвать foo () из C.

Итак, из вашего примера C вызывает конструктор из B, который вызывает конструктор из A. Кроме того, A также расширяется из класса Object. Так что конструктор в классе Object также вызывается!

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

Насколько известно C, все, что не перезаписывается в C, содержится в B, даже если под прикрытием класс A находится там, где может быть реализация.

public class A {
   public A() {
   }

   public void aMethod() {
   }
}

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

public class C extends B {
   public C() {
     super();
   }

   public void doWork() {
     super.aMethod();
   }
}

Таким образом, в этом случае A обрабатывает реализацию aMethod (), даже если вызов super () в конструкторе C вызывает конструктор B напрямую, а не A.

Даже если вы мог избегаете вызова промежуточного ctor, вы бы этого не захотели, потому что это означало бы, что у вас есть неинициализированные части промежуточных классов, к которым может обращаться самый нижний производный класс. К ужасным эффектам.

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

class B extends A implements C {
    // ... implement C methods here
}

или с помощью агрегации

class B extends A {
    private C c;
}