常用到的设计模式（1）

单例模式

所谓单例模式，就是确保一个类仅有一个实例，并提供一个访问它的全局访问点。单例模式又分为饿汉式单例和懒汉式单例。

饿汉式

第一次引用该类的时候就创建对象实例，而不管实际是否需要创建。

public class Test {
    private static final Test instance=new Test();
    private Test(){}
    public static Test getInstance(){
        return instance;
    }
}

懒汉式

什么时候用就什么时候创建实例，存在线程安全问题。实例在开始时为空，第一次加载后才实例化。

public class Test {
    private volatile static Test instance=null;
    private Test(){}
    public static Test getInstance(){
        if(instance==null) {
            instance=new Test();
        }
        return instance;
    }
}

双层检测锁模式

双重锁模式，是对饱汉模式的优化，进行双重判断，当已经创建过实例对象后就无需加锁。

public class Test {
    private volatile static Test instance=null;
    private Test(){}
    public static Test getInstance(){
        if(instance==null) {
            synchronized (Test.class){
                if(instance==null) {
                    instance=new Test();
                }
            }
        }
        return instance;
    }
}

工厂模式

工厂模式将创建对象的具体过程屏蔽隔离起来。工厂模式可以分为三类：简单工厂模式、工厂方法模式、抽象工厂模式。

简单工厂模式

简单工厂模式最重要的就是定义一个创建对象的接口。
Pizza类：

abstract class Pizza {
	public Pizza(){}
}

public class FruitPizza extends Pizza{
	public FruitPizza() {
		System.out.println("水果披萨");
	}
}

public class MeatPizza extends Pizza{
	public MeatPizza(){
		System.out.println("肉披萨");
	}
}

工厂类：

public class PizzaFactory {
	public Pizza createPizza(int type) {
		switch (type) {
		case 1:
			return new FruitPizza();
		case 2:
			return new MeatPizza();
		default:
			break;
		}
		return null;
	}
}

工厂方法模式

承接上例中的Pizza类。
工厂类：

interface FactoryPizza {
	Pizza createPizza();
}

public class FactoryFruitPizza implements FactoryPizza{
	@Override
	public FruitPizza createPizza() {
		return new FruitPizza();
	}
}

public class FactoryMeatPizza implements FactoryPizza {
	@Override
	public MeatPizza createPizza() {
		return new MeatPizza();
	}
}

抽象工厂模式

相机相关类：

//镜头
public interface Lens {}  
 

public class LensA implements Lens{  
   public LensA(){  
       System.out.println("索尼镜头");  
   }  
}  

public class LensB implements Lens{  
    public LensB(){  
        System.out.println("佳能镜头");  
    }  
}  

//机身
public interface CameraBody {} 

public class CameraBodyA implements CameraBody{  
    public CameraBodyA(){  
        System.out.println("索尼机身");  
    }  
}  

public class CameraBodyB implements CameraBody{  
    public CameraBodyB(){  
        System.out.println("佳能机身");  
    }  
} 

相机代理商类：

public interface CameraFactory {  
    public Lens createLens();
    public CameraBody createCameraBody(); 
}  

//生产索尼相机
public class FactorySONY implements CameraFactory{     
    @Override  
    public Lens createLens() {    
        return new LensA();  
    }  
    @Override  
    public CameraBody createCameraBody() {  
        return new CameraBodyA();  
    }  
}  

//佳能相机
public class FactoryCanon implements CameraFactory{ {  
     @Override  
    public Lens createLens() {    
        return new LensB();  
    }  
    @Override  
    public CameraBody createCameraBody() {  
        return new CameraBodyB();  
    }  
} 

建造者模式

建造者模式旨在把一个流程分解到不同的方法中，避免某个方法过于繁重，每个方法相互独立。
穿搭类：

public class Dressing {
    private String clothes;
    private String shoes;
    public String getClothes() {
        return clothes;
    }
    public void setClothes(String clothes) {
        this.clothes = clothes;
    }
    public String getShoes() {
        return shoes;
    }
    public void setShoes(String shoes) {
        this.shoes = shoes;
    }
}

穿搭构造类：

public abstract class DressingBuilder {
    Dressing dressing= new Dressing();
    public abstract void buildClothes();
    public abstract void buildShoes();
    public Dressing getDressing(){
        return dressing;
    }
}

穿搭A、穿搭B。

public class DressingA extends DressingBuilder{
    public void buildClothes() {
        dressing.setClothes("衣服A");
    }
    public void buildShoes() {
        dressing.setShoes("鞋子A");
    }
 
}

public class DressingB extends DressingBuilder{
    public void buildClothes() {
        dressing.setClothes("衣服B");
    }
    public void buildShoes() {
        dressing.setShoes("鞋子B");
    }
}

最后由构建人员搭配衣服

public class DressingPerson{
    private DressingBuilder dressingBuilder;
    public void setDressingBuilder(DressingBuilder dressingBuilder) {
        this.dressingBuilder = dressingBuilder ;
    }
    public Dressing construct(){
        dressingBuilder.buildClothes();
        dressingBuilder.buildShoes();
        return dressingBuilder.getDressing();
    }
}