1单例模式
定义:保证一个类仅有一个实例,并提供一个访问它的全局访问点
1.1单例模式的写法
1.1.1饿汉模式
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton() {
}
public static Singleton getInstance() {
return instance
}
}
这种在类加载时就完成了初始化,所以类加载慢,但是获取对象速度快,避免了线程同步问题,在类加载时候完成实例化,但是如果一直没有用过的话,就会造成内存浪费。
1.1.2 懒汉模式
public class Singleton {
private static Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
在用户第一次调用时候初始化。虽然节约资源但是需要实例化,可能比较慢,在多线程时候不能保证现场安全,如果需要线程安全
public class Singleton {
private static Singleton instance;
private Singleton() {
}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
1.1.3双重检查模式
public class Singleton {
private static volatile Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
instance = new Singleton();
}
}
return instance;
}
}
这种写法进行了两次判断,这个是推荐的写法,资源利用率高,只有在第一次执行的时候才会被实例化。且加入线程安全机制
1.1.4 静态内部单例模式
public class Singleton {
private static volatile Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
return SingletonHolder.mSinglton;
}
private static class SingletonHolder {
private static final Singleton mSinglton = new Singleton();
}
}
第一次加载时候不会初始化,只有第一次调用的时候才会加载并初始化内部类,这样能保证线程安全,也有唯一性
1.2 使用场景
1.2.1 一个系统需要一个同享访问点或者数据
1.2.2 创建一个对象需要耗费资源过多,比如链接数据库等
1.2.3 工具类对象
2.工厂模式
定义一个用于创建对象的接口,让子类决定通过实例化那个类去创建哪一个类,工厂方法可以使一个类实例化
我们只考虑动态工厂模式 大概代码如下
public class Computer {
}
public abstract class ComputerFactory {
public abstract <T extends Computer> T createComputer(Class<T> clz);
}
public class GDComputerFactory extends ComputerFactory {
@Override
public <T extends Computer> T createComputer(Class<T> clz) {
Computer computer = null;
String classname = clz.getName();
try {
computer = (Computer) Class.forName(classname).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return (T) computer;
}
}
public class Client {
public Client() {
GDComputerFactory gdComputerFactory = new GDComputerFactory();
PGComputer computer = (PGComputer) gdComputerFactory.createComputer(Computer.class);
}
}
3.建造者模式
3.1定义:将一个复杂的对象的构建和它的表示分离开,使得同样的构造过程可以创建不同的表示,它是创建一个复杂对象的创建者模型,能一步一步构建需要的配置。
3.2代码实现
如我现在需要生产一台电脑
先定义一个实体类
package com.example.maka.jianjiezhiguan2;
public class Computer {
private String mCpu;
private String mMainBoard;
private String mRam;
public String getmCpu() {
return mCpu;
}
public void setmCpu(String mCpu) {
this.mCpu = mCpu;
}
public String getmMainBoard() {
return mMainBoard;
}
public void setmMainBoard(String mMainBoard) {
this.mMainBoard = mMainBoard;
}
public String getmRam() {
return mRam;
}
public void setmRam(String mRam) {
this.mRam = mRam;
}
}
定义一个建造者接口
package com.example.maka.jianjiezhiguan2;
public abstract class Builder {
public abstract Builder buildCpu(String cpu);
public abstract Builder buildMainBorder(String mainBorder);
public abstract Builder buildRam(String ram);
public abstract Computer create();
}
定义具体实现
public class MoomComputerBuilder extends Builder {
private Computer mComputer = new Computer();
@Override
public Builder buildCpu(String cpu) {
mComputer.setmCpu(cpu);
return this;
}
@Override
public Builder buildMainBorder(String mainBorder) {
mComputer.setmMainBoard(mainBorder);
return this;
}
@Override
public Builder buildRam(String ram) {
mComputer.setmRam(ram);
return this;
}
@Override
public Computer create() {
return mComputer;
}
}
建造模式具体实现
public class Dirctor {
Builder mbuilder = null;
public Dirctor(Builder builder) {
mbuilder = builder;
}
public Computer createComputer(String cpu, String mainBoader, String ram) {
return mbuilder.buildCpu(cpu).buildMainBorder(mainBoader).buildRam(ram).create();
}
}
最后生产类
public class CreateComputer {
CreateComputer() {
MoomComputerBuilder moomComputerBuilder = new MoomComputerBuilder();
Dirctor dirctor = new Dirctor(moomComputerBuilder);
dirctor.createComputer("i5", "华硕", "666显卡");
}
}