package mianxiangduixiang;

public class gouZhaoOrExtend {

        public static void main(String[] args) {
                // TODO Auto-generated method stub
                        Zi zi = new Zi();
                      Zi  zi  = new Zi（9）；
        }

}
class Fu{
        int num ;
        Fu(){
                num=10;
                System.out.println("A fu run ");
               
        }
        Fu(int x){
                 System.out.println("B  fu run..."+x);
        }
}
class Zi extends Fu{
           int num ;
           Zi(){
                   System.out.println("C  zi   run.."+num);
           }
           Zi(int x){
                   super();
                   System.out.println("D  zi   run .."+x);
                  
           }
       
}

你这继承了，你还复写了，都是子类对象

a
c10
a
d9

你同一个对象定义了两次 这个错误你没看到吗

0小菜鸟0 发表于 2014-7-19 20:31
你同一个对象定义了两次 这个错误你没看到吗

到是编译过了，就是这样写，啥用图？

这是要搞哪样

继承后，首行默认有super吧，写不写一样，第二个子类构造，super里面传个参数，是不是就是你想要的了？

1. public class gouZhaoOrExtend
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Zi zi = new Zi();//Fu()-Zi()
   
6.                 Zi zi = new Zi(9);//Fu()-Zi(int x)
   
7.         }
   
8. }
   
9. class Fu
   
10. {
    
11.         int num ;
    
12.         Fu()
    
13.         {
    
14.                 num=10;
    
15.                 System.out.println("A fu run ");
    
16.         }
    
17.         Fu(int x)
    
18.         {
    
19.                 System.out.println("B  fu run..."+x);
    
20.         }
    
21. }
    
22. class Zi extends Fu
    
23. {
    
24.         int num ;
    
25.         Zi()
    
26.         {
    
27.                 //super()这里系统自动跳转到父类中的空参数构造函数
    
28.                 System.out.println("C  zi   run.."+num);
    
29.         }
    
30.         Zi(int x)
    
31.         {
    
32.                 super();//其实这里系统系统也会帮你自动加上
    
33.                 System.out.println("D  zi   run .."+x);
    
34.         }
    
35. }
    
36. //执行结果 A  C10  A  D9

复制代码

赵顺超 发表于 2014-7-19 20:36
到是编译过了，就是这样写，啥用图？

这能编译过 稀奇 我都没编译过去 你那个
   Zi zi = new Zi();
   Zi  zi = new Zi(9);
这个对象zi到底是一个还是两个

运行结果应该是：Zi zi = new Zi();这句代码结果是：A fu run    C zi  run10

0小菜鸟0 发表于 2014-7-19 21:17
这能编译过 稀奇 我都没编译过去 你那个
   Zi zi = new Zi();
   Zi  zi = new Zi(9);

同一个Zi  变量名指向了两个 实例对象！肯定错了！！！！有人说能编译通过？亲自测试过不了
应该是
Zi zi1=new Zi();
Zi zi2=new Zi(9);
子类构造函数默认会访问父类的 空参数构造函数
执行结果应该是：
A fu run
C zi run 0   ---------------此处fu类中给num赋值10，但是zi类中复写了该构造函数，子类没赋值，默认为0！
A fu run
D zi run 9

0小菜鸟0 发表于 2014-7-19 21:17
这能编译过 稀奇 我都没编译过去 你那个
   Zi zi = new Zi();
   Zi  zi = new Zi(9);

真过了，我也觉得过不了，但是我写了下，过了

yuli2039 发表于 2014-7-19 22:01
同一个Zi  变量名指向了两个 实例对象！肯定错了！！！！
应该是
Zi zi1=new Zi();

我写的z1  z2两个变量名，我就想知道结果是啥，就写了写

赵顺超 发表于 2014-7-19 22:57
我写的z1  z2两个变量名，我就想知道结果是啥，就写了写

确实 可以用这种方法可以体会构造过程顺序，

/*
在创建子类对象时，子类一定要访问父类中的构造函数，
因为父类中的数据子类可以直接获取，所以子类对象在建立时，
需要先查看父类是如何对这些数据进行初始化的，所以子类对
象在初始化时 ，要先访问一下父类中的构造函数
*/

public class gouZhaoOrExtend {

        public static void main(String[] args) {
                // TODO Auto-generated method stub
  //这里创建的空参数的子类对象，首先，子类构造函数中都有一个默认隐式super（）访问父类中的隐式构造函数
  //此时打印结果是  A  c10
                                                Zi zi = new Zi();
  //这里创建有参数的子类对象，首先，他会去选择有参数的子类构造函数，带参数的子类对象中第一行依旧有隐式suoer（）访问父类构造函数
  //此时打印结果：A    D9
                      Zi  zi  = new Zi（9）；
        }

}
class Fu{
        int num ;
        Fu(){
                num=10;
                System.out.println("A fu run ");
               
        }
        Fu(int x){
                 System.out.println("B  fu run..."+x);
        }
}
class Zi extends Fu{
           int num ;
           Zi(){
                   System.out.println("C  zi   run.."+num);
           }
           Zi(int x){
                   super();
                   System.out.println("D  zi   run .."+x);
                  
           }
        
}

光头强 发表于 2014-7-19 23:20
/*
在创建子类对象时，子类一定要访问父类中的构造函数，
因为父类中的数据子类可以直接获取，所以子类对象 ...

不好意思啊   第二个也是隐式super（），刚才打的太快打错了

0小菜鸟0 发表于 2014-7-19 21:17
这能编译过 稀奇 我都没编译过去 你那个
   Zi zi = new Zi();
   Zi  zi = new Zi(9);

哥们   分别运行  就是看  传值和不传值 有什么不同    对继承和super 的理解

第一个     A fu run  C  zi   run..0

第二个A fu run  D  zi   run ..9

光头强 发表于 2014-7-19 23:20
/*
在创建子类对象时，子类一定要访问父类中的构造函数，
因为父类中的数据子类可以直接获取，所以子类对象 ...

没传值时  A    C   0  不是9，他执行完super  后在拿自己的 num  =0