目录

 

1.多态的定义

2.多态的三种形式

3.多态的编译和运行

4.多态的转型

5.多态的好处

6.多态的弊端

1.多态的定义

多态、封装和继承是面向对象的三大特性。多态需满足三个条件：（1）有继承；（2）有重写；（3）有父类引用指向子类对象。最终多态体现为父类引用可以指向子类对象：父类类型 变量名 = new 子类类型()。

2.多态的三种形式

（1）普通类多态定义的格式：父类类型 变量名 = new 子类类型()。

class Father {
    int num = 4;
}

class Son extends Father {
    int num = 5;
}

//普通类多态形式
Father father = new Son();

（2）抽象类多态定义的格式

abstract class Father {
    abstract void method();
}

class Son extends Father {
    public void method() {
        System.out.println("abstract");
    }
}

//抽象类多态表现形式
Father father = new Son();

（3）接口多态定义的格式

interface Father {
    public void method();
}

class Son implements Father{
    public void method() {
        System.out.println("implements")
    }
}

//接口多态的表现形式
Father father = new Son();

3.多态的编译和运行

（1）成员变量：编译和运行都看左边。

（2）成员方法：编译看左边，运行看右边。

4.多态的转型

（1）向上转型：子类对象赋值给父类对象引用。

使用格式：父类类型 变量名 = new 子类类型()

（2）向下转型：父类对象引用强制转换为子类对象引用。

使用格式：子类类型 变量名 = （子类类型）父类类型

5.多态的好处

（1）向上转型：隐藏了子类类型，提高代码的扩展性。

（2）向下转型：可以使用子类特有功能。

6.多态的弊端

（1）向上转型：只能使用父类共性的内容，无法使用子类特有功能。

（2）向下转型：容易发生类型转换异常（ClassCastException）。

1.方法重载
通常在一个类中，相同的方法对应着不同的方法实现，这些方法名相同的方法其区别在于方法参数不同。
2.方法重写
方法重写主要用于父类和子类之间，子类重写父类的方法，只是对用方法的实现不同，方法名和参数相同。
3.抽象类
在Java语言中，一个类中的方法中给出了标准，而没有给出具体的实现方法，这样的类就是抽象类。
4.接口
在多态机制中，接口比抽象类使用起来更方便，而抽象类组成的集合就是接口。

概念：同一个类实例的相同方法在不同情形下有不同的表现形式
在Java中，对于多态的核心表现主要有以下两点：
1. 方法多态：
① 方法重载：同一个方法名称可以根据参数的类型或个数不同调用不同的方法体
② 方法覆写：同一个父类的方法可以根据实例化子类的不同也有不同的实现
方法多态之前的文章里面详细阐述过，在此不再赘述。
2. 对象多态：
① 向上转型(90%)：
天然发生，认爹过程，指的是将子类对象变成父类对象
语法：父类 父类引用 = 子类实例;，例如Person per = new Student();
class Person {
    public void print() {
        System.out.println("父类");
    }
}
class Student extends Person {
    public void print() {
        System.out.println("子类");
    }
}
public class XiangShangZhuanXing {
    public static void main(String[] args) {
        Person per = new Student();
        per.print();
    }
}



 结论：不管是否发生了向上转型，核心本质还是在于：你使用的是哪一个子类(new在哪里)，而且调用的方法是否被子类所覆写了。

应用场景：参数统一化
例如：要求定义一个方法，这个方法可以接收Person类的所有子类实例，并调用Person类的方法。
class Person {
    public void print() {
        System.out.println("1.我是人类！");
    }
}
class Student extends Person {
    public void print() {
        System.out.println("2.我是学生！");
    }
}
class Worker extends Person {
    public void print() {
        System.out.println("3.我是工人！");
    }
}
public class CanShuTongYiHua {
    public static void main(String[] args) {
        //Person per = new Student();
        WhoYouAre(new Student());
        //Person per = new Worker();
        WhoYouAre(new Worker());
    }
    public static void WhoYouAre(Person per) {
        per.print();
    } 
}


② 向下转型(1%)：
需要强转，指的是将父类对象变成子类对象
语法：子类 子类实例 = (子类)父类实例;，例如Student stu = (Student) per;


问题：向下转型存在的意义或者为什么我们需要向下转型？


class Person {
    public void print() {
        System.out.println("父类");
    }
}
class Student extends Person {
    public void print() {
        System.out.println("子类");
    }
    public void fun() {
        System.out.println("只有子类有");
    }
}
public class XiangXiaZhuanXing {
    public static void main(String[] args) {
        Person per = new Student();
        per.print();
        System.out.println("==========");
        Student stu = (Student) per;
        stu.fun();
    }
}



 结论：在上述代码中父类能调用的就只有本类定义好的方法，并没有Student类中的fun()方法，如果父类要想调用fun()方法就只能进行向下转型处理，总的来说就是当需要子类扩充操作的时候就要采用向下转型。

