这段关于多态性的代码怎么理解?

Question

public class Foo
{
    public void show()
    {
    }    public Foo()
    {
        show();
    }    public static void main(String[] args)
    {
        new SubFoo();
    }
}
class SubFoo extends Foo
{
    private int i = 20;
    
    public SubFoo()
    {
    }    public void show()
    {
        System.out.println("i = " + i);
    }
}
打印: i = 0刚接触Java, 满头雾水: 执行new时, 先调用Foo的构造方法, 进而调用show(). 这时SubFoo的构造方法还没有被执行, 没有SubFoo实例生成, 能执行SubFoo的show()吗? 就算能执行, 在没有实例化SubFoo之前是不是不会被初始化为20, SubFoo的i是什么时候被初始化为20的? 未必初始化时i指向哪里(内存地址)? 为什么不是个随机值?

Answer 1

public class products {
    int id;
     int number;
     String name;
     String type;
     
     
   // 设置构造函数
   products(int id,int number,String name,String type){
      this.id=id;           // this指向当前对象本身
      this.number=number;
      this.name=name;
      this.type=type;
 }
   public static void main(String[] args) {
    defective de=new defective(12,1,"电脑","次品","2005-2-1","电源坏了");
                System.out.println(de.getDetails());      }
   
   
  public String getDetails(){
       return "id:"+id+"\nNumber:"+number+"\nName:"+name+"\nType:"+type;
  }
}
   
  
  // 定义product子类wastrel
    class wastrel extends products{ 
        String Date;
        String foundDate;
        wastrel(int id,int number,String name,String type,String Date,String foundDate){
        super(id,number,name,type);   // super调用product父类的构造方法
        this.Date=Date;
        this.foundDate=foundDate;
        }     
    
    public String toString(){
        
        return super.getDetails()+"\nDate:"+Date+"\nFoundDate:"+foundDate;
    }// super调用父类product的成员方法
    
}
    // 定义products子类defective
    class defective extends products{
        String Date;
        String unqualified;
        defective(int id,int number,String name,String type,String Date,String unqualified){
            super(id,number,type,name);    
            this.Date=Date;
            this.unqualified=unqualified;
            }
        
        public String toString(){
               return super.getDetails()+"\nDate:"+Date+"\nUnqualified:"+unqualified;
               
        }
    }

Answer 2

public class Foo {
public void show() {
System.out.println("Foo.show()");
} public Foo() {
show();
} public static void main(String[] args) {
new SubFoo();
}
}class SubFoo extends Foo {
private int i = 20; public SubFoo() {
} public void show() {
System.out.println("SubFoo.show()");
System.out.println("i = " + i);
}
}打印
SubFoo.show()
i = 0
可见可以调用SubFoo.show()，但这时i还没有赋值，所以打出int的默认值0；

Answer 3

在这个程序的执行过程中：
1，先是找静态变量，你这里边没有
2，然后是初始化父类的普通变量，你这里边还没有，
3，再然后是执行父类构造函数，这个可以有，你这里边确实有。
这时问题来了，你重写了父类的show（）,程序开始执行你子类里的show(),但是这时，i初始化的语句还未执行，所以系统自动给你的i赋个值：0,打印出i=0;程序继续执行，
4，父类的构造函数执行完了,开始执行子类的普通变量初始化，此时，i才变成20
5，然后开始执行子类的构造函数，如果你在子类的构造里打印i值，就会打印20了。对这块不熟，以上仅供参考.