设计模式-遵守原则(java)

最新推荐文章于 2024-07-15 22:27:12 发布
最新推荐文章于 2024-07-15 22:27:12 发布
阅读量538 收藏
点赞数
分类专栏： 面试 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45405302/article/details/113788851
版权

设计模式是什么？

设计模式是对软件设计中普遍存在（反复出现）的各种问题，所提出的解决方案。

设计模式七大原则

1）单一职责原则
2）接口隔离原则
3）依赖倒转(倒置)原则
4）里式替换原则
5）开闭原则
6）迪米特法则
7）合成复用原则

单一职责原则

对类来说的，即一个类应该只负责一项职责。如类A负责两个不同的职责：
职责1，职责2，当职责1需求变更而改变A时，可能造成职责2执行错误。
应将类A的粒度分解为A1,A2

代码实现：
在这里插入图片描述
在这里插入图片描述

接口隔离原则

基本介绍：
客户端不应该依赖他不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上

如
有一个公用接口interface1
B、D 都分别实现interface1

然后目前有两个类，分别只需要B、D的中的123和145接口
此时B、D中的接口就会有用不掉的出现冗余

在这里插入图片描述

improve（改进）

在这里插入图片描述

依赖倒转原则

在这里插入图片描述
依赖传递有
1、接口传递
2、构造方法传递
3、setter传递
在这里插入图片描述
构造方法个setter 大同小异
主要做法是在调用的方法中声明一个private 的 接口对象，
调用对象的方法 ， 在构造、setter中进行赋值

在这里插入图片描述

在这里插入图片描述

里式替换原则

2）总结的意思是：类A ， 类B
把A中的方法全部换成B 且能正常使用。
在这里插入图片描述
总的来说，尽量不重写方法

public class Liskov {

    public static void main(String[] args) {
        A a = new A();
        System.out.println("11-3 = " + a.func1(11,3)); //8
        System.out.println("1-8 = " + a.func1(1,8)); //-7

        System.out.println("------------");
        B b = new B();
        //无意重写父类方法，发生错误
        //14
        System.out.println("11-3 = " + b.func1(11,3));
        //9
        System.out.println("1-8 = " + b.func1(1,8));
        //23
        System.out.println("11+3+9 = " + b.func2(11,3)); 
    }
}

/**
 * A类
 */
class A {

    /**
     * @return 返回两个数的差
     */
    public int func1(int num1 , int num2 ){
        return num1 - num2;
    }
}

/**
 * B类继承A
 * 增加了一个新功能，完成两个数相加，然后和9求和
 */
class B extends A{

    /**
     * 无意 重写了父类方法
     * @return
     */
    @Override
    public int func1(int a, int b){
        return a + b;
    }

    public int func2(int a, int b){
        return func1(a,b) + 9 ;
    }

}

解决

public class Liskov {

    public static void main(String[] args) {
        A a = new A();
        System.out.println("11-3 = " + a.func1(11,3)); //8
        System.out.println("1-8 = " + a.func1(1,8)); //-7

        System.out.println("------------");
        B b = new B();
        //B类不在继承A类，因此调用者不会认为func1是求减法
        //14
        System.out.println("11+3 = " + b.func1(11,3));
        //9
        System.out.println("1+8 = " + b.func1(1,8));
        //23
        System.out.println("11+3+9 = " + b.func2(11,3));
        //仍然可以使用组合使用A相关方法
        System.out.println("11-3 = " + b.func3(11,3));

    }
}

/**
 * 创建一个更加基础的基类
 * 把更加基础的方法和成员写到类中
 */
class Base {


}


/**
 * A类
 */
class A extends Base{

    /**
     * @return 返回两个数的差
     */
    public int func1(int num1 , int num2 ){
        return num1 - num2;
    }
}

/**
 * B类继承A
 * 增加了一个新功能，完成两个数相加，然后和9求和
 */
class B extends Base{

    /**
     *如果B需要使用A类方法，使用组合关系
     */
    private A a = new A();

