1.5.1 常用的设计原则和设计模式

最新推荐文章于 2024-07-19 17:37:28 发布

cyuluo69582

最新推荐文章于 2024-07-19 17:37:28 发布

阅读量166

点赞数

分类专栏： java笔记文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/cyuluo69582/article/details/119332112

版权

java笔记专栏收录该内容

22 篇文章 0 订阅

订阅专栏

一、常用的设计原则

1.软件开发的流程

需求分析文档、概要设计文档、详细设计文档、编码和测试、安装和调试、维护和升级

2. 常用的设计原则

开闭原则（Open Close Principle）
对扩展开放对修改关闭，为了使程序的扩展性好，易于维护和升级。

对修改关闭就是在程序测试完成后尽量不要修改，可以通过拓展的方式进行功能的调整。比如创建新的子类继承已经完成的类。

里氏代换原则（Liskov Substitution Principle）
任何基类可以出现的地方，子类一定可以出现，多使用多态的方式。

例如传参时，形参为父类引用，那么该父类的子类实参都可以传入。

依赖倒转原则（Dependence Inversion Principle）
尽量多依赖于抽象类或接口而不是具体实现类，对子类具有强制性和规范性。

对子类的强制性和规范性表现在：例如继承抽象类时必须重写所有的抽象方法，否则该类也变成抽象类。

接口隔离原则（Interface Segregation Principle）
尽量多使用小接口而不是大接口，避免接口的污染，降低类之间耦合度。

因为实现接口后必须要重写所有的方法，但是我们要实现的类并不一定适合所有的方法。例如狗不会飞。

迪米特法则（最少知道原则）（Demeter Principle）
一个实体应当尽量少与其他实体之间发生相互作用，使系统功能模块相对独立。
高内聚，低耦合。

高内聚：该有的功能高度聚集于实体的内部
低耦合:不该有的功能和其他模块中的功能尽量减少关联
例子：老师修水龙头

合成复用原则（Composite Reuse Principle）
尽量多使用合成/聚合的方式，而不是继承的方式。

public class A {

    public void show(){
        System.out.println("这是A类中的show方法！");
    }
}

public class B /*extends A */{
    private A a;//合成复用原则

    public B(A a) {
        this.a = a;
    }

    public void test(){
        //调用A类中的show方法，请问如何实现？
        a.show();
    }
}

二、常用的设计模式

1. 基本概念

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
设计模式就是一种用于固定场合的固定套路。

2 基本分类

创建型模式 - 单例设计模式、工厂方法模式、抽象工厂模式、…
结构型模式 - 装饰器模式、代理模式、…
行为型模式 - 模板设计模式

三、设计模式详解（重点）

1 单例设计模式

单例设计模式主要分为：饿汉式和懒汉式，懒汉式需要对多线程进行同步处理。

什么是单例设计模式？
单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。
具体实现需要：
（1）将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
（2）在该类内部产生一个唯一的实例化对象，并且将其封装为private static类型。
（3）定义一个静态方法返回这个唯一对象。

懒汉式的线程同步优化：

public class Singleton {

    //2.声明本类类型的引用指向本类类型的对象并用private static关键字修饰
    private static Singleton sin = null;
    //1.私有化构造方法，使用private关键字修饰
    private Singleton() {

    }
    //3.提供公有的get方法负责将上述对象返回出去，使用public static 关键字修饰

    public static /*synchronized*/ Singleton getSin() {
        /*synchronized (Singleton.class) {
            if (null == sin) {
                sin = new Singleton();
            }

            return sin;
        }*/

        if (null == sin) {
            synchronized (Singleton.class) {
                if (null == sin) {
                    sin = new Singleton();
                }

                return sin;
            }
        }
    }
}

在多线程下，懒汉式需要使用线程同步，否则不能保证懒汉式的线程安全
如果只是使用synchronized方法，效率较低
使用双重if实现双检查锁机制，内存占用率高，效率高，线程安全，多线程操作原子性。只会在第一次进入时加锁，之后sin不为null时，会直接跳到return。

2 普通工厂模式

（1）基本概念

普通工厂方法模式就是建立一个工厂类，对实现了同一接口的不同实现类进行实例的创建。

（2）类图结构

在这里插入图片描述图中一个工厂类，一个接口定义抽象方法来描述发送的行为，同时还有两个实现对象

什么是工厂模式？

send接口：

public interface Sender{
//自定义抽象方法来描述发送的行为
void send();
}

MailSender类实现Sender接口：

