工厂方法模式和抽象工厂模式

抽象工厂模式与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

工厂方法模式：

package com.java.object;

/**
 * 工厂方法模式示例
 */
public class FactoryMethod {
    public static void main(String... args) {
        CarFactory bmwFactory = new BMWFactory();
        CarFactory benzFactory = new BenzFactory();
        Car bmw = bmwFactory.createCar();
        Car benz = benzFactory.createCar();

        bmw.drive();
        benz.drive();
    }
}

interface Car {
    public void drive();
}

interface CarFactory {
    public Car createCar();
}

class BMW implements Car {

    @Override
    public void drive() {
        System.out.println("drive bmw");
    }
}

class Benz implements Car {

    @Override
    public void drive() {
        System.out.println("drive benz");
    }
}

class BMWFactory implements CarFactory {

    @Override
    public Car createCar() {
        return new BMW();
    }
}

class BenzFactory implements CarFactory {

    @Override
    public Car createCar() {
        return new Benz();
    }
}

抽象工厂模式：

package com.java.object;


/**
 * 抽象工厂模式示例
 */
public class AbstractFactory {

    public static void main(String... args) {
        AbstractCarFactory carFactoryA = new CarFactoryA();
        AbstractCarFactory carFactoryB = new CarFactoryB();

        carFactoryA.createBenz();
        carFactoryB.createBmw();
    }

}

interface BmwCar {
    public void drive();
}

interface BenzCar {
    public void drive();
}

class Bmw320 implements BmwCar {

    @Override
    public void drive() {
        System.out.println("drive 320");
    }
}

class Bmw530 implements BmwCar {
    @Override
    public void drive() {
        System.out.println("drive 530");
    }
}

class BenzC implements BenzCar {
    @Override
    public void drive() {
        System.out.println("drive c class");
    }
}

class BenzE implements BenzCar {
    @Override
    public void drive() {
        System.out.println("drive e class");
    }
}

interface AbstractCarFactory {
    public BenzCar createBenz();
    public BmwCar createBmw();
}

class CarFactoryA implements AbstractCarFactory {

    @Override
    public BenzCar createBenz() {
        return new BenzC();
    }

    @Override
    public BmwCar createBmw() {
        return new Bmw320();
    }
}

class CarFactoryB implements AbstractCarFactory {

    @Override
    public BenzCar createBenz() {
        return new BenzE();
    }

    @Override
    public BmwCar createBmw() {
        return new Bmw530();
    }
}