java 设计模式1－－工厂模式３种

why  工厂模式？

作用：通过一个工厂,  集中管理多个相近的类（拥有共同的父类）

当要获得多个类的实例的时候,  可以两三行代码就搞定,  这就是简单工厂模式的出发点！

而为了满足  '开闭原则' , 进一步的提高代码扩展性,  便有了工厂方法模式＋抽象工厂模式！

一：　　　xmind脑图解析：　类与类的关系

二：　　　java 代码详情　　　　　　　　　　　

第一种：简单工厂模式

//测试：验证结果
public class A_simpleFactory {
	//测试
		public static void main(String[] args) throws Exception {
			Computer comp=Factory.produce("a");
			comp.printname();
		}
}

//抽象产品类：电脑
	abstract class Computer{
		public abstract void printname();
	}

//普通工厂类
	class Factory{
		public static  Computer produce(String name) throws Exception{
			if (name.equals("a")){
				return new Acomputer();
			}
			else if (name.equals("b")){
				return  new Bcomputer();
			}
			else if (name.equals("c")){
				return  new Ccomputer();
			}
			else{
					throw new Exception("输入错误！");
			}
		}
	}

//具体产品类：a牌电脑，ｂ牌电脑，ｃ牌电脑
	class Acomputer extends Computer{
		@Override
		public void printname() {
			System.out.println("一台a牌电脑");
		}
	}
	
	class Bcomputer extends Computer{
		@Override
		public void printname() {
			System.out.println("一台b牌电脑");
		}
	}
	
	class Ccomputer extends Computer{
		@Override
		public void printname() {
			System.out.println("一台c牌电脑");
		}
	}

第二种：工厂方法模式

public class B_factoryMethod {
	//测试
		public static void main(String[] args) throws Exception {
			Computer comp=FactoryManager.selectFactory("b").produce();
			comp.printname();
		}
}

//抽象产品：电脑
	abstract class Computer2{
		public abstract void printname();
	}

//抽象工厂
	abstract class Factory2{
		public abstract  Computer produce();
	}

//工厂调度者－－工厂的工厂
	class FactoryManager{
		public static Factory2 selectFactory(String Fname) throws Exception{
			if (Fname.equals("a")){
				return new AcomputerFactory();
			}
			else if (Fname.equals("b")){
				return  new BcomputerFactory();
			}
			else if (Fname.equals("c")){
				return  new CcomputerFactory();
			}
			else{
					throw new Exception("输入错误！");
			}
		}
	}

二级目录：　抽象产品子类，　抽象工厂子类

//具体产品：a牌，ｂ牌，ｃ牌
	class Acomputer2 extends Computer2{
		@Override
		public void printname() {
			System.out.println("一台a牌电脑");
		}
	}
	
	class Bcomputer2 extends Computer2{
		@Override
		public void printname() {
			System.out.println("一台b牌电脑");
		}
	}
	
	class Ccomputer2 extends Computer2{
		@Override
		public void printname() {
			System.out.println("一台c牌电脑");
		}
	}

//具体工厂
	class AcomputerFactory extends Factory2{
		@Override
		public Computer produce() {
					return new Acomputer();
		}
	}
	
	class BcomputerFactory extends Factory2{
		@Override
		public Computer produce() {
					return new Bcomputer();
		}
	}
	
	class CcomputerFactory extends Factory2{
		@Override
		public Computer produce() {
					return new Ccomputer();
		}
	}

第三种：抽象工厂模式

　　　　　　第一种：固定组合式的（绑定产品）

//测试：验证结果
public class C_abstractFactory2 {
	public static void main(String[] args) {
		//选择工厂------选择产品:   需要windows 系列产品
	     Factory__ factory=FactoryManager__.selectFactory("linux");
        
             A_  a1=factory.getProductA(null);
             B_  b1=factory.getProductB(null);
        
             a1.printName();//A２产品-----for linux
             b1.printName();//B2产品-------for linux
	}
}
//抽象产品类A_, B_：-------具体A１_,Ａ２_，Ｂ１_,Ｂ２_
//抽象工厂 Factory__：--- 具体windows厂new A1(), new B1()，具体linux厂new A2(),newB2()
//工厂调度者　FactoryManager__：----selectFactory(String name)

　　　一级目录：

