多态

1 多态概述

多态是继封装、继承之后，面向对象的第三大特性。

现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。

Java 作为面向对象的语言，同样可以描述一个事物的多种形态。如 Student 类继承了 Person 类，一个 Student 的对象便既是 Student，又是 Person。

2 多态的定义与使用格式

多态的定义格式：及时就是父类的引用变量指向子类对象

父类类型  变量名 = new 子类类型();
变量名.方法名();

A：普通类多态定义的格式

父类 变量名 = new 子类();

如：

class Fu {}
class Zi extends Fu {}
//类的多态使用
Fu f = new Zi();

B：抽象类多态定义的格式

抽象类 变量名 = new 抽象类子类();

如：

abstract class Fu {
    public abstract void method();
}
class Zi extends Fu {
    public void method(){
        System.out.println(“重写父类抽象方法”);
    }
}
//类的多态使用
Fu fu= new Zi();

C：接口多态定义的格式

接口 变量名 = new 接口实现类();

如：

interface Fu {
    public abstract void method();
}
class Zi implements Fu {
    public void method(){
        System.out.println(“重写接口抽象方法”);
    }
}
//接口的多态使用
Fu fu = new Zi();

2.1 案例代码

实例

/*
 * 多态的前提：
 *     子父类的继承关系
 *     方法的重写
 *     父类引用指向子类对象
 * 
 * 动态绑定：运行期间调用的方法，是根据其具体的类型
 * 
 * 
 * 
 * 
 */
public class PoymorphicDemo {
    public static void main(String[] args) {
        /*Cat c = new Cat();
        c.eat();*/
        
        //父类引用 Animal a
        //指向     =
        //子类对象 new Cat()
        
        Animal a = new Cat();
        a.eat();
        
    }
}
 
class Animal {
    public void eat() {
        System.out.println("吃东西");
    }
}
 
 
class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

3 多态成员的特点

A:多态成员变量

当子父类中出现同名的成员变量时，多态调用该变量时：

• 编译时期：参考的是引用型变量所属的类中是否有被调用的成员变量。没有，编译失败。
• 运行时期：也是调用引用型变量所属的类中的成员变量。

简单记：编译和运行都参考等号的左边。编译运行看左边。

B:多态成员方法

• 编译时期：参考引用变量所属的类，如果没有类中没有调用的方法，编译失败。
• 运行时期：参考引用变量所指的对象所属的类，并运行对象所属类中的成员方法。

简而言之：编译看左边，运行看右边

3.1 案例代码六

实例

/*
 *    
 *     多态的成员特点:
 *         成员变量  编译时看的是左边，运行时看的左边
 *         成员方法  编译时看的是左边，运行时看右边
 *         静态方法  编译时看的是左边，运行时看的也是左边
 * 
 * 
 * 编译时看的都是左边，运行时成员方法看的是右边，其他（成员变量和静态的方法）看的都是左边
 * 
 */
public class PoymorphicDemo2 {
    public static void main(String[] args) {
        Dad d = new Kid();
        //System.out.println(d.num);
        
        //d.method();
        d.function();//使用变量去调用静态方法，其实相当于用变量类型的类名去调用
    }
}
 
class Dad {
    int num = 20;
    
    public void method() {
        System.out.println("我是父类方法");
    }
    
    public static void function() {
        System.out.println("我是父类静态方法");
    }
}
 
class Kid extends Dad {
    int num = 10;
    
    public void method() {
        System.out.println("我是子类方法");
    }
    
    public static void function() {
        System.out.println("我是子类静态方法");
    }
}

4 多态中向上转型与向下转型

多态的转型分为向上转型与向下转型两种：

A:向上转型：当有子类对象赋值给一个父类引用时，便是向上转型，多态本身就是向上转型的过程。

使用格式：

父类类型  变量名 = new 子类类型();

如：

Person p = new Student();

B:向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用转为子类引用，这个过程是向下转型。如果是直接创建父类对象，是无法向下转型的

使用格式：

子类类型 变量名 = (子类类型) 父类类型的变量;

如:

Student stu = (Student) p;  // 变量p 实际上指向 Student 对象

实例

/*
 *    
 *     多态中的向上转型和向下转型:
 * 
 *  引用类型之间的转换
 *      向上转型
 *          由小到大(子类型转换成父类型)
 *      向下转型
 *          由大到小
 *  基本数据类型的转换
 *      自动类型转换
 *          由小到大
 *          byte short char --- int --- long --- float --- double
 *      强制类型转换
 *          由大到小
 *          
 *     
 * 
 */
public class PoymorphicDemo3 {
    public static void main(String[] args) {
        Animal2 a = new Dog();//向上转型
        //a.eat();
        
        Dog d = (Dog)a;//向下转型
        d.swim();
        
    }
}
 
class Animal2 {
    public void eat() {
        System.out.println("吃东西");
    }
}
 
 
class Dog extends Animal2 {
    public void eat() {
        System.out.println("啃骨头");
    }
    
    public void swim() {
        System.out.println("狗刨");
    }
}

5 多态的优缺点

实例

/*
 *    
 *     多态的优缺点
 *         优点：可以提高可维护性（多态前提所保证的），提高代码的可扩展性
        缺点：无法直接访问子类特有的成员
 */
public class PoymorphicDemo4 {
    public static void main(String[] args) {
        MiFactory factory = new MiFactory();
        factory.createPhone(new MiNote());
        
        factory.createPhone(new RedMi());
    }
 
    
}
 
class MiFactory {
    /*public void createPhone(MiNote mi) {
        mi.call();
    }
    
    public void createPhone(RedMi mi) {
        mi.call();
    }*/
    
    public void createPhone(Phone p) {
        p.call();
    }
    
}
 
interface Phone {
    public void call();
}
 
//小米Note
class MiNote implements Phone{
    public void call() {
        System.out.println("小米Note打电话");
    }
}
 
//红米
class RedMi implements Phone {
    public void call() {
        System.out.println("红米打电话");
    }
}