java常用设计模式

一、设计模式作用

1. 重用设计和代码（设计重用更有意义，因为设计的重用会带来代码的重用）
2. 提高了扩展性（因大量使用面向对象接口编程，预留了扩展能力）
3. 提高了灵活性（因大量使用组合而不是继承，使得一处的修改不会涉及很多模块）
4. 提高开发效率（节省时间）

二、 设计模式分类

1. 按解决的问题可分为：创建型设计模式、结构型设计模式、行为型设计模式。

• 创建型设计模式：对象实例化的模式 (可以理解为构造方法new)，用于解耦对象实例化过程。
  包括 ：工厂方法模式、抽象工厂模式、建造者模式、单例模式、原型模式等。
• 结构型设计模式：将类和对象结合在一起形成一个大结构（可以理解为变量）。
  包括 ：外观模式、装饰模式、代理模式等。
• 行为型设计模式：类和对象如何交互，划分责任和算法。（方法）
  包括 ：责任链模式、模板模式、策略模式等。

2. 按处理对象间还是父子类关系可分为：类设计模式（静态的）和对象设计模式（动态的，在运行期间可变化）。

（1）创建型设计模式

• 解耦对象实例化过程，创建对象时隐藏创建逻辑，不再是 new 运算符直接实例化对象，使得创建对象更加灵活，创建和使用分离，只需知道接口不用知道细节。

1. 简单工厂模式（不属于23种经典设计模式，不符合开闭原则，但有助于后续理解）

• 原理：由工厂类根据传入的参数来判断应该创建产品的那个子类，且以产品类(父类)形式返回。

• 包含角色：(未抽象化)工厂(提供可被外界调用的静态方法，创建相应产品对象)， 抽象产品(产品父类/接口，有通用接口)， 具体产品(子类，是创建目标)

• 优点：产品的创建和使用分开，降低了客户端代码难度

• 缺点：若增减子类需要改工厂类，不符合开闭原则。如果子类太多不方便

• 图示：
  

• 代码示例：所有产品有一个共同的接口或者父类

/**
 * 这是一个产品接口，里面有要输出的操作
 * 所有产品有一个共同的接口或者父类，它们是一个系列，例如:都是手机
 */
public interface Product {
   

    public void output1();

    public void output2();
}

/**
 * 有三个产品子类来实现了产品接口
 */
 
//产品1
public class Product1 implements Product{
   
    @Override
    public void output1() {
   
        System.out.println("Product1: output1");
    }

    @Override
    public void output2() {
   
        System.out.println("Product1: output2");
    }
}

//产品2
public class Product2 implements Product{
   
    @Override
    public void output1() {
   
        System.out.println("Product2: output1");
    }

    @Override
    public void output2() {
   
        System.out.println("Product2: output2");
    }
}

//产品3
public class Procuct3 implements Product{
   
    @Override
    public void output1() {
   
        System.out.println("Product3: output1");
    }

    @Override
    public void output2() {
   
        System.out.println("Product3: output2");
    }
}

/**
 * 这是一个工厂类
 * static：可以通过工厂名直接访问方法
 * type：根据传人的type类型来判断要new哪个子类
 */
public class Factory {
   
    public Product getProduct(String type){
   
        Product product = null;
        if("1".equals(type)){
   
            product = new Product1();
        }else if("2".equals(type)){
   
            product = new Product2();
        }else{
   
            product = new Procuct3();
        }
        return product;
    }
}

/**
 * 这是一个测试类
 */
public class Test {
   
    public static void main(String[] args) {
   
        //创建一个工厂
        //Factory factory = new Factory();
        //不需要创建某个产品，直接从工厂获取
        //Product product = factory.getProduct("1");

        //可以不创建工厂，但是要在工厂中的方法上加static
        Product product = Factory.getProduct("1");
        product.output1();//输出Product1: output1
        product.output2();//输出Product1: output2
    }
}

2. 工厂方法模式

• 与简单工厂模式不同的是，工厂方法模式将工厂类也进行了抽象化。

• 工厂不再负责产品生产，而是指定规则，将创建任务交给子类完成。

• 符合了开闭原则，虽不用修改工厂类，但增加产品子类的时候也要增加工厂子类，增加了工作量。

• 图示：
  

• 代码示例：

/**
 * 这是一个运算的抽象类
 */
public abstract class Operation {
   

    protected int num1;

    protected int num2;

    public Operation() {
   
    }

    public Operation(int num1, int num2) {
   
        this.num1 = num1;
        this.num2 = num2;
    }

    public int getNum1() {
   
        return num1;
    }

    public void setNum1(int num1) {
   
        this.num1 = num1;
    }

    public int getNum2() {
   
        return num2;
    }

    public void setNum2(int num2) {
   
        this.num2 = num2;
    }

    //定义一个运算方法
    public abstract int operationMethod();
}

/**
 * 实现Operation中的运算接口
 */
public class Addition extends Operation {
   

    @Override
    public int operationMethod() {
   
        return num1 + num2;
    }
}

class Subtraction extends Operation {
   

    @Override
    public int operationMethod() {
   
        return num1 - num2;
    }
}

/**
 * 这是一个抽象工厂
 */
public abstract class Factory {
   
    /**创建一个运算对象
     * @return
     */
    public abstract Operation getMethod();
}

/**
 * 实现Factory中的get接口，来new不同的运算子类
 */
public class AddFactory extends Factory {
   
    @Override
    public Operation getMethod() {
   
        return new Addition();
    }
}

class SubtractFactory extends Factory {
   
    @Override
    public Operation getMethod() {
   
        return new Subtraction();
    }
}

public class Test {
   
    public static void main(String[] args) {
   
        //创建一个工厂,这是一个加法的
        Factory factory = new AddFactory();
        //从工厂中获取产品
        Operation operation = factory.getMethod();
        operation.setNum1(1);//或 operation.num1 = 1;
        operation.setNum2(2);

        //调用运算方法
        int res = operation.operationMethod()