设计模式
创建者模式（帮我们创建对象）：
单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式
结构型模式：
适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式
行为型模式：
模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式
创建者模式：
建一个鼠标，汽车，电脑，生产环境都不一样，所以创建者模式多种多样。
单例模式：
保证一个类只有一个实例。并且提供一个访问该实例的全局访问点（提供一个方法来访问这个对象）。
应用场景：
- 数据库连接池的设计采用的就是单例。
- 在Spring中的bean默认就是单例的，方便Spring容器管理。
- 每个Servlet也是单例的。
- 项目中读取配置文件的类也是单例，没有必要一直new去读。
优点：
对于创建对象耗费性能的实例，使用单例，减少系统性能开销，应用启动时直接产生一个单例对象，永久驻留内存。
创建单例模式的实现方式：
饿汉式：
线程安全，调用效率高，但是不能延时加载
public class SingletonDemo{
//立即加载，线程安全
private static SingletonDemo instance = new SinletonDemo();
private SingletonDemo(){
}
//没有同步锁效率高
public static SingletonDemo getInstance(){
return instance;
}
}
}
懒汉式：
延迟加载，真正用的时候才加载。
线程安全，调用效率不高。
资源利用率高，但是每次调用getInstance方法，都需要同步，并发效率低。
为什么需要同步：线程A if判断后挂起，线程B进入创建，线程A恢复后又创建
public class SingletonDemo{
private static SingletonDemo s;
private SingletonDemo(){
}
public static synchronized SingletonDemo getInstance(){
if(s==null){
s=new SingletonDemo();
}
return s;
}
}
双重检测锁实现
问题：由于编译器优化和jvm底层内部模型的原因，偶尔会出问题，因此不支持。
与懒汉式的区别：
懒汉式是在方法上加锁，双重检测锁实现是在if内部，不必每次获得对象都同步，只有第一次会同步。
静态内部类实现：
单例模式的理想状态：线程安全，效率高，延时加载。（静态内部类都可以实现）
public class SingletonDemo{
private SingletonDemo(){}
private static class GetSingletonDemo{
private static SingletonDemo instance =new SingletonDemo();
}
public static SingletonDemo getInstance(){
return GetSingletonDemo.instance;
}
}
枚举实现单例模式
比静态内部类更简单，枚举天然就是单例。
优点：实现简单，枚举本身就是单例，由jvm从根本上提供保障，避免通过反射和反序列化的漏洞
缺点：无延迟加载
public enum SingletonDemo{
INSTANCE;
public void singletonOperation(){
}
}
反射漏洞：
public class client{
psvm(){
Class<SingletonDemo> clazz=(Class<SingletonDemo>)Class.forName("类路径");
Constructor<SingletonDemo> c =clazz.getDeclaredConstructor(null);
//由于我们的单例都是私有化的，如果想访问私有成员，跳过权限检查。
c.setAccessible(true);
//获得的不是单例
SingletonDemo s3 = c.newInstance();
SingletonDemo s4= c.newInstance();
}}
解决办法
序列化漏洞
创建对象的方式
new，反射，序列化
public class client{
psvm(){
//要把这两个对象序列化到磁盘，然后反序列化回来
SingletonDemo s1=SingletonDemo.getInstance();
SingletonDemo s2=SingletonDemo.getInstance();
FileOutputStream fos =new FIleOutputStream("d:/a.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.write(s1);
oos.close();
fos.close();
ObjectInputStream ois =new ObjectInputStream(new FileInputStream("d:/a.txt"));
SingletonDemo s3=(SingletonDemo) ois.readObject();
//反序列出来是一个新的对象。
sout(s3);
}
}
解决办法：
在单例类中
反序列化时，直接返回之前的实例
工厂模式
实现了创建者和调用者的分离
分为：简单工厂模式、工厂方法模式、抽象工厂模式
核心本质：
实例化对象，用工厂方法代替new操作
将选择实现类、创建对象统 一管理和控制，从而将调用者跟我们的实现类解耦
简单工厂模式：
用来生产同一等级结构中的固定产品（对于增加的新的产品，需要修改已有代码）
public interface Car(){
void run();
}
public class Aodi implement car{
void run(){
sout(”aodi“);
}}
public class Byd implement car{
void run(){
sout(”byd“);
}}
//不使用工厂模式
public class client{
psvm(){
//不使用工厂模式，客户端（调用者）需要知道car，Aodi，Byd，依赖接口，依赖两个实现类。
Car c1=new Aodi();
Car c2=new Byd();
c1.run();
c2.run();
}}
//使用简单工厂模式，Factory就是调用者。
public class CarFactory{
public static Car createCar(String type){
if("奥迪".equals(type)){
return new Aodi();
}else if("比亚迪".equals(type)){
return new Byd();
}else{
return null;
}}}
public class Client2{
psvm(){
Car c1 =new CarFactory.createCar("奥迪");
Car c1 =new CarFactory.createCar("比亚迪");
}
}
简单工厂也可以称为静态工厂Factory类中使用静态方法
工厂方法模式
为了避免简单工厂无法满足OCP原则（开闭原则）的缺点。
增加一种品牌车需要在简单工厂的工厂类下增加代码
public interface Car(){
void run();
}
public class Aodi implement car{
void run(){
sout(”aodi“);
}}
public class Byd implement car{
void run(){
sout(”byd“);
}}
public interface CarFactory{
Car createCar();
}
public class AodiFactory implements CarFactory{
Car createCar(){
return new Aodi();
}
}
public class BydFactory implements CarFactory{
Car createCar(){
return new Byd();
}
}
public class Client{
psvm(){
Car c1= new AudiFactory.createCar();
Car c1= new BydFactory.createCar();
}
}
工厂方法和简单工厂方法区别：
工厂方法相对于简单工厂代码更多，依赖关系更复杂。但是工厂方法解决了简单工厂开闭原则。
抽象工厂模式
使用场景：创建一个实现多个接口的子类。
一个汽车需要发动机、轮胎、座椅，创建这样的类需要用到抽象工厂模式，如果创建一个发动机使用普通工厂/动态工厂。
client依赖carFactory接口（创建发动机、座椅、轮胎）
//发动机
public interface Engine{
void run();
void start();
}
class LuxuryEngine implements Engine{
public void run(){
sout("跑得快");
}
public void start(){
sout("自动挡");
}
}
class LowEngine implements Engine{
public void run(){
sout("跑得慢");
}
public void start(){
sout("手动挡");
}
}
//座椅
public interface Seat{
void massage();
}
class LuxurySeat implements Seat{
public void massage(){
sout("可以按摩");
}
}
class LowSeat implements Seat{
public void massage(){
sout("不可以按摩");
}
}
//轮胎
public interface Tyre{
void revolve();
}
class LuxuryTyre implements Tyre{
public void massage(){
sout("旋转磨损慢");
}
}
class LowTyre implements Tyre{
public void massage(){
sout("旋转磨损快");
}
}
public interface CarFactory{
Engine createEngine;
Seat createSeat;
Tyre createTyre;
}
public class LuxuryCarFactory implements CarFactory{
public Engine createEngine(){
return new LuxuryEngine();
}
public Seat createEngine(){
return new LuxuryEngine();
}
public Tyre createEngine(){
return new LuxuryEngine();
}
}
public class LowCarFactory implements CarFactory{
public Engine createEngine(){
return new LowEngine();
}
public Seat createEngine(){
return new LowEngine();
}
public Tyre createEngine(){
return new Low
Engine();
}
}
public class client{
psvm{
CarFactory LuxuryCar =new LuxuryCarFactory();
Engine e=LuxuryCar.createEngine();
e.run();
e.start();
}
}
更多推荐
设计模式（单例、工厂）
发布评论