九、面向对象三大特征（三）—

多态的含义

多态，从字面上理解，多态就是一种类型表现出了多种状态。我们就可以利用多态的特征，用统一的标识来完成不同的功能。

多态的类型

1.方法的多态（方法的重载和重写（覆写））

方法重载(overload)指的是通过一个方法名称，根据其传入的参数列表（参数类型、个数和顺序）的不同，所调用的方法执行体也不同，即调用同一个方法名称在一个类中有不同的功能实现。

方法的重写（覆写）是指父类中完成了一个方法的实现，而子类用了同样的方法名完成了不同的功能实现

2.对象的多态性

多态性允许将父类对象设置成为与一个或多个子对象相等的技术，通过赋值之后，父对象就可以根据当前赋值给不同的子对象，然后以子对象的特性运作。多态意味着相同的（父类）信息发送给不同的子对象，每个子对象表现出不同的形态。

多态的一个核心概念就是，子类（派生类）对象可以视为父类（基类）对象，我们举个例子

鱼类、鸟类、马类都继承于父类动物类，对于他们各自的实例化的对象，我们就可以说鱼是动物，鸟是动物，马是动物。

方法的重写override（覆写）

代码演示：

package demo;class People{private String name;private int age;public People(String name, int age) {this.name = name;this.age = age;}public void talk(){System.out.println("我是人，我会说话");}
}class Student extends People{private String name;private int age;public Student(String name, int age) {super(name, age);}public void talk(){System.out.println("我是学生，我会文明的说话");}}
public class InheritDemo {public static void main(String[] args){Student stu = new Student("bigdodo", 20);stu.talk();}
}

代码讲解：父类里有talk()方法，我们用子类Student去继承父类，理应也继承了父类的talk()方法，但是我们可以使用相同方法名，去完成不同实现方法体，这就是方法的重写（覆写）

方法的重载overload

方法重载(overload)指的是通过一个方法名称，根据其传入的参数列表（参数类型、个数和顺序）的不同，所调用的方法执行体也不同，即调用同一个方法名称在一个类中有不同的功能实现。接下里我来给大家演示一下

代码演示：

package demo;class Calculator{public void sum(int a,float b){System.out.println(a+b);}//参数顺序不一样public void sum(float b,int a){System.out.println(a+b);}//参数个数不一样public void sum(int a,int b,int c){System.out.println(a+b+c);}//参数类型不一样public void sum(int a,float b,int c){System.out.println(a+b+c);}
}public class Test {public static void main(String[] args) {Calculator cal = new Calculator();cal.sum(5, 6.0f);cal.sum(6.0f, 5);cal.sum(5, 6, 7);cal.sum(5, 8.0f, 7);}
}

代码讲解：我们定义了一个计算器类型，然后设置了四个不同的求和方法，但用的都是一个方法名，这时候我们如果定义了一定数量的sum()方法，参数列表就算不一样，我们一样可以在测试类用只用同一个名字的sum()方法计算求和即可，但记住，它们不是同一个方法，这就是方法的重载。

对象的多态性

在讲对象的多态性的时候我们需要先了解两个概念：向上转型、向下转型

向上转型

父类对象通过子类对象去实例化，实际上就是对象的向上转型。向上转型不需要进行强制类型转换的，但是向上转型会丢失精度，我们来举个例子

代码演示：

package demo;class Animal{public void move(){System.out.println("动物动");}
}class Bird extends Animal{public void move(){System.out.println("鸟儿飞");}
}class Horse extends Animal{public void move(){System.out.println("马儿跑");}
}
class Fish extends Animal{public void move(){System.out.println("鱼儿游");}
}public class Test {public static void main(String[] args) {Animal animal;Fish fish = new Fish();Bird bird = new Bird();Horse horse = new Horse();//将鱼儿对象赋值给animal,调用Fish的move()方法animal = fish;animal.move();//将马儿对象赋值给animal,调用Horse的move()方法animal = horse;animal.move();//将鸟儿对象赋值给animal,调用Bird的move()方法animal = bird;animal.move();}
}

代码运行结果：

代码讲解：这里运用了向上转型，通过赋值之后，父对象就可以根据当前赋值给不同的子对象，然后以子对象的特性运作。

这里还涉及了一个概念的知识点：动态绑定，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。这就解释了为什么向上转型能够调用子类对象的方法了。

向下转型

所谓向下转型，也就是说父类对象可以转换成子类的对象，但需要注意的是，这时候必须要使用强制类型的转换，举个例子。

代码演示：

package demo;class Animal{public void move(){System.out.println("动物动");}
}class Bird extends Animal{public void move(){System.out.println("鸟儿飞");}public void eat(){System.out.println("鸟儿吃虫子");}
}public class Test {public static void main(String[] args) {Animal animal;Bird bird = new Bird();//将鸟儿对象赋值给animal,调用Bird的move()方法animal = bird;animal.move();//向调用鸟儿吃的方法，无法调用//animal.eat();}
}

代码讲解：我们可以看到鸟类多了一个吃东西的方法，但是在主方法里通过向上转型，animal对象没办法调用子类的eat的方法，这就是精度丢失的问题，这时候我们就需要强制类型转换一下才能够使用

我们修改main()方法

public class Test {public static void main(String[] args) {Animal animal;Bird bird = new Bird();//将鸟儿对象赋值给animal,调用Bird的move()方法animal = bird;animal.move();//向下转型，强制类型转换Bird bird2 = (Bird)animal;bird2.eat();}
}

代码运行结果：

修改后，我们就可以调用子类的方法了

在向下转型中有一点需要注意，上述例子我们通过子类对象赋值给父类对象，通过父类对象去调用子类方法和行为，但有一个问题，我们怎么能够确定我们调用了正确的子类对象的行为呢？即我们怎么确保我们赋值的子类对象使我们想要的呢？java在这问题上给我们提供了一个关键字instanceof,所以我们有必要完善我们的代码，如下：

代码演示：

package demo;  class Animal{  public void move(){  System.out.println("动物动");  }
}  class Bird extends Animal{  public void move(){  System.out.println("鸟儿飞");  }  public void eat(){  System.out.println("鸟儿吃虫子");  }
}  class Fish extends Animal{  public void move(){  System.out.println("鱼儿游");  }  public void eat(){  System.out.println("鱼儿吃");  }
}  public class Test {  public static void main(String[] args) { //声明父类对象，并以子类型实例化Animal animal = new Bird();   //使用instanceof关键字，判断类型是否匹配if(animal instanceof Fish){//向下转型，强制类型转换  Bird bird2 = (Bird)animal;  bird2.eat();}else{System.out.println("类型不匹配");}}
}

代码讲解：instanceof关键字，使用方法对象名 instanceof 类名，即判断对象类型是否与类匹配，如果匹配则返回true，不匹配返回false。

总结点评：面向对象第三大特征多态，多态是在继承上的扩展，一定要区别多态和继承的概念，多态有方法的多态性，即方法的重载和重写，还有对象的多态性，而对象的多态性是通过向上、向下转型实现的。