设计模式总结

软件设计模式：是指在软件发展中，经过验证的，对于特定的环境下，重复出现的，特定问题的解决方案。

设计模式七大原则：单开里依接合迪

• 单一职责原则
• 开放封闭原则
• 里氏替换原则
• 依赖倒转原则
• 迪米特法则
• 合成复用原则
• 接口隔离原则

耦合性：功能模块之间的关系，各个模块之间的关系联系越少，耦合性就越低。

内聚型：块内联系，如果一个模块内的各个元素功能紧紧结合在一起，那么这个就是高内聚的。

程序开发追求：

• 高内聚，低耦合
• 可维护性
• 可扩展性
• 重用性
• 灵活性
• 可读性
• 可靠性
• 可以执行

单一职责原则

一个类只负责一个职责，对于一个类而言，应该只有一种引起他变化的原因。在类上不遵守单一职责原则但是在方法上遵守也可以

开放封闭原则

面型程序设计的终极目标。最基础最重要的设计原则。应该对扩展开放，对修改关闭。用扩展来替代修改。

/**
 * @author Pickled
 * @version V1.0
 * @date 2022/6/20 9:10
 */
class Client{
    public static void main(String[] args) {
        final GraphDraw graphDraw = new GraphDraw();
        graphDraw.draw(new Circle());
        graphDraw.draw(new rectangle());
        graphDraw.draw(new triangle());
    }
}
public abstract class Shape {
    abstract void show();
}
class Circle extends Shape{
    @Override
    void show() {
        System.out.println("画一个圆形");
    }
}
class triangle extends Shape{
    @Override
    void show() {
        System.out.println("画一个三角形");
    }
}
class rectangle extends Shape{
    @Override
    void show() {
        System.out.println("画一个矩形");
    }
}
class GraphDraw{
    void draw(Shape shape){
        shape.show();
    }
}

里氏替换原则

将所有父类出现的地方替换曾子类，逻辑依然成立。（子类可以以父类的身份出现）违反了里氏替换原则就必然违反了开放封闭原则。

依赖倒转原则

高层不应该依赖于底层，二者因该都依赖与抽象。

抽象不应该依赖细节，细节应该依赖抽象。

中心思想就是面型接口编程。

底层模块最好都要有抽象类或者接口

合成复用原则

使用合成聚合而不是使用继承。

接口隔离原则

不应该依赖不需要的接口。一个类对于另一个类的依赖应该建立在最小接口上。

迪米特法则

最少知道原则

单例模式-创建型模式

懒汉模式：调用方法时才开始创建单例，需要双重锁定处理

饿汉模式：在类初始化的时候就进行创建，在初始化的过程中是线程安全的，但是要提前占用系统资源

