JAVA总结 - 设计模式篇

1.命令模式

package com.designpatter.demo;

/****
 * 设计模式
 *
 * 命令模式
 * 命令（Command）模式的定义如下：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通，
 * 这样方便将命令对象进行储存、传递、调用、增加与管理。
 *
 * 命令模式的主要优点如下。
 * 降低系统的耦合度。命令模式能将调用操作的对象与实现该操作的对象解耦。
 * 增加或删除命令非常方便。采用命令模式增加与删除命令不会影响其他类，它满足“开闭原则”，对扩展比较灵活。
 * 可以实现宏命令。命令模式可以与组合模式结合，将多个命令装配成一个组合命令，即宏命令。
 * 方便实现 Undo 和 Redo 操作。命令模式可以与后面介绍的备忘录模式结合，实现命令的撤销与恢复。
 *
 * 其缺点是：可能产生大量具体命令类。因为计对每一个具体操作都需要设计一个具体命令类，这将增加系统的复杂性。
 */
public class CommandPatterDemo {

    public static void main(String[] args) {
        Context command = new Context(new read());
        command.execute();
    }

    public interface Command {
        void execute();
    }

    public static class read implements Command{
        @Override
        public void execute() {
            System.out.println("开始读取数据");
        }
    }

    public static class copy implements Command{
        @Override
        public void execute() {
            System.out.println("开始复制数据");
        }
    }

    public static class Context{
        private  Command command;

        public Context(Command command) {
            this.command = command;
        }

        public void execute(){
            this.command.execute();
        }
    }
}

2.装饰模式

package com.designpatter.demo;

/**
 * 装饰模式
 * 
 * 介绍其适用的应用场景，装饰模式通常在以下几种情况使用。
 * 当需要给一个现有类添加附加职责，而又不能采用生成子类的方法进行扩充时。例如，该类被隐藏或者该类是终极类或者采用继承方式会产生大量的子类。
 * 当需要通过对现有的一组基本功能进行排列组合而产生非常多的功能时，采用继承关系很难实现，而采用装饰模式却很好实现。
 * 当对象的功能要求可以动态地添加，也可以再动态地撤销时。
 *
 * 装饰模式在 Java 语言中的最著名的应用莫过于 Java I/O 标准库的设计了。例如，InputStream 的子类 FilterInputStream，
 * OutputStream 的子类 FilterOutputStream，Reader 的子类 BufferedReader 以及 FilterReader，还有 Writer 的子类 BufferedWriter、
 * FilterWriter 以及 PrintWriter 等，它们都是抽象装饰类。
 * */
public class DecoratePatternDemo {

        public static void main(String[] args) {
            SuperPerson  superPerson = new SuperPerson(new Person());
            superPerson.eat();
        }
        static class Person{
            public void eat(){
                System.out.println("吃饭");
            }
        }

        static class SuperPerson{
            private Person person;

            public SuperPerson(Person person) {
                this.person = person;
            }

            public void eat(){
                System.out.println("喝两口");
                this.person.eat();
                System.out.println("抽两根");
            }

        }
}

3.构建者模式

package com.designpatter.demo;
/**
 *
 * 建造者（Builder）模式的定义：指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。
 * 它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。
 *
 * 该模式的主要优点如下：
 * 各个具体的建造者相互独立，有利于系统的扩展。
 * 客户端不必知道产品内部组成的细节，便于控制细节风险。
 *
 * 其缺点如下：
 * 产品的组成部分必须相同，这限制了其使用范围。
 * 如果产品的内部变化复杂，该模式会增加很多的建造者类。
 *
 * 建造者（Builder）模式和工厂模式的关注点不同：建造者模式注重零部件的组装过程，而工厂方法模式更注重零部件的创建过程，但两者可以结合使用。
 * */
public class WithoutPatternDemo {

    public static void main(String[] args) {
        Student student = new ConCreateStudent()
                .setSpeak1("test1")
                .setSpeak2("test2")
                .setSpeak3("test3")
                .build();

        System.out.println(student);
    }

    public static class Student{
        private String speak1;
        private String speak2;
        private String speak3;

        public void setSpeak1(String speak1) {
            this.speak1 = speak1;
        }

        public void setSpeak2(String speak2) {
            this.speak2 = speak2;
        }

        public void setSpeak3(String speak3) {
            this.speak3 = speak3;
        }

        public String getSpeak1() {
            return speak1;
        }

        public String getSpeak2() {
            return speak2;
        }

        public String getSpeak3() {
            return speak3;
        }

        @Override
        public String toString() {
            return "Student{" +
                    "speak1='" + speak1 + '\'' +
                    ", speak2='" + speak2 + '\'' +
                    ", speak3='" + speak3 + '\'' +
                    '}';
        }
    }

    public interface Buidler{
        Buidler setSpeak1(String speak1);
        Buidler setSpeak2(String speak2);
        Buidler setSpeak3(String speak3);
        Student build();
    }

    public static class ConCreateStudent implements Buidler {
        Student student = new Student();
        @Override
        public Buidler setSpeak1(String speak1) {
            System.out.println("复杂的逻辑判断");
            student.setSpeak1(speak1);
            return this;
        }

        @Override
        public Buidler setSpeak2(String speak2) {
            System.out.println("复杂的逻辑判断");
            student.setSpeak2(speak2);
            return this;
        }

        @Override
        public Buidler setSpeak3(String speak3) {
            System.out.println("复杂的逻辑判断");
            student.setSpeak3(speak3);
            return this;
        }

        @Override
        public Student build() {
            return student;
        }
    }
}

4.组合模式

package com.designpatter.demo;

import java.util.ArrayList;
import java.util.List;
/**
 * 组合模式的主要优点有：
 * 组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码；
 * 更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，满足“开闭原则”；
 *
 * 其主要缺点是：
 * 设计较复杂，客户端需要花更多时间理清类之间的层次关系；
 * 不容易限制容器中的构件；
 * 不容易用继承的方法来增加构件的新功能；
 * */
public class WhihoutPatternDemo {
    public static void main(String[] args) {

        Department coreDep = new Department("主部门");

        Department subDep1 = new Department("子部门1");
        Department subDep2 = new Department("子部门2");

        Department leafDep1 = new Department("叶子部门1");
        Department leafDep2 = new Department("叶子部门2");
        Department leafDep3 = new Department("叶子部门3");

        subDep1.child.add(leafDep1);
        subDep2.child.add(leafDep2);
        subDep2.child.add(leafDep3);
        coreDep.child.add(subDep1);
        coreDep.child.add(subDep2);

        coreDep.remove();
    }

    static class Department{
        private String name;
        private List<Department> child = new ArrayList<Department>();

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

        public String getName() {
            return name;
        }
        public List<Department> getChild() {
            return child;
        }

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

        public void setChild(List<Department> child) {
            this.child = child;
        }

        void remove(){
            if(this.child.size() > 0){
                for(Department department:this.child){
                    department.remove();
                }
            }
            System.out.println("删除"+name);
        }
    }
}