设计模式

设计模式

一.单例模式

• 单例模式的作用
• 单例模式的实现步骤
• 单例设计模式的类型

单例模式的作用

通过单例模式，可以保证使用该模式的类只有一个实例，即一个类只有一个对象实例

单例模式的实现步骤

1. 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
2. 在该类内部产生一个唯一的实例化对象。
3. 定义一个静态方法返回这个唯一的对象。

单例模式的类型

• 饿汉单例设计模式
• 懒汉单例设计模式

（1）饿汉式单例设计模式

饿汉单例设计模式就是使用类的时候已经将对象创建完毕，不管以后会不会使用到该实例化对象，先创建了再说，一副很着急的样子，所以被称为“饿汉模式”

实例代码如下：

Person类
package com.wangyong.hungryModel;
//饿汉式
public class Person {

    //1.私有化构造方法
    private Person(){

    }
    //2.在该类的内部创建一个该类的对象
    private static final Person p=new Person();

    //3.提供一个获取该类对象的方法
    public static Person getInstance(){
        return p;
    }
}

测试类
package com.wangyong.hungryModel;

public class test {
    public static void main(String[] args) {
        Person person1 = Person.getInstance();
        Person person2 = Person.getInstance();
        Person person3 = Person.getInstance();
        Person person4 = Person.getInstance();
        System.out.println(person1);
        System.out.println(person2);
        System.out.println(person3);
        System.out.println(person4);
        //打印出来四个实例对象的地址号相同，为同一对象
    }
}

（2）懒汉式单例设计模式

懒汉单例设计模式就是调用getInstance()方法时实例才被创建，先不急着实例化出对象，等要用的时候才实例化出对象。不着急，故称为“懒汉模式”。

实例代码如下：

Person类
package com.wangyong.lazyModel;
//懒汉式
public class Person {
    //1.私有化构造方法
    private Person(){

    }
    // 2. 在该类内部产生一个唯一的实例化对象
    private static Person p ;// 默认值为null

    // 3. 定义一个静态方法返回这个唯一对象。
    public static synchronized Person getInstance(){
        // 创建Person类的唯一对象
        // 判断一下,如果p这个成语变量的值为null,就创建,不为null,说明该对象已经创建了,直接返回即可
        if (p == null){
            p = new Person();
        }
        return p;
    }
}

测试类
package com.wangyong.lazyModel;

public class test {
    public static void main(String[] args) {
        Person p1 = Person.getInstance();
        Person p2 = Person.getInstance();
        Person p3 = Person.getInstance();

        System.out.println(p1);
        System.out.println(p2);
        System.out.println(p3);
        //打印出来四个实例对象的地址号相同，为同一对象

    }
}

注意：懒汉单例设计模式在多线程环境下可能会实例化出多个对象，不能保证单例的状态，所以加上关键字：synchronized，保证其同步安全。

二. 多例模式

多例模式的作用

多例模式，是一种常用的软件设计模式。通过多例模式可以保证系统中，应用该模式的类有固定数量的实例。多例类要自我创建并管理自己的实例，还要向外界提供获取本类实例的方法。

实现步骤

1.创建一个类, 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。

​2.在该类内部产生固定数量的实例化对象 ----> 集合

​3.提高一个静态方法来随机获取一个该了的实例化对象

实例代码

person类
package com.wangyong.multModel;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Person {

    //私有化构造方法
    private Person(){

    }
    //创建一个存放对象的集合
    public static List<Person> list=new ArrayList<>();

    //在静态代码块中实例化几个对象
    static{
        for(int i=0;i<3;i++){
            Person p=new Person();
            list.add(p);
        }
    }

    //提供一个静态方法返回随机的对象
    public static Person getInstance(){
        Random r=new Random();
        int i = r.nextInt(list.size());
        Person p = list.get(i);
        return p;
    }

}

测试类
package com.wangyong.multModel;

public class test {
    public static void main(String[] args) {
        Person person = Person.getInstance();
        Person person1 = Person.getInstance();
        Person person2 = Person.getInstance();
        Person person3 = Person.getInstance();
        Person person4 = Person.getInstance();
        System.out.println(person);
        System.out.println(person1);
        System.out.println(person2);
        System.out.println(person3);
        System.out.println(person4);
        //com.wangyong.multModel.Person@677327b6
        //com.wangyong.multModel.Person@677327b6
        //com.wangyong.multModel.Person@677327b6
        //com.wangyong.multModel.Person@14ae5a5
        //com.wangyong.multModel.Person@7f31245a
        //打印结果对象都是在上面定义的三个对象中随机产生
    }
}

多例模式可以保证系统中一个类有固定个数的实例, 在实现需求的基础上, 能够提高实例的复用性.

三. 工厂模式

工厂模式的介绍

​ 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。之前我们创建类对象时, 都是使用new 对象的形式创建, 除new 对象方式以外, 工厂模式也可以创建对象.

耦合度: 类与类之间的关系,如果关系比较强,高耦合, 如果关系比较弱,低耦合

10个类:

10个测试类: 需要创建这10个类的对象

以前: 直接通过new 来创建 10个测试类都要和这个10个类关系起来

现在: 使用工厂模式,定义一个工厂类,专门用来创建这10个类的对象, 并提供获取的方法,

​ 在10个测试类中创建这10个类的对象,只需要使用工厂类来创建就行了,10个测试类就只和工厂类有关系

工厂模式的作用

将前端代码与要创建的对象分开，前端不需要直接创建对象，也就不需要关心创建对象时需要的数据。只需要通过工厂类获取对象即可。

• 解决类与类之间的耦合问题

案例演示

需求

1. 编写一个Car接口, 提供run方法
2. 编写一个Falali类实现Car接口,重写run方法
3. 编写一个Benchi类实现Car接口,重写run方法

提供一个工厂类,可以用来生产汽车对象

实现代码

1.编写一个Car接口, 提供run方法

public interface Car {
    public void run();
}

2.编写一个Falali类实现Car接口,重写run方法

public class Falali implements Car {
    @Override
    public void run() {
        System.out.println("法拉利以每小时500公里的速度在奔跑.....");
    }
}

3.编写一个Benchi类实现Car接口

public class Benchi implements Car {
    @Override
    public void run() {
        System.out.println("奔驰汽车以每秒1米的速度在挪动.....");
    }
}

4.提供一个CarFactory(汽车工厂),用于生产汽车对象

public class CarFactory {
    /**
     * @param id : 车的标识
     *           benchi : 代表需要创建Benchi类对象
     *           falali : 代表需要创建Falali类对象
     *           如果传入的车标识不正确,代表当前工厂生成不了当前车对象,则返回null
     * @return
     */
    public Car createCar(String id){
        if("falali".equals(id)){
            return new Falali();
        }else if("benchi".equals(id)){
            return new Benchi();
        }
        return null;
    }
}

5.定义CarFactoryTest测试汽车工厂

public class CarFactoryTest {
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        Car benchi = carFactory.createCar("benchi");
        benchi.run();
        Car falali = carFactory.createCar("falali");
        falali.run();
    }
}

小结

• 工厂模式的存在可以改变创建类的对象的方式,解决类与类之间的耦合.