public class Client {
    public static void main(String[] args) {
        final HungryMan hungryMan = HungryMan.getHungryMan();

    }
}
class HungryMan{
    private static final HungryMan hungryMan = new HungryMan();
    private HungryMan(){}
    public static HungryMan getHungryMan(){
        return hungryMan;
    }
}
class LazyMan{
    private static volatile LazyMan lazyMan;
    private LazyMan(){}
    public static LazyMan getLazyMan(){
        if(lazyMan==null){
            synchronized (object){
                if(lazyMan==null){
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }
}

• 优点：保证系统中只有一个实例，减少内存的开销。避免资源多重占用。共享资源访问。
• 缺点：扩展困难，违反了开放封闭原则 ( •̀ ω •́ )✧

适配器模式-结构型模式

结构型模式

/**
 * 对象适配器通过继承目标接口，依赖被适配对象实现适配器功能
 * @author Pickled
 * @version V1.0
 * @date 2022/6/20 11:04
 */
public class ObjectAdapter {
    public static void main(String[] args) {
        final Target adapter = new Adapter();
        adapter.request();
    }
}
interface Target{
    void request();
}
class Adaptee{
    public void specialRequest(){
        System.out.println("特殊的请求");
    }
}
class Adapter implements Target{
    private Adaptee adaptee = new Adaptee();
    @Override
    public void request() {
        adaptee.specialRequest();
    }
}

/**
 * 类适配器适配器通过继承目标接口和被适配对象实现适配器功能
 * @author Pickled
 * @version V1.0
 * @date 2022/6/20 11:12
 */
public class ClassAdapter {
    public static void main(String[] args) {
        final adapter adapter = new adapter();
        adapter.request();
    }
}
class adaptee{
    public void request(){
        System.out.println("Special Request");
    }
}
interface target{
    void reqeust();
}
class adapter extends adaptee implements target{
    @Override
    public void reqeust() {
        this.request();
    }
}

优点

• 可以复用
• 可扩展

缺点

过多使用会让系统十分凌乱

本质

转换匹配，复用功能

装饰者模式

结构型模式

既继承又组合

/**
 * @author Pickled
 * @version V1.0
 * @date 2022/6/20 15:08
 */
public class decorator {
    public static void main(String[] args) {
        final Man man = new Man();
        final clothes clothes = new clothes();
        final Pants pants = new Pants();
        clothes.setPerson(man);
        pants.setPerson(clothes);
        pants.operation();
    }
}
interface Person{
    void operation();
}
class Man implements Person{
    @Override
    public void operation() {
        System.out.println("男人");
    }
}
class Woman implements Person{
    @Override
    public void operation() {
        System.out.println("女人");
    }
}
abstract class ada1 implements Person{
    protected Person person;

    public void setPerson(Person person) {
        this.person = person;
    }

    @Override
    public void operation() {
        person.operation();
    }
}
class clothes extends ada1{
    @Override
    public void operation() {
        super.operation();
        System.out.println("穿上衣服");
    }
}
class Pants extends ada1{
    @Override
    public void operation() {
        super.operation();
        System.out.println("穿上裤子");
    }
}

优点：比继承更加灵活

​ 可以创造出多种不同行为的组合

缺点：会产生很多细粒度对象

访问者模式-行为型模式

行为型模式

在被访问者的类里面添加一个对外提供接受访问者的接口。

核心就是在被访问者的里面添加一个接受访问者的接口，然后传入this，在访问者里面编写访问相关类型的逻辑函数

import java.util.ArrayList;
import java.util.List;

/**
 * @author Pickled
 * @version V1.0
 * @date 2022/6/20 16:15
 */
public class Visitor {
    public static void main(String[] args) {
        final ConcreteElementA concreteElementA = new ConcreteElementA();
        final ConcreteElementB concreteElementB = new ConcreteElementB();
        final ConcreteVisitorA concreteVisitorA = new ConcreteVisitorA();
        final ObjectStructure objectStructure = new ObjectStructure();
        objectStructure.Attach(concreteElementA);
        objectStructure.Attach(concreteElementB);
        objectStructure.Accept(concreteVisitorA);
    }
}
interface VIS{
    void operationA(ConcreteElementA a);
    void operationB(ConcreteElementB b);
}
class ConcreteVisitorA implements VIS{
    @Override
    public void operationA(ConcreteElementA a) {
        System.out.println(this.getClass().getSimpleName() + "访问了" + a.getClass().getSimpleName());
    }

    @Override
    public void operationB(ConcreteElementB b) {
        System.out.println(this.getClass().getSimpleName() + "访问了" + b.getClass().getSimpleName());
    }
}
class ConcreteVisitorB implements VIS{
    @Override
    public void operationA(ConcreteElementA a) {
        System.out.println(this.getClass().getSimpleName() + "访问了" + a.getClass().getSimpleName());
    }
    @Override
    public void operationB(ConcreteElementB b) {
        System.out.println(this.getClass().getSimpleName() + "访问了" + b.getClass().getSimpleName());
    }
}
interface Element{
    void accept(VIS visitor);
}
class ConcreteElementA implements Element{
    @Override
    public void accept(VIS v) {
        v.operationA(this);
    }
}
class ConcreteElementB implements Element{
    @Override
    public void accept(VIS v) {
        v.operationB(this);
    }
}
class ObjectStructure{
    private List<Element> list = new ArrayList<>();
    public void Detach(Element element){
        list.remove(element);
    }
    public void Attach(Element element){
        list.add(element);
    }
    public void Accept(VIS vis){
        for (Element e :
                list) {
            e.accept(vis);
        }
    }
}

优点：增加新的操作相对容易

缺点：增加新的元素困难

​ 破环封装

桥接模式-结构型模式

public class Bridge {
	public static void main(String[] args) {
		Red red = new Red();
		Blue blue = new Blue();
		Rectangle rectangle = new Rectangle();
		rectangle.setColor(blue);
		rectangle.display();
		Triangle triangle = new Triangle();
		triangle.setColor(red);
		triangle.display();
	}
}
interface Color{
	void show();
}
abstract class Shape{
	protected Color color;
	public void setColor(Color color) {
		this.color = color;
	}
    abstract void display();
}
class Rectangle extends Shape{
	protected Color color;
	public void setColor(Color color) {
		this.color = color;
	}
	@Override
	public void display() {
		// TODO Auto-generated method stub
		color.show();
		System.out.println("I'm a Rectangle");
	}
	
}
class Triangle extends Shape{
	protected Color color;
	public void setColor(Color color) {
		this.color = color;
	}
	@Override
	public void display() {
		// TODO Auto-generated method stub
		color.show();
		System.out.println("I'm a Triangle");
	}
	
}
class Red implements Color{

	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("I'm a Red");
	}
}
class Blue implements Color{
	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("I'm a Blue");
	}	
}

组合模式-结构型模式

• 透明组合模式
• 安全组合模式
• 优点：清楚的定义各层次复杂的对象。简化客户端，符合开闭原则。
• 缺点：限制类型时会比较复杂，设计变得更加抽象。

//透明组合模式
import java.util.ArrayList;
import java.util.List;

public class Demo1 {
	public static void main(String[] args) {
		ShuZhi root = new ShuZhi("root");
		Leaf leaf = new Leaf("A");
		root.addChild(leaf);
		ShuZhi shuZhi = new ShuZhi("B");
		shuZhi.addChild(leaf);
		root.addChild(shuZhi);
		String string = root.operation();
		System.out.println(string);
	}
}
abstract class JieDian{
	protected String name;
	public JieDian(String name) {
		this.name = name;
	}
	public abstract String operation();
	public boolean addChild(JieDian jieDian) {
		throw new UnsupportedOperationException("addChild not supported!");
	}
	public boolean removeChild(JieDian jieDian) {
		throw new UnsupportedOperationException("removeChild not supported!");
	}
	public JieDian getChild(int index) {
		throw new UnsupportedOperationException("getChild not supported!");
	}
}
 class ShuZhi extends JieDian{
	 private  List<JieDian> list;
	public ShuZhi(String name) {
		super(name);
		list = new ArrayList<JieDian>();
		// TODO Auto-generated constructor stub
	}

