关于工厂方法模式的Java实现

关于工厂方法模式的Java实现，可以通过以下几个步骤进行：

1. 定义抽象产品类

工厂方法模式中，抽象产品类是具体产品类的父类，规定了具体产品类的共性的属性和方法，代码如下所示：

public abstract class Product {
    public abstract void use();
}

2. 定义具体产品类

具体产品类是抽象产品类的子类，实现了抽象产品类中定义的属性和方法，这里我们定义两个具体产品类，分别为ProductA和ProductB，代码如下所示：

public class ProductA extends Product {
    public void use() {
        System.out.println("Using ProductA");
    }
}

public class ProductB extends Product {
    public void use() {
        System.out.println("Using ProductB");
    }
}

3. 定义抽象工厂类

抽象工厂类是具体工厂类的父类，抽象工厂类中定义了一个抽象方法createProduct()，该方法用于生产具体产品，代码如下所示：

public interface Factory {
    public Product createProduct();
}

4. 定义具体工厂类

具体工厂类实现了抽象工厂类中定义的抽象方法createProduct()，在该方法中实例化具体产品类，代码如下所示：

public class ProductAFactory implements Factory {
    public Product createProduct() {
        return new ProductA();
    }
}

public class ProductBFactory implements Factory {
    public Product createProduct() {
        return new ProductB();
    }
}

5. 测试工厂方法模式

下面我们可以通过一个示例来测试工厂方法模式中的类，示例代码如下所示：

public class TestFactory {
    public static void main(String[] args) {
        Factory factoryA = new ProductAFactory();
        Product productA = factoryA.createProduct();
        productA.use();

        Factory factoryB = new ProductBFactory();
        Product productB = factoryB.createProduct();
        productB.use();
    }
}

以上就是工厂方法模式的完整攻略。下面我们通过两个示例来说明工厂方法模式在代码中的应用：

示例1：

我们有一个冰箱商店，该商店供应两种品牌的冰箱，分别为Haier和Midea。下面是代码的实现：

public abstract class Fridge {
    public abstract void use();
}

public class HaierFridge extends Fridge {
    public void use() {
        System.out.println("Using HaierFridge");
    }
}

public class MideaFridge extends Fridge {
    public void use() {
        System.out.println("Using MideaFridge");
    }
}

public interface FridgeFactory {
    public Fridge createFridge();
}

public class HaierFridgeFactory implements FridgeFactory {
    public Fridge createFridge() {
        return new HaierFridge();
    }
}

public class MideaFridgeFactory implements FridgeFactory {
    public Fridge createFridge() {
        return new MideaFridge();
    }
}

public class TestFridge {
    public static void main(String[] args) {
        FridgeFactory haierFactory = new HaierFridgeFactory();
        Fridge haierFridge = haierFactory.createFridge();
        haierFridge.use();

        FridgeFactory mideaFactory = new MideaFridgeFactory();
        Fridge mideaFridge = mideaFactory.createFridge();
        mideaFridge.use();
    }
}

示例2：

我们有一个电脑商店，该商店供应两种品牌的电脑，分别为Dell和HP。下面是代码的实现：

public abstract class Computer {
    public abstract void use();
}

public class DellComputer extends Computer {
    public void use() {
        System.out.println("Using DellComputer");
    }
}

public class HPComputer extends Computer {
    public void use() {
        System.out.println("Using HPComputer");
    }
}

public interface ComputerFactory {
    public Computer createComputer();
}

public class DellComputerFactory implements ComputerFactory {
    public Computer createComputer() {
        return new DellComputer();
    }
}

public class HPComputerFactory implements ComputerFactory {
    public Computer createComputer() {
        return new HPComputer();
    }
}

public class TestComputer {
    public static void main(String[] args) {
        ComputerFactory dellFactory = new DellComputerFactory();
        Computer dellComputer = dellFactory.createComputer();
        dellComputer.use();

        ComputerFactory hpFactory = new HPComputerFactory();
        Computer hpComputer = hpFactory.createComputer();
        hpComputer.use();
    }
}

以上就是两个示例，可以看到，通过工厂方法模式，我们可以在不改变具体产品类和具体工厂类的前提下，增加新的具体产品类和具体工厂类，非常符合“开放-封闭”原则的要求。