设计模式

23设计模式（大话西游）

---

前言

初次看到设计模式，似乎于我没有太大的关系，在平时工作开发中我很少用到，并且即使用到也浑然不知。但是最近初次接触到spring源码，看到源码是我苦不堪言，故学习一下设计模式，希望对自己有所帮助。

一、工厂模式

 工厂模式是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式，在工厂模式中我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象

1.简单工厂模式

    简单工厂模式是指由一个工厂对象决定创建哪一种产品类的实例

实例

1.汽车car 接口

   public interface Car {
   //汽车行为
   void racing();
}

2.宝马car实现car接口

   public class BmwCar implements Car {
    
    @Override
    public void racing() {
        System.out.println("我是宝马，我会飙车");
    }
}

3.奔驰car实现car接口

public class BenzCar  implements  Car {

   @Override
   public void racing() {
       System.out.println("我是奔驰，我会飙车");
   }
}

4.汽车工厂类

public class CarFactory {
    //汽车创建方法
    /*public Car create(String carName){

        if("Benz".equals(carName)){
        return new BenzCar();
        }else if("BmwCar".equals(carName)){
            return  new BmwCar();
        }
        return null ;
   }*/

   // 利用反射创建
    public Car create(Class claz)  {
        if(claz!=null){
            try {
                return (Car)claz.newInstance() ;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null ;
    }

}

4.简单工厂测试实例类

   public class FactoryTest {

    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        Car car =carFactory.create(BmwCar.class) ;
        car.racing();
    }
}

2.工厂方法模式

工厂方法模式是指定义一个创建对象的接口，但让实现这个接口的类决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。

实例

1.工厂接口

  public interface Factroy { 
    //创建方法
    Car create() ;
}

2.宝马工厂实现工厂接口

public class BmwCarFactory implements  Factroy{
    @Override
    public Car create() {
        return new BmwCar();
    }
}

3.奔驰工厂实现工厂接口

public class BenzCarFactory  implements Factroy{
    @Override
    public Car create() {
        return new BenzCar();
    }
}

4.工厂测试类

public class FactoryTest {

    public static void main(String[] args) {
       /* Factroy factroy = new BenzCarFactory();
        Car car  =factroy.create();
        car.racing();*/
        Factroy factroy = new BmwCarFactory();
        Car  car =factroy.create();
        car.racing();
    }
}

3.抽象工厂模式

抽象工厂模式是指提供一个创建一系列相关和相互依赖对象的接口，无须指定他们具体的类

实例

1.定义一个会唱歌的接口

public interface ISing {
   //唱歌
   void sing() ;
}

2.定义一个会跳舞的接口

public interface IDance {

    //跳舞
    void dance() ;
}

3.定义一个创建唱歌和跳舞的抽象工厂

public interface PersonFactroy {
      //唱歌
      ISing createSing();

      //跳舞
      IDance createDance() ;
}

4.男生实现唱歌接口

public class ManSing implements  ISing {
   @Override
   public void sing() {
       System.out.println("我是男生,我会唱歌");
   }
}

5.男生实现跳舞的接口

public class ManDance implements IDance {
    @Override
    public void dance() {
        System.out.println("我是男生,我会跳舞");
    }
}

6.创建一个会唱歌和跳舞的男生工厂实现抽象工厂

public class ManPersonFactroy implements PersonFactroy {
    @Override
    public ISing createSing() {
        return new ManSing();
    }

    @Override
    public IDance createDance() {
        return new ManDance();
    }
}

7.测试

public class FactroyTest {
    public static void main(String[] args) {
        PersonFactroy personFactroy = new ManPersonFactroy();
        personFactroy.createDance().dance();
        personFactroy.createSing().sing();
    }
}

总结

无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。

二.单例模式

 单例模式（Singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，并 提供一个全局访问点。
 他有如下三点特点:
 1.单例类只有一个实例。
 2.单例类必须自己创建自己唯一的实例。
 3.单例类必须给所有其他对象提供这一实例。

这里介绍四种写法： 饿汉式，懒汉式，注册式，枚举式

一.饿汉式

 //饿汉式
public class Sluggard {


  private Sluggard() {} ;

  private static final  Sluggard sluggar = new Sluggard() ;

  public static Sluggard getInstance(){
      return  sluggar ;
  }

}

饿汉式单例是在类加载的时候就立即初始化，并且创建单例对象。绝对的线程安全，在线程还没有出现以前就实例化了，不可能存在访问安全问题。但是类加载的时候就初始化，不管用与不用都占着空间,比较浪费内存。

二.懒汉式

public class Lazy {

 private static Lazy lazy = null ;
 private Lazy(){}
    
   
 public static  Lazy getInstance(){
        lazy = new Lazy();
        return  lazy ;
    }
}

懒汉式只有在外部类调用的时候才会创建对象但是这种写法存在线程安全问题。
双重校验加锁保证线程安全

//懒加载
public class Lazy {
  private static volatile   Lazy lazy = null ;
  private Lazy(){}
    //双重校验
   public  static  Lazy getInstance(){
       if(lazy ==null){
           synchronized (Lazy.class){
             if(lazy==null){
                 lazy = new Lazy();
                 return  lazy ;
             }
           }
       }
      return lazy ;
   } 
}