java 抽象工厂模式简单实例

抽象工厂模式：提供一个创建一系列的相关的或者依赖的对象的接口，无需指定它们的具体实现类，具体的时间分别在子类工厂中产生。

类似于工厂模式：隔离了具体类的生产实现，使得替换具体的工厂实现类很容易。包含有以下模块：

1.抽象产品接口：定义产品的接口，公共的暴露方法。便于实际的产品类实现。

2.具体的产品类:包含实际产品的类的逻辑处理：

3.抽象工厂接口：定义产生系列对象的接口

4.具体的工厂实现：实现抽象的接口工厂，返回具体的产品类的实现。

下面是具体的代码示例：

1.抽象的产品接口，定义了Car 和 IBreakFast

package factory.simple;

/**

 * 抽象产品角色 交通工具接口

 *

 * @author lilin

 *

 */

public interface Car {

    /**

     * 上班函数

     */

    void gotowork();

}

package factory.abstractfactory;

/**

 * @author lilin

 *

 */

public interface IBreakFast {

    /**

     * 吃早餐

     */

    void eat();

}

2.定义具体的产品类的实现：

package factory.simple;

/**

 * 具体产品角色，自行车

 *

 * @author lilin

 *

 */

public class Bike implements Car {

    @Override

    public void gotowork() {

        System.out.println("骑自行车去上班！");

    }

}

package factory.simple;

/**

 * @author lilin

 *

 */

public class Bus implements Car {

    @Override

    public void gotowork() {

        System.out.println("坐公交车去上班！");

    }

}

/**

 *

 */

package factory.abstractfactory;

/**

 * @author lilin

 *

 */

public class Milk implements IBreakFast {

    @Override

    public void eat() {

        System.out.println("喝牛奶！");

    }

}

/**

 *

 */

package factory.abstractfactory;

/**

 * @author lilin

 *

 */

public class Orange implements IBreakFast {

    @Override

    public void eat() {

        System.out.println("吃橘子!");

    }

}

3.定义好抽象的工厂接口，一系列的获取实例的接口方法：

/**

 *

 */

package factory.abstractfactory;

import factory.simple.Car;

/**

 * @author lilin

 *

 */

public interface IAbstractFactory {

    /**

     *

     * @return

     */

    Car getCar();

    /**

     *

     */

    IBreakFast getBreakFast();

}

4.定义具体的工厂生产类，具体的产品实例返回。

/**

 *

 */

package factory.abstractfactory;

import factory.simple.Bike;

import factory.simple.Car;

/**

 * @author lilin

 *

 */

public class LowPersonFactory implements IAbstractFactory {

    @Override

    public Car getCar() {

        return new Bike();

    }

    @Override

    public IBreakFast getBreakFast() {

        return new Orange();

    }

}

/**

 *

 */

package factory.abstractfactory;

import factory.simple.Bus;

import factory.simple.Car;

/**

 * @author lilin

 *

 */

public class HighPersonFactory implements IAbstractFactory {

    @Override

    public Car getCar() {

        return new Bus();

    }

    @Override

    public IBreakFast getBreakFast() {

        return new Milk();

    }

}

最后，通过testNG简单测试下，抽象工厂模式的实现：代码如下：

/**

 *

 */

package factory.abstractfactory;

import org.testng.annotations.Test;

import factory.simple.Car;

/**

 * @author lilin

 *

 */

public class AbstractFactoryTest {

    @Test

    public void test() {

        IAbstractFactory factory = new LowPersonFactory();

        Car car = factory.getCar();

        IBreakFast breakFast = factory.getBreakFast();

        System.out.println("吃的早饭是：");

        breakFast.eat();

        System.out.println("上班交通工具是：");

        car.gotowork();

        IAbstractFactory factory2 = new HighPersonFactory();

        car = factory2.getCar();

        breakFast = factory2.getBreakFast();

        System.out.println("吃的早饭是：");

        breakFast.eat();

        System.out.println("上班交通工具是：");

        car.gotowork();

    }

}

这样使用过程城中，只要注入抽象的工厂接口，具体的产品的产生，会在实际的子类工厂类中产生，也可以随意的添加和修改实际子类工厂类，而不需要改变既有的代码设计。

抽象工厂方法：一般常常使用于一套程序，需要多套实现的场景之下。

巴特西

java 抽象工厂模式简单实例

最新文章

热门文章