has-a关系
举个例子，学生与（学生姓名、考试成绩）的关系就是has-a关系而不是is-a关系，学生不是姓名，也不是一组考试成绩，学生有姓名，也有一组考试成绩
包含
通常，用于建立has-a关系的C++技术是组合（包含），即创建一个包含其他类对象的类。例如，可以将Student类声明为如下所示：
class Student{
private:
	string name;				// use a string object for name
	valarray<double> scores;	// use a valarray<double> object for scores
	...
public:
	double sum() const;
};

在派生类中，可以直接通过基类对象来调用基类的方法
double Student::sum() const { return scores.sum(); }

私有继承
C++还有另一种实现has-a关系的途径——私有继承。使用私有继承，基类的公有成员和保护成员都将成为派生类的私有成员。这意味着基类方法将不会成为派生对象公有接口的一部分，但可以在派生类的成员函数中使用它们。
使用私有继承，类将继承实现。例如，如果从string类派生出Student类，后者将有一个string类组件，可用于保存字符串。另外，Student方法可以使用string方法来访问string组件。
包含将对象作为一个命名的成员对象添加到类中，而私有继承将对象作为一个未被命名的继承对象添加到类中。因此私有继承提供的特性与包含相同：获得实现，但不获得接口。所以，私有继承也可以用来实现has-a关系
class Student : private std::string, private std::vallarray<double>
{
public:
	double average() const;
	...
};

在派生类中，可以使用类名和作用域解析运算符来调用基类的方法
double Student::average() const
{
	if(vallarray<double>::size() > 0)
		return vallarray<double>::sum() / vallarray<double>::size();
	else return 0;
}

如何选择
由于既可以使用包含，也可以使用私有继承来建立has-a关系，那么应使用哪种方式呢？大多数C++程序员倾向于使用包含。首先，它易于理解。类声明中包含表示被包含类的显示命名对象，代码可以通过名称引用这些对象，而使用继承将使关系更抽象。其次，继承会引起很多问题，尤其从多个基类继承时，可能必须处理很多问题，如包含同名方法的独立的基类或共享祖先的独立基类。总之，使用包含不太可能遇到这样的麻烦。另外，包含能够包括多个同类的子对象。如果某个类需要3个string对象，可以使用包含关系声明3个独立的string成员。而继承则只能使用一个这样的对象（当对象都没有名称时，难以区分）
然而，私有继承所提供的特性确实比包含多。例如，假设类包含保护对象（可以是数据成员，也可以是成员函数），则这样的成员在派生类中是可用的，但在继承层次结构外是不可用的。如果使用组合将这样的类包含在另一个类中，则后者将不是派生类，而是位于继承层次结构之外，因此不能访问保护成员。但通过继承得到的将是派生类，因此它能够访问保护成员。
另一种需要使用私有继承的情况是需要重新定义虚函数。派生类可以重新定义虚函数，但包含类不能。使用私有继承，重新定义的函数将只能在类中使用，而不是公有的。
总结
通常，应使用包含来建立has-a关系；如果新类需要访问原有类的保护成员，或需要重新定义虚函数，则应使用私有继承

    
内聚标志一个模块内各个元素彼此结合的紧密程度，它是信息隐藏和局部化概念的自然扩展。
低内聚：
（1）偶然内聚：如果一个模块完成一组任务，这些任务彼此间即使有关系，关系也是很松散 的，这就叫做偶然内聚；
（2）逻辑内聚：如果一个模块完成的任务在逻辑上属于相同或相似的一类（例如，一个模块产生各种类型的全部输出），称为逻辑模块；
（3）时间内聚：一个模块包含的任务必须在同一段时间内执行（例如，模块完成各种初始化工作），就叫时间内聚。
中内聚：
（1）过程内聚：如果一个模块内的处理元素是相关的，而且必须以特定次序执行，则称为过程内聚；
（2）通信内聚：如果模块中所有元素都使用同一个输入数据和（或）产生同一个输出数据，则称为通信内聚。
高内聚：
（1）顺序内聚：如果一个模块内的处理元素和同一个功能密切相关，而且这些处理必须顺序执行（通常一个处理元素的输出数据作为下一个处理元素的输入数据），则称为顺序内聚。根据数据流图划分模块时，通常得到顺序内聚的模块，这种模块彼此间的连接往往比较简单。
（2）功能内聚：如果模块内所有处理元素属于一个整体，完成一个单一的功能，则称为功能内聚。功能内聚是最高程度的内聚。

