Java设计模式

1、Java设计模式内容介绍

先看几个经典的面试题
原型设计模式问题：
1) 有请使用UML类图画出原型模式核心角色
2) 原型设计模式的深拷贝和浅拷贝是什么，并写出深拷贝的两种方式的源码(重写
clone方法实现深拷贝、使用序列化来实现深拷贝)
3) 在Spring框架中哪里使用到原型模式，并对源码进行分析
beans.xml

4) Spring中原型bean的创建，就是原型模式的应用
5) 代码分析+Debug源码

先看几个经典的设计模式面试题
设计模式的七大原则: 要求：
1) 七大设计原则核心思想
2) 能够以类图的说明设计原则
3) 在项目实际开发中，你在哪里使用到了ocp原则
设计模式常用的七大原则有:
1) 单一职责原则
2) 接口隔离原则
3) 依赖倒转原则
4) 里氏替换原则
5) 开闭原则 ocp
6) 迪米特法则
7) 合成复用原则

金融借贷平台项目：
借贷平台的订单，有审核- 发布-抢单 等等 步骤，随着操作的不同，会改 变订单的状态, 项目中的这个模块实现就会使用 到状态模式，请你使用状态模式进行设计，并 完成实际代码
问题分析 ：
这类代码难以应对变化，在添加一种状态时， 我们需要手动添加if/else，在添加一种功能时， 要对所有的状态进行判断。因此代码会变得越 来越臃肿，并且一旦没有处理某个状态，便会 发生极其严重的BUG，难以维护

解释器设计模式
1) 介绍解释器设计模式是什么?
2) 画出解释器设计模式的UML类图, 分析设计模式中的各个角色是什 么?
3) 请说明Spring的框架中，哪里 使用到了解释器设计模式，并 做源码级别的分析
解释器模式在Spring框架应用的源码剖析
1) Spring框架中 SpelExpressionParser就使用到解释器模式
2) 代码分析+Debug源码+模式角色分析说明

单例设计模式一共有几种实现方式？请分别用代码实现，并说明各个实现方式的 优点和缺点?
单例设计模式一共有8种写法，后面我们会依次讲到

1. 饿汉式 两种
2. 懒汉式 三种
3. 双重检查
4. 静态内部类
5. 枚举

设计模式的重要性
拿实际工作经历来说, 当一个项目开发完后，如果客户提出增新功能，怎么办?。

1. 如果项目开发完后，原来程序员离职，你接手维护该项目怎么办? (维护性[可读性、规范性])
2. 目前程序员门槛越来越高，一线IT公司(大厂)，都会问你在实际项目中使用过什么设计模式，怎样使用的，解决了什么问题。
3. 设计模式在软件中哪里？面向对象(oo)=>功能模块[设计模式+算法(数据结构)]=>框架[使用到多种设计模式]=>架构 [服务器集群]

4. 如果想成为合格软件工程师，那就花时间来研究下设计模式是非常必要的

   2、设计模式七大原则

   2.1、设计模式的目的

   编写软件过程中，程序员面临着来自 耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性 等多方面的挑战，设计模式是为了让程序(软件)，具有更好：

5. 代码重用性(即：相同功能的代码，不用多次编写)

6. 可读性(即：编程规范性,便于其他程序员的阅读和理解)
7. 可扩展性(即：当需要增加新的功能时，非常的方便，称为可维护)
8. 可靠性(即：当我们增加新的功能后，对原来的功能没有影响)
9. 使程序呈现高内聚，低耦合的特性
10. 分享金句：
    1. 设计模式包含了面向对象的精髓，“懂了设计模式，你就懂了面向对象分析和设计（OOA/D）的精要”
    2. Scott Mayers在其巨著《Effective C++》就曾经说过：C++老手和C++新手的区别就是前者手背上有很多伤疤

2.2、单一接口原则

单一职责(Simple Responsibility Pinciple，SRP)是指不要存在多于一个导致类变更 的原因。
核心：就是解耦和增强内聚性。
对类来说的，即一个类应该只负责一项职责。如类A负责两个不同职责：职责1，职责2。 当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为A1，A2
优点：

• 提高类的可维护性和可读写性
• 提高系统的可维护性
• 降低变更的风险

1) 降低类的复杂度，一个类只负责一项职责。
2) 提高类的可读性，可维护性
3) 降低变更引起的风险
4) 通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则
假设我们有一个 Class 负责两个职责，一旦发生需求变更，修改其中一个职责的逻辑代码，有可能会导致另一个职责的功能发生故障。这样一来，这个 Class 存在两个导 致类变更的原因。如何解决这个问题呢?我们就要给两个职责分别用两个 Class 来实现， 进行解耦。后期需求变更维护互不影响。这样的设计，可以降低类的复杂度，提高类的 可读性，提高系统的可维护性，降低变更引起的风险。总体来说就是一个 Class/Interface/Method 只负责一项职责。
下面我们来举一个实例

public interface UserOperate {
    void updateUserName(UserInfo userInfo);
    void updateUserPassword(UserInfo userInfo);
}
public class UserOperateImpl implements UserOperate {
    @Override
    public void updateUserName(UserInfo userInfo) {
        // 修改用户名逻辑
    }
    @Override
    public void updateUserPassword(UserInfo userInfo) {
        // 修改密码逻辑
    }
}

