工厂模式实现方式

• 第一种实现方式
  首先定义接口（Car）

public interface Car {
    public void run();
}

然后是两个具体实现：

public class JeepCar implements Car{

    @Override
    public void run() {
        System.out.println("Jeep run.");
    }

}

public class FordCar implements Car {

    @Override
    public void run() {
        System.out.println("Ford run.");
    }

}

再是一个工厂类：

public class CarFactory {
    public static Car createCar(Class<? extends Car> car) {
        try {
            if (JeepCar.class.equals(car)) {
                return (JeepCar) car.newInstance();
            }
            if (FordCar.class.equals(car)) {
                return (FordCar) car.newInstance();
            }
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}

最后是测试类：

public class CarTest {
    public static void main(String[] args) {
        //第一种方式
        JeepCar jc = (JeepCar) CarFactory.createCar(JeepCar.class);
        jc.run();

        //枚举方式
//      FordCar fc = (FordCar) CarEnumFactory.createCar(CarEnum.FORDCAR);
//      fc.run();
    }
}

• 第二种实现方式
  第二种方式使用了枚举类，声明类一个工厂可以生产的汽车的枚举，这样既避免了一些判断，也使代码显得比较简洁。

接口类、具体实现同上。
新增枚举类：

/**
 * 声明能生成car的种类
 * @author lrz
 *
 */
public enum CarEnum {
    JEEPCAR, FORDCAR;
}

新的工厂类：

public class CarEnumFactory {
    public static Car createCar(CarEnum car){
        switch (car) {
        case JEEPCAR:
            return new JeepCar();
        case FORDCAR:
            return new FordCar();
        default:
            break;
        }
        return null;
    }
}

测试类：

public class CarTest {
    public static void main(String[] args) {
        //第一种方式
//      JeepCar jc = (JeepCar) CarFactory.createCar(JeepCar.class);
//      jc.run();

        //枚举方式
        FordCar fc = (FordCar) CarEnumFactory.createCar(CarEnum.FORDCAR);
        fc.run();
    }
}