您现在的位置是：首页 >技术教程 >【软考七】面向对象技术--UML、设计模式（分数重，刷题刷题）网站首页技术教程

建议UML和设计模式去听听课，内容多，还需要记。这一部分内容较多，下半年的考生可以慢慢看，上半年的就去刷题吧。
该博客不适合学习UML和设计模式，只适合考试。要学的不要在这浪费时间，切记切记
在5月13号忽然发现时间已经不多了，博客就先这样，先去刷题了，以后会补回来。抱歉抱歉

一、面向对象基础

面向过程和面向对象

面向过程：就像人。
面向对象：就像会魔法的魔仙。

例子

比如：刷碗这个动作。
面向过程（人）：人将碗从桌子上拿到水池，拧开水龙头，用百洁布擦拭，倒入洗洁精，冲水，看到干净了就OK了
面向对象（魔仙）：用魔法棒控制，碗从桌子上飞到水池中，水龙头拧开，百洁布自动擦拭，洗洁精飞起倒入，碗感觉自己干净了就OK了。

其中包含的对象和对象的方法：
碗： 飞起、落地、检查自身状态
水龙头：关闭、打开
百洁布：擦拭
洗洁精：飞起、倾倒

开发人员调用碗、水龙头、百洁布、洗洁精的方法实现刷碗这个动作。

（一）基本概念

面向对象 = 对象+分类+继承+通过消息的通信

1、类

类是对象的抽象

（1） 类别

1. 实体类：实体类的对象表示现实世界中真实的实体
2. 接口类（边界类）：接口类的对象为用户提供一种与系统合作交互的方式，分为人和系统两种。
3. 控制类：控制活动流，充当协调者

2、对象

由对象名、属性和方法三个部分组成。
是类的实例，既包括数据（属性或状态或成员变量），也包括作用于数据的操作（行为或方法或函数或成员函数）

3、消息

对象间进行通信的一种构造 。当一个消息发送给某个对象时，包含要求对象去执行某些活动的信息。接收到信息的对象经过解释，然后予以响应。这种通信机制叫做消息传递

4、方法重载（也叫操作、行为、函数）

• 同一个方法名，参数名不同
• 同一个方法名，参数类型不同
• 同一个方法名，参数顺序不同

5、三大特征

封装、继承、多态

（1）封装

封装是一种信息隐藏技术，实现对象的使用者和生产者分离。
对象是封装数据和行为的整体

数据和行为可声明为private（私有）和public（共有），声明为private的方法或属性只能在当前类中定义的方法中被访问到。
关键字this可以用于区分同名的对象属性和局部变量名。

（2）继承

父类、超类、基类
子类、派生类
父类和子类共享数据和方法的机制。子类是父类的特例，一个父类可以有多个子类，父类已有的非私有化属性和方法在子类中不必定义，可直接使用，子类可有自己的属性和方法。同一个方法名可在子类中被重写（覆盖），也就相当于方法重载。
单重继承：子类只继承一个父类
多重继承：子类继承多个父类，可能造成子类中出现二义性的成员

（3）多态

收到消息时，对象要予以响应。不同对象收到同一消息可以完全产生不同的结果，这一现象称为多态，由继承机制来支持，实现细节由接收对象自行决定。动态绑定是实现多态的基础

Person gll = new Student();
编译：编译时gll类为Person
运行：运行时gll类为Student

多态的不同形式（考的多）

6、动态绑定、静态绑定

绑定是一个把过程调用和响应调用所需要执行的代码加以结合的过程。一般的程序设计语言中，编译时进行静态绑定，运行时进行动态绑定。一个给定的过程调用和代码的结合直到调用发生时才进行

（二）面向对象分析（按顺序的，背）–OOA

（三）面向对象设计 – OOD

目标：定义系统的构造蓝图。理解解决方案，实现系统

1、面向对象设计的原则 (常考，背)

2、面向对象设计的活动

（四）面向对象程序设计

