工厂模式

工厂模式：许多类型对象的创造需要一系列的步骤：你可能需要计算或取得对象的初始设置；选择生成哪个子对象的实例；
或在生成你需要的对象之前必须先生成一些辅助功能的对象。在这些情况下，新对象的简历就是一个“过程”，不仅是操作
，像是一个大机器的一个齿轮传动。

模式的问题：你如何能轻松方便的构造对象实例，而不必关心构造对象实例的细节或复杂的过程呢？
解决方案：建立一个工厂来创建对象。

三 区别
工厂方法模式：
      每个具体工厂类只能创建一个具体产品类的实例
抽象工厂模式：

具体区别：
      工厂模式只有一个抽象产品类，而抽象工厂模式有多个抽象类。
      工厂方法模式的具体工厂类只能创建一个具体产品类的的实例，而抽象工厂模式可以创建多个实例。

1.1 描述

简单工厂模式是由一个工厂对象根据收到的消息决定要创建哪一个类的对象实例。

1.2 使用场景

      工厂类负责创建的对象比较少，客户只需要传入工厂类参数，对于如何创建对象（逻辑）不关心。简单工厂模式很容易违反高内聚低耦合的原则，因此一般只在很简单的情况下使用。

1.3 优点

最大的优点在于工厂类中包含了必要的逻辑，根据客户需要的逻辑动态实例化相关的类。

public interface Shape {

public void draw();

}
public class Circle implements Shape {

@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}

}
public class Rectangle implements Shape {

@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}

}
public class Square implements Shape {

@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}

}
public class ShapeFactory {

public Shape getShape(String type) {
if ("circle".equals(type)) {
return new Circle();
} else if ("rectangle".equals(type)) {
return new Rectangle();
} else if ("square".equals(type)) {
return new Square();
} else {
return null;
}
}

}
public class FactoryPatternDemo {

public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();
shapeFactory.getShape("circle").draw();
shapeFactory.getShape("rectangle").draw();
shapeFactory.getShape("square").draw();
}

}

同一个接口中的方法，经过不同的实现类去实现，至于具体调用具体的哪个类的哪个方法，可以写一个工厂类去
调用不同的方法。

3.1 描述

抽象工厂是围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。

3.2 使用场景

系统的产品多于一个产品族，而系统只消费某一族的产品。

3.3 优点

当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

3.4 例子

public interface Button {

public void processEvent();

}
public interface Text {

public void getWholeText();

}
public class LinuxButton implements Button {

@Override
public void processEvent() {
System.out.println("Inside LinuxButton::processEvent() method.");
}

}
public class WindowsButton implements Button {

@Override
public void processEvent() {
System.out.println("Inside WindowsButton::processEvent() method.");
}

}
public class LinuxText implements Text {

@Override
public void getWholeText() {
System.out.println("Inside LinuxText::getWholeText() method.");
}

}
public class WindowsText implements Text {

@Override
public void getWholeText() {
System.out.println("Inside WindowsText::getWholeText() method.");
}

}
public interface AbstractFactory {

public Button createButton();

public Text createText();

}
public class LinuxFactory implements AbstractFactory {

@Override
public Button createButton() {
return new LinuxButton();
}

@Override
public Text createText() {
return new LinuxText();
}

}
public class WindowsFactory implements AbstractFactory {

@Override
public Button createButton() {
return new WindowsButton();
}

@Override
public Text createText() {
return new WindowsText();
}

}
public class AbstractFactoryDemo {

public static void main(String[] args) {
AbstractFactory linuxFactory = new LinuxFactory();
linuxFactory.createButton().processEvent();
linuxFactory.createText().getWholeText();
AbstractFactory windowsFactory = new WindowsFactory();
windowsFactory.createButton().processEvent();
windowsFactory.createText().getWholeText();
}

}

4. 总结

无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。

在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。

经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它

就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。
所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。