1.多态和instanceof
都是去买东西，但是根据我们给别人金额的不同，得到不同的结果！！！！ 生活中的多态！
操作是否一致？ 一致！ 都是买东西！
什么不一样？？
01.消费金额不一样
02.因为消费金额不一样 所以 得到的东西不一样
程序中的多态：
01.静态的多态 方法重载
String buySomething();
String buySomething(double money);
String buySomething(double money,String something);
02.动态的多态
Animal 是抽象类
Animal x=new X();
同一个引用类型，使用不同的对象实例，而执行不同的操作，从而得到一个不同的结果！
如果X是Dog，等会执行eat（）就是吃骨头；
如果X是Cat，等会执行eat（）就是吃鱼；
01.Dog和Cat都是动物！！ ===》同一个引用类型
02.一个Dog 一个Cat ===》不同的对象实例
03. 吃骨头 吃鱼 ===》不同的操作结果
多态存在的必要条件：
01.要有继承关系！ Dog和Cat is a 动物 都是 extends Animal
02.子类要重写父类方法 ！ eat（）是重写了父类的方法
03.父类的引用指向了子类的对象！ Animal x=new X(); X()子类的对象
多态的实际应用场景：
01.使用父类作为方法的参数！
我要买小动物！ buy(Animal) buy(Dog) 对！
02.使用父类作为方法的返回值！
我要买小动物！
public Animal buy(Animal animal){
这个方法让我们返回一个Animal（动物）
我们返回一个Cat 小猫咪 行吗？ 行！！！
return new Cat();
}
**instanceof 判断某个对象 是否属于某个类型
所有的对象 instanceof Object 返回值都是true
2.代码
需求：
01.创建Dog Cat Animal 三个类
02.Dog Cat 分别继承 Animal
03.创建一个Master 主人类
04.在Master中新增一个 给宠物喂食的方法，方法的参数是？？？Animal
05.模拟主人给小动物 喂食的方法
1 /** 2 * 动物的抽象类 3 */ 4 public abstract class Animal { 5 6 /** 7 * 所有动物的吃饭方法 8 */ 9 public abstract void eat(); 10 11 }
1 public class Cat extends Animal { 2 3 @Override 4 public void eat() { 5 System.out.println("СèßäÔÚ³ÔÓã"); 6 } 7 8 }
1 public class Dog extends Animal { 2 3 @Override 4 public void eat() { 5 System.out.println("小狗狗在啃骨头"); 6 } 7 8 /** 9 * 小狗狗特有的游泳的方法 10 */ 11 public void swimming() { 12 System.out.println("小狗狗在游泳"); 13 } 14 15 }
1 /** 2 * 宠物的主人类 3 */ 4 public class Master { 5 6 /** 7 * 给所有宠物喂食的方法 8 * 有那么多小宠物？ 喂谁？？？ 9 * 关键点： 10 * 我们怎么知道 传递来的是 小猫咪还是小狗狗！！！ 11 * 12 * instanceof 判断某个对象 是否属于某个类型 13 * 所有的对象 instanceof Object 返回值都是true 14 */ 15 public void feed(Animal animal) { 16 // animal.eat(); 那么子类中特有的方法我们无法访问 17 if (animal instanceof Dog) { 18 Dog dog = (Dog) animal;// 向下转型 19 dog.eat(); 20 dog.swimming(); // 调用子类特有的方法 21 } else if (animal instanceof Cat) { 22 Cat cat = (Cat) animal;// 向下转型 23 cat.eat(); 24 } 25 26 } 27 }
1 import java.util.Scanner; 2 3 public class AnimalTest { 4 5 public static void main(String[] args) { 6 // 实例化主人类 7 Master master = new Master(); 8 System.out.println("请您选择需要喂食的宠物： 01.小猫咪 02.小狗狗"); 9 Scanner input = new Scanner(System.in); 10 int choose = input.nextInt(); 11 // 创建一个动物 抽象类 不能被实例化 具体是哪个动物我们不知道 12 Animal animal; 13 switch (choose) { 14 case 1: // 给小猫咪喂食 15 animal = new Cat(); // 父类的引用指向了子类的对象 16 master.feed(animal); 17 break; 18 case 2: // 给小狗狗喂食 19 animal = new Dog(); 20 master.feed(animal); 21 break; 22 } 23 24 } 25 }
3.面试题
1 public class A { 2 /** 3 * ÏÂÃæÁ½¸ö·½·¨ÊÇÖØÔØ 4 */ 5 public String show(D d) { 6 return " A AND D"; 7 } 8 9 public String show(A a) { 10 return " A AND A"; 11 } 12 13 }
1 public class B extends A { 2 3 /** 4 * 下面两个方法是重载 5 */ 6 public String show(B b) { 7 return " B AND B"; 8 } 9 10 /** 11 *重写A类的方法 12 */ 13 public String show(A a) { 14 return " B AND A"; 15 } 16 17 }
1 public class C extends B { 2 3 }
1 public class D extends B { 2 3 }
1 public class TestExam { 2 3 public static void main(String[] args) { 4 A a1 = new A(); 5 A a2 = new B(); // 父类的引用指向了子类的对象 6 B b = new B(); 7 C c = new C(); 8 D d = new D(); 9 10 System.out.println(a1.show(b)); // A AND A 11 /** 12 * a1是A类的对象！ 13 * 我们传递了一个C对象 14 * C类继承B类 ，B类继承A类 15 * 所以会执行 A类中的 show(A a) 16 */ 17 System.out.println(a1.show(c)); // A AND A 18 System.out.println(a1.show(d)); // A AND D 19 /** 20 * a2是父类的引用指向了子类的对象 21 * a2.show（b）应该去A类中查询 show()并且参数是B类型的！ 22 * A类中没有参数为B的！ 23 * 但是有参数是B类父类的方法的！show(A a)! 24 * 又因为子类B重写了A类的show(A a) 所以执行 B类的show(A a) 25 */ 26 System.out.println(a2.show(b)); // B AND A 27 System.out.println(a2.show(c)); // B AND A 28 System.out.println(a2.show(d)); // A AND D 29 System.out.println(b.show(b)); // B AND B 30 System.out.println(b.show(c)); // B AND B 31 /** 32 * b确实是B类的对象！ 33 * 但是b.show(d)在B类中没有发现！ 34 * 这时候 会去父类中查询 有没有对应的show(d) 因为B类继承了A类 35 * 所以说 A类中的 show(D d) B类中也有！只不过在A类中！ 36 * A类中有就执行！否则就执行B类中的show(B b) 因为D类继承了B类 37 */ 38 System.out.println(b.show(d)); // A AND D 39 40 } 41 42 }
