有两类车分别是Audi和BMW，张三现在用的是Audi。
public interface Car {
public void description();
}
public class AudiCar implements Car{
public void description() {
System.out.println("AudiCar");
}
}
public class BMWCar implements Car{
public void description() {
System.out.println("BMWCar");
}
}
public class Client {
public static void main(String[] args) {
AudiCar audiCar = new AudiCar();
audiCar.description();
}
}
某一天，张三觉得Audi车车灯是在是太亮了，想换一辆BMW，则张三会这么做：
public class Client {
public static void main(String[] args) {
//AudiCar audiCar = new AudiCar();
//audiCar.description();
BMWCar bmwCar = new BMWCar();
bmwCar.description();
}
}
张三（调用方Client）自己去"造"了一辆BMW。
张三只是一个车主，当他需要一辆车时候，竟然需要自己去造车才能满足需求。
车主去造自己使用的车，实在是耸人听闻。毕竟专业的人干专业的事情嘛。造车还是非常复杂的，普通人根本干不了。
这个时候，车工厂（简单工厂）出现了，这个工厂能生产各种类型的车
//简单工厂模式
public class SimpleFactory {
public static Car getCar(String type){
switch (type) {//jdk1.7新特性switch支持string类型
case "BMW":
return new BMWCar();
case "Audi":
return new AudiCar();
default:
throw new RuntimeException(type+":类型不匹配");
}
}
}
于是张三不再需要自己去造车了，而是交给车工厂生产。
public class Client {
public static void main(String[] args) {
Car car = SimpleFactory.getCar("BMW");
car.description();
}
}
过了一段时间...
张三觉得Audi和BMW车不符合他的身份了（毕竟赚钱了嘛），想弄台RollsRoyce。
于是工厂紧急画了RollsRoyce图纸。
public class RollsRoyceCar implements Car{
public void description() {
System.out.println("RollsRoyceCar");
}
}
并把工厂升级，增加了RollsRoyce生产。
//简单工厂模式
public class SimpleFactory {
public static Car getCar(String type){
switch (type) {
case "BMW":
return new BMWCar();
case "Audi":
return new AudiCar();
case "RollsRoyce":
return new RollsRoyceCar();
default:
throw new RuntimeException(type+":类型不匹配");
}
}
}
似乎是没有问题，但仔细想想，在这个过程中简单工厂进行了大改动（进行了原有的代码修改）。
有没有方法能不改动工厂，实现张三的需求呢。
有人就想：为什么各种类型车的制造要放到一个工厂呢，哪种类型的车就交给对应的工厂多好。
于是改造开始了。
public interface Factory {
Car getCar();
}
public class AudiCarFactory implements Factory{
public Car getCar() {
return new AudiCar();
}
}
public class BMWCarFactory implements Factory{
public Car getCar() {
return new BMWCar();
}
}
于是张三想换车就找对应的工厂生产车。
public class Client {
public static void main(String[] args) {
//工厂方法模式
Car car = new AudiCarFactory().getCar();
car.description();
Car car2 = new BMWCarFactory().getCar();
car2.description();
}
}
想换一辆没有的车，就只需要增加对应的工厂即可。
public class RollsRoyceCarFactory implements Factory{
public Car getCar() {
return new RollsRoyceCar();
}
}
就这样各个工厂生产了10年，随着人们的消费水平越来越高，当然张三已经是个富豪了，人们需要游艇出游的愿望越来越强烈，各个工厂看到了商机，纷纷对自家的工厂进行了升级改造，使得工厂不仅能生产传统的车，还能生产船。
这里以BMWCarFactory为例子
public interface Boat {
void description();
}
public class BMWBoat implements Boat{
public void description() {
System.out.println("BMWBoat");
}
}
public class BMWCarFactory implements Factory{
public Car getCar() {
return new BMWCar();
}
public Boat getBoat() {
return new BMWBoat();
}
}
好了，BMWCarFactory 即可以生产car也能生产boat了（但是都是属于BMW品牌的）。
补充：我们这里说的汽车制造很复杂对应代码里面是对象业务逻辑很复杂，对于调用者（client）来说根本不需要了解其中的运行原理。
总结:
简单工厂：是对业务逻辑的初级封装，使得具体的new操作和调用者隔离开来（针对接口编程，减少程序之间的耦合）。
工厂方法：拥有简单工厂的优点，同时解决了简单工厂内部之间的耦合，但是缺点是增加了一些额外的类，使得类层次变得稍微复杂（但是符合开闭原则，对修改关闭，对扩展开发，扩展就必须要增加额外的类）。这个工厂适合生产同一品牌的一种（实现同一接口）商品（比如BMW品牌的车）。
抽象工厂：抽象工厂方法并不解决工厂方法的问题，是对工厂方法的加强（对功能进行加强，对扩展性没有改变）这个工厂适合生产同一品牌不同种类（实现不同接口）的商品（比如BMW品牌的车和船）。
