工厂：故名思议，就是用来制造各种产品的，在程序中主要是用来创建对象。
- 首先介绍下简单工厂（也称静态工厂）
class Car{
public void run(){
System.out.println("小车正在跑。。");
}
}
public class SampleFactoryTest {
public static void main(String[] args) {
//调用者创建一个Car
Car car = new Car();
//调用者调用run方法
car.run();
}
}
通过以上代码，你有没有发现一个问题。就是调用者（main方法）在调用小车的run()之前还需要创建一个Car对象，就好比你想要开车，你会不会自己先做一辆车然后再去开？我想你不会的。所以为了让调用者和创建者分离，工厂设计模式应允而生。
class Car{
public void run(){
System.out.println("小车正在跑。。");
}
}
/**
* 汽车工厂
*
*/
class CarFactory{
//加上static方便调用，也称静态工厂
public static Car createCar(){
return new Car();
}
}
public class SampleFactoryTest {
public static void main(String[] args) {
//通过工厂创建一个Car
Car car = CarFactory.createCar();
//调用者调用run方法
car.run();
}
}
实际应用当然不止才一个类型的车，下面是一个详细的例子：
interface Car{
public void run();
}
class Benz implements Car{
@Override
public void run() {
System.out.println("奔驰在跑...");
}
}
class Bmw implements Car{
@Override
public void run() {
System.out.println("宝马在跑...");
}
}
/**
* 汽车工厂
*
*/
class CarFactory{
/**
* 简单工厂一般加上static方便访问
* 通过不同类型获得不同的车
* @param type 类型
* @return 车
*/
public static Car createCar(String type){
Car car = null;
if(type.equals("benz")){
car = new Benz();
} else if(type.equals("bmw")){
car = new Bmw();
}
return car;
}
}
/**
* 也可以为每一种汽车写一个单独的方法
*/
class CarFactory2{
/**
* 简单工厂一般加上static方便访问
* 通过不同类型获得不同的车
* @param type 类型
* @return 车
*/
public static Car createBenz(){
return new Benz();
}
public static Car createBmw(){
return new Bmw();
}
}
public class SampleFactoryTest {
public static void main(String[] args) {
//通过工厂创建一个Benz
//Car benz = CarFactory.createCar("benz");
//Car bmw = CarFactory.createCar("bmw");
Car benz = CarFactory2.createBenz();
Car bmw = CarFactory2.createBmw();
//调用者调用run方法
benz.run();
bmw.run();
}
}
到这里一个简单工厂的实现已经完成，但是现在会有一个新的问题，当你要新增Car的时候，势必要去修改工厂方法来适应新的需求，这样便破坏了Open-closed Principle，下面是修改后的：
interface Car{
public void run();
}
class Benz implements Car{
@Override
public void run() {
System.out.println("奔驰在跑...");
}
}
class Bmw implements Car{
@Override
public void run() {
System.out.println("宝马在跑...");
}
}
/**
* 将工厂抽象为接口
*
*/
interface CarFactory{
Car createCar();
}
/**
* 奔驰工厂
*
*/
class BenzFactory implements CarFactory{
@Override
public Car createCar() {
return new Benz();
}
}
/**
* 宝马工厂
*
*/
class BmwFactory implements CarFactory{
@Override
public Car createCar() {
return new Bmw();
}
}
public class SampleFactoryTest {
public static void main(String[] args) {
//通过工厂创建对象
Car benz = new BenzFactory().createCar();
Car bmw = new BmwFactory().createCar();
//调用者调用run方法
benz.run();
bmw.run();
}
}
以上就是工厂方法模式，和简单工厂略有不同，通过抽象工厂为接口解决了OCP，现在的这个工厂变得更好扩展了，但其实这种写法复杂了很多，还是看你怎么取舍了吧。