修改用户名和修改密码逻辑分开，各自执行各自的职责，互不干扰，功能清晰明了。
具体比较实现
方式一：

/**
 * 做家务
 */
public interface HouseWork {
    // 扫地
    void sweepFloor();
    // 购物
    void shopping();
}
public class Xiaocheng implements HouseWork{
    @Override
    public void sweepFloor() {
        // 扫地
    }
    @Override
    public void shopping() {
    }
}
public class Xiaoming implements HouseWork{
    @Override
    public void sweepFloor() {
    }
    @Override
    public void shopping() {
        // 买菜
    }
}

说是妈妈在出门前嘱咐小明和小陈做家务（定义一个做家务接口），小明去买菜（实现买菜接口），小陈去扫地（实现扫地接口）。到这里其实你就发现，小明不需要扫地却要重写扫地的方法，小陈不需要买菜但因为实现了做家务的接口，就不得不也重写买菜方法。

这样的设计是不合理的，他违背了单一原则，也不符合开闭原则。

方式二：

public interface Cooking extends Hoursework{
    void cooking();
}
public class Xiaoming implements Shopping, Cooking{
    @Override
    public void shopping() {
        // 小明购物
    }
    @Override
    public void cooking() {
        // 小明做饭
    }
}

现在我们将扫地和做家务这个接口拆分，小陈扫地，那就实现扫地接口，小明购物就实现买菜接口。
接下来小明买完菜回来做饭，那么就只需要新增一个做法接口，让小明实现就可以了
一个接口实现一个功能就好。
接口层面，子类不实现多余的接口，这就符合单一原则：一个类只做一件事，并且修改它不会带来其他变化

2.3、接口隔离原则

接口隔离原则（Interface Segregation Principle），又称ISP原则
1、 客户端不应该依赖它不需要的接口
2、 类间的依赖关系应该建立在最小的接口上

介绍：
通俗的来讲，不要在一个接口中定义多个方法，接口应该尽量细化
案例实现接口隔离

public class SegregationDemo {
    public static void main(String[] args) {
        new FruitShop().cutApple(new CookZhang());
        new FruitShop().cutTomato(new CookZhang());
        new VegetableShop().cutTomato(new CookLi());
        new VegetableShop().cutPotato(new CookLi());
    }
}
interface Knife {
    void cutApple();
    void cutTomato();
    void cutPotato();
}
class CookZhang implements Knife {
    @Override
    public void cutApple() {
        System.out.println("张师傅在切苹果");
    }
    @Override
    public void cutTomato() {
        System.out.println("张师傅在切土豆");
    }
    @Override
    public void cutPotato() {
        System.out.println("张师傅在切番茄");
    }
}
class CookLi implements Knife {
    @Override
    public void cutApple() {
        System.out.println("李师傅在切苹果");
    }
    @Override
    public void cutTomato() {
        System.out.println("李师傅在切土豆");
    }
    @Override
    public void cutPotato() {
        System.out.println("李师傅在切番茄");
    }
}
class FruitShop {
    public void cutApple(Knife knife) {
        knife.cutApple();
    }
    public void cutTomato(Knife knife) {
        knife.cutTomato();
    }
}
class VegetableShop {
    public void cutPotato(Knife knife) {
        knife.cutPotato();
    }
    public void cutTomato(Knife knife) {
        knife.cutTomato();
    }
}

这里会实现过多的多余的实现方法
修改改接口后的代码：

public class SegregationDemo {
    public static void main(String[] args) {
        new FruitShop().cutApple(new CookZhang());
        new FruitShop().cutTomato(new CookZhang());
        new VegetableShop().cutTomato(new CookLi());
        new VegetableShop().cutPotato(new CookLi());
    }
}
interface AppleKnife {
    void cutApple();
}
interface TomatoKnife {
    void cutTomato();
}
interface PotatoKnife {
    void cutPotato();
}
class CookZhang implements AppleKnife, TomatoKnife {
    @Override
    public void cutApple() {
        System.out.println("张师傅在切苹果");
    }
    @Override
    public void cutTomato() {
        System.out.println("张师傅在切番茄");
    }
}
class CookLi implements TomatoKnife, PotatoKnife {
    @Override
    public void cutTomato() {
        System.out.println("李师傅在切土豆");
    }
    @Override
    public void cutPotato() {
        System.out.println("李师傅在切番茄");
    }
}
class FruitShop {
    public void cutApple(AppleKnife knife) {
        knife.cutApple();
    }
    public void cutTomato(TomatoKnife knife) {
        knife.cutTomato();
    }
}
class VegetableShop {
    public void cutPotato(PotatoKnife knife) {
        knife.cutPotato();
    }
    public void cutTomato(TomatoKnife knife) {
        knife.cutTomato();
    }
}

2.4、依赖倒置原则

依赖倒置原则的原始定义为：
高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象
核心就是面向接口编程;
让细节的具体实现类去依赖(使用)抽象类或者接口;而不是让接口或抽象类去依赖细节的具体实现类.
依赖倒置原则是实现开闭原则的重要途径之一，它降低了客户与实现模块之间的耦合。

