java设计模式-工厂设计模式

工厂设计模式是创建型设计模式，有三种设计方法：简单工厂（产品父类），工厂模式（工厂父类），抽象工厂（父类接口）

一、简单工厂

简单工厂的设计思想是：

1、定义一个产品的父类

2、具体产品类继承父类

3、定义具体工厂，定义静态方法创造产品，使用产品父类作为静态方法的返回值类型。方法中使用switch或if语句，根据用户传入的参数类型，返回不同的产品。

    也可以是用反射的方法，参数类型设为class类型，最终得到所要的产品对象。

缺点：代码被写死，要想要增加产品，不仅需要新增产品类，还需要修改工厂类提供的产品类型，和生产产品的方法

二、工厂模式

工厂模式的设计思想

1、定义一个抽象的工厂的父类

2、定义具体工厂，继承抽象的父类工厂（一个工厂只能生产一种产品）

缺点：由于java中单继承的特点，每种工厂只能继承一个父类，也就是说只能生产一种产品。

三、抽象工厂

1、定义n个生产产品的工厂接口

2、定义具体工厂，这个工厂需要生产什么产品就继承对应的接口

优点：可以生产多种产品

简单工厂的代码实现如下：

/**
 * 第一步：定义产品的基类
 */
public abstract class Light{
    public abstract void create();
}

/**
 * 第二步：定义定义产品的具体类，继承产品基类
 */
public class CeilingLamp extends Light {
    public void create(){
        System.out.print("生产一个吸顶灯");
    }
}
public class DropLight extends Light {
    public void create(){
        System.out.print("生产一个吊灯");
    }
}
public class TableLamp extends Light {
    public void create(){
        System.out.print("生产一个台灯");
    }
}

/**
 * 第三步：定义工厂类，提供静态方法，根据实参生产所需产品
 */
public class SimpleFactory {
    final static int DROP_LIGHT = 1;
    final static int CEILING_LAMP = 2;
    final static int TABLE_LAMP = 3;
    //静态方法
    public static Light LightFactory(int type) {
        switch (type) {
            case DROP_LIGHT:
                return new DropLight();
            case CEILING_LAMP:
                return new CeilingLamp();
            case TABLE_LAMP:
                return new TableLamp();
            default:
                return new DropLight();
        }
    }
}

 工厂方法模式的实代码如下：

/**
 * 定义工厂，要生产什么产品，就直接使用静态方法返回就行
 */
public class FactoryMethods {
    /**
     * 生产吊灯的静态方法
     * @return
     */
    public static Light creDropLight(){
        return new DropLight();
    }

    /**
     * 生产吸顶灯的静态方法
     * @return
     */
    public static Light creCeilingLamp(){
        return new CeilingLamp();
    }

    /**
     * 生台灯的静态方法
     * @return
     */
    public static Light creTableLamp(){
        return new TableLamp();
    }
}

抽象工厂模式代码如下：

/**
 * 第一步：定义灯工厂的基类
 */
public abstract class LigthFactory {
    public abstract void create();
}

/**
 * 第二步：定义灯工厂的具体类，继承灯工厂
 */
public class CeilingLamp extends Light {
    public void create(){
        System.out.print("生产一个吸顶灯");
    }
}
public class DropLight extends LigthFactory {
    public void create(){
        System.out.print("生产一个吊灯");
    }
}
public class TableLamp extends Light {
    public void create(){
        System.out.print("生产一个台灯");
    }
}

/**
 *第三步：定义五金工厂的基类
 */
public abstract class MetalsFactory {
    public abstract void create();
}

/**
 * 第四步：定义具体工厂，继承抽象五金工厂
 */
public class LaundryRackFactory extends MetalsFactory {
    public void create(){
        System.out.print("生产一个晾衣架");
    }
}
public class WaterFaucetFactory extends MetalsFactory {
    public void create(){
        System.out.print("生产一个水龙头");
    }
}

/**
 * 第五步：定义工厂多功能工厂的基类，提供继承该基类的工厂所能卖的东西类型的方法
 */
public abstract class Factory {
    public abstract LigthFactory createLigths();
    public abstract MetalsFactory createMetals();
}

/**
 * 第六步：定义具体多功能工厂类，实现抽象多功能工厂，可卖各种东西
 */
public class MutiFactory extends Factory{
    public LigthFactory createLigths(){
        return new DropLight();
    }
    public MetalsFactory createMetals(){
        return new WaterFaucetFactory();
    }
}

总结：个人觉得工厂方法模式是最方便，最有效的设计模式，抽象工厂没明白好在哪。