一、向上转型和向下转型
 
       向上转型和向下转型是在JAVA继承操作中用到的东西，在讲到转型之前我们需要认识到继承过程中的对象类型转换，这种转换有两个特点：
 
             1.这是继承过程中发生的操作
 
             2.新类是现有类的一种类型。这种说法主要是因为现有类的方法必定存在于新类中，所以通过现有类发送的信息（就是通过创建一个对象进行操作）可以直接通过新类发送。
 
 二、向上转型
 
        向上转型：创建一个基类的引用，但是在创建对象的时候是用的导出类的。示意图如下：
 
                                
 
         由图可知：由导出类转型成基类，在继承图上是向上移动的。同时由于是从较专用类型向较通用类型转换，所以是安全的，因为专用类型肯定包含通用类型。
 
         特点：
 
            1.把导出类对象直接赋给基类类引用，不用强制转换
 
            2.引用可以直接使用基类中的方法，但是不能使用导出类的方法
 
            3.从导出类向上转型，永远不需要知道正在处理的对象的确切类型
 
            4.在向上转型过程中可能发生类接口中方法丢失
 
        示例 ：
 
class Fupcasting{
	public Fupcasting(String ident) {
		System.out.println("i am " + ident);
	}
	public void count() {
		
	}
}
public class Upcasting extends Fupcasting{
	public Upcasting(String ident) {
		super(ident);
		// TODO Auto-generated constructor stub
	}
	public void add() {}
	public static void main(String[] args) {
		String  name = "fatherupcasting";
		// TODO Auto-generated method stub
		Fupcasting fupcasting = new Upcasting(name);    //向上转型
		fupcasting.count();
		//fupcasting.add();   //使用导出类的方法报错
	}

}
 
 三、向下转型
 
        向下转型可以参照向上转型，二者正好相反。这里使用向下转型的原因是因为上述的向上转型的第三条的关系：从导出类向上转型，永远不需要知道正在处理的对象的确切类型！
 
        解释如下：
 
 
 
可知：导出类可以完全代替基类，在使用它们的时候，完全不需要知道关于子类的任何信息。
 
这里如果你清楚  引用和对象  的概念，你就会明白，当我们在向上转型的时候，你处理的导出类的对象你完全不清楚确切类型，这里的类型可以是 基类，也可以是导出类，也就是这一步：
 
Fupcasting fupcasting = new Upcasting(name);  
 
你也可以写成这样：
 
Fupcasting fupcasting = (Fupcasting)new Upcasting(name);    
 
或者这样：
 
Fupcasting fupcasting = (Upcasting)new Upcasting(name);    
 
这里的   (Upcasting)  和 (Fupcasting)  都声明了我们创建的对象的类型，但是在向上转型的过程中我们是这样做的：
 
Fupcasting fupcasting = new Upcasting(name);  
 
通过上面的步骤我们知道我们并不清楚这个对象是什么类型的，所以如果在一定的情况下要获取类型信息，就会用到向下转型！
 
向下转型示意图：
 
 
借用上面的shape图，如果现在我们知道有一个几何图形，但是我们不清楚它是圆、正方形等，但是它的形状肯定是唯一确定的。
 
实例：
 
class Fupcasting{
	public Fupcasting(String ident) {
		System.out.println("i am " + ident);
	}
	public void count() {
		
	}
}
public class Upcasting extends Fupcasting{
	public Upcasting(String ident) {
		super(ident);
		// TODO Auto-generated constructor stub
	}
	public void add() {}
	public static void main(String[] args) {
		String  name = "fatherupcasting";
		// TODO Auto-generated method stub
	//	Fupcasting fupcasting = (Upcasting)new Upcasting(name);    //向上转型
	//	fupcasting.count();
		//fupcasting.add();   //使用导出类的方法报错
		 Upcasting upcasting = (Upcasting) new Fupcasting(name);   //向下转型
		 upcasting.add();
	}

}
 
特点：
 
   1.向下转型可以调用子类类型中所有的成员
 
   2.父类引用对象指向的是子类对象，那么在向下转型的过程中是安全的，就是编译是不会出错误。但是如果父类引用对象是父类本身，那么在向下转型的过程中是不安全的，编译不会出错，但是运行时会             出现 Java 强制类型转换异常
 
 
 