程序设计语言相关，下午题中记录

（五）面向对象测试

（六）其他知识点

1. 静态方法只能访问同一类中的静态数据成员
2. 静态数据成员可被同一类中的所有方法访问
3. 同一类的对象共享静态数据成员的值。
4. 静态数据成员的值可修改
5. 面向对象技术中，对象拥有清晰的边界、良好的定义行为和可扩展性三个特性
6. 领域类模型包含属性、操作、关联

二、UML（上午题3~5分，下午题15分）

UML（统一建模语言），构造块包含事物、关系、图。事物是对模型中最具有代表性的成分的抽象；关系把事物结合在一起；图聚集了相关事物。

（一）事物

各结构事物的图形化

各行为事物的图形表示

包和注解的图形表示

（二）关系

依赖关系图示

关联关系、聚合关系、组合关系图示
两个类之间可以有多个由不同角色标识的关联。
关联的多重度（重复度）指：一个类的实例能够被另一个类的多少实例相关联。
关联关系可不标注多重度和角色，若为实线单向箭头，则表示是单向关联（类似依赖，但是比依赖的强度要强。人依赖于食物活着，但不是时时刻刻需要；鱼单向关联水，需要时时刻刻在水中）。
下面关联代表的意思是：一个雇主对应0个或多个雇员，一个雇员对应0个或一个雇主。

当两个类关联，A类的实例重复关联B类的实例时，衍生出一个属性，放在这两个类中都不妥时，就定义一个关联类。

泛化关系图示

实现关系图示

（三）图

图：一组元素的图形表示，大多数情况下把图画成顶点（代表事物）和弧（代表关系）的连通图。

1、图的分类

(1) 类图补充

类

(2) 对象图补充（下午没考过）

对象

(3) 用例图补充（下午题常考，加油）

（4）交互图介绍

用于对系统的动态方面进行建模。一张交互图表现的是一个交互，由一组对象和他们之间的关系组成，包含传递的消息。包含序列图、通信图、交互概览图和计时图。序列图是强调消息时间顺序的交互图；通信图是强调接收和发送消息的对象的结构组织的交互图。一般包含对象、链和消息。

（5）序列图（也叫顺序图）

（6）通信图（协作图）

路径这一特点未在图中表现出来

（7）状态图（常考）

由状态、活动、转换、事件组成，分别介绍
状态和活动

转换和事件

（8）活动图（不常考）

状态图：从一个状态到另一个状态
活动图：从一个活动到另一个活动

（9）构件图（不常考）

（10）部署图（不常考）

2、图总结

UML构造块组织结构图附件

附件地址

附件中是UML部分的全部结构图，本人使用的工具是 XMIND 。

三、设计模式

(一) 创建型模式设计

简单工厂模式（引入，便于后续，不在23种设计模式之内）

/**
 * 简单工厂模式。以在饺子馆买饺子为例
 */
// main方法
public class SimpleFactory {
    public static void main(String[] args) {
        Product A = Factory.createProduct("A");
        A.info();

        Product B = Factory.createProduct("B");
        B.info();

        Product C = Factory.createProduct("C");
        C.info();
    }
}

// 工厂类，可直接被外界访问。该类相当于饺子馆，type为客户需求的饺子馅
class Factory {
    public static Product createProduct(String type) {
        Product product = null;
        switch(type) {
            case "A":
              product = new ProductA();
              break;
            case "B":
                product = new ProductB();
                break;
            default:
                System.out.println("产品生产完成");
                break;
        }
        return product;
    }
}

// 抽象的产品类，不可被实例化，为父类。相当于饺子，但不知道是什么馅
abstract class Product {
    public abstract void info();
}

// 具体的产品类，为子类。相当于韭菜馅饺子，是一个确定的个体了
class ProductA extends Product {
    @Override
    public void info() {
        System.out.println("此为A产品");
    }
}

