华为鸿蒙系统HarmonyOS学习之六：鸿蒙OpenHarmony常用术语说明

 

A

Ability: 应用的重要组成部分，是应用所具备能力的抽象。Ability分为两种类型，Feature Ability和Particle Ability。
AbilityForm:表单，是Feature Ability的一种界面展示形式，用于嵌入到其他应用中并作为其界面的一部分显示，并支持基础的交互功能。
AbilitySlice:切片，是单个可视化界面及其交互逻辑的总和，是Feature Ability的组成单元。一个Feature Ability可以包含一组业务关系密切的可视化界面，每一个可视化界面对应一个AbilitySlice。
ANS: Ability Notification Service，是HarmonyOS中负责处理通知的订阅、发布和更新等操作的系统服务。

C

CES: Common Event Service，是HarmonyOS中负责处理公共事件的订阅、发布和退订的系统服务。

D

DV: Device Virtualization，设备虚拟化，通过虚拟化技术可以实现不同设备的能力和资源融合。

F

FA: Feature Ability，元程序，代表有界面的Ability，用于与用户进行交互。

H

 HAP：HarmonyOS Ability Package，一个HAP文件包含应用的所有内容，由代码、资源、三方库及应用配置文件组成，其文件后缀名为.hap。
HDF：HarmonyOS Driver Foundation，HarmonyOS驱动框架，提供统一外设访问能力和驱动开发、管理框架。

I

IDN: Intelligent Distributed Networking，是HarmonyOS特有的分布式组网能力单元。开发者可以通过IDN获取分布式网络内的设备列表以及注册分布式网络内设备在网状态变化信息。

M

MSDP: Mobile Sensing Development Platform，移动感知平台。MSDP子系统提供两类核心能力：分布式融合感知和分布式设备虚拟化两大部分。

分布式融合感知：借助HarmonyOS分布式能力，将各设备感知源进行汇总融合，对用户的空间状态、移动状态、手势、健康状态等进行精准感知，构建全场景泛在基础感知能力，支撑智慧生活新体验。
	
分布式器件虚拟化：借助HarmonyOS分布式能力，构筑器件虚拟化平台，将外部设备的各类器件（如Camera、显示器、SPK/MIC等）虚拟化为本地设备的器件延伸使用。同时具备将自身器件共享给其他设备使用的能力。
P

PA: Particle Ability，元服务，代表无界面的Ability，主要为Feature Ability提供支持，例如作为后台服务提供计算能力，或作为数据仓库提供数据访问能力。

S

SA: System Ability，即系统能力，是由OS提供的基础软件服务和硬件服务。
Super virtual device，超级虚拟终端: 亦称超级终端，通过分布式技术将多个终端的能力进行整合，存放在一个虚拟的硬件资源池里，根据业务需要统一管理和调度终端能力，来对外提供服务。

适配器模式——把一个类的接口变成客户端所期待的另一种接口
	
装饰模式——又名包装模式，以对客户端透明的方式扩展对象的功能，是继承关系的替代方案
	
代理模式——开闭原则的直接支持
	
桥接模式
	
组合模式
	
外观模式
一、代理与代理模式

1.1、代理

所谓静态代理就是自己手写（或者用工具生成）代理类，程序运行前就已经存在的编译好的代理类；如果需要很多代理，每个都这样去创建浪费时间也可能有很多重复代码，采用动态代理可以在程序运行期间根据需要动态的创建代理类及其实例来完成具体的功能。总的来说，根据代理的创建时机和创建方式不同，可以将代理分为静态代理和动态代理。

代理的作用：

用于拦截对真实业务对象的访问（比如不需要直接买演唱会门票，把这个任务交给黄牛）；
	
代理对象应具有和目标对象相同的方法（实现相同的接口或者继承于同一个类）；
	
代理对象应该是目标对象的增强（否则就没必要代理了）。
事实上，真正的业务功能还是由目标类来实现，代理类只是用于扩展、增强目标类的行为。例如，在项目开发中我们没有加入缓冲、日志这些功能而后期需要加入，我们就可以使用代理来实现，而没有必要去直接修改已经封装好的目标类。

1.2、代理模式

在Spring AOP 与MyBatis缓存机制等都使用了代理模式。代理模式使得客户端在使用目标对象的时候 间接通过操作代理对象进行，代理对象是对目标对象的增强。本质是对 开闭原则（软件实体应该通过扩展来实现变化，而不是通过修改已有的代码来实现变化） 的直接支持。