//一级：组件:抽象产品，抽象工厂
abstract  class A_{abstract void printName();  }
abstract  class B_{abstract void printName(); }

abstract  class Factory__{ 
	abstract A_ getProductA(String name); 
	abstract B_ getProductB(String name);
}

            二级目录：具体产品类，具体工厂类

//二级产品子类＝＝＝＝＝＝＝＝＝＝＝
class A1_ extends A_{
	@Override
	public void printName() {
			System.out.println("A1产品-----for windows");
	}
}

class A2_ extends A_{
	@Override
	public void printName() {
			System.out.println("A２产品-----for linux");
	}
}
class B1_ extends B_ {
	@Override
	public void printName() {
			System.out.println("B1产品-----for windows");
	}
}

class B2_ extends B_ {
	@Override
	public void printName() {
			System.out.println("B2产品-------for linux");
	}
}

//二级：工厂子类＝＝＝＝＝＝＝＝＝＝＝
class FactoryWindows extends Factory__{
	@Override
	A_ getProductA(String name) {
		return new A1_();
	}
	@Override
	B_ getProductB(String name) {
		return new B1_();
	}
}

class FactoryLinux extends Factory__{
	@Override
	A_ getProductA(String name) {
		return new A2_();
	}
	@Override
	B_ getProductB(String name) {
		return new B2_();
	}
}　　

　　　三级目录：工厂调度者

//三级调度者
class  FactoryManager__{ 
	public static Factory__ selectFactory(String name){
		if (name.equals("windows")){
			return new FactoryWindows();
		}
		else if (name.equals("linux")){
			return new FactoryLinux();
		}
		else {
			System.out.println("error ......选择工厂错误");
			return null;
		}
	}
}

　　　　　　第二种：临时组合式的（自由组合产品）　　　　　　

//测试：检测结果
public class C_abstractFactory {
	public static void main(String[] args) {
		//选择工厂------选择产品:   需要a1产品
		Factory_ factory=FactoryManager_.selectFactory("A");
                Factory_ factory2=FactoryManager_.selectFactory("B");
        
                A a1=factory.getProductA("a1");
                B b1=factory2.getProductB("b1");
        
                a1.printName();//A1产品
                b1.printName();//B1产品
	}
}
//抽象产品类A, B：-----------------------具体A１,Ａ２，Ｂ１,Ｂ２
//抽象工厂 Factory_：------------------- 具体A厂，　具体B厂
//工厂调度者　FactoryManager_：----selectFactory(String name)

//一级：组件
abstract  class A{abstract void printName();  }
abstract  class B{abstract void printName(); }

abstract  class Factory_{ 
	abstract A getProductA(String name); 
	abstract B getProductB(String name);
}

//三级调度者
class  FactoryManager_{ 
	public static Factory_ selectFactory(String name){
		if (name.equals("A")){
			return new FactoryA();
		}
		else if (name.equals("B")){
			return new FactoryB();
		}
		else {
			System.out.println("error ......选择工厂错误");
			return null;
		}
	}
}

　　　　　二级目录

//二级目录：产品子类＝＝＝＝＝＝＝＝＝＝＝
class A1 extends A{
	@Override
	public void printName() {
			System.out.println("A1产品");
	}
}

class A2 extends A {
	@Override
	public void printName() {
			System.out.println("A２产品");
	}
}
class B1 extends B {
	@Override
	public void printName() {
			System.out.println("B1产品");
	}
}

class B2 extends B {
	@Override
	public void printName() {
			System.out.println("B2产品");
	}
}


//二级：工厂子类＝＝＝＝＝＝＝＝＝＝＝
class FactoryA extends Factory_{
	@Override
	public A getProductA(String name) {
		if(name.equals("a1")){
			return new A1();
		}
		else if(name.equals("a2")){
			return new A2();
		}
		else{
			System.out.println("error .........输入错误");
			return null;
		}		
	}
	@Override
	public B getProductB(String name) {	return null;}    }

class FactoryB extends Factory_{
	@Override
	A getProductA(String name) {return null; }

	@Override
	B getProductB(String name) {
		if(name.equals("b1")){
			return new B1();
		}
		else if(name.equals("b2")){
			return new B2();
		}
		else{
			System.out.println("error .........输入错误");
			return null;
		}
	}
}