javascript抽象工厂实例 java抽象工厂模式实例

 

抽象工厂模式

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

工厂方法模式通过引入工厂等级结构，解决了简单工厂模式中工厂类职责太重的问题，

但由于工厂方法模式中的每个工厂只生产一类产品，可能会导致系统中存在大量的工厂类，势必会增加系统的开销。

此时，我们可以考虑将一些相关的产品组成一个“产品族”，由同一个工厂来统一生产

抽象工厂（Abstract Factory）角色：它声明了一组用于创建一族产品的方法，每一个方法对应一种产品。
具体工厂（Concrete Factory）角色：它实现了在抽象工厂中声明的创建产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中。
抽象产品（Abstract Product）角色：它为每种产品声明接口，在抽象产品中声明了产品所具有的业务方法。
具体产品（Concrete Product）角色：它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法。

优点：
1. 拥有工厂方法模式的优点
2. 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端
始终只使用同一个产品族中的对象。
3 增加新的产品族很方便，无须修改已有系统，符合“开闭原则”。
缺点：
1. 增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需
要修改抽象层代码，这显然会带来较大的不便，违背了“开闭原则”。

适用场景：

(1) 系统中有多于一个的产品族。 而每次只使用其中某一产品族。可以通过配置文件等方式
 来使得用户可以动态改变产品族，也可以很方便地增加新的产品族。
(2) 产品等级结构稳定。设计完成之后，不会向系统中增加新的产品等级结构或者删除已有的产品等级结构

demo，增加一族很简单（横向），但是增加一个等级很难（纵向）

入口类 

package abstract_method_mod;

import org.junit.Test;

/**
 * 抽象工厂实现方法
 * 优点
 *
 * 抽象工厂模式隔离了具体类的生成， 使得客户并不需要知道什么被创建。 由于这种隔离，更换一个具体工厂就变得相对容易， 所有的具体工厂都实现了抽象工厂中定义的那些公共接口， 因此只需改变具体工厂的实例， 就可以在某种程度上改变整个软件系统的行为。
 *
 * 当一个族中的多个对象被设计成一起工作时， 它能够保证客户端始终只使用同一个族中的对象。
 *
 * 增加新的族很方便， 无须修改已有系统， 符合“开闭原则”。
 *
 * 缺点
 *
 * 增加新的等级结构麻烦， 需要对原有系统进行较大的修改， 甚至需要修改抽象层代码，这显然会带来较大的不便， 违背了“开闭原则”。
 * 使用场景
 *
 * 一个系统不应当依赖于具体类实例如何被创建、 组合和表达的细节， 这对于所有类型的工厂模式都是很重要的， 用户无须关心对象的创建过程， 将对象的创建和使用解耦；
 *
 * 系统中有多于一个的族， 而每次只使用其中某一族。 可以通过配置文件等方式来使得用户可以动态改变族， 也可以很方便地增加新的族。
 *
 * 属于同一个族的对象将在一起使用， 这一约束必须在系统的设计中体现出来。 同一个族中的对象可以是没有任何关系的对象， 但是它们都具有一些共同的约束， 如同一操作系统下的按钮和文本框， 按钮与文本框之间没有直接关系， 但它们都是属于某一操作系统的， 此时具有一个共同的约束条件： 操作系统的类型。
 *
 * 等级结构稳定， 设计完成之后， 不会向系统中增加新的等级结构或者删除已有的等级结构。
 */
public class Client {
    @Test
    public void test(){
        AnimalFactory americanFactory = new AmericanFactory();
        Animal cat = americanFactory.getCat();
        cat.say();
        Animal dog = americanFactory.getDog();
        dog.say();

        AnimalFactory chineseFactory = new ChineseFactory();
        Animal cat1 = chineseFactory.getCat();
        cat1.say();
        Animal dog1 = chineseFactory.getDog();
        dog1.say();
    }
}

 接口工厂，动物工厂接口

package abstract_method_mod;

/**
 * 抽象工厂：声明一组用于创建一族产品的方法，每个方法对应一种对象；在抽象工厂中声明了多个工厂方法， 用于创建不同类型的对象， 抽象工厂可以是接口， 也可以是抽象类或者具体类。
 */
public interface AnimalFactory {
    Animal getCat();
    Animal getDog();
}

动物接口 

package abstract_method_mod;

/**
 * 抽象类接口
 * 提供一组所有类都具有的业务方法
 */
public interface Animal {
    /**
     * 发声
     */
    void say();
}

实例化工厂，美国动物工厂 

package abstract_method_mod;

/**
 * 族 美国动物的工厂
 */
public class AmericanFactory implements AnimalFactory {
    @Override
    public Animal getCat() {
        return new AmericanCat();
    }

    @Override
    public Animal getDog() {
        return new AmericanDog();
    }
}

实例化工厂，中国动物工厂 

package abstract_method_mod;

/**
 * 族 中国动物的工厂
 * 具体工厂实现了抽象工厂，每个工厂方法返回一个具体对象，一个具体工厂所创建的具体对象构成一个族。
 */
public class ChineseFactory implements AnimalFactory {
    @Override
    public Animal getCat() {
        return new ChineseCat();
    }

    @Override
    public Animal getDog() {
        return new ChineseDog();
    }
}

实例化动物，美国的狗 

package abstract_method_mod;

/**
 * 具体实现类 族--美国的狗
 */
public class AmericanDog extends Dog {

    @Override
    public void say() {
        System.out.println(String.format("American Dog say %s","旺~旺~"));
    }
}

实例化动物，美国的猫 

package abstract_method_mod;

/**
 * 具体实现类 族--美国的猫
 */
public class AmericanCat extends Cat{
    @Override
    public void say() {
        System.out.println(String.format("American Cat say %s","喵~喵~"));
    }
}

实例化动物 中国的猫 

package abstract_method_mod;

/**
 * 具体实现类 族--中国的猫
 * 具体类：该角色继承抽象类，主要用于实现抽象类中声明的抽象方法，完成不同等级结构，不同族的业务方法的具体实现。
 */
public class ChineseCat extends Cat {

    @Override
    public void say() {
        System.out.println(String.format("Chinese cat say %s","喵~~~喵~~~"));
    }
}

实例化动物，中国的狗 

package abstract_method_mod;

/**
 * 具体实现类 族--中国的狗
 * 具体类：该角色继承抽象类，主要用于实现抽象类中声明的抽象方法，完成不同等级结构，不同族的业务方法的具体实现。
 */
public class ChineseDog extends Dog {
    @Override
    public void say() {
        System.out.println(String.format("Chinese dog say %s","旺~~~旺~~~"));
    }
}

抽象类猫 

package abstract_method_mod;

/**
 * 抽象类 猫
 * 用于实现抽象接口所定义的业务方法，但是该角色对于抽象接口定义的方法只做抽象实现，即所有实现都被定义为抽象方法，最终的具体实现全部交给具体类实现。引入该角色主要是为了根据声明不同的抽象类，将类区分为不同的等级结构。
 */
public abstract class Cat implements Animal {
    public  abstract void say();
}

抽象类狗 

package abstract_method_mod;

/**
 * 抽象类 狗
 * 用于实现抽象接口所定义的业务方法，但是该角色对于抽象接口定义的方法只做抽象实现，即所有实现都被定义为抽象方法，最终的具体实现全部交给具体类实现。引入该角色主要是为了根据声明不同的抽象类，将类区分为不同的等级结构。
 */
public abstract class Dog implements Animal{
    public abstract void say();
}