第二章 设计模式七大原则

news2024/11/14 6:06:15

文章目录

  • 前言
  • 一、单一职责 🍧
    • 1、单一职责原则注意事项和细节
    • 2、代码实现
      • 2、1 错误示例
      • 2、2 正确示例但有缺陷
      • 2、3 最终形态
  • 二、接口隔离原则 🥩
    • 1、代码示例
  • 三、依赖倒转原则 🥥
    • 1、代码示例
    • 2、依赖关系传递的三种方式
  • 四、里氏替换原则 🍇
    • 问题的引出：子类无意间重写了父类的方法导致业务逻辑发生错误
    • 解决方案：继承同一基类，使用组合
  • 五、开闭原则 🐷
    • 方式1
    • 方式 1 的缺点
    • 方式2 进行改进
  • 六、迪米特法则 🌍
    • 错误示例
    • 正确示例
  • 七、合成复用原则 🚑
  • 总结 ： 设计原则核心思想 🔞

前言

在这里插入图片描述
在这里插入图片描述

设计模式原则，其实就是程序员在编程时，应当遵守的原则，也是各种设计模式的基础(即:设计模式为什么这样设计的依据) 设计模式常用的七大原则有:

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

一、单一职责 🍧

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

例如我们平常用来操作数据库的实体类，每个实体类都对应着一张表，这就体现出了单一职责的各司其职。controller和service也都是一一对应各司其职，也是单一职责的表现

1、单一职责原则注意事项和细节

  1. 降低类的复杂度，一个类只负责一项职责。
  2. 提高类的可读性，可维护性
  3. 降低变更引起的风险
  4. 通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则

2、代码实现

2、1 错误示例

public class SingleResponsibility1 {
    public static void main(String[]{
        Vehicle vehicle = new Vehicle();
        vehicle.run("摩托车");
        vehicle.run("汽车");
        vehicle.run("飞机");
    }
}


// 交通工具类
// 方式 1
// 1. 在方式 1 的 run 方法中，违反了单一职责原则
// 2. 解决的方案非常的简单，根据交通工具运行方法不同，分解成不同类即可
class Vehicle {
    public void run(String vehicle) {
        System.out.println(vehicle + " 在公路上运行....");
    }
}

2、2 正确示例但有缺陷

public class SingleResponsibility2 {
    public static void main(String[] args){

        RoadVehicle roadVehicle = new RoadVehicle();
        roadVehicle.run("摩托车");
        roadVehicle.run("汽车");
        AirVehicle airVehicle = new AirVehicle();
        airVehicle.run("飞机");
   }
}


//方案 2 的分析
//1. 遵守单一职责原则
//2. 但是这样做的改动很大，即将类分解，同时修改客户端
//3. 改进：直接修改 Vehicle 类，改动的代码会比较少=>方案 3
class RoadVehicle {
    public void run(String vehicle) {
        System.out.println(vehicle + "公路运行");
    }
}


class AirVehicle {
    public void run(String vehicle) {
        System.out.println(vehicle + "天空运行");
    }
}

class WaterVehicle {
    public void run(String vehicle) {
        System.out.println(vehicle + "水中运行");
    }
}

2、3 最终形态

public class SingleResponsibility3 {
    public static void main(String[] args) {

        Vehicle2 vehicle2 = new Vehicle2();
        vehicle2.run("汽车");
        vehicle2.runWater("轮船");
        vehicle2.runAir("飞机");
    }
}


//方式 3的分析

//1. 这种修改方法没有对原来的类做大的修改，只是增加方法
//2. 这里虽然没有在类这个级别上遵守单一职责原则，但是在方法级别上，仍然是遵守单一职责
class Vehicle2 {
    public void run(String vehicle) {
       //处理
       System.out.println(vehicle + " 在公路上运行....");
    }
    public void runAir(String vehicle) {
       System.out.println(vehicle + " 在天空上运行....");
    }
    public void runWater(String vehicle) {
      System.out.println(vehicle + " 在水中行....");
    }

}

在这里插入图片描述

二、接口隔离原则 🥩

在这里插入图片描述
在这里插入图片描述

1、代码示例

package shejimoshi;

public class test1 {

