31--设计模式、面向对象设计原则

发布时间:2023年12月27日

1、设计模式

1.1 设计模式概述

设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

设计模式不是一种方法和技术,而是一种思想。

设计模式和具体的语言无关,学习设计模式就是要建立面向对象的思想,尽可能的面向接口编程,低耦合,高内聚,使设计的程序可复用。

学习设计模式能够促进对面向对象思想的理解,反之亦然。它们相辅相成

简单一句话:设计模式就是经验的总结

设计模式的几个要素

  • 名字:必须有一个简单,有意义的名字
  • 问题描述:在何时使用模式
  • 解决方案:描述设计的组成部分以及如何解决问题
  • 效果:描述模式的效果以及优缺点设计模式的分类

设计模式的分类

  • 创建型模式:对象的创建
  • 结构型模式:对象的组成(结构)
  • 行为型模式:对象的行为

创建型模式:简单工厂模式,工厂方法模式,抽象工厂模式,建造者模式,原型模式,单例模式。(6个)

结构型模式:外观模式、适配器模式、代理模式、装饰模式、桥接模式、组合模式、享元模式。(7个)

行为型模式:模版方法模式、观察者模式、状态模式、职责链模式、命令模式、访问者模式、策略模式、备忘录模式、迭代器模式、解释器模式。(10个)

1.2 单例模式详解

1.2.1 什么是单例设计模式

单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。

1.2.2 单例模式特点

1、单例类只能有一个实例。也就是只有一个对象

2、单例类必须自己创建自己的唯一实例。 写单例构造方法是要私有的

3、单例类必须给所有其他对象提供这一实例。 在该方法中,提供一个方法,用于获取该对象

1.2.3 单例设计模式实现前提条件

私有构造方法

在本类的成员位置,创建出自己类对象

提供公共方法,返回创建的对象 ,该方法必须是静态的

1.2.4 单例模式饿汉式

package com.suyv.singleton;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 10:46
 * @Description: 饿汉式单例模式
 */
public class A {

    // 2.定义变量接收类的对象
    private static A a = new A();

    // 1.私有化构造器
    private A(){
    }

    // 3.定义静态方法返回类的对象
    public static A getInstance(){
        return a;
    }

}

测试

package com.suyv.singleton;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 10:49
 * @Description: 饿汉式单例模式测试
 */
public class ADemo01 {

    public static void main(String[] args) {
        A a1 = A.getInstance();
        A a2 = A.getInstance();

        System.out.println(a1);     // com.suyv.singleton.A@677327b6
        System.out.println(a2);     // com.suyv.singleton.A@677327b6

        System.out.println(a1 == a2);       // true
    }
}

1.2.5 单例模式懒汉式

package com.suyv.singleton;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 10:52
 * @Description: 懒汉式单例模式
 */
public class B {
    // 2.定义静态变量接收创建的对象
    private static B b;

    // 1.私有化构造器
    private B(){

    }

    // 3.定义一个静态方法,第一次创建时才创建对象,后面调用都会返回这一个对象
    public static B getInstance(){
        if (b == null){
            b = new B();
        }
        return b;
    }
}

测试

package com.suyv.singleton;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 10:56
 * @Description: 懒汉式单例模式测试
 */
public class BDemo01 {

    public static void main(String[] args) {

        B b1 = B.getInstance();
        B b2 = B.getInstance();

        System.out.println(b1);     // com.suyv.singleton.B@677327b6
        System.out.println(b2);     // com.suyv.singleton.B@677327b6

        System.out.println(b1 == b2);       // true

    }
}

1.2.6 单例设计模式的线程安全问题

1.2.6.1 饿汉式没有线程安全问题

饿汉式:在类初始化时就直接创建单例对象,而类初始化过程是没有线程安全问题的

1.2.6.2 懒汉式线程安全问题

问题出现:

package com.suyv.singleton;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 10:52
 * @Description: 懒汉式单例模式
 */
public class B{
    // 2.定义静态变量接收创建的对象
    private static volatile B b;

    // 1.私有化构造器
    private B(){

    }

    // 3.定义一个静态方法,第一次创建时才创建对象,后面调用都会返回这一个对象
    public static B getInstance(){

        if (b == null){

            try {
                // 让问题暴露更加明显
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            b = new B();
        }
        return b;
    }
}
package com.suyv.singleton;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 10:56
 * @Description: 懒汉式单例模式线程安全测试
 */
public class BDemo02 {
    static B b1 = null;
    static B b2 = null;

    public static void main(String[] args) {

        Thread t1 = new Thread(){
            @Override
            public void run() {
                b1 = B.getInstance();
            }
        };

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                b2 = B.getInstance();
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        System.out.println(b1);     // com.suyv.singleton.B@677327b6
        System.out.println(b2);     // com.suyv.singleton.B@14ae5a5

        System.out.println(b1 == b2);       // false

    }
}

解决方案:

package com.suyv.singleton;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 10:52
 * @Description: 懒汉式单例模式
 */
public class B{
    // 2.定义静态变量接收创建的对象
    private static volatile B b;

