List<String> lists = new ArrayList();
ArrayList<String> lists = new ArrayList(); 
 
 

  到底有什么区别？这是上转型。
 
 
上转型对象不是父类创建的对象，而是子类对象的“简化”状态，它不关心子类新增的功能，只关心子类继承和重写的功能。
当一个类有很多子类时，并且这些子类都重写了父类中的某个方法。
当使用上转型对象在调用这个方法时就可能具有多种形态。因为不同的子类在重写父类的方法时可能产生不同的行为。也就是说，不同对象的上转型对象调用同一方法可能产生不同的行为。

例如下面的程序你测试一下就可以理解这样的用法。以下的程序输出为
 
Wang!Wang!......
miao~~miao~~...
package com.vince.testJava;

class Animal {
	void cry() {
	}
}

class Dog extends Animal {
	void cry() {
		System.out.println("Wang!Wang!......");
	}
}

class Cat extends Animal {
	void cry() {
		System.out.println("miao~~miao~~...");
	}
}

public class Test01 {
	public static void main(String args[]) {
		Animal animal;
		animal = new Dog(); // animal是Dog对象的上转型对象
		animal.cry();
		animal = new Cat(); // animal是Cat对象的上转型对象
		animal.cry();
	}
}

什么是向上转型？什么是向下转型？
 
向上转型是安全的，父类型的引用指向子类型的对象，直接转换。
 Animal animal = new Dog();
 向上转型则是不安全的，需要强转。
 Dog dog = (Dog)new Animal();
 一般出现选择题，举例说明即可。

 假如你在一个物流运输公司，有个客户要求你为他运输一定数量的产品到某地，使用某种交通工具．
 
 那我们假设你的管理程序中有Truck类，Train类，Plane类专门用来实现
 
 使用不同交通工具的成本计算，都有方法cost(Double weight,Double space);
 
 那么，问题出来了．客户对于运输器种类是可选择的，
 
 你是不是要对每种运输器new个实例放到不同的service方法中为客户服务呢？
 
 很明显这么做有很多代码重复，而且效率太低．
 
 那么为什么不构造一个运输工具的父类:
 
 
 
 
  
 
      

       1
      
 
      

       2
      
 
      

       3
      
 
      

       4
      
 
      

       5
      
 
      

       6
      
 
      

       7
      
 
      

       8
      
 
      

       9
      
 
      

       10
      
 
      

       11
      
 
      

       12
      
 
      

       13
      
 
      

       14
      
 
      

       15
      
 
      

       16
      
 
      

       17
      
 
      

       18
      
 
      

       19
      
 
      

       20
      
 
      

       21
      
 
      

       22
      
 
      

       23
      
 
      

       24
      
 
      

       25
      
 
      

       26
      
 
      

       27
      
 
      

       28
      
 
      

       29
      
 
      

       30
      
 
      

       31
      
 
      

       32
      
 
      

       33
      
 
      

       34
      
 
      

       35
      
 
      

       36
      
 
 
      
 
       

        public 
        class 
        Conveyance
       
 
       

        {
       
 
       

        protected 
        weight;
       
 
       

        protected 
        space;
       
 
       

        public 
        abstract 
        Double cost(Double weight,Double space);
       
 
       

        }
       
 
       

        //然后子类Truck,Plane,Train分别实现cost方法再构造一个工厂类为客户制造子类实例
       
 
       

        public 
        class 
        ConveyanceFactory
       
 
       

        {
       
 
       

            
        public 
        static 
        Conveyance getConveyance(String which)
       
 
       

            
        {
       
 
       

              
        if
        (which.equils(
        "Truck"
        ))
       
 
       

              
        {
       
 
       

              
        return 
        new 
        Truck();
       
 
       

              
        }
       
 
       

              
        else 
        if
        (which.equils(
        "Train"
        ))
       
 
       

              
        {
       
 
       

              
        return 
        new 
        Train();
       
 
       

              
        }
       
 
       

              
        else 
        if
        (which.equils(
        "Plane"
        ))
       
 
       

              
        {
       
 
       

              
        return 
        new 
        Plane();
       
 
       

              
        }
       
 
       

              
        else
       
 
       

              
        {
        return 
        null
        ;}
       
 
       

           
        }
       
 
       

        } 
       
 
       

        //服务程序的方法实现：
       
 
       

        public 
        double 
        transportCost(String type,Double weight,Double space)
       
 
       

        {
       
 
       

        Conveyance c;
       
 
       

        Double cost;
       
 
       

        c = ConveyanceFactory.getConveyance(
        "type"
        );
       
 
       

        cost = c.cost(weight,space);
       
 
       

        return 
        cost;
       
 
       

        }
       
 
      
 
 
 
 
 
 
 
 
 看上面服务层的代码多简单‘，而且在MVC层次结构中方法和类的设计也和面向对象．
 
 这就是上塑造型给我们带来的好处咯这回就方便了
 
 ，需要Truck的时候，客户只要告诉你他要用卡车运输运多少距离多远．
 
 那业务员就在option按扭里面选择”卡车”在文本框里输入重量多少距离多远．
 
 veiw层把数据传给controler处理成我们的服务程序需要的数据类型．
 
 然后服务程序被controler调用，用transportCost方法计算出成本返回给veiw，显示给业务员，业务员就可以告诉客户需要支付多少钱啦

 

  通过阅读TKJ和csdn上其他大神的文章，我对向上转型的理解如下。
 在子类继承父类之后，子类可以向上转换成父类。比如TKJ中的管弦乐器继承乐器，乐器拥有的属性管弦乐器一定会有。转换成我们人类的语言就是，管弦乐器一定是乐器。
但是在使用向上转型的时候，子类拥有的自己独有的方法，即父类没有的方法的时候，是会在转型的中被干掉的。
 
package xszx;
//向上转型的父类A
public class A {
	public void print(){
		System.out.println("this is A's printMethon");
	}
}

 

package xszx;
//转型中的子类
public class B extends A{

public void print(){
System.out.println("this is B's printMethon");
}

public void b(){
System.out.println("this is only B's methon");
}
}

 

 
 
 
package xszx;
//测试
public class C  {
	public static void main(String args[]){
		A a=new B();
		a.print();
		//a是没有B中独有的b()的
		
	}
}