抽象工厂模式与工厂模式的区别-代码比较

下面我将结合示例再具体说明工厂模式和抽象工厂模式的区别。

首先，我们假设有一个饮料店，它提供多种饮料，如可乐、雪碧、果汁等。我们可以使用工厂模式来创建这些饮料对象。首先，我们需要定义一个饮料接口 Drink：

public interface Drink {
    String getName();
}

然后，我们可以定义多个实现该接口的类，如 Coke、Sprite、Juice：

public class Coke implements Drink {
    @Override
    public String getName() {
        return "可乐";
    }
}

public class Sprite implements Drink {
    @Override
    public String getName() {
        return "雪碧";
    }
}

public class Juice implements Drink {
    @Override
    public String getName() {
        return "果汁";
    }
}

接着，我们定义一个工厂类 DrinkFactory，它提供了一个静态方法 createDrink，用于创建饮料对象：

public class DrinkFactory {
    public static Drink createDrink(String type) {
        if ("coke".equals(type)) {
            return new Coke();
        } else if ("sprite".equals(type)) {
            return new Sprite();
        } else if ("juice".equals(type)) {
            return new Juice();
        } else {
            throw new IllegalArgumentException("unsupported drink type");
        }
    }
}

最后，在饮料店中，我们可以使用工厂类来创建饮料对象，如：

public class DrinkShop {
    public void prepareDrink(String type) {
        Drink drink = DrinkFactory.createDrink(type);
        System.out.println("准备一杯" + drink.getName());
    }
}

public class Main {
    public static void main(String[] args) {
        DrinkShop drinkShop = new DrinkShop();
        drinkShop.prepareDrink("coke");
        drinkShop.prepareDrink("juice");
    }
}

在这个示例中，我们使用了工厂模式来创建饮料对象。工厂类 DrinkFactory 负责根据不同的类型创建不同的饮料对象，客户端代码只需要指定饮料类型即可。由于工厂模式只涉及单个对象的创建，因此使用起来非常简单和方便。

接下来，我们再看一个使用抽象工厂模式的示例。假设我们正在开发一个电子产品销售网站，它需要销售多种电子产品，如手机、电脑、平板等。我们可以使用抽象工厂模式来创建这些电子产品对象。

首先，我们需要定义多个产品接口，如 Phone、Computer、Tablet：

public interface Phone {
    String getName();
}

public interface Computer {
    String getName();
}

public interface Tablet {
    String getName();
}

然后，我们可以定义多个实现这些接口的类，如 IPhone、HuaweiPhone、DellComputer、LenovoComputer、IPad、Surface 等：

public class IPhone implements Phone {
    @Override
    public String getName() {
        return "iPhone";
    }
}

public class HuaweiPhone implements Phone {
    @Override
    public String getName() {
        return "华为手机";
    }
}

public class DellComputer implements Computer {
    @Override
    public String getName() {
        return "戴尔电脑";
    }
}

public class LenovoComputer implements Computer {
    @Override
    public String getName() {
        return "联想电脑";
    }
}

public class IPad implements Tablet {
    @Override
    public String getName() {
        return "iPad";
    }
}

public class Surface implements Tablet {
    @Override
    public String getName() {
        return "Surface平板";
    }
}

接着，我们定义一个抽象工厂类 ProductFactory，它定义了多个抽象工厂方法，每个方法用于创建一个不同的电子产品对象：

public interface ProductFactory {
    Phone createPhone();
    Computer createComputer();
    Tablet createTablet();
}

然后，我们为每个具体的电子产品类型实现一个工厂类，如 AppleProductFactory、HuaweiProductFactory、DellProductFactory、LenovoProductFactory 等，这些工厂类均实现了 ProductFactory 接口：

 public class AppleProductFactory implements ProductFactory { 

@Override public Phone createPhone() { 
	return new IPhone(); 
}

@Override
public Computer createComputer() {
    return new MacComputer();
}

@Override
public Tablet createTablet() {
    return new IPad();
}
 

public class HuaweiProductFactory implements ProductFactory { 

@Override 
public Phone createPhone() { 
	return new HuaweiPhone(); 
}

@Override
public Computer
//...省略部分实现代码 }

public class DellProductFactory implements ProductFactory { 

@Override 
public Phone createPhone() { 
	return new NokiaPhone(); 
}

@Override
public Computer createComputer() {
    return new DellComputer();
}

@Override
public Tablet createTablet() {
    return new Surface();
}
}

public class LenovoProductFactory implements ProductFactory { 

@Override 
public Phone createPhone() { 
	return new MotorolaPhone(); 
}

@Override
public Computer createComputer() {
    return new LenovoComputer();
}

@Override
public Tablet createTablet() {
    return new LenovoTablet();
}
}

最后，在电子产品销售网站中，我们可以使用相应的工厂类来创建电子产品对象，如：

public class ProductShop {
    private ProductFactory factory;
    
    public ProductShop(ProductFactory factory) {
        this.factory = factory;
    }

    public void sell() {
        Phone phone = factory.createPhone();
        Computer computer = factory.createComputer();
        Tablet tablet = factory.createTablet();
        System.out.println("销售一套电子产品：" + phone.getName() + "、" + computer.getName() + "、" + tablet.getName());
    }
}

public class Main {
    public static void main(String[] args) {
        ProductShop shop = new ProductShop(new AppleProductFactory());
        shop.sell();

        shop = new ProductShop(new HuaweiProductFactory());
        shop.sell();

        shop = new ProductShop(new DellProductFactory());
        shop.sell();

        shop = new ProductShop(new LenovoProductFactory());
        shop.sell();
    }
}

在这个示例中，我们使用了抽象工厂模式来创建电子产品对象。每个工厂类都负责创建一个相关的电子产品族，如苹果电子产品，华为电子产品等，工厂方法的数量与产品族数目相等。用于创建的方法涵盖了整个电子产品族，而不是单个产品。这样，我们就能够轻松地扩展产品族而无需修改代码，使得该模式非常适合于开发大型系统或框架。