如果觉得对你有帮助，点个赞再走吧！

一、概念
 向上转型是指将子类的实例赋值给父类类型的变量。
 向下转型是指将父类的实例赋值给子类类型的变量。
 二、向上转型
 1、向上转型后父类的引用所指向的属性是父类的属性。
 2、如果子类重写了父类的方法，那么父类引用指向的或者调用的方法是子类的方法，这个叫动态绑定（实现多态）。
 3、父类引用不能调用子类自己的方法。
 4、向上转型会丢失子类的新增方法，同时会保留子类重写的方法。
 三、向下转型
 1、编译时需要强制类型转换，father前面的必须添加（Son）。
 2、运行时会出现java.lang.ClassCastException错误，可使用instanceof来避免出错此类错误。
 3、向下转型可以得到子类的所有方法（包含父类的方法）。

基础知识：Java中的继承机制使得一个类可以继承另一个类，继承的类称为子类，被继承的类称为父类。在一个子类被创建的时候，首先会在内存中创建一个父类对象，然后在父类对象外部放上子类独有的属性，两者合起来形成一个子类的对象，所以子类可以继承父类中所有的属性和方法，包括private修饰的属性和方法，但是子类只是拥有父类private修饰的属性和方法，却不能直接使用它，也就是无法直接访问到它（子类可以通过调用父类的public声明的get方法来获取父类的private属性，但无法访问父类的private方法）。同时子类可以对继承的方法进行重写（@Override），并且新建自己独有的方法。
 
1.向上转型：
 
假设有一个Fruit类，Fruit类中有一个show（）方法，代码如下：
 
class Fruit{
	public void show() {
		System.out.println("this is a fruit");
	}
}
 
有一个Apple类继承自Fruit类，该类有自己的方法test（），并且重写了父类的show（）方法，代码如下：
 
class Apple extends Fruit{
    @Override
    public void show() {
	System.out.println("this is a apple");
    }
    public void test() {
	System.out.println("i am a apple");
    }
}
 
实例化Apple类，并新建一个Fruit类的引用变量引用该实例，调用实例的show（）方法：
 
Fruit fruit = new Apple();
fruit.show();
 
结果为：
 
 
调用实例的test（）方法：
 
fruit.test();
 
结果报错：
 
 
分析：这里用到了向上转型，换言之，就是用父类的引用变量去引用子类的实例，这是允许的。当向上转型之后，父类引用变量可以访问子类中属于父类的属性和方法，但是不能访问子类独有的属性和方法。例子中由于子类重写了父类的show（）方法，所以调用的show（）方法是子类的show（）方法，输出结果为：“this is a apple”,而调用子类的test（）方法则会报错。
 
2.向下转型
 
并不是所有的对象都可以向下转型，只有当这个对象原本就是子类对象通过向上转型得到的时候才能够成功转型。
 
实例化Apple类，并新建一个Fruit类的引用变量“fruit”引用该实例，然后新建一个Apple类的引用变量，引用向下转型的“fruit”变量，代码如下：
 
Fruit fruit = new Apple();
Apple apple = (Apple) fruit;
 
上述代码是允许的，因为fruit引用的对象原本就是Apple对象向上转型得到的，在对fruit向下转型后得到的还是Apple类的对象，能够被Apple类的引用变量引用。
 
假设有一个Orange类继承自Fruit类，代码如下：
 
class Orange extends Fruit{
    @Override
    public void show() {
	System.out.println("this is a Orange");
    }
    public void test() {
	System.out.println("i am a Orange");
    }
}
 
实例化Apple类，并新建一个Fruit类的引用变量“fruit”引用该实例，然后新建一个Orange类的引用变量，引用向下转型的“fruit”变量，代码如下：
 
Fruit fruit = new Apple();
Orange orange = (Orange) fruit;
 
上述代码虽然能够编译成功，但是在运行的时候会报错，因为fruit对象是由Apple对象向上转型得到的，只能够向下转型成Apple对象，不能够向下转型成Orange对象。
 
3.转型的好处
 
通过向上向下转型肯定是有好处的，比如可以减少编程代码。
 
假设在主类中定义了一个run（）方法，该方法传入一个Fruit参数，并调用了Fruit对象的show（）方法，代码如下：
 
public static void run(Fruit fruit) {
	fruit.show();
   }
 
