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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© vtming 中级黑马   /  2014-3-17 17:46  /  1245 人查看  /  9 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

public classSonTest {
   public static void main(String[] args) {
      Sonaa = newSonb();
      a.show();
   }
}
class Sona {
   public void show() {
      System.out.println("这是父类方法+++++");
   }
}
class Sonb extendsSona {
// publicvoid show() {
//    System.out.println("这是子类方法-------");
// }

}
输出结果:
这是父类方法+++++
--------------------------------------------------------
父类的引用为什么会调用自身的方法??

评分

参与人数 1黑马币 +1 收起 理由
zzkang0206 + 1

查看全部评分

9 个回复

倒序浏览

public class Demo {
   public static void main(String[] args) {
      Sona a = new Sonb();
      a.show();
   }
}
class Sona {
   public void show() {
      System.out.println("这是父类方法+++++");
   }
}
class Sonb extends Sona {
//public void show() {
   // System.out.println("这是子类方法-------");
//}

}

a.show();执行时,运行子类show()方法(即继承的父类的 show()方法,因为子类没有复写父类的show()方法),结果是:这是父类方法+++++
当把代码中红色标记去掉,即子类复写父类的show()方法, a.show();执行时,运行子类的方法show()方法,结果是:这是子类方法-------

评分

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

查看全部评分

回复 使用道具 举报
这叫做多态,因为子类没有复写父类的方法。所以方法执行时会找父类的方法。如果子类复写了,那么调用的将是子类的方法

评分

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

查看全部评分

回复 使用道具 举报
LZ记住一点就行了,用父类创建子类对象属于向上转型,向上转型调用的一定是子类的方法
回复 使用道具 举报
很明显的动态绑定嘛。。。。变量有声明类型和实例类型。方法的实际执行是由实例类型所决定的:1、从实例类型(sonb)开始查找的,有show()方法,则执行;2、如果实例类型(sonb)里面没有show()方法,就会在父类(sona)上找。这就是动态绑定。问题解决了。。。求加技术分啊。。。。各种求。呵呵

评分

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

查看全部评分

回复 使用道具 举报
乔钰博 发表于 2014-3-17 20:28
LZ记住一点就行了,用父类创建子类对象属于向上转型,向上转型调用的一定是子类的方法 ...

向上转型调用的是子类覆盖父类的方法  子类特有的方法是调不到的
回复 使用道具 举报
多态里编译看左边,执行看右边。就是说如果sona类中没有show()方法,编译会出错,如果有编译通过,执行的时候看右边,就是说如果右边sonb中有show()方法就执行,如果没有就执行sona中的show()方法

评分

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

查看全部评分

回复 使用道具 举报
子类继承了父类的show方法,你将子类重写的方法注释了,则调用的还是继承了父类的show方法,如果重写了父类的方法,则调用的是子类的show方法

评分

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

查看全部评分

回复 使用道具 举报
在多态中成员函数的特点:
在编译时期:参阅引用型变量所属的类中是否有调用的方法。如果有,编译通过,如果没有编译失败。
在运行时期:参阅对象所属的类中是否有调用的方法。
简单总结就是:成员函数在多态调用时,编译看左边,运行看右边。
运行的时候是看的右边的子类,但是你这个子类继承了父类的方法,所以表明子类也是有这个方法的,所以最后运行结果是这样的。

评分

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

查看全部评分

回复 使用道具 举报
这个很明显是向上转型嘛,向上转型以后是调用的是父类的方法
java继承的总结:
1.构造函数:
        当子类继承一个父类时,构造子类时需要调用父类的构造函数,存在三种情况
        (1),父类无构造函数或者一个无参数构造函数,子类若无构造函数或者有无参数构造函数,子类构造函数中不需要显式调用父类的构造函数,系统会自动在调用子类构造函数前调用父类的构造函数
         (2),父类只有有参数构造函数,子类在构造方法中必须要显示调用父类的构造函数,否则编译出错
         (3),父类既有无参数构造函数,也有有参构造函数,子类可以不在构造方法中调用父类的构造函数,这时使用的是父类的无参数构造函数
2.方法覆盖:
          (1)子类覆盖父类的方法,必须有同样的参数返回类型,否则编译不能通过
          (2)子类覆盖父类的方法,在jdk1.5后,参数返回类可以是父类方法返回类的子类
         (3)子类覆盖父类方法,可以修改方法作用域修饰符,但只能把方法的作用域放大,而不能把public修改为private
          (4)子类方法能够访问父类的protected作用域成员,不能够访问默认的作用域成员
         (5)子类的静态方法不能隐藏同名的父类实例方法
         (6)java与C++一样,继承的方法具有多态性
3.成员覆盖:
         (1)当子类覆盖父类的成员变量时,父类方法使用的是父类的成员变量,子类方法使用的是子类的成员变量
          这个听起来很容易理解的一回事,但是实际使用过程中很多人容易搞混:尤其是在多态的时候,调用一个被继承的方法,该方法访问是一个被覆盖的成员m,那么方法中到底是访问了父类的成员还是子类的成员m?结论是,若实际调用的是父类的方法,就使用了父类的该成员m,若实际调用的是子类的方法,就使用子类的成员m,记住一句,每个类使用成员都相当于在前面加了 一个this指针。

可以参考以下代码思考以下:
    class SuperClass {  
        private int number;  
      
      
        public SuperClass() {  
            this.number = 0;  
        }  
      
      
        public SuperClass(int number) {  
            this.number = number;  
        }  
      
      
        public int getNumber() {  
            number++;  
            return number;  
        }  
    }  
      
    class SubClass1 extends SuperClass {  
        public SubClass1(int number) {  
            super(number);  
        }  
      
    }  
      
    class SubClass2 extends SuperClass {  
        private int number;  
      
      
        public SubClass2(int number) {  
            super(number);  
        }  
      
    }  
      
    public class SubClass extends SuperClass {  
      
        private int number;  
      
      
        public SubClass(int number) {  
            super(number);  
        }  
      
      
        public int getNumber() {  
            number++;  
            return number;  
        }  
      
      
        public static void main(String[] args) {  
            SuperClass s = new SubClass(20);  
            SuperClass s1 = new SubClass1(20);  
            SuperClass s2 = new SubClass2(20);  
            System.out.println(s.getNumber());  
            System.out.println(s1.getNumber());  
            System.out.println(s2.getNumber());  
            //结论一:多态时,当子类覆盖了父类的方法,使用子类覆盖的方法  
            //结论二:当子类覆盖父类的成员变量时,父类方法使用的是父类的成员变量,子类方法使用的是子类的成员变量  
        }  
      
    }  

评分

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

查看全部评分

回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马