A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 姜姗姗 中级黑马   /  2014-4-24 21:06  /  1760 人查看  /  6 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 姜姗姗 于 2014-4-25 16:51 编辑
  1. package thread;

  2. class test_parent
  3. {
  4.         int x = 5;
  5.         int y = 10;
  6.         void set_value(int a, int b)
  7.         {
  8.                 x = a;
  9.                 y = b;
  10.         }
  11.         int get_1()
  12.         {
  13.                 return this.x + this.y;
  14.         }
  15.         int get_2()
  16.         {
  17.                 return x - y;
  18.         }
  19. }

  20. class test_4 extends test_parent
  21. {
  22.         int y;
  23.         test_4(int a)
  24.         {
  25.                 y = a;
  26.         }
  27.         void set_value(int a, int b)//重写
  28.         {
  29.                 x = a;
  30.                 y = b;
  31.         }
  32.         int get_2()//重写
  33.         {
  34.                 return y;
  35.         }
  36. }

  37. class  JoinDemo
  38. {
  39.         public static void main(String[] args)
  40.         {
  41.                  test_4  a1=new test_4(1);
  42.                 int x = a1.get_1();
  43.                
  44.                 System.out.println("x="+x);//为什么不是1呢,创建子类对象以后,y=1,怎么会是15呢
  45.                  
  46.                
  47.                  test_4  a2=new test_4(-1) ;
  48.                 a2.set_value(5,5);
  49.                 int z = a2.get_2();
  50.                 System.out.println("z="+z);//创建对象的时候,传值-1,为什么最后输出z不是-1,那-1去哪里了?难道是因为没有返回值?
  51.         }
  52. }
复制代码


评分

参与人数 1技术分 +1 收起 理由
SyouRai_Tsk + 1

查看全部评分

6 个回复

倒序浏览
  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. }
复制代码


回复 使用道具 举报

那初始化的-1去哪啦?
回复 使用道具 举报
本帖最后由 曲佳奇 于 2014-4-24 21:50 编辑
姜姗姗 发表于 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.         }
复制代码

评分

参与人数 1技术分 +1 收起 理由
枫儿 + 1 赞一个!

查看全部评分

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

正解。。understanded
回复 使用道具 举报
爱翚 中级黑马 2014-4-24 23:36:47
7#
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);
        }
}
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马