设计模式——抽象工厂模式

来源：互联网发布：c语言最大公约数的英文编辑：程序博客网时间：2024/04/29 16:47

http://blog.csdn.net/dawanganban/article/details/9879427

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的。抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象。

（1）创建一个Fruit接口

package com.meritit;  
  
public interface Fruit {  
  
    /* 
     * 采集 
     */  
    public void get();  
}  

（2）创建一个Apple抽象类

package com.meritit;  
  
public abstract class Apple implements Fruit{  
    /* 
     * 采集 
     */  
    public abstract void get();  
}  

（3）创建一个Banana抽象类

package com.meritit;  
  
public abstract class Banana implements Fruit{  
    /* 
     * 采集 
     */  
    public abstract void get();  
}  

（4）实现抽象的Apple，分为南方和北方两个产品族

package com.meritit;  
  
public class SouthApple extends Apple{  
  
    @Override  
    public void get() {  
        System.out.println("采集南方苹果");  
    }  
  
}  

package com.meritit;  
  
public class NorthApple extends Apple{  
  
    @Override  
    public void get() {  
        System.out.println("采集北方苹果");  
    }  
  
}  

同样Banana也分为南方和北方

package com.meritit;  
  
public class SouthBanana extends Banana{  
  
    @Override  
    public void get() {  
        System.out.println("采集南方香蕉");  
    }  
  
}  

package com.meritit;  
  
public class NorthBanana extends Banana{  
  
    @Override  
    public void get() {  
        System.out.println("采集北方香蕉");         
    }  
}  

（5）创建一个抽象的工厂方法（该工厂方法分为两个产品族）

package com.meritit;  
  
public interface FruitFactory {  
    //实例化Apple  
    public Fruit getApple();  
    //实例化Banana  
    public Fruit getBanana();  
}  

（6）实现南方族工厂方法和北方族工厂方法

package com.meritit;  
  
  
public class SouthFruitFactory implements FruitFactory {  
  
    @Override  
    public Fruit getApple() {  
        return new SouthApple();  
    }  
  
    @Override  
    public Fruit getBanana() {  
        return new SouthBanana();  
    }  
      
}  

package com.meritit;  
  
public class NorthFruitFactory implements FruitFactory{  
  
    @Override  
    public Fruit getApple() {  
        return new NorthApple();  
    }  
  
    @Override  
    public Fruit getBanana() {  
        return new NorthBanana();  
    }  
  
  
}  

（7）可以根据族而实例化不同族不同产品对象

package com.meritit;  
  
public class MainClass {  
      
    public static void main(String[] args) throws Exception {  
        FruitFactory northFactory = new NorthFruitFactory();  
        Fruit apple1 = northFactory.getApple();  
        apple1.get();  
        Fruit banana1 = northFactory.getBanana();  
        banana1.get();  
          
        FruitFactory southFactory = new SouthFruitFactory();  
        Fruit apple2 = southFactory.getApple();  
        apple2.get();  
        Fruit banana2 = southFactory.getBanana();  
        banana2.get();  
    }     
}  

上面的关系如图

下面我们来看一下这种设计模式的好处，假如我们要添加一个温室族的产品。

（1）添加WenshiApple和WenshiBanana

package com.meritit;  
  
public class WenshiApple extends Apple{  
  
    @Override  
    public void get() {  
        System.out.println("采集温室苹果");  
    }  
  
}  

package com.meritit;  
  
public class WenshiBanana extends Banana{  
  
    @Override  
    public void get() {  
        System.out.println("采集温室香蕉");  
    }  
  
}  

(2)添加族工厂WenshiFruitFactory

package com.meritit;  
  
public class WenshiFruitFactory implements FruitFactory{  
  
    @Override  
    public Fruit getApple() {  
        return new WenshiApple();  
    }  
  
    @Override  
    public Fruit getBanana() {  
        return new WenshiBanana();  
    }  
  
}  

现在的结构如图：

这样非常符合开放封闭原则，外部是开放的外部是封闭的。

但是这种方法也有缺点，当需要增加一个新的水果的时候，要对每个族工厂进行代码的修改。

抽象工厂模式的角色：

（1）抽象工厂角色：抽象工厂模式的核心，包含多个产品结构声明，任何工厂类都必须实现这个接口。

（2）具体工厂角色：具体工厂类是抽象工厂的一个实现，负责实例化某个族的产品对象。

（3）抽象角色：抽象模式所创建的所有产品的父类，它负责描述所有实例所共有的接口。

（4）具体产品角色：抽象模式所创建的具体实例。

0 0