标签: composition

我有一个函数数组,我正在尝试生成一个函数,该函数由我的数组中的元素组成.我的方法是:

def compose(list):
    if len(list) == 1:
        return lambda x:list[0](x)
    list.reverse()
    final=lambda x:x
    for f in list:
        final=lambda x:f(final(x))
    return final

这种方法似乎不起作用,将不胜感激.

(我正在颠倒列表,因为这是我想要函数的组合顺序)

我有一个实现两个接口的对象...接口是:

public interface IObject
{
    string Name { get; }
    string Class { get; }
    IEnumerable<IObjectProperty> Properties { get; }
}
public interface ITreeNode<T>
{
    T Parent { get; }
    IEnumerable<T> Children { get; }
}

这样的

public class ObjectNode : IObject, ITreeNode<IObject>
{
    public string Class { get; private set; }
    public string Name { get; private set; }
    public IEnumerable<IObjectProperty> Properties { get; set; }
    public IEnumerable<IObject> Children { get; private set; }
    public IObject Parent { get; …

我在将我的JSF应用程序转换为可书籍标记的页面方面取得了很大进展,但我想知道我是否以正确的方式进行操作.一个问题是f:元数据标签是否有最佳实践位置？

我的典型Facelets客户端页面如下所示:

    <ui:composition template="./pattern.xhtml">

        <ui:define name="content">

            <f:metadata>
                <f:viewParam name="userId" value="#{bean.userId}" />
                <f:viewParam name="startRecord" value="#{bean.startRecord}" />
                <f:viewParam name="pageSize" value="#{bean.pageSize}" />
                <f:viewParam name="sort" value="#{bean.sort}" />
            </f:metadata>

            <h1>Data Table</h1>

etc

所以f:metadata和child f:viewParam标签在我的页面正文中遇到.我的pattern.xhtml模板还有一个部分(名为"header"),可以将这些标记放在标题部分.它们应该放在那里吗？它是否有所作为,或者我是否设置了一些我尚未见过的副作用？

实际上,做一些业余的UML问题!在创建UML图来模拟某些域概念时,您遇到了一个"保存"某个有关另一个概念的信息的域概念,是否更好地保存对该实体的戳记/引用或将整个实体保存在模型本身中？请记住,这与创建一个简单的高级模型有关 - 我确信在实现阶段,事情会略有不同.

例如,下面两个模型中的哪一个实际上是正确的？第一个有一个组合关系,FlightBooking持有整个Flight.在第二个中,FlightBooking只是对Flight的引用.

其次,在创建高级UML图建模领域概念时,您真正想要了解多少细节？例如,在下图中,航班可以将有关原点/目的地的详细信息保存为字符串,或者我可以为这些概念建模单独的类并创建组合关系.哪两个是可取的？

另外,另外一件事,当上面的模型将飞行"保持"原始/目的地作为另一个类而不是字符串时,这两种方式中的哪一种是正确的建模方法？我很困惑什么时候展示assosciation和什么时候显示组成.

考虑以下两个特征:

trait Poked extends Actor {
  override def receive = {
    case Poke(port, x) => ReceivePoke(port, x)
  }

  def ReceivePoke(port: String, x: Any)
}

trait Peeked extends Actor {
  override def receive = {
    case Peek(port) => ReceivePeek(port)
  }

  def ReceivePeek(port: String)
}

现在考虑我可以创建一个实现两个特征的新Actor:

val peekedpoked = actorRef(new Actor extends Poked with Peeked)

如何撰写接收处理程序？即,接收器应该是类似下面的代码,虽然"自动生成"(即,所有特征应该组成):

def receive = (Poked.receive: Receive) orElse (Peeked.receive: Receive) orElse ...

是否有一种在F#中逻辑组合谓词的标准方法？例如,让我说我有isCar x,isBlue x然后我想要一些给我的东西:

let isBlueCar x = isCar x && isBlue x

但是使用某种组合而不是调用,可能就像:

let isBlueCar x = isCar && isBlue

优选地,某些东西能够接受大量/任意数量的谓词.

我正在使用MVP模式开发大规模应用程序.在开发过程中,我提出了是否应该使用组合或继承的问题.例如:让我们假设我有一个名为形式美孚与场一个和乙.在本申请的另一部分我有一个表格栏具有相同字段阿和乙但附加字段Ç.

目前,代码是使用继承方法编写的,其中表单Bar从表单Foo继承.然后,演示者处理与模型略有不同的数据.这很简单,但是如果遵循"是A"的经验法则,是否打败我,因为即使表格不同,它们也处理公共输入(A和B).

然而,在这里我一直在考虑"继承的构成"和Liskov替换原则,并认为我应该使用组合而不是继承.然而,因为我使用的是MVP,所以它比预期的要复杂得多,因为我必须有一个表格Foo的演示者,字段A和B,然后是一个带有字段C的Bar的演示者,以及对Foo的演示者的引用,以便它可以将字段A和B注入其中.

问题是它已被证明是更多的代码,因为我必须在Foo的演示者中添加一些排序getter和setter,以便能够将数据传递给Bar.如果我打破MVP以提供作曲,这感觉就像某种程度.

所以我的问题是:

对于我的情况,使用组合而不是继承是否真的更好？为什么？

使用组合"打破"MVP？

比方说,我有属性A上classA和财产B上classB,我想classAB有两个属性A和B.我仍然不明白如何使这一切都与作文有关.

我意识到这可以通过继承来完成,但我想学习如何使用组合来做到这一点.我看过一些例子,但我仍然不知道它是如何运作的.

我把两个单独的程序放在一起,玩一个名为'Crazy Eights'的纸牌游戏.

我为这个程序编写的类基于一个默认的"card"包,它提供了扑克牌对象和扑克牌的一些通用方法.

我采取了两种不同的方法来实现这一点,这些方法本身都是功能性的.

这是两个UML类图,描述了两种方法:

继承子类'转换'方法

具有类似方法的组合子类

正如你在方法1中看到的,EightsCard类包含一个方法转换(Card)这里是方法:

  /**
   * Converts a Card into an EightsCard
   * @param card The card to be converted
   * @return The converted EightsCard
   */
   public EightsCard convert(Card card) {
     if (card != null) {
     EightsCard result = new EightsCard(card.getRank(), card.getSuit());
     return result;
     } 
     return null;
   }
 }

此方法允许您从CardCollection调用方法,否则这些方法将不合法.例如,在EightsPlayer类的play方法中如下所示:

  /**
   * Removes and returns a legal card from the player's hand.
   */
  public EightsCard play(Eights eights, EightsCard prev) {
    EightsCard ecard = new EightsCard(0, 0); …

在实施方面,组合设计与授权的区别是否有所不同.例如,下面的代码似乎正在进行委托,因为用户无法在不使用b的情况下访问组合对象(即"a").因此,用户需要调用类b的接口,然后"class b"调用"class a"的适当接口,使其成为委托.这有意义吗？

Class A {
friend class B;
private: 
A(){}; //dont want user to instantiate this class object since it wont sense without any context. Just like a room with no house.
void PrintStructure(){};
};

Class B{
public:
void PrintStructure(){a.PrintStructure();} //delegate

private:
A a; //composition
};