// 具体的产品类，为子类。相当于猪肉大葱馅饺子，是一个确定的个体了
class ProductB extends Product {
    @Override
    public void info() {
        System.out.println("此为B产品");
    }
}

1、类模式

（1） 工厂方法模式（一个工厂只能创建一类产品）

/**
 * 工厂方法模式。以手机零件生产工厂为例
 */
public class FactoryMethod {
    public static void main(String[] args) {
        Factory1A factory1A = new Factory1A();
        Product1 product1A = factory1A.createProduct();
        product1A.info();

        Factory1B factory1B = new Factory1B();
        Product1 product1B = factory1B.createProduct();
        product1B.info();
    }
}

/**
 * 工厂类
 */
// 工厂父类。相当于工厂的管理部门，只知道要生产零件
interface Factory1 {
    public Product1 createProduct();
}

// 工厂子类。相当于手机屏生产车间，明确知道自己的工作，且只做这份工作，不接受外来消息的影响
class Factory1A implements Factory1 {
    @Override
    public Product1 createProduct() {
     return new Product1A();
    }
}

// 工厂子类。相当于充电器生产车间，明确知道自己的工作，且只做这份工作，不接受外来消息的影响
class Factory1B implements Factory1 {
    @Override
    public Product1 createProduct() {
        return new Product1B();
    }
}

// 产品父类。相当于手机
interface Product1 {
    public void info();
}

// 产品子类，相当于手机屏，明确知道自己是什么零件
class Product1A implements Product1 {
    @Override
    public void info() {
        System.out.println("此为工厂方法的A产品");
    }
}

// 产品子类，相当于充电器，明确知道自己是什么零件
class Product1B implements Product1 {
    @Override
    public void info() {
        System.out.println("此为工厂方法的B产品");
    }
}

2、对象模式

（1） 抽象工厂模式（一个工厂只能创建多类产品）

/**
 * 抽象工厂模式
 */
public class AbstractFactory {
    public static void main(String[] args) {
        // 创建工厂子类A实例
        ConcreateFactoryA concreateFactoryA = new ConcreateFactoryA();
        AbstractProductA abstractProductA1 = concreateFactoryA.createAbstractProductA();
        abstractProductA1.info();
        AbstractProductB abstractProductB1 = concreateFactoryA.createAbstractProductB();
        abstractProductB1.info();
        // 创建工厂子类B实例
        ConcreateFactoryB concreateFactoryB = new ConcreateFactoryB();
        AbstractProductA abstractProductA2 = concreateFactoryB.createAbstractProductA();
        abstractProductA2.info();
        AbstractProductB abstractProductB2 = concreateFactoryB.createAbstractProductB();
        abstractProductB2.info();
    }
}

// 工厂父类
interface FactoryAbstract {
    public AbstractProductA createAbstractProductA();
    public AbstractProductB createAbstractProductB();
}

// 具体的工厂，工厂子类A，可生产两类产品，且这两类不相关
class ConcreateFactoryA implements FactoryAbstract {
    @Override
    public AbstractProductA createAbstractProductA() {
        return new ProductA1();
    }
    @Override
    public AbstractProductB createAbstractProductB() {
        return new ProductB1();
    }
}

// 具体的工厂，工厂子类B，可生产两类产品，且这两类不相关
class ConcreateFactoryB implements FactoryAbstract {
    @Override
    public AbstractProductA createAbstractProductA() {
        return new ProductA2();
    }
    @Override
    public AbstractProductB createAbstractProductB() {
        return new ProductB2();
    }
}

// 产品父类A
interface AbstractProductA {
    public void info();
}

// 产品父类A的子类
class ProductA1 implements AbstractProductA {
    @Override
    public void info() {
        System.out.println("此为ProductA1");
    }
}

// 产品父类A的子类
class ProductA2 implements AbstractProductA {
    @Override
    public void info() {
        System.out.println("此为ProductA2");
    }
}

// 产品父类B
interface AbstractProductB {
    public void info();
}

