Java多态+抽象类

导学

本章节，我们将要学习面向对象三大特性之一的多态，所谓的多态，字面意义来看就是多种形态。它是面向对象程序设置的最核心的特征。从某种意义上来讲，封装和继承都是为了多态而准备的。

多态的概念

在构建对象时，等号左边被称之为对象的引用，等号右边称之为对象

实际上sc时一个对象的名字，sc指向一个具体的对象

多态指的是父类的引用指向的子类对象

造成多态的原因其实是：在堆内存的存储中，子类对象的内存空间套上了一层父类的类型

 

多态：父类引用指向子类对象 准确来说也并不是  这也是众多方法中是其中的一种

 

多态指编译时类型和运行时类型不一致

 

等号左边的：对对象的引用---它声明了***类类型的变量**

等号右边的：实际上才是真实的对象---等于号将实际的变量地址赋值给了**

 

 

在现实生活中，动物都有吃东西，跑和跳等通用的行为能力，但是不同的动物针对行为的表现形式是不同的。比如猫，狗，兔子喜欢吃的东西各有不同，而叫声也是不一样的。

再比如键盘上的f1键，在eclipse的界面会唤出eclipse的帮助文档，在word的界面会唤出word的帮助文档，在Windows系统下回唤出Windows的帮助文档。可以看到同样的行为在不同的对象上会产生不同的形式结果，这就是生活中的多态。
在程序中：

多态意味着允许不同类的对象对同一消息作出不同的响应。

在Java中，多态在广义上来说可以分为编译时多态（方法的多态性）和运行时多态（对象的多态性）。

1. 编译时多态（也叫设计时多态，通过方法重载实现）
2. 运行时多态（程序运行时动态决定调用哪个方法）

在Java中指的多态，大多指的是运行时多态（狭义上的多态）。
多态实现的具体条件在于：

1. 满足继承关系
2. 父类引用指向子类对象

那么，什么是父类引用指向子类对象呢？接下来通过具体代码来看看吧

多态的实现

场景描述及实体类编写

package com.dodoke.proJ.animal;

public class Animal {
	//属性：昵称、年龄
	private String name;
	
	private int month;
	
	//方法：吃东西
	public void eat() {
		System.out.println("动物都有吃东西的能力");
	}
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getMonth() {
		return month;
	}

	public void setMonth(int month) {
		this.month = month;
	}

	public Animal(String name, int month) {
		super();
		this.name = name;
		this.month = month;
	}
	
	public Animal() {
		super();
	}
	
}

package com.dodoke.proJ.animal;

public class Cat extends Animal {
	//属性：体重
	private double weight;

	//方法：跑动
	public void run() {
		System.out.println("小猫快乐的奔跑");
	}
	
	//方法：吃东西
	@Override
	public void eat() {
		System.out.println("猫吃鱼~");
	}
	
	public double getWeight() {
		return weight;
	}

	public void setWeight(double weight) {
		this.weight = weight;
	}
	
	public Cat() {
		super();
	}

	public Cat(String name, int month, double weight) {
		super(name, month);
		this.weight = weight;
	}
}

package com.dodoke.proJ.animal;

public class Dog extends Animal{
	//属性：性别
	private String sex;
	
	//方法：睡觉
	public void sleep() {
		System.out.println("小狗有午睡的习惯");
	}
	
