Java的设计模式：

1：工厂模式

1.1简单工厂模式

优点：

简单工厂模式，封装了创建对象的逻辑，完成了创建对象逻辑与业务代码逻辑的解耦。
试想客户端是多个service层的文件，对比不使用简单工厂模式，当我们要改变产生对象的逻辑时，
需要在多个service文件中找到这部分代码进行修改。在使用简单工厂模式后，只需要修改简单工厂中生成对象的逻辑即可，
不需要修改业务代码。完成了解耦。

缺点：

每当具体产品类的抽象产品类增多时，会需要在简单工厂类中新增关于新增产品类对象生成的方法。
当抽象产品类很多时，抽象工厂会很臃肿。并且在这种情形下，SimpleFactory类也不符合开闭原则。

public class SimpleFactory {
    public static void main(String[] args) {
        A a = getFactory("A1");
        a.method();
        a = getFactory("A2");
        a.method();
    }
    public static A getFactory(String type){
          if("A1".equals(type)){
              return new A1();
          }else
              return new A2();
    }
}
interface A{
    void method();
}
class A1 implements  A{
    public void method(){
        System.out.println("A1-----------");
    }
}
class A2 implements  A{
    public void method(){
        System.out.println("A2-----------");
    }
}

 

1.2工厂模式

从简单工厂模式的讲述知道：简单工厂的一个缺点在于，每当需要新增产品时，
都需要修改负责生产产品的SimpleFactory类，违背了“开闭原则”，
并且会使SimpleFactory类十分的臃肿。

而使用工厂方法模式后，当新增ProductC时，
只需要对应创建具体产品类ProductC和负责生产ProductC的具体工厂FactoryC即可。符合“开闭原则”，便于扩展。

它的缺点在于：
（1）类的个数容易过多，增加复杂度
（2）实现抽象工厂接口的具体工厂只能生产出一种产品（可以用抽象工厂模式解决）

public class Factory {
    public static void main(String[] args) {
        B b1 = new B1Factory().getB();
        b1.method();
        B b2 = new B2Factory().getB();
        b2.method();
    }
}
interface B {
    void method();
}
class B1 implements B {
    @Override
    public void method() {
        System.out.println("B1----------");
    }
}
class B2 implements B {
    @Override
    public void method() {
        System.out.println("B2----------");
    }
}

interface Factorys {
    B getB();
}

class B1Factory implements Factorys {
    @Override
    public B getB() {
        return new B1();
    }
}

class B2Factory implements Factorys {
    @Override
    public B getB() {
        return new B2();
    }
}

1.3抽象工厂模式

抽象工厂模式是用于解决“一类产品”的创建问题（在上述场景中，可以把“李宁篮球”，“李宁足球”，“安踏篮球”，“安踏足球”归纳为：“篮球”，“足球”这两类商品）
 

public class AbstractFactory {
    public static void main(String[] args) {
        AbstractFactorys  lnFactory = new LNFactory();

        lnFactory.getFootballFactory().makeFootBall();
        lnFactory.getBasketballFactory().makeBasketBall();


        AbstractFactorys nkFactory  = new NKFactory();

        nkFactory.getFootballFactory().makeFootBall();
        nkFactory.getBasketballFactory().makeBasketBall();
    }
}
//抽象工厂
interface AbstractFactorys{
    Football   getFootballFactory();
    Basketball getBasketballFactory();
}
//抽象产品
interface Football{
    void makeFootBall();
}
interface Basketball{
    void makeBasketBall();
}
//具体产品
class LNFootball implements Football{
    @Override
    public void makeFootBall() {
        System.out.println("makeLNFootball-----------");
    }
}
class NKFootball implements Football{
    @Override
    public void makeFootBall() {
        System.out.println("makeNKFootball-----------");
    }
}
class LNBasketball implements Basketball{
    @Override
    public void makeBasketBall() {
        System.out.println("makeLNBasketball-----------");
    }
}
class NKBasketball implements Basketball{
    @Override
    public void makeBasketBall() {
        System.out.println("makeNKBasketball-----------");
    }
}
//具体工厂
class LNFactory implements AbstractFactorys{
    @Override
    public Football getFootballFactory() {
        return new LNFootball();
    }

    @Override
    public Basketball getBasketballFactory() {
        return new LNBasketball();
    }
}
class NKFactory implements AbstractFactorys{
    @Override
    public Football getFootballFactory() {
        return new NKFootball();
    }

    @Override
    public Basketball getBasketballFactory() {
        return new NKBasketball();
    }
}