Java向上转型
很多初学java的小伙伴可能会对java中向上转型的使用有点疑惑，据我敲了不怎么多的代码发现，向上转型如：父类 Animal ，子类 Dog 继承父类, Animal a = new Dog();(向上转型)，引用对象a调用的方法可以看成是父类Animal中所包含的方法（有些方法可能被Dog类覆盖），Dog类中新增的方法，即在父类中没有的，在向上转型中的对象引用是无法调用的，如：假如子类Dog类中新增方法maiMeng（），当代码a.maiMeng()，会报错（提示：没有为类型Animal定义maiMeng()方法），成员变量也是如此。
总结：向上转型的对象引用只可调用父类有的成员方法和成员变量，包括已被覆盖的。子类新增的方法和变量在向上转型中无法被调用。

java向上转型
首先来了解一下下面的知识点：
    1，转型是在继承的基础上而言的，继承是面向对象语言中，代码复用的一种机制，通过继承，子类可以复用父类的功能，如果父类不能满足当前子类的需求，则子类可以重写父类中的方法来加以扩展。
    2，“动态绑定”也即后期绑定，意指在运行期间判断对象的类型并以此来判定去调用适当的方法。java属于后期绑定。在java中，几乎所有的方法都是后期绑定的，在运行时去动态的绑定一个方法是属于子类还是属于基类。
 
向上转型：子类引用的对象转换为父类类型称为向上转型，或者说把子类对象直接赋给父类引用。通俗地说就是是将子类对象转为父类对象。此处父类对象可以是接口.
Father father = new Son();  //向上转型，父类引用指向子类对象
 
看下面的代码段1：
public class Father{
    public void f1() {
       System.out.println("Father 的 method");
}
}
Father的子类Son：
public class Son extends Father {
    public void f1() {
       System.out.println("Son 的 method"); //覆盖父类的方法@override
}
       public void s1(){} //Son类定义了自己的新方法
public static void main(String[] args) {     
　　Father a = new Son();//向上转型     
　　a.fl();     
　　}     
}
        那么上面程序的运行结果会是什么呢？输出的是“Father 的 method”还是“Son 的 method”？事实上输出的结果是：Son 的 method 。分析一下，首先Father a = new Son()；声明的是父类的引用，但是执行的过程中调用的是子类的对象，所以程序首先寻找子类对象的f1方法，由于子类重写了父类的f1方法，根据“动态绑定”的理论知道程序会去调用子类的f1方法去执行，因为子类对象有f1方法而没有向上转型去寻找。那么我们再接着看下面的一段代码段2：
public class Father{
    public void f1() {
       System.out.println("Father 的 method");
}
}
Father的子类Son：
public class Son extends Father {
       public void s1(){} //Son类定义的方法
public static void main(String[] args) {     
　　Father a = new Son();//向上转型     
　　a.fl();     
　　}     
}
        这时Father a = new Son()；声明的仍然是父类的引用，执行过程中调用的也仍然是子类的对象，程序首先会去寻找子类对象的f1方法，但是没有找到，于是就会向上转型去父类寻找f1方法，这时会顺利的找到，将会给出的结果是：Father 的 method。
        这里我们需要注意，在向上转型时，父类指向子类引用对象会遗失除与父类对象共有的其他方法，也就是在转型过程中，子类的新有的方法都会遗失掉，在编译时，系统会提供找不到方法的错误  
        但是，值得注意的是在处理java类中的成员变量时，并不是采用运行时绑定，而是一般意义上的静态绑定。所以在向上转型的情况下，对象的方法可以找到子类，而对象的属性还是父类的属性。