依赖倒置原则的主要作用如下。

• 依赖倒置原则可以降低类间的耦合性。
• 依赖倒置原则可以提高系统的稳定性。
• 依赖倒置原则可以减少并行开发引起的风险。
• 依赖倒置原则可以提高代码的可读性和可维护性。

依赖倒置原则的实现方法
依赖倒置原则的目的是通过要面向接口的编程来降低类间的耦合性，所以我们在实际编程中只要遵循以下4点，就能在项目中满足这个规则。

1. 每个类尽量提供接口或抽象类，或者两者都具备。
2. 变量的声明类型尽量是接口或者是抽象类。
3. 任何类都不应该从具体类派生。
4. 使用继承时尽量遵循里氏替换原则。

下面以“顾客购物程序”为例来说明依赖倒置原则的应用。
【例1】依赖倒置原则在“顾客购物程序”中的应用。
分析：本程序反映了 “顾客类”与“商店类”的关系。商店类中有 sell() 方法，顾客类通过该方法购物以下代码定义了顾客类通过韶关网店 ShaoguanShop 购物：

class Customer {
    public void shopping(ShaoguanShop shop) {
        //购物
        System.out.println(shop.sell());
    }
}

但是，这种设计存在缺点，如果该顾客想从另外一家商店（如婺源网店 WuyuanShop）购物，就要将该顾客的代码修改如下：（上面的实现方法写死了店铺地址， 我们需要实现动态实现）
顾客每更换一家商店，都要修改一次代码，这明显违背了开闭原则。存在以上缺点的原因是：顾客类设计时同具体的商店类绑定了，这违背了依赖倒置原则。解决方法是：定义“婺源网店”和“韶关网店”的共同接口 Shop，顾客类面向该接口编程，其代码修改如下：

class Customer {
    public void shopping(Shop shop) {
        //购物
        System.out.println(shop.sell());
    }
}

这样，不管顾客类 Customer 访问什么商店，或者增加新的商店，都不需要修改原有代码了。
程序代码如下：
1、接口传递实现：

public class DIPtest {
    public static void main(String[] args) {
        Customer wang = new Customer();
        System.out.println("顾客购买以下商品：");
        wang.shopping(new ShaoguanShop());
        wang.shopping(new WuyuanShop());
    }
}
//商店
interface Shop {
    public String sell(); //卖
}
//韶关网店
class ShaoguanShop implements Shop {
    public String sell() {
        return "韶关土特产：香菇、木耳……";
    }
}
//婺源网店
class WuyuanShop implements Shop {
    public String sell() {
        return "婺源土特产：绿茶、酒糟鱼……";
    }
}
//顾客
class Customer {
    public void shopping(Shop shop) {
        //购物
        System.out.println(shop.sell());
    }
}

再来一个例子：

public class DependenceInversion02 {
    public static void main(String[] args) {
        Person person=new Person();
        person.getMes(new QQ());
        person.getMes(new Message());
    }
}
//接收消息的接口;
interface GetMes{
    //看看收到的消息;
    String show();
}
//短信类;
class Message implements GetMes{
    public String show(){
       return "收到短信了";
    }
}
//QQ消息;
class QQ implements GetMes{
    public String show(){
       return "收到QQ消息了";
    }
}
//具体的人;
class Person{
    //接收消息;
    public void getMes(GetMes getMes){
        System.out.println(getMes.show());
    }
}

2.5、里氏替换原则

里氏替换原则(Liskov Substitution Principle)(LSP)
定义：所有引用基类的地方必须能透明的使用子类对象
就是说当在程序中将一个对象替换成他的子类时，程序可以继续原有的行为，他察觉不出符类和子类的区别。但是反过来却不成立，如果一个程序使用的是一个子类的话，他不一定适用于父类。
以电脑举例：电脑有CPU，电脑就是程序实体，CPU就是它使用的基类，CPU又有子类IntelCpu。

public class Cpu {
    public void work(){
        System.out.println("CPU在工作");
    }
}
public class IntelCpu extends Cpu {
    @Override
    public void work() {
        System.out.println("英特尔CPU工作");
    }
}
public class Computer {
    private Cpu cpu;
    public void run() {
        this.cpu.work();
    }
    public Cpu getCpu() {
        return cpu;
    }
    public void setCpu(Cpu cpu) {
        this.cpu = cpu;
    }
}

电脑依赖的是父类，此时将Cpu换成Intel类型的，电脑仍能正常工作，它察觉不到任何改变，这符合里氏替换原则。
而反过来，假设现在有一台电脑，它只能使用IntelCpu才能工作。 就是只能子类替代父类而不能父类替代子类。

实例二：
让类A和类B公共去继承同一个类,这样A与B之间的耦合性就降低了;
若类B还想用类A的方法,可使用组合/聚合/依赖的方式将类A的方法调用过来.