// 产品父类B的子类
class ProductB1 implements AbstractProductB {
    @Override
    public void info() {
        System.out.println("此为ProductB1");
    }
}

// 产品父类B的子类
class ProductB2 implements AbstractProductB {
    @Override
    public void info() {
        System.out.println("此为ProductB2");
    }
}

（2） 生成器模式

/**
 * 生成器模式。以卖手机为例，有各种套餐
 */
public class BuilderMode {
    public static void main(String[] args) {
        Director director = new Director();
        Builder1 builder1 = new Builder1();
        director.Construct(builder1);
        ProductBuilder product1 = builder1.getResult();
        product1.show();

        Builder2 builder2 = new Builder2();
        director.Construct(builder2);
        ProductBuilder product2 = builder2.getResult();
        product2.show();
    }
}

// 相当于客户，指定需要哪种套餐
class Director {
    public void Construct(Builder builder) {
        builder.BuildPart();
    }
}

// 生成器父类。相当于手机套餐配送前的装箱小组
abstract class Builder {
    public abstract void BuildPart();
    public abstract ProductBuilder getResult();
}

// 生成器子类。相当于装箱小组中的成员1
class Builder1 extends Builder {
    // 此时为还不知道套餐是什么的产品
    ProductBuilder product = new ProductBuilder();

    @Override
    public void BuildPart() {
        product.Add("手机");
        product.Add("充电头");
        product.Add("充电线");
    }

    @Override
    public ProductBuilder getResult() {
        return product;
    }
}

// 生成器子类。相当于装箱小组中的成员2
class Builder2 extends Builder {
    // 此时为还不知道套餐是什么的产品
    ProductBuilder product = new ProductBuilder();

    @Override
    public void BuildPart() {
        product.Add("手机");
        product.Add("手环");
        product.Add("耳机");
    }

    @Override
    public ProductBuilder getResult() {
        return product;
    }
}

// 产品。相当于手机产品，里面有套餐数组
class ProductBuilder {
    List<String> parts = new ArrayList<String>();  // 手机部件
    // 向套餐中添加配件
    public void Add(String part) {
        parts.add(part);
    }

    public void show() {
        System.out.println("产品包含：");
        for (String part:parts
             ) {
            System.out.println(part+",");
        }
        System.out.println("
");
    }
}

（3） 原型模式

/**
 * 原型模式
 */
public class PrototypeMode {
    public static void main(String[] args) {
        ProductPrototype product1 = new ProductPrototype(2023, 5.28);
        System.out.println(product1.getId()+"/"+product1.getPrice());

        ProductPrototype product2 = product1.Clone();
        System.out.println(product2.getId()+"/"+product2.getPrice());
    }
}

// 类原型父类
interface Prototype {
    public Object Clone();
}

// 类原型子类，意思是直接复制这个类创建的一个实例
class ProductPrototype implements Prototype {
    private  int id;
    private double price;

    // 构造函数
    public ProductPrototype() {}
    public ProductPrototype(int id,double price) {
        this.id = id;
        this.price = price;
    }

    public int getId() {
        return id;
    }
    public double getPrice() {
        return price;
    }

    @Override
    public ProductPrototype Clone() {
        ProductPrototype productPrototype = new ProductPrototype();
        productPrototype.id = this.id;
        productPrototype.price = this.price;
        return productPrototype;
    }
}

（4） 单例模式

/**
 * 单例模式
 */
public class SingletonPattern {
    public static void main(String[] args) {
//        Singleton singleton1 = new Singleton();  // 这样会报错
        // 下面的其实都是一个实例
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        Singleton instance3 = Singleton.getInstance();
        System.out.println(instance1.getNumber()+"/"+instance2.getNumber()+"/"+instance3.getNumber());

        instance1.setNumber(22222);
        System.out.println(instance1.getNumber()+"/"+instance2.getNumber()+"/"+instance3.getNumber());
    }
}

class Singleton {
    private int number = 2023;
    public void setNumber(int number) {
        this.number = number;
    }
    public int getNumber() {
        return number;
    }

