超牛牪犇Java之多态

一.多态的规则

1.类和类之间 必须要有关系(继承关系)

2.必须要有方法的重写(否则多态没有意义)

3.(核心)父类的引用指向子类对象(子类得空间)

需求:创建 动物类 猫类 狗类

都有一个吃的方法 

动物类 动物吃饭 

猫 猫吃鱼 

狗 狗吃骨头

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

多态的写法:

public static void main(String[] args) {
		//本类的引用(指针) 指向 本类的对象(空间)
			Cat cat = new Cat();
			cat.eat();
			//多态的对象创建方式
			//父类指针指向子类空间
			Animal aCat = new Cat();
			aCat.eat();
			Animal aDog = new Dog();
			aDog.eat();
	}

二.多态如何使用成员变量

那么 多如何使用成员变量呢?

父类的引用 只能访问子类空间中属于父类的那块空间

编译:编译时要查看父类中是否有这个属性 没有就编译错误

运行:运行时访问的是父类中的这个成员变量

结论:当使用多态形式创建对象的时候

访问成员变量时 编译和运行 都是看父类中的属性

多态调用成员方法:

编译:编译时 需要看父类中是否有该方法 没有就报错 有就编译通过

运行:运行时 调用的是子类重写父类的方法(子类的方法)

结论:编译看父类运行看子类

public class Demo{
	public static void main(String[] args) {
		//多态的创建形式
		Father fSon = new Son();
		fSon.print();
		System.out.println(fSon.num);
		Son son = new Son();
		son.print();
		System.out.println(son.num);
	}
}
class Father{
	int num = 10;
	public void print() {
		System.out.println("我是父类的打印方法");
	}
}
class Son extends Father{
	int num = 20;
	@Override
	public void print() {
		System.out.println("我是子类的打印方法");
	}
}

三.多态的好处和弊端

多态的好处:

1.减少代码量 提高工作效率(相当于提高了代码的可维护性)(指的是继承)

2.(核心)提高方法的扩展性

多态的弊端:

当使用多态的方式创建对象时

无法直接调用子类中特有的方法

多态调用子类的特有方法时需要注意:

必须要先有向上转型 才能进行向下转型

public class Demo{
	public static void main(String[] args) {
		//提升了子类对象的类型---向上转型
		Person person = new Fraud();
		person.chat();
		//如何调用子类的特有方法
		//把装成人的骗子 打回原形
		//向下转型  ---使用强制类型转换
		Fraud pFraud = (Fraud)person;
		//调用子类的特有方法
		pFraud.fight();
	}
}
class Person{
	public void chat() {
		System.out.println("聊天");
	}
}
class Fraud extends Person{
	public void chat() {
		System.out.println("洗脑");
	}
	//
	public void fight() {
		System.out.println("打人");
	}
}

多态的核心特点:提升方法的扩展性

example:

创建一个武器类 一个剑类 一个刀类

class WuQi{
	public void hit() {
		System.out.println("武器打");
	}
}
class Jian extends WuQi{
	//重写父类方法
	@Override
	public void hit() {
		System.out.println("舞剑");
	}
	//特有方法
	public void lianJian() {
		System.out.println("练剑");
	}
}
class Dao extends WuQi{
	@Override
	public void hit() {
		System.out.println("砍人");
	}
	public void lianDao() {
		System.out.println("练刀");
	}
}

转型:

public class Demo{
	public static void main(String[] args) {
		//测试方法是否扩展
		Jian jian  = new Jian();
		fun(jian);
		Dao dao = new Dao();
		fun(dao);
	}
	//使用多态的方法
	public static void fun(WuQi wuQi) {
		//可以调用子类中重写的方法
		wuQi.hit();
		//判断一下类型
		//根据具体类型 进行向下转型
		//判断wuQi(对象)是否属于Jian(类名)这个类的对象
		if (wuQi instanceof Jian ) {
			//该武器就是一把剑
			//向下转型 成剑
			Jian j = (Jian)wuQi;
			//调用特有的方法
			j.lianJian();
		}else if (wuQi instanceof Dao) {
			Dao d = (Dao)wuQi;
			d.lianDao();
		}
	}
}