Java之多态

Java面向对象
完整代码
什么是多态或者为什么用多态呢？
以我们现在后宫模拟器的需求而言 我们缺少灵魂 那就是皇帝 后宫的一切都是为皇族而服务的
那么我现在有一个需求 那就是要召见后宫的妃子 太医 太监
如果不使用多态我们需要使用对象.方法的方式进行需求的实现 没有一个统一的调用方式会导致后期的维护相当复杂
我们先简单的实现这个需求对多态进行一个初步的了解
多态的形式一般分为两种形式 ：父类类型当做方法参数类型 父类类型当做返回值类型
下面示例使用父类类型当做方法参数类型实现多态
//在Person父类中加入召见方法

	public void Summon() {
		System.out.println("这是一个被召见的方法");		
	}

//在妃子子类中重写这个方法

	//召见
	public void Summon() {
		System.out.println(position+":"+name+"正在被皇帝召见！");
	}

//在医生子类中重写这个方法

	//召见 多态讲解
	public void Summon() {
		System.out.println("太医"+name+"正在被皇帝召见！");
	}

//在宦官子类中重写这个方法

		public void Summon() {
			System.out.println("太监"+name+"正在被皇帝召见！");
		}

//编写皇帝类实现召见需求

public class Emperor {
	//需要传入父类参数 向上转型的方式 进行召见函数操作
	public  void  ESummon(Person person) {
		person.Summon();	
	}
	
}

//在测试类中进行测试 传入不同参数可以实现不同的人

		//多态测试  妃子 医生 宦官对象在上面皆以创建
		//WifeConcubine  lingfei = new WifeConcubine("季凌菲");
		//	Doctors zhanghui = new Doctors();
		//	Eunuch lihei = new Eunuch();
		
		Emperor emperor = new Emperor();
		//同一个方法实现传入不同的参数实现不同的需求
		emperor.ESummon(lingfei);
		emperor.ESummon(zhanghui);
		emperor.ESummon(lihei);

控制台输出

以上便是多态的一个简单的小例子具体的实现方式看以下详细讲述

向上转型

**目的：**将子类对象转换成父类类型 使父类可以调用子父类中共有的函数
形式如下：
父类 变量名 = new 子类对象；
父类类型可以接收子类对象
//上面的示例便是使用了向上转型

//医生对象转换成了父类类型 父类可以调用子类中被重写的函数
Doctors zhanghui = new Doctors();
Person person = zhanghui;
person.Summon();

注重点：
☀ 向上转型 父类中与子类成员变量名相同 输出成员变量 调用的是父类的成员变量
☀ 向上转型 调用父类子类共有的属性和方法 不能调用特有的
☀ 当子类进行方法的重写后，调用的是子类的重写后的方法

instanceof

作用：对对象进行比较 同一对象类型返回true 不同返回false
实例

Doctors zhanghui = new Doctors();
Person person = zhanghui;
person instanceof Eunuch;//将返回false
person instanceof Doctors;//将返回true

向下转型

目的： 实现对子类对象特定方法的调用
使用过程
先进行向上转型

Doctors zhanghui = new Doctors();
Person person = zhanghui;

然后进行向下转型

//向上转型
Doctors zhanghui = new Doctors();
Person person = zhanghui;

//向下转型
Doctors doctors = (Doctors)person;
doctors.cure();//调用医生的特定方法

整个过程实现的是使用Person父类可以接受所有子类的对象 通过对子类对象的判断来确定子类对象的类型 进行强制转换 接收子类对象的信息 然后调用子类对象的特有方法完成相关需求
因此向下转型前提必须要先向上转型 才能实现

使用示例：
需求：后宫既然是为皇帝服务的 那么每个人都有特定的服务方向 比如太医治病 太监养马 妃子侍寝等等 我们可以使用多态和向下转型来完成整个需求

妃子侍寝

	//侍寝
	public void waiter() {
		System.out.println(name+"正在给皇帝侍寝");		
	}

太监养马

	//养马方法
	public void raiseHorses() {
		 System.out.println(name+"正在给皇上养马！");
	}

太医治病

	public void cure() {
		System.out.println(name+"正在给皇上治病");
	}
	