    public static void main(String[] args) {
// TODO Auto-generated method stub
// 使用一把
        A a = new A();
        a.depend1(new B()); // A 类通过接口去依赖 B 类
        a.depend2(new B());
        a.depend3(new B());
        C c = new C();
        c.depend1(new D()); // C 类通过接口去依赖(使用)D 类
        c.depend4(new D());
        c.depend5(new D());


    }

}



// 接口 1
interface Interface1 {
    void operation1();
}
// 接口 2
interface Interface2 {
    void operation2();
    void operation3();
}
// 接口 3
interface Interface3 {
    void operation4();
    void operation5();
}

class B implements Interface1, Interface2 {

    @Override
    public void operation1() {
        System.out.println("B 实现了 operation1");
    }

    @Override
    public void operation2() {
        System.out.println("B 实现了 operation2");
    }

    @Override
    public void operation3() {
        System.out.println("B 实现了 operation3");
    }
}


class D implements Interface1, Interface3 {
    @Override
    public void operation1() {
        System.out.println("D 实现了 operation1");
    }

    @Override
    public void operation4() {
        System.out.println("D 实现了 operation4");
    }

    @Override
    public void operation5() {
        System.out.println("D 实现了 operation5");
    }
}




class A { // A 类通过接口 Interface1,Interface2 依赖(使用) B 类，但是只会用到 1,2,3 方法
    public void depend1(Interface1 i) {
        i.operation1();
    }
    public void depend2(Interface2 i) {
        i.operation2();
    }
    public void depend3(Interface2 i) {
        i.operation3();
    }
}
class C { // C 类通过接口 Interface1,Interface3 依赖(使用) D 类，但是只会用到 1,4,5 方法
    public void depend1(Interface1 i) {
        i.operation1();
    }
    public void depend4(Interface3 i) {
        i.operation4();
    }
    public void depend5(Interface3 i) {
        i.operation5();
    }
}


输出
B 实现了 operation1
B 实现了 operation2
B 实现了 operation3
D 实现了 operation1
D 实现了 operation4
D 实现了 operation5

三、依赖倒转原则 🥥

在这里插入图片描述

1、代码示例

正常代码，没有加入设计模式

//完成 Person 接收消息的功能
//方式 1 分析
//1. 简单，比较容易想到
//2. 如果我们获取的对象是 微信，短信等等，则新增类，同时 Perons 也要增加相应的接收方法
//3. 解决思路：引入一个抽象的接口 IReceiver, 表示接收者, 这样 Person 类与接口 IReceiver 发生依赖
// 因为 Email, WeiXin 等等属于接收的范围，他们各自实现 IReceiver 接口就 ok, 这样我们就符合依赖倒转原则

package shejimoshi;

public class test2 {
    public static void main(String[] args) {
        Person person = new Person();
        
        person.receive(new Email());
    }

}





class Email {
    public String getInfo() {
        return "电子邮件信息: hello,world";
    }
}



//完成 Person 接收消息的功能
//方式 1 分析
//1. 简单，比较容易想到
//2. 如果我们获取的对象是 微信，短信等等，则新增类，同时 Perons 也要增加相应的接收方法
//3. 解决思路：引入一个抽象的接口 IReceiver, 表示接收者, 这样 Person 类与接口 IReceiver 发生依赖
// 因为 Email, WeiXin 等等属于接收的范围，他们各自实现 IReceiver 接口就 ok, 这样我们就符合依赖倒转原则
class Person {
    public void receive(Email email ) {
        System.out.println(email.getInfo());
    }
}


输出
电子邮件信息: hello,world

加入设计模式，依赖倒转原则

package shejimoshi;

public class test2 {
    public static void main(String[] args) {
        //客户端无需改变
        Person person = new Person();

        person.receive(new Email());
        person.receive(new WeiXin());
    }

}



//定义接口
interface IReceiver {
    public String getInfo();
}

//增加微信
class WeiXin implements IReceiver {
    public String getInfo() {
        return "微信信息: hello,ok";
    }
}



class Email implements IReceiver {
    public String getInfo() {
        return "电子邮件信息: hello,world";
    }
}






class Person {
    public void receive(IReceiver iReceiver ) {
        System.out.println(iReceiver.getInfo());
    }
}

输出
电子邮件信息: hello,world
微信信息: hello,ok

2、依赖关系传递的三种方式

在这里插入图片描述

三种方式代码示例


package shejimoshi;

public class DependencyPass {

