设计模式学习与整理-抽象工厂模式

客官°小女子只卖身不卖艺 2022-10-02 11:54 99阅读 0赞

### 介绍 ###

是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

### 应用场景 ###

（1）系统需要为用户提供多个对象，但不希望用户直接用new运算符实例化这些对象，即希望用户和创建对象脱耦。  
（2）系统需要为用户提供一系列对象，但只需要知道这些对象有哪些方法可用，不需要用户知道这些对象的创建过程。

### 模式结构 ###

（1）抽象产品（Product）：一个抽象类或接口，负责定义具体产品必须实现的方法；  
（2）具体产品（ConcreteProduct）：具体产品是一个类，实现抽象产品的方法。  
（3）抽象工厂（AbstractFactory）：一个接口或抽象类，负责定义若干个抽象方法；  
（4）具体工厂（ConcreteFactory）：具体工厂重写抽象工厂中的抽象方法。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hjeTExOTMwNjg2Mzk_size_16_color_FFFFFF_t_70][]

### 代码案例 ###

（1）抽象产品（裤子和上衣接口）

public interface UpperClothes {
        public abstract int getChestSize();
        public abstract int getHeight();
        public abstract String getName();
    }

public interface Trousers {
        public abstract int getWaistSize();
        public abstract int getHeight();
        public abstract String getName();
    }

（2）具体产品

分别是西服上衣、牛仔上衣、西装裤子和牛仔裤。

public class WesternUpperClothes implements UpperClothes {
        private int chestSize;
        private int height;
        private String name;
    
        WesternUpperClothes(String name , int chestSize , int height){
            this.name = name;
            this.chestSize = chestSize;
            this.height = height;
        }
    
        @Override
        public int getChestSize() {
            return chestSize;
        }
    
        @Override
        public int getHeight() {
            return height;
        }
    
        @Override
        public String getName() {
            return name;
        }
    }

public class CowboyUpperClothes implements UpperClothes {
        private int chestSize;
        private int height;
        private String name;
    
        CowboyUpperClothes(String name , int chestSize , int height){
            this.name = name;
            this.chestSize = chestSize;
            this.height = height;
        }
    
        @Override
        public int getChestSize() {
            return chestSize;
        }
    
        @Override
        public int getHeight() {
            return height;
        }
    
        @Override
        public String getName() {
            return name;
        }
    }

public class WesternTrousers implements Trousers {
        private int waistSize;
        private int height;
        private String name;
    
        WesternTrousers(String name , int waistSize , int height){
            this.name = name;
            this.waistSize = waistSize;
            this.height = height;
        }
    
        @Override
        public int getWaistSize() {
            return waistSize;
        }
    
        @Override
        public int getHeight() {
            return height;
        }
    
        @Override
        public String getName() {
            return name;
        }
    }

public class CowboyTrousers implements Trousers {
        private int waistSize;
        private int height;
        private String name;
    
        CowboyTrousers(String name , int waistSize , int height){
            this.name = name;
            this.waistSize = waistSize;
            this.height = height;
        }
        @Override
        public int getWaistSize() {
            return waistSize;
        }
    
        @Override
        public int getHeight() {
            return height;
        }
    
        @Override
        public String getName() {
            return name;
        }
    }

（3）抽象工厂

public abstract class ClothesFactory {
        public abstract UpperClothes createUpperClothes(int chestSize , int height);
        public abstract Trousers createTrousers(int waistSize , int height);
    }

（4）具体工厂（北京工厂和上海工厂）

public class BeijingClothesFactory extends ClothesFactory {
    
        @Override
        public UpperClothes createUpperClothes(int chestSize, int height) {
            return new WesternUpperClothes("北京牌西服上衣",chestSize,height);
        }
    
        @Override
        public Trousers createTrousers(int waistSize, int height) {
            return new WesternTrousers("北京牌西服裤子",waistSize,height);
        }
    }

public class ShanghaiClothesFactory extends ClothesFactory {
    
        @Override
        public UpperClothes createUpperClothes(int chestSize, int height) {
            return new CowboyUpperClothes("上海牌牛仔上衣",chestSize,height);
        }
    
        @Override
        public Trousers createTrousers(int waistSize, int height) {
            return new CowboyTrousers("上海牌牛仔裤子",waistSize,height);
        }
    }

（5）模式的使用（店铺类）

public class Shop {
        private UpperClothes cloth;
        private Trousers trouser;
        public void giveSuit(ClothesFactory factory , int chestSize , int waistSize , int height){
            cloth = factory.createUpperClothes(chestSize, height);
            trouser = factory.createTrousers(waistSize, height);
            showMess();
        }
        private void showMess(){
            System.out.println("<套装信息>");
            System.out.println(cloth.getName()+":");
            System.out.println("胸围："+cloth.getChestSize());
            System.out.println("身高："+cloth.getHeight());
            System.out.println(trouser.getName()+":");
            System.out.println("腰围："+trouser.getWaistSize());
            System.out.println("身高："+trouser.getHeight());
        }
    }

main方法：

public static void main(String args[]){
            Shop shop = new Shop();
            ClothesFactory factory = new BeijingClothesFactory();
            shop.giveSuit(factory, 110,82,170);
            factory = new ShanghaiClothesFactory();
            shop.giveSuit(factory, 120, 88, 180);
        }

![20190624095819189.png][]

### 优点 ###

当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。  
抽象工厂可以为用户创建一系列相关的对象，使用户和创建这些对象的类脱耦。  
在抽象工厂模式中，可以随时增加“具体工厂”为用户提供一组相关的对象。

### 缺点 ###

产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hjeTExOTMwNjg2Mzk_size_16_color_FFFFFF_t_70]: /images/20220112/965d69ad75bb400da53be1f238f1bb6e.png
[20190624095819189.png]: /images/20220112/67d59384258c45cfba3299aee452b39b.png