    // 1.私有化构造器
    private B(){

    }

    // 3.定义一个静态方法,第一次创建时才创建对象,后面调用都会返回这一个对象
    /*public static B getInstance(){

        if (b == null){

            try {
                // 让问题暴露更加明显
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            b = new B();
        }
        return b;
    }*/

    // 使用双重判断,效率更高
    public static B getInstance(){
        if (b == null){
            synchronized (B.class){
                if (b == null){
                    b = new B();
                }
            }
        }
        return b;
    }
}
package com.suyv.singleton;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 10:56
 * @Description: 懒汉式单例模式线程安全测试
 */
public class BDemo03 {
    static B b1 = null;
    static B b2 = null;

    public static void main(String[] args) {

        Thread t1 = new Thread(){
            @Override
            public void run() {
                b1 = B.getInstance();
            }
        };

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                b2 = B.getInstance();
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        System.out.println(b1);     // com.suyv.singleton.B@677327b6
        System.out.println(b2);     // com.suyv.singleton.B@677327b6

        System.out.println(b1 == b2);       // true

    }
}

解决程线安全问题

双层if判断的原因

  • 方法中加入同步锁,保证线程安全
  • 第二个线程调用方法getInstance()的时候,变量s,已经不是null,被前面的线程new过
  • 当已经有对象了,第二个线程没有必要再进入同步了,直接return返回对象即可

单例模式的应用场景和好处

????????Runtime

????????任务管理器对象、获取运行时对象

????????使用单例模式,可以避免资源浪费。

1.3 工厂模式

工厂设计模式,属于创建型,用于对象的创建; 简单来说,就是专门生产对象的

1.3.1 简单工厂模式

package com.suyv.factory;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 11:26
 * @Description: 动物抽象类
 */
public abstract class Animal {

    public abstract void eat();
}
package com.suyv.factory;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 11:27
 * @Description: 猫类
 */
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
package com.suyv.factory;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 11:28
 * @Description: 狗类
 */
public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
package com.suyv.factory;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 11:29
 * @Description: 工厂设计类,这个类就是专门来生产对象,今后从这个工厂类中可以直接获取类对象
 */
public class AnimalFactory {

    private AnimalFactory(){}

    public static Dog createDog(){
        return new Dog();
    }

    public static Cat creatCat(){
        return new Cat();
    }


}
package com.suyv.factory;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 11:32
 * @Description: 工厂模式测试
 */
public class AnimalTest {

    public static void main(String[] args) {

        // 工厂设计模式:
        //     优点:我可以直接通过工厂来获取对象
        //     缺点:如果要加对象,需要修改工厂类,不便于后期的维护

        // 使用工厂模式创建对象
        Cat cat = AnimalFactory.creatCat();
        Dog dog = AnimalFactory.createDog();

        // 调用方法
        cat.eat();
        dog.eat();
    }
}

1.3.2 实例工厂模式

package com.suyv.factory1;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 12:11
 * @Description: 创建一个接口
 */
public interface Product {
    public void doSomething();
}
package com.suyv.factory1;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 12:12
 * @Description: 实现接口的实现类
 */
public class ConcreteProduct implements Product{
    @Override
    public void doSomething() {
        System.out.println("Doing something in ConcreteProduct");
    }
}
package com.suyv.factory1;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 12:14
 * @Description: 实例工厂类
 */
public class ProductFactory {
    public Product createProduct(){
        return new ConcreteProduct();
    }

}
package com.suyv.factory1;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 12:15
 * @Description: 实例工厂测试类
 */
public class ProductTest {

    public static void main(String[] args) {
        ProductFactory factory = new ProductFactory();

        Product product = factory.createProduct();

        product.doSomething();
    }
}

1.3.3 静态工厂模式

package com.suyv.staticfactory;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 12:21
 * @Description: 定义一个咖啡类
 */
public abstract class Coffee {

    public abstract String getName();

    //加糖
    public void addsugar() {
        System.out.println("加糖");
    }

    //加奶
    public void addMilk() {
        System.out.println("加奶");
    }
}
package com.suyv.staticfactory;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 12:22
 * @Description: 美式咖啡
 */
public class AmericanCoffee extends Coffee{
    @Override
    public String getName() {
        return "美式咖啡";
    }
}
package com.suyv.staticfactory;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 12:23
 * @Description: 拿铁咖啡
 */
public class LatteCoffee extends Coffee{
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}
package com.suyv.staticfactory;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 12:29
 * @Description: 咖啡工厂类--静态工厂
 */
public class SimpleCoffeeFactory {

    public static Coffee createCoffee(String type) {
        //声明Coffee类型的变量,根据不同类型创建不同的coffee子类对象
        Coffee coffee = null;
        if("american".equals(type)) {
            coffee = new AmericanCoffee();
        } else if("latte".equals(type)) {
            coffee = new LatteCoffee();
        } else {
            throw new RuntimeException("对不起,您所点的咖啡没有");
        }

        return coffee;
    }
}
package com.suyv.staticfactory;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 12:24
 * @Description: 咖啡店类
 */
public class CoffeeStore {

