黑马程序员技术交流社区

标题: 关于继承 [打印本页]
作者: 刘圣繁    时间: 2013-2-20 23:06
标题: 关于继承
如果子类中有与父类中同名的成员变量    然后调用子类对象的函数（此函数继承于父类 未覆盖） 那么 函数调用的是子类的成员变量还是父类的
作者: 贾文泽    时间: 2013-2-20 23:20
  1. class A
  2. {
  3.         static int x=10;
  4.         public static int mun(int m)
  5.         {
  6.                 return x+m;
  7.         }
  8. }

  10. public class text extends A{
  11.         static int x=15;
  12.         public static void main(String args[]){
  13.                 System.out.println(mun(6));
  14.         }
  15. }
复制代码
运行结果是   16   说明调用mun方法传人6 是和父类中的变量x相加返回的。。。。
作者: Gaara    时间: 2013-2-21 00:37
如果子类没有父类的那个方法，那么就用父类的，并且调用方法时应该是  父类名.方法();
一般是自动省略父类名的像楼上的例子就是 A.mun(6)   省略了A

如果子类有，那就是重写了。。。。当然调用子类的
作者: 陈圳    时间: 2013-2-21 09:34
class demo extends A
{
        int age=3;//同名的成员变量
        public static void main(String[] args)
        {
                demo d=new demo();
                d.show();//调用父类继承的show()函数
        }
}
class A
{
        int age=4;//父类的成员变量.
        public void show()
        {
                System.out.println(this.age);  //输出本类中的age的值
        }
}
输出结果:4
作者: 罗海清    时间: 2013-2-21 09:50
我总结过了，只有非静态方法，在运行时，才看右边，就是看子类。。。
其他所有情况，无论在编译还是运行，都看左边，就是看父类。。。
作者: 范天成    时间: 2013-2-21 11:15
子类没有覆盖父类的方法，子类对象调用继承自父类中的方法调用的就是父类中的成员变量。
作者: 胥文    时间: 2013-2-21 11:58
public class Test18 {
        public static void main(String[] args) {
                Fu z = new Zi();
                z.show();
        }

}
class Fu
{
        int x =2;//该变量只作用于父类
        public void show()
        {
                int x=3;//局部变量在作用于方法内
                System.out.println(x);此处x=3
                System.out.println(this.x);//调用的是该类的成员变量,此处的x=2
        }
}
class Zi extends Fu
{
       
        int x =4;//该变量只作用于子类中
        public void show()
        {
                int x=3;//局部变量只作用于方法中
                System.out.println(x);
                System.out.println(super.x);//调用的是父类的成员变量，注：当父类和子类有相同的变量名时，通过super和this来区分
                System.out.println(this.x);//调用的是该类的成员变量
        }
}
输出结果是
3
2
4
作者: 冯飞    时间: 2013-2-21 20:33
  1. class A{
  2.         String a = "我是父类成员变量。";
  3.         public void show(){
  4.                 System.out.println(this.a);
  5.                 System.out.println(a);
  6.         }
  7. }

  9. class B extends A{
  10.         String a = "我是子类成员变量。";
  11.         public static void main(String[] srgs){
  12.                 B b = new B();
  13.                 b.show();
  14.                 System.out.println(b.a);
  15.         }
  16. }
复制代码
运行程序的结果是：

我是父类成员变量。
我是父类成员变量。
我是子类成员变量。

由此可以看出，当子类没有重写父类的方法时，程序运行时是父类的方法调用父类的成员变量。
若是重写了方法，代码如下：
  1. class A{
  2.         String a = "我是父类成员变量。";
  3.         public void show(){
  4.                 System.out.println(this.a);
  5.                 System.out.println(a);
  6.         }
  7. }

  9. class B extends A{
  10.         String a = "我是子类成员变量。";
  11.         public void show(){
  12.                 System.out.println(this.a);
  13.                 System.out.println(a);}
  14.        
  15.         public static void main(String[] srgs){
  16.                 B b = new B();
  17.                 b.show();
  18.                 //new A().show();
  19.                 System.out.println(b.a);
  20.         }
  21. }
复制代码
结果是：
我是子类成员变量。
我是子类成员变量。
我是子类成员变量。

可见，子类重写了父类方法后，才会在调用的时候使用子类成员变量。



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