1.设计模式（第1-10种）_1. 设计模式-CSDN博客

本文链接：https://blog.csdn.net/qq_42796729/article/details/127221731

设计模式的分类
总体来说设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

1.单例模式

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

//	（1）懒汉式 
class Singleton {
	/* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */ 
	private static Singleton instance = null;
	/* 私有构造方法，防止被实例化 */
	private Singleton() {
	}
	/* 1:懒汉式，静态工程方法，创建实例 */ 
	public static Singleton getInstance() { if (instance == null) { 
		instance= new Singleton();
	}
	return instance;
	}
}
//     （2）饿汉式
class Singletone {
	/* 持有私有静态实例，防止被引用 */
	private static  Singletone instancee = new Singletone();
	/* 私有构造方法，防止被实例化 */
	private Singletone() {
	}
	/* 1:懒汉式，静态工程方法，创建实例 */ public static Singleton getInstancee() {
		return instancee;
	}
}

使用场景：

要求生成唯一序列号的环境；
在整个项目中需要一个共享访问点或共享数据，例如一个Web页面上的计数器，可以不用把每次刷新都记录到数据库中，使用单例模式保持计数器的值，并确保是线程安全的；
创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源；
需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式（当然，也可以直接声明为static的方式）。

2.工厂模式

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

接口
public interface Fruit {
    public void print(); 
}

2个实现类
public class Apple implements Fruit{
	@Override
	public void print() {
	S	ystem.out.println("我是一个苹果");
	}
}
public class Orange implements Fruit{
	@Override
	public void print() {
		System.out.println("我是一个橘子");
	}
}
工厂类
public class FruitFactory {
	public Fruit produce(String type){
		if(type.equals("apple")){
			return new Apple();
		}else if(type.equals("orange")){
			return new Orange();
		}else{
			System.out.println("请输入正确的类型!");
			return null;
		}
	}
}

使用场景：jdbc连接数据库，硬件访问，降低对象的产生和销毁

3.抽象工厂模式

为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。

相对于工厂模式，我们可以新增产品类（只需要实现产品接口），只需要同时新增一个工厂类，客户端就可以轻松调用新产品的代码。

interface food {
}
class A implements food {
}
class B implements food {
}
interface produce {
	food get();
}
class FactoryForA implements produce {
	@Override
	public food get() {
		return new A();
	}
}
class FactoryForB implements produce {
	@Override
	public food get() {
		return new B();
	}
}
public class AbstractFactory {
	public void ClientCode(String name) {
		food x = new FactoryForA().get();
		x = new FactoryForB().get();
	}
}

使用场景：一个对象族（或是一组没有任何关系的对象）都有相同的约束。涉及不同操作系统的时候，都可以考虑使用抽象工厂模式

4.建造者模式

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

public class Build {
	static class Student {
		String name = null;
		int number = -1;
		String sex = null;
		public Student(Builder builder) {
			this.name = builder.name;
			this.number = builder.number;
			this.sex = builder.sex;
		}
		static class Builder {
			String name = null;
			int number = -1;
			String sex = null;
			public Builder setName(String name) {
				this.name = name;
				return this;
			}
			public Builder setNumber(int number) {
				this.number = number;
				return this;
			}
			public Builder setSex(String sex) {
				this.sex = sex;
				return this;
			}
			public Student build() {
				return new Student(this);
			}
		}
	}
	public static void main(String[] args) {
		Student A=new Student.Builder().setName("张 三")
				.setNumber(1).build(); 
		Student B=new Student.Builder().setSex("男")
				.setName("李四").build();
		System.out.println(A.name+" "+A.number+" "+A.sex); 
		System.out.println(B.name+" "+B.number+" "+B.sex);
	}
}

使用场景：

1. 相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式。
2. 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式。
3. 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常合适。

5.原型模式

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

