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牌电脑");
}
}

[b]第二种：工厂方法模式[/b]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();
}

//抽象工
4000
厂
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();
}
}

[b][b]第三种：抽象工厂模式[/b][/b]
[b][b]　　　　　　第一种：固定组合式的（绑定产品）[/b][/b]//测试：验证结果
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;
}
}
}[b][b][b][b][b]　　　　　　第二种：临时组合式的（自由组合产品）　　　　　　[/b][/b]
[/b][/b][/b]//测试：检测结果
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;
}
}
}