Java设计模式

最新推荐文章于 2024-07-30 20:50:32 发布

周广亚732

最新推荐文章于 2024-07-30 20:50:32 发布

阅读量1k

点赞数

文章标签： java 设计模式开发语言

本文链接：https://blog.csdn.net/qq_61899321/article/details/129027147

版权

设计模式

最早概念时在建筑领域产生，后来被引入到软件开发领域

之前的程序员们，在工作中对某一类问题解决方式及逆行总结归纳，一种问题对应着一个模式

设计模式就是在面向对象的基础上，更加合理的组织类与类之间的关系

为什么学习设计模式

提高编程设计能力，让程序设计更加标准合理，提高开发效率

提高程序的维护性，能够看懂复杂的源码

建模语言

使用特定图形符号，在设计阶段表示类的结构，以及类与类之间的关系

类

类是指具有相同属性，方法和关系的对象的抽象，它封装了数据和行为，是面向对象程序设计(OOP)的基础，具有封装性，继承性和多态性等三大特性

接口

接口是一种特殊的类，它具有类的结构但不可被实例化，只可以被子类实现。它包含抽象操作，但不包含属性。它描述了类或组件对外可见的动作

类之间的关系

依赖关系:是一种使用关系，它是对象这几件耦合度最弱的一种关联方式，是临时性的关联

关联关系:是对象之间的一种引用关系，用于不熬是一类对象与另一类对象之间的联系

聚合关系:是关联关系的一种，是强关联关系，是整体和部分之间的关系。聚合关系也是通过成员对象来是实现的，其中成员对象是整体对象的一部分，但是成员对象可以脱离整体对象而独立存在。

组合关系:表示类之间的整体与部分的关系，但它是一种更强烈的聚合关系，在组合关系中，整体对象可以控制部分对象的生命周期，一旦整体对象不存在，部分对象也将不存在，部分对象不能脱离整体对象而存在

继承关系:是对象自建耦合度最大的一种关系，表示一般与特殊的关系，是父类与子类之间的关系，是一种继承关系。

实现关系:是接口与实现类之间的关系，在这种关系中，类实现了接口，类中的操作实现了接口中所声明的所有的抽象操作

面向对象设计原则

单一原则

降低类的职责，一个类负责一个功能，耦合度降低

开闭原则

对修改关闭，对扩展开放

不建议在新家功能时，对原来的代码进行修改，可以通过新增加一个类完成

对程序进行抽象化设计设计出抽象类，接口，不同的功能扩展子列即可

里氏替换原则

子类继承父类后，尽量不要重写父类中的方法,可以扩展其他的功能

作用: 保证子类功能的正确性，不能让功能修改后导致程序出错

依赖倒置

上层依赖于抽象，不依赖于底层实现细节

接口隔离

接口功能设计时，尽量减少一个接口中有过多的功能，可以细分为多个接口

迪米特原则

一个对象应该对其他对象有最少的了解

在一个类中，应尽量少点使用与其没有之间关系的类(非直接朋友)

组合/聚合复用原理

使用继承为了复用父类中的方法，但是类与类的耦合度高、

可以使用关联/依赖，在一个类中达到复用别的类中的方法

23种设计模式介绍

1.单例模式

某个欸只能胜场一个实例,该类提供了一个全局访问点供外部获取该实例,其拓展是有限多例模式

2.原型模式

将一个对象作为原型,通过对其进行复制而克隆出多个和原型类似的新实例

3.工厂方法模式

定义一个用于创建产品的接口,有子类决定生产什么产品

4.抽象工厂模式

提供一个创建产品族的接口,其每个子类可以生产一系列相关的产品

5.建造者模式

将一个复杂对象分解成多个相对简单的部分,然后根据不同需要分别创建它们,最后构建成该复杂对象

6.代理模式

为某对象提供一种代理理以控制对该对象的访问。即客户端通过代理间接地访问该对象，从而限制、增强或修改该对象的一些特性。

7.适配器模式

将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。

8.桥接模式

将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。

9.装饰模式

动态的给对象增加一些职责，即增加其额外的功能

10.外观模式

为多个复杂的子系统提供一个一致的接口，使这些子系统更加容易被访问

11.享元模式

运用共享技术来有效地支持大量细粒度对象的复用

12.组合模式

将对象组合成树状层次结构，使用户对单个对象和组合对象具有一致的访问性。