这篇文章主要介绍了Java向上转型和向下转型实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
学习向上转型和向下转型怎么用没多难，但是为什么那样用，我搞了很多次没弄明白。没弄明白的原因是平时学习时之看例子，而例子一般都比较简单，没有对象之间的调用，一般就是一个对象调用自己的方法。
首先看下怎么用转型。
要转型，首先要有继承。继承是面向对象语言中一个代码复用的机制，简单说就是子类继承了父类中的非私有属性和可以继承的方法，然后子类可以继续扩展自己的属性及方法。
向上转型：子类对象转为父类，父类可以是接口。公式：Father f = new Son();Father是父类或接口，son是子类。
向下转型：父类对象转为子类。公式：Son s = (Son)f;
例子：向上转型
package multistate;
public class Human {
public void sleep() {
System.out.println("Human sleep..");
}
public static void main(String[] args) {
Human h = new Male();// 向上转型
h.sleep();
Male m = new Male();// 干嘛要向上转型
m.sleep();
// h.speak();此方法不能编译，报错说Human类没有此方法
}
}
class Male extends Human {
@Override
public void sleep() {
System.out.println("Male sleep..");
}
public void speak() {
System.out.println("I am Male");
}
}
class Female extends Human {
@Override
public void sleep() {
System.out.println("Female sleep..");
}
public void speak() {
System.out.println("I am Female");
}
}
注意：向上转型不要强制转型。向上转型后父类的引用所指向的属性是父类的属性，如果子类重写了父类的方法，那么父类引用指向的或者调用的方法是子类的方法,这个叫动态绑定。向上转型后父类引用不能调用子类自己的方法，就是父类没有但是子类的方法，如果调用不能编译通过，比如子类的speak方法。
非要调用子类的属性呢？如果不向下转型就需要给需要的属性写getter方法。
例子：
package multistate;
public class Human {
String name = "Human";
public String getName(){
return this.name;
}
public void sleep() {
System.out.println("Human sleep..");
}
public static void main(String[] args) {
Human h = new Male();// 向上转型
System.out.println(h.getName());
}
}
class Male extends Human {
String name = "Male";
public String getName(){
return this.name;
}
@Override
public void sleep() {
System.out.println("Male sleep..");
}
public void speak() {
System.out.println("I am Male");
}
}
class Female extends Human {
String name = "Female";
public String getName(){
return this.name;
}
@Override
public void sleep() {
System.out.println("Female sleep..");
}
public void speak() {
System.out.println("I am Female");
}
}
非要调用子类扩展的方法，比如speak方法，就只能向下转型了。
例子：向下转型
向下转型需要考虑安全性，如果父类引用的对象是父类本身，那么在向下转型的过程中是不安全的，编译不会出错，但是运行时会出现java.lang.ClassCastException错误。它可以使用instanceof来避免出错此类错误即能否向下转型，只有先经过向上转型的对象才能继续向下转型。
package multistate;
public class Human {
public void sleep() {
System.out.println("Human sleep..");
}
public static void main(String[] args) {
Human h = new Male();// 向上转型
Human h1 = new Human();
//h.speak();此时需要向下转型，否则不能调用speak方法。
Male m = (Male) h;
m.speak();
/**Male m1 = (Male)h1;
m1.speak();  此时会出现运行时错误，所以可以用instanceOF判断*/
if (h1 instanceof Male){
Male m1 = (Male)h1;
m1.speak();
}
}
}
class Male extends Human {
@Override
public void sleep() {
System.out.println("Male sleep..");
}
public void speak() {
System.out.println("I am Male");
}
}
弄了半天，向上转型反而不能拥有子类的全部方法，还得向下转型，那直接Son s = new Son();岂不是很方便？不知道是不是就我一个开始学习转型有这种想法。
最后搞明白了，原因还是我我的例子太简单，没有 考虑过要把类的对象传递给其他函数的例子。
例子：体现向上转型的好处，节省代码。
package multistate;
public class Human {
public void sleep() {
System.out.println("Human sleep..");
}
public static void doSleep(Human h){
h.sleep();
}//此时传递的参数是父类对象，但是实际调用时传递子类对象，就是向上转型。
public static void main(String[] args) {
Human h = new Male();// 向上转型
doSleep(new Male());//此处匿名子类对象，当然实际应用时应该是用上面的向上转型公式，然后将子类对象传递进来，这样以后好在向下转型，此处没有向下转型，所以直接用了匿名类对象。
doSleep(new Female());
}
}
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..");
}
}
如果不向上转型则必须写两个doSleep函数，一个传递Male类对象，一个传递Female类对象。这还是两个子类，如果有很多子类呢，就要写很多相同的函数，造成重复。
好，终于也理解了为什么要向上转型，一旦向上转型了，当需要用到子类的方法时，就需要向下转型，也就是为什么要向下转型也解决了。
总结一下：
1、把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转型。
如Father father = new Son();
2、把指向子类对象的父类引用赋给子类引用叫向下转型(downcasting)，要强制转型,要向下转型，必须先向上转型为了安全可以用instanceof判断。
如father就是一个指向子类对象的父类引用，把father赋给子类引用son 即Son son =(Son)father；
其中father前面的(Son)必须添加，进行强制转换。
3、upcasting 会丢失子类特有的方法,但是子类overriding 父类的方法，子类方法有效，向上转型只能引用父类对象的属性，要引用子类对象属性，则要写getter函数。
4、向上转型的作用，减少重复代码，父类为参数，调有时用子类作为参数，就是利用了向上转型。这样使代码变得简洁。体现了JAVA的抽象编程思想。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。

