1. package cn.up.demo5;
   
2. 
   
3. public class Employee {
   
4.        
   
5.         private String name;
   
6.         private String job_number;
   
7.         private double salary;
   
8.         public String getName() {
   
9.                 return name;
   
10.         }
    
11.         public void setName(String name) {
    
12.                 this.name = name;
    
13.         }
    
14.         public String getJob_number() {
    
15.                 return job_number;
    
16.         }
    
17.         public void setJob_number(String jobNumber) {
    
18.                 job_number = jobNumber;
    
19.         }
    
20.         public double getSalary() {
    
21.                 return salary;
    
22.         }
    
23.         public void setSalary(double salary) {
    
24.                 this.salary = salary;
    
25.         }
    
26.        
    
27.        
    
28. }
    
29. 
    
30. 
    
31. 
    
32. package cn.up.demo5;
    
33. 
    
34. public class Manager extends Employee {
    
35.        
    
36.         private String bonus;
    
37. 
    
38.         public String getBonus() {
    
39.                 return bonus;
    
40.         }
    
41. 
    
42.         public void setBonus(String bonus) {
    
43.                 this.bonus = bonus;
    
44.         }
    
45.        
    
46.        
    
47. 
    
48. }
    
49. 
    
50. 
    
51. 
    
52. 
    
53. package cn.up.demo5;
    
54. 
    
55. public class Test {
    
56. 
    
57.         /**
    
58.          * @param args
    
59.          */
    
60.         public static void main(String[] args) {
    
61.                
    
62.                
    
63.                 Manager m = new Manager();
    
64.                 m.setBonus("666");
    
65.                 m.setJob_number("110");
    
66.                 m.setName("zma");
    
67.                 m.setSalary(10000);
    
68.                
    
69.                
    
70.                 System.out.println(m.getBonus());
    
71.                 System.out.println(m.getJob_number());
    
72.                 System.out.println(m.getName());
    
73.                 System.out.println(m.getSalary());
    
74. 
    
75.         }
    
76. 
    
77. }
    
78. 
    
79. 
    
80. 
    
81. 程序运行结果：
    
82. 666
    
83. 110
    
84. zma
    
85. 10000.0

复制代码

子类对象中必有一个父类对象，想必大家会说你疯了吧，怎么可能？
那么请听我慢慢道来！
上面是一个程序


看到程序运行结果，大家会下意识的想到:额,不是这样吗，是这样的啊，别扯了，你说的子类对象中怎么会有一个父类对象。

这是我的解释:
依据大家的理解Manager类继承自Employee类，那么除了私有的成员变量其他的都继承下来了，那么Manager对象里面的结构应该是这样的

额，问题就来了，我调用m.setBonus("666");m.setJob_number("110");m.setName("zma");m.setSalary(10000);这些方法，调用
m.setBonus("666")还可以理解，但是调用另外的3个方法，m对象把值赋到什么地方去了，m对象不是没有name,job_number,salary这些成员变量的吗
还更奇怪的是，当我执行System.out.println()打印的时候这些值又出现了。

正式开始之前：我想问大家一个问题?构造函数的出现是不是都伴随着对象的创建，为什么构造函数的第一句代码都要是super.父类的构造函数
如果有3个层次继承关系，那么当我new一个孙子对象时，孙子对象的构造函数的第一句是不是要调用父亲的构造函数，而父亲的构造函数的第一句是不是要调用
爷爷的构造函数，这样就形成了构造方法的层级调用，于是，先创建爷爷对象，再创建父亲对象，再创建孙子对象，于是上面的m对象就应该是这种形式

当我们m.setJob_number("110")时，先看子类对象有没有对应的方法，如果没有就去看父类中有没有(多态就是这样形成的)，因为setJob_number方法是pubic类型的
所以m.setJob_number("110")方法是其实是调用了子类中父类的方法，父类的方法是能够访问其中的私有的成员变量的
同理，当我们m.getJob_number()也是一样的道理
当然了这些图可以形象的描述继承的关系(实际情况可能不是这样的)但是通过这种画图的方式可以得到正确的结果
希望同大家一起讨论java技术，无兄弟，不java

从对象的角度来理解构造方法的回溯调用以及多态，简单明了，非常不错！

父类是抽象的话,怎么创建父类的对象呢?望解释

接着上面的解释，请看下面一段代码

1. package cn.up.demo6;
   
2. 
   
3. public abstract class Fu {
   
4.        
   
5.         private int age;
   
6. 
   
7.         public int getAge() {
   
8.                 return age;
   
9.         }
   
10. 
    
11.         public void setAge(int age) {
    
12.                 this.age = age;
    
13.         }
    
14.        
    
15.        
    
16.         public abstract void fu();
    
17.        
    
18.        
    
19.        
    
20. }
    

复制代码

package cn.up.demo6;

public class Zi extends Fu {
       

        @Override
        public void fu() {
                System.out.println("aaaa");
               
        }

}

package cn.up.demo6;

public class Test {

        /**
         * @param args
         */
        public static void main(String[] args) {
               
               
                Zi z = new Zi();
               
                z.setAge(45);
                System.out.println(z.getAge());

        }

}

程序运行结果：45


如果子类对象z中没有父类对象,父类中的成员变量是哪里来的呢？要知道成员变量是存在对象中的


通过这个例子同样解释了为什么 子类继承自抽象类  当要new一个子类对象，必须重写父类的全部抽象方法

跪求此贴千万别沉，让更多的人了解类的构造，这样才能写出更加优雅的代码

恩恩，，不错不错。。