多态

多态

用父类的引用指子向类的对象

• 一种事物的多种形态 狗–动物–生物 学生–高级动物–动物–生物

• 多态的前提：类与类之间一定要有继承的关系

• 优点：可以提高代码的扩展性，使用之前定义好的功能，后边直接拿 ，而不用再去创建新的方法

• 缺点：不能直接调用特有的方法，只能调用父类有的方法

• 一个程序运行的时候分成三个阶段：

  • 预编译：程序打开的时候，活已经干完了.（预处理命令 #define）
  • 编译：从打开程序开始到点击左上角的三角之前的阶段—只会识别 * 用类型，不会去识别=后面的对象
  • 运行：从点击三角开始—这里才会去真正识别=后面的真正对象

public class Demo6 {
	public static void main(String[] args) {
		//使用继承--使用子类的引用工作
		Dog1 dog = new Dog1();
		dog.play();
		dog.show();
		
		//注意：这里说的父类不是单指直接的父类，只要是父类即可
		Animal1 animal = new Dog1();
	
		animal.play();
		//animal.show();//调用方法的工作机制：1.首先由animal找到Dog对象，Dog对象再去调用show方法
		//不能通过的原因：因为在编译的时候识别的是引用类型，不识别对象.所以只能识别出animal特有的方法，不能调用子类特有的方法
	
	}
}

class Animal1{
	String name;

	public Animal1(String name) {
		super();
		this.name = name;
	}

	public Animal1() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	public void play() {
		System.out.println("play");
	}
}

class Dog1 extends Animal1{
	public void show() {
		System.out.println("show-dog");
	}
}
class Cat1 extends Animal1{
	public void show() {
		System.out.println("show-cat");
	}
}

向上转型和向下转型

• 前提：这里一定是多态
• 父类的类型比子类的类型的等级高
• 向上转型：相当于自动类型转换，由低类型到高类型
• 注意：是将子类的引用转成父类的引用，但是只是将=前面进行转换，与等号后面无关
• 向下转型：相当于强制类型转换，由高类型到低类型
• 注意：是将父类的应用强制转换成子类的引用.

public class Demo8 {
	public static void main(String[] args) {
		//向上转型
		Animal3 animal = new Dog3();//多态
		
		//向下转型---为了调用子类特有的方法
		Dog3 dog = (Dog3)animal;
		dog.show();//调用子类特有的方法
		
		//注意点：
		//1.这里补交向上转型，这是错误.不能使用子类的引用指向父类的对象
		//Dog dog2 = new Animal3();
		
		//2.这里不是多态，所以不是向下转型，向下转型的前提是多态
		//Animal3 animal2 = new Animal3();
		//Dog3 dog3 = (Dog3)animal2;
		
	}
}

class Animal3{
	String name;

	public Animal3(String name) {
		super();
		this.name = name;
	}

	public Animal3() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	public void play() {
		System.out.println("play");
	}
}

class Dog3 extends Animal3{
	public void show() {
		System.out.println("show-dog");
	}
}
class Cat3 extends Animal3{
	public void show() {
		System.out.println("show-cat");
	}
}

instanceof 运算符

• 容错处理：包容这块出错的代码，不让他影响后面正常代码的执行---- * 用户体验
• instanceof构成：对象 instanceof 类
• 作用：确定前面的对象是否是后面的类或子类的对象 返回值有两个
  • true
  • false

public class Demo9 {
	public static void main(String[] args) {
		Dog4 dog = new Dog4();
		Cat4 cat = new Cat4();
		
		feedAnimal(cat);
	}
	
	public static void feedAnimal(Animal4 animal) {
		animal.eat();
		
		//容错处理：包容这块出错的代码，不让他影响后面正常代码的执行------增加用户体验
		//instanceof构成：对象  instanceof  类，  作用：确定前面的对象是否是后面的类或子类的对象   返回值有两个
		//是  true  不是   false
		/*
		 * 注意点：
		 * 1.instanceof前后必须由继承关系
		 */
		if(!(animal instanceof Dog4)) {
			
			System.out.println("传入的对象不是Dog4 或子类的对象");
			System.exit(0);
		}
		
		//向下转型
		Dog4 dog = (Dog4)animal;
		dog.show();
	}
	public void eat() {
		System.out.println("animal-eat");
	}
}

class Animal4{
	String name;

	public Animal4(String name) {
		super();
		this.name = name;
	}

	public Animal4() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	public void play() {
		System.out.println("play");
	}
	
	public void eat() {
		System.out.println("animal-eat");
	}
}

class Dog4 extends Animal4{
	public void show() {
		System.out.println("show-dog");
	}
	public void eat() {
		System.out.println("dog-eat");
	}
}
class Cat4 extends Animal4{
	public void show() {
		System.out.println("show-cat");
	}
	
	public void eat() {
		System.out.println("cat-eat");
	}
}

成员在多态下的使用

多态下:

• 当父类与子类定义了同名的属性：成员变量编译的时候看父类，运行还是看父类
• 成员方法：编译的时候看父类，运行的时候看子类
• 静态的成员方法：编译运行都看父类

public class Demo10 {
	public static void main(String[] args) {
		//继承当中成员的使用
		Zi zi = new Zi();
		System.out.println(zi.age);//3  说明在继承下，以子类的优先
		
		Fu fu = new Zi();
		System.out.println(fu.age);
		fu.eat();
		
		
		}
}

class Fu{
	int age = 5;
	public void eat() {
		System.out.println("eat");
	}
	
	public void play() {
		System.out.println("play");
	}
	
}

class Zi extends Fu{
	int age = 3;
	
	public void show () {
		System.out.println("show");
	}

}