public class LiskovSubstitution02 {
    public static void main(String[] args) {
        System.out.println("类A调用方法");
        A a = new A();
        System.out.println("11-3=" + a.func1(11, 3));
        System.out.println("1-8=" + a.func1(1, 8));
        System.out.println("类B调用方法");
        B b = new B();
        System.out.println("11-3=" + b.func3(11, 3));
        System.out.println("1-8=" + b.func3(1, 8));
        System.out.println("11+3+9=" + b.func2(11, 3));
    }
}
//创建一个公共类;让类A和类B去继承它
class PubClass{
}
//类 A 继承公共类 ;完成两数相减的任务;
class A extends PubClass{
    public int func1(int num1, int num2) {
        return num1 - num2;
    }
}
//类B 继承 公共类; 计划完成两数相加的任务;
class B extends PubClass {
    //若类B还想用类A的方法;可使用组合的方式;
    private A a=new A();
    public int func3(int num1,int num2){
        //这里调用的就是类A的方法了;
        return this.a.func1(num1, num2);
    }
    //这里的方法func1就和类A没关系了;
    public int func1(int a, int b) {
        return a + b;
    }
    //在这里就是两数相加 + 9 ;
    public int func2(int a, int b) {
        return func1(a, b) + 9;
    }
}

类A调用方法
11-3=8
1-8=-7
类B调用方法
11-3=8
1-8=-7
11+3+9=23

2.6、开闭原则(Open Closed Principle)

类,作用域,方法 应该做到 对扩展开放 (扩展开放是对提供方来说的) ;对修改关闭(修改关闭是对于使用方而言;例如说扩展了一个新的功能,使用方的代码不用去修改);
用接口抽象地构建框架;然后通过实现类扩展实现功能.

案例:不同的图形去继承图形类;得到 m_type 属性;
在绘制图形类(使用方)GraphicEditor中,根据不同的 m_type 去绘制图形,而每次要添加新的图形绘制时,需要定义图形后;然后还要在使用方GraphicEditor类中进行定义方法;

public class OpenClosed02 {
    public static void main(String[] args) {
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Rectangle());//我要矩形
        graphicEditor.drawShape(new Circle());//我要圆形
        graphicEditor.drawShape(new Square());//我要正方形
    }
}
//绘制图形类;
class GraphicEditor {
    //根据不同的 m_type 绘图;
    public void drawShape(Shape s) {
        s.willDraw();
    }
}
//图形类 (父类)==>作为抽象类;
abstract class Shape {
    int m_type;
    //抽象方法;
    public abstract void willDraw();
}
//矩形类,继承图形类
class Rectangle extends Shape {
    Rectangle() {
        super.m_type = 1;
    }
    public void willDraw() {
        System.out.println("我要矩形");
    }
}
//圆形类;继承图形类;
class Circle extends Shape {
    Circle() {
        super.m_type = 2;
    }
    public void willDraw() {
        System.out.println("我要原形");
    }
}
//如果需要新添加一个绘图方式;
class Square extends Shape{
    Square(){
        super.m_type =3;
    }
    public void willDraw() {
        System.out.println("我要正方形");
    }
}

2.7、迪米特法原则

类和类之间的关系越是复杂,他们的耦合性就会越高.
比如说 类 A依赖类B;那么类A就在内部 把类B的逻辑封装起来;不对外泄露信息.
如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用，如果其中一个类需要调用另一个类的某一个方法的话，可以通过第三者转发这个调用。

只要两个对象之间有耦合关系，那么这两个对象就是朋友关系;
出现成员变量，方法参数，方法返回值中的类为直接的朋友;
只与直接的朋友通信.

一般不要将其他类作为局部变量使用.
这里老师是通过班长这个第三者来清点学生的数量 而不是直接去清点 请求班长执行

public interface ITeacher {
    void command(IGroupLeader groupLeader);
}
public class Teacher implements ITeacher {
    @Override
    public void command(IGroupLeader groupLeader) {
        // 班长清点人数
        groupLeader.count();
    }
}
/**
 * 班长类
 */
public interface IGroupLeader {
    // 班长清点人数
    void count();
}
/**
 * 班长类
 */
public class GroupLeader implements IGroupLeader {
    private List<Student> students;
    public GroupLeader(List<Student> students) {
        this.students = students;
    }
    /**
     * 班长清点人数
     */
    @Override
    public void count() {
        // 班长清点人数
        System.out.println("上课的学生人数是: " + students.size());
    }
}
/**
 * 学生类
 */
public interface IStudent {
}
/**
 * 学生类
 */
public class Student implements IStudent {
}
/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        // 老师类
        ITeacher wangTeacher = new Teacher();
        List<Student> allStudent = new ArrayList(10);
        allStudent.add(new Student());
        allStudent.add(new Student());
        allStudent.add(new Student());
        allStudent.add(new Student());
        // 班长
        IGroupLeader zhangBanzhang = new GroupLeader(allStudent);
        wangTeacher.command(zhangBanzhang);
    }
}

减少对外的暴露 Man只需要一个咖啡机 其他操作内部解决

案例二：
分析：明星由于全身心投入艺术，所以许多日常事务由经纪人负责处理，如与粉丝的见面会，与媒体公司的业务洽淡等。这里的经纪人是明星的朋友，而粉丝和媒体公司是陌生人，所以适合使用迪米特法则，其类图如图 1 所示。

