java中的多态是指：父类的引用指向子类的对象，可以是代码更加方便简洁灵活

举个例子：

package com.qfedu.b_duotai;

public class Demo1 {
	public static void main(String[] args) {
		//父类的引用指向子类的对象
		Father father = new Son();
		father.eat();
		//当父类的引用指向子类的对象的时候
		//父类不能调用子类独有的方法
		//如果子类重写父类的方法，调用的是子类的方法
		//father.driver();
		//Daughter daughter = new Daughter();
		test(new Daughter());
		
		test(new Son());
		
		test(new Son1());
		
	}
	//如果写一个方法的参数的话，尽可能的写父类的对象
	//具有很强的扩展性
	public static void test (Father father) {
		father.eat();
	}
//	public static void test (Son son) {
//		son.eat();
//	}
//	public static void test (Daughter daughter) {
//		daughter.eat();
//	}
//	public static void test (Son1 son1) {
//		son1.eat();
//	}

}

package com.qfedu.c_duotailainxi;

public class Person {
	
//	public void feed (Dog dog) {
//		dog.eat();
//	}
//	public void feed (Cat cat) {
//		cat.eat();
//	}
	//方法的形参传的是一个父类的对象
	//调用方法的时候可以传子类的对象
	//形参 （父类）= 实参（子类）
	//父类的引用指向子类的对象
	public void feed (Pet  pet) {
		pet.eat();
	}

}

向上转型和向下转型

父与子对象之间的转换可以分为向上转型和向下转型

向上转型：通过子类对象（小范围的）去实例化父类对象（大范围）。自动转换

java多态的核心思想：【父类的引用指向子类的对象】

向下转型：通过父类的对象（大范围）转为子类的对象（小范围）。强制类型转换

例子：向上转型

package com.qfedu.d_zhuanxing;
class A {
	public void test () {
		System.out.println("test:A");
	}
}
class B extends A {
	@Override
	public void test() {
		// TODO Auto-generated method stub
		System.out.println("test:B");
	}
}

public class Demo1 {
	public static void main(String[] args) {
		//向上转型  过子类对象（小范围的）去实例化父类对象（大范围）。自动转换
		//把子类真实的值赋值给父类的引用
		//父类  子类对象 = new 子类()  无需强转 默认的一种写法
		A a = new B();
		//子类  子类对象 =  (子类)new  父类();  强转
		B b = (B) new A();
	}

}

例子：向下转型

package com.qfedu.d_zhuanxing;

class A1 {
	public void test1 () {
		System.out.println("test:A1");
	}
}
class B1 extends A1 {
	@Override
	public void test1() {
		// TODO Auto-generated method stub
		System.out.println("test:B1");
	}
}
public class Demo2 {
	public static void main(String[] args) {
		//向下转型  子类 子类对象 = new  父类(); 
		//B1 b1 = (B1)new A1();//报错了
		//解决方案
		A1 a1 = new B1();//向上转型
		func(a1);
	}
	public static void func (A1 a1) {
		if  (a1 instanceof B1) {
			B1 b1 = (B1)a1;//向下转型
			b1.test1();
		} else {
			System.out.println("xixida");
		}
	}
}

instanceof

作用：测试左边的对象是否是右边类的实例

语法格式：

对象  instnaceof 类    返回值是布尔类型数据

例子：

package com.qfedu.d_zhuanxing;

interface A2 {
	
}
class B2 implements A2 {
	
}
class C2 extends B2 {
	
}
public class Demo3 {
  public static void main(String[] args) {
	A2  a2 = new B2();//父类的引用指向子类的对象（小转 大）
	//测试左边的对象是否是右边类的实例
	boolean ret = a2 instanceof B2;
	System.out.println(ret);//true
	
	// a2这个对象的是接口A2实例对象的引用
	boolean ret1 = a2 instanceof A2;
	System.out.println(ret1);//true
	
	B2 b2 = new B2();
	//你的叔叔长得像你爷爷
	boolean ret2 = b2 instanceof A2;
	System.out.println(ret2);
	//你的叔叔长的像你  大忌
	//总结：左边的那个对象  一定是 instanceof  右边的那个类的子孙类
	//C2 c2 = (C2)new B2();
	boolean ret3 = b2 instanceof C2;//能不能将b2转为C2的实例吗？不能  爹转儿子  要强转
	System.out.println(ret3);//false
	B2 b3 = new C2();//向上转型
	boolean ret4 = b3 instanceof A2;// A2 b3 = new C2();
	System.out.println(ret4);
	boolean ret5 = b3 instanceof B2;// B2 b3 = new C2();
	System.out.println(ret5);
	
	boolean ret6 = b3 instanceof C2;//C2 c2 = new C2();
	System.out.println(ret6);
 }
}