    /**
     * 重写了父类方法,可能是无意的
     * @return
     */
    public int func1(int a, int b){
        return a + b;
    }

    public int func2(int a, int b){
        return func1(a,b) + 9 ;
    }

    /**
     * 我们仍然想使用A的方法
     */
    public int func3(int a, int b){
        return this.a.func1(a,b);
    }
}

在这里插入图片描述

开闭原则

在这里插入图片描述
方式1

public class Ocp {

    public static void main(String[] args) {
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Circle());
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Triangle());
    }
}

/**
 *这是一个用于绘制的类[使用方]
 */
class GraphicEditor {

    /**
     * 接收Shape对象，然后根据type，来绘制不同的图形
     * @param s
     */
    public void drawShape(Shape s){
        if(s.m_type == 1){
            drawRectangle(s);
        }else if(s.m_type == 2){
            drawCircle(s);
        }else if(s.m_type == 3){
            drawTriangle(s);
        }
    }

    //绘制矩形
    public void drawRectangle(Shape r){
        System.out.println("绘制矩形");
    }

    //绘制圆形
    public void drawCircle(Shape r){
        System.out.println("绘制圆形");
    }

    //新增绘制三角形
    public void drawTriangle(Shape r){
        System.out.println("绘制三角形");
    }

}

//Shape 基类
class Shape{
    int m_type;
}

class Rectangle extends Shape {
    Rectangle(){
        super.m_type = 1;
    }
}

class Circle extends Shape {
    Circle (){
        super.m_type = 2;
    }
}

//新增画三角形
class Triangle extends Shape {
    Triangle (){
        super.m_type = 3;
    }
}

方式一的优缺点：
在这里插入图片描述

improve
在这里插入图片描述

public class Ocp {

    public static void main(String[] args) {
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Circle());
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Triangle());
        graphicEditor.drawShape(new Other());
    }
}

/**
 *这是一个用于绘制的类[使用方]
 */
class GraphicEditor {

    /**
     * 接收Shape对象，然后根据type，来绘制不同的图形
     * @param s
     */
    public void drawShape(Shape s){
        s.draw();
    }

}

//Shape 基类
abstract class Shape{
    int m_type;

    public abstract  void draw();
}

class Rectangle extends Shape {

    Rectangle(){
        super.m_type = 1;
    }

    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}

class Circle extends Shape {

    Circle(){
        super.m_type = 2;
    }
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

//新增画三角形
class Triangle extends Shape {
    Triangle(){
        super.m_type = 3;
    }
    @Override
    public void draw() {
        System.out.println("绘制三角形");
    }
}

//新增一个图形
class Other extends Shape{
    Other(){
        super.m_type = 4;
    }
    @Override
    public void draw() {

        System.out.println("Other 图形");
    }
}

迪米特法则

在这里插入图片描述
重点看4、5

初始代码

public class Demeter1 {

    public static void main(String[] args) {
        SchoolManager schoolManager = new SchoolManager();
        //输出 信息
        schoolManager.printAllEmployee(new CollegeManager());

    }

}

/**
 * 学校总部员工
 */
class Employee {
    private String id;

    public void setId(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }
}

/**
 * 学院总部员工
 */
class CollegeEmployee {
    private String id;

    public void setId(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }
}

/**
 * 管理学院员工
 */
class CollegeManager {
    /**
     * 返回学院的所有员工
     */
    public List<CollegeEmployee> getAllEmployee() {
        List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
        //增加了10个员工到list
        for (int i = 0; i < 10; i++) {
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工id= " + i);
            list.add(emp);
        }
        return list;
    }
}

/**
 * 学校管理类
 * 分析 SchoolManager 类的直接朋友类有哪些  Employee、  CollegeManager
 * CollegeEmployee不是直接朋友（局部变量），这样违反了迪米特法则
 *
 */
class SchoolManager {
    /**
     * @return 返回学校总部的员工
     */
    public List<Employee> getAllEmployee() {
        List<Employee> list = new ArrayList<Employee>();
        //增加了5个员工到list
        for (int i = 0; i < 5; i++) {
            Employee emp = new Employee();
            emp.setId("学校总部员工id= " + i);
            list.add(emp);
        }
        return list;
    }