public class LoDtest {
    public static void main(String[] args) {
        Agent agent = new Agent();
        agent.setStar(new Star("林心如"));
        agent.setFans(new Fans("粉丝韩丞"));
        agent.setCompany(new Company("中国传媒有限公司"));
        agent.meeting();
        agent.business();
    }
}
//经纪人
class Agent {
    private Star myStar;
    private Fans myFans;
    private Company myCompany;
    public void setStar(Star myStar) {
        this.myStar = myStar;
    }
    public void setFans(Fans myFans) {
        this.myFans = myFans;
    }
    public void setCompany(Company myCompany) {
        this.myCompany = myCompany;
    }
    public void meeting() {
        System.out.println(myFans.getName() + "与明星" + myStar.getName() + "见面了。");
    }
    public void business() {
        System.out.println(myCompany.getName() + "与明星" + myStar.getName() + "洽淡业务。");
    }
}
//明星
class Star {
    private String name;
    Star(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}
//粉丝
class Fans {
    private String name;
    Fans(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}
//媒体公司
class Company {
    private String name;
    Company(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

2.8、合成复用原则Composite Reuse Principle

尽量不要使用继承关系

如果说仅仅是让类B去使用类A的方法,这时使用继承,会让A类和B类之间的耦合性增强
方式一：

方式二：
A 类聚合到B类

方式三：
A组合到B类中

3、23种设计模式

设计模式的分类
创建型模式：（描述怎样去创建一个对象，创建和使用分离）

• 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式

结构型模式：（描述如何将类或对象安装某种类型组成更大的结构）

• 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式

行为型模式：（描述类和对象如何可以相互协作）

• 模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式

  3.1、单例模式

  核心作用：保证一个类只有一个实例，并且提供一个访问该实例的 全局访问点
  比如Hibernate的SessionFactory，它充当数据存储源的代理，并负责创建Session 对象。SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个 SessionFactory就够，这是就会使用到单例模式。
  饿汉式单例模式：
  执行步骤：
  1) 构造器私有化 (防止 new )
  2) 类的内部创建对象
  3) 向外暴露一个静态的公共方法。getInstance
  4) 代码实现 ```java // 饿汉式单例 public class Hungry {

  // 可能会浪费空间 private byte[] data1 = new byte[10241024]; private byte[] data2 = new byte[10241024]; private byte[] data3 = new byte[10241024]; private byte[] data4 = new byte[10241024];

  // 单例模式核心思想：构造器私有 private Hungry(){

  } // 转载类的时候就完了实例化 一直存在 静态常量法 private final static Hungry HUNGRY = new Hungry();

  public static Hungry getInstance(){

    return HUNGRY;

  }

}

**优点**：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
**缺点**：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。**如果从始至终从未使用过这个实例，则会造成内存的浪费**
**静态代码块懒汉式**
```java
// 饿汉式单例
public class Hungry {
    // 可能会浪费空间 
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];
    // 单例模式核心思想：构造器私有
    private Hungry(){
    }
    // 静态代码块创建单例
    private static Hungry HUNGRY;
    static{
        HUNGRY = new Hungry();
    }
    public static Hungry getInstance(){
        return HUNGRY;
    }
}

DCL懒汉式单例模式：

// 懒汉式单例  线程安全的情况下
public class LazyMan {
    private LazyMan() {
        System.out.println(Thread.currentThread().getName() + "ok");
    }
    private  volatile static LazyMan lazyMan; // volatile 为了避免指令重排
    // 双重检测锁模式的懒汉式单例  DCL 懒汉式
    public static LazyMan getInstance() {
        if (lazyMan == null) {
            synchronized (LazyMan.class) {
                if (lazyMan == null) {
                    lazyMan = new LazyMan();// 不是一个原子性操作
                    /*
                    1、分配内存空间
                    2、执行构造方法，初始化对象
                    3、把这个对象指向这个空间
                    123
                    132 A
                        B // 此时B线程进来会认为lazyman不为null
                          // 直接返回 此时lazyman 还没有完成构造
                          // 为了避免指令重排
                       */
                }
            }
        }
        return lazyMan;
    }
//
//    public static LazyMan getInstance() {
//        if (lazyMan == null) {
//            lazyMan = new LazyMan();
//        }
//        return lazyMan;
//    }
    // 单线程下确实单例ok,但是多线程并发
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                LazyMan.getInstance();
            }).start();
        }
    }
}

优点：解决了线程不安全问题
缺点：效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行 同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例， 直接return就行了。方法进行同步效率太低

反射 可以破环这种单例