	//方法：吃东西
	@Override
	public void eat() {
		System.out.println("狗吃肉~");
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
	
	public Dog() {
		super();
	}

	public Dog(String name, int month, String sex) {
		this.setMonth(month);
		this.setMonth(month);
		this.sex = sex;
	}
}

多态是指编译时类型和运行时类型不一致

Java引用类型变量有两种类型：一种是编译时类型，一种是运行时类型

• 编译的类型是由声明变量的时候确定的
• 运行时的类型是由实际上赋给该变量的对象决定的

//比如声明变量类型为Animal，实际赋给该变量的对象类型为Dog
Animal animal = new Dog();

向上转型

向上转型是指父类引用指向子类的实例
通常也称向上转型为隐式转型和自动转型。通俗来说，是子类转型为父类，小类转型为大类。

public class Test {
	public static void main(String[] args) {
		//animal的引用  = 具体的animal实例
		Animal one = new Animal();
		Animal two = new Cat();
		Animal three = new Dog();
		
		one.eat();
		two.eat();
		three.eat();
		
		one.getMonth();
		two.getName();
		//three.sleep();
	}
}

父类引用指向子类实例，可以调用子类重写父类的方法以及父类派生的方法，但是无法调用子类独有方法！

父类中的静态方法无法被重写，所以向上转型后，只能调用到父类原有的静态方法

向下转型

向下转型指的是子类引用指向父类对象
向下转型又称之为强制类型转换，通俗来讲就是父类转型为子类，大类转为小类。对比之前的基本数据类型转换，数据范围大的类型转为数据范围小的类型就需要进行强制类型转换，引用数据类型也是如此。

public class Test {
	public static void main(String[] args) {
		//animal的引用  = 具体的animal实例
		Animal one = new Animal();
		Animal two = new Cat();
		Animal three = new Dog();
		
		one.eat();
		two.eat();
		three.eat();
		
		one.getMonth();
		two.getName();
		//three.sleep();
		
		System.out.println("=======================================");
		Cat temp = (Cat)two;
		temp.eat();
		temp.run();
		temp.getMonth();
		
		/**
		 * 此处的代码不能进行强制类型转换
		 * 原因：two这个对象定义的时候，实际上指向的是Cat这个类型的空间
		 * Cat temp = (Cat)two; 相当于把two对象还原成原来的实例空间。
		 * 但是狗和猫并没有兼容的关系，只是拥有同一个父类而已，是兄弟关系
		 */
		Dog temp1 = (Dog)two;//必须满足转型条件才能转换
		temp1.eat();
		temp1.sleep();
		temp1.getMonth();
        System.out.println("程序继续执行");
	}
}

比较：

向上转型	向下转型
又称隐式转型、自动转型	又称强制类型转换
父类引用指向子类实例，可以调用子类重写父类的方法以及父类派生的方法，无法调用子类独有方法	子类引用指向父类对象，此处必须进行强制转换，可以调用子类特有的方法
小类转为大类	必须满足转型条件才能进行转换

instanceof关键字

在之前的章节中，我们提到向下转型需要满足转型条件，那么我们该如何才能知道是否满足转型条件呢
这时候，instanceof关键字就派上用处了！

instanceof关键字用于判断左边的对象是否满足右边的实例。如果满足返回true，否则返回false。

利用多态，实际参数可以是该形参的类型和其子类的类型

在程序设计中存在一种通用性方法设计，这种方法设计可以不限制参数和返回值类型，重点在于使用Object类型作为参数和返回值类型，但是会导致安全性变低。（定义一个方法把返回值和参数定义成Object类型）

public class Test {
	public static void main(String[] args) {
		//animal的引用  = 具体的animal实例
		Animal one = new Animal();
		Animal two = new Cat();
		Animal three = new Dog();
		
		one.eat();
		two.eat();
		three.eat();
		
		one.getMonth();
		two.getName();
		//three.sleep();
		
		System.out.println("=======================================");
		if(two instanceof Cat) {
			Cat temp = (Cat)two;
			temp.eat();
			temp.run();
			temp.getMonth();
			System.out.println("two可以转换为Cat类型");
		}
		
		if(two instanceof Dog) {
			Dog temp1 = (Dog)two;
			temp1.eat();
			temp1.sleep();
			temp1.getMonth();
			System.out.println("two可以转换为Dog类型");
		}
		
		if(two instanceof Animal) {
			System.out.println("Animal");
		}
		
		if(two instanceof Object) {
			System.out.println("Object");
		}
		
		//所以two对象具有Animal类型和Object类型的特征
		
		System.out.println("程序继续执行");
	}
}

类型转换案例

案例

在原有的项目中，增加一个主人类。在猫类中添加玩线球方法

public class Master {
	/**
	 * 喂宠物：
	 * 喂猫咪：吃完东西后，主人会带着去玩线球
	 * 喂狗狗：吃完东西后，主人会带着去睡觉
	 * 养兔子、样鹦鹉、养乌龟
	 */
	//方案一：编写方法，传入不同类型的动物，调用各自的方法
	public void feed(Cat cat) {
		cat.eat();
		cat.palyBall();
	}
	
	public void feed(Dog dog) {
		dog.eat();
		dog.sleep();
	}
	
