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的疑问啊。子类和父类定义相同的属性有意义吗？

写的太好了。
学习了很多。