向上转型、向下转型和instanceof

1.向上转型

        里氏替换原则：所有要求父类对象出现的地方，子类对象都可以替换他（子类比父类更强大）。

        结构：

                 父类类型   应用   =   new   子类类型();        ---------自动转型

                （父类引用指向子类实例对象）

        向上转型后，可以调用父类派生给子类的方法和子类重写父类的方法，但不能调用子类独有的方法。

        好处：

                面向父类编程，方便扩展

        缺点：

                用不了子类特有的方法（如果想要子类特有的方法就必须向下转型）

例如：

创建一个Animal类

public class Animal {
	private String  name;
	private int month;
	public Animal(){
		
	}
	public String getName() {
		return name;
	}
	public int getMonth() {
		return month;
	}
	
	public double getWeight() {
		return getWeight();
	}
	public void eat() {
		System.out.println("动物在吃饭");

        创建一个Dog类 

public class Dog extends Animal{
	public void eat() {
		System.out.println("小狗在吃饭");        //重写eat方法
	}

        创建一个Cat类

public class Cat extends Animal{
	public void eat() {
		System.out.println("小猫要吃饭");
	}

        创建一个测试类：
 

public class AnimalText {

	public static void main(String[] args) {

		Animal[] animal = new Animal[2];	//创建一个对象数组	
		animal[0] = new Dog();
		animal[1] = new Cat();
		
		for (Animal anima : animal) {
			anima.eat();;
		}
		

	}

}

输出：

 2.向下转型

        子类引用类型   引用   =   （子类类型）父类类型对象；    ----强制转型    有可能引发 实例化异常（ClasscastException.）     

        子类引用指向父类对象，需要强制类型转换， 因为向上转型是从大到小，不需要强制转换，而向下转型是从小到大。例如：double类型转成int类型就不需要强制转换，而int型转double型需要强制转换。

代码如下：

public class Demo {

	public static void main(String[] args) {
		int i = 2;
		double j = i;
		
		double n = 2;
		int m = (int)n;
		
		System.out.println(i == j);
		System.out.println(n == m);
		
	}

}

执行结果：

        转型条件：将一个指明子类对象的父类应用赋值给这个子类的引用；向下转型时父类对象必须和子类类型有直接或间接关系的才可以，不能是任意的。例如（在上面向上转型的举例中）：Dog类实例化赋值给Animal类对象后，不能再向下转型为Cat类型的对象，只能向下转型Dog类型的对象。

代码如下：

public class AnimalText {                            //1

	public static void main(String[] args) {         //2

		Animal[] animal = new Animal[2];		     //3
		animal[0] = new Dog();                       //4
		animal[1] = new Cat();                       //5
		
		Dog d = (Dog)animal[1];                      //6
		Dog d1 = (Dog)animal[0];                     //7
	}

}

         上述程序中，第六行代码虽然编译没有问题，但是运行时会出错（实例化异常（ClasscastException.）），第七行是没有问题的。

        而在编码的过程中，时长要考虑向下转型会不会出现 实例化异常 的问题，所以Java提供了instanceof关键字。

3.instanceof关键字

         boolean result = (a instanceof b)     a是对象，b是类、接口、数组
                  ==>a是b的实例化对象，如果a对象直接或者间接是b的子类返回true
                  ==>a既不是b的实例化对象，也不是b类直接或间接的子类对象则返回false

        所以向下转型之前需要先进行类型判断，通过instanceof来实现。

代码如下

public class AnimalText {

	public static void main(String[] args) {

		Animal[] animal = new Animal[2];		
		animal[0] = new Dog();
		animal[1] = new Cat();
		
		for (int i = 0; i < animal.length; i++) {
			if (animal[i] instanceof Dog) {
				Dog d = (Dog)animal[i];
				d.eat();
			}
		}
		System.out.println("================");
		for (int i = 0; i < animal.length; i++) {
			if (animal[i] instanceof Cat) {
				Cat c = (Cat)animal[i];
				c.eat();
			}
		}
	}

}

输出：

         注意：在使用instanceof关键字时，animal[0] instanceof Animal、animal[0] instanceof Object返回的都是true

public class AnimalText {

	public static void main(String[] args) {

		Animal[] animal = new Animal[2];		
		animal[0] = new Dog();
		animal[1] = new Cat();
		
		System.out.println(animal[0] instanceof Animal);
		System.out.println(animal[0] instanceof Object);
		

	}

}

输出：

 但是不可以 

public class AnimalText {

	public static void main(String[] args) {

		Cat cat = (Cat)new Animal();
		Dog dog = (Dog)new Animal();
		
	}

}

        上述两个向下转型时错误的，因为Animal实例化，可以实任何动物，不仅仅是猫或者狗。

        点个赞吧，家人们