an2866
an2866

《大话设计模式》读书笔记

一、简单工厂模式

1.面向对象三大基本特性：封装、继承、多态

封装：封装是指将现实世界中存在的某个客体的属性与行为绑定在一起，并放置在一个逻辑单元内。该逻辑单元负责将所描述的属性隐藏起来，外界对客体内部属性的所有访问只能通过提供的用户接口实现。这样做既可以实现对客体属性的保护作用，又可以提高软件系统的可维护性。只要用户接口不改变，任何封装体内部的改变都不会对软件系统的其他部分造成影响。

继承：继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。

多态：多态的基础是继承。多态下，子类重写父类的方法，实际使用过程中，用父类引用变量指向子类对象，此时父类引用调用的是子类重写后的方法，由于是父类引用变量，所有无法调用子类特有的方法。如果想调用子类特有的方法，必须强制类型转换到子类。

class Person {
    public void speak() {
        System.out.println("person");
    }
}

class Chinese extends Person {
    @Override
    public void speak() {
        System.out.println("Chinese");
    }

    public void chinaNo1() {
        System.out.println("chinaNo1");
    }
}

class English extends Person {
    @Override
    public void speak() {
        System.out.println("English");
    }
}

public class SimpleFactory {
    public static void main(String args[]) {
        Person person1 = new Chinese();
        Person person2 = new English();
        person1.speak();
        person2.speak();
        //person1.chinaNo1(); 多态下父类引用变量无法直接调用子类特有的方法
        Chinese chinese = (Chinese) person1;
        chinese.chinaNo1();
    }

}

2.简单工厂模式

import java.util.Scanner;

class Operation {
    private double numberOne = 0;
    private double numberTwo = 0;

    public double getNumberOne() {
        return numberOne;
    }

    public void setNumberOne(double numberOne) {
        this.numberOne = numberOne;
    }

    public double getNumberTwo() {
        return numberTwo;
    }

    public void setNumberTwo(double numberTwo) {
        this.numberTwo = numberTwo;
    }

    public double getResult() throws Exception {
        double result = 0;
        return result;
    }
}

class OperationAdd extends Operation {
    @Override
    public double getResult() {
        return getNumberOne() + getNumberTwo();
    }
}

class OperationSub extends Operation {
    @Override
    public double getResult() {
        return getNumberOne() - getNumberTwo();
    }
}

class OperationMul extends Operation {
    @Override
    public double getResult() {
        return getNumberOne() * getNumberTwo();
    }
}

class OperationDiv extends Operation {
    @Override
    public double getResult() throws Exception {
        if (getNumberTwo() == 0) {
            throw new Exception("除数不能为0");
        }
        return getNumberOne() / getNumberTwo();
    }
}

class OperationFactory {
    public static Operation createOperation(char operation) throws Exception {
        switch (operation) {
            case '+': {
                return new OperationAdd();
            }
            case '-': {
                return new OperationSub();
            }
            case '*': {
                return new OperationMul();
            }
            case '/': {
                return new OperationDiv();
            }
            default: {
                throw new Exception("不支持的计算类型");
            }
        }
    }
}

