java小心机(6)| 多态的一些坑

 对于”多态”的概念,想必大家都很熟悉了,但我们还是来回顾一下吧

class Actor {
public void act(){
System.out.println(“Actor”);
}
}

class HappyActor extends Actor{
@Override
public void act() {
System.out.println(“HappyActor”);
}
}

class SadActor extends Actor{
@Override
public void act() {
System.out.println(“SadActor”);
}
}

public class Test {
public static void main(String[] args) {
Actor hActor = new HappyActor();//向上转型
Actor sActor = new SadActor();//向上转型
hActor.act();
sActor.act();
}
}
//out:
HappyActor
SadActor
上面例子中,HappyActor和SadActor都继承Actor并重写了act方法,在main函数中,两个Actor对象调用相同方法产生不同的结果,就称为”多态”。

在设计程序中,”多态”可使代码变得灵活,有时候还是很好使得,但也有一些坑在里面,下面就给你一一道来

坑1 “覆盖”私有方法
public class PrivateOverride {
private  void f(){
System.out.println(“private f()”);
}

public static void main(String[] args){
PrivateOverride po = new Derived();
po.f();
}
}

class Derived extends PrivateOverride{
public void f(){
System.out.println(“public f()”);
}
}
//out:
private f()
我们期望输出的是public f(),但结果并非我们所想。PrivateOverride中的f()方法是私有的,对它的子类是不可见的,Derived 的f()方法无法覆盖它。

结论：无法覆盖私有方法。需要注意，子类中方法切勿与父类中的私有方法同名，否则会容易混淆。

坑2 域与静态方法不存在多态
1. 域
class SuperClass {
public String field = “Super field”;

public String getField() {
return field;
}
}

class SubClass extends SuperClass {
public String field = “Sub field”;

@Override
public String getField() {
return field;
}

public String getSuperField() {
return super.getField();
}
}

public class FieldAccess {
public static void main(String[] args) {
SuperClass sup = new SubClass();//向上转型
System.out.println(“sup.field = ” + sup.field
+ “, sup.getField() = ” + sup.getField());

SubClass sub = new SubClass();
System.out.println(“sub.field = ” + sub.field
+ “, sub.getField() = ” + sub.getField()
+”, sub.getSuperField() = ” + sub.getSuperField());
}
}
//out:
sup.field = Super field, sup.getField() = Sub field
sub.field = Sub field, sub.getField() = Sub field,
sub.getSuperField() = Super field
域的访问操作是由编译器解析的,所以不是多态的。（扩展：多态是由动态绑定实现的，即是在程序运行期对数据做绑定）

SuperClass中的field和SubClass中的field分配了不同的内存空间,在SubClass中实际上包含了两个field:一个是自己的和从父类SuperClass中继承的。子类SubClass中可使用super.field显示地指明SuperClass中的field。

2. 静态方法
class StaticSuper{
public static String staticGet(){
return “Base staticGet()”;
}

public  String dynamicGet(){
return “Base dynamicGet()”;
}
}

class StaticSub extends StaticSuper{
public static String staticGet(){
return “Base staticGet()”;
}

@Override
public  String dynamicGet(){
return “Base dynamicGet()”;
}
}
public class StaticMethod {
public static void main(String[] args) {
StaticSuper sup = new StaticSub();
System.out.println(sup.staticGet());
System.out.println(sup.dynamicGet());
}
}
//out:
Base staticGet()
Base dynamicGet()
静态方法无法被覆盖,无法实现多态。

总结：域与静态方法都无法实现多态。需要注意，尽可能不对父类和子类的域使用相同的名字，无法覆盖的方法不使用相同名字，以免造成混淆。