服务方法

	//向下转型 实现对子类特有方法的调用
	//服务方法
	public void  service(Person person) {
		if(person instanceof Eunuch) {
			Eunuch eunuch = (Eunuch) person;
			eunuch.raiseHorses();
		}else if(person instanceof WifeConcubine) {
			WifeConcubine wifeConcubine = (WifeConcubine) person;
			wifeConcubine.waiter();
		}else if(person instanceof Doctors) {
			Doctors doctors = (Doctors)person;
			doctors.cure();
		}else {
			
		}

测试类

		//多态测试  妃子 医生 宦官对象在上面皆以创建
		//WifeConcubine  lingfei = new WifeConcubine("季凌菲");
		//	Doctors zhanghui = new Doctors();
		//	Eunuch lihei = new Eunuch();
		
		Emperor emperor = new Emperor();
		System.out.println("向上转型");	
		emperor.ESummon(lingfei);
		emperor.ESummon(zhanghui);
		emperor.ESummon(lihei);
		
		System.out.println("向下转型");
		emperor.service(lingfei);
		emperor.service(zhanghui);
		emperor.service(lihei);

控制台输出

多态的单例应用

需求
主人有猫、狗、乌龟三种宠物
主人需要给三种宠物喂食 猫吃鱼 狗吃骨头 乌龟吃龟粮
主人和每种宠物有一种特殊的互动 猫和主人玩红外线 狗和主人玩小球 乌龟和主人玩水花

//编写宠物父类

package com.qingsu.polymorphismTwo;

public class Pet {
	
	protected String name;//宠物姓名

	public Pet() {	
	}
	
	public void eat(){
		System.out.println("这是一个公有的吃饭方法");
	}
	
}

编写猫咪子类

package com.qingsu.polymorphismTwo;

public class Cat extends Pet {
	
	//构造函数 初始化宠物姓名
	public Cat(String name) {
		this.name=name;
	}
	
	public void eat() {
		System.out.println("主人正在给猫咪"+name+"喂鱼");
	}
	public void palyRedX() {
		System.out.println(name+"猫咪正在和主人玩红外线");
	}
	
	
}

编写狗狗子类

package com.qingsu.polymorphismTwo;


public class Dog extends Pet {
	

		public Dog (String name) {
			this.name=name;
		}
		public void eat() {
			System.out.println("主人正在给"+name+"狗狗喂骨头");
		}
		
		public void playball() {
			System.out.println(name+"狗狗正在和主人玩球");
		}
}

编写乌龟子类

package com.qingsu.polymorphismTwo;

public class Tortoise extends Pet{
	
	public Tortoise(String name) {
		this.name=name;
	}
	
	public void eat() {
		System.out.println("主人正在给"+name+"乌龟喂龟粮");
	}
	
	public void palySplash() {
		System.out.println(name+"乌龟正在配主人玩水花");
	}
}

编写主人类

package com.qingsu.polymorphismTwo;

public class Master {

	//多态 向上转型  调用共有方法 
	//父类类型当做方法参数类型
	 public void feed(Pet pet) {
		 pet.eat();
	 }
	 
	 //父类类型当做返回值类型
		public Pet getPet(int num,String name) {
			if(num==1) {
				return new Dog(name);
			}else if(num==2) {
				return new Cat(name);
			}else if(num==3) {
				return new Tortoise(name);
			}else {
				return null;
			}
			
		}
	 //多态 向下转型 调用特有方法
	 public void paly(Pet pet) {
		if(pet instanceof Dog) {
			Dog dog = (Dog) pet;
			dog.playball();
		}else if(pet instanceof Cat) {
			Cat cat = (Cat) pet;
			cat.palyRedX();
		}else if (pet instanceof Tortoise) {
			Tortoise tortoise = (Tortoise) pet;
			tortoise.palySplash();
		}
	}
	 
}

编写测试类

package com.qingsu.polymorphismTwo;

public class Test {

	public static void main(String[] args) {
		//实例化对象
		Cat xiaobai = new Cat("小白");
		Dog xiaohei = new Dog("小黑");
		Tortoise xiaolv = new Tortoise("小绿");
		Master master = new Master();
		
		//调用喂食方法
		//父类类型当做方法参数类型
		master.feed(xiaobai);
		master.feed(xiaohei);
		master.feed(xiaolv);
		
		//父类类型当做返回值类型 省去实例化对象
		Pet pet= master.getPet(1,"小白");
		pet.eat();
		pet= master.getPet(2,"小黑");
		pet.eat();
		pet = master.getPet(3,"小绿");
		pet.eat();
		//调用玩耍方法
		master.paly(xiaobai);
		master.paly(xiaohei);
		master.paly(xiaolv);
	}
}

控制台输出

文章是作者面向对象文章的单独拆分如果存在阅读不连续性请参考下文

Java面向对象
完整代码