    public static void main(String[] args) {
// TODO Auto-generated method stub
        ChangHong changHong = new ChangHong();
         OpenAndClose openAndClose = new OpenAndClose();
         openAndClose.open(changHong);
        //通过构造器进行依赖传递
//         OpenAndClose openAndClose = new OpenAndClose(changHong);
//         openAndClose.open();
        //通过 setter 方法进行依赖传递
//        OpenAndClose openAndClose = new OpenAndClose();
//        openAndClose.setTv(changHong);
//        openAndClose.open();
    }
}


// 方式 1： 通过接口传递实现依赖
// 开关的接口

interface IOpenAndClose {
    public void open(ITV tv); //抽象方法,接收接口
}

interface ITV { //ITV 接口
    public void play();
}

//class ChangHong implements ITV {
//
//    @Override
//    public void play() {
//        // TODO Auto-generated method stub
//        System.out.println("长虹电视机，打开");
//    }
//
//}
// 实现接口
class OpenAndClose implements IOpenAndClose{
    public void open(ITV tv){
        tv.play();
    }
}
// 方式 2: 通过构造方法依赖传递
//interface IOpenAndClose {
//    public void open(); //抽象方法
//}
//interface ITV { //ITV 接口
//    public void play();
//}
//class OpenAndClose implements IOpenAndClose{
//    public ITV tv; //成员
//    public OpenAndClose(ITV tv){ //构造器
//        this.tv = tv;
//    }
//    public void open(){
//        this.tv.play();
//    }
//}
// 方式 3 , 通过 setter 方法传递
//interface IOpenAndClose {
//    public void open(); // 抽象方法
//    public void setTv(ITV tv);
//}
//interface ITV { // ITV 接口
//    public void play();
//}
//class OpenAndClose implements IOpenAndClose {
//    private ITV tv;
//    public void setTv(ITV tv) {
//        this.tv = tv;
//    }
//    public void open() {
//        this.tv.play();
//    }
//}
class ChangHong implements ITV {
    @Override
    public void play() {
// TODO Auto-generated method stub
        System.out.println("长虹电视机，打开");
    }
}

在这里插入图片描述

四、里氏替换原则 🍇

我们在写代码的平常，很多地方会用到继承，这大大便利了我们程序的便利，但也带来了很多弊端，父类的修改可能会造成子类的故障，子类继承父类重写父类的方法后，如果父类进行了修改，就会对继承体系造成一些不可预知的侵入性，这时我们尽量不让子类去重写父类的方法，而是将子类和父类设计为兄长类，平起平坐，把两个类公共的方法抽象成一个抽象类，两个类都去继承抽象类，这样都具有了相同的行为，而一些特有的行为也不会影响到对方。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

问题的引出：子类无意间重写了父类的方法导致业务逻辑发生错误

package shejimoshi;

public class Liskov {
    public static void main(String[] args) {
// TODO Auto-generated method stub
        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 = new B();
        //这里本意是求出 11-3, 但由于子类不经意间重写了父类的方法，从而产生了不可预知的错误
        System.out.println("11-3=" + b.func1(11, 3));
        
        System.out.println("1-8=" + b.func1(1, 8));// 1-8
        System.out.println("11+3+9=" + b.func2(11, 3));
    }
}


// A 类
class A {
    // 返回两个数的差
    public int func1(int num1, int num2) {
        return num1 - num2;
    }
}
// B 类继承了 A
// 增加了一个新功能：完成两个数相加,然后和 9 求和
class B extends A {
    //这里，重写了 A 类的方法, 可能是无意识
    public int func1(int a, int b) {
        return a + b;
    }
    public int func2(int a, int b) {
        return func1(a, b) + 9;
    }
}

在这里插入图片描述

解决方案：继承同一基类，使用组合

package shejimoshi;

public class Liskov {
    public static void main(String[] args) {
// TODO Auto-generated method stub
        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 = new B();
        System.out.println("11-3=" + b.func1(11, 3));//这里本意是求出 11-3
        System.out.println("1-8=" + b.func1(1, 8));// 1-8
        System.out.println("11+3+9=" + b.func2(11, 3));


        System.out.println("---------使用组合后");
        //使用组合仍然可以使用到 A 类相关方法
        System.out.println("11-3=" + b.func3(11, 3));// 这里本意是求出 11-
    }
}


//创建一个更加基础的基类
class Base {
    //把更加基础的方法和成员写到 Base 类
    public int func1(int num1, int num2) {
        return num1 - num2;
    }
}
// A 类
class A extends Base {
    // 返回两个数的差
    public int func1(int num1, int num2) {
        return num1 - num2;
    }
}
// B 类继承了 A
// 增加了一个新功能：完成两个数相加,然后和 9 求和
class B extends Base {
    //如果 B 需要使用 A 类的方法,使用组合关系
    private A a = new A();
    //这里，重写了 A 类的方法, 可能是无意识
    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);
    }
}

