Java多态的成员特点及优缺点详解

Bertha 。 2023-10-07 08:32 14阅读 0赞

## 多态概述 ##

> 多态是继封装、继承之后，面向对象的第三大特性。
> 
> 现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。
> 
> 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("狗刨");
    	}
    }

## 多态的优缺点 ##

>  \*  多态的优缺点
> 
>  \*  优点：可以提高可维护性（多态前提所保证的），提高代码的可扩展性
> 
>  \*  缺点：无法直接访问子类特有的成员

### 案例四：多态的优缺点 ###

package com.itheima_01;
    /*
     *	
     * 	多态的优缺点
     * 		优点：可以提高可维护性（多态前提所保证的），提高代码的可扩展性
    		缺点：无法直接访问子类特有的成员
     */
    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("红米打电话");
    	}
    }