请分别写一个简单工厂、工厂方法、抽象工厂模式的Java代码

好的，下面分别给出简单工厂、工厂方法、抽象工厂模式的Java代码示例。

1. 简单工厂模式

首先，定义一个产品接口 `Product`：

public interface Product {
    void use();
}

然后，定义具体的产品类 `ProductA` 和 `ProductB`：

public class ProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

public class ProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

接着，定义一个工厂类 `ProductFactory` 用于创建产品：

public class ProductFactory {
    public static Product createProduct(String type) {
        Product product = null;
        if ("A".equals(type)) {
            product = new ProductA();
        } else if ("B".equals(type)) {
            product = new ProductB();
        }
        return product;
    }
}

最后，客户端调用：

public static void main(String[] args) {
    Product productA = ProductFactory.createProduct("A");
    productA.use();
    
    Product productB = ProductFactory.createProduct("B");
    productB.use();
}

输出结果为：

使用产品A
使用产品B

2. 工厂方法模式

首先，定义一个抽象产品类 `Product`：

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

然后，定义具体的产品类 `ProductA` 和 `ProductB`：

public class ProductA extends Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

public class ProductB extends Product {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

接着，定义一个抽象工厂类 `ProductFactory`，其中包含一个抽象的创建产品的方法 `createProduct()`：

public abstract class ProductFactory {
    public abstract Product createProduct();
}

然后，定义具体的工厂类 `ProductAFactory` 和 `ProductBFactory`，分别用于创建产品 `ProductA` 和 `ProductB`：

public class ProductAFactory extends ProductFactory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

public class ProductBFactory extends ProductFactory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

最后，客户端调用：

public static void main(String[] args) {
    ProductFactory factoryA = new ProductAFactory();
    Product productA = factoryA.createProduct();
    productA.use();
    
    ProductFactory factoryB = new ProductBFactory();
    Product productB = factoryB.createProduct();
    productB.use();
}

输出结果为：

使用产品A
使用产品B

3. 抽象工厂模式

首先，定义一个抽象产品族 `AbstractProduct`，其中包含一个抽象方法 `use()`：

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

然后，定义具体的产品类 `ProductA` 和 `ProductB`，它们属于不同的产品族：

public class ProductA extends AbstractProduct {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

public class ProductB extends AbstractProduct {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

接着，定义一个抽象工厂类 `AbstractFactory`，其中包含两个抽象的创建产品的方法 `createProductA()` 和 `createProductB()`：

public abstract class AbstractFactory {
    public abstract AbstractProduct createProductA();
    public abstract AbstractProduct createProductB();
}

然后，定义具体的工厂类 `ProductAFactory` 和 `ProductBFactory`，分别用于创建产品族 `ProductA` 和 `ProductB`：

public class ProductAFactory extends AbstractFactory {
    @Override
    public AbstractProduct createProductA() {
        return new ProductA();
    }

    @Override
    public AbstractProduct createProductB() {
        return null;
    }
}

public class ProductBFactory extends AbstractFactory {
    @Override
    public AbstractProduct createProductA() {
        return null;
    }

    @Override
    public AbstractProduct createProductB() {
        return new ProductB();
    }
}

最后，客户端调用：

public static void main(String[] args) {
    AbstractFactory factoryA = new ProductAFactory();
    AbstractProduct productA = factoryA.createProductA();
    productA.use();
    
    AbstractFactory factoryB = new ProductBFactory();
    AbstractProduct productB = factoryB.createProductB();
    productB.use();
}

输出结果为：

使用产品A
使用产品B