首先,java的转型是基于继承的基础上的，转型的使用一般在多态中。关于在转型中最重要的一点那就是：父类引用指向子类对象；而子类引用不能指向父类对象

要充分的了解向上转型与向下转型，我们先说下什么是多态

多态的定义：

指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）简而言之就是：对于同一动作做出的响应产生不同的结果

多态存在的必要条件：

1. 在继承的基础上
2. 要有重写
3. 父类引用指向子类对象（即向上转型）

多态存在的好处：

• 可替换性（substitutability）。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。
• 可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。
• 接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。
• 灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。
• 简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。

多态的实现方式：继承和接口

继承实现多态：

• 对于指向子类对象的父类引用，在处理该引用时，它适用于继承该父类的所有子类，子类对象的不同，对方法的实现也就不同，执行相同动作产生的行为也就不同。
• 如果父类对象是抽象类，则继承了该抽象类的子类必须父类中的所有抽象方法

接口实现多态：

• 在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法

多态分类：

• 编译时多态：其中编译时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的函数，通过编辑之后会变成两个不同的函数，在运行时谈不上多态；
• 运行时多态：而运行时多态是动态的，它是通过动态绑定来实现的，也就是我们所说的多态性。 对于多态的实现主要是基于动态绑定技术

示例：

class A ...{ 
 public String show(D obj)...{ 
 return ("A and D"); 
 } 
 public String show(A obj)...{ 
 return ("A and A"); 
 } 
} 
class B extends A...{ 
 public String show(B obj)...{ 
 return ("B and B"); 
 } 
 public String show(A obj)...{ 
 return ("B and A"); 
 } 
} 
class C extends B...{} 
class D extends B...{}
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)); ① 
 System.out.println(a1.show(c)); ② 
 System.out.println(a1.show(d)); ③ 
 System.out.println(a2.show(b)); ④ 
 System.out.println(a2.show(c)); ⑤ 
 System.out.println(a2.show(d)); ⑥ 
 System.out.println(b.show(b)); ⑦ 
 System.out.println(b.show(c)); ⑧ 
 System.out.println(b.show(d)); ⑨

运行结果：

① A and A
② A and A
③ A and D
④ B and A
⑤ B and A
⑥ A and D
⑦ B and B
⑧ B and B
⑨ A and D

向上转型与向下转型

一个简单的例子：有2个类，Animal是父类，Pig类继承自Father。

Animal a1 = new Pig();//父类引用a指向子类对象
Pig p1 = (Pig)a //子类对象的父类引用 a 赋给子类引用 p2
Animal a2 = new Animal();
Pig p2 = (Pig)a2//子类引用p2指向父类对象a2;(严格的说这里的a2是指的父类引用而不是父类的对象)

• 向上转型：父类引用指向子类对象，而子类引用不能指向父类对象
• 向下转型：子类对象的父类引用 赋给子类引用

向上转型在代码中的实现

package casting;
/**
 * Animal父类
 * @author wangyu
 * 
 * @create date:2017年10月12日
 */
public class Animal {
	public void eat(){
		System.out.println("animal eatting...");
	}
}
/**
 * 子类
 */
class Birds extends Animal{
 //重写父类方法
	@Override
	public void eat() {
		 System.out.println("bird eatting..."); 
	}
	public void fly(){
		System.out.println("bird fly..."); 
	}
}
/**
 * Human子类
 * @author wangyu
 * 
 * @create date:2017年10月12日
 */
public class Human {
	 public void sleep() { 
	 System.out.println("Human sleep.."); 
	 }
}
class Male extends Human { 
 @Override 
 public void sleep() { 
 System.out.println("Male sleep.."); 
 } 
}
class Female extends Human { 
 @Override 
 public void sleep() { 
 System.out.println("Female sleep.."); 
 } 
}
/**
 * 测试类
 * @author wangyu
 * 
 * @create date:2017年10月12日
 */
public class Main {
	public static void main(String[] args) {
		Animal b=new Birds(); //向上转型 
 b.eat(); 
 //! error: b.fly(); b虽指向子类对象，但此时丢失fly()方法 
 dosleep(new Male()); 
 dosleep(new Female()); 
	}
	
	public static void dosleep(Human h) { //这里以父类为参数，调有时用子类作为参数，就是利用了向上转型。使代码简洁
 h.sleep(); 
 } 
}
运行结果：
bird eatting...
Male sleep..
Female sleep..

向下转型在代码中的实现：

public static void main(String[] args) {
		Animal a = new Birds(); //向上转型 
		a.eat();
		
		Birds b = (Birds)a;//向下转型
		b.fly();
		b.eat();
		
		Animal a2 = new Animal();//不安全的向下转型,编译无错但会运行会出错
		if(a2 instanceof Birds){
			Birds b2 = (Birds)a2;
			b2.fly();
			b2.eat();
		}
		/*
		 * 运行出错：
			Exception in thread "main" java.lang.ClassCastException: com.wensefu.other1.Girl
			 at com.wensefu.other1.Main.main()
			如代码所示，可以通过instanceof来防止出现异常。
		 */
	}
	
运行结果：
bird eatting...
bird fly...
bird eatting...

以上就是我对多态及向上向下转型的理解，如有不对的地方欢迎指正，谢谢大家支持