在main（）方法中的代码如下：
 
public static void main(String[] args) {
    run(new Fruit());
    run(new Apple());
    run(new Orange());
    }
 
上述代码中，调用run（）方法时的参数不仅是Fruit对象，也可以是Apple对象和Orange对象，当传入的是Apple对象和Orange对象时，就会向上转型成Fruit对象，但是调用的show（）方法还是Apple对象和Orange对象的show（）方法。这样就不需要在主类中同时重载三个run（）方法，减少了代码量。

向上向下转型
 
 
定义一个父类Animals包含eat()方法、age初始值为0
 
然后再定义两个子类：Dog和Cat,都重写了eat()方法和age，然后再分别有自己的特有方法狗咆叫bark()，猫睡觉sleep()
 
向上转型：Animals a = new Cat()
 
向下转型：Cat cat = (Cat) a,必须要先经过向上转型的变量–再向下转型，此时cat就拥有子类自己定义的特有方法cat.sleep()
 
instanceof用法：a instanceof Cat 这里a必须是经过向上转型后的父类对象，而Cat是继承父类的子类
 
// 父类
public class Animals {
    public int age = 0;

    public void eat(){
        System.out.println("Eat...");
    }
}

// 子类 继承 父类 Animals
public class Dog extends Animals {
    public int age = 10;

    @Override
    public void eat(){
        System.out.println("eat bone...");
    }

    public void bark(){
        System.out.println("dog bark...");
    }
}

public class Cat extends Animals{
    public int age = 2;
    @Override
    public void eat(){
        System.out.println("eat fish...");
    }

    public void sleep(){
        System.out.println("cat sleep...");
    }
}

 
有一个宠物店AnimalsShop将宠物放入后，统计个数，以及可以取出该宠物
 
public class AnimalsShop {
    // 注意这里用的Animals泛型，加入宠物时，不关心宠物的具体类型
    private List<Animals> list = new ArrayList<Animals>();
    // 当加入一个宠物时，相当于进行了向上转型
    public void add(Animals a){
        list.add(a);
    }

    public int getSize(){
        return list.size();
    }
    // 取出的宠物也是经过向上转型的，此时类型为Animals
    public Animals getAnimal(int position){
        return list.get(position);
    }
}
 
public static final int DOG = 0;
public static final int CAT = 1;
    @Test
    public void test4(){
        // 通过泛型进行向上转型将不同类型的动物加入集合，此时不需要动物的不同特性，只需要知道个数即可
        AnimalsShop as = new AnimalsShop();
        as.add(new Dog());
        as.add(new Cat());

        // 获取动物个数
        System.out.println(as.getSize());

        // 查看所有的宠物
        Dog dog = (Dog) as.getAnimal(DOG); // 直接向下转型，并不安全，因为可以编译通过但运行出错
        dog.eat();
        dog.bark();

        Animals a = as.getAnimal(CAT);  // 获取已经向上转型Cat
        System.out.println(a instanceof Dog); // false，向上转型的Cat和Dog不构成子类关系
        // (（已经经过向上转型的）父类对象 instanceof 子类 ) 来判断是否可以向下转型更安全，防止ClassCastException转换异常
        if(a instanceof Cat){
            Cat cat = (Cat) as.getAnimal(CAT);
            cat.eat();
            cat.sleep();
        }

    }
 
 
 
向下转型的最大好处是：java的泛型编程，用处很大，Java的集合类都是这样的。
 参考博客
 
 
Java向下转型的意义
 
 
Java对象类型向上转型
 
 
多态的特点
 
多态的前提：
 
存在继承或实现接口extend或implement
重写方法@Override
父类引用指向子类对象Animals a = new Cat()
 
多态的特点：
 
相同变量看父类a.age = 0
重写方法看子类eat()看子类
子类特有方法不可用a.sleep()不可用
 
    public static void animalEat(Animals a){
        a.eat();
    }

    @Test
    public void test3(){
        Animals a1 = new Dog();
        System.out.println(a1.age); // 1. 变量看父类
        a1.eat(); // 2. 方法看子类
//        a1.bark();  3. 子类特有不可用

        Animals a2 = new Cat();
        a2.eat();

        // 当向上转型后，通过一个通用方法调用不同的子类，即可实现子类的方法
        animalEat(new Dog());
        animalEat(new Cat());
    }