代理模式包含如下角色：

客户端：客户端面向接口编程，使用代理角色完成某项功能
	
抽象主题：一般实现为接口，是对被代理对象行为的抽象
	
被代理角色（目标类）：直接实现上述接口，是抽象主题的具体实现
	
代理角色（代理类）：实现上述接口，是对被代理对象角色的增强
代理模式应用场景：

SpringAOP、事务原理、日志打印、权限控制、远程调用

二、静态代理

2.1、静态代理的实现模式

首先创建一个接口——>创建具体实现类实现该接口——>创建一个代理类也实现该接口。

不同之处在于具体实现类的方法要把业务逻辑功能实现起来，而代理类的方法只需要调用具体类中对应方法即可，这样在需要使用过接口中某个方法功能时直接调用代理类的方法即可，将具体的实现类隐藏在底层。

2.2、代码实例

电影的例子。电影是电影公司委托给影院进行播放的，但是影院可以在播放电影的时候，产生一些自己的经济收益，比如卖爆米花、可乐等，然后在影片开始结束时播放一些广告（最大缺点：静态代理需要生成代理对象，对象多很麻烦）

//1.抽象主题(接口)
//先得有一个接口，通用的接口是代理模式实现的基础(该接口 代表电影这个主题)
public interface Movie {
    void play();
}
//2.被代理角色(目标类)与代理角色(代理类)
//要有一个真正的实现这个 Movie 接口的类和一个只是实现接口的代理类
public class RealMovie implements Movie {
    @Override
    public void play() {
        System.out.println("您正在观看电影 《肖申克的救赎》");
    }
}

/**
这个表示真正的影片。它实现了 Movie 接口。Cinema 就是代理对象，它有一个 play() 方法。不过调用 play() 方法时，它进行了一些相关利益的处理，那就是广告；也就是说，Cinema(代理类) 与 RealMovie(目标类) 都可以播放电影，但是除此之外，Cinema(代理类)还对“播放电影”这个行为进行进一步增强，即增加了额外的处理，同时不影响RealMovie(目标类)的实现。
**/
public class Cinema implements Movie {
    RealMovie movie;
    public Cinema(RealMovie movie) {
        super();
        this.movie = movie;
    }
    @Override
    public void play() {
        guanggao(true);    // 代理类的增强处理
        movie.play();     // 代理类把具体业务委托给目标类，并没有直接实现
        guanggao(false);    // 代理类的增强处理
    }
    public void guanggao(boolean isStart){
        if ( isStart ) {
            System.out.println("电影马上开始了，爆米花、可乐、口香糖9.8折，快来买啊！");
        } else {
            System.out.println("电影马上结束了，爆米花、可乐、口香糖9.8折，买回家吃吧！");
        }
    }
}
//3.客户端
/**
如前所述，代理模式可以在不修改被代理对象的基础上(符合开闭原则)，通过扩展代理类，进行一些功能的附加与增强。由于Cinema(代理类)是事先编写、编译好的，而不是在程序运行过程中动态生成的，因此这个例子是一个静态代理的应用
**/
public class ProxyTest {
    public static void main(String[] args) {
        RealMovie realmovie = new RealMovie();
        Movie movie = new Cinema(realmovie);
        movie.play();
    }
}/** Output
        电影马上开始了，爆米花、可乐、口香糖9.8折，快来买啊！
        您正在观看电影 《肖申克的救赎》
        电影马上结束了，爆米花、可乐、口香糖9.8折，买回家吃吧！
 **/

三、动态代理

3.1、什么是动态代理

动态代理可以在程序运行期间根据需要 动态地创建代理类及其实例 来完成具体的功能费（不需要代理对象）

3.2代码示例（JDK动态代理）

（1）抽象主题（接口）

首先得有一个接口，通用的接口是代理模式实现的基础

public interface Subject {
    public void doSomething();
}

（2）被代理角色(目标类)

要有一个真正的实现这个 Subject 接口的类，以便代理

public class RealSubject implements Subject {
    public void doSomething() {
        System.out.println("call doSomething()");
    }
}

（3）代理角色(代理类)与客户端

在动态代理中，代理类及其实例都是程序自动生成的，因此不需要手动去创建代理类。

