工厂模式

一：new的问题

常规对象的创建方法：ClassA a=new ClassA();

new 的问题：紧耦合，实现依赖，不能应对“具体实例化类型”的变化。比如所有new ClassA的地方全部要换成 ClassB，如果是个大型项目那改动非常大。

解决思路：那里变化，封装哪里。

二：工厂模式的缘起

1：变化点在“对象创建”，因此就封装“对象的创建”。

2：面向接口编程--依赖接口，而非实现。

3：最简单的解决办法。

public class RoadFactory
{
    public static Road CreateRoad()
    {
            return new Road();
    }
　　public static Build CreateBuild()
   {return new Build();}
}

//客户调用程序
//Road 对象的创建依赖于RoadFactory，而不是new，如果Road的创建换成
//RoadB只需要在CreateRoad里return RoadB就可以了，只需要更改这一个
//地方。而不用向以前更改所有代码。增加可维护性。
Road a= RoadFactory.CreateRoad();

 上面是一个简单工厂的解决方案，也可以叫静态工厂。但是他只能解决一个系列工厂的创建，不能解决多个系列工厂的创建。这个系列包含普通道路，普通建筑，如果要创建柏油道路和摩天大厦呢？抽象工厂由此产生。

三：抽象工厂

1：动机，在软件系统中，经常面临“一系列相互依赖的对象”的创建工作；同时，由于需求的变化，往往存在更多系列对象的创建。

2：要点，如果没有应对“多系列对象构建”的需求变化，则没有必要使用抽象工厂，这时候使用简单工厂完全可以；“系列对象”指的是这些对象之间有相互依赖，或作用的关系，例如游戏开发中“道路”与“房屋”的依赖，“道路”与“地道”的依赖；ABSTRACT FACTORY模式主要应对“新系列”的需求变动，比如，经常变换的装修风格。其缺点在于难以应对“增加新对象”的需求变动，其系列对象的组成是稳定的，系列对象的组合不经常发生增减；抽象工厂常喝工厂方法模式共同组合来应对“对象创建”的需求变化。

3：实现

public interface Road{

}
public interface Building{

}

public class ModenRoad implements Road{
    
}
public class ModenBuilding implements Building{
    
}

public class ModenFaFactory implements FaFactory{
    public Road createRoad(){
    return new ModenRoad();
    }

    public Building createBuilding(){
    return new ModenBuilding();
    }
}
public class GameManager{
    private FaFactory faFactory;
    public GameManager(FaFactory faFactory){
    this.faFactory=faFactory;
    }

    public void buildGameFa(){
    Road road = faFactory.createRoad();
    Building building = faFactory.createBuilding();
    }
}

public interface FaFactory{
    public Road createRoad();
    public Building createBuilding();
}

客户端程序

public class Test{
    public static void main(String args[]){
    FaFactory factory = new ModenFaFactory();
    GameManager gm = new GameManager(factory);
    gm.buildGameFa();
    System.out.println("ss");
    }
}

工厂模式分为：简单工厂，工厂方法，抽象工厂。