黑马程序员技术交流社区

标题: 继承中的方法调用 [打印本页]
作者: 姜姗姗    时间: 2014-4-24 21:06
标题: 继承中的方法调用
本帖最后由 姜姗姗 于 2014-4-25 16:51 编辑
  1. package thread;

  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. }

  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. }

  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. }
复制代码


作者: 曲佳奇    时间: 2014-4-24 21:24
  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:38
曲佳奇 发表于 2014-4-24 21:24

那初始化的-1去哪啦？
作者: 曲佳奇    时间: 2014-4-24 21:47
本帖最后由 曲佳奇 于 2014-4-24 21:50 编辑
姜姗姗 发表于 2014-4-24 21:38
那初始化的-1去哪啦？

初始化对象的时候 对象中y的值是-1
  a2.set_value(5,5);  又把5赋给了y
所以最后y的值是5
作者: 世界公民    时间: 2014-4-24 21:59
首先你要知道，变量没有重写之说，如果子类声明了跟父类一样的变量，那意谓着子类中将有两个相同名称的变量 ；
你在子类中定义了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 22:16
世界公民 发表于 2014-4-24 21:59
首先你要知道，变量没有重写之说，如果子类声明了跟父类一样的变量，那意谓着子类中将有两个相同名称的变量 ...

正解。。understanded
作者: 爱翚    时间: 2014-4-24 23:36
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);
        }
}



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2