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.模拟主人给小动物 喂食的方法
/**
* 动物的抽象类
*/
public abstract class Animal { /**
* 所有动物的吃饭方法
*/
public abstract void eat(); }
多态
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("СèßäÔÚ³ÔÓã");
}
}多态
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("小狗狗在啃骨头");
}
/**
* 小狗狗特有的游泳的方法
*/
public void swimming() {
System.out.println("小狗狗在游泳");
}
}多态
/**
* 宠物的主人类
*/
public class Master { /**
* 给所有宠物喂食的方法
* 有那么多小宠物？ 喂谁？？？
* 关键点：
* 我们怎么知道 传递来的是 小猫咪还是小狗狗！！！
*
* instanceof 判断某个对象 是否属于某个类型
* 所有的对象 instanceof Object 返回值都是true
*/
public void feed(Animal animal) {
// animal.eat(); 那么子类中特有的方法我们无法访问
if (animal instanceof Dog) {
Dog dog = (Dog) animal;// 向下转型
dog.eat();
dog.swimming(); // 调用子类特有的方法
} else if (animal instanceof Cat) {
Cat cat = (Cat) animal;// 向下转型
cat.eat();
} }
}
多态
import java.util.Scanner;
public class AnimalTest {
public static void main(String[] args) {
// 实例化主人类
Master master = new Master();
System.out.println("请您选择需要喂食的宠物： 01.小猫咪 02.小狗狗");
Scanner input = new Scanner(System.in);
int choose = input.nextInt();
// 创建一个动物 抽象类 不能被实例化 具体是哪个动物我们不知道
Animal animal;
switch (choose) {
case 1: // 给小猫咪喂食
animal = new Cat(); // 父类的引用指向了子类的对象
master.feed(animal);
break;
case 2: // 给小狗狗喂食
animal = new Dog();
master.feed(animal);
break;
}
}
}多态
3.面试题
public class A {
/**
* ÏÂÃæÁ½¸ö·½·¨ÊÇÖØÔØ
*/
public String show(D d) {
return " A AND D";
}
public String show(A a) {
return " A AND A";
}
}exam
public class B extends A {
/**
* 下面两个方法是重载
*/
public String show(B b) {
return " B AND B";
}
/**
*重写A类的方法
*/
public String show(A a) {
return " B AND A";
}
}exam
public class C extends B {
}exam
public class D extends B {
}exam
public class TestExam {
public static void main(String[] args) {
A a1 = new A();
A a2 = new B(); // 父类的引用指向了子类的对象
B b = new B();
C c = new C();
D d = new D();
System.out.println(a1.show(b)); // A AND A
/**
* a1是A类的对象！
* 我们传递了一个C对象
* C类继承B类 ，B类继承A类
* 所以会执行 A类中的 show(A a)
*/
System.out.println(a1.show(c)); // A AND A
System.out.println(a1.show(d)); // A AND D
/**
* a2是父类的引用指向了子类的对象
* a2.show（b）应该去A类中查询 show()并且参数是B类型的！
* A类中没有参数为B的！
* 但是有参数是B类父类的方法的！show(A a)!
* 又因为子类B重写了A类的show(A a) 所以执行 B类的show(A a)
*/
System.out.println(a2.show(b)); // B AND A
System.out.println(a2.show(c)); // B AND A
System.out.println(a2.show(d)); // A AND D
System.out.println(b.show(b)); // B AND B
System.out.println(b.show(c)); // B AND B
/**
* b确实是B类的对象！
* 但是b.show(d)在B类中没有发现！
* 这时候 会去父类中查询 有没有对应的show(d) 因为B类继承了A类
* 所以说 A类中的 show(D d) B类中也有！只不过在A类中！
* A类中有就执行！否则就执行B类中的show(B b) 因为D类继承了B类
*/
System.out.println(b.show(d)); // A AND D
}
}exam