1. package thread;
   
2. 
   
3. class test_parent
   
4. {
   
5.         int x = 5;
   
6.         int y = 10;
   
7.         void set_value(int a, int b)
   
8.         {
   
9.                 x = a;
   
10.                 y = b;
    
11.         }
    
12.         int get_1()
    
13.         {
    
14.                 return this.x + this.y;
    
15.         }
    
16.         int get_2()
    
17.         {
    
18.                 return x - y;
    
19.         }
    
20. }
    
21. 
    
22. class test_4 extends test_parent
    
23. {
    
24.         int y;
    
25.         test_4(int a)
    
26.         {
    
27.                 y = a;
    
28.         }
    
29.         void set_value(int a, int b)//重写
    
30.         {
    
31.                 x = a;
    
32.                 y = b;
    
33.         }
    
34.         int get_2()//重写
    
35.         {
    
36.                 return y;
    
37.         }
    
38. }
    
39. 
    
40. class  JoinDemo
    
41. {
    
42.         public static void main(String[] args)
    
43.         {
    
44.                  test_4  a1=new test_4(1);
    
45.                 int x = a1.get_1();
    
46.                
    
47.                 System.out.println("x="+x);//为什么不是1呢，创建子类对象以后，y=1，怎么会是15呢
    
48.                  
    
49.                
    
50.                  test_4  a2=new test_4(-1) ;
    
51.                 a2.set_value(5,5);
    
52.                 int z = a2.get_2();
    
53.                 System.out.println("z="+z);//创建对象的时候，传值-1，为什么最后输出z不是-1，那-1去哪里了？难道是因为没有返回值？
    
54.         }
    
55. }
    

复制代码

1. class  JoinDemo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                  test_4  a1=new test_4(1);
   
6.                 int x = a1.get_1();
   
7.                 //a1.get_1 调用的是从父类继承的方法 因为子类没有重写  this指向父类 所以 this.x+this.y = 5+10=15
   
8.                 System.out.println("x="+x);
   
9.                 //子类对象实例化时 y=-1  
   
10.                 test_4  a2=new test_4(-1) ;
    
11.                 //a2.set_value(5,5)之后  对象中y的值改为5
    
12.                 a2.set_value(5,5);
    
13.                 int z = a2.get_2();
    
14.                 System.out.println("z="+z);
    
15.                 }
    
16. }

复制代码

曲佳奇 发表于 2014-4-24 21:24

那初始化的-1去哪啦？

姜姗姗 发表于 2014-4-24 21:38
那初始化的-1去哪啦？

初始化对象的时候 对象中y的值是-1
  a2.set_value(5,5);  又把5赋给了y
所以最后y的值是5

首先你要知道，变量没有重写之说，如果子类声明了跟父类一样的变量，那意谓着子类中将有两个相同名称的变量 ；
你在子类中定义了y，当你在给y赋值时，如y=5,只是给子类中的y赋值了而没有给父类中的y赋值，如果你想给父类中的y赋值的话就要用super.y=5,来做区分。了解了这点你就可以理解下面的代码了。

1. public static void main(String[] args)
   
2.         {
   
3.                  test_4  a1=new test_4(1);  //将值赋给了子类中的y
   
4.                 int x = a1.get_1();         //调用父类中的get_1()方法，返回父类中的x+y,因为你没有改变父类中的y，所以返回x+y=15
   
5.                
   
6.                 System.out.println("x="+x);
   
7.                  
   
8.                
   
9.                  test_4  a2=new test_4(-1) ;//将值赋给了子类中的y
   
10.                 a2.set_value(5,5);         //调用set_value()方法，把子类中的y变成5，同时父类中的x变为5
    
11.                 int z = a2.get_2();        //调用子类重写中的get_2()方法返回子类中的y，则返回5
    
12.                 System.out.println("z="+z);
    
13.         }

复制代码

世界公民 发表于 2014-4-24 21:59
首先你要知道，变量没有重写之说，如果子类声明了跟父类一样的变量，那意谓着子类中将有两个相同名称的变量 ...

正解。。understanded

class test_parent {
        int x = 5;
        int y = 10;
        void set_value(int a, int b) {
                x = a;
                y = b;
        }
        int get_1() {
                System.out.println("this.x=" + this.x);
                System.out.println("this.y=" + this.y);
                return this.x + this.y;
        }
        int get_2() {
                return x - y;
        }
}

class test_4 extends test_parent {
        int y;
        test_4(int a) {
                y = a;
                System.out.println("y=" + y);
        }
        void set_value(int a, int b){// 重写
                System.out.println("a=" + a);
                System.out.println("b=" + b);
                x = a;
                y = b;
        }
        int get_2(){// 重写
                return y;
        }
}

class JoinDemo {
        public static void main(String[] args) {
                //子类继承父类,在实例化子类对象时加载的顺序是先加载父类再加载子类
                //这一步父类的x,y都被显示赋值了
                //子类的y被赋值为1
                test_4 a1 = new test_4(1);
               
                //get_1()中的this引用的是父类当前的引用
                int x = a1.get_1();
               
                //所以这步得结果是15
                System.out.println("x=" + x);

                //子类继承父类,在实例化子类对象时加载的顺序是先加载父类再加载子类
                //这一步父类的x,y都被显示赋值了
                //子类的y被赋值为-1
                test_4 a2 = new test_4(-1);
               
                //由于方法名相同子类重写了父类的方法，这一步调用的是子类的set_value方法
                //子类的y被赋值围5
                //子类没有x,所以将父类的x也赋值为5
                a2.set_value(5, 5);
               
                //由于方法名相同子类重写了父类的方法，这一步调用的是子类的get_2方法
                //当前子类的y值是5
                int z = a2.get_2();
               
                //所以这步打印出的是y的值，是5
                System.out.println("z=" + z);
        }
}