// 懒汉式单例
// 道高一尺，魔高一丈
public class LazyMan {
    private static  boolean qinjiang = false;
    private LazyMan() {
        if(qinjiang == false){
            qinjiang=true;
        }else{
            throw new RuntimeException("不要试图使用反射破坏异常");
        }
//        synchronized (LazyMan.class){
//            if (lazyMan!=null){
//                throw new RuntimeException("不要试图使用反射破坏异常");
//            }
//        }
//        System.out.println(Thread.currentThread().getName() + "ok");
    }
    private  volatile static LazyMan lazyMan; // volatile 为了避免指令重排多线程的情况下防止线程相互影响的
    // 双重检测锁模式的懒汉式单例  DCL 懒汉式
    public static LazyMan getInstance() {
        if (lazyMan == null) {
            synchronized (LazyMan.class) {
                if (lazyMan == null) {
                    lazyMan = new LazyMan();// 不是一个原子性操作
                    /*
                    1、分配内存空间
                    2、执行构造方法，初始化对象
                    3、把这个对象指向这个空间
                    123
                    132 A
                        B // 此时B线程进来会认为lazyman不为null
                          // 直接返回 此时lazyman 还没有完成构造
                          // 为了避免指令重排
                       */
                }
            }
        }
        return lazyMan;
    }
    // 单线程下确实单例ok,但是多线程并发
    public static void main(String[] args) throws Exception {
        // 反射 可以破环这种单例
//        LazyMan instance = LazyMan.getInstance();
        Field qinjiang = LazyMan.class.getDeclaredField("qinjiang");
        qinjiang.setAccessible(true);
        Constructor<LazyMan> declaredConstructor =LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);//无视私有构造器
        LazyMan  instance=declaredConstructor.newInstance();
        qinjiang.set(instance,false);
        LazyMan instance2=declaredConstructor.newInstance();
        System.out.println(instance);
        System.out.println(instance2);
    }
}

静态内部类

// 静态内部类实现单例模式 不安全
public class Holder {
    private Holder(){
    }
    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }
    public static class InnerClass{
        private static final Holder HOLDER = new Holder();
    }
}

单例不安全，因为有反射
优缺点：
1) 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
2) 静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的 实例化。
3) 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
4) 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
5) 结论：推荐使用
枚举

// enum 本身也是一个 class 类
public enum  EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}
class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        //Constructor<EnumSingle> declaredConstructor=EnumSingle.class.getDeclaredConstructor(null);
        // 枚举没有无参构造，只有有参构造
        Constructor<EnumSingle> declaredConstructor=EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        // java.lang.NoSuchMethodException: com.kuang.single.EnumSingle.<init> 没有空参的构造方法
        // java.lang.IllegalArgumentException: Cannot reflectively create enum objects  反射不能破坏枚举的单例
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

枚举没有无参构造，只有有参构造
优缺点：
1) 这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
2) 这种方式是Effective Java作者Josh Bloch 提倡的方式
3) 结论：推荐使用

单例模式在JDK应用的源码分析
1) 我们JDK中，java.lang.Runtime就是经典的单例模式(饿汉式)
2) 代码分析+Debug源码+代码说明

单例模式注意事项和细节说明
1) 单例模式保证了 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
2) 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new
3) 单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等)。

3.2、工厂模式

3.2.1、作用

• 实现了创建者和调用者的分离
• 详细分类：
  • 简单工厂模式：用来生产同一等级结构中的任意产品（对于增加新的产品，需要扩展已有代码）
  • 工厂方法模式：用来生产同一等级结构中的固定产品（支持增加任意产品）
  • 抽象工厂模式：围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。

我们常用的工厂模式主要使用简单工厂模式 抽象工厂模式比较少用

工厂设计模式的原则（OOP七大原则）：

• 开闭原则：一个软件的实体应当对扩展开放，对修改关闭
• 依赖倒转原则：要针对接口编程，不要针对实现编程
• 迪米特法则：只与你直接的朋友通信，而避免和陌生人通信

核心本质：

• 实例化对象不使用new，用工厂方法代替 factory
• 将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦

  3.2.2、简单工厂模式（静态工厂模式）

  用来生产同一等级结构中的任意产品（对于增加新的产品，需要扩展已有代码） ```java public interface Car { void name(); }

public class WuLing implements Car{

@Override
public void name() {
    System.out.println("五菱宏光");
}

}

public class Tesla implements Car{

@Override
public void name() {
    System.out.println("特斯拉");
}

}

// 静态工厂模式 // 开闭原则 public class CarFactory {

// 方法一： 不满足开闭原则
public static Car getCar(String car){
    if(car.equals("wuling")){
        return new WuLing();
    }else if(car.equals("tesila")){
        return new Tesla();
    }else {
        return null;
    }
}
// 方法二：
public static Car geyWuling(){
    return new WuLing();
}
public static Car geyTesla(){
    return new Tesla();
}

}

public class Consumer { public static void main(String[] args) { // 接口，所有的实现类 // Car car = new WuLing(); // Car car1 = new Tesla();

    // 2、使用工厂创建
    Car car = CarFactory.getCar("wuling");
    Car car1 = CarFactory.getCar("tesila");
    car.name();
    car1.name();
}

}

弊端：<br />增加一个新的产品，做不到不修改代码。<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/25484710/1648367442717-99329dd8-956f-4587-9ac7-8cff6750a0b5.png#clientId=u5362e756-0f19-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=579&id=u80b4647a&margin=%5Bobject%20Object%5D&name=image.png&originHeight=965&originWidth=1265&originalType=binary&ratio=1&rotation=0&showTitle=false&size=320503&status=done&style=none&taskId=u57669efa-cae4-4a47-9f45-a32d2355361&title=&width=758.5)<br />来一个披萨订购的demo
```java
/**
 * 披萨接口
 */
