标签: composition

可能重复:
首选组合而不是继承？

我想知道,为什么(或者在哪种情况下)应该考虑继承而不是组合,当它有这么多的缺点时:

• 如果我们在调用超类方法的子类中实现/覆盖一个方法,则无法保证我们的超类的另一个版本(可能是某些库)不会破坏我们的代码
• 如果在超类中出现一个新方法,该方法具有与子类方法相同的签名,但具有不同的返回类型,则我们的类将不会编译.

因此,我无法想象,地球上我们如何依赖它.超类作者可能希望提高性能,我们的客户端代码可能会崩溃.

所以我的问题是:

• 这些问题是如何解决的(例如在标准Java库中)？
• 何时使用继承和组合？

我有一个 A 类和 B 类。C 类派生自 B 类，并将 A 类对象作为组合。http://ideone.com/JGT48M

#include "iostream"
using namespace std;

class A {
  int i;
public:
  A(int ii) : i(ii) {
      cout << "\n Constructor of A is called \n";

  }
  ~A() {
      cout << "\n destructor  of A is called \n";
  }
  void f() const {}
};

class B {
  int i;
public:
  B(int ii) : i(ii) {
      cout << "\n Constructor of B is called \n";
  }
  ~B() {
      cout << "\n …

由于聚合和组合是相关的协会,或者我们可以说它给出了对象或其他任何东西之间关系的理解.

我发布了这个问题,因为我在采访中问了一个问题,即什么是组合和聚合.

所以根据我的理解,我给出了我的想法,如下所示.

http://www.coderanch.com/t/522414/java/java/Association-Aggregation-Composition

聚合,关联和组合

Java中的关联与聚合与组合

还访问了更多.

我的基本解释与聚合表示松散的关系有关,而作文表明与此有关的强关系和明确的解释.

但是采访者侮辱了我并且说这是理论概念,你说我想要完美的Java代码,在这些代码中它们如何区别,并告诉我是否会给你一个小的应用程序然后你如何识别这是聚合和这个是作文？

那么现在我想了解纯技术概念和Java代码,它们的区别在于它们是什么？它们是什么？

我正在阅读这篇关于继承的组合的wiki文章,在这个例子中他们使用了一个抽象类.假设你想避免他们完全使用抽象类,只使用具体的类.我想知道,我的例子是正确使用构图.假设我有以下IGameobject接口.

    public interface IGameObject
    {
        string Name {get;}
    }

以及随后的武器界面:

    //Note the IGameObject getter
    public interface IWeapon
    {
        int Damage {get; }
        IGameObject gameObject {get;}
    }

通常,在我的游戏中,武器是一个 IGameObject.然而,考虑到我们正在使用组合,根据维基文章,这是一种关系.

现在,我可以在创建Sword对象时执行此操作:

public class Sword : IWeapon
{
        private IWeapon weaponObject;

        public Sword(IWeapon weapon)
        {
            this.weaponObject = weapon;
        }

        public int Damage
        {
            get
            {
                return this.weaponObject.Damage;
            }
        }

        public IGameObject gameObject
        {
            get
            {
                return this.weaponObject.gameObject;
            }
     }

}

我现在可以将我的剑存放在一个集合中,例如List:

List<IWeapon> weapons = new List<IWeapon>(); …

如何呈现匿名类的关联组成在UML 2中的类本身中定义？

谢谢

考虑有一个简单的用例，一个带有具有共同属性的子类的父类，例如：类 Animal 有一个名称：

public class abstract Animal{
    protected String name;
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }

    abstract void printInfo();
}

和子类：

public class Cat extends Animal{
    @Override
    public void printInfo(){
        System.out.println("I'm a cat");
    }
}

public class Dog extends Animal{
    @Override
    public void printInfo(){
        System.out.println("I'm a dog");
    }
}

根据优先组合而不是继承？和https://softwareengineering.stackexchange.com/questions/162643/why-is-clean-code-suggesting-avoiding-protected-variables，应该避免继承和受保护的变量，所以我将 Animal 修改为一个接口：

public interface Animal{
    void setName(String name);
    String getName();
    void printInfo();
}

但是在移动类属性时噩梦就来了：

public class Cat implements Animal{
    private …

我正在通过以下链接找出组合和聚合之间的区别。

https://www.geeksforgeeks.org/association-composition-aggregation-java/

我能够理解，组合意味着一种关系，其中孩子不能独立于父母而存在，而聚合意味着一种关系，其中孩子可以独立于父母而存在。但无法理解如何以编程方式区分。下面是链接中给出的聚合和组合的示例。在这两种情况下，除了 Student 和 Department 类有一个额外的变量“name”外，这两种类的结构相同。如在组合中“子不能独立于父而存在”，但是在这里，我可以创建一个单独的 Book 对象并使用它，而无需将其添加到 Library。

聚合

// student class
class Student 
{
    String name;
    int id ;
    String dept;

    Student(String name, int id, String dept) 
    { 
        this.name = name;
        this.id = id;
        this.dept = dept;
    }
}



/* Department class contains list of student
Objects. It is associated with student
class through its Object(s). */
class Department 
{
    String name;
    private List<Student> students;

    Department(String name, List<Student> students) 
    {
        this.name = name;
        this.students = students;    
    } …

我一直在学习如何在我的 python 编程中实现组合，但我很难理解为什么它比继承更受欢迎。

例如，这是我到目前为止的代码：

class Particle:
   # Constructor (public)
   def __init__(self, _name, _charge, _rest_energy, _mass, _velocity):
       # Attributes (private)
       self.__name = _name
       self.__charge = _charge
       self.__restEnergy = _rest_energy
       self.__mass = _mass
       self.__velocity = _velocity

   # Getter functions (public)
   def getName(self):
       return self.__name

   def getCharge(self):
       return self.__charge

   def getRestEnergy(self):
       return self.__restEnergy

   def getMass(self):
       return self.__mass

   def getVelocity(self):
       return self.__velocity

   # Setter procedures (public)
   def setName(self, _name):
       self.__name = _name

   def setCharge(self, _charge):
       self.__charge = _charge

   def setRestEnergy(self, _rest_energy):
       self.__restEnergy = _rest_energy …

假设我们有以下功能：

def first(a: A): B = ???
def second(b: B): C = ???

我想用 来组合它们andThen，但是下面的代码：

(first andThen second)(a)

结果是：

<console>:14: error: missing argument list for method first
Unapplied methods are only converted to functions when a function type is expected.
You can make this conversion explicit by writing `first _` or `first(_)` instead of `first`.                                                                                                                                                                    
(first andThen second) (1)

我正在为其他人的代码创建 UML 图，我遇到了一些奇怪的事情 - 一个子类有一个父类作为它的成员变量之一，似乎既有“有一个”关系，也有“是一个”关系。显然，这是故意的，但即使浏览了 UML 指南，我仍然不知道如何表示这一点。我是否只显示继承，更强的关系？我是否覆盖箭头，创建一个带有一条线的实心白色箭头？

在 Java 中替换了类名：

public abstract class A {
}

public abstract class B extends A {
    protected A a;
}

我将如何代表这一点？