7、多态

目录

• 多态
  • 什么是多态？
  • java中如何实现多态?使用多态的好处?
  • 多态的存在要有3个必要条件：
  • 为什么需要多态
    • 多态
    • 封装
    • 继承
    • 实现多态的步骤
  • 实现多态的形式
  • 向上转型和向下转型
    • 子类转换为父类：自动转换（向上转型）
    • 父类转换为子类：强制转换（向下转型）
  • 代码案例

多态

什么是多态？

多态性是OOP中的一个重要特性，主要是用来实现动态联编的，换句话说，就是程序的最终状态只有在执行过程中才被决定而非在编译期间就决定了。这对于大型系统来说能提高系统的灵活性和扩展性。

java中如何实现多态?使用多态的好处?

引用变量的两种类型：
编译时类型（模糊一点，一般是一个父类）
public void (Pet pet);
由声明时的类型决定。
运行时类型（运行时，具体是哪个子类就是哪个子类）
由实际对应的对象类型决定。

多态的存在要有3个必要条件：

要有继承，要有方法重写，父类引用指向子类对象

为什么需要多态

多态

含义：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

作用：把不同的子类看成父类来看，可以屏蔽不同子类的差异，写成通用的代码，以适应不同的需求而变化，提高代码的可扩展性和可维护性，还有代码的复用性

提高了程序的可扩展性和可维护性和提高代码复用性

封装

安全
提高代码复用性

继承

提高代码复用性

实现多态的步骤

​ 编写父类
编写子类 子类重写父类方法
运行时,使用父类的类型,子类的对象

实现多态的形式

父类作为参数的时候

public  返回值类型 方法名(父类类型 对象名){
}
public  void feed (Pet pet){
}
 

父类作为返回值类型的时候

//	父类作为方法的返回值类型
	public Pet getPet(int type) {
//	声明一个pet对象
	Pet pet = null;
	switch (type) {
	case 1:
//	父类的引用指向子类的对象
	pet = new Dog("旺财",2,60,"金毛");
	break;
	}
 

向上转型和向下转型

子类转换为父类：自动转换（向上转型）

Dog dog = new Dog();
Pet pet = dog;//自动转换

上转型对象不能操作子类新增的成员变量和方法。
上转型对象可以操作子类继承或重写的成员变量和方法
如果子类重写了父类的某个方法，上转型对象调用该方法时，是调用的重写方法。

父类转换为子类：强制转换（向下转型）

Dog dog = new Dog();
Pet pet = dog;//自动转换
//当父类引用需要调用子类的成员方法的时候，需要用子类的引用才能调用
Dog wangcai = (Dog)pet;//强制类型转换

（绝不是做手术，而是父类的真面目就是一个子类，否则会出现类型转换错误）
为了防止转换出错可以先用 instanceOf 判断类型,再去转换

dog instanceOf pet

代码案例

//父类
package practice;
 
public abstract class Cehicle {
	private String numble;
	private String brand;
	public Cehicle(String numble, String brand) {
		super();
		this.numble = numble;
		this.brand = brand;
	}
	public Cehicle() {
		super();
		// TODO Auto-generated constructor stub
	}
	//计算租金
	public abstract double rant(int day);
	
	public String getNumble() {
		return numble;
	}
	public void setNumble(String numble) {
		this.numble = numble;
	}
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
}
 

//子类----
package practice;
 
public class Cat extends Cehicle{
	private String type;
	
	
	public Cat() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Cat(String numble, String brand, String type) {
		super(numble, brand);
		this.type = type;
	}
	
	//计算租金
	@Override
	public double rant(int day) {
		if("550i".equals(type)) return 600*day;
		if("商务舱".equals(type)) return 800*day;
		return 0;
	}
	
	
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	
}
 

//子类---
package practice;
 
public class Bus extends Cehicle{
	private int numSeating;
	
	public Bus() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Bus(String numble, String brand, int numSeating) {
		super(numble, brand);
		this.numSeating = numSeating;
	}
	//计算租金
	@Override
	public double rant(int day) {
		if(numSeating == 0)return 0;
		if(numSeating > 16) return 1500*day;
		return 900*day;
	}
	public int getNumSeating() {
		return numSeating;
	}
	public void setNumSeating(int numSeating) {
		this.numSeating = numSeating;
	}
}
 

//实现租车的
package practice;
 
public class Customer {
	private String name;
 
	public Customer() {
		super();
		// TODO Auto-generated constructor stub
	}
	//多态的体现
	public double sumRant(Cehicle[] ceh,int day) {
		double sum = 0;
		for (Cehicle cehicle : ceh) {
			sum += cehicle.rant(day);
		}
		return sum;
	}
	public Customer(String name) {
		super();
		this.name = name;
	}
 
	public String getName() {
		return name;
	}
 
	public void setName(String name) {
		this.name = name;
	}
	
}
 

//测试类
package practice;
 
public class RantTest {
	public static void main(String[] args) {
		Cehicle[] arr = {new Cat("粤A0008","宝马","550i"),new Bus("粤A0009","金杯",16)};
		Customer cust = new Customer("小明");
		System.out.println(cust.sumRant(arr, 3));
		
	}
}