设计模式总结

设计模式的分类

1. 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
2. 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
3. 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

设计原则

单一职责原则：类的设计尽量做到只有一个原因可以引起它的改变
里氏替换原则：只要父类出现的地方子类就可以出现，且替换成子类也不会出现任何错误或者异常
依赖倒置原则：针对接口编程，而不是针对实现编程
接口隔离原则：不要建立臃肿庞大的接口。即接口尽量细化，同时接口中的方法尽量少
迪米特法则： 一个对象应该对其他对象有最少的了解，也就是说一个类要对自己需要耦合或者调用的类知道的最少
开闭原则： 一个软件实体，比如类，模块，函数应该对扩展开放，对修改关闭

常见设计模式

单例模式

饿汉式

package com.yjxxt.design;
/*
    单例模式:
        在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。

    懒汉式 : 在调用功能时才创建对象   ->线程不安全|不同步的
    饿汉式 : 在类加载完成之后就创建对象->线程安全的|同步的

    步骤:
        1.构造器私有化
        2.私有的静态的该类的引用
        3.公共的静态的访问方式

    饿汉式:
 */
public class Clsaa001_Single {
    //2.私有的静态的该类的引用
    private static Clsaa001_Single single = new Clsaa001_Single();

    //1.构造器私有化
    public Clsaa001_Single() {
    }

    //3.公共的静态的访问方式
    public static Clsaa001_Single newInsrance() {
        return single;
    }
}

懒汉式

package com.yjxxt.design;
/*
    懒汉式
        线程不安全的|不同步的
        控制线程安全: 方法在添加synchronized关键字进行修改
        synchronized : 被修改的内容多个线程之间排队执行
 */
public class Class002_SingleTon {
    //2.私有的静态的该类的引用
    private static Class002_SingleTon single = null;

    //1.构造器私有化
    private Class002_SingleTon(){

    }

    //A B C
    //3.公共的静态的访问方式
    public static synchronized Class002_SingleTon newInstance(){
        if(single==null){
            single = new Class002_SingleTon();
        }
        return single;
    }
}

代理模式

package com.yjxxt.design;
/*
   静态代理 :
       静态代理
       动态代理

   静态代理:
       代理角色与真实角色实现相同的接口
       代理角色持有真实角色的引用
       代理行为
*/
public class Clsaa003_StaticProxy {
   public static void main(String[] args) {

   }

   interface addUser {
      void addUser();
   }

   class Manager implements addUser {

      @Override
      public void addUser() {
         System.out.println("面试录用了");
      }
   }

   class HR implements addUser {

      Manager manager = null;
      public HR(Manager manager) {
         this.manager = manager;
      }

      @Override
      public void addUser() {
         System.out.println("发布招聘信息");
         System.out.println("筛选简历");
         System.out.println("预约面试");
         manager.addUser();
         System.out.println("预约成功");
      }
   }
}

简单工厂模式

定义：定义了一个创建对象的类，由这个类来封装实例化对象的行为。

package com.yjxxt.design;
/*
    简单工厂模式:
        抽象产品角色 : 具体产品角色实现的接口|继承的父类
        具体产品角色 : 实现类|子类
        工厂角色

    注意:
        字符串比较是否相等需要使用equals方法进行比较字符串的内容,建议常量放在.的前面,避免空指针异常的出现
 */
public class Class004_Factory {

    public static void main(String[] args) {
        Car car = factory("Benchi");
        car.run();
    }

    //工厂角色
    public static Car factory (String type) {
        if("Bm".equals(type)) {
            return new Bm();
        } else if("Benchi".equals(type)) {
            return new Benchi();
        }

        return null;
    }
}

//抽象产品角色
interface Car {
    void run();
}

//具体产品角色
class Bm implements Car {

    @Override
    public void run() {
        System.out.println("宝马笑");
    }
}

//具体产品角色
class Benchi implements Car {

    @Override
    public void run() {
        System.out.println("奔驰哭");
    }
}

下面针对简单工厂模式举一个例子（披萨）

package com.yjxxt.design;

import java.util.Scanner;

/*
   1.	编写程序实现比萨制作。需求说明编写程序，接收用户输入的信息，选择需要制作的比萨。可供选择的比萨有：培根比萨和海鲜比萨。
        实现思路及关键代码
        1)	分析培根比萨和海鲜比萨
        2)	定义比萨类
        3)	属性：名称、价格、大小
        4)	方法：展示
        5)	定义培根比萨和海鲜比萨继承自比萨类
        6)	定义比萨工厂类，根据输入信息产生具体的比萨对象
 */
public class Class005_PizzaTest {

    public static void main(String[] args) {
        Pizza pizza = factory();
        pizza.show();
    }
    
    //工厂方法
    public static Pizza factory() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请选择想要制作的Pizza \n1)培根披萨\n2)海鲜披萨");
        int num = sc.nextInt();
        System.out.println("请输入披萨的大小");
        int size = sc.nextInt();
        System.out.println("请输入披萨的价格");
        double price = sc.nextDouble();
        Pizza pizza = null;
        if(num==1){
            
        }else if(num==2) {
            System.out.println("请输入海鲜的配料信息");
            String infor = sc.next();
            pizza = new SeaPizza("海鲜披萨",price,size,infor);
        }
        return pizza; 
    }
    
}

abstract class Pizza {
    private String name;
    private double price;
    private int size;

    public Pizza() {}
    public Pizza(String name, double price, int size) {
        this.name = name;
        this.price = price;
        this.size = size;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public void show() {
        System.out.println(name);
        System.out.println(price);
        System.out.println(size);
    }
}

class SeaPizza extends Pizza {
    
    private String infor;

    public String getInfor() {
        return infor;
    }

    public void setInfor(String infor) {
        this.infor = infor;
    }

    public SeaPizza(){}
    
    public SeaPizza(String name, double price, int size, String infor) {
        super(name, price, size);
        this.infor = infor;
    }
    public void show() {
        super.show();
        System.out.println(infor);
    }
}