输出

11-3=8
1-8=-7
-----------------------
11-3=14
1-8=9
11+3+9=23
---------使用组合后
11-3=8

五、开闭原则 🐷

在这里插入图片描述
在这里插入图片描述

方式1

package tanchishell.SJMS.ocp;

public class Ocp {

    public static void main(String[] args) {
//使用看看存在的问题
        GraphicEditor graphicEditor = new GraphicEditor();

        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Circle());
        graphicEditor.drawShape(new Triangle());
    }
}


//这是一个用于绘图的类 [使用方]
class GraphicEditor {
    //接收 Shape 对象，然后根据 type，来绘制不同的图形
    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;
    }
}

输出
 绘制矩形 
 绘制圆形 
 绘制三角形

方式 1 的缺点

  1. 优点是比较好理解，简单易操作。
  2. 缺点是违反了设计模式的 ocp 原则，即对扩展开放(提供方)，对修改关闭(使用方)。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码.
  3. 比如我们这时要新增加一个图形种类 三角形，我们需要做如下修改，修改的地方较多

方式2 进行改进

思路：把创建 Shape 类做成抽象类，并提供一个抽象的 draw 方法，让子类去实现即可，这样我们有新的图形 种类时，只需要让新的图形类继承 Shape，并实现 draw 方法即可，使用方的代码就不需要修 -> 满足了开闭原

package tanchishell.SJMS.ocp;

public class ocp2 {

    public static void main(String[] args) {
        //使用看看存在的问题
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Circle());
        graphicEditor.drawShape(new Triangle());
        graphicEditor.drawShape(new OtherGraphic());
    }
}

//这是一个用于绘图的类 [使用方]
class GraphicEditor {
    //接收 Shape 对象，调用 draw 方法
    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() {
// TODO Auto-generated method stub
        System.out.println(" 绘制矩形 ");
    }
}
class Circle extends Shape {
    Circle() {
        super.m_type = 2;
    }
    @Override
    public void draw() {
// TODO Auto-generated method stub
        System.out.println(" 绘制圆形 ");
    }
}

//新增画三角形
class Triangle extends Shape {
    Triangle() {
        super.m_type = 3;
    }
    @Override
    public void draw() {
// TODO Auto-generated method stub
        System.out.println(" 绘制三角形 ");
    }
}
//新增一个图形
class OtherGraphic extends Shape {
    OtherGraphic() {
        super.m_type = 4;
    }
    @Override
    public void draw() {
// TODO Auto-generated method stub
        System.out.println(" 绘制其它图形 ");
    }
}

输出

 绘制矩形 
 绘制圆形 
 绘制三角形 
 绘制其它图形

六、迪米特法则 🌍

非直接关系的朋友对象，应该在该对象内部实现业务逻辑，暴露给外部一个 public 的引用，来避免对象间的耦合

在这里插入图片描述
在这里插入图片描述

错误示例

package tanchishell.SJMS.demeter;

import java.util.ArrayList;
import java.util.List;

//客户端
public class Demeter1 {

    public static void main(String[] args) {
//创建了一个 SchoolManager 对象
        SchoolManager schoolManager = new SchoolManager();
//输出学院的员工 id 和 学校总部的员工信息
        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>();
        for (int i = 0; i < 10; i++) { //这里我们增加了 10 个员工到 list
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工 id= " + i);
            list.add(emp);
        }
        return list;
    }
}

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

    //该方法完成输出学校总部和学院员工信息(id)
    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());
        }
    }
}