应用场景：发生在父类引用需要调用子类扩充方法时，才发生向下转型变为子类引用调用其扩充方法

注意：并不是所有的父类对象都可以向下转型 ，如果要想进行向下操作之前，前提是一定要首先发生向上转型，否则在转型时会出现ClassCastException(运行时异常，类型转换异常，发生在两个毫无关系的两个类之间的强转时)

观察错误转型：
class Person {
    public void print() {
        System.out.println("父类");
    }
}
class Student extends Person {
    public void print() {
        System.out.println("子类");
    }
    public void fun() {
        System.out.println("只有子类有");
    }
}
public class XiangXiaZhuanXing {
    public static void main(String[] args) {
        Person per = new Person();
        per.print();
        System.out.println("==========");
        Student stu = (Student) per;
        stu.fun();
    }
}



 结论：上述代码进行向下转型之前Person per = new Person();没有先进行向上转型，所以出现类型转换异常这个错误。

问题 ：如果向下转型存在安全隐患，那么如何转型才靠谱呢？


最好的做法就是先进行判断，而后再进行转型，那么就可以依靠关键字instanceof实现。
引用对象 instanceof 类：表示该引用能指向该类，返回true表示可以指向，返回flase表示不能指向。
因此，向下转型的标准格式为：
if(!(per instanceof Student)) {
	per = new Student();   // 先建立起联系
}
Student stu = (Student) per;

观察instanceof操作：
class Person {
    public void print() {
        System.out.println("父类");
    }
}
class Student extends Person {
    public void print() {
        System.out.println("子类");
    }
    public void fun() {
        System.out.println("只有子类有");
    }
}
public class XiangXiaZhuanXing {
    public static void main(String[] args) {
        Person per = new Person();
        //避免ClassCastException
        if(!(per instanceof Student)) {
            per = new Student();
        }
        Student stu = (Student) per;
        stu.fun();
    }
}



 结论：我们可以看到加上instanceof之后就算没有先向上转型，向下转型依然是可以进行的。

总结：

对象的多态性(向上转型或向下转型)本质在于方法的覆写。
通过对象的向上转型可以实现接收参数的统一，向下转型可以实现子类扩充方法的调用(一般不操作向下转型，有安全隐患)。
两个没有关系的类对象是不能够进行转型的，一定会出现ClassCastException。

[TOC]
## 多态
多态指的是一类事物有多种形态，比如
动物有多种形态：人，狗，猪
~~~
import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
@abc.abstractmethod
def talk(self):
pass
class People(Animal): #动物的形态之一:人
def talk(self):
print('say hello')
class Dog(Animal): #动物的形态之二:狗
def talk(self):
print('say wangwang')
~~~
## 多态性
### **什么是多态动态绑定(多态性)**
多态性是指在不考虑实例类型的情况下使用实例，多态性分为静态多态性和动态多态性
* 静态多态性：如任何类型都可以用运算符+进行运算
* 动态多态性：如下
~~~
peo=People()
dog=Dog()
pig=Pig()
#peo、dog、pig都是动物,只要是动物肯定有talk方法
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
peo.talk()
dog.talk()
pig.talk()
#更进一步,我们可以定义一个统一的接口来使用
def func(obj):
obj.talk()
~~~
### **为什么要用多态性**
从上面多态性的例子可以看出，python本身就是支持多态性的，这么做的好处是什么呢？
1. 增加了程序的灵活性
以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)
2. 增加了程序额可扩展性
通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用
~~~
>>> class Cat(Animal): #属于动物的另外一种形态：猫
...     def talk(self):
...         print('say miao')
>>> def func(animal): #对于使用者来说，自己的代码根本无需改动
...     animal.talk()
>>> cat1=Cat() #实例出一只猫
>>> func(cat1) #甚至连调用方式也无需改变，就能调用猫的talk功能
say miao
~~~
>新增了一个形态Cat，由Cat类产生的实例cat1，使用者可以在完全不需要修改自己代码的情况下。使用和人、狗、猪一样的方式调用cat1的talk方法，即func(cat1)
## 鸭子类型
Python崇尚鸭子类型，即‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子’
python程序员通常根据这种行为来编写程序。例如，如果想编写现有对象的自定义版本，可以继承该对象,也可以创建一个外观和行为像，但与它无任何关系的全新对象，后者通常用于保存程序组件的松耦合度。
* 例1：
利用标准库中定义的各种‘与文件类似’的对象，尽管这些对象的工作方式像文件，但他们没有继承内置文件对象的方法
~~~
#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
def read(self):
pass
def write(self):
pass
class DiskFile:
def read(self):
pass
def write(self):
pass
~~~
* 例2：序列类型有多种形态：字符串，列表，元组，但他们直接没有直接的继承关系
~~~
#str,list,tuple都是序列类型
s=str('hello')
l=list([1,2,3])
t=tuple((4,5,6))
#我们可以在不考虑三者类型的前提下使用s,l,t的len方法
s.__len__()
l.__len__()
t.__len__()
~~~