高手指教一下区别：在这儿我就没写下面的类了，只写了测试类的代码：问题：父类引用指向子类对象 和 直接实例化对象结果还不是一样的，为什么要搞得那么复杂咧？在这里体现不出任何子类指向父类对象的好处啊（多太的一种），那么在什么情况下才能更好的看出父类引用指向子类的好处咧？【求高手指教】‘’
public class GraphicsTest {//测试程序类

public static void main(String[] args) {
Graphics gc= new Graphics();// Graphics为父类
gc.calArea();
gc = new Rect();// Rect为子类（父类引用指向子类对象）
gc.calArea();
gc = new Circle();//Rect为子类（父类引用指向子类对象）
gc.calArea();   

Graphics gc1= new Graphics();
gc1.calArea();
Rect r=new Rect ();//实例化对象
r.calArea();//调用方法
Circle c=new Circle();
c.calArea();   

}



}

这种向上转型在运行期虚拟机能够知道它的确切类型，好处是例如有方法 void fun(Father f)这时候f可以是Father的任意子类，灵活性很大，如果传递的是一个子类具体类型那就写死了。这种写法尤其是在面向接口编程中常用，如果Father是一个接口，那么每个人的实现了这个接口类的对象，这个函数都可以接收。

我觉得你这里看不明显，当你有很多同一个父类（接口）的子类同时用一个容器来存储时，你会发现取出来的时候必须重新转型才能使用确切的方法，
那么既然有共同的父类，就可以直接用父类的然后多态了，否则必须挨个判断：instanceof，显然不合理。下面是一个Tij上的例子：

1. //: c10:Shapes.java
   
2. import com.bruceeckel.simpletest.*;
   
3. 
   
4. class Shape {
   
5.   void draw() { System.out.println(this + ".draw()"); }
   
6. }
   
7. 
   
8. class Circle extends Shape {
   
9.   public String toString() { return "Circle"; }
   
10. }
    
11. 
    
12. class Square extends Shape {
    
13.   public String toString() { return "Square"; }
    
14. }
    
15. 
    
16. class Triangle extends Shape {
    
17.   public String toString() { return "Triangle"; }
    
18. }
    
19. 
    
20. public class Shapes {
    
21.   private static Test monitor = new Test();
    
22.   public static void main(String[] args) {
    
23.     // Array of Object, not Shape:
    
24.     Object[] shapeList = {
    
25.       new Circle(),
    
26.       new Square(),
    
27.       new Triangle()
    
28.     };
    
29.     for(int i = 0; i < shapeList.length; i++)
    
30.       ((Shape)shapeList[i]).draw(); // 这里
    
31. //monitor.expect后面是预期打印结果
    
32.     monitor.expect(new String[] {
    
33.       "Circle.draw()",
    
34.       "Square.draw()",
    
35.       "Triangle.draw()"
    
36.     });
    
37.   }
    
38. } ///:~
    

复制代码