Question

我想知道如何设计一个系统，其中我有一个类Super和几个类是Super的子类（比如Sub1，Sub2，Sub3），我想要一个Cool类。现在有两件事我想要：

Sub1和Sub2可以是Cool，Sub3永远不会很酷。

我必须能够拥有一个List，其中可以有Sub1和Sub2，如果它们很酷的话。例如，如果我创建Sub1的对象并且很酷，我可以把它放在列表中，如果不是它不能在列表中。

有什么建议吗？提示？

Answer 1

也许是这样的：

class Super {}

interface Cool { boolean isCool(); }

class IsCool implements Cool {
    public boolean isCool() { return true; }
}

class NotCool impolements Cool {
    public boolean isCool() { return false; }
}

interface CoolSupporter {
    boolean isCool();
    Cool getCool();
}

class Sub1 extends Super implements CoolSupporter {
    private Cool cool;
    public Sub1() { this(new NotCool()); }
    public Sub1(Cool cool) { this.cool = cool; }
    public boolean isCool() { this.cool.isCool(); }
    public Cool getCool() { return this.cool; }
}

class Sub2 extends Super implements CoolSupporter {
    private Cool cool;
    public Sub1() { this(new NotCool()); }
    public Sub1(Cool cool) { this.cool = cool; }
    public boolean isCool() { this.cool.isCool(); }
    public Cool getCool() { return this.cool; }
}

class Sub3 extends Super {}

class CoolList {
    private List<CoolSupporter> list = new ArrayList<CoolSupporter>();
    public void add(CoolSupporter coolSupporter) {
        if (coolSupporter.isCool()) {
            list.add(coolSupporter);
        } else {
            throw new UncoolException();
        }
    }
}

Answer 2

Arne的回答有点像你想要的，但我发现它太复杂了。也许我错过了什么？为什么不呢：

class Super { }

interface Cool { boolean isCool(); }

class CoolImpl extends Super implements Cool {
    private boolean cool;
    public CoolImpl(boolean cool) { this.cool = cool; }
    public boolean isCool() { return this.cool; }
}

class Sub1 extends CoolImpl { }
class Sub2 extends CoolImpl { }    
class Sub3 extends Super { }

class CoolList extends ArrayList<Cool> {
    public boolean add(Cool cool) {
        if (!cool.isCool()) {
            return false;
        }
        return super.add(cool);
    }
}

Answer 3

你可以创建一个很酷的标记界面。让Sub1和Sub2类实现此接口在添加到列表之前检查是否存在酷

可能会有所帮助。

Answer 4

您不能拥有一个可选属于Java类型的类。虽然你可以继承Sub1，但是一个子类实现了Cool接口而另一个子类没有：

class Super { }

interface Cool { }

class Sub1 extends Super { }
class Sub1Cool extends Sub1 implements Cool { }

class Sub2 extends Super { }
class Sub2Cool extends Sub2 implements Cool { }

class Sub3 extends Super { }

class CoolList extends ArrayList<Super> {
    public boolean add(Super sup) {
        if (!(sup instanceof Cool)) {
            return false;
        }
        return super.add(cool);
    }
}

您也可以放弃Cool概念并使用访问者模式：

class Super { 
    public boolean addTo(List<Super> coolList) {
        if (canBeAddedToCoolList()) {
            return coolList.add(this);
        }
        return false;
    }

    protected boolean canBeAddedToCoolList() {
        return false;
    }
}

class Sub1 extends Super { 

    protected boolean canBeAddedToCoolList() {
        // check logic to allow/disallow addition
    }
}

Answer 5

IMO，你需要有一个覆盖的List（Say MyList，覆盖add（））。

在add（）中，检查您要添加的对象是否为Cool，如果是，则将其添加到列表的一部分。如果没有，那就优雅地忽视它。

这有帮助吗？

Answer 6

您可以采用的最简单方法是进一步继承Sub1（CoolSub1和NotCoolSub1）和Sub2（CoolSub2和NotCoolSub2）。

然后CoolSub1和CoolSub2可以实现Cool（Cool应该是一个接口，而不是一个类）

然后您可以定义

List<Cool>

将接受Sub1和Sub2的实现，但前提是它们实现了Cool。

类设计问题[可选实现]

6 个答案: