Java 什么是；扩展；真的吗？

我目前正在研究“类抽象”和“扩展”的概念，一直在想：
“如果我在抽象类中声明一个参数化构造函数，为什么在另一个类上的扩展不起作用，除非我用super关键字声明自己是调用抽象类构造函数参数的构造函数？”

我理解这样一个事实，即扩展将先前的抽象类实例化为扩展类，并尝试调用默认构造函数，但一直想知道为什么会出现错误

是因为构造函数已参数化，还是仅仅因为空构造函数不存在

扩展关键字是否按照以下方式调用某些内容

Object myClass = new AbstractClass();

缺少的参数是它给出错误的原因，所以沿着这条线的东西是正确的

Object myClass = new AbstractClass(int foo,float boo);

如果是这样的话，

super

关键字是否本质上就是，如果你允许我使用这个术语，“把”括号中给出的参数放在构造函数的“内部”

---

如果不是这样，我错在哪里？它实际上是如何工作的？

初始化对象时，始终会调用构造函数。即使您没有定义一个构造函数，也会有一个没有任何参数的默认构造函数。因此，如果在抽象类中定义构造函数，则必须使用

super（）

调用该构造函数

如果您没有定义任何构造函数，那么它将被隐式调用为默认构造函数

“如果我在抽象类中声明参数化构造函数，为什么 除非我宣布自己是老师，否则我不会再上另一堂课 使用super关键字调用 抽象类的构造函数？”

因为超类说它必须是使用声明的构造函数的构造函数，没有其他方法。这适用于每个扩展类-必须调用所需的构造函数

当您声明默认构造函数以外的其他构造函数时，任何类都会发生同样的情况。例如，拥有

public class A{
   //no default no-arg ctor here
   public A(String name){
       ....
   }

}

public class B{
  //default no-arg ctor will be created
}

那么

  B b=new B();
    A a=new A(); //// INVALID!
    A a=new A("foobar"); // yeah that is it

---

当您扩展类时，这同样适用。要构造子实例，必须首先调用

super.constructor

“内部创建父实例”。由于没有默认构造函数，因此必须使用任何显式声明的超构造函数。

在本上下文中，您应该将

extends

关键字看作是一个类是另一个类的子类，而不做其他事情。还有一些规则控制子类和超类应该如何工作

构造子类时，必须首先构造其超类。例如，要创建一只

鸟

，必须首先创建一只

动物

。这很有道理，不是吗？要在代码中演示这一点，请执行以下操作：

class Animal {
    public Animal() {
        System.out.println("Animal");
    }
}

class Bird extends Animal {
    public Bird() {
        System.out.println("Bird");
    }
}

执行

newbird（）

将首先打印

Animal

，然后打印

Bird

，因为

Animal

的构造函数先被调用，然后再被调用

Bird

构造函数。因此实际上，

Bird

构造函数隐式调用超类的构造函数。这可以写成：

public Bird() {
    super();
    System.out.println("Bird");
}

现在，如果超类没有无参数构造函数，会发生什么？假设

Animal

的构造函数现在将

字符串名

作为参数。您仍然需要首先调用超类的构造函数，但是

super（）

无法工作，因为

super（）

需要一个字符串参数

因此，编译器会给您一个错误。这可以通过使用参数调用

super（）

explicit来解决

如果我在抽象类中声明了一个参数化构造函数，为什么在另一个类上的扩展不起作用，除非我用super关键字声明自己是调用抽象类构造函数参数的构造函数

AbstractClass

中没有可用的默认构造函数，因为您定义了参数化构造函数。如果您不自己定义构造函数，则会隐式创建一个没有参数的默认构造函数。您现在可以手动添加这样的构造函数，或者您需要使用

super（）

的可用构造函数（参数化）

---

定义了无参数构造函数的代码示例：

---

使用参数调用

super（）

的代码示例：

---

如果你的类是抽象的，你就不能用

new

关键字来实例化它。你基本上得到了它。虽然它不是extends关键字，而是您的类是另一个类的子类。Extends关键字用于其他情况，但用于扩展类，在本例中，它不适用于您在这里讨论的所有事情。作为一个子类就可以做到。好吧，我明白了！谢谢！因此，使用extends，我告诉我的子类继承抽象类的属性、构造函数和方法？这对我来说似乎是一种很好的思考方式。从一个稍微不同的角度来看，您可以认为，当您用一个构造函数声明一个类

Foo

时，您“告诉”编译器这些参数对于

Foo

的任何实例的存在都是必不可少的。由于扩展

Foo

的类的实例基本上也是

Foo

的实例，因此扩展类的任何实例也必须需要相同的参数-尽管它们可以由扩展类提供，不一定是由创建该对象的人创建的。我不明白以下问题：

extends关键字调用的内容是否与此类似？

示例

object myClass=new AbstractClass（）。你能在这里再详细说明一下吗？
class AbstractClass {
    AbstractClass() {} // added manually since not created implicitly
    AbstractClass(int foo, float boo) {}
}
class RealClass extends AbstractClass {
    RealClass() { } // calls super() implicitly
}
AbstractClass myClass = new RealClass();

class RealClass extends AbstractClass {
    RealClass() {
        super(1, 2);
    }
}
class AbstractClass {
    AbstractClass(int foo, float boo) {}
}
AbstractClass myClass = new RealClass();