Java设计模式之工厂模式

工厂模式

众所周知，在现实生活中，工厂是用来生产产品的，它有两个关键的角色：工厂和产品。计算机的工厂模式和实际中的工厂特征是一样的，所以工厂模式的关键就是怎么描述好工厂和产品两者之间的关系。

分类

1，简单工厂，又叫静态工厂模式
2，工厂模式，又叫多态工厂模式
3，抽象工厂

代码实现

1，简单工厂

/**
 * 
 * @author 22247
 *简单工厂，静态工厂
 *优点：只需要知道工厂造什么
 *缺点：不符合开闭原则，单一职责
 */
public class simpleFactory {
	public static void main(String[] args) {
		CarSimpleFactory.Sell("奥迪");
		CarSimpleFactory.Sell("大众");
	}
}
 abstract class ICar{}
 class Benz extends ICar{
	public Benz() {//写一个构造方法输出车型
		System.out.println("奔驰");
	}
}
 class Bmw extends ICar{
		public Bmw() {//写一个构造方法输出车型
			System.out.println("宝马");
		}
	}
 class Audi extends ICar{
		public Audi() {//写一个构造方法输出车型
			System.out.println("奥迪");
		}
	}
 //写一个简单工厂
  class CarSimpleFactory{
	 //写一个静态方法分别实例上面的方法
	 public static ICar Sell(String sell) {
		 ICar obj=null;
		 if(sell.equals("奔驰")) {
			 obj=new Benz();
		 }else if(sell.equals("宝马")) {
			 obj=new Bmw();
		 }else if(sell.equals("奥迪")) {
			 obj=new Audi();
		 }else {
			 System.out.println("没有这种车卖");
		 }
		return obj;
	 }
 }

由于简单工厂的方法通常是静态的，所以又叫静态工厂。如果要防止客户端乱创建简单工厂实例，还可以把简单工厂的构造方法私有化。
2，工厂

/**
 * 
 * @author 22247
 *工厂模式实现
 *优点：符合单一职责
 */
//测试类
public class Factory {
	public static void main(String[] args) {
		CarFactory obj=new AudiAFactory();
		ICar2 car=obj.create();
				car.carKinds();
	}
}
//定义一个ICar接口,写一个carKinds静态方法
  interface ICar2{
	abstract void carKinds();
}
//各种车系车型
 class BenzA implements ICar2{
	//写一个构造方法方法
	public BenzA() {
		System.out.println("造奔驰A系");
	}

	@Override
	public void carKinds() {
		// TODO Auto-generated method stub
		System.out.println("卖奔驰A系");
	}
}
class BenzB implements ICar2{
	//写一个构造方法方法
		public BenzB() {
		System.out.println("造奔驰B系");
	}

		@Override
		public void carKinds() {
			// TODO Auto-generated method stub
			System.out.println("卖奔驰B系");
		}
}
 class BenzC implements ICar2{
	//写一个构造方法方法
		public BenzC() {
		System.out.println("造奔驰C系");
	}

		@Override
		public void carKinds() {
			// TODO Auto-generated method stub
			System.out.println("卖奔驰C系");
		}
}
 class BwmA implements ICar2{
	//写一个构造方法方法
		public BwmA() {
		System.out.println("造宝马A系");
	}

		@Override
		public void carKinds() {
			// TODO Auto-generated method stub
			System.out.println("卖宝马A系");
		}
}
 class BwmB implements ICar2{
	//写一个构造方法方法
		public BwmB() {
		System.out.println("造宝马B系");
	}

		@Override
		public void carKinds() {
			// TODO Auto-generated method stub
			System.out.println("卖宝马B系");
		}
}
 class AudiA implements ICar2{
	//写一个构造方法方法
		public AudiA() {
		System.out.println("造奥迪A系");
	}

		@Override
		public void carKinds() {
			// TODO Auto-generated method stub
			System.out.println("卖奥迪A系");
		}
}
 //写一个抽象工厂，有一个create方法
