标签: composition

我之前对装饰器模式的理解是你继承Window了WindowDecorator,然后在重写的方法中,在调用Window所述方法的实现之前做了一些额外的工作.类似于以下内容:

public class Window
{
    public virtual void Open()
    {
        // Open the window
    }
}

public class LockableWindow : Window // Decorator
{
    public virtual void Open()
    {
        // Unlock the window
        base.Open();
    }
}

然而,这基本上是对装饰进行硬编码,那么如何使用合成而不是继承来重构呢？

假设我有一份A的仲裁清单

class A
{
string K {get;set;}
string V {get;set;}
}

...
List<A> theList = ...

有没有一种简单的方法从列表中组成字典？(如下所示)

Dictionary<string, string> dict = magic(x => x.K, x => x.V, theList)

我不想写下面的代码:

var d = new Dictionary<string, string>
foreach(var blah in theList)
    d[blah.K] = blah.V

假设我的应用程序中需要一个新类型,它由一个std::vector<int>扩展的单个函数组成.直接的方式是组合(由于STL容器的继承限制):

class A {
    public:
        A(std::vector<int> & vec) : vec_(vec) {}
        int hash();
    private:
        std::vector<int> vec_
}

这要求用户首先在构造函数中构造一个vector<int>和一个副本,这在我们要处理大量的大向量时是不好的.当然,人们可以写一个传递push_back(),但这引入了可变状态,我想避免.

所以在我看来,我们可以避免复制或保持不可变,这是正确的吗？

如果是这样,最简单(和效率等效)的方法是在命名空间范围内使用typedef和free函数:

namespace N {
typedef std::vector<int> A;
int a_hash(const A & a);
}

这只是在某种程度上感觉不对,因为未来的扩展将"污染"命名空间.此外,调用a_hash(...)any vector<int>是可能的,这可能会导致意外的结果(假设我们对用户必须遵循的A施加约束或者在第一个示例中强制执行)

我的两个问题是:

• 在使用上述类代码时,如何不牺牲不变性和效率？
• 何时使用自由函数而不是类/结构中的封装是否有意义？

谢谢!

这个功能有什么问题？这似乎是一个范围错误(虽然我认为我通过将每个callable放在列表中而不是直接使用它来修复它).错误是达到最大递归深度(调用comp(inv,dbl,inc)时)...

注意:问题是:为什么它甚至会递归,而不是它达到最大深度的原因......

def comp(*funcs):
    if len(funcs) in (0,1):
        raise ValueError('need at least two functions to compose')
    # get most inner function
    composed = []
    print("appending func 1")
    composed.append(funcs[-1])
    # pop last and reverse
    funcs = funcs[:-1][::-1]
    i = 1
    for func in funcs:
        i += 1
        print("appending func %s" % i)
        composed.append(lambda *args, **kwargs: func(composed[-1](*args,**kwargs)))
    return composed[-1]

def inc(x):
    print("inc called with %s" % x)
    return x+1
def dbl(x):
    print("dbl called with %s" % x)
    return x*2
def inv(x):
    print("inv …

我有一个类BaseClass和一个类Subclass,它派生Baseclass并覆盖它的一些方法.

public class BaseClass{}

public class SubClass extends BaseClass{

//override some methods
}

还有另一个类SimpleBaseClass派生自BaseClass并覆盖其他一些方法BaseClass,因为它提供了与之相比的不同功能SubClass

 public class SimpleBaseClass extends BaseClass{

    //override some other methods
    }

我想在某些情况下的功能和特性赋予SubClass的SimpleBaseClass.最好的做法是什么？在这种情况下是否有适用的模式？简单地说,虽然可以创建一个新的SubSimpleBaseClass派生SubClass,但复制代码SimpleBaseClass并以这种方式具有两个类的功能:SubClass和SimpleBaseClass.

 public class SubSimpleBaseClass extends SubClass{

        //do what SimpleBaseClass does
        }

但是这样代码就会被重新编写SubSimpleBaseClass.避免它的最佳方法是什么？也许Composition？请问Decorator Pattern在这种情况下,适当的解决办法？

试图用我的头围绕javascript组成使用assign.我的基础对象上的属性意外地在实例之间共享.我究竟做错了什么？我有...

Stat.js:

import assign from 'object-assign';
var Stat = assign({}, {
    _value: undefined,

    get: function() {
        return this._value;
    },

    set: function(n) { 
        var max = this.getMax();

        if(n > max) {
            this._value = max;
        } else {
            this._value = n; 
        }
    },

    getMax: function() {
        return 1;
    }
});
module.exports = Stat;

HitPoints.js:

import assign from 'object-assign'
import Stat from './Stat.js';

var HitPoints = assign({}, Stat, {        
    getMax: function() {
        return 100;
    }
});
module.exports = HitPoints;

Unit.js:

import …

所以我对C#很新,我得到的引用类型是存储对内存中某个对象的引用的类型(通常在堆上).我的问题是,如果我有一个类将其他类作为其成员变量,那些类成员变量是否也存储引用？我问,因为很多时候你只希望你的类成员变量与他们拥有的对象的生命周期联系在一起,让这些成员变量存储对内存中其他地方的对象的引用是没有意义的.在查找这些变量的值时,这只会增加不必要的间接性.现在我知道解决这个问题的一种方法是制作那些成员变量结构,但是如果这些成员变量需要继承或其他只有类的功能呢？任何见解都表示赞赏.

我有以下文件：

module SimpleComposition where

class Domain a where
    f :: a -> a
    g :: a -> a

h = f . g

尝试在 ghci 中加载它时，出现错误

src\play.hs:7:5: error:
    * No instance for (Domain c0) arising from a use of `f'
    * In the first argument of `(.)', namely `f'
      In the expression: f . g
      In an equation for `h': h = f . g

我认为问题在于fand的类型gisforall a. Domain a => a ->a而不仅仅是a -> …

我想在函数中计算 Box 的高度，并且希望 compose 记住其结果而不是再次调用该函数。该函数具有一些可组合的内容，因此它是一个@Composable函数。

问题是，Compose 不允许我从remember块调用这个函数。

这是我的代码：

val coverImageHeightInDp = remember {
    viewModel.calculateTopCoverHeightInDp()
}

Box(modifier = Modifier
    .then(modifier)
    .fillMaxWidth()
    .height(coverImageHeightInDp)
)

以及以下函数viewModel：

@Composable
fun calculateTopCoverHeightInDp(): Dp {
    val originalImageDimens = Size(1440f, 828f)
    val imageRatio = originalImageDimens.width / originalImageDimens.height
    val configuration = LocalConfiguration.current
    val screenWidthInDp = configuration.screenWidthDp.dp
    return screenWidthInDp / imageRatio
}

我该如何编码才能记住该函数的结果并且在屏幕旋转之前不会再次调用该函数？

谢谢。

我是 OOP 人，最近我必须研究 Golang，这是我以前没有做过的语言。虽然我已经阅读了很多讨论组合的文章，但我注意到在 Golang 上正确使用它有点棘手

假设我有两个 Golang 组合示例，我不知道哪一个是正确的，它们之间会有所不同吗？谢谢

第一个例子

type BaseClass struct {
   db *DB
}

func NewBaseClass(db *DB) *BaseClass {
  return &BaseClass{db}
}

type ChildrenClass1 struct {
     baseClass *BaseClass
}

func NewChildrenClass1(db *DB) *ChildrenClass1 {
  baseClass := NewBaseClass(db)
  return &ChildrenClass1{baseClass}
}

type ChildrenClass2 struct {
     baseClass *BaseClass
}

func NewChildrenClass2(db *DB) *ChildrenClass2 {
  baseClass := NewBaseClass(db)
  return &ChildrenClass2{baseClass}
}

func main(){
  db := NewDB()
  chilrend1 := NewChildrenClass1(db)
  chilrend2 := NewChildrenClass2(db)
}

第二个例子

type BaseClass struct {
   db *DB …

内部类总是在外部类中.如果我们删除了外部类,那么内部类也将被销毁.我不关心内存释放,我只是在思考这个概念.这与构图的概念相同.在这种情况下,内部类必须是现实世界中对象的组合关系的示例.

简而言之,我如何将内在类与现实生活中的面向对象联系起来？通过这个,我的意思是一个非技术性的例子; 也许是与动物或电子游戏相关的隐喻？

如果构造函数是组合的一个很好的例子,那么在面向对象中涉及内部类的基本需求是什么？

以下示例是否准确？

例如

大学是外课.

教师是内在的阶级.

我确实理解面向对象,但我发现很难将内部阶级与现实世界联系起来.你能给我一些指示吗？