Java向上转型的结果解析与意义

相信很多初学者学到向上转型时，都是一头雾水，而我当时也有同样的疑问：

Fatherclass obj = new Sonclass();

???这是什么东西?到底是子类对象还是父类对象？

再来看一个例子：

class Quadrangle{ //Quadrangle:四边形
public static void draw(Quadrangle obj){
System.out.println(" 画了一个四边形");
}
}
public class Parallelogram extends Quadrangle{//Parallelogram:平行四边形
public static void main(String[] args){
Parallelogram p = new Parallelogram();
draw(p);
}
}

是可以run，没有异常出现的。
p是一个平行四边形对象，四边形类存在draw()方法,参数类型为四边形类型。而在主方法中调用draw()时传入的参数却是平行四边形类型的。
**平行四边形也是一种四边形，所以可以吧平行四边形对象看做成一个四边形对象。
这就相当于：
Fatherclass obj = new Sonclass();
**
把子类对象赋值给父类类型对象，这种技术被称为：“向上转型”。

那这些对象在调用方法和属性时，会怎么样呢？

class Animal{
	String name = "Animal";
	public Animal() {
		System.out.println("Animal类的构造方法");
	}
	public void eat() {
		System.out.println("父类Animal的eat方法");
	}
}

class Bird extends Animal{
	int age = 5;
   String name = "Bird";
	public Bird() {
		System.out.println("Bird类的构造方法");
	}
	public void eat() {
		System.out.println("子类Bird的eat方法");
	}

    public void fly() {
    	System.out.println("子类Bird的fly方法");
    }
}

定义父类Animal和子类Bird，Animal类有一个成员变量name（“Animal”）,构造方法和eat方法。
Bird类有两个成员变量name（“Bird”）&age（5）构造方法和继承重写的eat方法和独有的fly方法。
实现代码：

public class Main {
	public static void main(String[] args) {
		Animal Nancy = new Bird();
		System.out.println(Nancy.name);
		Nancy.eat();
	}
}

run结果：

Animal类的构造方法
Bird类的构造方法
Animal
子类Bird的eat方法

在newNancy这个对象时，子类Bird和父类Animal的构造方法都被执行。
输出Nancy的属性name，结果是父类的成员变量name。
Nancy执行eat方法，结果是子类继承后重写的eat()方法。
可以看出：这样的一个对象，在创建时会把子类和父类的构造方法都执行一遍；若父类和子类有同名不同值的成员变量，则向上转型的对象的该同名属性是父类的；执行重名的方法执行的是子类的。

如果子类独有的方法和变量呢？

class Animal{
	String name = "Animal";
	
	public Animal() {
		System.out.println("Animal类的构造方法");
	}
	public void eat() {
		System.out.println("父类Animal的eat方法");
	}
}

class Bird extends Animal{
	int age = 5;
	String name = "Bird";
	public Bird() {
		System.out.println("Bird类的构造方法");
	}
	public void eat() {
		System.out.println("子类Bird的eat方法");
	}

    public void fly() {
    	System.out.println("子类Bird的fly方法");
    }
}
public class Main {
	public static void main(String[] args) {
      Animal Nancy = new Bird();
        Nancy.fly();
        System.out.println(Nancy.age);
		}
}

程序抛出异常：

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
	The method show() is undefined for the type Animal
	age cannot be resolved or is not a field

	at Main.main(Main.java:30)

也就是说，向上转型后的对象，无法调用子类独有的方法和属性。
目前为止我们没有发现任何向上转型的好处，反而处处蛋疼。那么他的作用到底在哪呢？
其实Fatherclass obj = new Sonclass();*用不大，重要的是向上转型的思想：
吧子类对象看作是父类对象。

class Animal{
}
class Bird extends Animal{
}
class Dog extends Animal{
}
public class Main {
	public static void eat(Animal obj) {
		System.out.println("eat");
	}
	public static void main(String[] args) {
       eat(new Bird());
       eat(new Dog());
	}
}

参数为Animal obj的eat方法，可以让Bird和Dog对象成为参数。可以少写很多方法，提高代码简洁性。

//新人第一次写文章第一次发表文章！多多支持！谢谢大家！