单例模式、工厂模式、抽象模式、模板方法模式

一：单例模式

1.定义：单例模式确保某一个类智能创建一个对象。

2.单例模式的实现主要是把构造器设置为private，外部通过Singleton.getInstance()来访问。通用类图：

3.单例模式实现的三种方式：

（1）立即加载/饿汉模式，即在调用方法前，实例已经被创建了，这个模式具有很好的并发性。

public class Signleton {
private static Signleton signleton=new Signleton();
private Signleton(){}
public static Signleton getInstance(){
	return signleton;
}
}

（2）延迟加载/懒汉模式，即需要调用方法才能创建实例，这个模式在多线程时会不安全，因此在多线程时需要对getInstance()方法声明synchronized关键字，具体的可以看之前的博客关于单例模式和多线程结合。

public class Signleton {
private static Signleton signleton;
private Signleton(){}
public static Signleton getInstance(){
	if(signleton==null){
		signleton=new Signleton();
	}
	return signleton;
}
}

（3）利用内部类，因为内部类不会立即加载，只有调用内部类的方法时才会被调用，所以可以采用内部类来实现单例类，这种模式既实现了懒汉模式又能保证并发性。

public class Signleton {
private Signleton(){}
private static class inner{
	private static Signleton signleton=new Signleton();
}
public static Signleton getInstance(){
	return inner.signleton;
}
}

4.单例模式的扩展

这里的扩展指的是指定一个类生成几个对象，比如3个或者4个等。这里就不详细说了，知道这么回事就行，等用到再说。

二：工厂方法模式

1.定义：工厂方法模式指的是定义一个用于创建对象的接口，让子类决定实例化哪一个类，换句话说哦工厂方法模式就是让一个类的实例化延迟到子类中。

2.通用类图如下，Produc是抽象产品类，Creator是抽象生产Product的类，相对应的有它们的实现类：

3.实例：

Product.java

public abstract class Product {
public void method1(){System.out.println("Product->method1");}
public abstract void method2();
}

produci1.java

public class product1 extends Product{
	@Override
	public void method2() {
		System.out.println("produt1->method2");
	}
}

product2.java

public class product2 extends Product{
	@Override
	public void method2() {
		System.out.println("product2->method2");
	}
}

Creator.java

public abstract class Creator {
public abstract  T createProduct(Class c);
}

creator1.java

public class creator1 extends Creator{
	@Override
	public  T createProduct(Class c) {
		Product product=null;
		try{
			product=(Product) Class.forName(c.getName()).newInstance();
		}catch(Exception e){
			e.printStackTrace();
		}
		return (T) product;
	}
}

Client.java

public class Client {
public static void main(String[] args){
	Creator c=new creator1();
	Product p1=c.createProduct(product1.class);
	p1.method2();
}
}

4.工厂方法模式是new一个对象的替代品，所有在有需要声称对象地方都可以用；当需要灵活的可扩赞的框架时，可以考虑此模式。

5.工厂模式的扩展

（1）简单工厂模式

当一个模块只需要一个工厂时，就不需要工厂的抽象类了，在上面的例子中，把抽象类Creator去掉，直接新建creator1类，只不过里面的createProduct方法前要加上static修饰。因此简单工厂模式也叫做静态工厂模式。

（2）升级为多个工厂类

为每一个产品定义一个生产者，对应于上面的例子，即product1对应于creator1，product2对应于creator2，做好一一对应以后，Creator里面的抽象方法就不需要传递相关参数了。

（3）还可以替代单例模式，这里不详细说。

第三：抽象工厂模式

1.定义：抽象工厂模式是为创建一组或相互依赖的对象提供一个接口，而且无需指定它们的具体类。

2.通用类图如下，感觉看上去和工厂模式很相似，但是要注意的是抽象工厂模式至少要包括两个产品族：

3.实例

ProducA.java

public abstract class ProductA {
public void method1(){System.out.println("Product->method1");}
public abstract void method2();
}

productA1.java

public class productA1 extends ProductA{
	@Override
	public void method2() {
		System.out.println("produtA1->method2");
	}
}

productA2.java

public class productA2 extends ProductA{
	@Override
	public void method2() {
		System.out.println("productA2->method2");
	}
}

ProductB.java

public abstract class ProductB {
	public void method1(){System.out.println("Product->method1");}
	public abstract void method2();
}

produceB1.java

public class productB1 extends ProductB{
	@Override
	public void method2() {
		System.out.println("productB1->method2");
	}
}

productB2.java

public class productB2 extends ProductB{
	@Override
	public void method2() {
		System.out.println("productB2->method2");
	}
}

Creator.java

/*
 * 有几个产品族就要包括几个生产方法
 * 有几个生产等级就有几个实现工厂类，在每个实现工厂中，实现不同产品族的生产等级
 */
public abstract class Creator {
//生产A产品家族
public abstract ProductA createProductA();
//生产B产品家族
public abstract ProductB createProductB();
}

creator1.java

public class creator1 extends Creator{
	//生产等级1的A产品
	@Override
	public ProductA createProductA() {
		return new productA1();
	}
//生产等级二的B产品
	@Override
	public ProductB createProductB() {
		return new productB1();
	}
}

creator2.java

public class creator2 extends Creator{
//生产等级为2的产品A
	@Override
	public ProductA createProductA() {
		return new productA2();
	}
//生产等级为2的产品B
	@Override
	public ProductB createProductB() {
		return new productB2();
	}
}

Client.java

public class Client {
public static void main(String[] args){
	Creator c1=new creator1();
	Creator c2=new creator2();
	ProductA p1=c1.createProductA();
	ProductA p2=c2.createProductA();
	ProductB p3=c1.createProductB();
	ProductB p4=c2.createProductB();
	p1.method2();
	p2.method2();
	p3.method2();
	p4.method2();
}
}

抽象工厂类中，对一个产品来说，我们只要知道它的工厂方法可以直接产生一个产品对象即可，不需要指导它的实现类。

4.抽象工厂模式和工厂方法模式的区别

工厂方法就指有一个专门生产某个产品的类，比如鼠标工厂，专业生产鼠标。抽象工厂模式是不仅生产鼠标，还生产键盘等不同的产品族。

工厂方法里面就两个元素：创造者和产品，工厂方法就是一个创建者创建这个类的方法而已。抽象工厂包括客户端、工厂、产品族A、产品族B...。

抽象工厂关键字在于产品之间的抽象关系，至少两个产品族。工厂方法在于生产产品，不关注产品之间的关系，所以可以只生产一个产品。

抽象工厂在最后使用的时候一般使用客户端，产品之间的关系是被封装固定的，工厂方法使用的时候使用产品本身。

第四：模块方法模式

1.定义：模块方法模式就是定义一个操作中的算法框架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。模板方法模式仅仅使用了Java的继承机制，一般模板方法前面都加上final关键字，不允许被重写。

2.通用类图：

3.抽象模板中的基本抽象方法尽量使用protected修饰。抽象类是子类的共性封装，如果两个实现类里面各自定义的方法一样，则需要把这个方法抽到抽象类中。

模板方法封装的是不变的部分，扩展可变的部分；提取公共部分的代码；行为由父类控制，实现由子类决定。

在模板方法的使用中要注意的是要结合钩子方法。钩子方法就是由子类的返回值决定公共部分的执行效果，钩子方法由protected修饰