	@Override
	public String operation() {
		// TODO Auto-generated method stub
		StringBuilder builder = new StringBuilder();
		builder.append(this.name);
		for (JieDian jieDian : list) {
			builder.append("\n");
			builder.append(jieDian.operation());
		}
		return builder.toString();
	}
	public boolean addChild(JieDian jieDian) {
		return list.add(jieDian);
	}
	public boolean removeChild(JieDian jieDian) {
		return list.remove(jieDian);
	}
	public JieDian getChild(int index) {
		return list.get(index);
	}
}
 class Leaf extends JieDian{

	public Leaf(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}

	@Override
	public String operation() {
		// TODO Auto-generated method stub
		return this.name;
	}
	 
 }

备忘录模式-行为型模式

• 优点：可以支持撤回操作
• 缺点：占用资源，浪费资源

public class Memento {
	public static void main(String[] args) {
		Originator originator = new Originator();
		System.out.println(originator);
		IRecord record = originator.save();
		CareTaker careTaker = new CareTaker();
		careTaker.setRecord(record);
		originator.setX(100);
		System.out.println(originator);
		originator.reload(careTaker.getRecord());
		System.out.println(originator);
	}
}
interface IRecord{
	
}
class CareTaker{
	private IRecord record;
	public IRecord getRecord() {
		return this.record;
	}
	public void setRecord(IRecord record) {
		this.record = record;
	}
}
class Originator{
	
	@Override
	public String toString() {
		return "Originator [lable=" + lable + ", x=" + x + ", y=" + y + "]";
	}
	private String lable;
	private int x;
	private int y;
	public String getLable() {
		return lable;
	}
	public void setLable(String lable) {
		this.lable = lable;
	}
	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		this.y = y;
	}
	public IRecord save() {
		return new Record(this.lable,this.x,this.y);
	}
	public void reload(IRecord record) {
		this.lable = ((Record)record).lable;
		this.x = ((Record)record).x;
		this.y = ((Record)record).y;
	}
	static class Record implements IRecord{
		private String lable;
		private int x;
		private int y;
		private Record(String lable,int x,int y) {
			this.lable = lable;
			this.x = x;
			this.y = y;
		}
	}
}