在JDK动态代理中，InvocationHandler(Interface)接口和Proxy(Class)类是实现动态代理必须用到的，Proxy通过使用InvocationHandler对象生成具体的代理代理对象，下面是InvocationHandler接口的实现：

/**
 * Title: InvocationHandler 的实现 
 * Description: 每个代理的实例都有一个与之关联的 InvocationHandler
 * 实现类，如果代理的方法被调用，那么代理便会通知和转发给内部的 InvocationHandler 实现类，由它调用invoke()去处理。
 */
public class ProxyHandler implements InvocationHandler {
    private Object proxied;   // 被代理对象
    public ProxyHandler(Object proxied) {
        this.proxied = proxied;
    }
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // 在转调具体目标对象之前，可以执行一些功能处理
        System.out.println("前置增强处理： yoyoyo...");
        // 转调具体目标对象的方法(三要素：实例对象 + 实例方法 + 实例方法的参数)
        Object obj = method.invoke(proxied, args);
        // 在转调具体目标对象之后，可以执行一些功能处理
        System.out.println("后置增强处理：hahaha...");
        return obj;
    }
}

在实现了InvocationHandler接口后，我们就可以创建代理对象了。在Java的JDK动态代理机制中，我们使用Proxy类的静态方法newProxyInstance创建代理对象，如下：

public class Test {
    public static void main(String args[]) {
        // 真实对象real
        Subject real = new RealSubject();
        // 生成real的代理对象
        Subject proxySubject = (Subject) Proxy.newProxyInstance(
                Subject.class.getClassLoader(), new Class[] { Subject.class },
                new ProxyHandler(real));
        proxySubject.doSomething();
        System.out.println("代理对象的类型 ： " + proxySubject.getClass().getName());
        System.out.println("代理对象所在类的父类型 ： " + proxySubject.getClass().getGenericSuperclass());
    }
}/** Output
        前置增强处理： yoyoyo...
        call doSomething()
        后置增强处理：hahaha...
        代理对象的类型 ： com.sun.proxy.$Proxy0
        代理对象所在类的父类型 ： class java.lang.reflect.Proxy
 **/

代理对象proxySubject所对应的类继承自java.lang.reflect.Proxy类，这也正是JDK动态代理机制无法实现对class的动态代理的原因：Java只允许单继承。

（4）JDK中InvocationHandler接口与Proxy类

InvocationHandler接口：

InvocationHandler 是一个接口，每个代理的实例都有一个与之关联的 InvocationHandler 实现类，如果代理的方法被调用，那么代理便会通知和转发给内部的 InvocationHandler 实现类，由它决定处理。的invoke() 方法决定了怎么样处理代理传递过来的方法调用

public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

Proxy类：

DK通过 Proxy 的静态方法 newProxyInstance 动态地创建代理，Proxy 动态产生的代理对象调用目标方法时，代理对象会调用 InvocationHandler 实现类，所以 InvocationHandler 是实际执行者。

    /**  
     * @param loader 类加载器
     * @param interfaces 目标类所实现的接口
     * @param h  InvocationHandler 实例
     */
    public static Object newProxyInstance(ClassLoader loader,
            Class<?>[] interfaces,
            InvocationHandler h)

3.3、CGLIB动态代理

（1）CGLIB动态代理原理

利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理

（2）什么是CGLIB

使用cglib实现动态代理，并且不要求委托类必须实现接口，底层采用asm字节码生成框架 生成代理类的字节码

public class CglibProxy implements MethodInterceptor {
	private Object targetObject;
	// 这里的目标类型为Object，则可以接受任意一种参数作为被代理类，实现了动态代理
	public Object getInstance(Object target) {
		// 设置需要创建子类的类
		this.targetObject = target;
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(target.getClass());
		enhancer.setCallback(this);
		return enhancer.create();
	}

	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
		System.out.println("开启事物");
		Object result = proxy.invoke(targetObject, args);
		System.out.println("关闭事物");
		// 返回代理对象
		return result;
	}
	public static void main(String[] args) {
		CglibProxy cglibProxy = new CglibProxy();
		UserDao userDao = (UserDao) cglibProxy.getInstance(new UserDao());
		userDao.save();
	}
}


3.4、CGLIB动态代理与JDK动态代理的区别

（1）jdk动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前 调用InvokeHandler来处理；

而cglib动态代理是利用asm开源包，对代理类的class文件加载进来，通过修改其字节码生成子类来处理。

