Question

我想避免使用带标记的类和大的if-else块或switch语句，而是将多态性用于类层次结构，我相信这是更好的做法。

例如，类似下面的内容，其中执行方法的选择仅依赖于Actor类型的对象的一个字段。

switch(actor.getTagField())
{
    case 1: actor.act1(); break;
    case 2: actor.act2(); break;
    [...]
}

会变成

actor.act();

并且act方法将在Actor的子类中被覆盖。

但是，在运行时决定实例化哪个子类的最明显的方法看起来与原始类似：

Actor newActor(int type)
{
    switch(type)
    {
        case 1: return new Actor1();
        case 2: return new Actor2();
        [...]
    }
}

所以似乎没有真正获得任何东西;逻辑刚刚被移动。

有什么更好的方法可以做到这一点？我能想出的唯一方法是为Actor的每个子类实现一个工厂类，但对于这样一个简单的问题，这似乎相当麻烦。

我是否过度思考这个？如果我在其他地方做同样的事情，似乎没有必要做出原始的改变。

Answer 1

问题是“如果”你需要一家工厂。工厂旨在管理实例的创建，而不是相关实例的行为。

否则，你只是在看基本的继承。像...这样的东西。

class Actor{
  public void act(){
    System.out.println("I act..");
  }
}

class StuntActor extends Actor {
  public void act(){
    System.out.println("I do fancy stunts..");
  }
}

class VoiceActor extends Actor {
  public void act(){
    System.out.println("I make funny noises..");
  }
}

要使用，您可以直接实例化您需要的演员类型。

Actor fred = new Actor();
Actor tom = new VoiceActor();
Actor sally = new StuntActor();

fred.act();
tom.act();
sally.act();

输出：

I act..
I make funny noises..
I do fancy stunts..

修改

如果你需要集中创建Actors..aka对工厂，你将无法摆脱某种切换逻辑 - 在这种情况下......我通常会使用枚举来提高可读性：

public class Actor{ public enum Type{ REGULAR, VOICE, STUNT } public static Actor Create(Actor.Type type){ switch(type) { case VOICE: return new VoiceActor(); case STUNT: return new StuntActor(); case REGULAR: default: return new Actor(); } } public void act(){ System.out.println("I act.."); } }

用法：

Actor some_actor = Actor.Create(Actor.Type.VOICE); some_actor.act();

输出：

I make funny noises..

Answer 2

我相信你可以用Abstract factory pattern ...

来做到这一点

这是一个例子：

abstract class Computer {
    public abstract Parts getRAM();
    public abstract Parts getProcessor();
    public abstract Parts getMonitor();
}

class Parts {
    public String specification;
    public Parts(String specification) {
        this.specification = specification;
    }
    public String getSpecification() {
        return specification;
    }
}

我们有两个扩展Computer

的类

class PC extends Computer {
    public Parts getRAM() {
        return new Parts("512 MB");
    }
    public Parts getProcessor() {
        return new Parts("Celeron");
    }
    public Parts getMonitor() {
        return new Parts("15 inches");
    }
}

class Workstation extends Computer {
    public Parts getRAM() {
        return new Parts("1 GB");
    }
    public Parts getProcessor() {
        return new Parts("Intel P 3");
    }
    public Parts getMonitor() {
        return new Parts("19 inches");
    }
}

最后我们有，

public class ComputerType {
    private Computer comp;
    public static void main(String[] args) {
        ComputerType type = new ComputerType();
        Computer computer = type.getComputer("Workstation");
        System.out.println("Monitor: "+computer.getMonitor().getSpecification());
        System.out.println("RAM: "+computer.getRAM().getSpecification());
        System.out.println("Processor: "+computer.getProcessor().getSpecification());
    }    

    public Computer getComputer(String computerType) {
        if (computerType.equals("PC"))
            comp = new PC();
        else if(computerType.equals("Workstation"))
            comp = new Workstation();
        return comp;
    }    
}

Answer 3

切换声明不是纯粹的邪恶。你真的想要通过更好的设计消除重复。通常，您会发现相同的switch语句显示在代码中的不同（远处）位置 - 不一定做同样的事情，而是切换相同的数据。通过引入多态，您可以将这些开关作为同一对象的不同方法拉出来。

这有两件事，首先它将几个开关减少到工厂内的一个开关和它将可能依赖于类似数据的逻辑分散开来。该数据将变成对象中的成员变量。

值得注意的是，您并不总是在工厂的引擎盖下使用开关声明。也许您可以在启动时扫描类路径并构建实现接口的HashMap类型。例如，考虑像SMTP这样的套接字协议的实现。您可以拥有名为HeloCommand，MailFromCommand等的对象，并通过将socket命令与类名匹配来找到处理消息的正确对象。

创建对象和多态

3 个答案: