[Java知识库]设计模式之工厂模式

工厂模式

简单工厂模式

属于创建型工厂模式，由一个工厂类决定创建出哪种类的实例，这个类封装了实例化对象的行为，是工厂模式中最简单使用的模式。

package SimpleFactory;

/**
 * 简单工厂模式(也可以叫静态工厂模式)
 */
public class SimpleFactory {

    //工厂类的静态方法
    public static Product getProduct(String className){
        Product product = null;
        //根据条件判断生成相应的类实例
        if("A".equals(className)){
            product =  new Son1Product();
        }
        if("B".equals(className)){
            product = new Son2Product();
        }
        return product;
    }
}

//父类
abstract class Product{

    public abstract void getProduct();
}

//子类1
class Son1Product extends Product{

    @Override
    public void getProduct() {
        System.out.println("son1调用getProduct方法");
    }
}

//子类2
class Son2Product extends Product{

    @Override
    public void getProduct() {
        System.out.println("son2调用getProduct方法");
    }
}

class MainClass{
    public static void main(String[] args) {
        Product product = SimpleFactory.getProduct("A");
        product.getProduct();
    }
}

工厂方法模式

定义一个创建对象的抽象方法，由子类决定要实例化的类。将对象的实例化推迟到子类中。

package SimpleFactory;

/**
 * 工厂方法模式
 */
public abstract class FactoryMethod {

    abstract Pizza getPizza(Integer data);
}

//单数的工厂子类
class SingleSonFactory extends FactoryMethod{

    @Override
    Pizza getPizza(Integer data) {
        Pizza pizza = null;
        if(data ==1){
            pizza = new Son1Pizza();
        }
        if(data ==3){
            pizza = new Son3Pizza();
        }
        return pizza;
    }
}

//双数的工厂子类
class DoubleSonFactory extends FactoryMethod{

    @Override
    Pizza getPizza(Integer data) {
        Pizza pizza = null;
        if(data == 2){
            pizza = new Son2Pizza();
        }
        if(data == 4){
            pizza = new Son4Pizza();
        }
        return pizza;
    }
}
//父类
abstract class Pizza{

    public abstract void getPizza();
}

//子类1
class Son1Pizza extends Pizza{

    @Override
    public void getPizza() {
        System.out.println("son1调用getSon方法");
    }
}

//子类2
class Son2Pizza extends Pizza{

    @Override
    public void getPizza() {
        System.out.println("son2调用getSon方法");
    }
}

//子类1
class Son3Pizza extends Pizza{

    @Override
    public void getPizza() {
        System.out.println("son3调用getSon方法");
    }
}

//子类1
class Son4Pizza extends Pizza{

    @Override
    public void getPizza() {
        System.out.println("son4调用getSon方法");
    }
}

class MainFactoryMethodClass{
    public static void main(String[] args) {
        Pizza pizza = new SingleSonFactory().getPizza(3);
        pizza.getPizza();
    }
}

抽象工厂模式

定义一个接口用于创建相关或有依赖关系的对象簇，而无需指定具体的类，可以看成是将简单工厂模式和工厂方法模式的整合。

package SimpleFactory;

/**
 * 抽象工厂模式
 */
public interface AbstractFactory {

    Pizza getPizza(Integer data);

}

单数的工厂子类
class SingleSonFactory implements AbstractFactory{

    @Override
    public Pizza getPizza(Integer data) {
        Pizza pizza = null;
        if(data ==1){
            pizza = new Son1Pizza();
        }
        if(data ==3){
            pizza = new Son3Pizza();
        }
        return pizza;
    }
}

//双数的工厂子类
class DoubleSonFactory implements AbstractFactory{

    @Override
    public Pizza getPizza(Integer data) {
        Pizza pizza = null;
        if(data == 2){
            pizza = new Son2Pizza();
        }
        if(data == 4){
            pizza = new Son4Pizza();
        }
        return pizza;
    }
}

//父类
abstract class Pizza{

    public abstract void getPizza();
}

//子类1
class Son1Pizza extends Pizza{

    @Override
    public void getPizza() {
        System.out.println("son1调用getSon方法");
    }
}

//子类2
class Son2Pizza extends Pizza{

    @Override
    public void getPizza() {
        System.out.println("son2调用getSon方法");
    }
}

//子类1
class Son3Pizza extends Pizza{

    @Override
    public void getPizza() {
        System.out.println("son3调用getSon方法");
    }
}

//子类1
class Son4Pizza extends Pizza{

    @Override
    public void getPizza() {
        System.out.println("son4调用getSon方法");
    }
}

class MainAbstractFactory{
    public static void main(String[] args) {
        getInstance(new SingleSonFactory());
    }
    
    public static void getInstance(AbstractFactory abstractFactory){
        abstractFactory.getPizza(1);
    }
}

JDK中Calendar类就使用了简单工厂模式