目录
多态的基本概念
概念
多态是继封装、继承之后，面向对象的第三大特性。
现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。
Java 作为面向对象的语言，同样可以描述一个事物的多种形态。如 Student 类继承了 Person 类，一个 Student 的对象便既是 Student，又是 Person。
多态的定义与使用格式
多态的定义格式：及时就是父类的引用变量指向子类对象
父类类型 变量名 = 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();
实例
/*
* 多态的前提：
* 子父类的继承关系
* 方法的重写
* 父类引用指向子类对象
* 动态绑定：运行期间调用的方法，是根据其具体的类型
* */
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("猫吃鱼");
}
}
多态成员的特点
A:多态成员变量
当子父类中出现同名的成员变量时，多态调用该变量时：
- 编译时期：参考的是引用型变量所属的类中是否有被调用的成员变量。没有，编译失败。
- 运行时期：也是调用引用型变量所属的类中的成员变量。
简单记：编译和运行都参考等号的左边。编译运行看左边。
B:多态成员方法
- 编译时期：参考引用变量所属的类，如果没有类中没有调用的方法，编译失败。
- 运行时期：参考引用变量所指的对象所属的类，并运行对象所属类中的成员方法。
简而言之：编译看左边，运行看右边
实例
/* * * 多态的成员特点: *
成员变量 编译时看的是左边，运行时看的左边 *
成员方法 编译时看的是左边，运行时看右边 *
静态方法 编译时看的是左边，运行时看的也是左边 *
* * 编译时看的都是左边，运行时成员方法看的是右边，其他（成员变量和静态的方法）看的都是左边 * */
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("我是子类静态方法");
}
}
多态中向上转型与向下转型
多态的转型分为向上转型与向下转型两种：
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("狗刨");
}
}
### 2.5 多态的优缺点
多态的优点
多态的好处
1.提高了代码的可维护性
2.提高了代码的扩展性
多态的作用：
可以当做形式参数，可以接受任意子类对象
多态的弊端：
不能使用子类特有的属性和行为
案例演示：
父类与子类：
class Animal{
public void eat(){
System.out.println("动物吃饭");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
public void CatchMouse(){
System.out.println("猫抓老鼠");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("狗吃骨头");
}
}
主类：
//加入现在需要创建三个猫对象和三个狗对象并使用eat方法，如果我们按照正常的思路：
class Demo_Animal{
public static void main(String[] args) {
Cat c1=new Cat();
Cat c2=new Cat();
Cat c3=new Cat();
Dog d1=new Dog();
Dog d2=new Dog();
Dog d3=new Dog();
c1.eat();
c2.eat();
c3.eat();
d1.eat();
d2.eat();
d3.eat();
}
}
//显然这样写代码冗余，我
们可以先优化一下创建对象和调用方法的过程,把创建对象和调用方法的过程提取成为一个方法
class Demo_Animal{
public static void main(String[] args) {
method(Cat c1);
method(Cat c2);
method(Cat c3);
method(Dog d1);
method(Dog d2);
method(Dog d3);
}
public static void method(Cat c){
c.eat();
}
public static void method(Dog d){
d.eat();
}
}
//这个时候，如果有十个，百个类，猫，狗，猪，牛，羊........我们每次都需要写一个对应的method，这样是不现实的，因
//此我们需要进一步优化，使用多态，把父类当做形参
class Demo_Animal{
public static void main(String[] args) {
method(Cat c1);
method(Cat c2);
method(Cat c3);
method(Dog d1);
method(Dog d2);
method(Dog d3);
｝
public static void method(Animal a){
a.eat();
}
｝
/* * * 多态的优缺点 *
优点：可以提高可维护性（多态前提所保证的），提高代码的可扩展性
缺点：无法直接访问子类特有的成员 */
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("红米打电话");
}
}