Java中的多态性表现：
1.方法的重载和重写；
2.用父类的引用指向子类的具体实现，而且可以随时更换为其他子类的具体实现

先建个父类Animal:

public class Animal {
	public void say() {
		System.out.println("我是一只动物");
	}
}

再建两个子类Dog和Cat，重写父类方法say：

public class Dog extends Animal{
	public void say() {
		System.out.println("我是一只狗");
	}
}

public class Cat extends Animal{
	public void say() {
		System.out.println("我是一只猫");
	}
}

建个test测试类

public class test {
	public static void main(String[] args) {
		Dog d=new Dog();
		d.say();
		
		Cat c=new Cat();
		c.say();
	}
}

运行结果

上面只是简单的子类继承 以及实例化对象 调用方法，
下面用多态测试，父类引用指向子类具体实现

public class test {
	public static void main(String[] args) {
		// 父类引用指向Dog子类的具体实现
		Animal animal=new Dog();
		animal.say();
		
		// 更换实现
		animal=new Cat();
		animal.say();
	}
}

运行结果

对象的转型：
向上转型：子类对象->父类对象 安全
向下转型：父类对象->子类对象 不安全

比如上面的实例：Animal animal=new Dog(); 就是后面的new Dog() 子类对象 向上 Animail animal 转型 是安全的；

向下转型 是父类对象强制转换成子类对象：我们来改下Test类：

public class test {
	public static void main(String[] args) {
		// 父类引用指向Dog子类的具体实现
		Animal animal=new Dog();
		animal.say();
		
		//向下转型
		Dog d=(Dog) animal;
		d.say();

		// 向下转型  因为animal指向的是Dog具体实现 所以会报错
		Cat c=(Cat) animal;
		c.say();
	}
}

运行结果

转换异常 所以说向下转型是不安全的，我们必须知道具体的实现类

上面用的继承方式演示了多态 其实在实际开发中 更多的是用接口
再写一个实例，先建一个父类接口People

public interface People {
	public void say();
}

接下来写两个具体实现类,Student Teacher

public class Student implements People{

	@Override
	public void say() {
		System.out.println("我是学生");
	}

}

public class Teacher implements People{

	@Override
	public void say() {
		System.out.println("我是老师");
	}
	
}

再写一个测试类

public class test2 {
	public static void main(String[] args) {
		People p=new Student();
		p.say();
		
		p=new Teacher();
		p.say();
	}
}

运行结果