面对对象之多态-----多态基础

多态基础

1. 多态，事物的多种形态

1） 同一个行为具有多种不同的表现形式或形态的能力
2）一个引用变量会指向哪个类的实例对象，该引用变量发出来的方法调用是哪个类中实现的方法，必须在程序运行期间才能决定。

2. 实现多态的三个必要条件

1）父子类
2）重写（子类重写父类方法）
3）向上转型（重点）
父类 变量 = new 子类

酒 五粮液 = new 五粮液();
		五粮液.喝酒();

向上转型的好处：子类是父类的扩展，它可以提供比父类更强大的功能，如果我们定义了一个指向子类的父类的引用，那么它除了能引用父类的共性外，还可以使用子类的强大功能。

3. 多态实例

/**
 *多态的意义:编译时并不确定该程序指什么,只有运行时才知道
 *
 */
public class 多态案列 {
	public static void main(String[] args) {
		//向上转型
		Animal animal1 = new Dog();
		animal1.eat();
		//多态局限性,不能调用子类的扩展方法
		//animal1.lookDoor();
		
		Animal animal2 = new Cat();
		animal2.eat();
	}

}
//1：父子关系
//2：方法重写
//3：向上转型(父类有一个引用去指向子类)
abstract class Animal {
	public abstract void eat() ;
		
}
class Dog extends Animal{
	//方法重写标志
	@Override
	public void eat() {
		System.out.println("Dog吃骨头");
	}
	public void lookDoor() {
		System.out.println("看门");
	}
}
class Cat extends Animal{

	@Override
	public void eat() {
		System.out.println("猫吃鱼");
		
		
	}
	
	
}

注意：Animal作为父类，无法访问子类中自己定义的的扩展的方法。

• 使用多态完成主人喂猫、狗吃东西的功能，要求喂猫和喂狗只能由一个方法

public class 多态案列{
	public static void main(String[] args) {

	    Animal animal1= new Dog();
	    animal1.name = "二哈";
	    Animal animal2= new Cat();
	    animal2.name = "二淼";
		Master master = new Master();
		master.feed(animal2);
		master.feed(animal1);
		
	}

}
abstract class Animal {
	String name;
	public abstract void eat() ;
		
}
class Dog extends Animal{
	//方法重写标志
	@Override
	public void eat() {
		System.out.println("Dog吃骨头");
	}
	public void lookDoor() {
		System.out.println("看门");
	}
}
class Cat extends Animal{

	@Override
	public void eat() {
		System.out.println("猫吃鱼");
		
	}
}

//	主人喂食（多态的真正运用）
class Master{
	public void feed(Animal animal){
			System.out.println("准备喂" +  animal.name+"吃");
			animal.eat();
			System.out.println( animal.name + "吃完了");
		
}
}
	

4. 多态的表现形式

1）基于继承
采用抽象类来做，必须有继承关系，抽象类中定义的抽象方法，子类继承抽象类后覆写抽象类中的方法，达到多态效果。

public abstract class 酒 {
		public abstract void 喝酒();
}

public class 剑南春 extends 酒{
	@Override
	public void 喝酒() {
		System.out.println("喝剑南春");	
	}
}

2）基于接口
必须是指定这实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。

public interface 酒 {
	public abstract void 喝酒();	
}

public class 剑南春 implements 酒{
	@Override
	public void 喝酒() {
		System.out.println("喝剑南春");	
	}
}

5.多态继承链调用优先级

在继承链中对象方法的调用存在一个优先级，有优先级顺寻如下：

• this.show( O);
• super.show(O);
• this.show(super)O)
• super.show(super)O)

上述字符描述如下：

• this: 当前类对象
• show: 执行方法
• O: 对象参数
• super: 父类

如下代码输出什么？？

class Parent{
	public void show(Parent parent) {
		System.out.println("Parent类中的Parent类型的参数方法");
	}
	public void show(ChildB childB) {
		System.out.println("Parent类中的ChildB类型的参数方法");
	}
}
class ChildA extends Parent{
	
	public void show(Parent parent) {
		System.out.println("ChildA类中的Parent类型的参数方法");
	}
	
	public void show(ChildA childA) {
		System.out.println("ChildA类中的childA类型的参数方法");
	}
}
class ChildB extends ChildA {
	
}