Oop 这还会被认为是一种责任链模式吗？

我已经使用了一段时间的设计模式，并一直将其称为“”，但现在我意识到存在差异，这样做可能不合适。所以我的问题是1，“以下是这种模式的一个例子，还是应该称之为其他模式？”和2，“有什么理由我更喜欢传统的方式吗？”

在开发软件时，我经常使用以下模式。我有一个接口，它定义了一个

interface FooBar{
    boolean isFooBar( Object o );
}

这些类通常是搜索、筛选或处理类；通常是这样。实施方法通常是功能性的（即无副作用）。最终，我发现自己创建了一个界面的实现，看起来像：

class FooBarChain implements FooBar{
    FooBar[] foobars;

    FooBarChain( FooBar... fubars ){
         foobars = fubars;
    }

    boolean isFooBar( Object o ){
         for( FooBar f : foobars )
             if(  f.isFooBar( o )  )
                 return true;

         return false;
    }
}

它也不总是布尔值-我也对可变对象使用过这种模式-但总是存在短路条件（例如，返回true、字符串为空字符串、设置标志等）

到目前为止，我通常称之为“责任链”模式，将从基类继承的问题视为实现细节。然而，今天我意识到了一个重要的区别：链条上的物体不能打断链条的其余部分。实现没有办法说“这是错误的，我可以保证它在任何情况下都是错误的”（注意：仅在

true

上短路）

---

那么，这应该被称为责任链模式以外的其他模式吗？在使用这种方法时，有没有考虑到的问题或问题，传统的例子是传递消息的。

< P>你有一个责任链，但是你可以通过添加一些小的变化来做一个“纯粹的责任链”。 您可以创建一个枚举，该枚举将表示此函数预期的3个不同结果

 public enum Validity{
     Invalid,
     Indeterminate,
     Valid
 }

您可以将界面更改为可链接，如下所示：

 public interface ChainFooBar{
     public boolean isFooBar(Object o);
     public Validity checkFooBar(Object o);
 }

大多数

FooBar

s都必须实现如下方法：

public abstract class AbstractFooBar implements FooBar{
    public Validity checkFooBar(Object o){
        return this.isFooBar(o) ? Validity.Valid : Validity.Indeterminate;
    }
}

然后你可以改变你的链来检查其中一个明确的答案

public class FooBarChain implements FooBar{
    private FooBar[] fooBars;

    public FooBarChain(FooBar... fooBars){
        this.fooBars = fooBars;
    }

    public Validity isFooBar(Object o){
        for(FooBar fooBar : this.fooBars){
            Validity validity = fooBar.checkFooBar(o);
            if(validity != Validity.Indeterminate){
                return validity == Validity.Valid;
            }
        }
        return false;
    }
}

---

你拥有的是一个责任链，但你可以通过添加一些小的改变来形成一个“纯粹”的责任链

您可以创建一个枚举，该枚举将表示此函数预期的3个不同结果

 public enum Validity{
     Invalid,
     Indeterminate,
     Valid
 }

您可以将界面更改为可链接，如下所示：

 public interface ChainFooBar{
     public boolean isFooBar(Object o);
     public Validity checkFooBar(Object o);
 }

大多数

FooBar

s都必须实现如下方法：

public abstract class AbstractFooBar implements FooBar{
    public Validity checkFooBar(Object o){
        return this.isFooBar(o) ? Validity.Valid : Validity.Indeterminate;
    }
}

然后你可以改变你的链来检查其中一个明确的答案

public class FooBarChain implements FooBar{
    private FooBar[] fooBars;

    public FooBarChain(FooBar... fooBars){
        this.fooBars = fooBars;
    }

    public Validity isFooBar(Object o){
        for(FooBar fooBar : this.fooBars){
            Validity validity = fooBar.checkFooBar(o);
            if(validity != Validity.Indeterminate){
                return validity == Validity.Valid;
            }
        }
        return false;
    }
}

---

我不会称之为责任链

在责任链中，“短路”大致是“我能处理这件事，所以链中的下一个人不必”而不是任何形式的返回值。链中的每个对象都知道谁是链中的下一个对象，并根据需要将控制权传递给下一个对象，这是正常的。他们通常会做一些事情，而不是返回一个值

---

您提供的示例非常合理，尽管我不确定它是否是命名模式。我现在不太清楚您描述的其他变体。

我不会称之为责任链

在责任链中，“短路”大致是“我能处理这件事，所以链中的下一个人不必”而不是任何形式的返回值。链中的每个对象都知道谁是链中的下一个对象，并根据需要将控制权传递给下一个对象，这是正常的。他们通常会做一些事情，而不是返回一个值

---

您提供的示例非常合理，尽管我不确定它是否是命名模式。关于您描述的其他变体，我现在还不太清楚。

我想我可以，但很抱歉，我认为这根本不是一个好主意。1） 它不适用于现有接口，2）您不想返回Inderterminate，因为您希望每个接口都有明确的答案。通常我发现每个实例都代表一个特定的约束。你不需要相互确定的答案。而且，不确定只存在于链接它们的时候，也只存在于处理单个类的时候，这种情况变得更容易处理。另外，你没有回答是否仍然称之为CoR模式。我更新了我的答案。这个问题很难回答，因为它介于两者之间。当你用肯定或否定的答案将选项添加到短路中，那么你在做一个纯CoR，但它仍然是CoR，但不是纯的。我想我可以，但我认为这根本不是一个好主意，我很抱歉这么说。1） 它不适用于现有接口，2）您不想返回Inderterminate，因为您希望每个接口都有明确的答案。通常我发现每个实例都代表一个特定的约束。你不需要相互确定的答案。而且，不确定只存在于链接它们的时候，也只存在于处理单个类的时候，这种情况变得更容易处理。另外，你没有回答是否仍然称之为CoR模式。我更新了我的答案。这个问题很难回答，因为它介于两者之间。当你用肯定或否定的答案将选项添加到短路时，那么你在做一个纯CoR，但它仍然是CoR，但不是纯CoR。我认为关键是你的“通常做一些事情，而不是返回一个值”评论。我使用的一个变体是一系列文本过滤器。一个过滤器删除诅咒词、另一个停止词、另一个数字等。返回的结果将传递给下一个过滤器。如果a过滤器返回空字符串（例如，仅由诅咒过滤器处理的诅咒词组成的字符串），则它会短路。我的观点是该模式不是布尔型的，我可以想象将其与图像过滤器一起使用。@ArtB：您的示例中使用了数据f