输出

------------学院员工------------
学院员工 id= 0
学院员工 id= 1
学院员工 id= 2
学院员工 id= 3
学院员工 id= 4
学院员工 id= 5
学院员工 id= 6
学院员工 id= 7
学院员工 id= 8
学院员工 id= 9
------------学校总部员工------------
学校总部员工 id= 0
学校总部员工 id= 1
学校总部员工 id= 2
学校总部员工 id= 3
学校总部员工 id= 4

正确示例


package tanchishell.SJMS.demeter;

import java.util.ArrayList;
import java.util.List;

//客户端
public class Demeter2 {

    public static void main(String[] args) {
//创建了一个 SchoolManager 对象
        SchoolManager schoolManager = new SchoolManager();
//输出学院的员工 id 和 学校总部的员工信息
        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>();
        for (int i = 0; i < 10; i++) { //这里我们增加了 10 个员工到 list
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工 id= " + i);
            list.add(emp);
        }
        return list;
    }


    public void printEmployee() {
//问题解决
//1. 这里的 CollegeEmployee 不是 SchoolManager 的直接朋友
//2. CollegeEmployee 是以局部变量方式出现在 SchoolManager
//3. 违反了 迪米特法则
//获取到学院员工
        List<CollegeEmployee> list1 = this.getAllEmployee();
        System.out.println("------------学院员工------------");
        for (CollegeEmployee e : list1) {
            System.out.println(e.getId());
        }

    }
}

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

    //该方法完成输出学校总部和学院员工信息(id)
    void printAllEmployee(CollegeManager sub) {
//获取到学院员工
        sub.printEmployee();
//获取到学校总部员工
        List<Employee> list2 = this.getAllEmployee();
        System.out.println("------------学校总部员工------------");
        for (Employee e : list2) {
            System.out.println(e.getId());
        }
    }
}

输出
------------学院员工------------
学院员工 id= 0
学院员工 id= 1
学院员工 id= 2
学院员工 id= 3
学院员工 id= 4
学院员工 id= 5
学院员工 id= 6
学院员工 id= 7
学院员工 id= 8
学院员工 id= 9
------------学校总部员工------------
学校总部员工 id= 0
学校总部员工 id= 1
学校总部员工 id= 2
学校总部员工 id= 3
学校总部员工 id= 4

七、合成复用原则 🚑

在这里插入图片描述

在这里插入图片描述

总结 ： 设计原则核心思想 🔞

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/439660.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【C 语言】习题 1 - 用代码将二进制转换为十进制

【C 语言】习题 1 - 用代码将二进制转换为十进制

目录 1、缘起 2、算法描述 3、代码清单 4、相关知识点 5、总结 1、缘起 我以前计算二进制转换为十进制的时候&#xff0c;喜欢用笔算&#xff0c;或者电脑在手旁的时候&#xff0c;用电脑自带的程序员计算器进行计算。今天兴起&#xff0c;突然想写一个代码用于计算…
阅读更多...
Bootstrap框架实战：轻松搭建响应式网站

Bootstrap框架实战：轻松搭建响应式网站

Bootstrap 是一款非常受欢迎的前端开发框架&#xff0c;它可以帮助我们轻松地搭建响应式网站。在这篇文章中&#xff0c;我们将介绍如何使用 Bootstrap 框架创建一个简单的响应式网站&#xff0c;并了解其核心概念和组件。 1. Bootstrap 简介 Bootstrap 是由 Twitter 公司的开…
阅读更多...
字节码插桩：从分析class文件结构开始

字节码插桩：从分析class文件结构开始

作者&#xff1a;小马快跑 Class字节码 Java 能做到 一次编译&#xff0c;到处运行&#xff0c;主要就是靠 class字节码 文件&#xff0c;也就是 java 文件经过编译之后 .java -> .class&#xff0c;然后再被 JVM 虚拟机加载。其实&#xff0c;不仅是 java 语言&#xff0c…
阅读更多...
每日做题总结——day02

每日做题总结——day02

