什么时候向上转型，什么时候向下转型？用它们有什么意义？

        (1)同一个对象，在不同时刻的多种运行状态。
        (2)举例：
                动物，狗   狗是狗，狗是动物。
                水(气体，液态，固定)
        (3)前提
                A:存在着继承或者实现关系
                B:有方法的重写
                C:父类(接口)引用指向子类(实现)对象
        (4)不同形式形式模拟多态
                A:普通类
                B:抽象类
                C:接口
        (5)多态中对象调用成员的特点
                Fu f = new Zi();
               
                A:成员变量
                        编译看左边，运行看左边
                B:成员方法
                        编译看左边，运行看右边
                C:静态方法
                        编译看左边，运行看左边
        (6)多态的思想
                指挥同一批对象做事情。

                举例：带兵打仗，下课等。
        (7)向上转型和向下转型
                Animal a = new Dog();  //向上转型
                //使用Dog中特有的方法
                Dog d = (Dog) a;  //向下转型

                //注意：不能转换成不同类型的
                Cat c = (Cat)a;
               
                举例：
                孔子爹:教课(java)
                孔子:教课(论语)，玩游戏()

                //多态
                孔子爹 k爹 = new 孔子(); //孔子就穿上他爹的衣服，装爹 向上转型
                k爹.教课();  //论语
                //k爹.玩游戏();

                孔子 k = (孔子) k爹;  //脱下衣服，穿上自己衣服。向下转型
                k.玩游戏();

向上转型就是装箱，向下转型就是拆箱
在java中，数据类型总共可分为两大种，基本数据类型（值类型）和类类型（引用数据类型）。基本类型的数据不是对象，不能作为对象调用其toString()、hashCode()、getClass()、equals()等等方法。
所以在java中，针对8种基本数据类型，提供了针对每个基本数据类型的包装类。如下：
INDEX        基本数据类型        包装类
1        int            Integer
2        char          Character
3        float          Float
4        double          Double
5        byte          Byte
6        short          Short
7        long          Long
8        boolean          Boolean
所谓装箱，就是把基本类型用它们相对应的引用类型包起来，使它们可以具有对象的特质，如我们可以把int型包装成Integer类的对象，或者把double包装成Double，等等。
所谓拆箱，就是跟装箱的方向相反，将Integer及Double这样的引用类型的对象重新简化为值类型的数据。
public class IntegerDemo02
{
        public static void main (String []agrs)
        {
                int i=10
                Integer j=i;
                int k=j;
                System.out.println(++k);
        }
}; //output:11
包装类的另外一个比较有用的是可以将String 字符串类型转换为相应的基本数据类型。下面以将String转为int为例：
public class IntegerDemo04
{
        public static void main (String[] args)
        {
                String str="1500";
                try
                {
                        int i=Integer.parseInt(str);
                        System.out.println(++i);
                }
                catch (Exception e)
                {
                        e.printStackTrace(); //打印异常信息
                }
        }
};// output: 1501

父类：动物
子类：狼
动物=狼 向上转型
狼=动物 向下转型
动物=狗 ok
狼=狗  不ok
一个只能治狼病的诊所 你带着狗来看病 肯定不可以 所以这里就要用到向下转型来判断
这就是所谓的向下转型

动物都可以奔跑 所以动物类里有一个奔跑的方法
动物=狼
动物=狗
动物=猪
动物=奥特曼
动物=小日本
动物这个类里可以接受n多动物通过向上转型来使用奔跑方法
或者继承父类改写奔跑方法
各种小动物改写完奔跑方法后 要接受传进来的动物
假如把 动物=小日本 传进了 狗改写父类的奔跑方法里了
小日本会奔跑吗 显然不会！

所以 动物 狗 = (狗) 小日本 不ok
向下转型失败

焦晨光 发表于 2012-8-8 23:37
父类：动物
子类：狼
动物=狼 向上转型

太有才了:D