public abstract class Pizza {
    protected  String  name;
    // 不同的披萨原材料是不同的 因此做成抽象方法
    public  abstract void prepare();
    public void bake(){
        System.out.println(name + " baking");
    }
    public void cut(){
        System.out.println(name + " cutting");
    }
    public void box(){
        System.out.println(name + " boxing");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
public class GreekPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println(" 给希腊披萨 准备原材料！");
    }
}
public class CheesePizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println(" 给制作奶酪披萨 准备原材料！");
    }
}
/**
    订购工厂
**/
public class OrderPizza {
    // 构造器
    public OrderPizza() {
        Pizza pizza = null;
        String orderType; // 订购披萨类型
        do {
            orderType = getType();
            if (orderType.equals("greek")){
                pizza = new GreekPizza();
                pizza.setName("greek");
            }else if (orderType.equals("cheese")){
                pizza = new CheesePizza();
                pizza.setName("cheese");
            }else {
                break;
            }
            // 输出披萨制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }while (true);
    }
    // 写一个方法 来获取用户希望订购的披萨种类
    private String getType(){
        Scanner scanner = new Scanner(System.in);
        String next = scanner.next();
        return next;
    }
}
/**
 * 客户端
 */
public class PizzaStore {
    public static void main(String[] args) {
        new OrderPizza();
    }
}

违反了设计模式的ocp原则，即对扩展开发 对修改关闭 当我们要增加新功能的时候要修改代码

修改一些代码：

import java.util.Scanner;
public class OrderPizza {
    // 定义一个简单工厂
    SimpleFactory simpleFactory;
    Pizza pizza = null;
    public void setSimpleFactory(SimpleFactory simpleFactory){
        String orderType = null;
        this.simpleFactory = simpleFactory;
        do {
            orderType = getType();
            pizza = simpleFactory.createPizza(orderType);
            if (pizza != null){
                pizza.setName(orderType);
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }
        }while (true);
    }
    // 写一个方法 来获取用户希望订购的披萨种类
    private String getType(){
        Scanner scanner = new Scanner(System.in);
        String next = scanner.next();
        return next;
    }
}
// 加一个管理全部pizza的工厂
public class SimpleFactory {
    public Pizza createPizza(String orderType){
        Pizza pizza = null;
        System.out.println("使用了简单工厂模式");
        if (orderType.equals("greek")){
            pizza = new GreekPizza();
            pizza.setName("greek");
        }else if (orderType.equals("cheese")){
            pizza = new CheesePizza();
            pizza.setName("cheese");
        }
        return pizza;
    }
}

3.2.3、工厂方法模式：

用来生产同一等级结构中的固定产品（支持增加任意产品）

public interface Car {
    void name();
}
public class WuLing implements Car {
    @Override
    public void name() {
        System.out.println("五菱宏光");
    }
}
public class Tesla implements Car {
    @Override
    public void name() {
        System.out.println("特斯拉");
    }
}
// 工厂方法模式
public interface CarFactory {
    Car getCar();
}
public class WulingFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new WuLing();
    }
}
public class TeslaFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Tesla();
    }
}
public class Consumer {
    public static void main(String[] args) {
        Car car = new WulingFactory().getCar();
        Car car1 = new TeslaFactory().getCar();
        car.name();
        car1.name();
        Car car2 = new MoBaiFactory().getCar();
        car2.name();
    }
}

对比简单工厂模式
1、结构复杂度：simple>method
2、代码复杂度：simple>method
3、编程复杂度：simple>method
4、管理上的复杂度：simple>method
根据设计原则，使用工厂方法模式；根据实际业务，使用简单工厂模式

3.3、原型模式

3.3.1、模式介绍

• 原型模式(Prototype模式)是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象
• 原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节
• 工作原理是：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即 对象.clone()

在有些系统中，存在大量相同或相似对象的创建问题，如果用传统的构造函数来创建对象，会比较复杂且耗时耗资源，用原型模式生成对象就很高效，就像孙悟空拔下猴毛轻轻一吹就变出很多孙悟空一样简单。
原型模式的定义和特点
原型（Prototype）模式的定义如下：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。例如，Windows 操作系统的安装通常较耗时，如果复制就快了很多。在生活中复制的例子非常多，这里不一一列举了。
优点：

• Java 自带的原型模式基于内存二进制流的复制，在性能上比直接 new 一个对象更加优良。
• 可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份，并将其状态保存起来，简化了创建对象的过程，以便在需要的时候使用（例如恢复到历史某一状态），可辅助实现撤销操作。

原型模式的缺点：

• 需要为每一个类都配置一个 clone 方法
• clone 方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违背了开闭原则。
• 当实现深克隆时，需要编写较为复杂的代码，而且当对象之间存在多重嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来会比较麻烦。因此，深克隆、浅克隆需要运用得当。

原型模式结构和实现
由于 Java 提供了对象的 clone() 方法，所以用 Java 实现原型模式很简单。

3.3.2、 模式的结构

原型模式包含以下主要角色。

1. 抽象原型类：规定了具体原型对象必须实现的接口。
2. 具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
3. 访问类：使用具体原型类中的 clone() 方法来复制新的对象。

3.3.3、模式的实现

原型模式的克隆分为浅克隆和深克隆。

• 浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的的
• 深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

