标签: composition

我已经提取了继承和组合之间的以下区别.我想知道后端对象的创建延迟是什么意思？请找到以下差异.

组合允许您延迟后端对象的创建,直到(并且除非)它们被需要,以及在前端对象的整个生命周期中动态地更改后端对象.通过继承,您可以在创建子类时立即在子类对象图像中获取超类的图像,并且在子类的整个生命周期中它仍然是子类对象的一部分

在python中我定义了函数:

def foo_1(p): return p + 1
def foo_2(p): return p + 1
def foo_3(p): return p + 1
def foo_4(p): return p + 1
def foo_5(p): return p + 1

我需要执行这些功能,因为链可能是这样的:

foo_1(foo_2(foo_3(foo_4(foo_5(1)))))

我是否可以知道是否可以将函数推入列表然后将这些函数作为链执行,也许我可以给出执行序列？

lf = [Null,foo_1,foo_2,foo_3,foo_4,foo_5]  # Null is for +1 issue here

def execu(lst, seq, raw_para):
    # in some way

execu(lf,(1,2,3,4,5), 1)   # = foo_1(foo_2(foo_3(foo_4(foo_5(1)))))
execu(lf,(1,2,3), 1)       # = foo_1(foo_2(foo_3(1)))
execu(lf,(3,3,3), 1)       # = foo_3(foo_3(foo_3(1)))

谢谢!

RGS,

KC

我想用两个对象制作一个合成.我可以用对象嵌套来做到这一点:

object Composition {
  object SomePartOfComposition {
    // some body
  }
}

但是SomePartOfComposition的主体是如此之长,我希望它在一个单独的文件中.我怎样才能做到这一点？

//编辑

我知道,我可以使用特质.但我想要严格的一对一关系 - 它是一个单身人士.

我很惊讶在调用erase时发现了vector :: erase移动元素.我认为它会将最后一个元素与"待删除"元素交换,并将大小减小一个.我的第一反应是:"让我们扩展std :: vector并覆盖erase()".但是我在很多线程中发现了" 从C++ STL容器中获取真的风险吗？ ",它会导致内存泄漏.但是,我没有向vector添加任何新的数据成员.因此没有额外的内存可以释放.还有风险吗？

有些人认为我们应该更喜欢构成而不是继承.在这种情况下,我无法理解这个建议.为什么我要浪费我的时间在"机械"任务中包装其他精彩的std :: vector类的每个函数.继承确实对这项任务最有意义 - 或者我错过了什么？

我为我的节目制作了一个小组.它仅由RadioButtons组成.当选择radiobutton时,我想在其他代码中设置一个布尔值.此面板将用作更大面板或框架的组件,该面板或框架还应能够收听此面板内发生的事件.

那么,我应该选择以下哪个选项来收听事件 -

1 -

RadioButtonPanel extends JPanel implements ActionListener{

  public void actionPerformed(ActionEvent e){}
  //code to add the action listener to the radio buttons 
  oneRadioButton.addActionListener(this);   
}

2 -

RadioButtonPanel extends JPanel{

  class InnerStrength implements ActionListener{
     public void actionPerformed(ActionEvent e){} 
   }    

  //code to add the action listener to the radio buttons     
  oneRadioButton.addActionListener(Anonymous InnerStrength) 

}

3 - 我没想到的任何其他方式吗？

我有一个超级类的东西

class SuperClass {
   private String name;
   private List<SuperClass> subList;
   //getter setters
}

我想扩展这个SuperClass以获得更多的字段,比如

class SubClass extends SuperClass {
    private String email;
   //getter setter
}

现在,我的问题是,因为SuperClass包含对SuperClass类型的对象列表的引用,我将如何确保任何SubClass对象保存对SubClass类型的对象列表的引用...它甚至可能吗？我在这里做了什么非常错的事吗？

编辑 我可以做类似的事情

class SuperClass {
private String name;
private List<? extends SuperClass> subList;
public SuperClass(List<? extends SuperClass> subList) {
    this.subList = subList;
  }
}

而现在SubClass只需要调用超类的构造函数

class SubClass extends SuperClass{
    private String email;

    private SubClass(List<? extends SuperClass> subList) {
        super(subList);
      }
    }

但是现在,如果我想在列表中添加一些内容,我将无法做到,因为PECS(生产者 - 扩展,消费者 - 超级)泛型的原则不允许我这样做..所以无论何时,我都必须将对象添加到subList我将不得不创建一个新列表,然后在SubClass中设置列表

你能帮我用C++编写组合示例应用程序吗？

我需要这样的层次结构:类AppleCake继承自基类Cake,还有类CakePacket,它有4个Cakes.我写了一些代码,但问题是我不知道如何向CakePacket添加4个Cake对象.我是C++的初学者,所以如果会有一些愚蠢的错误,我很抱歉.

#include <iostream>
using namespace std;

class Cake {

protected:
  int cost;
public:
  void setCostr(int a) { cost = a; }
  int getCost() { return cost; }
  Cake(int x) { cost = x;  }
  ~Cake() {  }
};


class AppleCake : public Cake {
  int diameter;
public:
  int getDiameter() { return diameter; }

  AppleCake(int x, int y): Cake(x)
    { diameter = y; }

  ~AppleCake() {  }
};


class CakePacket 
{
private:
    Cake *cArr;

    CakePacket() { }

public:
    CakePacket(Cake *x) …

我是一名Java/C#程序员,正在尝试用PHP学习/完成一个项目.任何人都可以向我解释为什么"组合"在PHP 5.3中不起作用,因为人们会期望从面向对象的语言？

我试图研究这个问题,但由于术语混淆(使谷歌无用......)和糟糕的文档,我还没有找到任何有用的东西.

<?php /*PHP VERSION 5.3.3*/

class MyClassOne
{
    public function myFunctionOne()
    {
        echo "<p> My Function One </p>";
    }
}

class MyClassTwo
{
    private $myClassOne;

    function __constructor() // WRONG WRONG WRONG - __construct() - and it works.
    {
        $this->myClassOne = new MyClassOne();
    }

    public function myFunctionTwo()
    {
        echo "<p> My Function Two </p>";
        $this->myClassOne->myFunctionOne(); // This crashes the "application"
    }

}


$myclassone = new MyClassOne();
$myclassone->myFunctionOne();
$myclasstwo = new MyClassTwo();
$myclasstwo->myFunctionTwo();


/*
Expectet result:
My Function One
My …

我有一个关于我在一个例子上做过重构的问题.

这是原始代码:

class Parts
  attr_reader :parts

  def initialize(parts)
    @parts = parts
  end

  def size
    parts.size
  end

  def spares
    parts.select{|part| part.needs_spare}
  end
end

这是重构的代码:

require 'forwardable'
class Parts
  extend Forwardable
  def_delegators :@parts, :size, :each
  include Enumerable

  def initialize(parts)
    @parts = parts
  end

  def spares
    select{|part| part.needs_spare}
  end
end

在备用方法中,原始代码执行"parts.select {| part | part.needs_spare}",然后在重构中将其调整为"select {| part | part.needs_spare}".新的备用方法如何知道它从哪个实例变量中选择？

我已经读过g :: A - > B和f :: B - > C的组成,发音("f由g组成"),导致另一个函数(箭头)来自A - > C.这可以是更正式地表达为

f•g = f(g)= compose ::(B - > C) - >(A - > B) - >(A - > C)

上述组成也可以定义如下吗？请澄清.在这种情况下,compose函数采用相同的两个函数f和g并从A - > C返回一个新函数.

f•g = f(g)= compose ::((B - > C),(A - > B)) - >(A - > C)