（2）jdk动态代理只能对 实现了接口的类 生成代理，而不能针对类；cglib是针对 类 实现代理，主要是对指定的类生成一个子类，覆盖其中的方法

3.5、在Spring中什么时候用CGLIB或者JDK动态代理

如果目标对象实现了接口，默认采用JDK动态代理实现AOP；如果没实现接口，必须使用CGLIB库，Spring会自动切换。

 

四、Spring AOP 与动态代理

AOP专门用于处理系统中分布于各个模块中交叉关注点问题，使用动态代理机制实现的。Spring AOP 默认使用动态代理来创建AOP代理，具体通过以下几步完成：

Spring IOC容器创建Bean（目标类对象）；
	
Bean创建完后，根据具体的切面逻辑及Bean本身使用Java动态代理技术生成 代理对象；
	
应用程序使用上述生成的代理对象替代原对象来完成业务逻辑，从而达到增强处理的目的。

软件六大设计原则（代码充实ing）

1、开--闭原则：对拓展开放，对修改关闭

2、里氏代换原则：任何积累出现的地方，子类一定出现

3、单一职责原则：功能职责单一， 只能拥抱一种变化

4、依赖倒置原则：依赖于抽象，不依赖于实现

5、接口隔离原则：为用户提供小的接口，使用多个专门的接口比使用单一的多接口好

6、迪米特原则：尽量与非朋友少发生关系

#设计模式分为三大类：

创建型模式，共五种： 工厂方法模式、抽象工厂模式、单例模式、构建者模式、原型模式。

结构型模式，共七种： 适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种： 策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

其实还有两类：并发型模式和线程池模式。

关于各种设计模式的详细介绍

#设计模式的六大原则：

总原则－开闭原则

对扩展开放，对修改封闭。 在程序需要进行拓展的时候，不能去修改原有的代码，而是要扩展原有代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。 想要达到这样的效果，我们需要使用接口和抽象类等。

1、单一职责原则 不要存在多于一个导致类变更的原因，也就是说每个类应该实现单一的职责，否则就应该把类拆分。

2、里氏替换原则（Liskov Substitution Principle） 任何基类可以出现的地方，子类一定可以出现。里氏替换原则是继承复用的基石，只有当衍生类可以替换基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。 里氏代换原则是对“开-闭”原则的补充。实现“开闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。里氏替换原则中，子类对父类的方法尽量不要重写和重载。因为父类代表了定义好的结构，通过这个规范的接口与外界交互，子类不应该随便破坏它。

3、依赖倒转原则（Dependence Inversion Principle） 面向接口编程，依赖于抽象而不依赖于具体。写代码时用到具体类时，不与具体类交互，而与具体类的上层接口交互。

4、接口隔离原则（Interface Segregation Principle） 每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分。使用多个隔离的接口，比使用单个接口（多个接口方法集合到一个的接口）要好。

5、迪米特法则（最少知道原则）（Demeter Principle） 一个类对自己依赖的类知道的越少越好。无论被依赖的类多么复杂，都应该将逻辑封装在方法的内部，通过public方法提供给外部。这样当被依赖的类变化时，才能最小的影响该类。 最少知道原则的另一个表达方式是：只与直接的朋友通信。类之间只要有耦合关系，就叫朋友关系。耦合分为依赖、关联、聚合、组合等。我们称出现为成员变量、方法参数、方法返回值中的类为直接朋友。局部变量、临时变量则不是直接的朋友。我们要求陌生的类不要作为局部变量出现在类中。

6、合成复用原则（Composite Reuse Principle） 尽量首先使用合成/聚合的方式，而不是使用继承。

设计模式

1.1设计模式简介

设计模式：每一个模式都描述了在我们的环境中不断出现的问题的解决方案的核心。通过这种方式，可以无数次地使用那些已有的解决方案，无需做重复相同的工作。

模式的组成：特点的环境+产生的一个问题+解决方案

模式的核心思想：进行设计的复用
1.2设计模式与体系结构模式：

设计模式：描述了定制化的相互通信的对象与类，已解决特定环境中的通用设计问题。

体系结构模式：是对系统的高层设计，是从一个较高的层次来考虑组成系统的构件，构件之间的连接关系，以及系统需要满足的约束，用以实现体系结构级的设计复用。通常被称为架构模式，体系结构风格。

二者关系：多个设计模式组件相组合形成了体系结构模式

