一、向上转型和向下转型
 
       向上转型和向下转型是在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 强制类型转换异常
 
 
 
如果觉得对你有帮助，点个赞再走吧！

基础知识：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（）方法，减少了代码量。

上一条博客中我们一起了解了Java向上转型的意思以及它的优点，但同时也知道了在向上转型的过程中子类对象将不能调用其独有的方法。那我们怎么样才能既实现向上转型，又能使子类可以调用其独有的方法呢，这就需要使用向下转型了。 
 注意 
 向下转型必须是在向上转型之后才能进行。
 
我们还是以汽车为例。代码如下：
 
class Car {
    public void run() {
        System.out.println("这是父类run()方法");
    }
}

public class Benz extends Car {
    public void run() {
        System.out.println("这是Benz的run()方法");
    }

    public void price() {
        System.out.println("Benz:800000$");
    }

    public static void main(String[] args) {
        Car car = new Benz();// 先进行向上类型转换
        // car.price(); 此时还不能调用子类独有方法
        Benz benz = (Benz) car;// 向下类型转换
        benz.price();// 经过向下类型转换后可以调用子类中独有的方法
    }
}
 
运行结果： 
 此时我们通过向下转型成功的调用了子类中独有的方法，但是倘若我们没有先进行向上转型，也就是如下的代码：
 
    public static void main(String[] args) {
        Car car2 = new Car();
        Benz benz2 = (Benz)car2;
        benz2.price();
    }
 
编译使未报错，但运行后程序出现错误： 
  
 这个是指类型转换异常，因为我们一开始直接new了一个父类的对象，当我们后面去使用Benz去强制类型转换的时候，由于benz2是子类的对象，而car2是父类的对象，前者的域小于后者，这个时候我们直接向下转型就会发生这个错误。 
 所以使用向下转型之前必须先进行向上转型
 
 
对于上面这个异常，我们可以通过使用instanceof这个关键字来解决。 
 instanceof用法： 
 对象名 instanceof 类名 ，判断这个对象是否是属于这个类或是其子类 
 代码如下
 
public static void main(String[] args) {
        Car car2 = new Car();
        boolean result = car2 instanceof Benz;// 判断car2这个对象是否是Benz的类（或是其子类），返回的是一个布尔值
        if (result) {// 如果是(true)，则可以进行向下类型转换
            Benz benz2 = (Benz) car2;
            benz2.price();
        } else {// false,输出
            System.out.println("不能进行向下类型转换");
        }

    }
 
运行结果： 
  总结
 
 向下转型在Java的泛型编程中应用较多，只要记住向下转型之前必须进行向上转型，且配合instanceof关键字一起使用就可以了。 

java 向下转型与instanceof关键字-总结
 


 
文章目录
 
java 向下转型与instanceof关键字-总结
1. 向下转型和instanceof关系
1.1. 为什么要有向下转型
1.2. 向下转型和instanceof有什么关系
    
2. 向下转型和instanceof示例Demo
2.1. 父类 Person
2.2. 子类 Man
2.3.子类Woman
2.4. 多态向下转型和instanceof
   
  
 

 
1. 向下转型和instanceof关系
 
1.1. 为什么要有向下转型
 
 
 
向下转型出现的原因：有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。
 如何才能调用子类特有的属性和方法：向下转型：使用强制类型转换。
 
 
		//Person是父类；Man是子类；Woman是子类；
		//对象的多态性：父类的引用指向子类的对象
        Person per = new Man();
        //强制将Person类型装换为Man类型
        Man man = (Man) per;
        man.setManId(111);
        System.out.println("使用向下转型调用子类特有的属性和方法");
 
1.2. 向下转型和instanceof有什么关系
 
 
 
使用强转时，可能出现ClassCastException的异常。
 为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。
 
 
		//使用强转时，出现 java.lang.ClassCastException 异常
        Woman woman = (Woman) per;
        woman.setWomanId(222);
 
2. 向下转型和instanceof示例Demo
 
2.1. 父类 Person
 
package tepmdemo.instanseof;

/**
 * @author bruce
 * 
 */
public class Person {
    protected String name;
    protected int age;

    protected void eat() {
        System.out.println("人吃饭");
    }

    protected void walk() {
        System.out.println("人走路");
    }
}
 
2.2. 子类 Man
 
package tepmdemo.instanseof;

/**
 * @author bruce
 *
 */
public class Man extends Person{
    private int manId;

    //重写父类eat方法
    @Override
    public void eat() {
        System.out.println("男人吃饭是为了挣钱");
    }

    //重写父类walk方法
    @Override
    protected void walk() {
        System.out.println("男人走路去上班");
    }

    //Man子类特有的方法
    protected void setManId(int manId) {
        this.manId = manId;
        System.out.println("男人的ID:"+this.manId);
    }
}
 
2.3.子类Woman
 
package tepmdemo.instanseof;

/**
 * @author bruce
 * 
 */
public class Woman extends Person {
    private int womanId;

    //重写父类eat方法
    @Override
    protected void eat() {
        System.out.println("女人吃饭是为了购物");
    }
    
    //重写父类walk方法
    @Override
    protected void walk() {
        System.out.println("女人走路去逛街");
    }

    //WoMan子类特有的方法
    public void setWomanId(int womanId) {
        this.womanId = womanId;
        System.out.println("女人ID："+this.womanId);
    }
}
 
2.4. 多态向下转型和instanceof
 
package tepmdemo.instanseof;

/**
 * @author bruce
 * 
 */
public class App {
    public static void main(String[] args) {
        System.out.println("--------------------多态的应用-------------------------");
        //对象的多态性：父类的引用指向子类的对象
        Person per = new Man();
        //多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
        per.walk();
        per.eat();

        System.out.println("--------------------向下转型应用-----------------------");
        /**
         * 1.有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致
         * 编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。
         * 2.如何才能调用子类特有的属性和方法？
         * 3.向下转型：使用强制类型转换符，向下转型原理和基本类型的double类型转int类型一样都需要强制装换。
         */
        //强制将Person类型装换为Man类型
        Man man = (Man) per;
        man.setManId(111);
        System.out.println("使用向下转型调用子类特有的属性和方法");

        System.out.println("--------------------instanceof关键字-----------------------");

        //使用强转时，可能出现 java.lang.ClassCastException 异常
//        Woman woman = (Woman) per;
//        woman.setWomanId(222);

        /*
         * instanceof关键字的使用
         *
         * a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。
         *
         *
         *  使用情境：为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先
         *  进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。
         *
         *  如果 a instanceof A返回true,则 a instanceof B也返回true.
         *  其中，类B是类A的父类。
         */

        if (per instanceof Man) {
            Man mans = (Man) per;
            mans.setManId(1);
        }

        // 向下转型判断per不属于Woman，不执行里面的语句。
        if (per instanceof Woman) {
            Woman womans = (Woman) per;
            womans.setWomanId(2);
        }
    }
}