Java 用于分析实例组合的设计模式？

我正在寻找一种设计模式的建议，这种模式可以用来解释一系列不同的

对象
实例。理想情况下，这些模式定义是静态定义的

因此，作为一个例子，我在寻找一些类似的东西：

配料[]新配料[]{新石灰（）、新苏打（）、新糖（）、新薄荷（）、新朗姆酒（）}

Patterns.WHITE_-俄语.isRecipe（语言成分）//返回false
Patterns.MOJITO.isRecipe（ling成分）//返回真值

我设法使用
对象
类引用开发了一个有效的解决方案，但是很明显，在以后的开发中，我的一些模式将依赖于实例数据成员，而其他模式则不会。我希望模式是灵活的，因此它们可能不必依赖于数组中的特定顺序，或者忽略多余的元素，或者检测重复项

是否有适合这些要求的广泛使用的方法
 也许你可以用这两种方法中的一种来做

interface Ingredient {
  boolean belongsTo(Cocktail cocktail)
}

interface Cocktail {
  boolean hasIngredient(Ingredient ingredient)
}

鸡尾酒本身可以是一个数组或其他成分的集合
也许，你可以使用这两种成分中的一种

interface Ingredient {
  boolean belongsTo(Cocktail cocktail)
}

interface Cocktail {
  boolean hasIngredient(Ingredient ingredient)
}

鸡尾酒本身可以是一个数组或其他成分的集合
当您有要处理的类的层次结构时，首选的设计模式是

编辑：我同意上述解决方案会产生太多开销。然后我会和一个匹配者一起去，你可以这样做：

private Matcher mojitoMatcher = arrayContainingInAnyOrder(
        instanceOf(Rum.class),
        instanceOf(Mint.class),
        instanceOf(SodaWater.class),
        instanceOf(Lime.class),
        instanceOf(Sugar.class)
);
public boolean isMojito(Ingredient[] ingredients) {
    return mojitoMatcher.matches(ingredients);
}

当您有要处理的类的层次结构时，首选的设计模式是

编辑：我同意上述解决方案会产生太多开销。然后我会和一个匹配者一起去，你可以这样做：

private Matcher mojitoMatcher = arrayContainingInAnyOrder(
        instanceOf(Rum.class),
        instanceOf(Mint.class),
        instanceOf(SodaWater.class),
        instanceOf(Lime.class),
        instanceOf(Sugar.class)
);
public boolean isMojito(Ingredient[] ingredients) {
    return mojitoMatcher.matches(ingredients);
}

在从其他StackOverflow用户提供的精彩答案中得到一些思考和鼓励之后，我认为我偶然发现了一个合理的解决方案

情景
我们想用一系列的
配料
系统地解释一系列可以从中复制的美味鸡尾酒配方。这些关系必须是灵活的，并且能够从通用阵列规范访问数据成员

技术的
在这个应用程序中，我们将处理一组实例。在这方面，我们希望开发模式匹配代码，作为数据成员集合的函数，而不是让数据成员自己定义配方的逻辑。原因有两个方面；首先，一种
配料
不仅仅用于
鸡尾酒
（这会让你更容易参加聚会）；它可能在
蛋糕
、
沙拉
甚至是
结肠镜检查
；因此，我们必须从基类规范中抽象分析逻辑，以改进职责分离。这种方法激励我们开发一套通用工具，适用于各种不同的应用程序，而不仅仅是我想象中的酒吧。其次，它使我们能够处理自动装箱的Java原语或JavaBean，而无需构造任何接口。这种方法的另一个令人高兴的双产品是，它可以使
鸡尾酒
模式作为一个整体更加清晰地可视化；类调用之间没有“隐藏”交互

因此，我决定将整个方法形式化为两个通用实体之间的有限交互，而不是处理不同
成分之间的关系
Alice
和
Bob
。我决定将这些互动称为“利亚森”，这不仅是因为我感到悲伤，也是因为我感到孤独

设计
首先，我构建了一个名为
ILiason
的
接口。我使用接口是因为这样可以使设计中的现有类与模式匹配体系结构集成，而不会导致多继承冲突

/*定义了一个独立的基础*/
公共接口{
/*定义Alice和Bob之间是否存在ILiason*/
公共抽象布尔isLiason（最后一页）；
/*返回比较的源*/
公共摘要B getBob（）；
}

在
ILiason
中，我们定义了两个简单的方法，它们依赖于两个泛型类型，
A
（Alice）和
B
（Bob）
A
将是我们希望比较的运行时集合或对象，
B
将是
getBob（）
返回的比较源。在方法
isLiason（final A pAlice）
中，我们将定义如何正确比较Alice和Bob的特定逻辑

在
Cocktails
应用程序中，我决定将每个特定成分表示为
iIngElement
接口的实现者。您将在下面看到，我们定义了诸如
Rum
、
Vodka
和eugh<代码>轧棉机
。我还定义了
iIngCredit
，
iPoonfuls
的附加扩展；这将枚举调用者选择的特定成分的汤匙数。
ISpoonfuls
的具体实现在
iInCredit.Sugar
类规范中定义

`/*基本成分界面*/
公共接口元件{

/* Amount Interface. */
public static interface ISpoonfuls extends IIngredient {
    /* Returns the Number of Teaspoons required for the concrete Ingredient. */
    public abstract int getNumberOfTeaSpoons();
}

/* Define some example implementations. */
public static final class Rum      implements IIngredient { }; 
public static final class Liquor   implements IIngredient { }; 
public static final class Vodka    implements IIngredient { }; 
public static final class Cream    implements IIngredient { }; 
public static final class Gin      implements IIngredient { }; 
public static final class Vermouth implements IIngredient { }; 
public static final class Orange   implements IIngredient { }; 
public static final class Lime     implements IIngredient { }; 
public static final class Soda     implements IIngredient { }; 
public static final class Mint     implements IIngredient { }; 

public static final class Sugar  implements ISpoonfuls  { 
    /* Member Variables. */
    private final int mNumberOfTeaspoons;
    /* Constructor. */
    public Sugar(final int pNumberOfTeaspoons) {
        /* Initialize Member Variables. */
        this.mNumberOfTeaspoons = pNumberOfTeaspoons;
    }
    /* Getters. */
    @Override public int getNumberOfTeaSpoons() { return this.mNumberOfTeaspoons; } 
}; 

}`

从这个设计中可以明显看出，为了检查集合中是否存在某个
iIngElement
，我们希望测试它的类。因此，我们将定义我们的第一个
ILiason
类型，即
可分配的
：

/*用于确定给定实例是否可从给定类赋值的一个函数*/
公共静态抽象类可分配mBob；公共Impl（最终类pBob）{this.mBob=pBob；}@Override p