    public Coffee orderCoffee(String type) {

        Coffee coffee = SimpleCoffeeFactory.createCoffee(type);

        //加配料
        coffee.addMilk();
        coffee.addsugar();

        return coffee;
    }
}
package com.suyv.staticfactory;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 12:26
 * @Description: 静态工厂类测试
 */
public class CofferTest {
    public static void main(String[] args) {

        //创建咖啡店类对象
        CoffeeStore store = new CoffeeStore();
        Coffee coffee = store.orderCoffee("latte");

        System.out.println(coffee.getName());
    }
}

1.4 模板设计模式

模版方法模式,简称为模板设计模式,它主要思想是:把通用的代码生成一个模板,可以反复的使用

package com.suyv.template;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 14:00
 * @Description: 创建一个模板类
 */
public abstract class GetTime {

    /**
     * @description: 获取一段程序的运行时间
     * @author: 憨憨浩浩
     * @date: 2023/12/27 14:02
     * @param: []
     * @return: long
     **/
    public long getTime(){

        long start = System.currentTimeMillis();

        // 程序
        code();

        long end = System.currentTimeMillis();

        return end - start;
    }

    public abstract void code();

}
package com.suyv.template;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 14:03
 * @Description: 用户使用模板类
 */
public class ForDemo extends GetTime{
    @Override
    public void code() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}
package com.suyv.template;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 14:04
 * @Description: 模板设计模式测试类
 */
public class TemplateTest {
    public static void main(String[] args) {
        ForDemo forDemo = new ForDemo();

        System.out.println(forDemo.getTime() + "毫秒");
    }
}

1.5 装饰设计模式

装饰设计模式: 增强原有对象的功能

原本有一个对象,但是这个对象的功能不够强,采用装饰设计模式,对原对象中功能进行增强

回想一下我们当时讲的缓冲流,其实就是装饰设计模式

package com.suyv.decorate;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 14:09
 * @Description: TODO
 */
public class Phone {
    public void call(){
        System.out.println("手机打电话功能!");
    }
}
package com.suyv.decorate;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 14:10
 * @Description: TODO
 */
public class SendMsg {
    private Phone phone;

    public SendMsg(Phone phone) {
        this.phone = phone;
    }

    //增强原有手机的功能
    public void msg(){
        System.out.println("发彩信");
        System.out.println("发短信");
        phone.call();
    }
}
package com.suyv.decorate;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-27 14:11
 * @Description: TODO
 */
public class PhoneTest {
    public static void main(String[] args) {

        SendMsg sendMsg = new SendMsg(new Phone());

        sendMsg.msg();

    }
}

2、面向对象思想设计原则

面向对象思想设计原则

在实际的开发中,我们要想更深入的了解面向对象思想,就必须熟悉前人总结过的面向对象的思想的设计原则

  • 单一职责原则
  • 开闭原则
  • 里氏替换原则
  • 依赖注入原则
  • 接口分离原则
  • 迪米特原则

2.1 单一职责原则

其实就是开发人员经常说的"高内聚,低耦合”

也就是说,每个类应该只有一个职责,对外只能提供一种功能,而引起类变化的原因应该只有一个。在设计模式中,所有的设计模式都遵循这一原则。能自己完成的事就不要麻烦别人,把一件事细化细化,只做一件事情

能自己完成的事就不要麻烦别人,把一件事细化细化,只做一件事情

2.2 开闭原则 ocp

核心思想是:一个对象对扩展开放,对修改关闭。

其实开闭原则的意思就是:对类的改动是通过增加代码进行的,而不是修改现有代码。

也就是说软件开发人员一旦写出了可以运行的代码,就不应该去改动它,而是要保证它能一直运行下去,如何能够做到这一点呢?这就需要借助于抽象和多态,即把可能变化的内容抽象出来,从而使抽象的部分是相对稳定的,而具体的实现则是可以改变和扩展的

2.3 里氏替换原则

核心思想:在任何父类出现的地方都可以用它的子类来替代。

其实就是说:同一个继承体系中的对象应该有共同的行为特征。

2.4 依赖注入原则

核心思想:要依赖于抽象,不要依赖于具体实现。

其实就是说:在应用程序中,所有的类如果使用或依赖于其他的类,则应该依赖这些其他类的抽象类,而不是这些其他类的具体类。为了实现这一原则,就要求我们在编程的时候针对抽象类或者接口编程,而不是针对具体实现编程。

2.5 接口分离原则

核心思想:不应该强迫程序依赖它们不需要使用的方法。

其实就是说:一个接口不需要提供太多的行为,一个接口应该只提供一种对外的功能,不应该把所有的操作都封装到一个接口中。

2.6 迪米特原则

核心思想:一个对象应当对其他对象尽可能少的了解

其实就是说:降低各个对象之间的耦合,提高系统的可维护性。在模块之间应该只通过接口编程,而不理会模块的内部工作原理,它可以使各个模块耦合度降到最低,促进软件的复用

文章来源:https://blog.csdn.net/weixin_46612641/article/details/135248200
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。