    /**
     * 该方法完成输出学校总部和学院员工信息的方法(id)
     * @param sub
     */
    void printAllEmployee(CollegeManager sub) {


        //分析问题
        //1、这里的CollegeEmployee 不是SchoolManager的直接朋友
        //2、CollegeEmployee以局部变量出现在SchoolManager
        //3、违反了迪米特法则
        //获取到学院员工
        List<CollegeEmployee> list1 = sub.getAllEmployee();
        System.out.println("------------学院员工------------");
        for (CollegeEmployee e : list1) {
            System.out.println(e.getId());
        }
        //获取到学校总部员工
        List<Employee> list2 = this.getAllEmployee();
        System.out.println("------------—学校总部员工------------");
        for (Employee e : list2) {
            System.out.println(e.getId());
        }
    }
}

存在的问题
在这里插入图片描述
improve(将输出学院的员工方法，封装到CollegeManager)

public class Demeter1 {

    public static void main(String[] args) {
        SchoolManager schoolManager = new SchoolManager();
        //输出 信息
        schoolManager.printAllEmployee(new CollegeManager());

    }

}

/**
 * 学校总部员工
 */
class Employee {
    private String id;

    public void setId(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }
}

/**
 * 学院总部员工
 */
class CollegeEmployee {
    private String id;

    public void setId(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }
}

/**
 * 管理学院员工
 */
class CollegeManager {
    /**
     * 返回学院的所有员工
     */
    public List<CollegeEmployee> getAllEmployee() {
        List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
        //增加了10个员工到list
        for (int i = 0; i < 10; i++) {
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工id= " + i);
            list.add(emp);
        }
        return list;
    }

    //输出学院员工的信息
    public void printEmployee() {
        List<CollegeEmployee> list1 = getAllEmployee();
        System.out.println("------------学院员工------------");
        for (CollegeEmployee e : list1) {
            System.out.println(e.getId());
        }
    }
}

/**
 * 学校管理类
 * 分析 SchoolManager 类的直接朋友类有哪些  Employee、  CollegeManager
 * CollegeEmployee不是直接朋友（局部变量），这样违反了迪米特法则
 *
 */
class SchoolManager {
    /**
     * @return 返回学校总部的员工
     */
    public List<Employee> getAllEmployee() {
        List<Employee> list = new ArrayList<Employee>();
        //增加了5个员工到list
        for (int i = 0; i < 5; i++) {
            Employee emp = new Employee();
            emp.setId("学校总部员工id= " + i);
            list.add(emp);
        }
        return list;
    }

