java 设计模式之简单工厂模式

简单工厂模式遵循哪些原则

1.面向接口原则，即依赖倒置原则

为什么要使用简单工厂模式

1.规范编码，增加代码的整洁性可读性，有利于团队合作开发效率

为什么要学习简单工厂模式

1. 增强自己阅读优秀软件代码的能力。
2. 增强自己团队合作开发的团队智商，即团商。

我怎么学习简单工厂模式并运用到代码里。

1.利用便于自己理解的生活例子理解其思想
2.把那个例子写成代码。

一学习误区

1.学习工厂模式让代码整洁等同于代码开发者需要写的代码变少？
不是的，是让后来者阅读感觉整洁，代码开发者还要多写代码。

生活水果例子

1.平时我会吃一些水果，喜欢的水果品种也很多，像椰子，菠萝，苹果，香蕉，葡萄，我不需要自己种这些水果，首先自己种的话根本没有那么精力去种和照顾它们，为了吃到品种多品质优良的水果，我跟果商购买，果商给我打包，我直接带回家吃就完。
2.理解上面的例子，把我当做开发中的调用者，水果是被调用者，果商是工厂。
3.如果我不跟果商买，我自己种自己照顾水果，有一个问题是如果我的朋友兄弟和村里的村民都想吃水果，然后我让他们自己摘，人多了，果树那么背破坏，小孩子看到了别人都自己摘了他不会摘急的哭了，这样就麻烦了。果树被破坏，摘不到的人怨声载道，对我心生恨意。
4.为了以后方便，我就去买，不自己种。想吃水果都去买，没有纠纷。

代码

下面展示一些 没有工厂模式的代码和调用。。
水果

public class Coconut {
    public Coconut(){

    }

    public void eat(){
        Log.i("coconut","吃椰子");
    }
}

public class Pineapple {
    public Pineapple(){

    }

    public void eat(){
        Log.i("pineapple","吃菠萝");
    }
}

public class Apple {
    public Apple(){

    }

    public void eat(){
        Log.i("apple","吃苹果");
    }
}

public class AppleBag  {
  
    public void pack() {
        Log.i("coconut","打包苹果");
    }
}

public class CoconutBag {

    public void pack() {
        Log.i("coconut","打包椰子");
    }
}

public class PineAppleBag {
  
    public void pack() {
        Log.i("coconut","打包菠萝");
    }
}

调用者

public class User {

    public static void main(String[] args) {
       // eatConconut();  //想吃椰子的时候
       // eatPineapple(); //想吃菠萝的时候
       packApple();
        eatApple(); //想吃苹果的时候
    }

    public static void eatConconut(){//吃椰子
        Coconut co = new Coconut();
        co.eat();
    }
    public static void eatPineapple(){//吃菠萝
        Pineapple pineapple = new Pineapple();
        pineapple.eat();
    }
    public static void eatApple(){//吃苹果
        Apple apple = new Apple();
        apple.eat();
    }
 public static void packCoconut(){
        CoconutBag bag = new CoconutBag();
        bag.pack();
    }
 public static void packApple(){
        AppleBag  bag = new AppleBag();
        bag.pack();
    }
}
 public static void packPineapple(){
        PineAppleBag  bag = new PineAppleBag();
        bag.pack();
    }

以上代码看起来怎么样，看起来是不是感觉很正常没有问题，咋一看代码确实没问题，很合理。我学习到这里，我感觉很正常。于是我继续学工厂模式。
下面展示的是简单工厂模式的代码
水果代码

//水果接口
public interface Fruit {
    public void eat();
}

//包装接口
public interface Bag {

    public void pack();
}

public class Coconut implements Fruit{
    public Coconut(){

    }

    public void eat(){
        Log.i("coconut","吃椰子");
    }
}

public class Pineapple  implements Fruit{
    public Pineapple(){

    }

    public void eat(){
        Log.i("pineapple","吃菠萝");
    }
}

public class Apple  implements Fruit{
    public Apple(){

    }

    public void eat(){
        Log.i("apple","吃苹果");
    }
}

public class AppleBag implements Bag {
    @Override
    public void pack() {
        Log.i("coconut","打包苹果");
    }
}

