[Java知识库]Java中的多态

一、语法机制：

1.Anima、Cat、Bird三个类之间的关系：
Cat继承Animal
Bird继承Animal
Cat和Bird之间没有任何继承关系
2.面向对象的三大特征：封装，继承，多态。
3.关于多态的概念：

• 向上转型（upcasting）
  子类型—>父类型
  又被称为：自动类型转换
• 向下转型（downcasting）
  父类型—>子类型
  又称为强制类型转换。【需要加强制类型转换符】
  需要记忆：无论是向下转型还是向上转型，两者之间都必须要有继承关系。
  没有继承关系，程序是无法编译运行通过的。

package test001;

import sun.print.PrintJob2D;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Animal a1 = new Animal();
		a1.move();
		Cat c1= new Cat();
		c1.move();
		c1.catchMouse();
		Bird b1 = new Bird();
		b1.move();
		//使用多态语法机制
		/* 1.Animal和Cat之间存在继承关系
		 * 2.Cat is a animal
		 * 3.new Cat（）创建对象的类型是Cat，a2这个引用数据类型是Animal，可见他们进行了类型转换
		 * 子类型转换为父类型，称为向上转型/upcasting,或称为自动类型转换。
		 * 4.Java中允许父类型引用指向子类型的对象*/
		Animal a2=new Cat();
		/* 1.java分为编译阶段和运行阶段
		 * 2.先分析编译阶段，再分析运行阶段，编译无法通过，根本无法运行的。
		 * 3.编译阶段编译器检查a2引用的数据类型为animal，
		 * 由于字节码中又move方法 所以编译通过。这个阶段我们称为静态绑定，百衲衣阶段绑定。
		 * 只有绑定成功之后才会有后续的运行
		 * 4.在程序运行阶段，jvm堆内存中真实创建的对象是Cat对象，那么一下程序运行阶段一定
		 * 会调用Cat对象的move()方法，此时发生了程序动态的绑定，运行阶段运行绑定
		 * 5.无论Cat类有没有重写Move方法，运行阶段一定调用的是Cat对象的move方法，因为底层真实的对象就是Cat对象。
		 * 6.父类型引用指向子类型对象这种机制导致程序存在编译绑定和运行阶段绑定两种不同的形态或状态
		 * 这种机制可以成为一种多态的语法机制*/
		a2.move();
		/* 分析下一语句不能运行的原因： 
		 * 因为在编译阶段编译器检查到a2的类型是Animal类型，
		 * 从Animal.class 字节码文件当中查找catMoyse()
		 * 方法最终没有找到该方法，导致静态绑定失败，也就是说编译失败。*/
		//a2.catchMouse();
		/*
		 * 需求：
		 * 假设想让以上对象执行catchMouse（）方法，怎么办？
		 * a2是无法调用的，因为a2的类型Animal，Animal中没有catchMouse（）方法。
		 * 我们可以将a2强制类型准换为Cat类型。
		 * a2的类型是Animal（父类）转换成Cat类型（子类），向下转型/downcasting/强制类型转换。
		 * 注意：向下转型也需要两种类型之间必须又继承关系，不然编译报错。强制类型转换需要加强制类型转换符。
		 * 	当调用的方法，访问的属性是子类型中特有的，在父类型中不存在，必须向下转型。
		 */
		Cat c2=(Cat)a2;
		c2.catchMouse();
		
		
		Animal a3 = new Bird();
		/* 类型转换异常，总是在向下转型时候会发生， */
		Cat a3=(Cat)a3;
		/**
		 * 1.以上异常只有在强制类型转换的时候会发生，也就是说向下转型存在安全隐患！（编译过了，但是运行错了）
		 * 2.向上转型只要编译通过运行一定不会出问题。
		 * 3.向下转型编译通过，运行可能错误Animal a3 = new Bird();Cat a3=(Cat)a3;
		 * 4.如何避免，使用instanceof运算符可以避免：
		 * 5.instanceof运算符怎么用：
		 * （1）语法格式:
		 * (引用 instanceof 数据类型名)
		 * （2）以上运算符的执行结果类型是布尔类型
		 * （3）关于运算结果：（a instanceof Animal）
		 * 	true表示：a这个引用指向的对象是一个Animal类型
		 * false表示：a这个引用不是一个Animal类型。
		 * 6.java规范中在强制类型转换之前，建议采用instanceof运算符进行判断*/
		if(a3 instanceof Cat) {
			Cat c3=(Cat)a3;
			c3.catchMouse();
		}
		else if(a3 instanceof Bird) {
			Bird b2 = (Bird)a3;
			b2.fly();
		}
	}

}

package test001;

public class Bird extends Animal {

	@Override
	public void move() {
		System.out.println("鸟儿在飞翔");
	}
	public void fly() {
		System.out.println("鸟儿在飞翔");
	}
}

package test001;

public class Cat extends Animal {

	@Override
	public void move() {
		// TODO Auto-generated method stub
		System.out.println("猫在走猫步");
	}
	public void catchMouse() {
		System.out.println("猫可以抓老鼠");
	}

}

package test001;

public class Animal {
	public void move() {
		System.out.println("动物在移动");
	}
}

二、多态在实际开发中的作用：

package test002;

public class Test {
	/* 主人喂养宠物： 
	 * 1.分析：实现类的抽象
	 * -主人类：
	 * -主人喂养宠物，所以主人要有喂养这个动作
	 * -宠物类
	 * -宠物可以吃东西，所以宠物有吃东西这个动作
	 * 2.面向对象编程的核心：定义好类，然后将类实例化为对象，给一个环境驱使一下，让各个对象之间协作起来形成一个系统。
	 * 3.多态的作用
	 * 降低程序的耦合度，提高程序的扩展能力
	 * 能使用多态尽量使用多态。
	 * 父类型引用指向子类型对象。
	 * 核心：抽象编程，尽量不要具体编程
	 * */

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Master master=new Master();
//		Cat Tom =new Cat();
//		master.feed(Tom);
		master.feed(new Cat());
//		Dog erhaDog= new Dog();
//		master.feed(erhaDog);
		master.feed(new Dog());
		Snake mangshi=new Snake();
		master.feed(mangshi);
	}

}

package test002;
//宠物
public class Pet {
	public void eat() {
		
	}
}

package test002;

/*没有使用多态机制，存在的缺点：Master的扩展能力很差，因为，只要加一个
 * 新的宠物，Master类就需要添加新的方法。*/
//public class Master {
//	public void feed(Cat c) {
//		c.eat();
//	}
//	public void feed(Dog d) {
//		d.eat();
//	}
//}
//降低程序的耦合度，提高程序的扩展能力【软件开发很重要的目标】
public class Master {
	//Master主人类面向的是一个抽象的Pet,不再面向具体的宠物
	//提倡面向抽象编程，不需要面向具体编程。
	//面向抽象的编程的好处是，耦合度底，扩展能力强
	public void feed(Pet pet) {//Pet pet父类型的引用
		pet.eat();
	}
	
}

package test002;
//宠物小猫

public class Cat extends Pet {
	public void eat() {
		System.out.println("小猫在吃鱼");
	}
}

package test002;

public class Dog extends Pet {
	public void eat() {
		System.out.println("小狗正在啃骨头");
	}
}

package test002;

public class Snake extends Pet {
public void eat() {
	System.out.println("蛇吞象");
}
}