Java知识点复习：Day11

知识点

1. 多态

多态的转型分为向上转型与向下转型两种

向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的
（当父类引用指向一个子类对象时，便是向上转型。）
使用格式：

父类类型 变量名 = new 子类类型(); 如：

Animal a = new Cat();

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

（一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。）
使用格式：

子类类型 变量名 = (子类类型) 父类变量名; 如:

Cat c =(Cat) a;

1.2 转型

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥 有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子 类特有的方法，必须做向下转型。

---

package com.hg.demo01;

public class Fu {
	public void method() {
		System.out.println("父类方法");
	}
	public void methodFu() {
		System.out.println("父类特有方法");
	}
}

package com.hg.demo01;

import com.hg.demo03.Animal;

public class Zi extends Fu {
		@Override
		public void method() {
			System.out.println("子类方法");
		}
		public void methodZi() {
			System.out.println("子类特有方法");
		}
}

package com.hg.demo01;

public class Demo012Multi {
	public static void main(String[] args) {
		Fu fu  = new Fu();
		fu.method();
		fu.methodFu();
		
		System.out.println("======");
		
		Zi zi = new Zi();
		zi.method();
		zi.methodFu();
		zi.methodZi();
		
		System.out.println("=============");
		
		Fu obj = new Zi();
		obj.method();
		obj.methodFu();
	}
}

---

课堂实例：

package com.hg.demo02;

public class Fu {
	int num = 10;
	
	public void showNum() {
		System.out.println("父类方法"+num);
	}
	public void method() {
		System.out.println("父类方法");
	}
	public void methodFu() {
		System.out.println("父类特有方法");
	}
	
	
}

package com.hg.demo02;

public class Zi extends Fu {
	int num = 20;
	int age = 16;
	
	public void showNum() {
		System.out.println("子类方法"+num);
	}
	public void method() {
		System.out.println("子类方法");
	}
	public void methodZi() {
		System.out.println("子类特有方法");
	}
}

package com.hg.demo02;

public class Demo02MultiField {
	public static void main(String[] args) {
		
		
		// 直接访问 看等号左边的是谁，就用谁，没有则向上找
		Fu obj = new Zi();
		System.out.println(obj.num); // 父 10
		
		 // System.out.println(obj.age); 错误用法
		System.out.println("==========");
		
		// 通过成员方法访问   看该方法属于谁，就用谁
		obj.showNum();
		
		
		
	}
}

package com.hg.demo02;

// 成员方法
// new 的是谁，就先用谁


// 对比
// 成员变量  编译看左边 运行还看左边
// 成员方法  编译看左边 运行 看右边
public class Demo02MultiMthod {
	public static void main(String[] args) {
		
		
		Fu obj = new Zi();
		
		obj.method();
		// obj.methodFu();
		obj.methodFu();
	}
}

---

package com.hg.demo03;

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

package com.hg.demo03;

public class Cat extends Animal {
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
	public void catchMouse() {
		System.out.println("猫抓老鼠");
	}
}

package com.hg.demo03;

public class Dog extends Animal {
	@Override
	public void eat() {
		System.out.println("狗吃骨头");
	}
	
	public void watchHouse () {
		System.out.println("狗看门");
	}
}

package com.hg.demo03;
// 向上类型转换 总是安全的，但是也有缺陷  原来的子类的特有功能就不能使用了

public class Demo03Main {
	public static void main(String[] args) {
		
	// 类似于  隐式类型转换
	Animal animal = new Cat();
	animal.eat();
	
	// aniaml.catchMouse();
	
	// 向下类型转换  由父类型   转换成子类型   还原
	Cat cat = (Cat) animal; // 强制类型转换
	cat.catchMouse();
	
	// java.lang.classCastException
	// Dog dog = (Dog)animal;
	
}
}

package com.hg.demo03;

public class Demo03lnstancof {
	public static void main(String[] args) {
		
	Animal animal = new Dog();
	animal.eat();
	giveMeAPet(animal);
	
	}






public static void giveMeAPet(Animal animal) {
	if(animal instanceof Dog)
	{
		Dog dog = (Dog)animal;
		dog.watchHouse();
	}
	
	if(animal instanceof Cat)
	{
		Cat cat = (Cat)animal;
		cat.catchMouse();
	}
}
}

---

2020080605036