    private Singleton(){}  // 设为私有，可保证只能通过全局访问点访问唯一的实例
    private static Singleton instance =  new Singleton();
    public static Singleton getInstance(){
        return instance;
    }
}

(二) 结构型模式设计

1、类模式

（1） 适配器模式（不常考，可不看）

2、对象模式

（1） 适配器模式（一般考对象适配器模式）

/**
 * 适配器模式。相当于转接头，此处以typec接口转USB接口为例
 */
public class AdapterPattern {
    public static void main(String[] args) {
        Target target = new Adapter();
        target.Request();
    }
}
// 最终需要的类。相当于USB口
class Target {
    public void Request() {
        System.out.println("我是目标类");
    }
}

// 适配转换的类。相当于转接头，披着羊皮的狼。我外表是目标类，实际内心是现有的不匹配的类
class Adapter extends Target {
    private Adaptee adaptee = new Adaptee();
    @Override
    public void Request() {
        adaptee.specificRequest();
    }
}

// 现有的类。与需要的类不同。相当于Typec接口
class Adaptee {
    public void specificRequest() {
        System.out.println("我是特殊的，需要转换一下的类");
    }
}

（2） 桥接模式

/**
 * 桥接模式。理解的意思就像是生产手机，可生产的机型可以有多种，手机的颜色可以有多种上色选择。
 * 任意一种机型可以上各种不同的颜色。就是将两个都可实现的方法任意组合起来
 */
public class BridgePattern {
    public static void main(String[] args) {
        Abstraction abstractionA1 = new AbstractionA();
        Abstraction abstractionA2 = new AbstractionA();
        Implementor implementor1 = new Implementor1();
        Implementor implementor2 = new Implementor2();
        
        abstractionA1.setName("iphone 12");
        abstractionA1.setImplementor(implementor1);
        abstractionA1.Operation();
        
        abstractionA2.setName("iphone 13");
        abstractionA2.setImplementor(implementor2);
        abstractionA2.Operation();
    }
}

// 抽象父类
abstract class Abstraction {
    private String name;
    protected  Implementor implementor;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }

    public void setImplementor(Implementor implementor) {
        this.implementor = implementor;
    }

    public abstract void Operation();
}

// 抽象子类。使用implementor类实现最终的操作
class AbstractionA extends Abstraction {
    @Override
    public void Operation() {
        implementor.OperationImp(this.getName());
    }
}

// 实现类接口父类
interface Implementor {
    public void OperationImp(String name);
}

// 实现类接口子类
class Implementor1 implements Implementor {

    @Override
    public void OperationImp(String name) {
        System.out.println(name+":涂为乳白色");
    }
}

// 实现类接口子类
class Implementor2 implements Implementor {

    @Override
    public void OperationImp(String name) {
        System.out.println(name+":涂为天蓝色");
    }
}

（3） 组合模式

/**
 * 组合模式，以树形结构展示部分-整体。此处以文件夹中包含文件、文件夹为例
 */
public class CompositePattern {
    public static void main(String[] args) {
        Component root = new Composite("root");
        Component folderA = new Composite("folderA");
        Component fileA = new Leaf("fileA");

        Component folderB = new Composite("folderB");
        Component fileB = new Leaf("fileB");

        Component fileC = new Leaf("fileC");
        Component fileD = new Leaf("fileD");
        
        root.Add(folderA);
        root.Add(fileA);
        root.Add(folderB);
        folderA.Add(fileB);
        folderA.Add(fileC);
        folderB.Add(fileD);
        print(root);

    }

    // 该方法可打印某节点的所有儿子、孙子、重孙....后代们
    static void print(Component com) {
        com.printName();

        List<Component> childrenList = com.getChildren();
        if(childrenList == null) return;
        for (Component children: childrenList
             ) {
            // 递归
            print(children);
        }
    }
}

