Java “覆盖”私有方法，域，静态方法存在的转型“缺陷”

今天，我们讲的是关于Java在转型时需要注意的问题。现在就开始今天的话题。

在Java中我们经常使用继承，对于转型也一样，然而当转型遇到私有方法、域、静态方法会怎样呢？

1. “覆盖”私有方法

有以下代码：

class Derived extends Test_1{
    public void f(){System.out.println("public f()!");}
}

public class Test_1 {
    private void f(){System.out.println("private f()!");}
    public static void main(String[] args){
        Test_1 po=new Derived();
        ((Derived) po).f();
        po.f();
    }
}

在这里我们进行了转型，一般我们转型之后po.f() 输出的应该是Derived 类中的方法返回值，然而程序输出结果如下：

public f()!
private f()!

正确输出我们想要转型后的值方法为：((Derived) po).f();，也就是需要对他进行强转。

---

结论：只有非private方法才可以被覆盖，或者在转型的基础上再使用强转。确切地说，在导出类中，对于基类中的private方法，最好采用不同的名字。

---

2.域

对于多态机制，只有普通的方法调用是可以多态的。如果你想直接访问某个域，就会如下所示：

首先代码如下：

class Super{
    public int field=0;
    public int getField(){
        return field;
    }
}
class Sub extends Super{
    public int field=1;
    public int getField(){
        return field;
    }
    public int getSuperField(){
        return super.field;
    }
}

public class Test_2 {
    public static void main(String[] args){
        Super sub=new Sub();
        System.out.println("sub.field= "+((Sub) sub).field+"     sub.getField= "+sub.getField());
        System.out.println("sub.field= "+sub.field+"     sub.getField= "+sub.getField());
        Sub sub1=new Sub();
        System.out.println("sub1.field= "+sub1.field+"     sub1.getField= "+sub1.getField()+"     sub1.getSuperField= "+sub1.getSuperField());
    }
}

输出结果为：

sub.field= 1 sub.getField= 1
sub.field= 0 sub.getField= 1
sub1.field= 1 sub1.getField= 1 sub1.getSuperField= 0

通过对比可以知道，直接使用转型调用**“sub.field”**得到的是基类中的值，而不是我们想要的值，如果想输出想要的值，也需要如私有方法的强转。

---

3.静态方法

当某个方法是静态的时，它的行为就不具有多态性。

具体测试如下：

class StaticSuper{
    public static String staticGet(){
        return "Base staticGet!";
    }
    public String dynamicGet(){
        return "Base dynamicGet!";
    }
}
class StaticSub extends StaticSuper{
    public static String staticGet(){
        return "Derived staticGet!";
    }
    public String dynamicGet(){
        return "Derived dynamicGet!";
    }
}

public class Test_3 {
    public static void main(String[] args){
        StaticSuper ss=new StaticSub();
        System.out.println("ss.staticGet= "+ss.staticGet()+"       ss.dynamicGet= "+ss.dynamicGet());
        StaticSub sub=new StaticSub();
        System.out.println("sub.staticGet= "+sub.staticGet()+"       sub.dynamicGet= "+sub.dynamicGet());
        StaticSuper ssuper=new StaticSuper();
        System.out.println("ssuper.staticGet= "+ssuper.staticGet()+"       ssuper.dynamicGet= "+ssuper.dynamicGet());

    }
}

输出结果为：

ss.staticGet= Base staticGet! ss.dynamicGet= Derived dynamicGet!
sub.staticGet= Derived staticGet! sub.dynamicGet= Derived dynamicGet!
ssuper.staticGet= Base staticGet! ssuper.dynamicGet= Base dynamicGet!

静态方法是与类相关联，而并非与单个的对象相关联的。