一、简单工厂模式 又叫静态工厂方法模式
是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
缺点：
拓展性差，额外增加一个具体产品类时，需要修改工厂。
一个例子：
我喜欢吃面条，抽象一个面条基类，(接口也可以)，这是产品的抽象类。
public abstract class Noodles {
//描述每种面条啥样的
public abstract void desc();
}
先来一份兰州拉面（具体的产品类）：
程序员加班必备也要吃泡面（具体的产品类）：
还有我最爱吃的家乡的干扣面（具体的产品类）：
public class LzNoodles extends Noodles{
@Override
public void desc() {
System.out.println("兰州拉面 上海的好贵");
}
}
public class PaoNoodles extends Noodles{
@Override
public void desc() {
System.out.println("泡面-程序员加班必备");
}
}
public class GankouNoodles extends Noodles {
@Override
public void desc() {
System.out.println("还是家里的干扣面好吃 6块一碗");
}
}
准备工作做完了，我们来到一家“简单面馆”（简单工厂类）
public class NoodlesFactory {
public static Noodles createNoodles(String name){
if(name == "兰州拉面"){
return new LzNoodles();
}else if(name == "泡面"){
return new PaoNoodles();
}else if(name == "干扣面"){
return new GankouNoodles();
}
return null;
}
}
简单面馆就提供三种面条（产品），你说你要啥，他就给你啥。这里我点了一份干扣面:
Noodles noodles = NoodlesFactory.createNoodles("干扣面");
noodles.desc();
输出：
还是家里的干扣面好吃 6块一碗
二. 工厂方法模式
通过定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象。
优点：提高了程序拓展性，降低了程序间耦合度，
缺点：当具体产品种类非常多时，会出现大量的与之对应的具体子工厂对象，程序变得
使用步
步骤1： 创建抽象工厂类，定义具体工厂的公共接口
abstract class Factory{
public abstract Product Manufacture();
}
步骤2： 创建抽象产品类 ，定义具体产品的公共接口；
abstract class Product{
public abstract void Show();
}
步骤3： 创建具体产品类（继承抽象产品类）， 定义生产的具体产品；
//具体产品A类
class ProductA extends Product{
@Override
public void Show() {
System.out.println("生产出了产品A");
}
}
//具体产品B类
class ProductB extends Product{
@Override
public void Show() {
System.out.println("生产出了产品B");
}
}
步骤4：创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；
//工厂A类 - 生产A类产品
class FactoryA extends Factory{
@Override
public Product Manufacture() {
return new ProductA();
}
}
//工厂B类 - 生产B类产品
class FactoryB extends Factory{
@Override
public Product Manufacture() {
return new ProductB();
}
}
步骤5：外界通过调用具体工厂类的方法，从而创建不同具体产品类的实例
/生产工作流程
public class FactoryPattern {
public static void main(String[] args){
//客户要产品A
FactoryA mFactoryA = new FactoryA();
mFactoryA.Manufacture().Show();
//客户要产品B
FactoryB mFactoryB = new FactoryB();
mFactoryB.Manufacture().Show();
}
}
结果：
生产出了产品A 生产出了产品C
三. 抽象工厂模式
实现的条件：
1.将产品工厂抽象化，为每一个具体产品类提供一个具体产品子工厂
2.对应在子工厂中提供去获取该具体产品对象的方法
3.在设计程序时要严格划分产品的等级关系
优点：限制了程序自由拓展
缺点：程序的拓展性变差，耦合度增加
使用场景：1.解决工厂方法模式带来的弊端
Nike和Adidas公司在生产鞋的同时，都还在生产衣服，那么，这种情况用工厂模式就不能做到了，因此产生了抽象工厂模式。
抽象工厂模式的适用范围比工厂模式更加广泛，它与工厂模式最大的区别在于：
工厂模式中一个工厂只能生产一种产品，而抽象工厂可以生产多个。
Shoes
public interface Shoes {
public void wear();
}
AdidasShoes
public class AdidasShoes implements Shoes{
@Override
public void wear() {
System.out.println("Wear Adidas Shoes");
}
}
NikeShoes
public class NikeShoes implements Shoes{
@Override
public void wear() {
System.out.println("Wear Nike Shoes");
}
}
Clothes
public interface Clothes {
public void wear();
}
NikeClothes
public class NikeClothes implements Clothes{
@Override
public void wear() {
System.out.println("Wear Nike Clothes");
}
}
AdidasClothes
public class AdidasClothes implements Clothes{
@Override
public void wear() {
System.out.println("Wear Adidas Clothes");
}
}
LabourFactory
public interface LabourFactory {
Shoes produceShoes();
Clothes produceClothes();
}
NikeFactory
public class NikeFactory implements LabourFactory{
@Override
public Shoes produceShoes() {
System.out.println("Produce Nike Shoes");
return new NikeShoes();
}
@Override
public Clothes produceClothes() {
System.out.println("Produce Nike Clothes");
return new NikeClothes();
}
}
AdidasFactory
public class AdidasFactory implements LabourFactory{
@Override
public Shoes produceShoes() {
System.out.println("Produce Adidas Shoes");
return new AdidasShoes();
}
@Override
public Clothes produceClothes() {
System.out.println("Produce Adidas Clothes");
return new AdidasClothes();
}
}