java多态特性

多态:用父类的引用指向子类的对象

package com.qianfeng.test;

/*

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

• 多态的前提:类与类之间一定要有继承的关系
  */
  public class Demo6 {

  public static void main(String[] args) {

   // 使用继承--使用子类的引用工作
   Dog dog = new Dog();
   dog.play();// 调用父类的方法
   dog.show();// 调用自己的方法
  
   // 多态:用父类的引用指向子类的对象
   // 注意:这里说的父类不是单指直接的父类,只要是父类即可
   Animal animal = new Dog();
   /*
    * 一个程序运行的时候分成三个阶段: 预编译:程序打开的时候,活儿已经干完了. (预处理命令 #define)
    * 编译:从打开程序开始到点击左上角的三角之前的阶段.----只会识别=前面的引用类型,不会去识别=后面的对象.
    * 运行:从点击三角开始.----这里才会去真正识别=后面的对象.
    */
   animal.play();
   // animal.show();//调用方法的工作机制:1.首先由animal找到Dog对象,Dog对象再去调用show方法
   // 不能通过的原因:在编译的时候识别的是引用类型,不识别对象.所以只能识别出animal特有的方法,不能调用子类特有的方法.
  
   /*
    * 优点:可以提高代码的扩展性,使用之前定义好的功能,后面直接拿来使用,而不用再去创建新的方法.解释在Demo7
    * 缺点:不能直接调用子类特有的方法,只能调用父类有的方法
    */
  

  }
  }

class Animal {
String name;

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

public Animal() {
	super();
	// TODO Auto-generated constructor stub
}

public void play() {
	System.out.println("Animal-play");
}

}

class Dog extends Animal {

public void show() {
	System.out.println("Dog-show");
}

}

class Cat extends Animal {

public void eat() {
	System.out.println("Cat-eat");
}

}

---

多态的优点:可以提高代码的扩展性,使用之前定义好的功能,后面直接拿来使用,而不用再去创建新的方法。

package com.qianfeng.test;

/*

• 优点:可以提高代码的扩展性,使用之前定义好的功能,后面直接拿来使用,而不用再去创建新的方法.解释在Demo7
  */
  public class Demo7 {

  public static void main(String[] args) {

   Dog1 dog1 = new Dog1();
   Cat1 cat1 = new Cat1();
   Animal1 animal1 = new Animal1();
  
   // feedDog(dog1);
   // feedCat(cat1);
   feedAnimal(dog1);
   feedAnimal(cat1);
   feedAnimal(animal1);
  

  }

  public static void feedAnimal(Animal1 animal) {// animal = dog1 = new Dog1()
  //多态

   animal.eat();
  

  }

  // public static void feedDog(Dog1 dog1) {
  // dog1.eat();
  // }
  //
  // public static void feedCat(Cat1 cat1) {
  // cat1.eat();
  // }
  }

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("Animal1-play");
}

public void eat() {
	System.out.println("动物吃");
}

}

class Dog1 extends Animal1 {

public void show() {
	System.out.println("Dog1-show");
}

public void eat() {
	System.out.println("狗吃");
}

}

class Cat1 extends Animal1 {

public void eat() {
	System.out.println("Cat1-eat");
}

}

---

向上转型与向下转型

package com.qianfeng.test;

/*

• 前提:这里一定是多态
• 父类的类型比子类的类型等级高
• 向上转型:相当于自动类型转换,由低类型到高类型

•  	注意:是将子类的引用转成父类的引用,但是只是将=前面进行转换,与=后面无关
  

• 向下转型:相当于强制类型转换,由高类型到低类型

•  	注意:是将父类的引用强制转换成子类的引用.
  

*/
public class Demo8 {

public static void main(String[] args) {

	// 向上转型
	Animal2 animal2 = new Dog2();// 多态

	// 向下转型--为了调用子类特有的方法
	Dog2 dog2 = (Dog2) animal2;
	dog2.show();// 调用子类特有方法

	// 注意点:
	// 1.这里不叫向上转型,这是错误.不能使用子类的引用指向父类的对象.
	// Dog2 dog22 = new Animal2();

	// 2.这里不是多态,所以不是向下转型,向下转型的前提是多态
	Animal2 animal22 = new Animal2();
	Dog2 dog22 = (Dog2) animal22;
}

}

class Animal2 {

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

public Animal2() {
	super();
	// TODO Auto-generated constructor stub
}

public void play() {
	System.out.println("Animal2-play");
}

}

class Dog2 extends Animal2 {

public void show() {
	System.out.println("Dog2-show");
}

}

class Cat2 extends Animal2 {

public void eat() {
	System.out.println("Cat2-eat");
}

}

---

intstanceof关键字

package com.qianfeng.test;

public class Demo9 {

public static void main(String[] args) {

	Dog3 dog3 = new Dog3();
	Cat3 cat3 = new Cat3();

	feedAnimal(cat3);
}

public static void feedAnimal(Animal3 animal3) {// animal3 = dog3 = new
												// Dog3() 多态
	// animal3.eat();

	// 容错处理:包容这块出错的代码,不让他影响后面正常代码的执行-----增加用户体验
	// intstanceof本身是一个运算符.构成: 对象 instanceof 类 ,作用:确定前面的对象是否是后面的类或子类的对象
	// 返回值有两个:如果是返回true
	// 不是:返回false
	// 注意点:
	// 1.instanceof前后必须有继承关系
	if (!(animal3 instanceof Dog3)) {
		System.out.println("传入的对象不是Dog3或子类的对象");
		System.exit(0);// 退出程序
	}

	// 向下转型
	Dog3 dog3 = (Dog3) animal3;
	dog3.show();// 调用子类特有的方法

	System.out.println("继续");

}

}

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("Animal3-play");
}

public void eat() {
	System.out.println("animal-eat");
}

}

class Dog3 extends Animal3 {

public void show() {
	System.out.println("Dog3-show");
}

public void eat() {
	System.out.println("Dog3-eat");
}

}

class Cat3 extends Animal3 {

public void eat() {
	System.out.println("Cat3-eat");
}

}

---

成员在多态下的使用

package com.qianfeng.test;

/*
*成员在多态下的使用
*/
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);// 5
	fu.eat();
	Fu.play();
}

}

class Fu {
int age = 5;

public void eat() {
	System.out.println("eat");
}

public static void play() {
	System.out.println("Fu-play");
}

}

class Zi extends Fu {
int age = 3;

public void show() {
	System.out.println("Zi-show");
}

public static void play() {
	System.out.println("Zi-play");
}

}