public class CoconutBag implements Bag {
    @Override
    public void pack() {
        Log.i("coconut","打包椰子");
    }
}

public class PineAppleBag implements Bag {
    @Override
    public void pack() {
        Log.i("coconut","打包菠萝");
    }
}

//简单工厂模式  ---静态工厂模式
public class SimpleFactory {

    public static final int TYPE_APPLE = 1;
    public static final int TYPE_COCONUT = 2;
    public static final int TYPE_PIANEAPPLE = 3;
  

    public static  Fruit getFruit(int type){
        if(type==TYPE_APPLE){
            return new Coconut();
        }else if(type==TYPE_COCONUT){
            return new Pineapple();
        }else if(type==TYPE_PIANEAPPLE){
            return new Apple();
        }

        return null;
    }
    
    public static Bag getBag(int type){
        if(type==TYPE_APPLE){
            return new CoconutBag();
        }else if(type==TYPE_COCONUT){
            return new PineAppleBag();
        }else if(type==TYPE_PIANEAPPLE){
            return new AppleBag();
        }
        return null;
    }
}

public class User {

    public static void main(String[] args) {
       // eatConconut();  //想吃椰子的时候
       // eatPineapple(); //想吃菠萝的时候
       packApple();//打包苹果
        eatApple(); //想吃苹果的时候
        
    }

    public static void eatConconut(){//吃椰子
       // Coconut co = new Coconut();
      //  co.eat();
        Fruit fruit = SimpleFactory.getFruit(SimpleFactory.TYPE_COCONUT);
        fruit.eat();
    }
    public static void eatPineapple(){//吃菠萝
      //  Pineapple pineapple = new Pineapple();
      //  pineapple.eat();
        Fruit fruit = SimpleFactory.getFruit(SimpleFactory.TYPE_PIANEAPPLE);
        fruit.eat();
    }
    public static void eatApple(){//吃苹果
      //  Apple apple = new Apple();
      //  apple.eat();
        Fruit fruit = SimpleFactory.getFruit(SimpleFactory.TYPE_APPLE);
        fruit.eat();
    }
}
 public static void packCoconut(){
        Bag bag = SimpleFactory.getBag(SimpleFactory.TYPE_COCONUT);
        bag.pack();
    }
 public static void packApple(){
        Bag  bag = SimpleFactory.getBag(SimpleFactory.TYPE_APPLE);
        bag.pack();
    }
}
 public static void packPineapple(){
        Bag  bag = SimpleFactory.getBag(SimpleFactory.TYPE_PIANEAPPLE);
        bag.pack();
    }

看到上面的代码是不是有了变化，比原先多写了很多代码，多掉几根头发。但是好好阅读一下，我根本不在需要直接跟具体水果接触，就是我根本不需要自己种我想吃的具体水果，我直接跟工厂接触，告诉工厂我想吃什么水果然后它就给我什么水果。具体业务逻辑是具体水果代码，新来的需要这些业务逻辑，他不需要再到我的具体代码里面看我的代码，它也不需要去new 来调用我的代码，它直接调用工厂给一个类型参数，他就能获得他需要的业务，他开发的效率是不是很快？其实他的效率快就是我的工作量变大了，代替他完成了，这样实际开发者多加班码代码就是心里不平衡。调用开发者心里美滋滋的下班回家。所以学习工厂模式只是让自己变苦逼，让后来者轻松。学习工厂模式的误区这里应该解开了，它不是让代码变少，它是让代码变多，但是后来调用的时候非常方便。可阅读性增加，后来者根本不需要去理睬他需要调用的业务，也不需要去接触他需要的业务，他直接通过静态工厂调用就可以继续开发他的业务。他的业务也需要工厂模式，下次我调用的时候我也不需要去直接跟他的业务打交道，直接跟工厂调用，也提前下班回家，让他加班码代码。团队总体来看，开发时间进度没有变化，但是专业熟悉的业务开发起来更快，质量更高。我不需要担心他调用我的代码出现bug，他不需要担心我调用他的出现bug。

总结

1.工厂模式没有让程序员编写代码量变少而是变多。
2.代码可读性增加，质量增加。
3.维护成本下降
4.简单工厂模式也就是静态工厂模式