装饰者模式-结构型模式

• 优点：是继承的有力补充，比继承灵活，可以动态的给一个对象扩展功能；完全遵守开放封闭原则
• 缺点：出现很多的代码，类以及对象，增加程序的复杂程度。

public class Decorator {
	public static void main(String[] args) {
		ConcretePerson concretePerson = new ConcretePerson();
		Clothes clothes = new Clothes(concretePerson);
		Clothes clothes2 = new Clothes(clothes);
		clothes2.operation();
		Pants pants = new Pants(clothes2);
		pants.operation();
	}
}
interface Person{
	void operation();
}
class ConcretePerson implements Person{

	@Override
	public void operation() {
		// TODO Auto-generated method stub
		System.out.println("我是一个人");
	}
}
abstract class FuShi implements Person{

	private Person person;
	public FuShi(Person person) {
		this.person = person;
	}
	public void operation() {
		// TODO Auto-generated method stub
		person.operation();
	}
}
class Clothes extends FuShi{

	public Clothes(Person person) {
		super(person);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void operation() {
		// TODO Auto-generated method stub
		super.operation();
		System.out.println("穿了衣服");
	}
	
}
class Pants extends FuShi{
	
	public Pants(Person person) {
		super(person);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void operation() {
		// TODO Auto-generated method stub
		super.operation();
		System.out.println("穿了裤子");
	}
	
}

代理模式

• 优点：保护目标对象的同时增强了目标对象。实现了代理对象与真实被调用目标分离。降低了耦合性，扩展性好。
• 缺点：增加了访问时间。增加了系统的复杂程度。

public class Proxy {
	public static void main(String[] args) {
		RealSubject subject = new RealSubject();
		Daili daili = new Daili(subject);
		daili.request();
	}
}
interface ISubject{
	void request();
}
class RealSubject implements ISubject{

	@Override
	public void request() {
		// TODO Auto-generated method stub
		System.out.println("发送请求");
	}
}
class Daili implements ISubject{

	private ISubject subject;
	public Daili(ISubject subject) {
		// TODO Auto-generated constructor stub
		this.subject = subject;
	}
	public void before() {
		System.out.println("建立连接");
	}
	@Override
	public void request() {
		// TODO Auto-generated method stub
		before();
		subject.request();
		after();
	}
	public void after() {
		System.out.println("关闭连接");
	}
}

建造者模式

• 优点：封装性好，构建与表示分离。便于控制细节
• 缺点：修改产品会破坏开放封闭原则，后期维护成本较大

public class Demo2 {
	public static void main(String[] args) {
		Director director = new Director(new ConcreteBuilder(new Product()));
		Product construct = director.construct();
		System.out.println(construct);
	}
}
class Product{
	private String partA;
	private String partB;
	private String partC;
	public String getPartA() {
		return partA;
	}
	public void setPartA(String partA) {
		this.partA = partA;
	}
	public String getPartB() {
		return partB;
	}
	public void setPartB(String partB) {
		this.partB = partB;
	}
	public String getPartC() {
		return partC;
	}
	public void setPartC(String partC) {
		this.partC = partC;
	}
	@Override
	public String toString() {
		return "Product [partA=" + partA + ", partB=" + partB + ", partC=" + partC + "]";
	}
}
abstract class Builder{
	protected Product product;
	public Builder(Product product) {
		// TODO Auto-generated constructor stub
		this.product = product;
	}
	
	public abstract void builderA();
	public abstract void builderB();
	public abstract void builderC();
	public Product getResult() {
		return product;
	}
}
class ConcreteBuilder extends Builder{

	public ConcreteBuilder(Product product) {
		super(product);
		// TODO Auto-generated constructor stub
	}
	@Override
	public void builderA() {
		// TODO Auto-generated method stub
		product.setPartA("建造PartA");
	}
	@Override
	public void builderB() {
		// TODO Auto-generated method stub
		product.setPartB("建造PartB");
		
	}

	@Override
	public void builderC() {
		// TODO Auto-generated method stub
		product.setPartC("建造PartC");
		
	}
}
class Director{
	private Builder concreBuilder;
	public Director(Builder builder) {
		this.concreBuilder = builder;
	}
	public Product construct() {
		concreBuilder.builderA();
		concreBuilder.builderB();
		concreBuilder.builderC();
		return concreBuilder.getResult();
	}
}

🐟