您现在的位置是：首页 >其他 >常用的设计模式(单例模式、工厂模式等)网站首页其他

1.单例模式

概述:    在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式. 例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。

public class Window {
    //饿汉式单例,  类在初始化时就会加载,  就会初始化对象,只有一份
    //不会存在任何线程安全的问题
    private static Window window = new Window();

    private Window(){

    }

    public static Window getWindow(){
        return window;
    }


    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                System.out.println(Window.getWindow());
            }).start();
        }
    }
}

(2)懒汉式单例

       该模式在类加载时不创建对象, 只有在使用时才创建对象,   这时生成对象的数量需要我们来控制,  所以会存在线程安全问题。

以下是懒汉式单例的代码演示:

当有多个线程同时进入到第一个if中时,  第一个线程去创建对象, 后来获得锁的线程就不会再创建对象,  所以这里利用了两个if,  也就是双重检索+synchronized

public class Window {
    private static Window window;

    private Window(){

    }

    //懒汉式单例,在类加载的时候不创建对象,在使用时创建对象
    //这时,生成的对象的数量需要我们自己来控制
    //懒汉式单例会出现线程安全问题:
    //    在多线程访问时,可能会出现多个线程同时进入到if,就会创建出多个对象
    //如何解决?
    //  1.给方法加锁,但是效率太低,一次只能有一个线程进入
    //  2.给代码块加锁,双重检索+synchronized
    public static Window getWindow(){
        if(window==null){
            synchronized (Window.class){
                if(window==null){
                    window=new Window();
                }
            }
        }
        return window;
    }
}

懒汉式单例双重检索+volatile

   在我们创建对象时,  编译后的汇编指令码正常的执行顺序如下:

1. new  (申请内存空间) 

2. dup

3. invokespecial  <init> :  //调用构造方法

4. astore_1  (将对象地址赋给引用变量)

5. return

线程 1 开始执行,先执行 new,在内存中申请内存空间

此时指令可能发生重排序,先把半成品对象引用地址赋给引用变量 t 

线程 1暂停执行,线程 2进入到 cpu执行,引用变量t 不为空,指向的是半成品对象.

 所以说如果在检索时用if(t  !=  null)来进行判断就会出现问题,  虽然不为空,  但是是一个半成品对象。

2.工厂模式（Factory Pattern）

(1)简单工厂模式

     简单工厂模式并不是 23 种设计模式之一，因为它并不符合开闭原则。主要目的是为了引出工厂方法模式，适合产品子类比较少的、创建操作比较简单的情况。

 由一个工厂类根据传入的参数（一般是字符串参数），动态决定应该创建哪一个产品子类的实例，并以父类形式返回。

以下是代码演示(汽车厂造汽车):

首先创建一个Car接口

public interface Car {
      
      void run();
      
}

其次创建几个具体的汽车(奥迪、宝马)

  奥迪汽车:

public class Aodi implements Car{

    @Override
    public void run() {
        System.out.println("奥迪汽车行驶");
    }
}

宝马汽车:

public class Bmw implements Car{

    @Override
    public void run() {
        System.out.println("宝马汽车行驶");
    }
}

再创建一个造汽车的工厂

/*
 汽车工厂
 */
public class CarFactory {

     public static Car createCar(String name){
            if(name.equals("aodi")){
                Aodi aodi = new Aodi();
                //aodi.
                return aodi;
            }
            if(name.equals("bmw")){
                return new Bmw();
            }
            if(name.equals("bc")){
                 return new BC();
            }
            return null;
     }
}

最后创建一个Test类进行造汽车

public class Test {

    public static void main(String[] args) {

        Car bmw  = CarFactory.createCar("bmw");
        Car aodi  = CarFactory.createCar("aodi");

          bmw.run();
          aodi.run();
    }
}

根据我们传入的内容造相应的汽车,  所以很明显这是不满足开闭原则的,  每添加一个种类的汽车都需要更改原代码。

• 客户端不负责对象的创建，而是由专门的工厂类完成；
• 客户端只负责对象的调用，实现了创建和调用的分离，降低了客户端代码的难度；

• 如果增加和减少产品子类，需要修改简单工厂类，违背了开闭原则如果产品子类过多，会导致工厂类非常的庞大，违反了高内聚原则，不利于后期维护.

• 所有的产品子类都有同一个父类（或接口），属于同一个产品系列产品子类比较少的、创建操作比较简单。

(2)工厂方法模式

代码演示如下(还是同样的造汽车):

先创建一个Car接口

public interface Car {

      void run();

}

其次创建一个工厂接口

public interface CarFactory {

       Car createCar();

}

再创建两个具体的汽车(奥迪和宝马),分别都实现Car

奥迪:

public class Aodi implements Car {

    @Override
    public void run() {
        System.out.println("奥迪汽车行驶");
    }
}

宝马:

public class Bmw implements Car {

    @Override
    public void run() {
        System.out.println("宝马汽车行驶");
    }

}

再创建具体的工厂(奥迪工厂和宝马工厂), 分别实现工厂接口(CarFactory)

奥迪工厂

public class AodiFactory implements  CarFactory{

    @Override
    public Car createCar() {
        return new Aodi();
    }
    
}

宝马工厂

public class BmwFactory implements  CarFactory{

    @Override
    public Car createCar() {
        return new Bmw();
    }
    
}

最后创建一个Test类进行测试(造车)

public class Test {

    public static void main(String[] args) {

           CarFactory aodicarFactory = new AodiFactory();
           Car aodi =  aodicarFactory.createCar();
           aodi.run();

           CarFactory bmwcarFactory = new BmwFactory();
           Car bmw = bmwcarFactory.createCar();
           bmw.run();

            CarFactory  bcf =  new BCFactroy();
            Car bc =   bcf.createCar();
               bc.run();

    }
}

 代码演示如下:

比如一个工厂可以造一类的所有产品,  这里我们创建车和手机

首先分别创建Car和Phone接口

public interface Car {

        void run();
}

public interface Phone {

       void  call();

}

public interface AbstractFactory {

       Car getCar();
       Phone getPhone();


}

public class AodiFactory implements  AbstractFactory{

    @Override
    public Car getCar() {
        return new AodiCar();
    }

    @Override
    public Phone getPhone() {
        return new AodiPhone();
    }

}

public class BmwFactory implements AbstractFactory{

    @Override
    public Car getCar() {
        return new BmwCar();
    }

    @Override
    public Phone getPhone() {
        return new BmwPhone();
    }
}

public class BmwFactory implements AbstractFactory{

    @Override
    public Car getCar() {
        return new BmwCar();
    }

    @Override
    public Phone getPhone() {
        return new BmwPhone();
    }
}

public class Test {

    public static void main(String[] args) {
        AbstractFactory aodiFactory = new AodiFactory();
        Car aodiCar = aodiFactory.getCar();
        Phone aodiphone = aodiFactory.getPhone();
              aodiCar.run();
              aodiphone.call();

        AbstractFactory bmwFactory = new BmwFactory();
        Car bmwCar = bmwFactory.getCar();
        Phone bmwPhone = bmwFactory.getPhone();
              bmwCar.run();
              bmwPhone.call();


    }
}