单例模式/工厂方法模式/抽象工厂模式

单例模式：

public class Person2 { 

//      饿汉模式
//	private static Person2 person = new Person2();
//	private Person2(){}
//	public static Person2 getInstacne(){
//		return person;
//	}
	
//	静态 内部类-->外部类才能调用
//	静态-->随着类的加载而产生
	private static class PersonHolder{
		private static final Person2 INSTANCE = new Person2();
	}
	private Person2(){}
	public static Person2 getInstance2(){
		return PersonHolder.INSTANCE;
	}
//      懒汉模式
//	private static Person2 person2;
//	private Person2(){}
//	public static synchronized Person2 getInstace(){ 
//		if(person==null){
//			person = new Person2();
//		}
//		return person;
//	}
	
	
}

工厂方法采用的是类继承机制，生成一个子类，重写该工厂方法，在方法内生成一个对象。

抽象工厂采用的是对象组合机制，专门定义”工厂“对象来负责对象的创建

简单用例:

interface icar {
	void docar();
}
class bwm implements icar{
	@Override
	public void docar() {
		System.out.println("bwm");	
	}
}
class bk implements icar{
	@Override
	//工厂方法采用的是类继承机制（生成一个子类，重写该工厂方法，在该方法中生产一个对象）
	public void docar() {
		System.out.println("bk");
	}
}

interface icarFac{
	icar createCar();
}
class bwmFac implements icarFac{
	
	@Override
	//抽象工厂采用的是对象组合机制，专门定义“工厂”对象来负责对象的创建
	public  bwm createCar() {
		return new bwm();
	}
}
class bkFac implements icarFac{
	@Override
	public  bk createCar() {
		return new bk();
	}
}
//抽象工厂针对多个产品等级结果
public class test{
	public static void main(String[] args) {
		
		icarFac mfac = new bwmFac();
		icar m = mfac.createCar();//工厂类负责创建抽象产品的具体子类的实例
		m.docar();
		
		mfac = new bkFac();
		icar k = mfac.createCar();
		k.docar();
	}
}