abstract class CarFactory{
	public abstract ICar2 create();
}
//分别建工厂
class BenzAFactory extends CarFactory{
	public ICar2 create() {
		return new BenzA();
	}
}
class BenzBFactory extends CarFactory{
	public ICar2 create() {
		return new BenzB();
	}
}
class BenzCFactory extends CarFactory{
	public ICar2 create() {
		return new BenzC();
	}
}
class BwmAFactory extends CarFactory{
	public ICar2 create() {
		return new BwmA();
	}
}
class BwmBFactory extends CarFactory{
	public ICar2 create() {
		return new BwmB();
	}
}
class AudiAFactory extends CarFactory{
	public ICar2 create() {
		return new AudiA();
	}
}

该方法可以应用于，当用户需要一个类的子类实例，但是不希望与子类形成更多的耦合或者不知道该类有哪些子类可以用时。
3，抽象工厂

/**
 * @author 22247
 *抽象工厂模式
 */
//test class 
public class AbstractFactory {
	public static void main(String[] args) {
		sonFactory obj=new BenzA3Factory();
		ICar3 car=obj.create();
				car.carKind();
		Engine engine=obj.createEn();
		engine.engindKind();
		Ac ac=obj.createAc();
		ac.AcKind();
	}
}
//定义一个ICar3接口,写一个carKind静态方法
interface ICar3{
	abstract void carKind();
}
//各种车系车型
class BenzA3 implements ICar3{
	//写一个构造方法方法
	public BenzA3() {
		System.out.print("造奔驰A系");
	}
	public void carKind() {
		System.out.print("卖奔驰A系");
	}
}
class BwmA3 implements ICar3{
	//写一个构造方法方法
		public BwmA3() {
		System.out.print("造宝马A系 ");
	}
		public void carKind() {
			// TODO Auto-generated method stub
			System.out.print("卖宝马A系 ");
		}
}
class AudiA3 implements ICar3{
	//写一个构造方法方法
		public AudiA3() {
		System.out.print("造奥迪A系-");
	}
		public void carKind() {
			System.out.print("卖奥迪A系-");
		}
}
//写一个发动机接口
		interface Engine{
			//这是一个发动机种类的抽象方法
			abstract void engindKind();
		}
class EngineA implements Engine{
	public void engindKind() {
		System.out.print("A型号发动机-");
	}		
}
class EngineB implements Engine{
	public void engindKind() {
		System.out.print("B型号发动机-");
	}			
}
class EngineC implements Engine{
	public void engindKind() {
		System.out.print("C型号发动机-");
	}		
}	
// 写一个空调种类接口
//interface Ac
 abstract class Ac{
	abstract void AcKind();
}
class AcA extends Ac{
	public void AcKind() {
		System.out.print("A型号空调-");
	}
}
class AcB extends Ac{
	public void AcKind() {
		System.out.print("B型号空调-");
	}
}
class AcC extends Ac{
	public void AcKind() {
		System.out.print("C型号空调-");
	}
}
//写一个抽象工厂
abstract class AbstractFactory{
}
//写一个Benz工厂继承抽象工厂
abstract class sonFactory extends AbstractFactory{
	public abstract ICar3 create();
	public abstract Engine createEn();
	public abstract Ac createAc();
}
//分别建工厂
class BenzA3Factory extends sonFactory{
	public ICar3 create() {
		return new BenzA3();
	}
	public Engine createEn() {
		return new EngineA();
	}
	public Ac createAc() {
		return new AcA();
	}
}
class BwmA3Factory extends sonFactory{
	public ICar3 create() {
		return new BwmA3();
	}
	public Engine createEn() {
		return new EngineB();
	}
	public Ac createAc() {
		return new AcB();
	}
}
class AudiA3Factory extends sonFactory{
	public ICar3 create() {
		return new AudiA3();
	}
	public Engine createEn() {
		return new EngineC();
	}
	public Ac createAc() {
		return new AcC();
	}
}

该方法可以应用于，当用户需要系统提供多个对象，且希望和创建对象的类解耦合时