    /**
     * 该方法完成输出学校总部和学院员工信息的方法(id)
     * @param sub
     */
    void printAllEmployee(CollegeManager sub) {


        //分析问题
        //1、将输出学院的员工方法，封装到CollegeManager
        sub.printEmployee();
        //获取到学校总部员工
        List<Employee> list2 = this.getAllEmployee();
        System.out.println("------------—学校总部员工------------");
        for (Employee e : list2) {
            System.out.println(e.getId());
        }
    }
}

在这里插入图片描述

合成复用原则

原则是尽量使用合成/聚合的方式，而不是使用继承
合成/聚合：
声明变量传递，对需要的方法进行调用，而不是使用继承。
如： B类中用到A类方法，不继承A，而是传入一个A的对象实例。

__H__
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java设计模式面试题汇总
10-01
本文将对Java设计模式面试题进行总结，涵盖软件设计原则、设计模式的定义、分类、常见模式等内容。 软件设计原则： 软件设计原则是指在软件设计中需要遵守的一些规则和原则，这些原则可以帮助软件开发人员设计出...
详解Java设计模式编程中的里氏替换原则
09-02
总结来说，Java设计模式中的里氏替换原则是指导我们如何正确使用继承的重要原则，它强调子类的替换不应破坏程序的结构和功能，从而保证代码的稳定性和可维护性。在编写继承关系的代码时，应当谨慎考虑是否有必要重写...
设计模式--创建型设计模式
KyleWong的博客
09-27 681
设计模式介绍、设计模式的七大原则以及创建型设计模式各模式的简单示例
Java中23种设计模式
热门推荐
呜呜老司机的博客家园
10-10 7万+
Java中23种设计模式，包括简单介绍，适用场景以及优缺点等
Java设计模式之七大设计原则
qq_49529322的博客
04-28 1万+
Java设计模式之七大设计原则 本文对Java设计模式中的七大设计原则进行汇总介绍，提炼最核心的概念。 设计模式总结笔记 一、设计模式七大原则 设计模式的目的： 代码可重用性：相同功能的代码，不用多次编写。 可读性：编程规范性，便于其他程序员的阅读和理解。 可扩展性：当需要增加新的功能的时候，非常方便，称为可扩展性。 可靠性：当我们新增功能后，对原来的功能没有影响。 使程序呈现高内聚、低耦合特性。 1.1、单一职责原则 不遵守单一职责原则： 对类来说的，就是一个类应该只负责一项职责。 比如：Us
java设计模式--创建型模式
z2331198564653的博客
07-10 1169
1) 设计模式是程序员在面对同类软件工程设计问题所总结出来的有用的经验，模式不是代码，而是某类问题的通用解决方案，设计模式（Design pattern）代表了最佳的实践。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。2) 设计模式的本质提高 软件的维护性，通用性和扩展性，并降低软件的复杂度。
java设计模式的六大原则
身体，灵魂，技术。总要有一个在前进
08-27 4564
java设计模式的六大规则
Java设计模式-开闭原则
码农日常的博客
03-01 7713
Java设计模式学习
设计模式七大原则——迪米特原则
★★光亭★★
02-06 8775
设计模式七大原则——迪米特原则
Java设计模式七大原则-单一职责原则
m0_62946761的博客
11-25 7017
讲解java设计模式遵循的七大原则之一的单一职责原则
设计模式-里氏替换原则
海的那边，还是海吗
09-15 1839
里氏替换原则（Liskov Substitution Principle，LSP）是面向对象编程中的一个重要设计原则，它是SOLID原则中的一部分，旨在确保子类（派生类）可以替代父类（基类）而不引入错误或破坏原有的程序设计和逻辑。这个原则的核心思想是，子类应该是父类的可替代品，它们应该具有相同的行为，或者说子类应该能够在不修改父类的情况下扩展或修改其行为。里氏替换原则是一个有助于设计稳健、可维护的面向对象系统的关键原则。它强调子类可以扩展或修改父类的行为，但不应该破坏父类的契约。
23种设计模式-单一原则
qq_32923295的博客
04-25 941
单一原则
java设计模式与原则demo
12-05
在这个"java设计模式与原则demo"中，我们将会探讨23种经典的设计模式以及6大设计原则。 首先，我们要了解的是六项设计原则，它们是SOLID原则的缩写： 1. 单一职责原则（Single Responsibility Principle, SRP）：一...
java设计模式之简单工厂模式简述
09-01
简单工厂模式是软件设计模式中的一种基础模式，它在Java编程中被广泛使用。这个模式的主要目的是通过一个公共的工厂类来创建对象，而避免客户端直接new对象，从而降低了代码的耦合度，使得系统更加灵活和易于扩展。 ...
积分兑换系统java源码-DesignPattern:设计模式
06-06
引入设计模式常常会增加程序复杂性，不是任何时候编码都严格遵守设计模式，而是讲究结合场景取舍，适度使用不是全部遵守。 工作过程中不经意间经常使用，但未总结过，抽时间用代码表达一下，同时让自己再加深下理解...
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 825
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 900
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1021
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
最新发布
m0_69266818的博客
07-15 827
介绍了Redis命令和用java操作redis还有营业额状态接口的书写

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值