1.3设计原则

1单一职责原则：类的职责要单一，高内聚，低耦合

2开闭原则：对实体拓展开放，对修改关闭

3里氏代换原则：在软件系统中，可以接受基类对象的地方，必然能使用子类对象

4依赖倒转原则：针对抽象层编程而不是具体的类

5合成复用原则：系统中尽量多的使用组合和聚合关联关系，尽量少使用甚至不使用继承关系。

6接口隔离原则：使用多个接口而不是一个统一的接口

7迪米特法则：两个类之间不应当发生直接的相互作用，相互通信，而是通过引入一个第三者发生间接交互。
2.1 单例模式

确保一个类仅有一个唯一的实例，并且提供一个全局的访问接口。

应用场景：全局有且只有一个实例产生，比如，任务管理器，无论怎么打开有且只有一个。

解决的问题：只有一个唯一的实例（独生子女）
解决方案：

首先将构造函数声明为私有类型，屏蔽通过直接实例化的形式来访问

其次控制全局只有一个实例的类------Static

第三，提供一个可以获得实例的方法，用于返回类的实例，并保证得到的是同一个对象
3.1观察者模式：发布-订阅模式
两个角色:观察者和被观察对象。当被观察者发生改变时，观察者就会收到来自被观察者的消息变化，做出响应。

比较直观的一种形式是使用“注册----通知----撤销注册”
实现步骤：观察者将自己注册到被观察者对象的容器中，被观察对象发生了某种变化，从容器中得到所有的注册对象，逐一通知变化，撤销的时候，观察者通知被观察者，将观察者从容器中清除

减少观察者和被观察者对象之间的耦合
观察者实现类
简单使用加测试结果
4.1适配器模式

使用环境：同一种东西，在不同的环境展现方式不同

例如:游戏中的坐骑-----五彩神鹿,在第一世界它的行走方式是喷跑，在第二世界，行走方式为飞
问题：想使用一个已经存在的类，但他的接口不符合需求

适配器模式：将一个类的接口转换为客户希望的另外一个接口，是的原本接口不兼容而不能一起工作哦的那类类可以一起工作。

适配器模式有四个角色：

目标（target）：定义客户端使用的与特定领域相关的接口

被适配者（adaptee）定义了一个已经存在的接口，这个接口需要匹配

适配者（adapter）：对Adaptee的接口与target的接口进行适配

客户端（Client）:与符合target接口的对象协同。
4.2适配器模式分类

4.2.1类的适配器模式（采用继承实现）

实现步骤（确定目标接口，确定被适配者，创建适配器，继承自被试配者，实现目标接口）

4.2.2对象适配器（采用对象组合方式实现）

实现步骤（确定目标接口，确定被试配者，创建适配器：拥有被试配者的对象，实现目标接口）

1.被确定目标接口
2.确定被试配者：
3.创建适配器（类适配器）将飞的方式给被适配者
/类适配器/

public class ClassAdapter extends Deer implements ITarget {

@Override

public void fly() {

System.out.println(“进入第二世界，我可以带你飞哦”);

}

}
3.2对象适配器

public class ObjectAdapter implements ITarget  {

private Deer deer;

public  ObjectAdapter(Deer d){

this.deer=d;

}

@Override

public void run() {

deer.run();

}

@Override

public void fly() {

System.out.println(“起飞”);

}

}

使用：
二者比较：

类适配器采用多继承的实现方式，带来了不良的高耦合

对象适配器采用对象组合的方式，更符合松耦合精神

类适配器无法面对多个被适配对象
5.1策略模式

环境：游戏中，游戏人物可以有多种组合的武器，比如AK47+98K

或者m416+m24，在团队竞技可以随意切换组合，或者在打人的时候可以随意在两种武器之间进行切换。

策略模式：让算法独立于使用它的客户而独立变化。并将每一个算法封装起来，使他们可以相互替换。
三个角色：

抽象策略类：定义所有支持的算法的公告接口

具体策略类：以抽象策略类接口实现某种具体算法

环境类：维护一个对抽象策略类对象的引用。可定义一个接口来让抽象策略类访问他的数据。
抽象策略类：

//定义了抽象策略类，战斗方式

public interface IStrategy {

public void fighting();

}
具体策略类：