// 父类
abstract class  Component {
    protected String name;

    // 可打印当前结点的名称
    public void printName() {
        System.out.println(name);
    };

    public abstract boolean Add(Component com);  // 此处的参数设为父类，可保证叶子结点和非叶子节点中都可正常使用
    // 对应意图中的 “Composite使得用户对单个对象和组合对象的使用具有一致性”
    public abstract boolean Remove(Component com);

    public abstract List<Component> getChildren();
}

// 子类叶子结点。相当于文件，文件中不可再有文件或文件夹
class Leaf extends Component {
    public Leaf(String name) {
        this.name = name;
    }

    // 叶子结点不能有儿子了，所以直接在添加子节点的时候返回了false
    @Override
    public boolean Add(Component com) {
        return false;
    }

    @Override
    public boolean Remove(Component com) {
        return false;
    }

    @Override
    public List<Component> getChildren() {
        return null;
    }
}

// 子类可有子节点的节点。相当于文件夹，文件夹中还可添加文件或者文件夹
class Composite extends Component {
    // 因为有多个儿子，所以此处用一个list来保存所有的儿子.
    // 此处使用Component，是与上面方法的定义呼应的
    List<Component> childrenList = new ArrayList<Component>();

    public Composite(String name) {
        this.name = name;
    }

    @Override
    public boolean Add(Component com) {
        return childrenList.add(com);
    }

    @Override
    public boolean Remove(Component com) {
        return childrenList.remove(com);
    }

    @Override
    public List<Component> getChildren() {
        return childrenList;
    }
}

（4） 装饰器模式

/**
 * 装饰器模式。在已有的基础上给你增加工作量
 */
public class DecoratorPattern {
    public static void main(String[] args) {
        ComponentDecorator you = new ConcreteComponent("老黄牛");
        you.Operation();  // 本身已有的职责

        // 添加职责
        you = new DecoratorA(you);  // 因为大boss都是ComponentDecorator，所有直接用you来接收，这样操作的就都是老黄牛
        you.Operation();
    }
}

// 父类，大boss，其他类都是它的儿子或孙子
abstract class ComponentDecorator {
    protected String name;
    public abstract void Operation();
}

// 子类，作用是保存已有的职责
class ConcreteComponent extends ComponentDecorator {
    public ConcreteComponent(String name) {
        this.name = name;
    }

    @Override
    public void Operation() {
        System.out.println(name+"的职责：写一个列表页面");
    }
}

// 装饰器。其实就是为你添加工作量的领导，具体领导是谁还不确定
abstract class Decorator extends ComponentDecorator {
    protected ComponentDecorator componentDecorator;
}

// 装饰器子类。给你添加工作量的领导之一，可以有千千万万个这样的领导
class DecoratorA extends Decorator {
    public DecoratorA(ComponentDecorator componentDecorator) {
        this.componentDecorator = componentDecorator;
    }

    @Override
    public void Operation() {
        componentDecorator.Operation(); // 已有的职责
        System.out.println("为其添加职责 ");
    }
}

（5） 外观模式

/**
 * 外观模式。相当于一个大工厂，工厂的管理人员知道哪个部门生产什么部件
 */
public class FacadePattern {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.Method1();
        facade.Method2();
        facade.Method3();
    }
}

// 工厂对外的大门
class Facade {
    SubsystemA subsystemA;
    SubsystemB subsystemB;
    SubsystemC subsystemC;

    public Facade() {
        subsystemA = new SubsystemA();
        subsystemB = new SubsystemB();
        subsystemC = new SubsystemC();
    }

    public void Method1() {
        subsystemA.MethodA();
    }
    public void Method2() {
        subsystemB.MethodB();
    }
    public void Method3() {
        subsystemC.MethodC();
    }
}

// 子系统。工厂内部部门
class SubsystemA {
    public void MethodA() {
        System.out.println("子系统A的方法");
    }
}

