面向对象三大特性之——多态

面向对象三大特性之——多态

一、引言

此篇文章来自一个初学Java不久的学生，内容的用词、深度、广度甚至部分理解不够到位，再加上Markdown语法的不熟练，所以排版不够美观。但还是希望有疑问的读者能够读完全文，大家遇到问题可以一起交流。谢谢！

二、初步理解多态

多态，顾名思义一种东西的多种形态。那面向对象里面为什么或者说哪里来的多态？要想顺理的理解多态，就需要你对封装和继承又很好的理解。内容可以参考我之前写的
面向对象三大特性之——封装
面向对象三大特性之——继承。
当然，也希望你读完这篇文章之后，能够完成下面几个问题。
1.什么是多态，为什么使用多态？
2.理解为什么会有抽象类和接口，二者的区别是什么？
3.理解使用多态类和几口实现多态的不同。

三、多态

一、基本概念

1.什么是多态？

答：同一个对象，在不同时刻表现出来的不同形态，在继承的子父类里面体现。

2.多态的前提？

答：

​ 1）要有继承或实现关系

​ 2）要有方法的重写

​ 3）要有父类引用指向子类对象

二、成员的访问特点

成员变量：编译看父类，运行看父类（编译看左边，运行也看左边）

成员方法：编译看父类，运行看子类（编译看左边，运行看右边）

People类（父类）：

public class People {   
    int age = 100;   
    public void show() {    
        int age = 200;    
        System.out.println("年龄是："+age);    
    }
}

Student类（子类）：

public class Student extends People {   
    int age = 10;    
    @Override   
    public void show() {    
        int age = 20;      
        System.out.println("年龄是："+age);  
    }   
    public void study() {    
        System.out.println("要好好学习");   
    }
}

测试类：

public class Demo01 {
    public static void main(String[] args) { 
        People p = new Student();      
        p.show();  
    }
}

运行结果：

年龄是：20

总结：成员方法在编译的时候查看父类里面是否含有show（）方法，如果有，在运行的时候在子类里面查找show（）方法，然后执行子类方法的代码。由于子类继承了父类，所以只要父类能够查找到指定的方法，子类的方法里面就一定含有重写父类的方法。所以运行代码，产出结果。

三、多态的优点和缺点

优点：提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作

缺点：不能使用子类的特有成员

四、多态的自动转型

为什么会出现自动转型？

举个例子，我想要打印子类的成员变量age。但是根据多态成员的访问特点来看。成员变量编译看左边，执行也看左边，根本没有出现右边（子类）的成员变量。于是多态的转型就出来了。

1.向上转型：也成为自动转型，即正常的运行方式

2.向下转型：称为强制转型。

主要就是这段代码的理解：

int age = ((Student) p).age;
System.out.println(age);

p被声明为People类型，此时需要向下转型为People的子类Student类型。如果你能想到整型数据的强制转化，这里运用了相同的语法格式。（Student）p。那么此时的p则是Student类型的，然后再调用它里面的age对象，再赋值给main方法里面定义的变量age，打印输出。

四、抽象类

一、基本理解

当我们在做子类相同功能进行抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了。在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。口水话理解就是：抽象类就相当于一个没有劳动能力的父亲，但是心中却又有很多抱负（成员变量和常量），于是只能将自己的想法定义为抽象类，自己没有办法实现，之能把这些想法告诉自己的子类，让它们帮助自己去实现这些抱负（常量和方法）

二、抽象类的基本特点

1.抽象类和抽象方法必须使用 abstract 关键字修饰

//抽象类的定义
public abstract class 类名 {}

//抽象方法的定义
public abstract void eat();

2.抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

3.抽象类不能实例化，要想实现抽象类的方法，需要借助其子类实现，也就是多态的概念。

4.抽象类的子类可以是一下两种情况

​ 1）要么重写抽象类中的所有抽象方法

​ 2）要么是抽象类

三、抽象类的成员特点

成员变量：既可以是变量，也可以是常量

构造方法：空参构造，有参构造

成员方法：抽象方法，普通方法

五、接口

