Java 向上转型的问题

Question

引用他人的一段解释：
方法     打(XX){     },基中XX代表一基类   
子类   人和水都继承XX   
调用打(new   人()),打(new   水()),很显然行为是不一样的,但它可以正常的执行。我的问题是这样做有什么好处？
如果按照一般的写法：人 a ＝　new   人()；a.打();
                    水 b ＝　new   水()；b.打();
转型的写法：打(new   人())；打(new   水())；代码量上来说没减少什么，这样做的好处是什么呢？

Answer 1

郁闷……  看见中文的就累   就想起我们学校上JAVA时的那本教材！闪

Answer 2

只是举个例子！
我换成thinking in Java 的写法算了
class Shape {
  public void erase(){
    //若干处理
  }
}
class Circle extends Shape {
  public void erase(){
    //覆盖父类若干处理
  }
}class Line extends Shape {
  public void erase(){
    //覆盖父类若干处理
  }
}class XXX {
  void doSomething(Shape shape) {
     shape.erase();
     //....
  }
  
  public static void doMain(String[] args) {
    Circle c = new Circle();
    Line l = new Line();
    doSomething(c);
    doSomething(l);
  }
}如果上面的例子没有向上转型，没有继承，没有doSomething这个方法。
代码应该是这样的class XXX {
  public static void doMain(String[] args) {
    Circle c = new Circle();
    Line l = new Line();
    c.erase();
    l.erase();
  }
}
同样是4行代码，向上转型好在什么地方呢？

Answer 3

好处是动态的决定调用哪个子类，实现了java的多态。
应用环境如：打印机（父类）子类：黑白打印机
      彩色打印机当你调用打印机（不知道是哪个子类）打印时，你不用知道是哪个子类实现的打印方法，而子类的实例化是在程序的其它地方实现的。

Answer 4

请问你不知道哪一个子类的话括号里的参数难道用new 父类()的写法吗？
在你实际应用到这个方法的时候还是要把子类的对象放到参数中去吧！

Answer 5

改了一下楼主的代码，加上说明，希望你明白使用了向上转型的代码如下：
class Shape { 
  public void erase(){ 
    //若干处理 
  } 
} 
class Circle extends Shape { 
  public void erase(){ 
    //覆盖父类若干处理 
  } 
} class Line extends Shape { 
  public void erase(){ 
    //覆盖父类若干处理 
  } 
} 
class Eraser {
void cleanBoard(Shape shape){
shape.erase();
}
}class MainMethod { 
  
  public static void main(String[] args) { 
    Eraser earser = new Eraser();
    earser.cleanBoard(New Line());
    earser.cleanBoard(New Circle());
  } 
} 结论：使用了向上转型，无论在main method里增加什么shape的继承对象，都不需要修改Eraser类
不使用向上转型的代码应该是这样的：class Eraser {
void cleanBoard(Circle circle){
circle.erase();
}

void cleanBoard(Line line){
line.erase();
}
}
class MainMethod { 
  public static void main(String[] args) { 
    Eraser eraser = new Eraser();
    earser.cleanBoard(New Line());
    earser.cleanBoard(New Circle());
  } 
} 结论：每当MainMethod里增加一种shape的继承对象，你都不用去修改Eraser类重写cleanBoard函数

Answer 6

向上转型有什么好处？这么说吧。   现在有一个基类A，有3个子类B,C,D   那么我有一个方法接受A类型的参数，那么A，以及A的子类都是我接受的范围了。void fc(A x){}   这样一个方法，那么所有A类（包括A本身，以及任何A的子类，都是我所接受的范围。）如果没有继承，没有向上转型。   我要写一个能够接受A,B,C,D四个类的方法，那么我得这样 void fc1(A x){} void fc1(B x){} void fc1(C x){} void fc1(D x){}  ，但是事实上这些方法的功能都是一样的。但是因为不能向上转型，类型的问题，而导致我得把一个同样功能代码块，重载4次。    那不是累死了。

Answer 7

楼上的两位似乎侧重点和我想得不一样。
我看到的是main方法里面代码的行数还是没变。
9楼的朋友的结论：
不使用向上转型的代码应该是这样的： class Eraser { 
void cleanBoard(Circle circle){ 
circle.erase(); 
} void cleanBoard(Line line){ 
line.erase(); 
} 
} 
class MainMethod { 
  public static void main(String[] args) { 
    Eraser eraser = new Eraser(); 
    earser.cleanBoard(New Line()); 
    earser.cleanBoard(New Circle()); 
  } 
} 
但是如果我这么改呢class MainMethod { 
  public static void main(String[] args) { 
    Eraser eraser = new Eraser(); 
    Line l = New Line(); 
    l.erase(); 
    Circle c = New Circle(); 
    c.erase(); 
  } 
} 
代码是不是反而变少了？10楼的朋友，你所说的void fc(A x){}  这样的一个代码，能不能这么理解，这个方法被调用的时候，肯定要在那个调用的方法里面（先认为是main方法）New 一下这个A类。那个时候还是要根据情况来分别New B,C,D吧！
可以总结成这样的形式：
使用向上转型：main方法New A,B,C,D类-->把New出来的类作为参数传给那个以基类作为参数的方法-->在以基类作为参数的方法里面，调用 A,B,C,D这些类的共有方法。
不使用向上转型：main方法New A,B,C,D类--->main方法调用A,B,C,D类的方法。明显是不使用向上转型来的简单。我们增加一个E类。向上转型的第二步不用修改，但是第一步还是要修改。和下面不使用向上转型的结果还是一样。我还是不了解向上转型的优势在哪里？

Answer 8

呵呵，就拿我现在做的一个游戏来说吧，游戏里面所有能动的东西我都将它继承与Actor类，在Jpanel里面我重写了她的paintComponent方法，每次都将整个画面重绘，重绘的过程中，我就必须将每个能动的东西重绘，因为他们都继承于Actor类，所以我创建一个Actor[]数组，挨个重绘就可以了。如果不用这个方法，我如让他们挨个重绘呢？我觉得会很恼火~~

Answer 9

这个可以写在配置文件里，然后利用java的反射机制实现松耦合。可以用spring里的ioc容器实现