public class SimpleFactory {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        double number1 = sc.nextDouble();
        System.out.println(number1);
        char op = sc.next().charAt(0);
        System.out.println(op);
        double number2 = sc.nextDouble();
        System.out.println(number2);
        Operation operation = null;
        try {
            operation = OperationFactory.createOperation(op);
        } catch (Exception e) {
            e.printStackTrace();
        }
        operation.setNumberOne(number1);
        operation.setNumberTwo(number2);
        try {
            System.out.println(operation.getResult());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

 3.UML类图

《大话设计模式》读书笔记_第1张图片

关联（association）：当一个类“知道”另一个类时，可以用关联。企鹅“知道”气候的变化。
聚合（Aggregation）：表示一种弱的“拥有”关系，体现的是A对象可以包含B对象，但B对象不是A对象但一部分。一个雁群可以有多只大雁，满足聚合关系。
合成（Composition）：是一种强的“拥有”关系，体现了严格的部分和整体的关系，部分和整体的生命周期一样。
依赖（Dependency）：动物依赖氧气和水，它们是依赖关系。

 二、策略模式

面相对象的编程，并不是类越多越好，类的划分是为了封装，但分类但基础是抽象，具有相同属性和功能的抽象集合才是类。例如打折，打一折和打九折只是形式的不同，抽象分析出来，所有的打折方法都是一样的，所以打折算法应该是一个类。

策略模式（Strategy）：它定义类算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。

《大话设计模式》读书笔记_第2张图片

 

1.简单工厂模式与策略模式的结合

class CashContext {
    private CashSuper cashSuper;

    public CashContext(String type) {
        if (type.equals("无优惠")) {
            cashSuper = new CashNormal();
        } else if (type.equals("打八折")) {
            cashSuper = new CashRebate(0.8);
        } else if (type.equals("满300减20")) {
            cashSuper = new CashReturn(300, 20);
        }
    }

    public double getResult(double money) {
        return cashSuper.getResult(money);
    }
}

class CashSuper {
    public double getResult(double money) {
        double result = 0;
        return result;
    }
}

class CashRebate extends CashSuper {
    private double rebate;

    public CashRebate(double rebate) {
        this.rebate = rebate;
    }

    @Override
    public double getResult(double money) {
        return money * rebate;
    }
}

class CashNormal extends CashSuper {
    @Override
    public double getResult(double money) {
        return money;
    }
}

class CashReturn extends CashSuper {
    private double full;
    private double reduction;

    public CashReturn(double full, double reduction) {
        this.full = full;
        this.reduction = reduction;
    }

    @Override
    public double getResult(double money) {
        return money - (money >= full ? Math.floor(money / full) * reduction : 0);
    }
}

public class Strategy {
    public static void main(String args[]) {
        CashContext cashContext = new CashContext("无优惠");
        System.out.println(cashContext.getResult(1000));
        cashContext = new CashContext("打八折");
        System.out.println(cashContext.getResult(1000));
        cashContext = new CashContext("满300减20");
        System.out.println(cashContext.getResult(1000));
    }
}

上面的例子是简单工厂模式和策略模式的结合，从上一章可以看出，简单工厂模式需要让用户知道两个类（Operation和OperationFactory），而策略模式只需要认识一个类（CashContext）就可以类，耦合度降低。这里我们在客户端实例化的是CashContext的对象，调用的是CashContext的方法getResult，这是的收费算法彻底的与客户端分离。连算法的父类CashSuper都不让客户端认识了。

2.策略模式解析

策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合[DPE]。

策略模式的Strategy类（对应例子中的CashSuper）层次为Context定义类一系列的可供重用的算法或行为。继承有助于析取出这些算法中的公共功能[DP]。

策略模式的优点是简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试[DPE]。

当不同的行为堆砌在一个类中时，就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的Strategy类中，可以在使用这些行为的类中消除条件语句[DP]。

策略模式就是用来封装算法的，但在实践中，我们发现可以用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性[DPE]。

在基本的策略模式中，选择所用具体实现的职责由客户端对象承担，并转给策略模式的Context对象[DPE]。这本身没有解除客户端需要选择判断的压力，而策略模式与简单工厂模式结合后，选择具体实现的职责也可以由Context来承担，这就最大化地减轻了客户端的职责。

但它依然不够完美，因为在CashContext里还是用到来switch，也就是说，要增加一种算法，就必须更改switch，更好的办法是使用反射技术（注：在抽象工厂模式章节有对反射的讲解）。

三、单一职责原则

单一职责原则：就一个类而言，应该仅有一个引起它变化的原因[ASD]。

如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。这种耦合会导致脆弱的设计，当变化发生时，设计会遭受到意想不到的破坏[ASD]。

四、开放——封闭原则

开放——封闭原则：软件实体（类、模块、函数等等）应该可以扩展，但是不可修改[ASD]。

这个原则其实有两个特征，一个是说“对于扩展是开放的（Open for extension）”，另一个是说“对于更改是封闭的（Closed for modification）”[ASD]。

在我们最初编写代码时，假设变化不会发生。当变化发生时，我们就创建抽象来隔离以后发生的同类变化[ASD]。

面对需求，对程序的改动是通过增加新代码进行的，而不是更改现有的代码[ASD]。

开放——封闭原则是面相对象设计的核心所在。遵循这个原则可以带来面相对象技术所声称的巨大好处，也就是可维护、可扩展、可复用、灵活性好。开发人员应该仅对程序中呈现出频繁变化的那些部分作出抽象，然而，对于应用程序中的每个部分都进行抽象同样不是一个好主意。拒绝不成熟的抽象和抽象本身一样重要[ASD]。

五、依赖倒转原则

依赖倒转原则：

1.高层模块不应该依赖低层模块。两个都应该依赖抽象。

2.抽象不应该依赖细节。细节应该依赖抽象。[ASD]

不管高层模块还是低层模块，它们都依赖于抽象，具体一点就是接口或抽象类，只要接口是稳定的，那么任何一个的更改都不用担心其他收到影响，这就使得无论高层模块还是低层模块都可以很容易地被复用。

1.里氏代换原则

里氏代换原则（LSP）：子类型必须能够替换掉它们的父类型。[ASD]

一个软件实体如果使用的是一个父类的话，那么一定适用于其子类，而且它察觉不出父类对象和子类对象的区别。也就是说，在软件里面，把父类都替换成它的子类，程序的行为没有变化，简单的说，子类型必须能够替换掉它们的父类型[ASD]。

只有当子类可以替换掉父类，软件单位的功能不受到影响时，父类才能真正被复用，而子类也能够在父类的基础上增加新的行为。

由于子类型的可替换性才使得使用父类类型的模块在无需求改的情况下就可以扩展。

依赖倒转其实可以说是面相对象设计的标志，用哪种语言来编写程序并不重要，如果编写时考虑的都是如何针对抽象编程而不是针对细节编程，即程序中所有的依赖关系都是终止于抽象类或者接口，那就是面相对象的设计，反之那就是过程化的设计了[ASD]。

 六、装饰模式

装饰模式（Decorator）：动态地给一个对象添加一些额外地职责，就增加功能来说，装饰模式比生成子类更为灵活[DP]。

《大话设计模式》读书笔记_第3张图片

Component是定义一个对象接口，可以给这些对象动态地添加职责。ConcreteComponent是定义了一个具体的对象，也可以给这个对象添加一些职责。Decorator，装饰抽象类，继承了Component，从外类来扩展Component类的功能，但对于Component来说，是无需知道Decorator的存在的。至于ConcreteDecorator就是具体的装饰对象，起到给Component添加职责的功能[DPE]。

装饰模式是利用SetComponent来对对象进行包装的。这样每个装饰对象的实现就和如何使用这个对象分开来，每个装饰对象只关心自己的功能，不需要关心如何被添加到对象链当中[DPE]。

interface Output {
    String output();
}

class ConsoleOutput implements Output {
    private String input;

    public ConsoleOutput(String input) {
        this.input = input;
    }

    public String output() {
        return input;
    }
}

class FilterOutput implements Output {
    private Output component;

    public FilterOutput(Output output) {
        this.component = output;
    }

    public String output() {
        if (component != null) {
            return component.output();
        }
        return null;
    }
}

class LowCaseOutput extends FilterOutput {
    public LowCaseOutput(Output output) {
        super(output);
    }

    @Override
    public String output() {
        return super.output().toLowerCase();
    }
}

public class Decorator {
    public static void main(String args[]) {
        Output output = new LowCaseOutput(new ConsoleOutput("FlkJ:LKJ:LKjLKJ"));
        System.out.println(output.output());
    }
}

装饰模式是为已有功能动态添加更多功能的一种方式。

装饰模式把每个要装饰的功能放在单独的类中，并让这个类包装它所要装饰的对象，因此，当需要执行特殊行为时，客户代码就可以在运行时根据需要有选择地、按顺序地使用装饰功能包装对象类[DP]。

装饰模式的优点是把类中的装饰功能从类中搬移出去，这样可以简化原有的类。

有效地把类的核心职责和装饰功能区分开了。而且可以去除相关类中的重复的装饰逻辑。

七、代理模式

代理模式（Proxy）：为其他对象提供一种代理以控制对这个对象的访问[DP]。

《大话设计模式》读书笔记_第4张图片

//同城代打
interface SameCityProxyBeat {
    void BeatWithBrick();

    void BeatWithStick();

    void BeatWithDesk();
}

class Victim {
    private String name;

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

    public String getName() {
        return name;
    }
}

class Buyer implements SameCityProxyBeat {
    private Victim victim;

    public Buyer(Victim victim) {
        this.victim = victim;
    }

    public void BeatWithBrick() {
        System.out.println(String.format("用板砖打了%s一下", victim.getName()));
    }

    public void BeatWithStick() {
        System.out.println(String.format("用棍子打了%s一下", victim.getName()));
    }

    public void BeatWithDesk() {
        System.out.println(String.format("用凳子打了%s一下", victim.getName()));
    }
}

class Proxyer implements SameCityProxyBeat {
    private Buyer buyer;

    public Proxyer(Buyer buyer) {
        this.buyer = buyer;
    }

    public void BeatWithBrick() {
        buyer.BeatWithBrick();
    }

    public void BeatWithStick() {
        buyer.BeatWithStick();
    }

    public void BeatWithDesk() {
        buyer.BeatWithDesk();
    }
}

public class Proxy {
    public static void main(String args[]) {
        Proxyer proxyer = new Proxyer(new Buyer(new Victim("皮皮虾")));
        proxyer.BeatWithBrick();
        proxyer.BeatWithStick();
        proxyer.BeatWithDesk();
    }
}

 代理模式应用场景：

1.远程代理：也就是为一个对象在不同的地址空间提供局部代表。这样可以隐藏一个对象存在于不同地址空间的事实[DP]。

2.虚拟代理：根据需要创建开销很大的对象。通过它来存放实例化需要很长时间的真实对象[DP]。

3.安全代理：用来控制真实对象访问时的权限[DP]。

4.智能指针：当调用真实的对象时，代理处理另外一些事[DP]。

代理模式其实就是在访问对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。

 八、工厂方法模式

简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除类与具体产品的依赖。对于前面的例子来说，我们将操作符如'+'传给工厂，工厂返回响应的实例，但这样违背了开放——封闭原则。

工厂方法模式（Factory Method）：定义了一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类[DP]。

《大话设计模式》读书笔记_第5张图片《大话设计模式》读书笔记_第6张图片

 

 整个工厂和产品体系其实都没有修改的变化，而只是扩展的变化，这就完全符合类开放——封闭原则的精神。

interface IFactory{
    IOperation createOperation();
}

class IOperation{
    public double numberOne = 0;
    public double numberTwo = 0;
    public double getResult(){
        return 0;
    }
}

class AddOperationFactory implements IFactory{

    public IOperation createOperation() {
        return new AddOperation();
    }
}

class SubOperationFactory implements IFactory{

    public IOperation createOperation() {
        return new SubOperation();
    }
}

class AddOperation extends IOperation{

    public double getResult() {
        return numberOne + numberTwo;
    }
}

class SubOperation extends IOperation{

    public double getResult() {
        return numberOne - numberTwo;
    }
}

public class Factory {
    public static void main(String[] args){
        IFactory factory = new AddOperationFactory();
        IOperation addOperation1 = factory.createOperation();
        IOperation addOperation2 = factory.createOperation();
        addOperation1.numberOne = 1;
        addOperation1.numberTwo = 1;
        System.out.println(addOperation1.getResult());
    }
}

九、原型模式

原型模式（Prototype）：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象[DP]。

《大话设计模式》读书笔记_第7张图片

原型模式其实就是从一个对象再创建另外一个可定制的对象，而且不需知道任何创建的细节。

一般在初始化的信息不发生变化的情况下，克隆是最好的办法。这既隐藏类细节，又对性能是大大的提高。

不用重新初始化对象，而是动态地获得对象运行时的状态。

1.深拷贝与浅拷贝

浅拷贝：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都仍然指向原来的对象。

深拷贝：把要复制的对象所引用的对象都复制一遍。深拷贝把引用对象的变量指向复制过的新对象，而不是原有的被引用的对象。

class WorkExperience implements Cloneable {

    private String workDate;
    private String company;

    public String getWorkDate() {
        return workDate;
    }

    public void setWorkDate(String workDate) {
        this.workDate = workDate;
    }

    public String getCompany() {
        return company;
    }

    public void setCompany(String company) {
        this.company = company;
    }

    @Override
    public String toString() {
        return "WorkExperience{" +
                "workDate='" + workDate + '\'' +
                ", company='" + company + '\'' +
                '}';
    }

    @Override
    protected Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

class Resume implements Cloneable {

    private String name;
    private String sex;
    private String age;
    private WorkExperience workExperience;

    public void setPersonalInfo(String sex, String age){
        this.sex = sex;
        this.age = age;
    }

    public void setWorkExperience(String workDate, String company) {
        this.workExperience.setWorkDate(workDate);
        this.workExperience.setCompany(company);
    }

    public Resume() {
    }

    public Resume(String name) {
        this.name = name;
        this.workExperience = new WorkExperience();
    }

    @Override
    public String toString() {
        return "Resume{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age='" + age + '\'' +
                ", workExperience=" + workExperience +
                '}';
    }

    @Override
    protected Object clone() {
        Resume resume = new Resume();
        resume.name = this.name;
        resume.sex = this.sex;
        resume.age = this.age;
        resume.workExperience = (WorkExperience) this.workExperience.clone();
        return resume;
    }
}

public class Prototype {
    public static void main(String[] args){
        Resume resume = new Resume("小明");
        resume.setPersonalInfo("男", "12");
        resume.setWorkExperience("2019-03-21", "字节跳动");

        Resume resume1 = (Resume) resume.clone();
        resume1.setPersonalInfo("女", "13");
        resume1.setWorkExperience("2018-08-08", "网易游戏");

        System.out.println(resume);
        System.out.println(resume1);
    }
}

 十、模版方法模式

模版方法模式：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模版方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

《大话设计模式》读书笔记_第8张图片

模版方法模式用到了继承，父类成为子类的模版，所有重复的代码都应该要上升到父类去，而不是让每个子类都去重复。

当我们要完成在某一细节层次一致的一个过程或一系列步骤，但其个别步骤在更详细但层次上的实现可能不同时，我们通常考虑用模版方法模式来处理。

模版方法模式是通过把不变形为搬移到超类，去除子类中的重复代码来体现它的优势。

模版方法模式就是提供来一个很好的代码复用平台。

当不变的和可变的行为在方法的子类实现中混合在一起的时候，不变的行为就会在子类中重复出现。我们通过模版方法模式把这些行为搬移到单一的地方，这样就帮助子类摆脱重复的不变行为的纠缠。

abstract class Story {
    public abstract String getNameOne();

    public abstract String getNameTwo();

    public abstract String getPostion();

    public abstract String getTalk();

    public void tellStory() {
        System.out.println(String.format("有一天，%s在%s对%s说：%s", getNameOne(), getPostion(), getNameTwo(), getTalk()));
    }
}

class HappyStory extends Story{
    @Override
    public String getNameOne() {
        return "小明";
    }

    @Override
    public String getNameTwo() {
        return "小芳";
    }

    @Override
    public String getPostion() {
        return "学校";
    }

    @Override
    public String getTalk() {
        return "我喜欢你";
    }
}

class SadStory extends Story{
    @Override
    public String getNameOne() {
        return "小芳";
    }

    @Override
    public String getNameTwo() {
        return "小明";
    }

    @Override
    public String getPostion() {
        return "家门前";
    }

    @Override
    public String getTalk() {
        return "分手吧！";
    }
}

public class Template {
    public static void main(String[] args){
        Story story = new HappyStory();
        story.tellStory();
        story = new SadStory();
        story.tellStory();
    }
}

十一、迪米特法则

迪米特法则（LoD，也叫最少知识原则[J&DP]）：如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用。如果其中一个类需要调用另一个类的某一个方法对话，可以通过第三者转发这个调用[J&DP]。

迪米特法则首先强调对前提是在类对结构设计上，每一个类都应当尽量降低成员对访问权限[J&DP]，也就是说，一个类包装好自己对private状态，不需要让别的类知道的字段或行为就不要公开。

迪米特法则其根本思想，是强调了类之间的松耦合。

类之间的耦合越弱，越有利于复用，一个处在若耦合的类被修改，不会对有关系对类造成波及。

十二、外观模式

外观模式（Facade）：为子系统中对一组接口提供一个一致对界面，此模式定义类一个高层接口，这个接口使得这个子系统更加容易使用[DP]。

《大话设计模式》读书笔记_第9张图片

外观模式在什么时候使用最好呢？

这要分三个阶段来说，首先，在设计模式初期阶段，应该要有意识对将不同的两个层分离，比如经典对三层架构，就需要考虑在数据访问层和业务逻辑层、业务逻辑层和表示层的层与层之间建立外观Facade，这样可以为复杂对子系统提供一个简单对接口，使得耦合大大降低。其次，在开发阶段，子系统往往因为不断的重构演化而变得越来越复杂，大多数对模式使用时也都会产生很多很小对类，这本是好事，但也给外部调用他们的用户程序带来类使用上的困难，增加外观Facade可以提供一个简单的接口，减少它们之间的依赖。第三，在维护一个遗留的大型系统时，可能这个系统已经非常难以维护和扩展了，但因为它包含非常重要的功能，新的需求开发必须要依赖于它。此时用外观模式Facade也是非常合适的。你可以为新系统开发一个外观Facade类，来提供设计粗糙或者高度复杂的遗留代码的比较清晰简单的接口，让新系统与Facade对象交互，Facade与遗留代码交互所有复杂的工作[R2P]。

class SubSystemOne{
    public void methodOne(){
        System.out.println("methodOne");
    }
}
class SubSystemTwo{
    public void methodTwo(){
        System.out.println("SubsystemTwo");
    }
}
class SubSystemThree{
    public void methodThree(){
        System.out.println("methodThree");
    }
}
class SubSystemFour{
    public void methodFour(){
        System.out.println("methodFour");
    }
}
public class Facade {
    private SubSystemOne subSystemOne;
    private SubSystemTwo subSystemTwo;
    private SubSystemThree subSystemThree;
    private SubSystemFour subSystemFour;

    public Facade(){
        this.subSystemOne = new SubSystemOne();
        this.subSystemTwo = new SubSystemTwo();
        this.subSystemThree = new SubSystemThree();
        this.subSystemFour = new SubSystemFour();
    }

    public void MethodA(){
        subSystemOne.methodOne();
        subSystemThree.methodThree();
        subSystemTwo.methodTwo();
    }

    public void MethodB(){
        subSystemThree.methodThree();
        subSystemFour.methodFour();
    }

    public static void main(String[] args){
        Facade facade = new Facade();
        facade.MethodA();
        facade.MethodB();
    }
}

十三、建造者模式

建造者模式（Builder）：将一个复杂对象的构建与它的表示分离，使得同样的构造过程可以创建不同的表示[DP]。

《大话设计模式》读书笔记_第10张图片

Builder：是为创建一个Product对象的各个部件指定的抽象接口。

ConcreteBuilder：具体建造者，实现Builder接口，构造和装配各个部件。

Product：具体的产品角色。

Director：构建一个使用Builder接口的对象。

建造者模式使用时机：主要是用于创建一些复杂的对象，这些对象内部构建间的建造顺序通常是稳定的，但对象内部的构建通常面临着复杂的变化。

建造者模式的好处就是使得建造代码与表示代码分离，由于建造者隐藏了该产品是如何组装的，所以若需要改变一个产品的内部表示，只需要再定义一个具体的建造者就可以了。

import java.util.LinkedList;
import java.util.List;

class Product{
    List parts = new LinkedList();

    public void add(String part){
        parts.add(part);
    }

    public void show(){
        System.out.println(parts.toString());
    }
}
interface IBuilder{
    void buildPartOne();
    void buildPartTwo();
    Product getResult();
}
class ConcreteBuilderOne implements IBuilder{
    private Product product = new Product();

    public void buildPartOne() {
        product.add("ConcreteBuilderOne partOne");
    }

    public void buildPartTwo() {
        product.add("ConcreteBuilderOne partTwo");
    }

    public Product getResult() {
        return product;
    }
}
class ConcreteBuilderTwo implements IBuilder{
    private Product product = new Product();

    public void buildPartOne() {
        product.add("ConcreteBuilderTwo partOne");
    }

    public void buildPartTwo() {
        product.add("ConcreteBuilderTwo partTwo");
    }

    public Product getResult() {
        return product;
    }
}
class Director{

    public void createProduct(IBuilder builder){
        builder.buildPartOne();
        builder.buildPartTwo();
    }
}
public class Builder {
    public static void main(String[] args){
        Director director = new Director();
        IBuilder builder1 = new ConcreteBuilderOne();
        IBuilder builder2 = new ConcreteBuilderTwo();
        director.createProduct(builder1);
        director.createProduct(builder2);
        Product p1 = builder1.getResult();
        Product p2 = builder2.getResult();
        p1.show();
        p2.show();
    }
}

建造者模式是在当创建复杂对象当算法应该独立于该对象当组成部分以及它们当装配方式时适用当模式。

十四、观察者模式

观察者模式：又叫做发布——订阅（Publish/Subscribe）模式，定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己[DP]。

《大话设计模式》读书笔记_第11张图片

import java.util.LinkedList;
import java.util.List;

//通知者接口
interface ISubject {

    abstract void attach(IObserver observer);

    abstract void detach(IObserver observer);

    abstract void Notify();
}

class ConcreteSubject implements ISubject {
    private List observers = new LinkedList();
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public void attach(IObserver observer) {
        observers.add(observer);
    }

    public void detach(IObserver observer) {
        observers.remove(observer);
    }

    public void Notify() {
        for (IObserver observer : observers) {
            observer.update();
        }
    }
}

interface IObserver {
    void update();
}

class ConcreteObserver implements IObserver {
    private ConcreteSubject subject;
    private String name;
    private String message;

    public ConcreteObserver(ConcreteSubject subject, String name) {
        this.subject = subject;
        this.name = name;
    }

    public void update() {
        this.message = subject.getMessage();
        System.out.println(name + ":" + message);
    }
}

public class Observer {
    public static void main(String[] args){
        ConcreteSubject subject = new ConcreteSubject();
        IObserver observer1 = new ConcreteObserver(subject, "小明");
        IObserver observer2 = new ConcreteObserver(subject, "小红");
        subject.attach(observer1);
        subject.attach(observer2);
        subject.setMessage("老师来了");
        //subject.detach(observer1);
        subject.Notify();
    }
}

观察者模式动机：将一个系统分割成一系列相互协作的类有一个很不好的副作用，那就是需要维护相关对象间的一致性。我们不希望为了维持一致性而使各类紧密耦合，这样会给维护、扩展和重用都带来不便[DP]。

使用时机：当一个对象的改变需要同时改变其他对象的时候。

而且它不知道具体有多少对象有待改变时，应该考虑使用观察者模式。

一个抽象模型有两个方面，其中一个方面依赖于另一方面，这时使用观察者模式可以将这两者封装在独立的对象中使它们各自独立地改变和复用。

总的来说，观察者模式所做的工作其实就是在解除耦合。让耦合的双方都依赖于抽象，而不是依赖于具体。从而使得各自的变化都不会影响另一边的变化。

1.观察者模式的不足

不足：“抽象通知者”依赖“抽象观察者”，也就是说，万一没有类抽象观察者这样的接口，通知的功能就完不成了。

用委托进行改造：

委托delegate在C#中属于基本特性，在Java中没有委托，但可以用反射实现观察者模式的委托。

十五、抽象工厂模式

抽象工厂模式（Abstract Factory）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类[DP]。

《大话设计模式》读书笔记_第12张图片

好处：

1.易于交换产品系列，由于具体工厂类，在一个应用中只需要在初始化的时候出现一次，这就使得改变一个应用的具体工厂变得非常容易，他只需要改变具体工厂即可使用不同的产品配置。

2.它让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操作实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户代码中。

缺点：新增功能要增加的类太多

1.用简单工厂来改进抽象工厂

《大话设计模式》读书笔记_第13张图片

2.用反射+抽象工厂的数据访问程序

由于简单工厂方法是在工厂中添加switch语句，导致如果要新增一个种类就必须在switch中增加一个case，不利于维护，因此采用反射来解决。

class User {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class Production {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

interface IUser {
    void insert();

    void getUser();
}

interface IProduction {
    void insert(Production production);

    Production getProduction();
}

class SQLServerUser implements IUser {
    public void insert() {
        System.out.println("SqlserverUser 插入记录");
    }

    public void getUser() {
        System.out.println("SqlserverUser 查询记录");
    }
}

class AccessUser implements IUser {
    public void insert() {
        System.out.println("AccessUser 插入记录");
    }

    public void getUser() {
        System.out.println("AccessUser 查询记录");
    }
}

class SimpleFactory1 {
//    private static final String db = "SQLServer";
    private static final String db = "Access";

    IUser createUser() {
        try {
            Class clazz = Class.forName(db + "User");
            return (IUser) clazz.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}

public class AbstractFactory {
    public static void main(String[] args) {
        SimpleFactory1 simpleFactory = new SimpleFactory1();
        IUser user = simpleFactory.createUser();
        user.insert();
        user.getUser();
    }
}

3.用反射+配置文件实现数据访问程序

由于配置文件不是重点，这里就不讨论了，但为了保证原书的完整性，还是将其列了出来。

十六、状态模式

状态模式（State）：当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类[DP]。

状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类当中，可以把复杂的判断逻辑简化。

《大话设计模式》读书笔记_第14张图片

好处：将与特定状态相关的行为局部化，并且将不同状态的行为分割开来。

将特定的状态相关的行为都放入一个对象中，由于所有与状态相关的代码都存在于某一个ConcreteState中，所以通过定义新的子类可以很容易地增加新的状态和转换[DP]。

消除庞大的条件分支语句。

状态模式通过把各种状态转移逻辑分布到State的子类之间，来减少相互间的依赖。

何时使用状态模式：当一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为，就可以考虑使用状态模式。

class Work{
    private IState state;
    private int hour;
    private boolean finish;

    public IState getState() {
        return state;
    }

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

    public int getHour() {
        return hour;
    }

    public void setHour(int hour) {
        this.hour = hour;
    }

    public boolean getFinish() {
        return finish;
    }

    public void setFinish(boolean finish) {
        this.finish = finish;
    }

    public void writeProgram(){
        state.writeProgram(this);
    }
}
interface IState{
    void writeProgram(Work work);
}
class ForenoonState implements IState{
    public void writeProgram(Work work) {
        if(work.getHour()<12) {
            System.out.println(work.getHour() + " 早晨精力充沛");
        }else{
            work.setState(new AfternoonState());
            work.writeProgram();
        }
    }
}
class AfternoonState implements IState{
    public void writeProgram(Work work) {
        if(work.getHour()<18){
            System.out.println(work.getHour()+" 在中午的困倦中慢慢苏醒");
        }else{
            work.setState(new EveningState());
            work.writeProgram();
        }
    }
}
class EveningState implements IState{
    public void writeProgram(Work work) {
        if(work.getFinish()){
            work.setState(new HomeState());
            work.writeProgram();
        }else{
            if(work.getHour()<21){
                System.out.println(work.getHour()+" 加班哦...");
            }else{
                work.setState(new SleepState());
                work.writeProgram();
            }
        }
    }
}
class SleepState implements IState{
    public void writeProgram(Work work) {
        System.out.println(work.getHour()+" 睡着了...");
    }
}
class HomeState implements IState{
    public void writeProgram(Work work) {
        System.out.println(work.getHour()+" 在家舒服的一批");
    }
}
public class State {
    public static void main(String[] args){
        Work work = new Work();
        work.setState(new ForenoonState());
        work.setHour(9);
        work.writeProgram();
        work.setHour(13);
        work.writeProgram();
        work.setHour(17);
//        work.setFinish(true);
        work.setHour(19);
        work.writeProgram();
        work.setHour(22);
        work.writeProgram();
    }
}

 十七、适配器模式

适配器模式（Adapter）：将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作[DP]。

系统的数据和行为都正确，但接口不符时，我们应该考虑用适配器，目的是使控制范围之外的一个原有对象与某个接口匹配。适配器模式主要应用于希望复用一些现存的类，但是接口又与复用环境要求不一致的情况。

《大话设计模式》读书笔记_第15张图片

1.何时使用？

使用一个已经存在的类，但如果它的接口，也就是它的方法和你的要求不相同时，就应该考虑用适配器模式。

两个类所做的事情相同或相似，但是具有不同的接口时要使用它。

在双方都不太容易修改的时候再使用适配器模式。

如果能事先预防接口不同的问题，不匹配问题就不会发生；在有小的接口不统一问题发生时，及时重构，问题不至于扩大；只有碰到无法改变原有设计和代码的情况时，才考虑适配。

十八、备忘录模式

备忘录模式（Memento）：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态[DP]。

《大话设计模式》读书笔记_第16张图片

 要保存的细节给封装在了Memento中了，哪一天要更改保存的细节也不用影响客户端了。

Memento模式比较适用于功能比较复杂的，但需要维护或记录属性历史的类，或者需要保存的属性只是众多属性中的一小部分时，Originator可以根据保存的Memento信息还原到前一状态。

使用备忘录可以把复杂的对象内部信息对其他的对象屏蔽起来[DP]。

当角色的状态改变的时候，有可能这个状态无效，这时候就可以使用暂时存储起来的备忘录将状态复原[DP]。

class Player {
    private int hp;
    private int mp;
    private int level;

    public Player() {
        hp = 100;
        mp = 100;
        level = 1;
    }

    public Memonto createMemonte() {
        return new Memonto(hp, mp, level);
    }

    public void setMemonto(Memonto memonto) {
        System.out.println("回档");
        this.hp = memonto.getHp();
        this.mp = memonto.getMp();
        this.level = memonto.getLevel();
    }

    public void toBeDie() {
        hp = 1;
        mp = 1;
        System.out.println("to be die");
    }

    public void show() {
        System.out.println(String.format("hp=%d, mp=%d, level=%d", hp, mp, level));
    }
}

public class Memonto {
    private int hp;
    private int mp;
    private int level;

    public int getHp() {
        return hp;
    }

    public void setHp(int hp) {
        this.hp = hp;
    }

    public int getMp() {
        return mp;
    }

    public void setMp(int mp) {
        this.mp = mp;
    }

    public int getLevel() {
        return level;
    }

    public void setLevel(int level) {
        this.level = level;
    }

    public Memonto(int hp, int mp, int level) {
        this.hp = hp;
        this.mp = mp;
        this.level = level;
    }

    public static void main(String[] args) {
        Player player = new Player();
        player.show();
        Caretaker caretaker = new Caretaker();
        caretaker.setMemonto(player.createMemonte());
        player.toBeDie();
        player.show();
        player.setMemonto(caretaker.getMemonto());
        player.show();
    }
}

class Caretaker {
    private Memonto memonto;

    public Memonto getMemonto() {
        return memonto;
    }

    public void setMemonto(Memonto memonto) {
        this.memonto = memonto;
    }
}

十九、组合模式

组合模式（Composite）:将对象组合成树形结构以表示“部分—整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性[DP]。

《大话设计模式》读书笔记_第17张图片

import java.util.LinkedList;
import java.util.List;

abstract class Company {
    String name;

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

    public abstract void add(Company company);

    public abstract void remove(Company company);

    public abstract void display(int depth);

    public abstract void lineOfDuty();
}

class ConcreteCompany extends Company {
    private List children = new LinkedList<>();

    public ConcreteCompany(String name) {
        super(name);
    }

    @Override
    public void add(Company company) {
        children.add(company);
    }

    @Override
    public void remove(Company company) {
        children.remove(company);
    }

    @Override
    public void display(int depth) {
        StringBuilder prefix = new StringBuilder();
        for (int i = 0; i < depth; i++) {
            prefix.append('-');
        }
        prefix.append(name);
        System.out.println(prefix);
        for (Company company : children) {
            company.display(depth + 2);
        }
    }

    @Override
    public void lineOfDuty() {
        System.out.println(String.format("%s 牛批", name));
        for (Company company : children) {
            company.lineOfDuty();
        }
    }
}

class HRDepartment extends Company {
    public HRDepartment(String name) {
        super(name);
    }

    @Override
    public void add(Company company) {

    }

    @Override
    public void remove(Company company) {

    }

    @Override
    public void display(int depth) {
        StringBuilder prefix = new StringBuilder();
        for (int i = 0; i < depth; i++) {
            prefix.append('-');
        }
        prefix.append(name);
        System.out.println(prefix);
    }

    @Override
    public void lineOfDuty() {
        System.out.println(String.format("%s 员工招聘培训管理", name));
    }
}

class FinanceDepartment extends Company {

    public FinanceDepartment(String name) {
        super(name);
    }

    @Override
    public void add(Company company) {

    }

    @Override
    public void remove(Company company) {

    }

    @Override
    public void display(int depth) {
        StringBuilder prefix = new StringBuilder();
        for (int i = 0; i < depth; i++) {
            prefix.append('-');
        }
        prefix.append(name);
        System.out.println(prefix);
    }

    @Override
    public void lineOfDuty() {
        System.out.println(String.format("%s 公司财务收支管理", name));
    }
}

public class Composite {
    public static void main(String[] args) {
        Company root = new ConcreteCompany("全球总部");
        Company rootHr = new HRDepartment("全球总部HR");
        root.add(rootHr);
        Company rootFa = new FinanceDepartment("全球总部财政");
        root.add(rootFa);
        Company com1 = new ConcreteCompany("中国总部");
        root.add(com1);
        Company com1Hr = new HRDepartment("中国总部HR");
        com1.add(com1Hr);
        Company com1Fa = new FinanceDepartment("中国总部财政");
        com1.add(com1Fa);
        Company com2 = new ConcreteCompany("杭州总部");
        com1.add(com2);
        Company com2Hr = new HRDepartment("杭州总部HR");
        com2.add(com2Hr);
        Company com2Fa = new FinanceDepartment("杭州总部财政");
        com2.add(com2Fa);

        root.display(2);
        root.lineOfDuty();
    }
}

 

1.何时使用组合模式？

当你发现需求中是体现部分与整体层次的结构时，以及你希望用户可以忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象时，就应该考虑用组合模式了。

2.好处

组合模式定义了包含人力资源部和财务部这些基本对象和分公司、办事处等组合对象的类层次结构。基本对象可以被组合成更复杂的组合对象，而这个组合对象又可以被组合，这样不断地递归下去，客户代码中，任何用到基本对象的地方都可以使用组合对象了。

用户不用关心到底是处理一个叶节点还是处理一个组合组建，也就用不着为定义组合而写一些选择判断语句了。

组合模式让客户可以一致地使用组合结构和单个对象。

二十、迭代器模式

迭代器模式（Iterator）：提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示[DP]。

当你需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，你就应该考虑用迭代器模式。

你需要对聚集有多种方式遍历时，可以考虑用迭代器模式。

为遍历不同的聚集结构提供如开始、下一个、是否结束、当前哪一项等统一的结构。

迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器来负责，这样既可以做到不暴露集合的内部结构，又可以让外部代码透明地访问集合内部的数据。

《大话设计模式》读书笔记_第18张图片

 

 

import java.util.LinkedList;
import java.util.List;

interface Iterator {
    public abstract Object first();

    public abstract Object next();

    public abstract boolean isDone();

    public abstract Object currentItem();
}

interface Aggregate {
    public abstract Iterator createIterator();
}

class ConcreteAggregate implements Aggregate {
    private List items = new LinkedList<>();

    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(this);
    }

    public Object get(int index) {
        return items.get(index);
    }

    public void add(Object obj) {
        items.add(obj);
    }

    public Integer size() {
        return items.size();
    }
}

class ConcreteIterator implements Iterator {
    private ConcreteAggregate aggregate;
    private int current = 0;

    public ConcreteIterator(ConcreteAggregate aggregate) {
        this.aggregate = aggregate;
    }

    @Override
    public Object first() {
        return aggregate.get(0);
    }

    @Override
    public Object next() {
        Object res = null;
        current++;
        if (current < aggregate.size()) {
            res = aggregate.get(current);
        }
        return res;
    }

    @Override
    public boolean isDone() {
        return current >= aggregate.size();
    }

    @Override
    public Object currentItem() {
        return aggregate.get(current);
    }
}

public class MyIterator {
    public static void main(String[] args) {
        ConcreteAggregate aggregate = new ConcreteAggregate();
        aggregate.add("c1");
        aggregate.add("c2");
        aggregate.add("c3");
        aggregate.add("c4");
        aggregate.add("c5");
        aggregate.add("c6");
        Iterator iterator = aggregate.createIterator();
        while (!iterator.isDone()) {
            System.out.println(iterator.currentItem());
            iterator.next();
        }
    }
} 
    
   
二十一、单例模式
 
   
单例模式（Singleton）：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
 
   
通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象。一个最好的办法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法[DP]。
 
   
《大话设计模式》读书笔记_第19张图片
 
   
单例模式因为Singleton类封装它的唯一实例，这样它可以严格地控制客户怎样访问它以及何时访问它。简单地说就是对唯一实例的受控访问。
 
   
1.单例模式VS实用类的静态方法
 
   
实用类不保存状态，仅提供一些静态方法或静态属性让你使用，而单例类是有状态的。实用类不能用于继承多态，而单例虽然实例唯一，却是可以有子类来继承。实用类只不过是一些方法属性的集合，而单例却是有着唯一的对象实例。
 
   
2.多线程时的单例
 
   
多线程中，调用GetInstance()方法，会有可能造成多个实例。
 
   
可以使用lock（Java可以使用synchronized）
 
   
 
    
public class Singleton {
    private static Singleton instance;
    private static final Object syncRoot = new Object();

    private Singleton() {
    }

    public static Singleton GetInstance() {
        synchronized (syncRoot) {
            if (instance == null) {
                instance = new Singleton();
            }
        }
        return instance;
    }
}
 
   
 
   
这样的话会导致每次调用Singleton实例都会进行一次加锁。使用双重锁定来避免。
 
   
3.双重锁定
 
   
 
    
public class Singleton {
    private static Singleton instance;
    private static final Object syncRoot = new Object();

    private Singleton() {
    }

    public static Singleton GetInstance() {
        if (instance == null) {
            synchronized (syncRoot) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
 
   
 
   
二十二、桥接模式
 
   
对象的继承关系时在编译时就定义好了，所以无法在运行时改变从父类继承的实现。子类的实现与它的父类有着非常紧密的依赖关系，以至于父类实现中的任何变化必然会导致子类发生变化。当你需要复用子类时，如果继承下来的实现不适合解决新的问题，则父类必须重写或被其他更合适的类替换。这种依赖关系限制了灵活性并最终限制了复用性[DP]。
 
   
桥接模式（Bridge）：将抽象部分与它的实现部分分离，使它们都可以独立地变化[DP]。
 
   
这里需要理解一下，什么叫抽象与它的实现分离，这并不是说，让抽象类与其派生类分离，因为这没有任何意义。实现指的是抽象类和它的派生类用来实现自己的对象[DPE]。
 
   
1.合成/聚合复用原则
 
   
合成/聚合复用原则（CARP）：尽量使用合成/聚合，尽量不要使用类继承[J&DP]。
 
   
聚合表示一种弱的“拥有”关系，体现的是A对象可以包含B对象，但B对象不是A对象的一部分。
 
   
合成则是一种强的“拥有”关系，体现了严格的部分和整体的关系，部分和整体的生命周期一样[DPE]。
 
   
好处是优先使用对象的合成/聚合将有助于你保持每个类被封装，并被集中在单个任务上。这样类和类继承层次会保持较小规模，并且不太可能增长为不可控制的庞然大物[DP]。
 
   
《大话设计模式》读书笔记_第20张图片
 
   
 
 
   
 《大话设计模式》读书笔记_第21张图片
 
   
《大话设计模式》读书笔记_第22张图片
 
   
《大话设计模式》读书笔记_第23张图片
 
   
实现系统可能有多角度分类，每一种分类都有可能变化，那么就把这种多角度分离出来让它们独立变化，减少它们之间的耦合。
 
   
 
    
abstract class Implementor {
    public abstract void operation();
}

class ImplementorA extends Implementor {

    @Override
    public void operation() {
        System.out.println("implement A");
    }
}

class ImplementorB extends Implementor {

    @Override
    public void operation() {
        System.out.println("implement B");
    }
}

abstract class Abstraction {

    protected Implementor implementor;

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

    public void operation() {
        implementor.operation();
    }
}

class RefinedAbstraction extends Abstraction {
    @Override
    public void operation() {
        implementor.operation();
    }
}

public class Bridge {
    public static void main(String[] args) {
        Abstraction abstraction = new RefinedAbstraction();
        Implementor implementorA = new ImplementorA();
        Implementor implementorB = new ImplementorB();
        abstraction.setImplementor(implementorA);
        abstraction.operation();
        abstraction.setImplementor(implementorB);
        abstraction.operation();
    }

}
 
   
 
   
 二十三、命令模式
 
   
命令模式（Command）：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作[DP]。
 
   
《大话设计模式》读书笔记_第24张图片
 
   
1.优点
 
   
1.它能较容易的设计一个命令队列。
 
   
2.在需要的情况下，可以较容易地将命令记入日志。
 
   
3.允许接受请求的一方决定是否要否决请求。
 
   
4.可以容易地实现对请求的撤销和重做。
 
   
5.由于加进新的具体命令类不影响其他的类，因此增加新的具体命令类很容易。
 
   
6.命令模式把请求一个操作的对象与知道怎么执行一个操作的对象分割开[DP]。
 
   
敏捷开发原则告诉我们，不要为代码添加基于猜测的、实际不需要的功能。如果不清楚一个系统是否需要命令模式，一般就不要着急去实现它，事实上，在需要的时候通过重构实现这个模式并不困难，只有在真正需要如撤销/恢复操作等功能时，把原来的代码重构为命令模式才有意义[R2P]。
 
   
 
    
import java.util.LinkedList;
import java.util.List;

class Receiver {
    public void actionOne() {
        System.out.println("执行请求1");
    }

    public void actionTwo() {
        System.out.println("执行请求2");
    }
}

class Invoker {
    List commands = new LinkedList<>();

    public void setCommand(Command command) {
        commands.add(command);
    }

    public void cancelCommand(Command command) {
        commands.remove(command);
    }

    public void Notify() {
        for (Command c : commands) {
            c.executeCommand();
        }
    }
}

public abstract class Command {
    protected Receiver receiver;

    public Command(Receiver receiver) {
        this.receiver = receiver;
    }

    public abstract void executeCommand();

    public static void main(String[] args) {
        Invoker invoker = new Invoker();
        Receiver receiver = new Receiver();
        Command commandOne = new CommandOne(receiver);
        Command commandTwo = new CommandTwo(receiver);
        invoker.setCommand(commandOne);
        invoker.setCommand(commandTwo);
        invoker.cancelCommand(commandOne);
        invoker.Notify();
    }
}

class CommandOne extends Command {
    public CommandOne(Receiver receiver) {
        super(receiver);
    }

    @Override
    public void executeCommand() {
        receiver.actionOne();
    }
}

class CommandTwo extends Command {
    public CommandTwo(Receiver receiver) {
        super(receiver);
    }

    @Override
    public void executeCommand() {
        receiver.actionTwo();
    }
}
 
   
 
   
 
 
   
二十四、职责链模式
 
   
职责链模式（Chain of Responsibility）：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
 
   
《大话设计模式》读书笔记_第25张图片
 
   
1.好处
 
   
当客户提交一个请求时，请求时沿链传递直至有一个ConcreteHandler对象负责处理它[DP]。
 
   
接收者和发送者都没有对方的明确信息，且链中的对象自己也并不知道链的结构。结果是职责链可简化对象的相互连接，它们仅需保持一个指向其后继者的引用，而不需保持它所有的候选接收者的引用[DP]。
 
   
随时地增加或修改处理一个请求的结构。增强了给对象指派职责的灵活性[DP]。
 
   
一个请求极有可能到了链的末端都得不到处理，或者因为没有正确配置而得不到处理。
 
   
 
    
class Request {
    private String type;
    private String content;

    public Request(String type, String content) {
        this.type = type;
        this.content = content;
    }

    public String getType() {
        return type;
    }

    public String getContent() {
        return content;
    }
}

abstract class Manager {
    private String name;
    protected Manager superior;

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

    public void setSuperior(Manager superior) {
        this.superior = superior;
    }

    public abstract void handleRequest(Request request);
}

class MainProgrammer extends Manager {

    public MainProgrammer(String name) {
        super(name);
    }

    @Override
    public void handleRequest(Request request) {
        if (request.getType().equals("请假")) {
            System.out.println(String.format("%s %s 同意了", request.getType(), request.getContent()));
        } else {
            System.out.println(String.format("作为一个主程，我不能处理%s", request.getType()));
            superior.handleRequest(request);
        }
    }
}

class CommonManager extends Manager {

    public CommonManager(String name) {
        super(name);
    }

    @Override
    public void handleRequest(Request request) {
        if (request.getType().equals("请长假")) {
            System.out.println(String.format("%s %s 同意了", request.getType(), request.getContent()));
        } else {
            System.out.println(String.format("作为一个经理，我不能处理%s", request.getType()));
            superior.handleRequest(request);
        }
    }
}

class Boss extends Manager {

    public Boss(String name) {
        super(name);
    }

    @Override
    public void handleRequest(Request request) {
        if (request.getType().equals("加薪")) {
            System.out.println(String.format("%s %s 同意了", request.getType(), request.getContent()));
        }
    }
}

public class ResponsibilityChain {
    public static void main(String[] args) {
        MainProgrammer mainProgrammer = new MainProgrammer("主程");
        CommonManager commonManager = new CommonManager("经理");
        Boss boss = new Boss("老板");
        Request request = new Request("加薪", "大哥想加薪");
        mainProgrammer.superior = commonManager;
        commonManager.superior = boss;
        mainProgrammer.handleRequest(request);
    }
}
 
   
 
   
二十五、中介者模式
 
   
中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互[DP]。
 
   
《大话设计模式》读书笔记_第26张图片
 
   
尽管将一个系统分割成许多对象通常可以增加其可复用性，但是对象间相互连接的激增又会降低其可复用性了。
 
   
大量的连接使得一个对象不可能在没有其他对象的支持下工作，系统表现为一个不可分割的整体，所以，对系统的行为进行任何较大的改动就十分困难了。
 
   
 
    
abstract class UnitedNation {
    public abstract void declare(String message, Country colleague);
}

abstract class Country {
    protected UnitedNation mediator;
    private String name;

    public Country(String name, UnitedNation mediator) {
        this.name = name;
        this.mediator = mediator;
    }

    public abstract void declare(String message);

    public abstract void Notify(String message);
}

class Chinese extends Country {

    public Chinese(String name, UnitedNation mediator) {
        super(name, mediator);
    }

    @Override
    public void declare(String message) {
        mediator.declare(message, this);
    }

    @Override
    public void Notify(String message) {
        System.out.println(message);
    }
}

class Japanese extends Country {

    public Japanese(String name, UnitedNation mediator) {
        super(name, mediator);
    }

    @Override
    public void declare(String message) {
        mediator.declare(message, this);
    }

    @Override
    public void Notify(String message) {
        System.out.println(message);
    }
}

class UnitedNationSecurityCouncil extends UnitedNation {
    private Country chinese;
    private Country japanese;

    public void setChinese(Country chinese) {
        this.chinese = chinese;
    }

    public void setJapanese(Country japanese) {
        this.japanese = japanese;
    }

    @Override
    public void declare(String message, Country colleague) {
        if (colleague == chinese) {
            japanese.Notify("小日本收到消息: " + message);
        } else if (colleague == japanese) {
            chinese.Notify("大中国收到消息: " + message);
        }
    }
}

public class Mediator {
    public static void main(String[] args) {
        UnitedNationSecurityCouncil unitedNation = new UnitedNationSecurityCouncil();
        Country chinese = new Chinese("Chinese", unitedNation);
        Country japanese = new Japanese("Japanese", unitedNation);
        unitedNation.setChinese(chinese);
        unitedNation.setJapanese(japanese);
        chinese.declare("钓鱼岛是中国的！");
        japanese.declare("是的，钓鱼岛是中国的！");
    }
}
 
   
 
   
中介者模式很容易在系统中应用，也很容易在系统中误用。当系统出现了“多对多”交互复杂的对象群时，不要急于使用中介者模式，而要先反思你的系统在设计上是不是合理。
 
   
1.优点
 
   
Mediator的出现减少了各个Colleague的耦合，使得可以独立地改变和复用各个Colleague类和Mediator。
 
   
由于把对象如何协作进行了抽象，将中介作为一个独立的概念并将其封装在一个对象中，这样关注的对象就从对象各自本身的行为转移到它们之间的交互上来，也就是站在一个更宏观的角度去看待系统。
 
   
2.缺点
 
   
由于ConcreteMediator控制了集中化，于是就把交互复杂性变为了中介者的复杂性，这就使得中介者会变得比任何一个ConcreteColleague都复杂。
 
   
中介者模式一般应用于一组对象以定义良好但是复杂的方式进行通信的场合，以及想定制一个分布在多个类中的行为，而又不想生成太多的子类的场合。
 
   
二十六、享元模式
 
   
享元模式（Flyweight）：运用共享技术有效地支持大量细粒度的对象。
 
   
《大话设计模式》读书笔记_第27张图片
 
   
享元模式可以避免大量非常相似类的开销。在程序设计中，有时需要生成大量细粒度的类实例来表示数据。如果能发现这些实例除了几个参数外基本上都是相同的，有时就能够大幅度地减少需要实例化的类的数量。如果能把哪些参数移到类实例的外面，在方法调用时将它们传递进来，就可以通过共享大幅度地减少单个实例的数目。
 
   
如果一个应用程序使用了大量的对象，而大量的这些对象造成了很大的存储开销时及应该考虑使用；
 
   
还有就是对象的大多数状态可以外部状态，如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象，此时可以考虑使用享元模式。
 
   
 
    
import java.util.Hashtable;

class User{
    private String name;

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

    public String getName() {
        return name;
    }
}
abstract class Website{
    protected String name;

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

    public abstract void use(User user);
}
class ConcreteWebsite extends Website{

    public ConcreteWebsite(String name) {
        super(name);
    }

    @Override
    public void use(User user) {
        System.out.println(String.format("%s %s", name, user.getName()));
    }
}
class WebsiteFactory{
    private Hashtable websites = new Hashtable();
    public Website getWebsite(String type){
        if(!websites.contains(type)){
            websites.put(type, new ConcreteWebsite(type));
        }
        return (Website) websites.get(type);
    }
}
public class Flyweight {
    public static void main(String[] args){
        WebsiteFactory factory = new WebsiteFactory();
        Website w1 = factory.getWebsite("blog");
        w1.use(new User("xiaoming"));
        Website w2 = factory.getWebsite("blog");
        w2.use(new User("xiaohong"));
        Website w3 = factory.getWebsite("notBlog");
        w3.use(new User("xiaolan"));
        Website w4 = factory.getWebsite("notBlog");
        w4.use(new User("xiaolv"));
    }
}
 
   
 
   
二十七、解释器模式
 
   
解释器模式（interpreter）：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子[DP]。
 
   
如果一种特定类型的问题发生的频率足够高，那么可能就值得将问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题[DP]。
 
   
《大话设计模式》读书笔记_第28张图片
 
   
二十八、访问者模式
 
   
访问者模式（Visitor）：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作[DP]。
 
   
《大话设计模式》读书笔记_第29张图片
 
   
访问者模式适用于数据结构相对稳定的系统。
 
   
他把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由地演化。
 
   
1.目的
 
   
访问者模式的目的是要把处理从数据结构分离出来。
 
   
如果系统有比较稳定的数据结构，又有易于变化的算法的话，使用访问者模式就是比较合适的，因为访问者模式使得算法操作的增加变得容易。
 
   
2.优点
 
   
访问者模式就是增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问者对象中。
 
   
3.缺点
 
   
增加新的数据结构变得困难了。
 
   
 
    
import java.util.LinkedList;
import java.util.List;

abstract class Person {
    public abstract void getConclusion(Action action);
}

class Man extends Person {

    @Override
    public void getConclusion(Action action) {
        action.getManConclusion(this);
    }
}

class Woman extends Person {

    @Override
    public void getConclusion(Action action) {
        action.getWomenConclusion(this);
    }
}

abstract class Action {
    public abstract void getManConclusion(Man man);

    public abstract void getWomenConclusion(Woman woman);
}

class Success extends Action {

    @Override
    public void getManConclusion(Man man) {
        System.out.println(String.format("%s成功时，背后一定有个伟大的女人", man.getClass().toString()));
    }

    @Override
    public void getWomenConclusion(Woman woman) {
        System.out.println(String.format("%s成功时，背后一定有个窝囊的男人", woman.getClass().toString()));
    }
}

class Marriage extends Action {

    @Override
    public void getManConclusion(Man man) {
        System.out.println(String.format("%s结婚后，有妻徒刑", man.getClass().toString()));
    }

    @Override
    public void getWomenConclusion(Woman woman) {
        System.out.println(String.format("%s结婚后，得到保障", woman.getClass().toString()));
    }
}

class ObjectStructure {
    private List elements = new LinkedList<>();

    public void add(Person person) {
        elements.add(person);
    }

    public void remove(Person person) {
        elements.remove(person);
    }

    public void display(Action action) {
        for (Person p : elements) {
            p.getConclusion(action);
        }
    }
}

public class Visitor {
    public static void main(String[] args) {
        ObjectStructure objectStructure = new ObjectStructure();
        Man man = new Man();
        Woman woman = new Woman();
        objectStructure.add(man);
        objectStructure.add(woman);
        objectStructure.display(new Success());
        objectStructure.display(new Marriage());
    }
}
 
   
 
   
 
 
   
  
转载于:https://www.cnblogs.com/yfzhou/p/9976001.html
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(《大话设计模式》读书笔记)

        

            

                
    
                    
  • 10月|愿你的青春不负梦想-读书笔记-01
                        Tracy的小书斋

                        
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
    
                    
    • 
                    
  • 《投行人生》读书笔记
                        小蘑菇的树洞

                        
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
    
                    
    • 
                    
  • 拥有断舍离的心态，过精简生活--《断舍离》读书笔记
                        爱吃丸子的小樱桃

                        
    不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
    
                    
    • 
                    
  • 读书笔记|《遇见孩子，遇见更好的自己》5
                        抹茶社长

                        
    为人父母意味着放弃自己的过去，不要对以往没有实现的心愿耿耿于怀，只有这样，孩子们才能做回自己。985909803.jpg孩子在与父母保持亲密的同时更需要独立，唯有这样，孩子才会成为孩子，父母才会成其为父母。有耐心的人生往往更幸福，给孩子留点余地。认识到养儿育女是对耐心的考验。为失败做好心理准备，教会孩子控制情绪。了解自己的底线，说到底线，有一点很重要，父母之所以发脾气，真正的原因往往在于他们自己，
    
                    
    • 
                    
  • 阅读《认知觉醒》读书笔记
                        就看看书

                        
    本周阅读了周岭的《认知觉醒开启自我改变的原动力》，启发较多，故做读书笔记一则，留待学习。全书共八章，讲述了大脑、潜意识、元认知、专注力、学习力、行动力、情绪力及成本最低的成长之道。具体描述了大脑、焦虑、耐心、模糊、感性、元认知、自控力、专注力、情绪专注、学习专注、匹配、深度、关联、体系、打卡、反馈、休息、清晰、傻瓜、行动、心智宽带、单一视角、游戏心态、早起、冥想、阅读、写作、运动等相关知识点。大脑
    
                    
    • 
                    
  • 《对生命说是》读书笔记2021-5-27
                        Diana_58d9

                        
    静心技巧——换个视角看待问题。尝试一下这个实验，1坐在椅子上，允许自己全身心的沉浸在你最爱的问题当中，你知道头脑热爱咀嚼他们，记录当你被卷入问题时的感受。2站起来有意识地离开那张椅子，想象你现在离开了你的问题。缓缓的围绕椅子走一圈，从不同的角度看看你的问题。在房间中找一个远离问题的空间，开始仔细深入的看看这个问题，他是真实的还是你制造出来的，同样的状况对于其他人来说会是问题吗？3反复体会作战问题里
    
                    
    • 
                    
  • 精力是碎片化时代的核心竞争力——精力管理介绍
                        爱写作的harry

                        
    《掌控：开启不疲惫、不焦虑的人生》读书笔记精力是碎片化时代的核心竞争力精力包括身、心两个层面，包括体力、专注力和意志力等多个维度。在信息爆炸、全球化竞争的时代，谁的体力充沛，专注力和意志力更强，谁获胜的机会就更大。而要做到这些，不做精力管理，一切都是空谈。另外，人的精力是有限的，表现会有高低起伏，所以需要管理，需要规划使用。怎样才算做到了精力管理精力管理是指主动掌握自己的体力、专注力和意志力，让自
    
                    
    • 
                    
  • 《经营者养成记》读书笔记分享
                        37度杉杉

                        
    何为经营者：变革的能力、赚钱的能力、建设团队的能力和追求理想的能力。读书笔记：（一）经营的含义1、所谓经营者，就是取得成果的人2、所谓经营者，是抱持使命感，将使命与成果相结合的人3、经营者必须是领导者，具备“建设团队的能力”4、经营者必须为使命而生的人，具备“追求理想的能力”（二）为什么必须培养经营者？一、变革的能力1、抱持高远的目标2、质疑常识，不受常识束缚3、树立高标准、不放松不放弃4、不畏风
    
                    
    • 
                    
  • 财富自由之路读书笔记2
                        Elaine_a963

                        
    继续财富自由读书笔记，今天就第十-二十三章进行归纳总结思考。这本书可以说是边学边练的武功秘籍。秘籍一：注意力。先从认知上刷新，先前谈到价值的重要性及单位价值提升的必要性。这里就引出了：“注意力”是在任何地方“挖掘”价值的最基本工具。那么，要自如运用注意力，就得练习。这里李老师给的无他，就是基本功训练扎实-坐享。秘籍二：活在未来。再一次颠覆认知，大众的思维是活在当下，而这里指引我们要活在未来。用正确
    
                    
    • 
                    
  • 【机器人建模和控制】读书笔记
                        Piccab0o
机器人
                        
    机器人建模和控制——马克·斯庞A.x10=x1∙x0x^0_1=x_1\bulletx_0x10=x1∙x0，其实就是：1）x1x_1x1轴向量在O0O_0O0系下的坐标2）在x0x_0x0轴上的投影3）坐标变换矩阵的R10R_1^0R10的第一个元素B.点p在o1x1y1z1o_1x_1y_1z_1o1x1y1z1系下的坐标p1p^1p1可以表示为：p=ux1+vy1+wz1p=ux_1+vy_
    
                    
    • 
                    
  • 读书笔记
                        语馨_f389

                        
    王聪丽坚持分享第1008天《亲密关系》期望就是通往地狱之路，因为期望会把接受和让人自由等充满爱意的感觉挡在门外。如果我不能接受别人现在的样子或不让他们自由地走自己的路，那么我就不是真的爱他们，我只是想从他们身上得到满足，与他们建立亲密关系的目的并不是为了爱，而是为了满足我小小的自私需求。我们可以觉察一下，在潜意识里，我对他有什么要求。让人惊讶的是，不开心的原因往往是沉睡多年的需求。不论是用暗示还是
    
                    
    • 
                    
  • 《掌控习惯》第二遍读书笔记
                        尼古拉斯咚

                        
    这本书反反复复看了两遍，每一遍对书中的内容都有不同的认识；以下是我的读书笔记和行动感悟读书的笔记和感悟好习惯+复利的力量是巨大的，这个可能是老生常谈的话题，但当我真正意识到，并重新开始审视自己日常生活中的习惯时才发现，坏习惯让我自己每天有不少时间浪费在了平庸上，随着时间的消逝我损失的也越来越多；生活中经常说“做时间的朋友”，“延迟满足”之类的话，但这些都有一个前提条件是只有当你真正是养成了好的习惯
    
                    
    • 
                    
  • 【0220读书笔记】面对压力怎么办
                        正本

                        
    人生每一天都是现场直播，所谓的人前显赫，不过是以往的极致积累付出所换来的。今天看到江南春谈到他过往的创业史，也并不是一帆风顺，顺风顺雨的。恰恰相反，在他创业的道路上，每一步都是如履薄冰，都是受宠若惊，竞争对手也会层出不穷，虎视眈眈向其发起挑战。001.量力而行与全力以赴在创业初期，我们的态度就应当是敢想敢做，全力以赴，因为不拼就不会有机会。当我们进入经营时期时，就要综合评判，尽自己所能去行事，万不
    
                    
    • 
                    
  • 2022-08-3读书笔记
                        静待花开20

                        
    ❤️据报道，有些人在面对及其重要甚至关系到自身前途和命运的大事要做出决定时，往往不是挖空心思、深思熟虑，而是根据自己的内心感觉做出抉择。❤️据研究，人从看到一个物体到对它做出反应，全过程仅有0.07秒的时间。在这个过程中，仅是神经和主观意识参与了吗？不是。潜意识也是参与其中的。故曰：“所以任物者心。”❤️研究发现，人们在学习一种知识、机能后，如能美美睡上一觉，则会对所学知识、机能的消化、掌握很有裨
    
                    
    • 
                    
  • 重读《新生-七年就是一辈子》- 26 不能容错的系统肯定是脆弱的
                        greenorchid

                        
    读后感想：我觉得自己的容错能力在学生，同事、朋友方面都还好，毕竟我很少和他们交流。但是，我对家人有时做的不好，容错能力反而较差，因此，有时会影响心情、注意力等。看了这篇文章，我能做到平心静气，不乱发脾气吗？我觉得有时能做到，很多时候可能还是做不到。读书笔记：今天的计算机科学里（包括它的“邻居”工程学里），都有一个重要的概念：容错（Faulttolerance）如果一个系统不能容错，那么它就是脆弱的
    
                    
    • 
                    
  • 《野草》复仇（其一） 读书笔记
                        女人知书香

                        
    “复仇”是鲁迅从早年到晚年，念兹在兹，一以贯之的恶一个思绪。几十年间在他心头萦绕不去，回环往复，多次谈及，成为作品和思想的重要主题之一。人的皮肤之厚，大概不到半分，鲜红的热血，就循着那后面，在比密密层层地爬在墙壁上的槐蚕更其密的血管里奔流，散出温热。于是各以这温热互相蛊惑，煽动，牵引，拼命希求偎倚，接吻，拥抱，以得生命的沉酣的大欢喜。【议论】如有人以丽人刺穿其皮肤，则有鲜血喷灌于杀戮者，这是动态的
    
                    
    • 
                    
  • 平平淡淡才是真——《菜根谭》读书笔记
                        云卷韵舒

                        
    图片图片士君子之涉世，于人不可轻为喜怒，喜怒轻，则心腹肝胆皆为人所窥。于物不可重为爱憎。爱憎重，则意气精神悉为物所制。士大夫君子在世上，对人不能轻易流露自己的喜怒哀乐，否则，所有的心思都会被人看破；对世上万物，也不要过分喜欢或厌恶，否则，就会玩物丧志。心体澄澈，常在明镜止水之中，则天下自无可厌之事；意气和平，常在丽日光风之内，则天下自无可恶之人。如果心如明镜，世上就没有心烦之事；心态平和，世上就没
    
                    
    • 
                    
  • 读《野草》有感
                        雨后晴天的女孩

                        
    这段时间有点懒，看过的书都没有做读书笔记，也就没有写读后感。但今晚看鲁迅的散文诗集《野草》时，却做了很多的笔记（主要是抄好词好句），突然就有了一种想写的冲动，虽然不知道要写点什么，但是随便写写也好。鲁迅的题辞中说到:野草，根本不深，花叶不美，却有一股顽强的生命力，任何人都阻挡不了它的生长。是啊，《野草》这本书虽不厚，却可以让人联想到一大堆的东西。阅读完之后，我想找几个词来形容一下，却怎么也想不到，
    
                    
    • 
                    
  • 2023-04-20
                        祝澜

                        
    祝澜1940天2023-4-20读书笔记：当家庭作业的责任明确地由孩子来承担时，才会有真正的学习。期待孩子们承担责任，而不是期待他们的父母比着他们承担责任，会造就有能力的年轻人。这并不是说父母们和老师不能帮助孩子们在家庭作业上取的成功。当着眼于帮助那些自我帮助的孩子时，每个人就都会赢。
    
                    
    • 
                    
  • 读书笔记
                        语馨_f389

                        
    王聪丽坚持分享第688天《非暴力沟通》真正高情商的人，会认为，发脾气是一种很好的沟通方式。我以前说过，所谓情商高，就是心中有他人；所谓情商高，不是虚伪，而是温暖。但这不是说，我们心中要没有自己，真正的情商高，是把自己当朋友，与自己和解，对自己也要温暖啊。为了幸福，必须把“别人怎么看我”这个问题放在一边。不带评论的观察是人类智慧的最高境界。学会说出自己的感受，而不是让别人猜。社会的节奏很快，人们都在
    
                    
    • 
                    
  • 《Android进阶之光》读书笔记
                        soleil雪寂
读书笔记#Android进阶之光
                        
    文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
    
                    
    • 
                    
  • 《人生海海》读书笔记
                        墨染馨香

                        
    天地英雄客，人间寸草心。“人生海海，潮落之后是潮起，你说那是消磨、笑柄、罪过，但那就是我的英雄主义。”各位读书的时候，有没有那么一句话，突然击中了你，让你的内心秩序瞬间变得兵荒马乱、溃不成军？书确是一部好书，只是读到最后全是眼泪。人间的美与丑、人性善与恶、人生痛与泪不停地交织纠缠，心绪随着情节跌宕起伏，却又夹杂着抑制不住的伤感，久久无法平静。“上校”传奇的一生，“爷爷”无奈的一生，“父亲”沉默的一
    
                    
    • 
                    
  • 决胜b端 | 读书笔记01-03章
                        一白学习录

                        
    C端与B端产品的区别：B端产品经理应具备的能力：1、逻辑思维与抽象能力：基于对业务的透彻理解，把现实世界的复杂场景抽象成结构性的系统和模块，将现实世界的抽象运转机制提炼成规律。2、技术知识储备3、复杂项目管理能力4、业务与经营管理知识B端产品经理的职业发展方向：1、产品设计：B端产品经理可以从某一个细分的产品方向做起，逐步延伸到一条或多条业务线的设计。在一个方向打牢根基，同时关注新的动态，抓住机遇
    
                    
    • 
                    
  • 《买书记历》读书笔记
                        歪嘴文说

                        
    《买书记历》本书以作者及他身边爱书人，准确说是“爱淘书”的人，来记叙他们当年的“淘书”经历。淘旧书，缺本，古书，罕书，有价值的。类似淘古董，转手可出高价或自我珍藏。因书过厚，后部多为跳看。对其中一段记事细看了，知道还有这么一种事。一个人打作者电话说有一批书来看一下，具体数量不好说有60吨吧，作者去看后爬书堆上，看有没有珍品，结果都是杂志。问价，要5千一顿，作者当即要走，说这书卖废品也不值1千1一吨
    
                    
    • 
                    
  • 精诚所至，金石为开 - 草稿
                        一禾粒子

                        
    今天阅读的章节是：精益求精几天来，虽说是在分享读书笔记，实则还是在继续梳理自己。每天的学习内容，读起来，对自己都有不小的触动。我时常在感叹猫叔的剽悍！为了让我们少走弯路，把自己一路走来的足迹，展示给我们；猫叔通过大量的阅读和践行，获得了成功，又将最精华的环节推荐给我们，他选定的读本，都是针对我们前行路上会遇到的迷茫，由于他的督导，成就了后来人，使得行者事半功倍。在学习的路上，我们需要得到这些具有针
    
                    
    • 
                    
  • 《一年顶十年》读书笔记Day2/17
                        设绘喵爱读书April

                        
    1-2状态如何成为一个更在状态的狠人？1.你想成为怎样的人如果你想成为强者，你现在就可以向强者靠近，并以强者的标准来要求自己，像强者一样活着。2.你应该远离哪些人总是打击你的人；见不得别人好的人；不思进取混日子的人；过度消耗你的人。3.我会常备哪些法宝读能带来力量的书；励志的电影；能带来力量的音乐；4.墙上挂字有什么用目所能及。稻盛和夫六项精进：付出不亚于任何人的努力；要谦虚，不要骄傲；要每天反省
    
                    
    • 
                    
  • 读书笔记《焦虑自救手册》
                        如雪般飞舞

                        
    各位好，今天我们讲一本非常实用的小书，叫作《焦虑自救手册》。昨天我见到一个朋友，他就有焦虑症。他说你们不是讲过两本关于焦虑症的书了吗，而且讲得都很好，为什么还要再讲一本？我说因为大部分读者的焦虑症还没有缓解，只要有读者的焦虑症还没有缓解，我们其实就应该继续地探索这方面的话题。为什么呢？因为这本书的作者告诉我们，对于焦虑的治疗来说，一个非常重要的原理就是不断地重复。就是我们要一而再、再而三的重复，直
    
                    
    • 
                    
  • 《把时间当朋友》读书笔记
                        小二王

                        
    1、养成不怕麻烦的性格，才可能拥有耐心。耐心则是在任何工作、学习上获得成功的前提。2、你比别人强一点根本没用，真正有用的是你比别人强很多很多。3、要提高自己的社交质量，最好将时间和精力更多的倾注在"把自己变得更加优秀"这件事情上——哪怕只在某一方面。4、想办法提前预知自己需要掌握哪些技能，再确定它们是自己可以通过练习真正熟练掌握的技能，而后制定长期计划，一点一点稳步执行。5、如果我们一整天都在做那
    
                    
    • 
                    
  • 整本书阅读评价设计
                        zhangshoulan

                        
    一、评价设计的理论背景（一）2022新课标关于课程评价的描述：“语文课程评价包括过程性评价和终结性评价。过程性评价贯串语文学习全过程，终结性评价包括学业水平考试和过程性评价的综合结果。”“应关注整本书阅读和跨学科学习的阶段性评价，采用读书笔记、读书报告会、读书分享会等方式引导学生高质量完成整本书的阅读；可通过观察报告、实验报告、研究报告等，评价学生跨学科学习的阶段性成果。”“第一学段的评价要特别重
    
                    
    • 
                    
  • 读书笔记|碎片化写作
                        听雨Jack

                        
    在现代职场，总的趋势就是工作时间越来越碎片化，即使在没有微博微信的时代，我们的工作时间也早就被电话、邮件、QQ、会议打断成了碎片，而微博、微信这样的移动媒体只是加剧了这一趋势。这就需要我们利用碎片时间完成系统化工作。对于写作这件事，可以使用碎片化写作法：一份完整的文章=1分钟灵感+5分钟构思+5分钟提纲+5分钟素材+…+3分钟素材+半小时高效写作+5分钟排版+5分钟配图+1分钟推送+1分钟回复评论
    
                    
    • 
                                
  • SAX解析xml文件
                                    小猪猪08
xml
                                    
    1.创建SAXParserFactory实例 
2.通过SAXParserFactory对象获取SAXParser实例 
3.创建一个类SAXParserHander继续DefaultHandler，并且实例化这个类 
4.SAXParser实例的parse来获取文件 
    public static void main(String[] args) { 
 //
    
                                
    • 
                                
  • 为什么mysql里的ibdata1文件不断的增长？
                                    brotherlamp
linuxlinux运维linux资料linux视频linux运维自学
                                    
    我们在 Percona 支持栏目经常收到关于 MySQL 的 ibdata1 文件的这个问题。 
当监控服务器发送一个关于 MySQL 服务器存储的报警时，恐慌就开始了 —— 就是说磁盘快要满了。 
一番调查后你意识到大多数地盘空间被 InnoDB 的共享表空间 ibdata1 使用。而你已经启用了 innodbfileper_table，所以问题是： 
ibdata1存了什么？ 
当你启用了 i
    
                                
    • 
                                
  • Quartz-quartz.properties配置
                                    eksliang
quartz
                                    
    其实Quartz JAR文件的org.quartz包下就包含了一个quartz.properties属性配置文件并提供了默认设置。如果需要调整默认配置，可以在类路径下建立一个新的quartz.properties，它将自动被Quartz加载并覆盖默认的设置。 
  
下面是这些默认值的解释 
#-----集群的配置
org.quartz.scheduler.instanceName =
    
                                
    • 
                                
  • informatica session的使用
                                    18289753290
workflowsessionlogInformatica
                                    
    如果希望workflow存储最近20次的log，在session里的Config  Object设置，log  options做配置，save  session log :sessions  run  ;savesessio log for  these runs:20 
session下面的source 里面有个tracing 
    
                                
    • 
                                
  • Scrapy抓取网页时出现CRC check failed 0x471e6e9a != 0x7c07b839L的错误
                                    酷的飞上天空
scrapy
                                    
    Scrapy版本0.14.4 
出现问题现象： 
  
ERROR: Error downloading <GET http://xxxxx  CRC check failed 
  
解决方法 
  
1.设置网络请求时的header中的属性'Accept-Encoding': '*;q=0' 
  
明确表示不支持任何形式的压缩格式，避免程序的解压
    
                                
    • 
                                
  • java Swing小集锦
                                    永夜-极光
java swing
                                    
    1.关闭窗体弹出确认对话框 
  1.1   this.setDefaultCloseOperation (JFrame.DO_NOTHING_ON_CLOSE); 
  1.2   
	this.addWindowListener (
				new WindowAdapter () {
					public void windo
    
                                
    • 
                                
  • 强制删除.svn文件夹
                                    随便小屋
java
                                    
      
        在windows上，从别处复制的项目中可能带有.svn文件夹，手动删除太麻烦，并且每个文件夹下都有。所以写了个程序进行删除。因为.svn文件夹在windows上是只读的，所以用File中的delete()和deleteOnExist()方法都不能将其删除，所以只能采用windows命令方式进行删除
    
                                
    • 
                                
  • GET和POST有什么区别？及为什么网上的多数答案都是错的。
                                    aijuans
get post
                                    
      
    如果有人问你，GET和POST，有什么区别？你会如何回答？ 我的经历 
     前几天有人问我这个问题。我说GET是用于获取数据的，POST，一般用于将数据发给服务器之用。 
    这个答案好像并不是他想要的。于是他继续追问有没有别的区别？我说这就是个名字而已，如果服务器支持，他完全可以把G
    
                                
    • 
                                
  • 谈谈新浪微博背后的那些算法
                                    aoyouzi
谈谈新浪微博背后的那些算法
                                    
    本文对微博中常见的问题的对应算法进行了简单的介绍，在实际应用中的算法比介绍的要复杂的多。当然，本文覆盖的主题并不全，比如好友推荐、热点跟踪等就没有涉及到。但古人云“窥一斑而见全豹”，希望本文的介绍能帮助大家更好的理解微博这样的社交网络应用。 
微博是一个很多人都在用的社交应用。天天刷微博的人每天都会进行着这样几个操作：原创、转发、回复、阅读、关注、@等。其中，前四个是针对短博文，最后的关注和@则针
    
                                
    • 
                                
  • Connection reset 连接被重置的解决方法
                                    百合不是茶
java字符流连接被重置
                                    
    流是java的核心部分,,昨天在做android服务器连接服务器的时候出了问题,就将代码放到java中执行,结果还是一样连接被重置 
  
被重置的代码如下; 
  
客户端代码; 
package 通信软件服务器;

import java.io.BufferedWriter;
import java.io.OutputStream;
import java.io.O
    
                                
    • 
                                
  • web.xml配置详解之filter
                                    bijian1013
javaweb.xmlfilter
                                    
    一.定义 
<filter>
	<filter-name>encodingfilter</filter-name>
	<filter-class>com.my.app.EncodingFilter</filter-class>
	<init-param>
		<param-name>encoding<
    
                                
    • 
                                
  • Heritrix
                                    Bill_chen
多线程xml算法制造配置管理
                                    
    作为纯Java语言开发的、功能强大的网络爬虫Heritrix，其功能极其强大，且扩展性良好，深受热爱搜索技术的盆友们的喜爱，但它配置较为复杂，且源码不好理解，最近又使劲看了下，结合自己的学习和理解，跟大家分享Heritrix的点点滴滴。 
Heritrix的下载（http://sourceforge.net/projects/archive-crawler/）安装、配置，就不罗嗦了，可以自己找找资
    
                                
    • 
                                
  • 【Zookeeper】FAQ
                                    bit1129
zookeeper
                                    
    1.脱离IDE，运行简单的Java客户端程序 
#ZkClient是简单的Zookeeper~$ java -cp "./:zookeeper-3.4.6.jar:./lib/*" ZKClient   
  
1. Zookeeper是的Watcher回调是同步操作，需要添加异步处理的代码 
2. 如果Zookeeper集群跨越多个机房，那么Leader/
    
                                
    • 
                                
  • The user specified as a definer ('aaa'@'localhost') does not exist
                                    白糖_
localhost
                                    
    今天遇到一个客户BUG，当前的jdbc连接用户是root，然后部分删除操作都会报下面这个错误：The user specified as a definer ('aaa'@'localhost') does not exist 
最后找原因发现删除操作做了触发器，而触发器里面有这样一句 
  
 /*!50017 DEFINER = ''aaa@'localhost' */ 
 原来最初
    
                                
    • 
                                
  • javascript中showModelDialog刷新父页面
                                    bozch
JavaScript刷新父页面showModalDialog
                                    
    在页面中使用showModalDialog打开模式子页面窗口的时候，如果想在子页面中操作父页面中的某个节点，可以通过如下的进行： 
      window.showModalDialog('url',self,‘status...’); // 首先中间参数使用self 
      在子页面使用w
    
                                
    • 
                                
  • 编程之美-买书折扣
                                    bylijinnan
编程之美
                                    
    


import java.util.Arrays;

public class BookDiscount {

	/**编程之美 买书折扣

书上的贪心算法的分析很有意思，我看了半天看不懂，结果作者说，贪心算法在这个问题上是不适用的。。
下面用动态规划实现。
哈利波特这本书一共有五卷，每卷都是8欧元，如果读者一次购买不同的两卷可扣除5%的折扣，三卷10%，四卷20%，五卷
    
                                
    • 
                                
  • 关于struts2.3.4项目跨站执行脚本以及远程执行漏洞修复概要
                                    chenbowen00
strutsWEB安全
                                    
    因为近期负责的几个银行系统软件，需要交付客户，因此客户专门请了安全公司对系统进行了安全评测，结果发现了诸如跨站执行脚本，远程执行漏洞以及弱口令等问题。 
下面记录下本次解决的过程以便后续 
1、首先从最简单的开始处理，服务器的弱口令问题，首先根据安全工具提供的测试描述中发现应用服务器中存在一个匿名用户，默认是不需要密码的，经过分析发现服务器使用了FTP协议， 
而使用ftp协议默认会产生一个匿名用
    
                                
    • 
                                
  • [电力与暖气]煤炭燃烧与电力加温
                                    comsci

                                    
     
      在宇宙中,用贝塔射线观测地球某个部分,看上去,好像一个个马蜂窝,又像珊瑚礁一样,原来是某个国家的采煤区..... 
 
      不过,这个采煤区的煤炭看来是要用完了.....那么依赖将起燃烧并取暖的城市,在极度严寒的季节中...该怎么办呢? 
 
  &nbs
    
                                
    • 
                                
  • oracle O7_DICTIONARY_ACCESSIBILITY参数
                                    daizj
oracle
                                    
    O7_DICTIONARY_ACCESSIBILITY参数控制对数据字典的访问.设置为true,如果用户被授予了如select any table等any table权限,用户即使不是dba或sysdba用户也可以访问数据字典.在9i及以上版本默认为false,8i及以前版本默认为true.如果设置为true就可能会带来安全上的一些问题.这也就为什么O7_DICTIONARY_ACCESSIBIL
    
                                
    • 
                                
  • 比较全面的MySQL优化参考
                                    dengkane
mysql
                                    
    本文整理了一些MySQL的通用优化方法，做个简单的总结分享，旨在帮助那些没有专职MySQL DBA的企业做好基本的优化工作，至于具体的SQL优化，大部分通过加适当的索引即可达到效果，更复杂的就需要具体分析了，可以参考本站的一些优化案例或者联系我，下方有我的联系方式。这是上篇。 
  
1、硬件层相关优化 
  
1.1、CPU相关 
  
在服务器的BIOS设置中，可
    
                                
    • 
                                
  • C语言homework2，有一个逆序打印数字的小算法
                                    dcj3sjt126com
c
                                    
    #h1# 
  
0、完成课堂例子 
1、将一个四位数逆序打印 
1234 ==> 4321 
实现方法一： 
# include <stdio.h>

int main(void)
{
	int i = 1234;
	int one = i%10;
	int two =  i / 10 % 10;
	int three = i / 100 % 10;

    
                                
    • 
                                
  • apacheBench对网站进行压力测试
                                    dcj3sjt126com
apachebench
                                    
       ab 的全称是 ApacheBench ， 是 Apache 附带的一个小工具 ， 专门用于 HTTP Server 的 benchmark testing ， 可以同时模拟多个并发请求。前段时间看到公司的开发人员也在用它作一些测试，看起来也不错，很简单，也很容易使用，所以今天花一点时间看了一下。 
通过下面的一个简单的例子和注释，相信大家可以更容易理解这个工具的使用。 
    
                                
    • 
                                
  • 2种办法让HashMap线程安全
                                    flyfoxs
javajdkjni
                                    
    多线程之--2种办法让HashMap线程安全 
多线程之--synchronized 和reentrantlock的优缺点 
多线程之--2种JAVA乐观锁的比较( NonfairSync VS. FairSync) 
  
  
HashMap不是线程安全的,往往在写程序时需要通过一些方法来回避.其实JDK原生的提供了2种方法让HashMap支持线程安全. 
  

    
                                
    • 
                                
  • Spring Security（04）——认证简介
                                    234390216
Spring Security认证过程
                                    
    认证简介 
目录 
1.1     认证过程 
1.2     Web应用的认证过程 
1.2.1    ExceptionTranslationFilter 
1.2.2    在request之间共享SecurityContext 
   

1
    
                                
    • 
                                
  • Java 位运算
                                    Javahuhui
java位运算
                                    
    // 左移( << ) 低位补0 
// 0000 0000 0000 0000 0000 0000 0000 0110 然后左移2位后，低位补0： 
// 0000 0000 0000 0000 0000 0000 0001 1000 
System.out.println(6 << 2);// 运行结果是24 
 
// 右移( >> ) 高位补"
    
                                
    • 
                                
  • mysql免安装版配置
                                    ldzyz007
mysql
                                    
    1、my-small.ini是为了小型数据库而设计的。不应该把这个模型用于含有一些常用项目的数据库。 
2、my-medium.ini是为中等规模的数据库而设计的。如果你正在企业中使用RHEL,可能会比这个操作系统的最小RAM需求(256MB)明显多得多的物理内存。由此可见，如果有那么多RAM内存可以使用，自然可以在同一台机器上运行其它服务。 
3、my-large.ini是为专用于一个SQL数据
    
                                
    • 
                                
  • MFC和ado数据库使用时遇到的问题
                                    你不认识的休道人
sqlC++mfc
                                    
    =================================================================== 
第一个 
=================================================================== 
 
try{
		CString sql;
	sql.Format("select * from p
    
                                
    • 
                                
  • 表单重复提交Double Submits
                                    rensanning
double
                                    
    可能发生的场景： 
 
 
 *多次点击提交按钮  
 *刷新页面  
 *点击浏览器回退按钮  
 *直接访问收藏夹中的地址  
 *重复发送HTTP请求（Ajax） 
 
（1）点击按钮后disable该按钮一会儿，这样能避免急躁的用户频繁点击按钮。 
这种方法确实有些粗暴，友好一点的可以把按钮的文字变一下做个提示，比如Bootstrap的做法： 
http://getbootstrap.co
    
                                
    • 
                                
  • Java String 十大常见问题
                                    tomcat_oracle
java正则表达式
                                    
    　1.字符串比较，使用“==”还是equals()?   　　"=="判断两个引用的是不是同一个内存地址(同一个物理对象)。   　　equals()判断两个字符串的值是否相等。   　　除非你想判断两个string引用是否同一个对象，否则应该总是使用equals()方法。   　　如果你了解字符串的驻留(String Interning)则会更好地理解这个问题。   　 
　
    
                                
    • 
                                
  • SpringMVC 登陆拦截器实现登陆控制
                                    xp9802
springMVC
                                    
    思路，先登陆后，将登陆信息存储在session中，然后通过拦截器，对系统中的页面和资源进行访问拦截，同时对于登陆本身相关的页面和资源不拦截。 
  
实现方法： 
        1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18   19   20   21   22   23  
    
                                
    •