主页 / 问题 / 1074483
Accepted
Miron
Asked:2020-01-26 14:11:42 +0000 UTC2020-01-26 14:11:42 +0000 UTC

函数的返回类型（基于类数据）必须可以转换为其他几种类型。如何构建正确的架构？

  • 772

让我们以仅知道该函数所在的类的类型就可以将函数的返回类型转换为其他类型为基础，因为函数的返回类型直接取决于执行的计算在解析过程中。
下面的解决方案立刻浮现在脑海：创建一个解析器类，其中有许多解析函数，可以将函数的返回类型转换为其他类型。但是可以通过没有方法的接口仅表明这是一个解析器。然后整个抽象崩溃了——我们开始依赖特定的实现。如何进行？可能是我一开始建的系统不正确，这个问题是根治不了的？

如果需要，这里是程序的文本：

public interface Crashable<OutputType, ToBreakDeterminator> {
    boolean hasCrushed();
    default boolean canBreakDown(CrasherUI<OutputType, ToBreakDeterminator> crasher) { // проверять должен CrasherUI.canCrash()!
        return crasher.canCrash(this);
    }
    OutputType breakDown(CrasherUI<OutputType, ToBreakDeterminator> crasherUI) throws IllegalStateException;
    ToBreakDeterminator getToBreakDeterminator();   
}

public class Thing implements Crashable<String, Integer>{
    private Integer rigidity;
    private String name;

    private CrasherUI crushedBy;

    public final static Integer DEFAULT_RIGIDITY = 50;
    public final static String DEFAULT_NAME = "unnamed";

    {
        crushedBy = null;
    }

    //...

    @Override
    public String breakDown(CrasherUI<String, Integer> crasher) throws IllegalStateException {
        if(hasCrushed()) {
            throw new IllegalStateException("It is already crushed by " + crushedBy);
        }
        crushedBy = crasher;
        return "u broke " + name + " with " + rigidity + " by " + crasher + ", dude"; 
        // это возврат ф-ции. По-идее должен возвращать уже OutputType(см абстрактный класс)
    }

    //...
}

这是抽象类本身：

public abstract class AbstractApartaments<OutputType, InputType, ToBreakDeterminator> implements ApartamentUI{
    private Stack<? extends Crashable<InputType, ToBreakDeterminator>> things;

    private CrasherUI<InputType, ToBreakDeterminator> crasher;

    private Function<InputType, OutputType> inputToOutput; // один тип(Crashable) только обрабатывать можем. 
    private ConcurrentLinkedQueue<OutputType> toUserOutputs;
    private ToUserOutputUI<OutputType> out;

    {
        things = new Stack();
        toUserOutputs = new ConcurrentLinkedQueue();
    }

    public AbstractApartaments(Collection<? extends Crashable<InputType, ToBreakDeterminator>> toCrush, CrasherUI<InputType, ToBreakDeterminator> crasher, Function<InputType, OutputType> inputToOutput, ToUserOutputUI<OutputType> out){
        things.addAll(toCrush); // Ошибка!
        this.crasher = crasher;
        this.inputToOutput = inputToOutput;
        this.out = out;
    }


    @Override
    public boolean hasThingsToCrash() {
        return things.isEmpty();
    }

    @Override
    public boolean crashNext() {
        if(!things.isEmpty()) {
            Crashable<InputType, ToBreakDeterminator> toCrash = things.pop();
            if(toCrash.canBreakDown(crasher)) {
                toUserOutputs.add(inputToOutput.apply(toCrash.breakDown(crasher)));
                return true;
            } else {
                return false;
            }
        } else {
            throw new NoSuchElementException();
        }
    }

    @Override
    public void pullToUserOutputs() {
        while(!toUserOutputs.isEmpty()) {
            out.toOutput(toUserOutputs.poll());
        }
    }

}
java

1 个回答

  1. Best Answer

    请注意，您的队列可以接受从 Crashable 继承的任何类型

    public abstract class AbstractApartaments<InputType, ToBreakDeterminator> implements ApartamentUI{
private Stack<Crashable> things;
private CrasherUI crasher;
private ConcurrentLinkedQueue<Crashable> toUserOutputs;
private ToUserOutputUI<OutputType> out;

{
    things = new Stack<>();
    toUserOutputs = new ConcurrentLinkedQueue<>();
}

public AbstractApartaments( Collection<? extends Crashable<InputType, ToBreakDeterminator>> toCrush,
                            CrasherUI<InputType, ToBreakDeterminator> crasher,
                            ToUserOutputUI<OutputType> out){

    this.things.addAll(toCrush);
    this.crasher = crasher;
    this.out = out;
}


@Override
public boolean hasThingsToCrash() {
    return things.isEmpty();
}

@Override
public boolean crashNext() {
    if(!things.isEmpty()) {
        Crashable toCrash = things.pop();
        if(toCrash.canBreakDown(crasher)) {
            toUserOutputs.add(toCrash.breakDown(crasher));
            return true;
        } else {
            return false;
        }
    } else {
        throw new NoSuchElementException();
    }
}

@Override
public void pullToUserOutputs() {
    while(!toUserOutputs.isEmpty()) {
        out.toOutput(toUserOutputs.poll());
    }
}

}
    • 1

相关问题