// 子系统。工厂内部部门
class SubsystemB {
    public void MethodB() {
        System.out.println("子系统B的方法");
    }
}

// 子系统。工厂内部部门
class SubsystemC {
    public void MethodC() {
        System.out.println("子系统C的方法");
    }
}

（6） 享元模式

/**
 * 享元模式。已有多个白色石块了，但是客户要彩色的，无需再次生产，直接将石块喷上各种颜色的漆就可以。
 * 内部状态：石块大小、石块位置
 * 外部状态：石块颜色
 *
 * 此处以圆形包含各种颜色的为例
 */
public class FlyweightPattern {
    public static void main(String[] args) {
        FlyweightFactory flyweightFactory = new FlyweightFactory();

        Random random = new Random();
        String[] colors = {"red","green","blue","pink","black"};
        for (int i = 0; i < 20; i++) {
            int x = random.nextInt(colors.length);   // 区间是[0,5)
            Flyweight flyweight = flyweightFactory.getFlyweight(colors[x]);
            System.out.println("第"+i+"个圆");
            flyweight.draw(random.nextInt(2222), random.nextInt(3333) );
        }
    }
}

// 享元工厂。保存各种对象的仓库
class FlyweightFactory {
    private Map<String,Flyweight> map = new HashMap<String,Flyweight>();  // 用map来保存颜色以及圆本身

    // map里面已有了红色的圆之后，就不再生成了，直接返回；否则，生成保存到map中再返回
    public Flyweight getFlyweight(String key) {
        if(!map.containsKey(key)) {
            Flyweight concreteFlyweight = new ConcreteFlyweight(key);
            map.put(key,concreteFlyweight);
            System.out.println("创建了一个"+key+"色的圆");
        }
        return map.get(key);
    }
}

//享元父类
abstract class Flyweight {
    protected String color;
    public abstract void draw(int x,int y);  // 画圆，标明位置
}

// 享元子类。具体的享元
class ConcreteFlyweight extends Flyweight {
    public ConcreteFlyweight(String color){
        this.color = color;
    }

    @Override
    public void draw(int x, int y) {
        System.out.println("画一个颜色为"+color+"的圆，位置是x: "+x+" y: "+y);
    }
}

（7） 代理模式

/**
 * 代理模式。例如代购、律师。此处以代购为例
 */
public class ProxyPattern {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        Proxy proxy = new Proxy(realSubject);
        proxy.buy();
    }
}

interface Subject {
    public void buy();
}

class Proxy implements Subject {
    public RealSubject realSubject;

    public Proxy(RealSubject realSubject){
        this.realSubject = realSubject;
    }

    @Override
    public void buy() {
        System.out.println("找到商品");
        System.out.println("讨价还价");
        realSubject.buy();  // 实际的买主付钱
    }
}

class RealSubject implements Subject {
    @Override
    public void buy() {
        System.out.println("付款");
    }
}

(三) 行为模式设计

1、类模式

（1） 解释器模式

/**
 * 解释器模式。说实话，没听太懂，不理解什么情境下能用到。感觉作用就是做了个判断
 */
public class InterpreterPattern {
    public static void main(String[] args) {
        Context context = new Context();

        context.check("朝阳区的开发人员");
        context.check("昌平区的测试人员");
        context.check("东城区的闲散人员");
    }
}

class Context {
    private String[] regions = {"朝阳区","东城区","西城区","丰台区"};
    private String[] persons = {"开发人员","测试人员","行政人员","审计人员"};

    private NonterminalExpression nonterminalExpression;
    public Context() {
        TerminalExpression region = new TerminalExpression(regions);
        TerminalExpression person = new TerminalExpression(persons);
        nonterminalExpression = new NonterminalExpression(region,person);
    }

    public void check(String info) {
        boolean bool = nonterminalExpression.Interprete(info);
        if(bool) {
            System.out.println("识别成功");
        }else {
            System.out.println("识别失败");
        }
    }
}

