23种设计模式（自学笔记）

---

创建型模式：关注对象的创建过程
结构型模式：关注对象和类的组织
行为型模式：关注系统中对象之间的相互交互，研究系统在运行时对象之间的相互通信和协作

创建型模式

单例模式

最大特定：私有构造器，只能存在一个对象。
在类内已经生成一个对象，提供getInstance方法获取对象。
分为 饿汉式，懒汉式，枚举式，静态内部类。
主要列举饿汉式和懒汉式：
区别在于：饿汉式在提供的类已经事先new好了对象，这样在调用的时候就效率高，缺点就是可能会浪费资源，因为如果不用用到，而调用又很耗费内存，这样就造成了浪费资源。
懒汉式一开始不创建对象，在用户调用getInstance的时候才new对象，优点就是不会浪费资源，缺点就是用户在使用的时候需要等待创建，而且会出现多个用户同时调用此方法，可能会生成多个对象，因此需要加入锁来防止并发出错。
饿汉式代码：

/**
 * 测试饿汉式单例模式      线程安全    调用效率高   缺点是可能会浪费资源
 * 占用资源少，不需要延时加载时，枚举式比它好
 * @author Little Black
 *
 */
public class SingletonDemo01 {
   

	private static SingletonDemo01 instance = new SingletonDemo01();//类初始化时立即加载，new对象，饿汉式
	//如果建立的时候非常麻烦，则缓存式建立对象会比较好  （没有延时加载的优势）
	
	private SingletonDemo01() {
   
		
	}
	
	public static SingletonDemo01 getInstance() {
   
		return instance;  //不管怎么样，返回的都是第一次建立的对象
	}
}

懒汉式：

/**
 * 测试懒汉式  不直接new对象 延时加载   优点就是没有浪费资源  调用效率不高
 *  占用资源多，需要延时加载时，静态内部类式比它好
 * @author Little Black
 *
 */
public class SingletonDemo02 {
   
	
    private static SingletonDemo02 instance;  //不初始化，延时加载，真正用的时候再创建
    
    private SingletonDemo02() {
     //私有构造器
    	
    }
    
    //防止并发出错，加入锁
    public static synchronized SingletonDemo02 getInstance() {
   
    	if(instance == null )            //在用的时候开始创建，效率低，要等待
    		instance = new SingletonDemo02();
    	return instance;
    }
}

用户调用时不管创建多少个对象，内存里面永远都指向同一个内存地址，也就是同一个对象

public class Client {
   
	
	public static void main(String[] args) {
   
		SingletonDemo01 s1= SingletonDemo01.getInstance();
		SingletonDemo01 s2= SingletonDemo01.getInstance();

		System.out.println(s1);
		System.out.println(s2);  //单例模式，对象是同一个
	}
}

要实现创建多个对象有两种方法：
1.反射出对象，越过构造器的私有权限，构造新对象

	c.setAccessible(true);  //跳过权限检测调用到私有的构造器

解决方法：
在构造器方法中加入代码：

    private SingletonDemo03() {
     //私有构造器
    	if(instance!=null) {
   
    		throw new RuntimeException();  //处理反射破解
    	}
    }

2.反序列化：利用io流把对象写入文件，读取的时候用一个新对象接收内容

		//2.通过反序列化方式构造多个对象
		FileOutputStream fos = new FileOutputStream("d:/a.txt");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(s1);
		oos.close();   //把对象内容写入到文件中
		
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/a.txt"));
		SingletonDemo03 s5 = (SingletonDemo03)ois.readObject();  //把文件内容读取到新对象内
		
		System.out.println(s5);  //反序列化成功破解单例，生成了新的对象
		

解决方法：加入readResolve方法，发现有反序列化的情况就直接返回原对象

   //处理反序列化
    private Object readResolve() throws ObjectStreamException {
   
    	return instance;  //反序列化时直接调用这个方法，返回原对象，不用生成新对象
    }

工厂模式

• 面向对象设计的基本原则：
• OCP 扩展开放，修改关闭
• DIP 针对接口编程，不要针对实现编程
• loD 只与自己人通信

简单工厂模式

写一个car接口，创建两个不同车型的车class接上car接口
创建一个carFactory类：

//有工厂模式的话 这个不好增加新的子类，只能加入代码增加新的调用方法，违反了开闭原则
public  class CarFactory {
   
	
	public static Car createCar(String type) {
   
		if("奥迪".equals(type))
			return new Audi();
		else if("比亚迪".equals(type))
			return new Biyadi();
		else {
   
			return null;
		}
	}
}

这样用户在创建车的时候只需要传车名就可以创建出车

//简单工厂模式的情况下,只需要知道carfactory 和接口的方法 
//对调用者来说简单了
public class Demo2 {
    //调用者

