Java怎样实现菱形继承

教授Java编程的书总是欺骗大家，多继承不是必要的。

其实，一种语言不支持多继承是件很恶心的事，因为不能因为“救命”一词生活中不常用，就从自然语言中去掉它。

普通的多重继承很容易用组合替代，而共用根结点的菱形继承则不那么容易。所以我写Java代码的时候常有一种残废的感觉，直到想到菱形继承的方法。

譬如Programmer类和Manager类都继承自People类，ProgramManager类该如何设计？

其实只要借鉴Decorator pattern中的设计改造改造：

首先要有个表示People行为的接口：

public interface PeopleBehavior {
    void sayName();
}

则有People类实现如下：

public class People implements PeopleBehavior {
    private final String mName;

    public People(final String name) {
        mName = name;
    }

    @Override
    public void sayName() {
        System.out.println("People:" + "sayName:" + mName);
    }
}

为了模拟C++的虚继承两边指向同一个虚基类对象，参考Decorator pattern的设计，关键在于要有一个People类的wrapper：

public class PeopleWrapper implements PeopleBehavior {
    private final People mPeople;

    public PeopleWrapper(final People people) {
        mPeople = people;
    }

    @Override
    public void sayName() {
        mPeople.sayName();
    }
}

表示Programmer行为的接口：

public interface ProgramBehavior {
    void setLanguage(final String lanaguage);
    void program();
}

则有Programmer类：

public class Programmer extends PeopleWrapper implements ProgramBehavior {
    private String mLanguage;

    public Programmer(final People people) {
        super(people);
    }

    @Override
    public void program() {
        System.out.println("Programmer:" + "program:" + mLanguage);
    }

    @Override
    public void setLanguage(final String lanaguage) {
        mLanguage = lanaguage;
    }
}

同理表示Manager行为的接口：

public interface ManagerBehavior {
    void setStyle(final String style);
    void manage();
}

Manager类：

public class Manager extends PeopleWrapper implements ManagerBehavior {
    private String mStyle;

    public Manager(final People people) {
        super(people);
    }

    @Override
    public void setStyle(final String style) {
        mStyle = style;
    }

    @Override
    public void manage() {
        System.out.println("Manager:" + "manage:" + mStyle);
    }
}

如此，不难得出ProgramManager类的设计：

public class ProgramManager extends PeopleWrapper implements ProgramBehavior,
        ManagerBehavior {

    private final ProgramBehavior mProgramAbility;
    private final ManagerBehavior mManagerAbility;

    public ProgramManager(final People people) {
        super(people);
        mProgramAbility = new Programmer(people);
        mManagerAbility = new Manager(people);
    }

    @Override
    public void setStyle(final String style) {
        mManagerAbility.setStyle(style);
    }

    @Override
    public void manage() {
        mManagerAbility.manage();
    }

    @Override
    public void setLanguage(final String lanaguage) {
        mProgramAbility.setLanguage(lanaguage);
    }

    @Override
    public void program() {
        mProgramAbility.program();
    }
}

看上去有些麻烦，但毕竟是功能完备的菱形继承，一想到这个方案，Java看上去就不那么残废了~