五分钟快速入门单例、简单工厂、工厂方法三种设计模式

前言：设计模式的概念是很抽象的，不好理解，我第一次看完这些概念也是一面懵逼，又想了想，还是一面懵逼的。在这里将概念放在前面看不懂没关系，本章的正确学习方式应该是先看《案例演示》和《代码实现》然后再回头看概念（别看概念很难理解，其实都是纸老虎，将demo敲一遍，不懂，拿刀来砍我）

前言 ：虽然有六大设计原则，二十三种设计模式，不过常见的设计模式也就那么几种，想要真正的掌握，肯定还需要我们结合具体的应用场景去练习去理解，方可应用！

一、单例设计模式

• A:单例设计模式：保证类在内存中只有一个对象。

• B:如何保证类在内存中只有一个对象呢？

  • (1)构造方法私有化（控制类的创建，不让其他类来创建本类的对象）。private
  • (2)在本类中定义一个本类的对象。Singleton s;
  • (3)提供公共的访问方式。 public static Singleton getInstance(){return s}

• C:单例的两种写法

  • 饿汉模式，开发用这种方式

  class Singleton {
                  //1,私有构造函数
                  private Singleton(){}
                  //2,创建本类对象
                  private static Singleton s = new Singleton();
                  //3,对外提供公共的访问方法
                  public static Singleton getInstance() {
                      return s;
                  }
                  
                  public static void print() {
                      System.out.println("11111111111");
                  }
              }
  

  • 懒汉式，面试的时候写这种方式。但是建议不要在项目中使用，因为他存在多线程问题。

            //懒汉式,又称单例的延迟加载模式
                class Singleton {
                    //1,私有构造函数
                    private Singleton(){}
                    //2,声明一个本类的引用
                    private static Singleton s;
                    //3,对外提供公共的访问方法
                    public static Singleton getInstance() {
                        if(s == null)
                            //线程1,线程2
                            s = new Singleton();
                        return s;
                    }
                    
                    public static void print() {
                        System.out.println("11111111111");
                    }
                }
  

  线程安全问题： 多线程中，在创建单例对象的时候，假如线程1，经过if判断时没有创建对象，假如此时还没有执行s = new Singleton();时，执行权被线程2抢过去了，那么线程2在if判断时，s的对象仍然是null，如果此时线程2通过了判断。线程1又有了执行权，那么线程1和线程2都可以去创建s对象了，如果是这样这还是单例模式吗？所以建议使用饿汉模式。如果还不理解可以参考一下我写的《搞定Java多线程（三）》中的线程安全。

  • 第三种格式（了解）

  class Singleton {
              private Singleton() {}
          
              public static final Singleton s = new Singleton();//final是最终的意思,被final修饰的变量不可以被更改
          }
  

二、简单工厂设计模式

• A:简单工厂模式概述

  • 又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例

• B:优点

  • 客户端不需要在负责对象的创建，从而明确了各个类的职责

• C:缺点

  • 这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护

• D:案例演示

  • 动物抽象类：

  public abstract Animal {
      public abstract void eat(); 
      
  }
  

  • 具体狗类：

  public class Dog extends Animal {
       @Override
      public void eat() {
          System.out.println("狗喜欢吃骨头");
      }
  }
  

  • 具体猫类：

  public class Cat extends Animal {
       @Override
      public void eat() {
       System.out.println("猫喜欢吃鱼");
      }
  }
  

  • 工厂类(在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。)

  public class AnimalFactory {
              private AnimalFactory(){}
          
              public static Dog createDog() {return new Dog();}
              public static Cat createCat() {return new Cat();}
          
              //改进
              /*public static Animal createAnimal(String animalName) {
                  if(“dog”.equals(animalName)) {}
                  else if(“cat”.equals(animale)) {
          
                  }else {
                      return null;
                  }
              }*/
          } 
  

  • 主方法，创建类的实例

  public class Main {
      public static void main(String[] args) {
          Dog dog = AnimalFactory.createDog();
          dog.eat();
          Cat cat = AnimalFactory.createCat();
          cat.eat();
         //改进
      //Dog dog = AnimalFactory.createAnimal("dog");
      }
  }
  

  • 运行结果

    
    简单工厂.png

三、工厂方法设计模式

• A:工厂方法模式概述

  • 工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。

• B:优点

  • 客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性

• C:缺点

  • 需要额外的编写代码，增加了工作量

• D:案例演示

  • 动物抽象类：

  public abstract Animal { 
      public abstract void eat(); 
       }
  

  • 工厂接口：

  public interface Factory {
      public abstract Animal createAnimal();
          }
  

  • 具体狗类：

  public class Dog extends Animal {
           @Override
           public void eat() {
               System.out.println("狗喜欢吃骨头");
           }
       }
  

  • 具体猫类：

  public class Cat extends Animal {
      @Override
      public void eat() {
          System.out.println("猫喜欢吃鱼");
      }
  }
  

  • 在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。发现每次修改代码太麻烦，用工厂方法改进，针对每一个具体的实现提供一个具体工厂。
  • 狗工厂：

  public class DogFactory implements Factory {
      @Override
          public Animal createAnimal() {
                return new Dog();
          }
  }
  

  • 猫工厂：

  public class CatFactory implements Factory {
      @Override
          public Animal createAnimal() {
              return new Cat();
      }
  }  
  

  • 主方法，创建类的实例

  public static void main(String[] args) {
    DogFactory dogFactory = new DogFactory();
    Dog dog = (Dog) dogFactory.createAnimal();
    dog.eat();
  }
  

  • 运行结果

    
    工厂方法.png