请教一个java基本问题

Question

public class BaseSubDemo { /**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
Base base=new  Base();
Sub sub=new Sub(); }}
class Base{
public Base(){
System.out.println("Base init !");
}
}
class Sub extends Base{
public Sub(){
System.out.println("Sub init !");
}
}
程序执行后为什么会有打印两个Base init?当创建子类实例的时候,父类之前不是已经加载进来了吗,为什么还会打印一个Base init?求教.

Answer 1

是有2个的，你main（）是有两句，它会依次执行，第一个是Base base=new Base();打印的，而Sub sub=new Sub();是实例化Sub（）,但它又继承了 Base()，所以就拥有了 Base()的属性，在加上自己的属性，所以打印的结果就应是：
Base init !  
Sub init !所以，最终结果是Base init !
Base init !
Sub init !
是有2个

Answer 2

Base base=new Base()会打印一个Base init,我知道.Sub sub=new Sub(),创建Sub类实例的时候,因为继承自Base,所以会有Base的属性,我也知道.问题是Base类之前已经加载进来了,创建子类实例的时候,会先检查有木有直接父类,现在是有,但是创建父类实例的时候,父类加载了一次,然后创建子类实例的时候,父类应该不用加载第二次啊?郁闷...

Answer 3

只加载一次的是 static 修饰的new 一个类实例时会初始化父类一直到 Object。

Answer 4

这样不对的
执行Sub sub=new Sub();程序会重新调用Base的构造方法不会引用第一个的
BaseSubDemo中的实例根本无法在Base或者sub 中引用
即使能引用 好像也会再给你重新加载一边 这个我就不太清楚了

Answer 5

类应该只加载一次吧?
你说的类变量只加载一次,指的是类变量属于类,不管你new多少个实例,类变量只有一个,供大家共享.而成员变量不同,你new几个实例,每个实例就会有一个自己成员变量的副本.你是这个意思吧?
我仔细想想,这个题应该是创建子类实例的时候,因为子类构造器一定调用父类的构造器,所以会打印一个Base init,然后调用自己的构造器,所以打印Sub init,加上第一句new了一个Base的实例,会打印一个Base init,所以一共三.无论Base还是Sub类,都只加载一次.如你所说"new 一个类实例时会初始化父类一直到 Object",而构造器不就是用来初始化实例的么,子类又一定调父类的构造器,所以打印结果如此.和加载无关,考察的只是"子类一定调用父类构造器"这个知识点.
不知道我理解的对不对?

Answer 6

这里就是考察初始化过程，子类初始化过程中先看有没有基类，如果有的话就先初始化基类，然初始化子类，所有此时会打印两次Base init !

Answer 7

打印两次Base init !

Answer 8

Base base=new Base(); --实例化Base对象，在后台打印一次Base的构造方法；
Sub sub=new Sub();  --实例化Sub对象，因为继承了Base，所以它必须要继承调用父类的构造方法，因而要打印一下那句，然后再把自己的给打印出来…………

Answer 9

new Sub()的时候从Object开始，一直到他自身Sub，中间会经过 Base的构造方法，这是我刚才用调试器看的，具体为什么，我不知道

Answer 10

    首先执行"Base base=new Base()”，调用构造方法，实例化Base对象，打印构造方法里面的输出语句：Base int!，然后执行"Sub sub =new Sub()”,实例化Sub对象时，除了会继承父类Base的属性，输出Base int!,还会它自己的调用构造方法，输出：Sub int!

Answer 11

结果正常！LZ,整个执行过程是这样的：
main()方法里第一个为：
Base base=new Base();
System.out.println("Base init !");  
一条记录：Base init！
第二个：
Sub sub=new Sub();
注意它的类里会先默认调用super()[即先调用基类的构造方法];
所以是两条记录：Base init！ 和Sub init！
共计三条记录。
LZ 可以把super()加进去，试一下！

Answer 12

第一条打印是:
public Base(){
System.out.println("Base init !");
}
第二样打印是：
public Sub(){
super();/*调用父类的所有方法，所以这里会
打印出一个：Base init !
这个super();是隐藏的，写不写的都一样，
所以父类没有加载两次。
System.out.println("Sub init !");
}
***初学者，分析的不好请见谅***

Answer 13

public class BaseSubDemo {/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Base base=new Base();
base.getInfo();
Sub sub=new Sub();}}
class Base{public void getInfo(){System.out.println("Base init !");}}
class Sub extends Base{
public Sub(){
System.out.println("Sub init !");
}
}
这样 就只有一个了

Answer 14

//子类继承父类的属性，主要是这个方法是Base类的构造器 所以然,,,,,,,,,,,,,,,,,,,
public Base(){
    System.out.println("Base init !");
}

Answer 15

Base base=new Base();
Sub sub=new Sub();这两句都会println一下！

Answer 16

构造方法在对象被实例化时执行，程序会先检查它是否继承了某个类，如果存在父类继续检查其是否存在继承以此类推，最先执行的是父类的构造方法。你的main方法中首先Base base=new Base();这个类没有父类所以打印 Base init ! 。Sub sub=new Sub(); 这个实例化首先它继承了Base所以它会先打印
Base init !，再打印Sub init !。