public class Test implements Cloneable {
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	protected Object clone() {
		try {
			return super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
			return null;
		} 
	}
	public static void main(String[] args) {
		Test pro = new Test();
		pro.setName("wuli");
		Test pro1 = (Test) pro.clone();//深拷贝
		Test pro2 = (Test) pro1;//浅拷贝
		System.out.println(pro);
		System.out.println(pro1);
		System.out.println(pro2);
		System.out.println(pro.getName());
		System.out.println(pro1.getName());
		System.out.println(pro2.getName());
	}

    /**
    输出
        com.Test@1494fbf
        com.Test@1dc4ec2
        com.Test@1dc4ec2
        wuli
        wuli
        wuli
    */
}

原型模式实际上就是实现Cloneable接口，重写clone（）方法。
使用原型模式的优点：
- 1.性能优良
  - 原型模式是在内存二进制流的拷贝，要比直接new一个对象性能好很多，特别是要在一个循环体内产生大量的对象时，原型模式可以更好地体现其优点。
- 2.逃避构造函数的约束
  - 这既是它的优点也是缺点，直接在内存中拷贝，构造函数是不会执行的（参见 13.4节）。
使用场景：
- 资源优化场景类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
- 性能和安全要求的场景通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
- 一个对象多个修改者的场景一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
浅拷贝和深拷贝：浅拷贝拷贝地址，深拷贝拷贝变量自己有地址
- 浅拷贝：Object类提供的方法clone只是拷贝本对象，其对象内部的数组、引用对象等都不拷贝，还是指向原生对象的内部元素地址，这种拷贝就叫做浅拷贝，其他的原始类型比如int、long、char、string（当做是原始类型）等都会被拷贝。
  - 注意：使用原型模式时，引用的成员变量必须满足两个条件才不会被拷贝：一是类的成员变量，而不是方法内变量；二是必须是一个可变的引用对象，而不是一个原始类型或不可变对象。
- 深拷贝：对私有的类变量进行独立的拷贝如：this.arrayList = (ArrayList)this.arrayList.clone();

6.适配器模式

将一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。

在Java 代码中 service 层就是一个适配器

主要可分为3种：

1. 类适配：创建新类，继承源类，并实现新接口，例如 class adapter extends oldClass implements newFunc{}
2. 对象适配：创建新类持源类的实例，并实现新接口，例如 class adapter implements newFunc { private oldClass oldInstance ;}
3. 接口适配：创建新的抽象类实现旧接口方法。例如 abstract class adapter implements oldClassFunc { void newFunc();}

使用场景：

你有动机修改一个已经投产中的接口时，适配器模式可能是适合你的模式。比如系统扩展了，需要使用一个已有或新建立的类，但这个类又不符合系统的接口，怎么办？使用适配器模式，这也是我们例子中提到的。

7.装饰器模式

动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。

（）

interface Source {
	void method();
}
class Consum1 implements Source{

	public void method() {
		System.out.println("consum1");
	}
	
}

class Consum2 implements Source{

	public void method() {
		System.out.println("consum2");
	}
	
}

class ScoratorDecorator implements Source {
	private Source source;
	
	public ScoratorDecorator(Source source) {
        this.source = source;
    }
	
	public void method() {
		source.method();
	}
	
}

class SourceMaleDecorator extends ScoratorDecorator {

	public SourceMaleDecorator(Source source) {
		super(source);
	}
	@Override
	public void method() {
		super.method();
		this.setGender();
	}
	
	private void setGender(){
		System.out.println("Ta is male");
	}

}
public class Test {
	public static void main(String[] args) {
		SourceMaleDecorator co1 = new SourceMaleDecorator(new Consum1());
		SourceMaleDecorator co2 = new SourceMaleDecorator(new Consum2());
		
		co1.method();
        System.out.println("-------------------------");
        co2.method();
        System.out.println("-------------------------");
		
	} 
}

使用场景：

1. 需要扩展一个类的功能，或给一个类增加附加功能。
2. 需要动态地给一个对象增加功能，这些功能可以再动态地撤销。
3. 需要为一批的兄弟类进行改装或加装功能，当然是首选装饰模式。