一、接口理解

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。Java中的接口更多的体现在对行为的抽象。这个在我们现实中的理解就好比，在离开继承的is…a关系之后，自然界还有一种关系就好比，你和老鹰会飞，飞机也会飞，你做梦的时候也会飞，但是你们三者很难找到一个继承的关系，所以接口就来了，它就类似于一个功能的开关。当给你连接这个接口的时候，你就可以获得这个功能。

二、接口的特点

接口用关键字interface修饰

public interface 接口名 {} 

类实现接口用implements表示

public class 类名 implements 接口名 {}

接口不能实例化：这一点和抽象类的用法相同。要想实现接口的方法，需要借助其子类实现，也就是多态的概念。

接口的子类：要么重写接口中的所有抽象方法，要么子类也是抽象类

三、接口的成员特点

成员变量：只能是常量
​ 默认修饰符：public static final

构造方法：没有，因为接口主要是扩展功能的，而没有具体存在

成员方法：只能是抽象方法

默认修饰符：public abstract

六、例子

一、抽象类与多态的结合

需求：定义一个抽象的Father类，定义一个Son类用来充当Father的子类，并且实现Father的抽象方法。在测试类里面，利用多态的方式，调用Son里面指定的方法

定义一个Father类：

public abstract class Father {   
    public abstract void hobby();
}

定义一个Son类：

public class Son extends Father {
    @Override   
    public void hobby() {    
        System.out.println("我的爱好是打篮球");  
    }
}

定义一个测试类：

public class Demo03 {
    public static void main(String[] args) { 
        Father f = new Son();  
        f.hobby(); 
    }
}

代码执行结果：

我的爱好是打篮球

二、接口类与多态的结合

需求： 定义一个Fly的接口，里面包含两个不同定义方式的eat和fly方法。再定义三个方法People、Plane和Eagles用于实现接口。定义一个测试类，用前面提到的不同的方式去调用不同的方法和常量。

定义一个Fly的接口类：

public interface Fly { 
    //省略了默认的修饰符的方式定义方法
    void fly();   
    //加上默认的修饰符的方式定义方法，除方法名不一样外，两者的效果一样
    public abstract void eat();
}

定义三个Fly接口的实现类，People、Plane和Eagles：

People类：

public class People02 implements Fly{  
    int num =1;  
    //在子类中对接口中的方法进行重写
    @Override   
    public void eat() {  
        System.out.println("我是人，我要吃饭");  
    } 
    //在子类中对接口中的方法进行重写
    @Override   
    public void fly() {    
        System.out.println("我是人，我做梦会飞"); 
    }
}

Plane类：

public class Plane implements Fly {  
    int num = 2;  
    @Override 
    public void eat() {   
        System.out.println("我是飞机，我不需要吃饭");   
    }   
    @Override  
    public void fly() {   
        System.out.println("我是飞机，我可以飞的很高");  
    }
}

Eagles类：

public class Eagles implements Fly {   
    int num =3;  
    @Override  
    public void eat() {   
        System.out.println("我是老鹰，我要吃蛇");   
    }   
    @Override    
    public void fly() {     
        System.out.println("我是老鹰，我会飞翔");   
    }
}

定义一个测试类：

public class Demo02 {   
    public static void main(String[] args) {    
        //利用多态的方式创建一个对象
        Fly f = new People02();   
        f.eat();  
        f.fly();      
        //向下转型的运用
        System.out.println(((People02) f).num);   
        
        //正常的实例化Plane
        Plane p = new Plane();      
        p.eat();      
        p.fly();    
        System.out.println(());    
        
        Fly e = new Eagles();  
        //使用的是向下转型的方式调用这个方法，但是成员方法的访问特点是：编译看左边，执行看右边，所以使用下面的方式调用也可以
        ((Eagles)e).eat();     
        e.fly();       
        //利用向下转型（强制转型）的方式，打印输出其实现子类的成员变量
        System.out.println(((Eagles) e).num);  
    }
}

代码执行结果：

我是人，我要吃饭
我是人，我做梦会飞
1
我是飞机，我不需要吃饭
我是飞机，我可以飞的很高
2
我是老鹰，我要吃蛇
我是老鹰，我会飞翔
3