public class MailSender implements Sender{
@Override
public void send(){
	System.out.println("正在发送邮件...");
}

SmsSender类实现Sender接口：

public class SmsSender implements Sender{
@Override
public void send(){
System.out.println("正在发送短信...")；
}

SendFactory工厂类

public class SendFactory{
//自定义成员方法实现对象的创建
public Sender produce(String type){
System.out.println("随便打印一句话进行测试");
if("mail".equals(type)){
return new MailSender();
}
if("sms".equals(type)){
return new SmsSender();
}
return null;
}
}

SenderFactoryTest工厂测试类：

public class SenderFactoryTest{
public static void main(String[] args){
//1.声明工厂类类型的引用指向工厂类类型的对象
SenderFactory sf = new SendFactory();
//2.调用生产方法来实现对象的创建
Sender sender = sf.produce("mail");
//Sender sender sf.produce("mail1");//传递的字符出错，不能正确创建对象，出现空指针异常
//3.使用对象调用方法模拟发生的行为
sender.send();
}
}

（3）主要缺点

在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，并且可能出现空指针异常。

3.多个工厂方法模式

（1）类图结构

在这里插入图片描述

在代码方面，Sender接口和下属的MailSender类以及Sms类不需要更改。
SendFactory改用：

public class SendFactory{
public Sender produceMail(){
return new MailSender();
}
public Sender produceSms(){
return new SmsSender();
}
}

SenderFactoryTest改用：

public class SenderFactoryTest{
public static void main(String[] args){
//1.声明工厂类类型的引用指向工厂类类型的对象
SendFactory sf = new SendFactory();
//2.调用生产方法来实现对象的创建
Sender sender = sf.produceMail();
//3.使用对象调用方法模拟发生的行为
sender.send();
}
}

(2)主要缺点

在多个工厂方法模式中，为了能够正确创建对象，先需要创建工厂类的对象才能调用工厂类中的生产方法。

4.静态工厂方法模式

（1）类图结构

在这里插入图片描述

静态工厂方法模式与多个工厂方法模式相比，就是在SendFactory类中的成员方法中添加了static关键词，方便可以直接用类名调用。
SendFactory类改写：

public class SendFactory{
//添加static方便直接类名调用
public static Sender produceMail(){
return new MailSender();
}
public static Sender produceSms(){
return new SmsSender();
}
}

SendFactoryTest类改写：

public class SenderFactoryTest{
public static void main(String[] args){
//调用生产方法来实现对对象的创建
Sender sender = SendFactory.produceMail();
//使用对象调用方法模拟发生的行为
sender.send();
}
}

（2）实际意义

工厂方法模式适合：凡是出现了大量的产品需要创建且具有共同的接口时，可以通过工厂方法模式进行创建。

（3）主要缺点

工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序生产新的产品，就必须对工厂类的代码进行修改，这就违背了开闭原则。

5.抽象工厂模式

（1）类图结构

在这里插入图片描述

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

提供一个接口类，该类中定义抽象方法用来描述产品的生产行为，是工厂的接口。Sender接口继续用。

Provider接口：

public interface Provider{
//自定义抽象方法描述产品的生产行为
Sender produce();
}

MailSenderFactory类实现Provider接口：

public class MailSenderFactory implement Provider{
@Override
public Sender produce(){
return new MailSender();
}
}

SmsSenderFactory类实现Provider接口：

public class SmsSenderFactory implenment Provider{
@Override 
public Sender produce(){
return new SmsSender();
}
}

SenderFactoryTest类改为：

public class SenderFactoryTest {
public static void main(String[] args){
Provider provider = new MailSenderFactory();
Sender sender2 = provider.produce();
sender2.send();
}
}

6.装饰器模式

（1）基本概念

装饰器模式就是给一个对象动态的增加一些新功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。

（2）类图结构

在这里插入图片描述

（3）实际意义

可以实现一个类功能的扩展。
可以动态的增加功能，而且还能动态撤销（继承不行）。
缺点：产生过多相似的对象，不易排错。
Sourceable接口：

public interface Sourceable{
//自定义抽象方法
void method();
}

Source（被装饰）类实现Sourceable接口：

public class Source implements Sourceable{
@Override
public void method(){
System.out.println("素颜美可以如此之美！");
}
}

Decorator（装饰）类实现Sourceable接口：

public class Decorator implements Sourceable{
private Sourceable source;

public Decorator(Sourceable source){
this.source = source;
}
@Override
public void method(){
source.method();//保证原有功能不变
System.out.println("化妆之后你会更美！");
}
}

7.代理模式

（1）基本概念

代理模式就是找一个代理类替原对象进行一些操作。
比如我们在租房子的时候找中介，再比如我们打官司需要请律师，中介和律师在这里就是我们的代理。

（2）类图结构

在这里插入图片描述

（3）实际意义

将多个子类共有且逻辑基本相同的内容提取出来实现代码复用。
不同的子类实现不同的效果形成多态，有助于后期维护。
Proxy类实现Sourceable接口：

public class Proxy implements Sourceable{
private Source source;

public Proxy(){
source = new Source();

@Override 
public void method(){
source.method();
System.out.println("我和装饰器模式其实是不一样的！")
}
}
}

SourceableTest类：

public class SourceableTest{
public static void main(String[] args){
Sourceable sourceable = new Source();
sourceable.method();

System.out.println("-----------------------------------------------");
//接下来使用装饰类实现功能
Sourceable sourceable1 =new Decorator(sourceable);
sourceable1.method();

System.out.println("-----------------------------------------------");
//代理模式
Sourceable sourceable2 = new Proxy();
sourceable2.method();
}
}

三、总结

1、常用的设计原则和设计模式
软件开发的流程、常用的设计原则、设计模式的概念和分类、常用设计模式的详解等

cyuluo69582

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
1.5.1 常用的设计原则和设计模式

一、常用的设计原则1.软件开发的流程需求分析文档、概要设计文档、详细设计文档、编码和测试、安装和调试、维护和升级2. 常用的设计原则开闭原则（Open Close Principle）对扩展开放对修改关闭，为了使程序的扩展性好，易于维护和升级。Markdown将文本转换为 HTML。对修改关闭就是在程序测试完成后尽量不要修改，可以通过拓展的方式进行功能的调整。比如创建新的子类继承已经完成的类。里氏代换原则（Liskov Substitution Principle）任何基类
复制链接

扫一扫