Java学习笔记(多态)

原创 2015年11月21日 11:12:02

12.多态

多态:事物存在的多种体现形态

例:动物中猫,狗。

  • 猫这个对象对应的类型是猫类型:猫 x=new 猫();
  • 同时猫也是动物中的一种,也可以把猫称为动物:动物 y=new 猫();

动物是猫和狗具体事物中抽取出来的父类型。
父类型引用指向了子类对象

体现:父类的引用指向了自己的子类对象;父类的引用也可以接受自己的子类对象。

作用:提高了程序的扩展性

应用前提:

  • 需要存在继承或实现关系;
    • 需要有重写操作。

例1

    public class MulitDemo {
        public static void main(String[] args){
            Animal c = new Cat();
            method(c);
            method(new Dog());
            method(new Pig());

        }
        public static void method(Animal a){
            a.eat();
        }

    }

    abstract class Animal{
        public abstract void eat();
    }

    class Cat extends Animal{
        public void eat(){
            System.out.println("吃鱼");
        }
        public void catchMouse(){
            System.out.println("抓老鼠");
        }
    }

    class Dog extends Animal{

        public void eat() {
            System.out.println("吃骨头");  
        }
        public void watchDoor(){
            System.out.println("看家");
        }
    }

    class Pig extends Animal{
        public void eat() {
            System.out.println("吃饲料");  
        }
        public void gongdi(){
            System.out.println("拱地");
        }
    }

运行结果:

例2

class MulitDemo2{
    public static void main(String[] args){
        Animal a = new Cat();//类型提升,向上转型
        a.eat();
        //如果想要调用猫的特有方法时,
        //强制将父类的引用转成子类类型,向下装换
        Cat c =(Cat)a;
        c.catchMouse();
        //不能出现将父类对象转成子类类型的操作;
        //多态始终都是子类对象在做变化
        //Animal a = new Animal();
        //Cat c = (Cat)a;

        //Animal a = new Dog();
        //Cat c = (Cat)a;//也不能随意转换,
                         //否则可能回报出ClasCastException的异常      
    }   
    public static void method(Animal a){
        a.eat();
        if(a instanceof Cat){
            Cat c = (Cat) a;
            c.catchMouse();
        }
        else if(a instanceof Dog){
            Dog d = (Dog) a;
            d.watchDoor();
        }
    }
}

例3

public class MutilDemo3 {

    public static void main(String[] args) {
        DoSth ds = new DoSth();
        ds.doSomething(new BaseStudent());
    }
}

 class DoSth{
    public void doSomething(Student st){
        st.sleep();
        st.study();
    }
}

abstract class Student{
    public abstract void study();
    public void sleep(){
        System.out.println("躺着睡");
    }
}

class BaseStudent extends Student{
    public void study(){
        System.out.println("base study");
    }
    public void sleep(){
        System.out.println("坐着睡");
    }
}

class AdvStudent extends Student{
    public void study(){
        System.out.println("avd sleep");
    }
}

运行结果:

12.1 在多态中成员函数(非静态)的特点:

  • 在编译时期,参考引用型变量所属的类中是否有调用的方法,如果有,编译通过,如果没有编译失败;
  • 在运行时期,参考对象所属的类中是否有调用的方法;
  • 简单说,成员函数在多态调用时,编译看左边,运行看右边。

    class Fu1{
        void method1(){
            System.out.println("fu_method_1");
        }
        void method2(){
            System.out.println("fu_method_2");
        }
    }
    
    class Zi1 extends Fu1{
        void method1(){
            System.out.println("zi_method_1");
        }
        void method3(){
            System.out.println("zi method_3");
        }
    }
    
    public class MutilDemo3 {
        public static void main(String[] args){
            Fu1 f = new Zi1();
            f.method1();
            f.method2();
            //f.method3();
        }
    }
    

运行结果为:

12.2 在多态中成员变量的特点:

  • 编译时,参考引用型变量所属的类中是否有调用的成员变量,如果有则编译通过,没有则编译失败;
  • 运行时,参考引用型变量所属的类是否有调用的成员变量,并运行该所属类中的成员变量;
  • 无论编译和运行,都参考左边(引用类型变量所属的类);

12.3 在多态中静态成员、函数的特点:

  • 无论编译和运行,都参考左边(引用类型变量所属的类);

    class Fu1{
        int num = 5;
        void method1(){
            System.out.println("fu_method_1");
        }
        void method2(){
            System.out.println("fu_method_2");
        }
        static void method4(){
            System.out.println("fu_method_4");
        }
    }
    
    class Zi1 extends Fu1{
        int num = 6;
        void method1(){
            System.out.println("zi_method_1");
        }
        void method3(){
            System.out.println("zi method_3");
        }
        static void method4(){
            System.out.println("zi method_4");
        }
    }
    
    public class MutilDemo3 {
        public static void main(String[] args){
            Fu1 f= new Zi1();
            System.out.println(f.num);
            f.method4();
            Zi1 z= new Zi1();
            System.out.println(z.num);
            z.method4();
        }
    }
    

运行结果:

相关文章推荐

C++虚函数和多态学习笔记

  • 2007年08月31日 13:31
  • 37KB
  • 下载

Java学习笔记-对象-继承-接口-多态-内部类

1.类和对象的区别:对象是一个实例,类对对象进行描述。 2.成员变量:成员变量作用于整个类中。堆内存中。 3.局部变量:局部变量作用于函数中。栈内存中。 4.匿名对象:作为实际参数传递,简化书写。 5...

java学习笔记---构造器的多态和调用顺序

话不多说,先看一个例子: public class Constructor extends Child { public Constructor() { System.out.pri...

JAVA学习笔记之-封装,继承,多态 总结

1、封装 封装:把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。是软件设计模块化、软件复用和软件维护的一个基础。 属性的封装:java中类的...

Java学习笔记--继承与多态

何谓继承 继承的基本概念就不在赘述。 多态与is-a 在Java中,子类只能继承一个父类,子类与父类之间会有is-a的关系,我们称之为“是一种”的关系。我们要理解多态,必须知道我们操作的...

黑马程序员-java多态学习笔记

------- android培训、java培训、期待与您交流! ---------- JAVA多态 多态:可以理解为事务存在的多种体现形态 一、多态的提现: l 父类的引用指向了自己的子类对...

Java学习笔记--接口与多态

其实,我们在Java中,提倡用的是接口而不是继承,很多书上都说“别滥用继承”,那么什么是接口呢,他和继承,多态有什么关系? 何谓接口 Java是一门面向对象的语言,它尝试着把所有问题都抽象为一个实...

Java学习笔记---继承和多态

继承public class Circle extends GeometricObject{} //Circle-子类 GeometricObject-父类 super() //调用父类的无参构造方法...
  • Hareric
  • Hareric
  • 2015年11月18日 20:39
  • 430

java jdk7学习笔记:继承与多态

何谓继承 面向对象中,子类继承(Inherit)父类,避免重复的行为定义,不过并非为了避免重复定义行为就使用继承,滥用继承而导致程序维护上的问题时有所闻。如何正确判断使用继承的时机,以及继承之后...

Android入门基础 Java基础学习笔记dya9 多态,抽象类和接口

1.多态 A.多态概述:事物存在的多种形态 B.多态前提: a.要有继承关系 b.要有方法重写 c.要有父类引用指向子类对象。Animal a = new Cat();a.eat();//...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java学习笔记(多态)
举报原因:
原因补充:

(最多只允许输入30个字)