黑马程序员_毕向东_Java基础****学习笔记（二十一）

----------------------ASP.Net+Android+IOS开发.Net培训、期待与您交流！----------------------

package day06;

/*
 * 多态：可以理解为事物存在的多种体现形态
 * 
 * 人：男人、女人
 * 动物：猫、狗
 * 猫 x=new 猫();
 * 动物 x=new 猫();
 * 
 * 
 * 1、多态的体现：
 * 		父类的引用指向了自己的子类对象
 * 		父类的引用页可以接收自己的子类对象
 * 2、多态的前提：
 * 		必须是类于类之间有关系，要么继承，要么实现。
 * 		通常还有一个前提：存在覆盖。
 * 3、多态的好处：
 * 		多态的出现大大的提高了程序的扩展性。
 * 4、多态的弊端：
 * 		提高了扩展性，但是只能引用父类的引用访问父类中的成员。
 * 
 * 5、多态的应用：
 * 
 * 6、多态的出现代码中的特点：（多态使用的注意事项）
 * 
 */

/*
 * 需求：动物
 * 猫、狗
 */
abstract class Animal {
	public abstract void eat();
}

class Cat extends Animal {
	public void eat() {
		System.out.println("吃鱼");
	}

	public void catchMouse() {
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal {
	public void eat() {
		System.out.println("吃骨头");
	}

	public void kanJia() {
		System.out.println("看家");
	}
}
class Pig extends Animal {
	public void eat() {
		System.out.println("饲料");
	}

	public void gongDi() {
		System.out.println("拱地");
	}
}

// --------------------------------------------
public class DuoTaiDemo {
	public static void main(String[] args) {
		// Cat c=new Cat();
		// c.eat();

		// Dog d=new Dog();
		// d.eat();
		//Cat c = new Cat();
		//c.eat();
//		Cat c1 = new Cat();
//		function(c1);
//		function(new Dog());
//		function(new Pig());
		function(new Cat());
		function(new Dog());
		function(new Pig());
	}
	public static void function(Animal animal){
		animal.eat();
	}
/*
	public static void function(Cat c) {
		c.eat();
	}
	public static void function(Dog d) {
		d.eat();
	}
	public static void function(Pig p) {
		p.eat();
	}
*/
}

package day06;

abstract class Animal1 {
	public abstract void eat();
}

class Cat1 extends Animal1 {
	public void eat() {
		System.out.println("吃鱼");
	}

	public void catchMouse() {
		System.out.println("抓老鼠");
	}
}

class Dog1 extends Animal1 {
	public void eat() {
		System.out.println("吃骨头");
	}

	public void kanJia() {
		System.out.println("看家");
	}
}
class Pig1 extends Animal1 {
	public void eat() {
		System.out.println("饲料");
	}

	public void gongDi() {
		System.out.println("拱地");
	}
}

// --------------------------------------------
public class DuoTaiDemo2{
	public static void main(String[] args) {
		//Animal a=new Cat();//类型提升，向上转型
		//a.eat();
		//如果想要调用猫的特有方法时，如何操作？
		//强制父类的引用转成子类类型.向下转型
		//Cat c=(Cat)a;
		//c.catchMouse();
		//千万不要出现这样的操作，就是将父类对象转换成子类对象
		//我们能转换的事父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换
		//多态自始至终都是子类对象在做着变化
//		Animal a=new Animal();
//		Cat c=(Cat)a;
		//function(new Cat());
		function(new Cat1());
		function(new Dog1());
	}
	
	
	public static void function(Animal1 animal){
		animal.eat();
		/*
		 * if (animal instanceof Animal1){
		 * 		System.out.println("不能这么做");
		 * }
		 * 原因：因为你无论传什么，只要能接收进来，它全是动物类型，父类型全满足，下面的语句不执行了
		 * 
		 * instanceof关键字的使用情况：1、子类对象有限，例如：男人，女人。
		 * 							  2、当传的类型需要其他操作时，比如比较
		 */
		if(animal instanceof Cat1){
			Cat1 c=(Cat1)animal;
			c.catchMouse();
		}
		else if(animal instanceof Dog1){
			Dog1 d=(Dog1)animal;
			d.kanJia();
		}
		
	}

}

package day06;
/*
 * 基础班的学生：
 * 				学习、睡觉
 * 高级班的学生：
 * 				学习、睡觉
 * 
 * 可将这两类事物进行抽取
 */
abstract class Student{
	public abstract void study();
	public void sleep(){
		System.out.println("躺着睡觉");
	}
}
//单独定义一个类，用来操作调用学生的对象，相当于一个工具类
class DoStudent{
	public void doSome(Student stu){
		stu.study();
		stu.sleep();
	}
}
class BaseStudent extends Student{
	public void study(){
		System.out.println("base study......");
	}
	public void sleep(){
		System.out.println("趴着睡");
	}
}
class AdvStudent extends Student{
	public void study(){
		System.out.println("Adv study......");
	}
}

public class DuoTaiDemo3 {
	public static void main(String [] args){
//		BaseStudent bs=new BaseStudent();
//		bs.study();
//		bs.sleep();
//		AdvStudent as=new AdvStudent();
//		as.study();
//		as.sleep();
		DoStudent ds=new DoStudent();
		ds.doSome(new BaseStudent());
		ds.doSome(new AdvStudent());
	}
	
}

package day06;

class Fu {
	int num = 5;

	void method1() {
		System.out.println("fu method1().......");
	}

	void method2() {
		System.out.println("fu method2().......");
	}

	static void method4() {
		System.out.println("fu method4().......");
	}
}

class Zi extends Fu {
	int num = 8;

	void method1() {
		System.out.println("zi method1()......");
	}

	void method3() {
		System.out.println("zi method3().......");
	}

	static void method4() {
		System.out.println("zi method4().......");
	}
}

public class DuoTaiDemo4 {
	public static void main(String[] args) {
		/*
		 * 在多态(父类的引用指向子类的对象)中成员函数的特点：
		 * 在编译期，参与引用型变量所属的类中是否有调用方法，如果有，编译通过，如果没有编译失败。 在运行期，参阅所属的类中是否有调用的方法。
		 * 
		 * 简单总结：成员函数在多态调用时，编译看左边，运行看右边
		 * 
		 * 面试中出现： 在多态中成员变量的特点： 无论编译和运行，都参考左边。（引用型变量所属的类）
		 * 
		 * 在多态中，静态成员函数的特点： 无论编译和运行，都参考左边。（引用型变量所属的类）
		 */
		// Zi z=new Zi();
		// z.method4();
		Zi.method4();// 静态方法直接用类名调用就行了，静态方法不需要对象

		// System.out.println(z.num);
		// z.method1();
		// z.method3();
		// z.method2();
		// Fu f=new Zi();//静态方法直接用类名调用就行了，静态方法不需要对象
		// f.method4();

		Fu.method4();
		// System.out.println(f.num);
		// f.method1();
		// f.method2();
		// f.method3();
	}
}

----------------------ASP.Net+Android+IOS开发.Net培训、期待与您交流！----------------------