Java设计模式
1.单例模式 实现
懒汉式
public class Singleton {
/* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */
private static Singleton instance = null;
/* 私有构造方法，防止被实例化 */
private Singleton() {}
/* 1:懒汉式，静态工程方法，创建实例 */
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
//优点：延迟加载（需要的时候才去加载）,适合单线程操作
//缺点： 线程不安全，在多线程中很容易出现不同步的情况，如在数据库对象进行的频繁读写操作时
双重线程检查模式
public class SingletonInner {
private static volatile SingletonInner sInst = null; //这里添加了 volatile 可见性 有序性
private SingletonInner() {}
public static SingletonInner getInstance() {
SingletonInner inst = sInst; // <<< 在这里创建临时变量
if (inst == null) {
synchronized (SingletonInner.class) {
inst = sInst;
if (inst == null) {
inst = new SingletonInner();
sInst = inst;
}
}
}
return inst; // <<< 注意这里返回的是临时变量
}
protected void method() {
System.out.println("SingletonInner");
}
}
//优点：延迟加载，线程安全
//缺点： 写法复杂，不简洁
内部类的实现
public class SingletonInner {
/**
* 内部类实现单例模式
* 延迟加载，减少内存开销
*/
private static class SingletonHolder {
private static SingletonInner instance = new SingletonInner();
}
/**
* 私有的构造函数
*/
private SingletonInner() {}
public static SingletonInner getInstance() {
return SingletonHolder.instance;
}
protected void method() {
System.out.println("SingletonInner");
}
}
//优点：延迟加载，线程安全（java中class加载时互斥的），也减少了内存消耗，推荐使用内部类方式。
Num2：工厂模式
简单工厂模式：该模式对对象创建管理方式最为简单，因为其仅仅简单的对不同类对象的创建进行了一层薄薄的封装。该模式通过向工厂传递类型来指定要创建的对象，
public interface Phone {
void make();
}
public class MiPhone implements Phone {
public MiPhone() {
this.make();
}
工厂方法模式：也就是定义一个抽象工厂，其定义了产品的生产接口，但不负责具体的产品，将生产任务交给不同的派生类工厂。这样不用通过指定类型来创建对象了。
public interface AbstractFactory {
Phone makePhone();
}
public class XiaoMiFactory implements AbstractFactory{
抽象工厂模式：抽象工厂模式通过在AbstarctFactory中增加创建产品的接口，并在具体子工厂中实现新加产品的创建，当然前提是子工厂支持生产该产品。否则继承的这个接口可以什么也不干。
public interface PC {
void make();
}
public class MiPC implements PC {
public MiPC() {
this.make();
}
Num3：模板方法模式（Template Method）
是指：一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用，先看个关系图：
public abstract class AbstractCalculator {
//主方法，实现对本类其它方法的调用
public final int calculate(String exp,String opt){
int array[] = split(exp,opt);
return calculate(array[0],array[1]);
}
//被子类重写的方法
abstract public int calculate(int num1,int num2);
public int[] split(String exp,String opt){
String array[] = exp.split(opt);
int arrayInt[] = new int[2];
arrayInt[0] = Integer.parseInt(array[0]);
arrayInt[1] = Integer.parseInt(array[1]);
return arrayInt;
}
}
public class Plus extends AbstractCalculator {
Num4：代理模式
interface Game {
void play();
}
class LeagueOfLegends implements Game {