Java 中的 Object 类提供了浅克隆的 clone() 方法，具体原型类只要实现 Cloneable 接口就可实现对象的浅克隆，这里的 Cloneable 接口就是抽象原型类。其代码如下：

//具体原型类
class Realizetype implements Cloneable {
    Realizetype() {
        System.out.println("具体原型创建成功！");
    }
    public Object clone() throws CloneNotSupportedException {
        System.out.println("具体原型复制成功！");
        return (Realizetype) super.clone();
    }
}
//原型模式的测试类
public class PrototypeTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Realizetype obj1 = new Realizetype();
        Realizetype obj2 = (Realizetype) obj1.clone();
        System.out.println("obj1==obj2?" + (obj1 == obj2));
    }
}

实例：

public class Sheep implements Cloneable{
    private String name;
    private int age;
    private String color;
    public Sheep(String name, int age, String color) {
        super();
        this.name = name;
        this.age = age;
        this.color = color;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    @Override
    public String toString() {
        return "Sheep [name=" + name + ", age=" + age + ", color=" + color + "]";
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

传统方法（不适用原型模式）

public static void main(String[] args) {
        Sheep sheep = new Sheep("tom", 1, "白色");
        Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        System.out.println(sheep.hashCode());// 1735600054
        System.out.println(sheep2.hashCode());// 21685669
}

原型模式

public static void main(String[] args) throws CloneNotSupportedException {
        Sheep sheep = new Sheep("tom", 1, "白色");
        Sheep cloneSheep = (Sheep) sheep.clone();
          System.out.println(sheep.hashCode());// 1735600054
        System.out.println(cloneSheep.hashCode());// 21685669
    }

通过上述两种方式的对比，我们发现不管使用哪种方式，拷贝的方式都是深拷贝，那对于对象中的属性对象是什么拷贝呢？向 Sheep类中加入一个对象属性

    private String name;
    private int age;
    private String color;
    public Sheep friend; //是对象, 克隆是会如何处理
    .............

 public static void main(String[] args) throws CloneNotSupportedException {
        Sheep sheep = new Sheep("tom", 1, "白色");
        sheep.friend = new Sheep("jerry", 2, "黑色");
        Sheep cloneSheep = (Sheep) sheep.clone();
        // 哈希值：1735600054 sheep.friend 21685669
     System.out.println(sheep.hashCode()+" sheep.friend"+" "+sheep.friend.hashCode());
         // 哈希值：2133927002 cloneSheep.friend 21685669
     System.out.println(cloneSheep.hashCode()+" cloneSheep.friend"+" "+cloneSheep.friend.hashCode());
    }

经测试，我们发现，对于类中属性对象，采用的是浅拷贝方式，那有什么方法能让他实现深拷贝呢？有下面两种方法

1. 通过重写clone()方法实现
2. 通过序列化实现

一、通过重写clone()方法实现深拷贝

1. 修改上述 Sheep类的克隆方法 ```java @Override protected Sheep clone() throws CloneNotSupportedException {

    Sheep sheep = null;
    // 先克隆Sheep对象
    sheep = (Sheep) super.clone();
    // 再克隆Sheep中的friend对象
    sheep.friend =  friend.getclone();
    return sheep;

   } // 为对象中的对象即friend提供克隆方法 protected Sheep getclone() throws CloneNotSupportedException {

    return (Sheep) super.clone();

   }

```java
  public static void main(String[] args) throws CloneNotSupportedException {
        Sheep sheep = new Sheep("tom", 1, "白色");
        sheep.friend = new Sheep("jerry", 2, "黑色");
        Sheep cloneSheep = (Sheep) sheep.clone();
        // 1735600054 sheep.friend 21685669
      System.out.println(sheep.hashCode()+" sheep.friend"+" "+sheep.friend.hashCode());
      // 2133927002 cloneSheep.friend 1836019240
      System.out.println(cloneSheep.hashCode()+" cloneSheep.friend"+" "+cloneSheep.friend.hashCode());
    }

3.3.4、深拷贝

深拷贝通过多种方法实现
方式一： 通过clone方法实现深拷贝

public class DeepProtoType implements Serializable, Cloneable {
    public String name;
    public DeepCloneableTarget deepCloneableTarget;
    public DeepProtoType() {
        super();
    }
    // 深拷贝  方式1  使用clone方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object deep = null;
        // 这里完成基本数据类型和String的克隆
        deep = super.clone();
        // 对引用类型进行单独处理
        DeepProtoType deepProtoType = (DeepProtoType) deep;
        deepProtoType.deepCloneableTarget = (DeepCloneableTarget) deepCloneableTarget.clone();
        return deepProtoType;
    }
}

方式二： 通过序列化来实现深拷贝

public class DeepProtoType implements Serializable, Cloneable {
    public String name;
    public DeepCloneableTarget deepCloneableTarget;
    public DeepProtoType() {
        super();
    }
    // 方式二  利用对象的 序列化来实现  推荐使用
    public Object deepClone(){
        // 创建流对象
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;
        DeepProtoType deepProtoType = null;
        try {
            // 序列化
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this); // 对当前的对象以对象流的方式输出
            // 反序列化
            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            deepProtoType = (DeepProtoType) ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return deepProtoType;
    }
}