Java多态的使用注意事项

java多态是如何实现的？
java的多态和c++一样，是通过延时绑定（late binding）或者说运行时绑定（runtime binding）来实现的。当调用某一个对象引用的方法时，因为编译器并不知道这个引用到底指向的是变量声明时说明的类型对象，还是该类型子类的对象。因此编译器无法为这次调用绑定到具体的某个方法。只有通过java中的运行时类型识别（rtti, runtime type identification）在运行时绑定到具体的方法。下面是一个具体的例子：

class shape
{
    public void draw()
    {

   print("shape");
    }
}
class triangle extends shape
{
    public void draw()
    {

   print("triangle");
    }
}
public class polymorphism {
public static void main(string[] args)
{
    shape s=new triangle();
    s.draw();
}

结果是triangle
s是一个shape引用，但是在运行时因为是triangle对象，所以还是调用了triangle的draw方法。

java多态中的一些陷阱

重写私有方法？
java里面是不能重写私有方法的，这个其实很好理解，因为私有方法在子类是不可见的。子类没有继承父类的私有方法，更谈不上重写了。因此在子类中的同名方法是一个全新的方法。

public class polymorphism {
    private void show()
    {

   print("show parent");
    }
public static void main(string[] args)
{
    polymorphism p=new privatemethod();
    p.show();
}
}
class privatemethod extends polymorphism
{
    public void show()
    {

   print("show derived");
    }
}

结果是 show parent

字段和静态方法的多态？
子类可以继承父类的非私有字段，子类的字段是否也具有多态性呢？我们来看一个实际的例子：

class shape
{
    protected int perimeter=1;
    public void draw()
    {

   print("shape");
    }
    public int getperimeter()
    {

   return perimeter;
    }
}
class triangle extends shape
{

int perimeter=3;
    public void draw()
    {

   print("triangle");
    }
    public int getperimeter()
    {

   return perimeter;
    }
    public int getsuperperimeter()
    {

   return super.perimeter;
    }
}
public class polymorphism {

public static void main(string[] args)
{
    shape s=new triangle();
    print("s.perimeter:"+s.perimeter);
    print("s.getperimeter:"+s.getperimeter());
    triangle t=new triangle();
    print("t.perimeter:"+t.perimeter);
    print("t.getperimeter:"+t.getperimeter());
    print("t.getsuperperimeter:"+t.getsuperperimeter());
}
}

以下是运行结果：

这个运行结果包含了以下信息：
1.triangle对象向上转型成shape后字段直接访问都是由编译器确定的，因此不会表现出多态性，返回的是1。
2.triangle对象向上转型成shape后调用方法访问字段是根据运行时对象类型延时绑定调用了triangle的getperimeter方法，返回的是3
3.t对象中包含了两个perimeter字段，一个来自于他本身，一个来自于他的父类。同时用字段名去调用该字段时默认返回的是他本身的perimeter字段，要调用从父类继承的该字段，要用super.perimeter的方法。
这个结果看起来多多少少让人有些疑惑，为了避免这种情况出现，我们一般都把字段声明为private（子类就无法继承），同时我们在子类中声明的字段最好不要与从父类继承的字段同名。
静态方法是没有多态性的，因为静态方法是和类绑定的，不会存在不知道具体类型的情况。

构造函数的多态性？
构造函数是不具有多态性的，因为构造方法本身是静态方法（如果不是的话，就会陷入鸡生蛋，蛋生鸡的死循环了）。要引入我们的问题，先来看一下构造函数的调用顺序。
1.为这个对象分配的存储空间都被初始化为0（对象初始化为null）
2.父类的构造函数调用（这样才能保证在子类的构造函数中访问的字段被初始化）
3.成员变量初始化
4.子类的构造函数调用

现在假设如果在第二步中，我们在父类的构造函数里调用了某个方法，这个方法是不是多态的？还是来看一个具体的例子：

class shape
{
    protected int perimeter=1;
    public shape()
    {

   draw();

   print("shape created");
    }
    public void draw()
    {

   print("draw shape "+perimeter);
    }

}
class triangle extends shape
{

int perimeter=3;

public triangle()

{

    print("triangle created");

}
    public void draw()
    {

   print("draw triangle "+perimeter);
    }
    public int getperimeter()
    {

   return perimeter;
    }
}

public class polymorphism {

public static void main(string[] args)
{
    shape s=new triangle();
}
}

运行结果：

 

我们可以看到虽然triangle对象还没有构造完毕，draw方法仍是动态绑定到了triangle的draw方法。同时注意到perimeter的值还没有初始化为3，而是0。

这样的结果就是我们在triangle对象还没有被初始化之前就访问了其中的字段。因此我们在实际应用中要避免在构造函数中调用其他方法，或者只调用私有方法（不会被继承，因此不会引发该问题）