interface Expression {
    public boolean Interprete(String info);
}


class NonterminalExpression implements Expression {
    private TerminalExpression region;
    private TerminalExpression person;

    public NonterminalExpression(TerminalExpression region,TerminalExpression person) {
        this.region = region;
        this.person = person;
    }

    @Override
    public boolean Interprete(String info) {
        String[] str = info.split("的");
        return region.Interprete(str[0]) && person.Interprete(str[1]);
    }
}

class TerminalExpression implements Expression {
    private Set<String> set = new HashSet<>();
    public TerminalExpression(String[] data) {
        for (String str:data
             ) {
            set.add(str);
        }
    }

    @Override
    public boolean Interprete(String info){
        return set.contains(info);
    }

}

（2） 模板方法模式

2、对象模式

（1） 责任链模式

/**
 * 责任链模式。类似审批流、也可以理解为连带责任。各处理对象间有条隐形的链。
 * 此处以请假审批流为例
 */
public class ChainOfResponsibilityPattern {
    public static void main(String[] args) {
        Handler concreteHandler1 = new ConcreteHandler1();
        Handler concreteHandler2 = new ConcreteHandler2();

        concreteHandler1.setNext(concreteHandler2);
        concreteHandler1.HandleRequest(8);
    }
}

// 处理类父类
abstract class Handler {
    protected Handler next;   // 我处理不了，要将这个请求转给next

    public void setNext(Handler next){
        this.next = next;
    }

    abstract public void HandleRequest(int request);
}

// 处理类子类。明确知道了谁处理了我的请求，我处理不了，就给ConcreteHandler2
// 可以理解成甩锅，这锅我背不了，甩给另一个。
class ConcreteHandler1 extends Handler{

    @Override
    public void HandleRequest(int request) {
        if(request <=7){
            System.out.println("ConcreteHandler1 审批通过");
        }else {
            if(next != null){
                next.HandleRequest(request);
            }else {
                System.out.println("无法审批");
            }
        }
    }
}

// 处理类子类。明确知道了谁处理了我的请求，我处理不了，就给ConcreteHandler2
class ConcreteHandler2 extends Handler {

    @Override
    public void HandleRequest(int request) {
        if(request < 20){
            System.out.println("ConcreteHandler2 审批通过");
        }else {
            if(next != null){
                next.HandleRequest(request);
            }else {
                System.out.println("无法审批");
            }
        }
    }
}

（2） 命令模式

/**
 * 命令模式。此处以遥控器发出命令控制电视机的开关为例
 */
public class CommandPattern {
    public static void main(String[] args) {
        Receiver receiver = new Receiver();

        Command commandOne = new CommandOne(receiver);
        Command commandTwo = new CommandTwo(receiver);

        Invoker invoker = new Invoker();
        // 开机操作
        invoker.setCommand(commandOne);
        invoker.call();
        // 关机操作
        invoker.setCommand(commandTwo);
        invoker.call();
    }
}

// 请求者。类似遥控器
class Invoker {
    private Command command;
    public void setCommand(Command command){
        this.command = command;
    }

    public void call() {
        command.Execute();
    }
}

// 命令接口
interface Command {
    public void Execute();
}


// 明确的命令1
class CommandOne implements Command {
    private Receiver recevier;

    public CommandOne(Receiver recevier){
        this.recevier = recevier;
    }

    @Override
    public void Execute() {
        recevier.open();
    }
}

// 明确的命令2
class  CommandTwo implements Command {
    private Receiver recevier;

    public CommandTwo(Receiver recevier){
        this.recevier = recevier;
    }

    @Override
    public void Execute() {
        recevier.close();
    }
}

// 命令的接收者。类似于电视机
class Receiver {
    public void open() {
        System.out.println("开机操作");
    }
    public void close() {
        System.out.println("关机操作");
    }
}

（3） 迭代器模式

（4） 解释器模式