“为新的类提供方法”并不是继承技术中最重要的方面，其最重要的方面是用来表现新类和基类之间的关系。这种关系可以用“新类是现有类的一种类型”这句话加以概括。
这个描述并非只是一种解释继承的华丽的方式，这直接是由语言所支撑的。例如，假设有一个称为Instrument的代表乐器的基类和一个称为Wind的导出类。由于继承可以确保基类中所有的方法在导出类中也同样有效，所以能够向基类发送的所有消息同样也可以向导出类发送。如果Instrument类具有一个play()方法，那么Wind乐器也同样具备。这意味着我们可以准确地说Wind对象也是一种类型的Instrument。下面这个例子说明了编译器是怎样支持这一概念的：
package reusing;



class Instrument{
public void paly(){}
static void tune(Instrument i){
i.paly();
}

}



public class Wind extends Instrument{
public static void main(String[] args){
Wind flute = new Wind();
Instrument.tune(flute);
}

}

在此例中，tune()方法可以接受Instrument引用，这是太有趣了。但在Wind.main()中，传递给tune()方法的是一个Wind引用。鉴于Java对类型的检查十分严格，接受某种类型的方法同样可以接受另外一种类型就会显得很奇怪，除非你认识的到Wind对象同样也是一种instrument对象，而且也不存在任何tune()方法时可以通过Instrument来调用，同时又不存在于Wind之中。在tune()中，程序代码可以对Instrument和它所有的导出类起作用，这种将Wind引用转换为Instrument引用的动作，我们称之为向上转型。

由导出类转型为基类，其继承图上是向上移动的，因此一般称为向上转型。由于向上转型是从一个较专用类型向较通用类型转换，所以总是很安全的。也就是说，导出类是基类的一个超集。它可能比基类含有更多的方法，但它必须至少具备基类中所含有的方法。在向上转型的过程中，类接口中唯一可能发生的事情是丢失方法，而不是获取它们。这就是为什么编译器在“未曾明确表示转型”或“未曾指定特殊标记”的情况下，仍然允许向上转型的原因。


在面向对象编程中，生成和使用程序代码最有可能采用的方法就是直接将数据和方法包装进一个类中，并使用该类的对象。也 可以运用组合技术使用现有类来开发新的类，而继承技术其实是不太常用的。因此，尽管多次强调继承，但这并不意味着要尽可能使用它。相反，应当慎用这一技术，其使用场合仅限于你确信使用该技术确实有效的情况。到底是该用组合还是用继承，一个最清晰的判断方法就是问一问自己是否需要从新类向基类进行向上转型。如果必须向上转型，则继承是必需的。但如果不需要，则应当好好考虑自己是否需要继承。