Question

两类 public class A{ } public class B extends A{ } 那么 A a=new B()与B b=new B(); 两者有什么区别?

多态，父类引用指向子类对象好处到底在哪里？？越详细越好！谢谢！

Answer 1

A a = new B();
这条语句的意思是，通过B()构造方法创建一个类型为A，名字为a的对象。
对象都要具有类型，本语句中a对象的类型是A。
构造之后才能有对象，这条语句a对象构造自B()。
对象的能够具有的属性，以及它的行为是由它的类型决定的，与它如何构造而来无关。
这条语句，a的类型是A，换句话说，a是A的对象，那么a只能具有A类确定的属性和行为，不能具有B类有，A类没有的属性和行为。
希望能够帮上你……

继续回答你的补充问题：
多态，父类引用指向子类对象好处到底在哪里？？
我们编写代码的目的是什么——是为了解决问题。
我们用什么解决问题——使用对象和对象之间的相互关系解决问题。
什么是对象——对象是某一个类型的“客观存在”。
如何让对象客观存在——构造一个对象。
对象的属性和行为由谁决定——它的类型。
什么是对象之间的关系——类型的行为是对象之间的关系，对象之间的组合/聚合是对象之间的关系。
对象之间的关系与类之间的关系有什么区别——对象之间只有组合/聚合，以及对象行为决定的关系，没有继承，实现等类的关系。
对象与它的类型之间是什么关系——对象的行为由类决定（指对象的行为已经有类实现），对象能够具有的属性与类一致——但对象已经为这些属性赋值了。
类应该如何理解——类是一种抽象概念，它确定了某个抽象能够具有的属性，以及它的对象行为实现。
什么是多态——1，子类与父类具有同样名称，同样输入的行为，但子类行为内部实现与父类不同。2，类的行为接受的输入不同，但行为的名字一致。
如：电器有行为打开，打开时需要输入打开按钮，打开后什么也不做。电视有行为“打开”——输入的打开命令为遥控器的开关按钮，打开后显示中央一套电视节目，手机有行为“打开”——输入的打开命令为开关键按钮，打开后显示手机欢迎屏幕。那么，虽然电器的打开，电视的打开，手机的打开都接受“打开按钮”类型的输入，但打开的实现过程不同，则构成了多态。
对于第二种情况，我们要解决问题：小明打开一个电器。
这里有两个对象：一个人（小明），一个电器。两个对象之间有关系，是电器的打开行为：人的对象调用电器对象的打开行为，就能解决问题了。
小明这个对象不需要知道他打开的电器是电视还是手机，反正他就是打开了一个电器。如果电器的对象来自于电视的构造，则小明打开的就是电视；如果电器的对象来自手机的构造，则小明打开的就是手机。
所以，电器有打开这个行为，电器的子类复写这个行为，构成多态，能够简化对象之间的关系。
再如，还是这个问题：小明打开一个电器。
这里有两个对象：一个人（小明），一个电器。还有他们之间的关系，打开。
这次我们将打开这个行为放到人这个类上。那么，小明就具有打开的行为。
由于目的不同，人要打开的东西不同。那么，打开这个行为在人这个类中，可能具有三种实现，分别为打开电视，打开手机，还有更广泛的打开电器。这三个行为名字相同，都是打开，只不过是行为的输入具有电视，手机，电器的区分。这是说，方法名一样，方法的输入参数类型不同。
当小明要打开电视是，小明只需要执行他的打开行为，输入电视即可；如要打开手机，则执行它的打开行为，输入手机即可。
所以说，多态给了对象更多的目的选择。

对于第一个例子，我们如何写代码呢？
class 电器{
public void 打开(){
System.out.println(“我什么也不做。”);
}
}
class 电视 extends 电器{
public void 打开(){
System.out.println(“打开中央一套。”);
}
}
class 手机 extends 电器{
public void 打开(){
System.out.println(“打开欢迎屏幕。”);
}
}
class 人{
private 电器 我的电器;
private String 名字;
public 人(String 名字){
this.名字=名字;
}
public void set(电器 一个电器){
我的电器=一个电器;
}
public void open(){
我的电器.打开();
}
}
// 解决问题
public static void main(String args[]){
电器 一个电器 = new 电器();
电器 一个电视 = new 电视();
电器 一个手机 = new 手机();
人 小明 = new 人("小明");
小明.set(一个电器);
小明.open(); // 打开了一个电器
小明.set(一个电视);
小明.open(); // 虽然一个电视的类型是电器，但调用打开行为，使用的是电视的打开行为，所以打开的是中央一套。
小明.set(一个手机);
小明.open(); / //打开的是手机。
}

Answer 2

我们从小了看就应该清楚多了

比如我有B,C,D继承A

那我现在要实现他们的共同功能eat();他们吃饭方法不同，要重写
你可以这样写
B b=new B();
b.eat();
C c=new C();
c.eat();
D d=new D();
d.eat();
同样的你把这改成
A b=new B();
b.eat();
A c=new C();
c.eat();
A d=new D();
d.eat();
你发现暂时没区别。可是认真看一下会发现有个地方有规律，就是开关是一样的。
好了，如果你这样想就是好的开始

我们来写个方法
public void eat(A a){
a.eat();
}
这个方法可以传入继承它的类。假如同样的b c d
eat(b)
eat(c)
eat(d)
这个是通过参数来实现多态。
用一个方法来实现，如果不这样写的话，你必须写三个。因为他们三个类型不一样。

好了有点扯远了。
这样讲，现在来帮你区别A a=new B();和B b=new B();
假设我在b方法里有个特别的方法，A里没有。
那么用第一种。你点不出来。
用第二种，你点得出来。

那你可能会再想，那第两种不是更好吗？
问题就在，如果你用第两种方式的时候，你可以试一下，通过F3可以追踪到原代码，换句话就不安全。
如果你用第一种的话，它会追踪到A。一般A这里是抽象方法(以后会是接口)，保证它的安全性。

总结一下就是：
父类指向子类，一是便于实现多态，可以通过父类当参数，或者当返回类型都可以
第二是出于安全考虑。
至于其他的暂时也不多说了

追问

谢谢！虽然我已经没分了！但是我发至内心的感谢！谢谢合作！

追答

呵呵，这重东西理论的挺多。你有空就用小事例，自己写写就会明白了

Answer 3

可以向上转型啊，去看看向上转型吧。那里很详细