	//方案二：编写方法传入动物的父类，方法中通过类型转换，调用指定的子类的方法
	public void feed(Animal ani) {
		if(ani instanceof Cat) {
			Cat cat = (Cat)ani;
			cat.eat();
			cat.palyBall();
		} else if(ani instanceof Dog) {
			Dog dog = (Dog)ani;
			dog.eat();
			dog.sleep();
		}
	}
}

多个对象要实现一个方法吃的时候，一般的解决方法是写重载函数。
而新的解决方法是用一个方法传参的时候先向上转化成父类， 然后再根据实际情况进行判断后，转化成原来的类型 ，在调用自己本身的方法 （向下转型）

新增需求

针对主人空闲时间的判断，如果时间多则养狗，如果时间少则养猫。

package com.dodoke.proJ.animal;

public class Master {
	//方案一
	public Dog hasManyTime() {
		System.out.println("主人空闲时间充足，适合养狗狗");
		return new Dog();
	}
	
	public Cat hasLittleTime() {
		System.out.println("主人空闲时间比较少，适合养猫咪");
		return new Cat();
	}
	
	//方案二
	public Animal raise(boolean isManyTime) {
		if(isManyTime) {
			System.out.println("主人空闲时间充足，适合养狗狗");
			return new Dog();
		} else {
			System.out.println("主人空闲时间比较少，适合养猫咪");
			return new Cat();
		}
	}
}

在方法内部实现多态。返回值为子类对象，由父类引用接收。相当于Animal animal=new Cat();向上转型。
当我们在实际开发当中需要同一个操作行为，针对不同的参数， 返回不同的实例对象，完成不同的操作结果的时候，就比较适用于这种多态的操作。类型转换的优势就会充分体现出来了。

抽象类

用abstract修饰的类统称为抽象类

抽象类不允许被实例化

抽象类表示我这个类仅仅用来规范子类

抽象类可以通过下面向上转型，指向子类实例，调用子类重写父类的方法以及派生的放啊

 

应用场景：某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法

 

抽象和类中可以没有抽象方法，但是一个类中出现抽象方法，这个类肯定是抽象类

用abstract修饰的，并没有方法体的方法叫做抽象方法

方法体（即没有大括号和其中的内容）

 

在之前的代码中，我们创建了一个动物类。接下来，我们来看看这段代码

Animal pet = new Animal("花花",2);
pet.eat();

针对于这样的代码，编译运行都没有什么问题，但是它在实际的开发中并没有有效的意义。每个动物都应该有具体的吃东西的行为，实例化pet对象没有意义。实际的开发中会指代具体的猫还是狗来完成指代。如上的代码并不符合程序的逻辑。
那么，该如何限制程序员写这些没有意义的代码呢？
我们可以使用abstract关键字来限制类的实例化。

abstract 是不能修饰成员变量的；

抽象类

public abstract class Animal {}
abstract public class Animal {}

抽象数据类型： 在类的定义前加上 abstract 关键字，使得该类成为一个抽象类
抽象类不允许被实例化，但是可以通过向上转型，指向子类实例，调用子类重写父类的方法以及父类派生的方法
public 与 abstract可以互换，但是却不能 与class关键字相互换位。
抽象类利用子类与父类的继承关系，既限制了子类的设计随意性，又避免了父类无意义的实例化。

应用场景：某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法

抽象方法

public abstract class Animal {
	//属性：昵称、年龄
	private String name;
	
	private int month;
	
	/**
	 * 抽象方法：没有方法体，在子类中必须重写抽象方法，如果子类不重写，则子类只能设置为抽象类
	 */
	public abstract void eat();
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getMonth() {
		return month;
	}

	public void setMonth(int month) {
		this.month = month;
	}

	public Animal(String name, int month) {
		super();
		this.name = name;
		this.month = month;
	}
	
	public Animal() {
		super();
	}
	
}

含有抽象方法的类，只能被定义为抽象类。抽象类中不一定含有抽象方法。
在抽象类中的成员方法可以包括一般方法和抽象方法。
抽象类不能实例化，即使抽象类中不包含抽象方法，这个抽象类也不能创建实例。
一个类继承抽象类后，必须实现其所有的抽象方法，否则也是抽象类，不同的子类对父类的抽象方法可以有不同的实现。

如果方法定义为 static，就不能使用 abstract 修饰符；
如果方法定义为 private ，也不能使用 abstract 修饰符；

抽象类体现的是一种模板模式的设计思想，抽象类作为多个子类的通用模板，子类在抽象的基础上进行扩充，但是子类整体上会保留抽象类的行为方法（必须要实现抽象类的抽象方法）。

抽象类一般只是定义需要使用的方法，把不能实现的部分抽象成抽象方法，留给子类去实现。

父类中可以有实现的方法，但是子类也是可以对已经实现的方法进行改造的（override），但是如果在子类中还需要调用父类的实现方法，可以使用 super 关键字。