目录 字符串处理函数&#xff0c;strcpy&#xff0c;strcat 数组指针 函数缺省值 初始化列表​编辑 友元函数 new与delete 静态成员变量 new与构造函数 delete与析构函数 拷贝构造函数的特点 常成员函数 初始化列表 编程题 字符串中找出连续最长的数字串 数组中超过…
阅读更多...
字节的面试，你能扛住几道？

字节的面试，你能扛住几道？

C &#xff0c; Python 哪一个更快&#xff1f; 读者答&#xff1a;这个我不知道从哪方面说&#xff0c;就是 C 的话&#xff0c;它其实能够提供开发者非常多的权限&#xff0c;就是说它能涉及到一些操作系统级别的一些操作&#xff0c;速度应该挺快。然后 Python 实现功能还…
阅读更多...
从数据到应用 Web3不再纸上谈兵

从数据到应用 Web3不再纸上谈兵

继宣布拨款5000万港元加速推动Web3生态圈发展后&#xff0c;香港再次明确对Web3产业创新的支持。近日&#xff0c;香港Web3协会正式成立&#xff0c;创立Web3Hub基金&#xff0c;“东方之珠”正在大力推进第三代互联网的生态建设。 不仅仅是政策红利&#xff0c;ChatGPT等人工…
阅读更多...
Web服务器配置（Tomcat）【Centos】

Web服务器配置（Tomcat）【Centos】

Tomcat 是一个轻量化服务器&#xff0c;理论上支持 20,000 个用户 LNMP&#xff1a;Linux Nginx MySQL LTMP&#xff1a;Linux Tomcat MySQL 1.Apache Tomcat 从版本7开始&#xff0c;若仅仅只需要部署HTML静态页面&#xff0c;Apache就可以完全够用 查看Apache是否安装 rpm -…
阅读更多...
Ajax的特性以及用法

Ajax的特性以及用法

一、什么是Ajax 1、jQuery的Ajax ①&#xff1a;get方法​编辑 ②&#xff1a;post方法 ③&#xff1a;Ajax&#xff08;这个重要&#xff0c;jQuery的ajax最常用&#xff09; PS&#xff1a;一定要注意&#xff0c;数据类型是 json &#xff01;&#xff01;&#xff01; …
阅读更多...
google breakpad中minidump_stackwalk的编译（Windows）

google breakpad中minidump_stackwalk的编译（Windows）

接上一篇的内容&#xff1a; breakpad编译指南&#xff08;Windows&#xff09;_我的胖是因为太膨胀的博客-CSDN博客 1、获取 googletest 放进 breakpad/src 目录下&#xff0c;并把目录名重命名为testing git clone https://github.com/google/googletest.git 如下图 2、把…
阅读更多...
ROS2安装教程（virtualbox7.0.6+ROS2）

ROS2安装教程（virtualbox7.0.6+ROS2）

整个过程分两步&#xff1a;先安装Virtualbox&#xff0c;再安装ROS2 一、安装virtualbox7.0.6 网址&#xff1a;https://www.virtualbox.org/wiki/Downloads 问题1 安装时报错&#xff1a;缺少python core 、win32api依赖&#xff08;下图网上拷贝的图&#xff0c;版本忽略…
阅读更多...
这份完整WhatsApp营销方案请收好！

这份完整WhatsApp营销方案请收好！

WhatsApp是什么&#xff1f; WhatsApp是一种跨平台的即时通讯应用程序&#xff0c;可以在手机、平板电脑和电脑上使用。它允许用户发送文字消息、语音消息、图片、视频和文件等内容&#xff0c;同时还可以进行语音通话和视频通话。 WhatsApp拥有多种功能&#xff0c;包括但不…
阅读更多...
Windows下通过CMake编译hiredis及应用

Windows下通过CMake编译hiredis及应用

1、 在下载的redis-6.2.12.tar.gz的压缩包中&#xff0c;解压后有个deps文件夹&#xff0c;里面有个hiredis文件夹&#xff0c;是我们访问redis的C接口&#xff0c;需要我们手动编译后才能使用。&#xff08;redis: https://redis.io/download/&#xff09; 2、打开CMake软件&…
阅读更多...
日本PSE认证日本的電気用品安全法METI备案

