Java学习之多态

Java面向对象的四大特性： 继承、封装、多态、抽象

多态

同一个对象 体现出来的多种不同形态(身份) 将一种行为表现出不同的效果
想要实现多态的效果 需要现有继承关系

体现

父类类型的引用 指向 子类的对象 向上转型
　　 Person p = new Teacher();

该引用只能调用父类中定义的 属性和方法

如果子类中重写了父类方法，那么调用的是子类重写后的 方法
　　如果父类与子类有同名的属性 执行父类的属性
　　如果父类与子类有同名的方法 执行子类的方法

如果想要调用子类独有的属性或方法
　　需要将类型还原成真实类型 强制类型转化 向下转型
　　 Teacher t = (Teacher p)

强制向下转型时可能会出现一个运行时异常
ClassCastException 造型 异常
所以需要进行判断 instanceof 判断对象是否属于后面类型
对象 instanceof 类

============================================================================================================
设计一个类 银行 有叫号，取钱，存钱方法
设一个类 Person 类 有name
三个子类继承 Person类 OldMan 类，YoungMan类 Toff类(土豪类)
银行依赖于人类，所以银行类有一个属性是Person

// 定义一个抽象类
public abstract class Person {
	protected String name;
	public String getName() {
		return this.name;
	}
	// 定义抽象方法
	public abstract void callName();
	public abstract void transact();
	public abstract void leave();
}
// 继承父类，对父类抽象方法进行重写
public class OldMan extends Person {
	public OldMan() {}
	public OldMan(String name) {
		this.name = name;
	}
	public void callName() {
		System.out.println("年纪大了，不会取号，需要找大堂经理帮忙");
	}
	public void transact() {
		System.out.println("存养老金");
	}
	public void leave() {
		System.out.println("大堂经理送老人家出门");
	}
}
// 继承父类，对父类抽象方法进行重写
public class YoungMan extends Person{
	
	public YoungMan() {}
	public YoungMan(String name) {
		this.name = name;
	}
	public void callName() {
		System.out.println("年纪人，自己取号");
	}
	public void transact() {
		System.out.println("存工资");
	}
	public void leave() {
		System.out.println("自己出去");
	}
}
// 继承父类，对父类抽象方法进行重写
public class Toff extends Person{
	
	public Toff() {}
	public Toff(String name) {
			this.name = name;
	}
	
	public void callName() {
		System.out.println("土豪不用取号，进VIP通道");
	}
	public void transact() {
		System.out.println("转账一个亿");
	}
	public void leave() {
		System.out.println("大摇大摆出门");
	}
}

public class Bank{
	//父类作为参数传递
	public void profession(Person person) {
		System.out.println("欢迎"+person.getName()+"!");
		//因为每个子类对方法进行了重写，所以调用的是子类的方法
		person.callName();
		person.transact();
		person.leave();
	}	
	//这种方法避免了每出现一个新的子类就要在Bank中重新写一个方法
	/*
	public void profession(OldMan ol) {
		System.out.println("欢迎"+ol.getName()+"!");
		ol.callName();
		ol.transact();
		ol.leave();
	}
	*/
}

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Bank bank = new Bank();
		
		Person p = new OldMan("老年人");
		bank.profession(p);
		
		Person p1 = new YoungMan("年轻人");
		bank.profession(p1);
		
		Person p2 = new Toff("土豪");
		bank.profession(p2);

	}
}
/*
欢迎老年人!
年纪大了，不会取号，需要找大堂经理帮忙
存养老金
大堂经理送老人家出门
欢迎年轻人!
年纪人，自己取号
存工资
自己出去
欢迎土豪!
土豪不用取号，进VIP通道
转账一个亿
大摇大摆出门
*/

调用一个方法 名字一样 传递参数却不同
1.利用方法重载----静态加载
2.利用多态效果----动态加载