13.模板方法模式

定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。

14.策略模式

定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的改变不会影响使用算法的客户。

15.命令模式

将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开

16.职责链模式

把请求从链中的一个对象传到下一个对象，直到请求被响应为止。通过这种方式去除对象之间的耦合。

17.状态模式

允许一个对象在其内部状态发生改变时改变其行为能力

18.观察者模式

多个对象间存在一对多关系，当一个对象发生改变时，把这种改变通知给其他多个对象，从而影响其他对象的行为。

19.中介者模式

定义一个中介对象来简化原有对象之间的交互关系，降低系统中对象间的耦合度，使原有对象之间不必相互了解。

20.迭代器模式

提供一种方法来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。

21.访问者模式

在不改变集合元素的前提下，为一个集合中的每个元素提供多种访问方式，即每个元素有多个访问者对象访问。

22.备忘录模式

在不破坏封装性的前提下，获取并保存一个对象的内部状态，以便以后恢复它。

23.解释器模式

提供如何定义语言的文法，以及对语言句子的解释方法，即解释器。

常用设计模式

单例模式

为了节省内存资源保证数据内容的一致性,对某些类要求只能创建一个实例

特点:

1.单例类只能有一个实例对象

2.该单例对象必须由单例类自行创建

3.单例类对外提供一个访问该单例的全局访问点

单例模式的两种实现

饿汉式单例:

静态的成员在类被加载时,就会初始化类丢向,只有一份,没有任何的线程安全问题

懒汉式单例:

在类加载的时候,不创建对象,在使用时创建,会出现线程安全问题

线程安全问题解决方案:

1.给方法加锁,可以解决,但效率低,一次只能由一个线程进入获取

2.给代码块加锁, 双重检索+synchronized

抽象工厂模式

基本原理:

抽象工厂模式一个具体的工厂创建一系列相互关联的产品,会简化客户端的调用,并且更换产品系列非常方便,更换一个工厂类即可.

优点:

获取具体系列产品,只需要通过具体系列工厂获取,无需关心创建的细节

代码示例:

// 抽象工厂类
public interface AbstractFactory {
    Computer getComputer();
    Phone getphone();
}

// 华为工厂实现抽象工厂类
public class HuaWeiFactory implements AbstractFactory {
    @Override
    public Computer getComputer() {
        return new HuaWeiComputer();
    }

    @Override
    public Phone getphone() {
        return new HuaWeiPhone();
    }
}

// 苹果工厂实现抽象工厂类
public class AppleFactory implements AbstractFactory {
    @Override
    public Computer getComputer() {
        return new AppleComputer();
    }

    @Override
    public Phone getphone() {
        return new ApplePhone();
    }
}

// 抽象手机类
public interface Phone {
    void call();
}

// 抽象电脑类
public interface Computer {
    void sentmessage();
}

// 华为手机实现抽象手机类
public class HuaWeiPhone implements Phone{
    @Override
    public void call() {
        System.out.println("华为手机打电话");
    }
}

// 苹果手机实现抽象手机类
public class ApplePhone implements Phone{
    @Override
    public void call() {
        System.out.println("苹果手机打电话");
    }
}

// 华为电脑实现抽象电脑类
public class HuaWeiComputer implements Computer {
    @Override
    public void sentmessage() {
        System.out.println("华为电脑发信息");
    }
}

// 苹果电脑实现抽象电脑类
public class AppleComputer implements Computer{
    @Override
    public void sentmessage() {
        System.out.println("苹果电脑发消息");
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {

        // 创建华为工厂对象
        AbstractFactory huaWeiFactory = new HuaWeiFactory();
        // 调用获得华为电脑对象
        Computer huaweicomputer = huaWeiFactory.getComputer();
        // 调用获得华为手机对象
        Phone huaweiphone = huaWeiFactory.getphone();
        huaweicomputer.sentmessage();// 华为电脑发信息
        huaweiphone.call();// 华为手机打电话

        // 创建苹果工厂对象
        AbstractFactory appleFactory = new AppleFactory();
        // 调用获得苹果手机对象
        Phone applephone = appleFactory.getphone();
        // 调用获得苹果电脑对象
        Computer applecomputer = appleFactory.getComputer();
        applephone.call(); // 苹果手机打电话
        applecomputer.sentmessage();// 苹果电脑发消息
    }
}

解析图片: