标签: object-composition

我有以下问题,我将尝试使用以下示例进行说明.

class Brick():
    def __init__(self):
        self.weight = 1

class House():
    def __init__(self, number_bricks):
        self.bricks = [Brick() for i in range(number_bricks)]

    def get_weight(self):
        return reduce(lambda x,y: x+y, [brick.weight for brick in self.bricks])

但现在假设我创建了一种新的Brick,StrongBrick,以便我创建一个房子,一个子类StrongHouse,StrongBrick在StrongHouse扮演与Brick在House中扮演的角色完全相同的角色.我怎样才能以一种很好的方式做到这一点(不只是重新输入所有的类定义)？

所以基本的想法是,如何将一些由一些对象组成的类更改为同一个类但是由原始成员对象的子类组成？

非常感谢你能给我的任何帮助.

我正在使用MVVM模式.NET Framework 4.6.1开发WPF.和C#.

我的问题不是关于WPF,而是关于使用组合而不是继承这两个类:

public class ObservableObject : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected void RaisePropertyChangedEvent(string propertyName)
    {
        var handler = PropertyChanged;
        if (handler != null)
            handler(this, new PropertyChangedEventArgs(propertyName));
    }
}

和:

public class MainViewModel : ObservableObject
{
    private string statusPrinter;

    public string StatusPrinter
    {
        get { return statusPrinter; }
        set
        {
            statusPrinter = value;
            RaisePropertyChangedEvent("StatusPrinter");
        }
    }
}

MainViewModel继承自我ObservableObject,我不想使用继承.

我可以做这个:

public class MainViewModel
{
    private string statusPrinter;
    private ObservableObject observable;

    public string StatusPrinter
    {
        get …

只是（模拟）多重继承是混合的唯一优点：

 Object.assign( MyClassA.prototype, MyMixinB )

与继承

 class MyClass extends MyClassB {

 // MyClassB = class version of MyMixinB

在 ES6 JavaScript 中？

谢谢

我在这里阅读此链接,在此处输入链接描述,以了解State Desing Patern.

接口类:

public interface State {
    void doAction();
}

onState类:

public class TVStartState implements State {

    @Override
    public void doAction() {
        System.out.println("TV is turned ON");
    }
}

截止态:

public class TVStopState implements State {

    @Override
    public void doAction() {
        System.out.println("TV is turned OFF");
    }

}

TvContext类:

public class TVContext implements State {

    private State tvState;

    public void setState(State state) {
        this.tvState=state;
    }

    public State getState() {
        return this.tvState;
    }

    @Override
    public void doAction() { …

我正在尝试将一些数据保存到我的Room数据库中，但是它一直向我显示一个错误，这是代码：

MovieDao.kt

@Dao
interface MoviesDao {
    @Query("SELECT * from movie")
    fun getAll() : LiveData<List<Movie>>

    @Update
    fun update(movie: Movie)

    @Insert(onConflict = OnConflictStrategy.IGNORE)
    fun insert(movie: Movie)
}

MoviesDatabase.kt

@Database(entities = [Movie::class], version = 1, exportSchema = false)
@TypeConverters(TorrentConverter::class, GenreConverter::class)
abstract class MoviesDatabase : RoomDatabase() {
    companion object {
        private var instance: MoviesDatabase? = null
        fun getDatabase(context: Context) : MoviesDatabase{
            if(instance == null) {
                instance = Room.databaseBuilder(context.applicationContext, MoviesDatabase::class.java,
                    "movies_database").build()
            }
            return instance as MoviesDatabase
        }
    }
    abstract fun getMoviesDao() : MoviesDao
}

MovieModels.kt …

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

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

我有以下代码，有一个由“Eyebrow”类组成的“Face”类。面部表情可以更改为允许的公共枚举之一，从而控制应如何更改每个组成部分。每个组成类都应该负责响应更改后的表达式，这就是我想将其传递给每个组成部分的原因。

脸.h：

#include "eyebrow.h"
class Face {
    public:
        enum Expression {NEUTRAL, JOY, ANGER};
        void setExpression(Expression);
    private:
         Eyebrow left_eyebrow;
}

脸.cpp：

#include "face.h"
#include "eyebrow.h"

void Face::setExpression(Expression e) {
     left_eyebrow.setExpression(e);
}

眉毛.h：

#include "face.h"

class Eyebrow {
    public:
         void setExpression(Face::Expression);
};

代码正在用 Cmake 编译：

add_executable(Main main.cpp face.cpp eyebrow.cpp)

我收到以下编译器错误：'Face' 尚未在 eye.h 中的 void setExpression(Face::Expression_e) 中声明。

然后我转发声明的人脸（见下文）并得到编译器错误：'Face::Expression' has not been created in void setExpression(Face::Expression); 在眉毛.h

眉毛.h（带有前向声明）：

#include "face.h"

class Face;
class Eyebrow {
    public:
         void setExpression(Face::Expression);
};

有什么推荐的解决方法，朋友们应该用吗？

java version 1.7.0_65

我有一个单例设计模式类.这将始终返回最初创建的同一实例.

但是,我遇到的问题是这个类需要从另一个类创建许多其他对象.我已经使用了这个组合(POI类的实例ArlabFacade).从这个单例实例中,客户端应该能够创建许多POI对象.而且我不想公开POI类的内部工作,一切都必须通过单例实例.

private static ArlabFacade mArlabFacade = null;
private POI mPoi; /* Should be able to create many object of this class */

private ArlabFacade(Context context) {     
        /* initialize properties */
        mContext = context;

        mPoi = null;
    }

public static ArlabFacade getInstance(Context context) {

        /* Create a synchronised singleton instance */
        ReentrantLock lock = new ReentrantLock();
        lock.lock();
        if(mArlabFacade == null) {
            mArlabFacade = new ArlabFacade(context);
        }
        lock.unlock();

        return mArlabFacade;
    }

我尝试过做这样的事情,但它有两个问题.

1) I …