Java中的对象初始值设定项和构造函数有什么区别？

Question

正如我研究过的那样，构造函数用于创建类对象和初始化实例字段。但是在抽象类中，当子类继承抽象类并创建子类的对象时也会创建构造函数。根据抽象类的定义，我们无法创建因此，如何在不创建抽象类对象的情况下调用抽象类的构造函数。

Answer 1

创建子类时，您必须调用超类构造函数。

Answer 2

I'm not sure how well this answers your question, but in my experience I've only used abstract constructors to call a super() in the subclass constructors. I can't say Parent x = new Parent(); but I can say Parent y = new Child() where the first line of Child() is super(); , essentially calling Parent(); .

Answer 3

We can not create the object of abstract class but we can create the constructor of abstract class and we can call it in sub class using super()

abstract class abc{
  abc(){}

}
class Test extends abc{
super();
}

A contructor intialize the instance of the fields and give them default values if they dont have any value at the time of intialization

class A{
  int b;
}
A a = new A();
System.out.println("value of b "+b);

answer is : value of b 0

the constructor intialize the fileds with default values

Answer 4

By using super() you can call constructor of abstract class from its sub class. For eg. your abstract class have fields a and b and you want to initialize those so this can be done from its sub class by using abstract class constructor and super() .

Answer 5

I think the best answer is in the first comment. You don't actually use the constructor in this case to instantiate the abstract class but to initialize its state and the invariants. Let's say you were allowed to create a subclass without calling super(...), there would be cases where you'd have a partially constructed object

public abstract class AbstractMe {
    protected List<Object> objects;
    protected AbstractMe() { 
         objects = new ArrayList<>();
    }
    protected int elements() { return objects.size(); }
}

If you call super elements will always work fine, but if you were allowed not to call it it could be a NPE even if your invariant is that there always is a list in your class.