转载于:https://www.cnblogs.com/tt10/p/5384483.html

背景
有一个list，其中的元素存在之间相互包含的关系，即元素A可能是原始B的子串。举个例子：

输入list a=['我是卖麻辣烫的小男孩', '小男孩', '麻辣烫', '华中科技大学','大学']，希望返回的结果是['我是卖麻辣烫的小男孩', '华中科技大学']
解法
由于长字符串不可能被短字符串所包含，即长字符串不可能是短字符串的子串，那么只需要按照字符串长度降序排序，并设立一个新的list(比如new_a)，从长->短，依次判断排序后的字符串是否是new_a中元素的子串。

具体代码：
    def get_max_len_string(input_list):
        input_list.sort(key=lambda x: len(x), reverse=True)#降序排序，因为最长的字符串是不可能是其他字符串的子串
        out, filter_list = [], []
        for s in input_list:
            mask_list = [s in o for o in out]
            if not any(mask_list):#any函数全部为false才返回false
                out.append(s)
            else:
                # 记录是因为那个元素的存在导致被过滤
                been_contained_index = mask_list.index(True)
                large_word = out[been_contained_index]
                filter_list.append(s)
        return out, filter_list
    a = ['我是卖麻辣烫的小男孩', '小男孩', '麻辣烫', '华中科技大学', '大学']
    new_a = get_max_len_string(a)
    print("new list=", new_a[0])
    print("abandoned elements=", new_a[1])

运行结果：
new list= ['我是卖麻辣烫的小男孩', '华中科技大学']
abandoned elements= ['小男孩', '麻辣烫', '大学']

形象说明UML中的包含与扩展的区别
举个网上流行的例子:比如你从1楼要去5楼,那爬楼梯是必须的,则爬楼梯是"包含关系",如果你上到2楼时,顺便去了趟卫生间,则去卫生间是"扩展关系"。




包含关系：使用包含（Inclusion）用例来封装一组跨越多个用例的相似动作（行为片断），以便多个基（Base）用例复用。基用例控制与包含用例的 关系，以及被包含用例的事件流是否会插入到基用例的事件流中。基用例可以依赖包含用例执行的结果，但是双方都不能访问对方的属性。 


   包含关系对典型的应用就是复用，也就是定义中说的情景。但是有时当某用例的事件流过于复杂时，为了简化用例的描述，我们也可以把某一段事件流抽象成为一个被包含的用例；相反，用例划分太细时，也可以抽象出一个基用例，来包含这些细颗粒的用例。这种情况类似于在过程设计语言中，将程序的某一段算法封装成一个子过程，然后再从主程序中调用这一子过程。　

   例如：业务中，总是存在着维护某某信息的功能，如果将它作为一个用例，那新建、编辑以及修改都要在用例详述中描述，过于复杂；如果分成新建用例、编辑用例和删除用例，则划分太细。这时包含关系可以用来理清关系。




2、扩展(extend)

扩展关系：将基用例中一段相对独立并且可选的动作，用扩展（Extension）用例加以封装，再让它从基用例中声明的扩展点（Extension Point）上进行扩展，从而使基用例行为更简练和目标更集中。扩展用例为基用例添加新的行为。扩展用例可以访问基用例的属性，因此它能根据基用例中扩展 点的当前状态来判断是否执行自己。但是扩展用例对基用例不可见。

对于一个扩展用例，可以在基用例上有几个扩展点。   


例如，系统中允许用户对查询的结果进行导出、打印。对于查询而言，能不能导出、打印查询都是一样的，导出、打印是不可见的。导入、打印和查询相对独立，而且为查询添加了新行为。因此可以采用扩展关系来描述：






