Read Sean

謝謝您，學到很容易忽略的東西，覺得很重要
再謝謝你...

>>只有方法的多態而沒有字段的多態

以前都沒有想過這個問題哦。

前兩天遇到一個內嵌類的方法重載時候的古怪問題，不知是否與此有關，正好回頭去研究一下。

Java的對象模型偶不太清楚，不過通過對Delphi的對象模型的了解，我感覺應該和Java沒有太大的區別。

按照樓主所說的，當執行了語句“a=b”后，變量a和b的內容應該是不變的，所變的是a指向的對象實體中的指向類的指針的內容，在Delphi中，這個指針叫做vptr，CPP中也是如此叫法。vptr直接指到類的VMT（不知道Java中如何叫法）；因此，再次使用a.s訪問實例變量，則要進入b指向的對象實體中進行字段的查找，但由于b里面存在兩個s字段，并且以類型信息為區分方式，所以找到的是類型A的字段s。至于編譯處理方面，我想應該是把類型信息作為字段的前綴或者后綴。

同樣，當執行了“（（A）b）.s=“[AA]””后，由于已經把b的類型轉化為A類型，而且b指針的未改變，所以在b的對象實體中，實際改變的是屬于類型A的字段s的內容。個人感覺，其實樓主已經說出了，對b中不同類型的同名字段的訪問方式。

最后留下一個問題：這種對象模型中的字段處理方式如果在繼承字段訪問量小的情況下是很浪費空間的。那么，這樣處理的優點又是什么？

按照OO這種東西在語言設計上的考慮，對象所涉及到的所有內容就是三塊：對象指針，對象實體和對象所屬類型的內存布局。而對象實體中只存放狀態信息，即對象所屬類型的實例字段的內容，因此，從這個角度考慮，多態和實例字段的信息是沒有任何關系的。但對于類字段，即申明為static的字段就未必了。

System.out.println(a.s); // prints "[A]"
這句確實我沒想到！看來真被難倒了

非常感謝

我是想到了,不過就像樓主所說的,這種編碼風格不好,子類盡量不要用父類用過的變量名,真的是容易搞混,這種代碼用來考試可以,但用來編程不好.

請問：
java中字符串的連接是不是一種多態的表現？

@tcpipok
我不知道你是否理解OO真正的精髓，以上用法展示了面向對象設計的核心思想，通過虛方法調用，實現不同子類對同一行為（方法）的不同實現。希望以下例子可以給大家一些啟發：

public class Employee {

protected String name = "張三";

private double salary = 1000;

public Employee(String name, double salary) {
this.name = name;
this.salary = salary;
}

public Employee() {
this("王老五", 1);
}

public String getDetails() {
return "姓名:" + this.name + ", 工資: " + this.salary;
}

public double getSalary() {
return this.salary;
}

public void setSalary(double salary) {
this.salary = salary;
}

public String getName() {
return this.name;
}

public void setName(String name) {
this.name = name;
}

public boolean equals(Object o) {
if (this == o) {
return true;
}

if (o instanceof Employee) {
Employee te = (Employee) o;

return this.salary == te.getSalary() && this.name.equals(te.getName());
}

return false;
}

public int hashCode() {
if (this.name == null) {
return 0;
}
return this.name.hashCode();
}

public String toString() {
return "$$" + this.getDetails();
// return super.toString();
}

public static void printAll(Employee[] all) {
System.out.println("所有員工:");
for (int i = 0; i < all.length; ++i) {
System.out.println(all[i].getDetails());
}
}

public static void main(String[] args) {
Employee e = new Employee("張三", 2500);
System.out.println(e.getDetails());

Manager m = new Manager("李四", 4500, "軟件開發部");
System.out.println(m.getDetails());

Employee ee = new Manager("王五", 4500, "軟件銷售部");
System.out.println(ee.getDetails());

if (ee instanceof Manager) {
Manager mmm = (Manager) ee;
System.out.println(mmm.getDepartment());
}

Employee e2 = new Employee("張三", 2500);
System.out.println(e.equals(e2));

System.out.println(e);
System.out.println("##" + e);

Employee[] eAll = {
e, m, ee
};
printAll(eAll);
}
}

class Manager extends Employee {
private String department = "44";

public Manager() {
super();
this.department = "計算機";
}

public Manager(String name, double salary, String department) {
super(name, salary);

this.department = department;
}

public String getDetails() {
return super.getDetails() + ", 管理部門: " + this.department;
}

public String getDepartment() {
return this.department;
}
}

核心在
public static void printAll(Employee[] all) {
System.out.println("所有員工:");
for (int i = 0; i < all.length; ++i) {
System.out.println(all[i].getDetails());
}
}
函數的設計上，通過Employee隱藏所有雇員子類的細節，通過getDetails()方法來隱藏不同雇員（Manger，Engineer等）對詳細信息的函數細節。

只有這樣的函數才能最大程度上復用，既當設計有新的Employee子類定義也不許要對此函數做任何的修改，個人認為面向對象的最大好處是提高程序的復用性，降低維護成本。這些需要多態，繼承才能作到。：）

謝謝 谷鈺 的回復!

to 谷鈺,你的代碼也沒有回答tcpipok的疑問啊。子類和父類定義相同的屬性有意義嗎？

寫的太好了。
學習了很多。