日本PSE认证日本的電気用品安全法METI备案

日本的電気用品安全法&#xff08;PSE认证&#xff09;法规要求日本的采购商在购进商品后一个月内必须向日本METI注册申报&#xff0c;并必须将采购商名称或ID标在产品上&#xff0c;以便在今后产品销售过程中进行监督管理&#xff0c;完成后将获得電気用品製造事業届出書&…
阅读更多...
全球化背景下，如何利用内容营销促进跨境电商业务增长

全球化背景下，如何利用内容营销促进跨境电商业务增长

随着全球跨境电商市场的迅速发展&#xff0c;越来越多的企业开始将注意力转向跨境电商。然而&#xff0c;随着竞争的激烈化&#xff0c;企业不再能够仅仅依靠产品本身来吸引消费者的注意。因此&#xff0c;内容营销成为了跨境电商企业在吸引、留住消费者方面的关键。在这篇文章…
阅读更多...
【Spring】— Spring AOP

【Spring】— Spring AOP

目录 一、Spring AOP简介1.什么是AOP2.AOP术语 二、AspectJ开发1.基于XML的声明式AspectJ1.1 配置切面1.2 配置切入点1.3 配置通知 2.基于注解的声明式AspectJ 一、Spring AOP简介 1.什么是AOP AOP的全称是Aspect-Oriented Programming&#xff0c;即面向切面编程&#xff08;…
阅读更多...
芴甲氧羰酰基-氨基-聚乙二醇-巯基吡啶Fmoc-NH-PEG-OPSS

芴甲氧羰酰基-氨基-聚乙二醇-巯基吡啶Fmoc-NH-PEG-OPSS

修饰性PEG芴甲氧羰基-氨基-聚乙二醇-巯基吡啶Fmoc-NH-PEG-OPSS是保护氨基的PEG衍生物之一 结构式&#xff1a; 芴甲氧羰酰基-氨基-聚乙二醇-巯基吡啶Fmoc-NH-PEG-OPSS聚乙二醇化可以提高聚乙二醇分子的稳定性&#xff0c;降低其免疫原性&#xff0c;仅用于科研实验。 FMOC-NH…
阅读更多...
骨传导风靡蓝牙耳机市场 AI赋能有望打破行业技术桎梏

骨传导风靡蓝牙耳机市场 AI赋能有望打破行业技术桎梏

一、骨传导耳机行业概述 骨传导耳机是运用骨传导技术应用制造的耳机&#xff0c;听到的大部分声音都是声波经过空气到达骨膜振动进而将声音传入内耳&#xff0c;另一种方式是声波通过骨震动可以直接传至内耳。骨传导耳机可分为骨传导扬声器技术应用耳机、骨传导麦克风技术应用…
阅读更多...
关于比较中设置极大值，常设置的0x3f3f3f3f

关于比较中设置极大值，常设置的0x3f3f3f3f

无穷大常量 int型变量的取值范围&#xff1a;[-2^31, 2^31 - 1] -> [-2147483648, 2147483647] 0x7fffffff 2147483647 (2^31 - 1) (1 << 31) - 1 0x3fffffff 1073741823 (2^30 - 1) (1 << 30) - 1 0x3f3f…
阅读更多...
产品经理必读 | 俞军产品经理十二条军规

产品经理必读 | 俞军产品经理十二条军规

最近在学习《俞军产品方法论》&#xff0c;觉得俞军总结的十二条产品经理原则非常受用&#xff0c;分享给大家。 01. 产品经理首先是产品的深度用户 自己设计的产品都没使用过的产品经理&#xff0c;如何明白用户使用的问题&#xff0c;如何解决问题&#xff0c;所以产品经理肯…
阅读更多...
java版工程项目管理系统源代码-功能清单 图文解析

java版工程项目管理系统源代码-功能清单 图文解析

Java版工程项目管理系统 Spring CloudSpring BootMybatisVueElementUI前后端分离 功能清单如下&#xff1a; 首页 工作台&#xff1a;待办工作、消息通知、预警信息&#xff0c;点击可进入相应的列表 项目进度图表&#xff1a;选择&#xff08;总体或单个&#xff09;项目显示…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023