类与类之间存在以下关系:
(1)泛化(Generalization)

(2)关联(Association)

(3)依赖(Dependency)

(4)聚合(Aggregation)

UML图与应用代码例子:

1.泛化(Generalization)

[泛化]
表示类与类之间的继承关系，接口与接口之间的继承关系，或类对接口的实现关系。一般化的关系是从子类指向父类的，与继承或实现的方法相反。
[具体表现]
父类 父类实例＝new 子类()
[UML图](图1.1)


图1.1 Animal类与Tiger类,Dog类的泛化关系


[代码表现]



class Animal{}   

class Tiger extends Animal{}   

public class Test   

{   

    public void test()   

     {   

         Animal a=new Tiger();   

     }   

}  

2.依赖(Dependency)

[依赖]
对于两个相对独立的对象，当一个对象负责构造另一个对象的实例，或者依赖另一个对象的服务时，这两个对象之间主要体现为依赖关系。
[具体表现]
依赖关系表现在局部变量，方法的参数，以及对静态方法的调用
[现实例子]
比如说你要去拧螺丝，你是不是要借助(也就是依赖)螺丝刀(Screwdriver)来帮助你完成拧螺丝(screw)的工作
[UML表现](图1.2)

图1.2 Person类与Screwdriver类的依赖关系


[代码表现]

public class Person{   

    /** 拧螺丝 */  

    public void screw(Screwdriver screwdriver){   

         screwdriver.screw();   

     }   

}  

3.关联(Association)

[关联]
对于两个相对独立的对象，当一个对象的实例与另一个对象的一些特定实例存在固定的对应关系时，这两个对象之间为关联关系。
[具体表现]
关联关系是使用实例变量来实现
[现实例子]
比如客户和订单，每个订单对应特定的客户，每个客户对应一些特定的订单；再例如公司和员工，每个公司对应一些特定的员工，每个员工对应一特定的公司
[UML图] (图1.3)

图1.3 公司和员工的关联关系


[代码表现]

public class Company{   

    private Employee employee;   

    public Employee getEmployee(){   

        return employee;   

     }   

    public void setEmployee(Employee employee){   

        this.employee=employee;   

     }   

    //公司运作   

    public void run(){   

         employee.startWorking();   

     }   

}  
(4)聚合（Aggregation）

[聚合]
当对象A被加入到对象B中，成为对象B的组成部分时，对象B和对象A之间为聚集关系。聚合是关联关系的一种，是较强的关联关系，强调的是整体与部分之间的关系。
[具体表现]
与关联关系一样，聚合关系也是通过实例变量来实现这样关系的。关联关系和聚合关系来语法上是没办法区分的，从语义上才能更好的区分两者的区别。
[关联与聚合的区别]

(1)关联关系所涉及的两个对象是处在同一个层次上的。比如人和自行车就是一种关联关系，而不是聚合关系，因为人不是由自行车组成的。

聚合关系涉及的两个对象处于不平等的层次上，一个代表整体，一个代表部分。比如电脑和它的显示器、键盘、主板以及内存就是聚集关系，因为主板是电脑的组成部分。

(2) 对于具有聚集关系（尤其是强聚集关系）的两个对象，整体对象会制约它的组成对象的生命周期。部分类的对象不能单独存在，它的生命周期依赖于整体类的对象的 生命周期，当整体消失，部分也就随之消失。比如张三的电脑被偷了，那么电脑的所有组件也不存在了，除非张三事先把一些电脑的组件（比如硬盘和内存）拆了下 来。
[UML图](图1.4)

图1.3 电脑和组件的聚合关系


[代码表现]

public class Computer{   

    private CPU cpu;   

    public CPU getCPU(){   

        return cpu;   

     }   

    public void setCPU(CPU cpu){   

        this.cpu=cpu;   

     }   

    //开启电脑   

    public void start(){   

        //cpu运作   

         cpu.run();   

     }   

}