	public static void main(String[] args) {
   

		Car c1 =CarFactory.createCar("奥迪");   //调用工厂，不用知道实现类
		Car c2 =CarFactory.createCar("比亚迪");

		c1.run();
		c2.run();

	}
}

弊端：加入车型的话就要修改车厂类，加入新的if判断，违反了设计原则

工厂方法模式

不再只有一个工厂，每一种车都有一个车厂，都继承carFactory的接口，车厂内的方法就是创建车。
这样有新的车型的话直接设置新的车厂然后继承carFactory接口即可。
用户使用方法：

//满足了设计模式的开闭原则，缺点就是类太多复杂，一般还是简单工厂模式
public class Client {
   
	public static void main(String[] args) {
   
		//扩展的时候更符合OCP原则，不用修改代码，直接加新的工厂类
		Car c1 = new AudiFactory().createCar();
		Car c2 = new BiyadiFactory().createCar();
		
		c1.run();
		c2.run();
	}
}

抽象工厂模式

使用情况是：不同对象有不同的零件需要创建
设置各种零件的接口，然后设置不同等级的类继承其零件接口，得到不同等级的零件
设置carFactory工厂接口，设置不同的零件的创建方法
设置不同车型的类继承carFactory接口，重载new不同等级的零件，例如：

//高端汽车的接口就创建高端汽车的零件  对接汽车工厂
public class LuxuryCarFactory implements CarFactory {
   


	public Engine createEngine() {
   
	return new LuxuryEngine();
}

	public Seat createSeat() {
   
	return new LuxurySeat();
	}

		public Tyre createTyre() {
   
		return new LuxuryTyre();
		}
}

用户使用的时候只需要指定车型的车厂，就会创建里面设置好的等级的零件

public class Client {
   
	
	public static void main(String[] args) {
   
		//好车
		CarFactory factory1 = new LuxuryCarFactory();
		CarFactory factory2 = new LowCarFactory();
	}
}

建造者模式

例如飞机等对象，需要先构建不同的零件，然后再拿出来装配，这就需要建造者模式。
这个模式是对构建者Builder和装配者Directory的分离

先设置好飞机对象，里面写需要的零件对象：

/**
 * 宇宙飞船 
 * //建造复杂的产品，如手机，如果构建的对象也非常复杂时，则需要建造者模式，对对象子组件的单独构造（Builder）和装配（Director）

 * @author Little Black
 *
 */
public class AirShip {
   
	private OrbitalModule orbitalModule;  //轨道舱
	private Engine engine;  //发动机
	private EscapeTower escapeTower; //逃逸塔
	
	public static void launch() {
   
		System.out.println("发射！");
		
	}
}

当然，零件对象也需要创建，并getset属性

然后设置构建者的接口，分别构建零件方法，设置装配者接口，设置装配方法

public interface AriShipBuilder {
   
	Engine builderEngine();

	OrbitalModule builderOrbitalModule();

	EscapeTower builderEscapeTower();

}

public interface AriShipDirector {
   
		AirShip createAirShip();  //组装飞船对象
}

然后设置飞机的构建者类，里面的方法可以构建不同需要的零件：

//构建者构建需要的零件
public class JJ_AirShipBuilder implements AriShipBuilder {
   
	@Override
	public Engine builderEngine() {
   
		System.out.println("构建发动机");
		return new Engine("JJ牌发动机");
	}
	@Override
	public EscapeTower builderEscapeTower() {
   
		System.out.println("构建逃逸塔");
		return new EscapeTower("JJ牌逃逸塔");
	}
	@Override
	public OrbitalModule builderOrbitalModule() {
   
		System.out.println("构建轨道舱");
		return new OrbitalModule("JJ牌轨道舱");		 
	}
}

设置装配者的类继承装配者的接口：
装配者首先需要获取构建者类对象，获取到对应零件
然后在创建飞机的方法中：
设置一个飞机对象，把构建者的零件都装配到这个对象内，返回这个飞机对象

//装配者，需要导入构建者构建好的零件，然后进行组装
public class JJ_AirShipDirector implements AriShipDirector{
   
	
	private AriShipBuilder builder;

	public JJ_AirShipDirector(AriShipBuilder builder) {
   
		super();
		this.builder = builder;
	}

	public AirShip createAirShip() {
   
		
		//构建飞机，调用构建者对象的零件，开始构建需要的零件
		Engine e = builder.builderEngine();
		OrbitalModule o = builder.builderOrbitalModule();
		EscapeTower et = builder.builderEscapeTower();
		
		//开始装配成飞机对象
		AirShip ship = new AirShip();
		ship.setEngine(e);
		ship.setEscapeTower(et);
		ship.setOrbitalModule(o);
		
		return ship;
	}
}

用户使用ÿ