8.代理模式

为其他对象提供一种代理以控制对这个对象的访问。

interface Source {
	void method();
}
class OldClass implements Source {
	public void method() {
		System.out.println("oldClass");
	}
}
class Proxy implements Source {
	
	private Source ce;
	void doSomething() {
	}
	
	public Proxy(Source source){
		ce = source;
	}
	
	public void method() {
		System.out.println("nima");
		ce.method();
		System.out.println("atama");
	}
}

public class Test {
    public static void main(String[] args) {
 
    	Source source = new OldClass();

    	Source proxy1 = new Proxy(source);

    	proxy1.method();
    }
}
	/*输出
		nima
		oldClass
		atama
	*/

9.中介者模式

用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

class ChatRoom {
	public static void showMessage(User user, String message) {
		System.out.println(new Date().toString() + " [" + user.getName()
				+ "] : " + message);
	}
}
class User {
	private String name;

	public String getName() {
		return name;
	}

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

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

	public void sendMessage(String message) {
		ChatRoom.showMessage(this, message);
	}
}

public class Test {
	public static void main(String[] args) {
		User robert = new User("Robert");
		User john = new User("John");

		robert.sendMessage("Hi! John!");
		john.sendMessage("Hello! Robert!");
	}
}

//Sun Oct 09 11:49:58 CST 2022 [Robert] : Hi! John!
//Sun Oct 09 11:49:58 CST 2022 [John] : Hello! Robert!

使用场景： 中介者模式适用于多个对象之间紧密耦合的情况，紧密耦合的标准是：在类图中出现了蜘蛛网状结构，即每个类都与其他的类有直接的联系

10.命令模式

将一个请求封装成一个对象，从而让你使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能。

Receiver接受者角色：该角色就是干活的角色，命令传递到这里是应该被执行的

Command命令角色：需要执行的所有命令都在这里声明

Invoker调用者角色：接收到命令，并执行命令

//通用Receiver类
abstract class Receiver {
	public abstract void doSomething();
}
//具体Receiver类
class ConcreteReciver1 extends Receiver{
	//每个接收者都必须处理一定的业务逻辑
	public void doSomething(){ 
		System.out.println("ConcreteReciver1");
	}
}
class ConcreteReciver2 extends Receiver{
	//每个接收者都必须处理一定的业务逻辑
	public void doSomething(){
		System.out.println("ConcreteReciver2");
	}
}
//抽象Command类 
abstract class Command {
	public abstract void execute();
}
//具体的Command类
class ConcreteCommand1 extends Command {
	//对哪个Receiver类进行命令处理
	private Receiver receiver;
		//构造函数传递接收者
		public ConcreteCommand1(Receiver _receiver){
		this.receiver = _receiver;
	}
	//必须实现一个命令
	public void execute() {
		//业务处理
		this.receiver.doSomething();
	}
}
class ConcreteCommand2 extends Command {
	//哪个Receiver类进行命令处理
	private Receiver receiver;
	//构造函数传递接收者
	public ConcreteCommand2(Receiver _receiver){
		this.receiver = _receiver;
	}
	//必须实现一个命令
	public void execute() {
		//业务处理
		this.receiver.doSomething();
	}
}
//调用者Invoker类 
class Invoker {
	private Command command;
	public void setCommand(Command _command){
		this.command = _command;
	}
	public void action() {
		this.command.execute();
	}
}
//场景类
public class Test {
	public static void main(String[] args){
		Invoker invoker = new Invoker();
		Receiver receiver = new ConcreteReciver1();
		Command command = new ConcreteCommand1(receiver); 
		invoker.setCommand(command);
		invoker.action();
	}
}

//ConcreteReciver1

使用场景： 认为是命令的地方就可以采用命令模式，例如，在GUI开发中，一个按钮的点击是一个命令，可以采用命令模式；模拟DOS命令的时候，当然也要采用命令模式；触发－反馈机制的处理等。