分类
- 创建型模式（5）：将对象的创建和使用分离
- 单例
- 原型
- 工厂方法
- 抽象工厂
- 建造者
- 结构型模型（7）：类或者对象以怎样的结构组成一个大的系统
- 代理
- 适配器
- 桥接
- 装饰
- 外观
- 享元
- 组合
- 行为型模型（11）：类或者对象之间怎样协作完成任务，怎样分配职责
- 模板方法
- 策略
- 命令
- 职责链
- 状态
- 观察者
- 中介者
- 迭代器
- 访问者
- 备忘录
- 解释器
其中工厂方法，适配器，模板方法，解释器属于是用于类之间使用的设计模式，其余的属于对象使用的设计模式
创建型模型
关注怎样创建对象，让对象的创建和使用分离，用户只关心对象的使用，不在关注对象的创建
单例模式（Singleton）
类只能创建一个对象，构造函数为私有的
特点：
- 类只能创建一个对象
- 对象由类自己创建
- 单例类对外只有一个全局访问点
举例：
- 数据库连接池
- web配置
- 日志对象
实现
1.懒汉式单例模式
类加载时没有创建对象，第一次使用时创建对象
package com.singLeton;
/**
* @Author redarm
* @Date 2020/5/17 12:59 下午
**/
public class LazySingLeton {
private static volatile LazySingLeton lazySingLeton = null;
private LazySingLeton(){
}
public static synchronized LazySingLeton getInstance(){
if (lazySingLeton == null){
lazySingLeton = new LazySingLeton();
}
return lazySingLeton;
}
}
2.饿汉单例模式
加载类时就创建单例对象
package com.singLeton;
/**
* @Author redarm
* @Date 2020/5/17 1:03 下午
**/
public class HungrySingLeton {
private static final HungrySingLeton instance = new HungrySingLeton();
private HungrySingLeton(){
}
public static HungrySingLeton getInstance(){
return instance;
}
}
应用：
- 要求只有一个对象
- 对象需要被共享
- 对象反复的创建和销毁时
原型模式（Prototype）
对象的创建不是new，而是复制clone一个对象
实现
实现Cloneable接口的clone方法
package com.DesignPatterns.protoType;
/**
* @Author redarm
* @Date 2020/5/17 2:43 下午
* 原型模式
**/
public class ProtoType{
public static void main(String[] args) throws CloneNotSupportedException {
Student student1 = new Student("liu");
Student student2 = student1.clone();
System.out.println(student1.toString() + " : " + student2.toString());
}
}
class Student implements Cloneable{
private String name;
public Student(String name){
this.name = name;
}
public Student(){
this.name = null;
}
@Override
protected Student clone() throws CloneNotSupportedException {
return (Student)super.clone();
}
@Override
public String toString() {
return "name: " + this.name;
}
}
clone：完全复制复制对象
应用：
- 对象之间相同，或者个别属性不同
工厂方法模型（FactoryMethod）
通过工厂创建对象，只要直到工厂名称就能创建对象，不需要知道创建的过程，而且可以增加对象的种类，同时也增加了对应的工厂类
实现：
- 产品接口
- 产品实现
- 工厂接口
- 工厂实现
动物接口
package com.DesignPatterns.factoryMethod;
/**
* @Author redarm
* @Date 2020/5/17 6:21 下午
* 工厂方法模型
**/
public interface Animal {
void getName();
}
动物实现
package com.DesignPatterns.factoryMethod;
/**
* @Author redarm
* @Date 2020/5/17 6:22 下午
**/
public class Dog implements Animal {
private String name;
public Dog(){
this.name = "dog";
}
@Override
public void getName() {
System.out.println("I am a " + this.name);
}
}
package com.DesignPatterns.factoryMethod;
/**
* @Author redarm
* @Date 2020/5/17 6:23 下午
**/
public class Horse implements Animal {
private String name;
public Horse(){
this.name = "horse";
}
@Override
public void getName() {
System.out.println("I am a " + this.name);
}
}
工厂接口
package com.DesignPatterns.factoryMethod;
/**
* @Author redarm
* @Date 2020/5/17 6:24 下午
**/
public interface AnimalFarm {
Animal getAnimal();
}
工厂实现
package com.DesignPatterns.factoryMethod;
/**
* @Author redarm
* @Date 2020/5/17 6:26 下午
**/
public class DogFarm implements AnimalFarm {
@Override
public Animal getAnimal() {
return new Dog();
}
}
package com.DesignPatterns.factoryMethod;
/**
* @Author redarm
* @Date 2020/5/17 6:26 下午
**/
public class HorseFarm implements AnimalFarm {
@Override
public Animal getAnimal() {
return new Horse();
}
}
测试：
package com.DesignPatterns.factoryMethod;
/**
* @Author redarm
* @Date 2020/5/17 6:27 下午
**/
public class Test {
public static void main(String[] args) {
new DogFarm().getAnimal().getName();
new HorseFarm().getAnimal().getName();
}
}
应用：
- 只需知道工厂名，无需知道产品名
- 工厂中产品种类一样，品牌不一样
抽象工厂模型（AbstractFactory）
当工厂可以生产不同类型的产品时，使用抽象工厂模型
实现
- 产品接口
- 实现产品的工厂
动物接口
package com.DesignPatterns.abstractFactory;
/**
* @Author redarm
* @Date 2020/5/17 6:43 下午
* 抽象工厂模型
**/
public interface Animal {
void newDog();
void newHorse();
}
工厂实现
package com.DesignPatterns.abstractFactory;
/**
* @Author redarm
* @Date 2020/5/17 6:45 下午
**/
public class AnimalFactory implements Animal {
@Override
public void newDog() {
System.out.println("I am a Dog");
}
@Override
public void newHorse() {
System.out.println("I am a Horse");
}
}
建造者模式（Builder）
对象由多个部件组成，比如电脑对象由CPU，GPC，Board组成
实现：
- 对象
- 建造者抽象类
- 建造者实现（可以多个）
- 统一管理者
电脑对象：
package com.DesignPatterns.builder;
/**
* @Author redarm
* @Date 2020/5/17 7:09 下午
* 建造者模型
**/
public class Computer {
private String CPU;
private String board;
private String GPU;
public String getCPU() {
return CPU;
}
public void setCPU(String CPU) {
this.CPU = CPU;
}
public String getBoard() {
return board;
}
public void setBoard(String board) {
this.board = board;
}
public String getGPU() {
return GPU;
}
public void setGPU(String GPU) {
this.GPU = GPU;
}
@Override
public String toString() {
return "CPU: " + this.getCPU() + " GPU: " + this.getGPU() + " Board: " + this.getBoard();
}
}
建造者抽象和两个实现
package com.DesignPatterns.builder;
/**
* @Author redarm
* @Date 2020/5/17 7:11 下午
**/
public abstract class ComputerBuilder {
Computer computer = new Computer();
void setCPU() {
}
void setBoard() {
}
void setGPU() {
}
Computer getComputer(){
return computer;
};
}
package com.DesignPatterns.builder;
/**
* @Author redarm
* @Date 2020/5/17 7:14 下午
**/
public class InterComputerBuilderOne extends ComputerBuilder {
@Override
public void setCPU() {
computer.setCPU("i9 9900k");
}
@Override
public void setBoard() {
computer.setBoard("B360-M");
}
@Override
public void setGPU() {
computer.setGPU("2080Ti");
}
}
package com.DesignPatterns.builder;
/**
* @Author redarm
* @Date 2020/5/17 7:18 下午
**/
public class AMDComputerBuilder extends ComputerBuilder {
@Override
public void setCPU() {
computer.setCPU("r5 3600x");
}
@Override
public void setBoard() {
computer.setBoard("B360-M");
}
@Override
public void setGPU() {
computer.setGPU("2080Ti");
}
}
统一管理
package com.DesignPatterns.builder;
/**
* @Author redarm
* @Date 2020/5/17 7:17 下午
**/
public class ComputerManager {
private ComputerBuilder computerBuilder;
public ComputerManager(ComputerBuilder computerBuilder){
this.computerBuilder = computerBuilder;
}
public ComputerManager(){
this.computerBuilder = new InterComputerBuilderOne();
}
public Computer newComputer(){
computerBuilder.setCPU();
computerBuilder.setGPU();
computerBuilder.setBoard();
return computerBuilder.getComputer();
}
public Computer newInterComputer(){
this.computerBuilder = new InterComputerBuilderOne();
computerBuilder.setBoard();
computerBuilder.setCPU();
computerBuilder.setGPU();
return computerBuilder.getComputer();
}
public Computer newAMDComputer(){
this.computerBuilder = new AMDComputerBuilder();
computerBuilder.setCPU();
computerBuilder.setGPU();
computerBuilder.setBoard();
return computerBuilder.getComputer();
}
}
测试
package com.DesignPatterns.builder;
/**
* @Author redarm
* @Date 2020/5/17 7:24 下午
**/
public class Test {
public static void main(String[] args) {
ComputerManager computerManager = new ComputerManager();
Computer InterComputer = computerManager.newInterComputer();
Computer AMDComputer = computerManager.newAMDComputer();
System.out.println("Inter: " + InterComputer.toString() + "\nAMD: " + AMDComputer.toString());
}
}
应用：
- 对象复制，组件多
- 每个对象部件组成相同，但是每个部件的实现不同