Java多态

概念

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

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

在Java中，多态在广义上来说可以分为编译时多态（方法的多态性）和运行时多态（对象的多态性）。
• 编译时多态（也叫设计时多态，通过方法重载实现）
• 运行时多态（程序运行时动态决定调用哪个方法）
在Java中指的多态，大多指的是运行时多态（狭义上的多态）。

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

补充：如果一个方法的参数（形参）为引用类型，实际参数可以是该引用类型对象或者其子类对象

多态的实现

多态的实现条件：

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

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

Java引用类型变量有两种类型：一种是编译时类型，一种是运行时类型
• 编译的类型是由声明变量的时候确定的
• 运行时的类型是由实际上赋给该变量的对象决定的

多态的定义格式：
定义格式：父类类型 变量名=new 子类类型();
比如：

Animal animal = new Dog();
//Animal animal---对对象的引用，它声明了一个Animal类型的变量animal
//new Dog()---实际上才是真实的对象，等于号=将实际的变量地址赋予给了animal

多态的转型

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

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 类

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

抽象类

被关键字"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 关键字。