public class Ak47 implements IStrategy {

@Override

public void fighting() {

System.out.println(“使用AK47，dadada!”);

}

}
public class M24 implements IStrategy {

@Override

public void fighting() {

System.out.println(“使用m24，dewu~”);

}

}
public class M416 implements IStrategy {

@Override

public void fighting() {

System.out.println(“使用M416，dedede!”);

}

}
3.环境类：

public class Context {

private IStrategy iStrategy;//里氏代换原则

public Context(IStrategy strategy){

this.iStrategy=strategy;

}

public void fighting(){

this.iStrategy.fighting();

}

}
使用：

//策略模式

Context context;

context=new Context(new Ak47());

context.fighting();

context=new Context(new M24());

context.fighting();

context=new Context(new M416());

context.fighting();

输出结果：

I/System.out: 使用AK47，dadada!

I/System.out: 使用m24，dewu~

使用M416，dedede!

思考：适配器模式和策略模式的区别：

适配器模式是在于同一东西在不同环境有不同的表现，类似于，武器的升级

策略模式是同一种环境同一种行为不同的表现形式，比如，射击时武器的更换

比如人选择旅游出行方式
策略模式优点：提供了对开闭原则的完美支持，用户可以在不修改原有系统的基础上选择算法或行为，也可以灵活的增加新的算法或行为。

策略模式提供了管理相关的算法族的办法

策略模式提供了可以替换继承关系的办法

使用策略模式可以避免使用多重条件转移语句

缺点：客户端必须知道所有的策略类，并自行决定使用哪一个策略类，策略模式将造成产生很多策略类

策略模式适用环境

如果在一个系统里面有许多类，它们之间的区别仅

在于它们的行为，那么使用策略模式可以动态地让

一个对象在许多行为中选择一种行为。

一个系统需要动态地在几种算法中选择一种。

不希望客户端知道复杂的、与算法相关的数据结构

，在具体策略类中封装算法和相关的数据结构，提

高算法的保密性与安全性。
6.1组合模式

环境：用户想表示对象的部分与整体的层次结构，并希望忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象。描述了如何将容器对象和叶子对象进行递归组合，使得用户在使用时无需对他们进行区分，可以一致的对待容器对象和叶子对象。解决树形结构的问题。

组合模式三个角色：

抽象组件类：组合中的对象声明接口，实现所有类共有接口的行为。声明用于访问和管理抽象组件类的子部件的接口。

叶子节点：叶节点对象，叶节点没有子节点。由于叶子节点不能添加分支和树叶，所以叶节点的add和remove没有实际意义。

组件集合类：实现抽象组件类的相关操作，比如add和remove操作。其中包含抽象组件类的容器，用来存储叶子节点集合，有叶节点行为，用来存储叶节点集合
组合模式实现步骤：
定义抽象组件接口

实现叶子节点类，实现抽象组件类的接口

实现组件集合类，实现抽象组件类的接口

定义环境类，将叶子节点和组件集合加入根组件集合

7.1 装饰模式

环境：汽车4s店汽车销售店，用户可以挑选汽车的型号奥迪A1，A4，A6。可装饰的组件倒车雷达，真皮座椅，gps定位。用户可以挑选汽车的型号，加任意的组件。
不必改变原类文件和使用继承的情况下，动态的扩展一个对象的功能，应用程序的可维护性，可扩展性差。
装饰模式中的角色：

油漆工：用来刷油漆，给被装饰着进行装饰的

被修饰者：实现装饰模式有很多形式，最常见的一种就是  “实现被装饰者类----定义被装饰者对象----使用被装饰者对象产生装饰者对象”
装饰模式的实现：

首先定义被装饰者类

通过被装饰者对象产生装饰者对象
解决的问题：如何动态的给一个对象添加功能。

解决方案是利用子对象，委派
8.1状态模式

环境：实现一个旅馆的住宿管理系统，房间有三种状态：空闲，预定，已住

状态模式：允许对象在其内部状态改变的时候改变它的行为。

角色：

环境类：客户使用他的对象类。维护一个抽象状态子类的实例，这个实例定义当前状态。

抽象状态类：定义一个接口来封装与环境类的一个特定状态相关的行为

具体状态类：每一个子类实现与环境类的一个状态相关的行为
实现步骤：定义状态类接口，实现当前系统的真实状态实现此接口

定义环境类，具有状态的类，包含状态类接口的对象

当环境类执行某个接口的方法时，去调用真实状态类的实现方法

当环境类修改状态时，修改环境类的真实状态对象