多态
多态的概念
多态是面向对象的重要特性，是指一个引用在不同的情况下的多种状态。
具体讲就是完成某个行为，当不同的对象去完成时会产生不同的状态。
结合实际，把一张图片给黑白打印机，将会打印出黑白照片，给彩色打印机，将会打印出彩色照片。
总的来说：同一件事情，发生在不同对象身上，就会产生不同的结果。
多态的实现条件
Java中实现多态，必须满足以下条件：
- 继承体系下
- 子类必须对父类方法进行重写
- 通过父类的引用调用重写的方法（向上转型 + 动态绑定）
满足以上条件实现多态后：代码运行时，当传递不同类实例化的对象，会调用对应类中的方法
而想要理解多态，我们必须熟悉：方法的重写和向上转型，接下来一一介绍。
方法的重写
重写，也叫覆写或覆盖。
重写是子类对父类非静态、非private修饰、非final修饰、非构造方法等的实现过程（方法体）的重新编写。
【规则】
- 重写要求方法的参数列表不变
- 重写要求方法的返回值不变，除非返回类型具有父子关系，例如，返回值类型分别为父类和子类（父类方法的返回类型为父子关系中的父，子类方法的返回值为父子关系中的子；反之不可）
- 子类重写后的方法的访问权限必须大于等于父类方法的访问权限，例如，父类方法被
public修饰，子类就不可以被protected修饰，此时只能被public修饰 - 子类不能重写父类中被
static、private、final修饰的方法 - 子类不能重写父类的构造方法
我一段含有重写的代码：
//Animal.java
public class Animal {
public String name;
public int age;
//...
//父类被重写的方法
public void eat() {
System.out.println(this.name + "吃饭");
}
}
//Dog.java
public class Dog extends Animal {
//子类重写父类方法
public void eat() {
System.out.println(this.name + "吃狗粮");
}
}
关于重写，有一个小知识：
重写的方法，可以使用注解@Override，这个注解可以帮我们进行校验，校验重写后的方法是否存在问题：
//Animal.java
public class Animal {
public String name;
public int age;
public void eat() {
System.out.println(this.name + "吃饭");
}
}
//Dog.java
public class Dog extends Animal {
@Override
public void eat() {
System.out.println(this.name + "吃狗粮");
}
}
当我们修改重写后的方法名，就会报错提示：
重写与重载的区别
其中，重写返回类型可以不相同，不过必须构成父子关系。
方法重写是子类与父类的一种多态性表现；而方法重载是一个类的多态性的表笑。
动态绑定和静态绑定
【动态绑定】
动态绑定也称后期绑定（晚绑定），即在编译时，不能确定方法的行为，需要等到程序运行时，才能确定具体调用哪个类的方法。
观察以下代码，说出打印结果：(建议先看下一个模块向上转型，这部分知识联系密切，不可严格分割)
//Animal.java
public class Animal {
public String name;
public int age;
//...
public void eat() {
System.out.println(this.name + "吃饭");
}
}
//Dog.java
public class Dog extends Animal {
@Override
public void eat() {
System.out.println(this.name + "吃狗粮");
}
}
//Test.java
public class Test {
public static void main(String[] args) {
Animal animal = new Dog();
animal.name = "大哈";
animal.eat();
}
}
我们用Animal类的引用访问eat方法，为什么访问到的是子类Dog的eat呢？
这里就涉及到了动态绑定。
动态绑定的条件：
- 父类引用引用了子类对象
- 通过满足上述上条件的父类调用了父类和子类重写的那个方法
动态绑定效果：
父类引用最终调用了其引用的子类中的重写方法
对于上述例子，其程序在编译时调用的确实是父类的eat方法，我们可以通过观察反汇编代码：
当程序运行时，就能确认调用子类的eat方法
如果在父类的构造方法中调用子类和父类重写的方法，此时会发生动态绑定，最终调用的是子类重写后的方法
public class Test {
public Test() {
this.func();
}
public void func() {
System.out.println("父类方法");
}
}
class Child extends Test {
// public Child() {
// super();
// }
@Override
public void func() {
System.out.println("子类方法");
}
public static void main(String[] args) {
Child child = new Child();
}
}
打印结果是：
我们实例化子类对象，调用子类构造方法，子类构造方法先调用父类构造方法，父类构造方法中调用了func方法，此时发生动态绑定，调用子类重写后的func方法。
这样的代码我们不会写，我们要避免在构造方法中调用重写方法！
【静态绑定】
静态绑定也称为前期绑定（早绑定），即在编译时，根据用户所传递实参类型就确定了具体调用哪个方法。 如，方法重载，根据调用参数时的传入的参数，（不同的方法签名）在编译期间就可以确定调用哪个方法。
向上转型
向上转型： 创建一个子类对象，将其当作父类对象使用（父类的引用 引用了子类的对象）
向上转型有三种方式：
- 直接赋值
- 方法传参
- 方法返回
【直接赋值】
//Base.java
public class Base {
public int a;
}
//Child.java
public class Child extends Base {
public int b;
}
//Test.java
public class Test {
public static void main(String[] args) {
//直接赋值
Base base = new Child();//父类Base的引用base指向了子类Child的对象
}
}
【方法传参】
//Base.java
public class Base {
public int a;
}
//Child.java
public class Child extends Base {
public int b;
}
//Test.java
public class Test {
public void test(Base base) {
System.out.println("方法传参实现向上转型");
}
public void useTest() {
Child child = new Child();
test(child);//传一个Child类的对象，用Base对象的引用接收，向上转型
}
public static void main(String[] args) {
Test test = new Test();
test.useTest();
}
}
【方法返回】
//Base.java
public class Base {
public int a;
}
//Child.java
public class Child extends Base {
public int b;
}
//Test.java
public class Test {
//返回类型为Base类，实际返回的是Child类，向上转型
public Base test() {
Child child = new Child();
return child;
}
}
向上转型的缺点：不能调用到子类特有的方法
//Base.java
public class Base {
public int a;
}
//Child.java
public class Child extends Base {
public int b;
public void myChild() {
System.out.println("子类特有的方法");
}
}
//Test.java
public class Test {
public static void main(String[] args) {
//正常子类引用指向子类对象，可以访问到子类特有的方法
Child child = new Child();
child.myChild();
//向上转型后，虽然base指向Child类对象，但是不能调用子类特有的方法了
Base base = new Child();
base.myChild();
}
}
向下转型
向下转型，就是子类的引用引用了父类的对象。
向下转型是有风险的，要强制类型转换才能实现。
以动物（父类）、猫（子类）、狗（子类）为例，猫和狗一定是动物，但是，动物不一定是猫。
向下转型能够处理向上转型不能够访问子类特有方法的问题：
//Animal.java
public class Animal {
public String name;
public int age;
//...
public void eat() {
System.out.println(this.name + "吃饭");
}
}
//Dog.java
public class Dog extends Animal {
@Override
public void eat() {
System.out.println(this.name + "吃狗粮");
}
public void bark() {
System.out.println(this.name + "正在汪汪叫");
}
}
//Cat.java
public class Cat extends Animal {
@Override
public void eat() {
System.out.println(this.name + "吃猫粮");
}
}
//Test.java
public class Test {
public static void main(String[] args) {
Animal animal = new Dog();//向上转型
animal.name = "大哈";
animal.eat();
Dog dog = (Dog)animal;//向下转型
dog.bark();//调用子类Dog特有的方法
}
}
向下转型是有风险的，例如（仅修改上述代码的Test类）：
public class Test {
public static void main(String[] args) {
Animal animal = new Cat();
animal.name = "小猫";
//animal此时指向的是猫对象
//向下转型成狗类
Dog dog = (Dog)animal;
//调用狗类特有方法
dog.bark();
}
}
如果上述代码可行，我们打印的结果就是：小猫正在汪汪叫
在我们的认知下，小猫怎么能汪汪叫呢，Java也是这么想的：
为了避免报错，我们可以使用instanceof关键字：
public class Test {
public static void main(String[] args) {
Animal animal = new Cat();
animal.name = "小猫";
if(animal instanceof Dog) {
Dog dog = (Dog) animal;
dog.bark();
}
}
}
instanceof的作用是：判断左边的对象是否是右边类的实例，返回boolean类型的值
所以，上例中，animal instanceof Dog就是判断animal的对象是否是Dog类的实例，显然，animal指向的是Cat类对象，所以，返回false。
理解多态
了解了上面的知识后，我们看一段代码，体现了多态：
//Animal.java
public class Animal {
public String name;
public int age;
//...
public void eat() {
System.out.println(this.name + "吃饭");
}
}
//Dog.java
public class Dog extends Animal {
@Override
public void eat() {
System.out.println(this.name + "吃狗粮");
}
}
//Cat.java
public class Cat extends Animal {
@Override
public void eat() {
System.out.println(this.name + "吃猫粮");
}
}
//Test.java
public class Test {
public static void func(Animal animal) {
animal.eat();//父类引用调用重写方法（动态绑定）
}
public static void main(String[] args) {
Dog dog = new Dog();
Cat cat = new Cat();
//传入Dog类和Cat类，Animal类接收，发生向上转型（方法传参）
Test.func(dog);
System.out.println("============");
Test.func(cat);
}
}
打印结果如下：
从调用者的角度看，我们给同一个func方法传入不同的对象（猫、狗），得到的结果不一样（吃猫粮，吃狗粮），这就是多态。
【多态的优缺点】
优点：
简化代码，降低代码的"圈复杂度"，避免大量使用
if-else语句圈复杂度，简单讲就是代码中条件语句和循环语句的个数，个数越多越复杂。
使代码的可拓展性变强
对于优点一，我们设置一个场景，根据场景写代码体会：
假设我们要画一些图形：
父类和子类代码：
//Shape.java
public class Shape {
public void draw() {
System.out.println("画一个图形");
}
}
//Pentagram.java
public class Pentagram extends Shape {
@Override
public void draw() {
System.out.println("五角星☆");
}
}
//Rotundity.java
public class Rotundity extends Shape {
@Override
public void draw() {
System.out.println("圆形⭕");
}
}
//Square.java
public class Square extends Shape {
@Override
public void draw() {
System.out.println("正方形□");
}
}
测试类代码（实现画图形）：
- 不使用多态
//Test.java
public class Test {
public static void main(String[] args) {
//实例化三个对象，后续通过它们调用自己的方法
Pentagram pentagram = new Pentagram();
Rotundity rotundity = new Rotundity();
Square square = new Square();
String[] strings = {"pentagram", "rotundity", "square"};
for(String s : strings){
if(s.equals("pentagram")){
pentagram.draw();
}else if(s.equals("rotundity")){
rotundity.draw();
}else{
square.draw();
}
}
}
}
if-else语句使用较多。
- 使用多态
public class Test {
public static void main(String[] args) {
Pentagram pentagram = new Pentagram();
Rotundity rotundity = new Rotundity();
Square square = new Square();
Shape[] shapes = {pentagram, rotundity, square};
//向上转型
for(Shape shape : shapes){
shape.draw();//体现动态绑定
}
}
}
代码的圈复杂度明显降低了。
缺点：
降低代码运行效率
属性没有多态性
子类和父类具有同名属性时，通过父类引用，只能访问父类自己的属性
构造方法没有多态性
以上就是多态部分的全部内容了，希望能对大家有所帮助！
预告：抽象类与接口
367
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
