设计模式——七大原则详解

目录

  • 设计模式
  • 单一职责原则
    • 应用实例
    • 注意事项和细节
  • 接口隔离原则
    • 应用实例
  • 依赖倒转（倒置）原则
    • 基本介绍
    • 实例代码
    • 依赖关系传递的三种方式
    • 注意事项和细节
  • 里氏替换原则
    • 基本介绍
    • 实例代码
  • 开闭原则
    • 基本介绍
    • 实例代码
  • 迪米特法则
    • 基本介绍
    • 实例代码
    • 注意事项和细节
  • 合成复用原则
    • 基本介绍
  • 设计原则的核心思想

设计模式

设计模式原则：其实就是程序员在编程时，应当遵守的原则，也是各种设计模式的基础（设计模式为什么这么设计的依据）

编写软件的过程中，程序员面临着来自 耦合性 内聚性以及可维护性，可扩展性，重用性 灵活性，等多方面的挑战 设计模式是为了让软件具有更好的

  • 代码重用性（相同功能的代码，不用多次编写）
  • 可读性（编程规范性，便于其他程序员阅读和理解）
  • 可扩展性（需要增加新的功能时，非常的方便）
  • 可靠性（新增功能后，对原来的功能没有影响）
  • 使程序呈现 高内聚 低耦合的特性

单一职责原则

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

应用实例

以交通工具为例

未遵循单一职责原则

package 单一职责原则;/*** 创建一个交通工具类测试** @author Han* @data 2023/10/18* @apiNode*/
public class VehicleTest {public static void main(String[] args) {Vehicle vehicle = new Vehicle();vehicle.run("摩托车");vehicle.run("三轮车");// 运行结果 "飞机在地上运行……" 违反常理// 违反单一职责原则vehicle.run("飞机");}
}
// 交通工具类
class Vehicle{public void run(String vehicle) {System.out.println(vehicle+"在地上运行……");}
}

遵循单一职责原则（这里对类发生了较大的修改，继续优化）

package 单一职责原则;/*** 创建一个交通工具类测试2* 将每个类型的交通工具职责分离* @author Han* @data 2023/10/18* @apiNode*/
public class VehicleTest2 {public static void main(String[] args) {// 陆地类型的交通工具RoadVehicle roadvehicle = new RoadVehicle();roadvehicle.run("摩托车");roadvehicle.run("三轮车");// 天空类型的交通工具AirVehicle airvehicle = new AirVehicle();airvehicle.run("飞机");}
}
// 交通工具类(公路)
class RoadVehicle{public void run(String vehicle) {System.out.println(vehicle+"在地上运行……");}
}
// 交通工具类(天上)
class AirVehicle{public void run(String vehicle) {System.out.println(vehicle+"在地上运行……");}
}

第三种优化方式

/*** 创建一个交通工具类测试** @author Han* @data 2023/10/18* @apiNode*/
public class VehicleTest3 {public static void main(String[] args) {Vehicle3 vehicle = new Vehicle3();vehicle.runRode("三轮车");vehicle.runAir("飞机");}
}// 交通工具类
// 这种修改方法没有对原来的类做较大的修改，知识增加方法
// 这里虽然没有在类上遵循单一职责原则，但是在方法上，仍然是遵守单一职责原则的
class Vehicle3{public void runRode(String vehicle) {System.out.println(vehicle+"在地上运行……");}public void runAir(String vehicle) {System.out.println(vehicle+"在天上运行……");}
}

注意事项和细节

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

接口隔离原则

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

应用实例

image-20231019213421561

  • 类A通过接口interface1依赖B ,类C通过接口interface1依赖D，如果接口interface1对于A和C类来说不是最小接口，那么类B和类D必须去实现他们不需要的方法

这种依赖关系的代码为：

package 接口隔离原则;/*** @author Han* @data 2023/10/19* @apiNode*/
public interface TestCode {public static void main(String[] args) {// A通过接口依赖B 但只用到了1 2 3 方法A a = new A();B b = new B();a.useMethod1(b);a.useMethod2(b);a.useMethod3(b);// C通过接口依赖D 但只用到了1 4 5 方法C c = new C();D d = new D();c.useMethod1(d);c.useMethod2(d);c.useMethod3(d);}
}interface Interface1 {void method1();void method2();void method3();void method4();void method5();
}// A通过接口依赖B 但只用到了1 2 3 方法
// 而实现的4 5 方法就白写了
class B implements Interface1 {@Overridepublic void method1() {System.out.println("B类实现了method1");}@Overridepublic void method2() {System.out.println("B类实现了method2");}@Overridepublic void method3() {System.out.println("B类实现了method3");}@Overridepublic void method4() {System.out.println("B类实现了method4");}@Overridepublic void method5() {System.out.println("B类实现了method5");}
}// C通过接口依赖D 但只用到了1 4 5 方法
// 2 3 方法就白写了
class D implements Interface1 {@Overridepublic void method1() {System.out.println("D类实现了method1");}@Overridepublic void method2() {System.out.println("D类实现了method2");}@Overridepublic void method3() {System.out.println("D类实现了method3");}@Overridepublic void method4() {System.out.println("D类实现了method4");}@Overridepublic void method5() {System.out.println("D类实现了method5");}
}// A类通过接口使用B类
// 使用时,因为B实现了接口，可以根据多态性质传入B类对象，即可使用B类中实现的方法
class A {public void useMethod1(Interface1 interface1) {interface1.method1();}public void useMethod2(Interface1 interface1) {interface1.method2();}public void useMethod3(Interface1 interface1) {interface1.method3();}public void useMethod4(Interface1 interface1) {interface1.method4();}public void useMethod5(Interface1 interface1) {interface1.method5();}
}// C类通过接口使用D类
// 使用时,因为D实现了接口，可以根据多态性质传入D类对象，即可使用D类中实现的方法
class C {public void useMethod1(Interface1 interface1) {interface1.method1();}public void useMethod2(Interface1 interface1) {interface1.method2();}public void useMethod3(Interface1 interface1) {interface1.method3();}public void useMethod4(Interface1 interface1) {interface1.method4();}public void useMethod5(Interface1 interface1) {interface1.method5();}
}

这种方式会导致B类和C类都会有从不会使用的方法存在，没有遵循接口隔离原则

优化

image-20231019221118011

  • 将接口interface1拆分为独立的几个接口，类A和类C分别与他们需要的接口简历依赖关系。也就是采用接口隔离原则
  • 接口interface1中出现的方法根据实际情况去拆分为3个接口

遵循接口隔离原则

package 接口隔离原则;/*** @author Han* @data 2023/10/19* @apiNode*/
public interface TestCode2 {public static void main(String[] args) {// A通过接口依赖B 但只用到了1 2 3 方法A a = new A();B b = new B();a.useMethod1(b);a.useMethod2(b);a.useMethod3(b);// C通过接口依赖D 但只用到了1 4 5 方法C c = new C();D d = new D();c.useMethod1(d);c.useMethod4(d);c.useMethod5(d);}
}
// 拆解接口
// 一个类依赖1 2 3 方法，一个类依赖1 4 5 方法   
/*** 1接口定义 1 方法* 2接口定义 2 3 方法* 3接口定义4 5 方法*/interface Interface2 {void method1();
}interface Interface3 {void method2();void method3();
}interface Interface4 {void method4();void method5();
}// A通过接口依赖B 但只用到了1 2 3 方法
// 就去实现2 3 接口
class B2 implements Interface2, Interface3 {@Overridepublic void method1() {System.out.println("B类实现了method1");}@Overridepublic void method2() {System.out.println("B类实现了method2");}@Overridepublic void method3() {System.out.println("B类实现了method3");}
}// C通过接口依赖D 但只用到了1 4 5 方法
// 就去实现2 4 接口
class D2 implements Interface2, Interface4 {@Overridepublic void method1() {System.out.println("D类实现了method1");}@Overridepublic void method4() {System.out.println("D类实现了method4");}@Overridepublic void method5() {System.out.println("D类实现了method5");}
}// A类通过接口使用B类
// 使用时,因为B实现了接口，可以根据多态性质传入B类对象，即可使用B类中实现的方法
// 实现1 2 3 方法
class A2 {public void useMethod1(Interface2 interface1) {interface1.method1();}public void useMethod2(Interface3 interface1) {interface1.method2();}public void useMethod3(Interface3 interface1) {interface1.method3();}}// C类通过接口使用D类
// 使用时,因为D实现了接口，可以根据多态性质传入D类对象，即可使用D类中实现的方法
class C2 {public void useMethod1(Interface2 interface2) {interface2.method1();}public void useMethod4(Interface4 interface4) {interface4.method4();}public void useMethod5(Interface4 interface4) {interface4.method5();}
}

依赖倒转（倒置）原则

基本介绍

  • 高层模块不应该依赖底层模块，二者都应该依赖其抽象
  • 抽象不应该依赖细节，细节应该依赖抽象
  • 依赖倒转（倒置）的中心思想是面向接口编程
  • 依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多，以抽象为基础搭建的框架比以细节为基础的架构要稳定的多，在Java中，抽象指的是接口和抽象类，细节就是具体的实现类
  • 使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现的细节的任务交给他们的实现类去完成

实例代码

package 依赖倒转原则;/*** 依赖倒转原则 理解代码* 传统方式** @author Han* @data 2023/10/20* @apiNode*/// 定义一个接口 规范方法
interface IReceiver {String getInfo();
}/*** 这样做的问题在哪里呢？*      如果用户Person要的是微信消息，或者qq消息呢 不要email*      还需在Person增加响应的方法*/
public class testCode2 {public static void main(String[] args) {Person2 person = new Person2();person.reverse(new Email1());person.reverse(new QQ());}
}// 实现类实现接口中的方法
class Email1 implements IReceiver {@Overridepublic String getInfo() {return "电子邮件发送的信息";}
}class QQ implements IReceiver {@Overridepublic String getInfo() {return "QQ邮件发送的信息";}
}// 在调用类中传入接口的“对象”
// 运行时会因为多态而运行对应实现类的方法
// 这样Person只需要在类中实现一个方法
class Person2 {// 可以传入实现了Ireserve接口的实现类对象public void reverse(IReceiver rieserve) {System.out.println(rieserve.getInfo());}}

优化后

package 依赖倒转原则;/*** 依赖倒转原则 理解代码* 传统方式** @author Han* @data 2023/10/20* @apiNode*/// 定义一个接口 规范方法
interface IReceiver {String getInfo();
}/*** 这样做的问题在哪里呢？*      如果用户Person要的是微信消息，或者qq消息呢 不要email*      还需在Person增加响应的方法*/
public class testCode2 {public static void main(String[] args) {Person2 person = new Person2();person.reverse(new Email1());person.reverse(new QQ());}
}// 实现类实现接口中的方法
class Email1 implements IReceiver {@Overridepublic String getInfo() {return "电子邮件发送的信息";}
}class QQ implements IReceiver {@Overridepublic String getInfo() {return "QQ邮件发送的信息";}
}// 在调用类中传入接口的“对象”
// 运行时会因为多态而运行对应实现类的方法
// 这样Person只需要在类中实现一个方法
class Person2 {// 可以传入实现了Ireserve接口的实现类对象public void reverse(IReceiver rieserve) {System.out.println(rieserve.getInfo());}}

依赖关系传递的三种方式

接口传递

image-20231020202450610

构造方法传递

image-20231020202829972

setter传递

image-20231020202953809

注意事项和细节

  • 底层模块尽量都要有抽象类和接口，或者两者都有，程序稳定性更好
  • 变量的声明类型尽量是抽象类或接口，这样我们的变量引用和实际对象之间，就存在一个缓冲层，利于程序扩展和优化
  • 继承时遵循里式替换原则

里氏替换原则

基本介绍

  • 如果对每个类型为T1的对象o1,都有类型为T2的对象o2，使得以T1定义的所有程序p在所有的对象o1都代换为o2时，程序p的行为没有发生变化，那么类型T2是类型T1的子类型，换句话说，所有引用基类的地方必须能透明地使用其子类的对象
  • 在使用继承时，遵循里式替换原则，在子类中尽量不要重写父类的方法
  • 里式替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖 来解决问题

实例代码

为遵循里式替 换原则

package 里氏替换原则;/*** 案例，因为错误的重写父类方法导致程序出现错误** @author Han* @data 2023/10/20* @apiNode*/
public class testCode1 {public static void main(String[] args) {A a = new A();System.out.println("3 - 2 = " + a.func1(3, 2));// 下面出现错误，因为子类不小心错误的重写了父类的方法A b = new B();System.out.println("3 - 2 = " + b.func1(3, 2));B b1 = new B();System.out.println("3 - 2 = " + b1.func2(3, 2));}
}
class A {// 返回两个数的差public double func1(int i, int j) {return i - j;}
}class B extends A {// 重写错误@Overridepublic double func1(int i, int j) {return i + j;}public double func2(int a, int b) {return func1(a, b) + 9;}
}

优化后

避免重写父类方法，采用组合的方式优化

package 里氏替换原则;/*** 案例，因为错误的重写父类方法导致程序出现错误** @author Han* @data 2023/10/20* @apiNode*/
public class testCode2 {public static void main(String[] args) {A2 a = new A2();System.out.println("3 - 2 = " + a.func1(3, 2));B2 b1 = new B2();System.out.println("3 + 2 + 9 = " + b1.func2(3, 2));System.out.println("3 - 2 = " + b1.func3(3, 2));}
}class Base {// 这里放更基础的方法
}class A2 extends Base {// 返回两个数的差public double func1(int i, int j) {return i - j;}
}class B2 extends Base {// 组合A2A2 a2 =  new A2();public double func3(int i, int j) {return i - j;}// 没有重写父类的方法，与A类也没有耦合public double func2(int a, int b) {// 采用组合的方式替换return this.a2.func1(a, b) + 9;}
}

开闭原则

基本介绍

  • 开闭原则是编程中最基础，最重要的设计原则
  • 一个软件实体如类，模块和函数应该对扩展开放（对提供方），对修改关闭（对使用方）。用抽象构建框架，用实现扩展细节
  • 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化
  • 编程中遵循其他原则，以及使用设计模式的目的就是遵循开闭原则

实例代码

现在有一个绘画功能的程序，只能绘画圆形

package 开闭原则;
/*** @author Han* @data 2023/10/21* @apiNode*/
public class testCode {public static void main(String[] args) {Hua hua = new Hua();hua.hua(new Circle());}
}
class Shape {int m_type;
}
// 使用方
class Hua {public void hua(Shape shape) {if (shape.m_type == 1) {System.out.println("圆形");}}
}
// 提供方 
class Circle extends Shape {public Circle() {super.m_type = 1;}
}

我要给这个类增加一个绘画三角形的方法

  • 方式一
package 开闭原则;
/*** @author Han* @data 2023/10/21* @apiNode*/
public class testCode {public static void main(String[] args) {Hua hua = new Hua();hua.hua(new Circle());hua.hua(new Triangle());}
}
class Shape {int m_type;
}
// 使用方
class Hua {public void hua(Shape shape) {if (shape.m_type == 1) {System.out.println("圆形");}else if (shape.m_type == 2) {System.out.println("三角形");}}
}
// 提供方
class Circle extends Shape {public Circle() {super.m_type = 1;}
}
class Triangle extends Shape {public Triangle() {super.m_type = 2;}
}

方式1的优缺点：

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

改进方式1

  • 方式二

在抽象父类shape中创建一个 draw方法 ，让子类去实现即可，这样我们有新的图形种类时，只需要让新的图形类去继承这个Shape抽象类，并实现draw方法即可，使用方的代码就不需要修改

package 开闭原则;/*** @author Han* @data 2023/10/21* @apiNode*/
public class testCode2 {public static void main(String[] args) {Hua2 hua2 = new Hua2();hua2.hua(new Circle2());hua2.hua(new Triangle2());}
}abstract class Shape2 {public abstract void hua();
}
// 使用方
class Hua2 {// 再增加图形时，只需要让图形对应的类继承shape2这个抽象类就好了public void hua(Shape2 shape2) {shape2.hua();}
}
// 提供方
// 继承了抽象类
class Circle2 extends Shape2 {@Overridepublic void hua() {System.out.println("圆形");}
}
class Triangle2 extends Shape2 {@Overridepublic void hua() {System.out.println("三角形");}
}

迪米特法则

基本介绍

  • 一个类应该对其他对象保持最少的了解
  • 类与类关系越密切，耦合度越大
  • 迪米特法则又叫最少知道法则，即一个类对自己依赖的类知道的越少越好，也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供public方法，不对外泄露任何信息
  • 迪米特法则还有个更简单的定义：只与直接的朋友通信
  • **直接的朋友：**每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系，耦合的方式很多，依赖，关联，组合，聚合等， 其中，我们称出现在成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变
    量中得类不是直接的朋友，也就是说，陌生的类最好不要以局部变量的形式出现 在类的内部

实例代码

这种方式违反了迪米特法则，在几局部变量中出现了陌生类

package 迪米特法则;import java.util.ArrayList;
import java.util.List;public class Demeter1 {public static void main(String[] args) {// TODO Auto-generated method stubSchoolManager schoolManager = new SchoolManager();schoolManager.printAllEmployee(new CollegeManager());}
}class CollegeManager {public List<CollegeEmployee> getAllEmployee() {List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();for (int i = 0; i < 10; i++) {CollegeEmployee emp = new CollegeEmployee();emp.setId("学院员工id= " + i);list.add(emp);}return list;}
}// 学校管理类
class SchoolManager {// Employee是类的直接朋友public List<Employee> getAllEmployee() {List<Employee> list = new ArrayList<>();for (int i = 0; i < 5; i++) {Employee emp = new Employee();emp.setId("学校总部员工id= " + i);list.add(emp);}return list;}// CollegeManager是类的直接朋友void printAllEmployee(CollegeManager sub) {// CollegeEmployee不是类的直接朋友，是一个陌生类// 这里违反了迪米特法则，陌生类最好不要以局部变量的方式出现在类的内部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());}}
}class Employee {private String id;public String getId() {return id;}public void setId(String id) {this.id = id;}
}class CollegeEmployee {private String id;public String getId() {return id;}public void setId(String id) {this.id = id;}
}

改进，遵循迪米特法则

package 迪米特法则;import java.util.ArrayList;
import java.util.List;public class Demeter2 {public static void main(String[] args) {// TODO Auto-generated method stubSchoolManager2 schoolManager = new SchoolManager2();schoolManager.printAllEmployee(new CollegeManager2());}
}class CollegeManager2 {// 封装学院员工信息public List<CollegeEmployee> getAllEmployee() {List<CollegeEmployee> list = new ArrayList<>();for (int i = 0; i < 10; i++) {CollegeEmployee emp = new CollegeEmployee();emp.setId("学院员工id= " + i);list.add(emp);}return list;}// 输出学院员工信息public void printCollegeInfo() {List<CollegeEmployee> list1 = this.getAllEmployee();for (CollegeEmployee e : list1) {System.out.println(e.getId());}}
}// 学校管理类
class SchoolManager2 {// Employee是类的直接朋友public List<Employee> getAllEmployee() {List<Employee> list = new ArrayList<>();for (int i = 0; i < 5; i++) {Employee emp = new Employee();emp.setId("学校总部员工id= " + i);list.add(emp);}return list;}// CollegeManager是类的直接朋友void printAllEmployee(CollegeManager2 sub2) {// 你是怎么输出的不要告诉我，我只要结果（遵循迪米特法则）System.out.println("------------分学院员工------------");sub2.printCollegeInfo();List<Employee> list2 = this.getAllEmployee();System.out.println("------------学校总部员工------------");for (Employee e : list2) {System.out.println(e.getId());}}
}// bean类
class Employee2 {private String id;public String getId() {return id;}public void setId(String id) {this.id = id;}
}class CollegeEmployee2 {private String id;public String getId() {return id;}public void setId(String id) {this.id = id;}
}

注意事项和细节

  • 迪米特法则的核心是降低类之间的耦合
  • **但是注意：**由于每个类都减少了不必要的依赖，因此迪米特法则只是要求降低类间（对象间）的耦合关系，并不是要求完全没有依赖关系

合成复用原则

基本介绍

原则是尽量使用合成，聚合的方式，而不是使用继承

  • 继承方式，依赖性太强

image-20231022145650865

使用方式优化依赖关系

  • 将A对象当做方法参数 依赖

image-20231022145725863

  • 在B中引入A类型变量，聚合

image-20231022145731808

  • 在B中创建A的对象，组合

image-20231022145736048

设计原则的核心思想

  • 找出应用中可能需要变化之处，把他们独立出来，不要和那些不需要变化的代码混在一起
  • 针对接口编程，而不是针对实现编程。
  • 为了交互对象之间的松耦合设计而努力

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

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

相关文章

golang笔记17--编译调试go源码

golang笔记17--编译调试go源码

golang笔记17--编译调试go源码 前置条件编译源码在 fmt 包中加自定义函数说明 当前go语言越来越流行了&#xff0c;各大厂商都有加大go工程师的需求&#xff0c;作为go语言的学习者&#xff0c;我们除了要了解如何使用go语言外&#xff0c;也有必要了解一下如何编译、调试go源码…
阅读更多...
解决XXLJOB重复执行问题--Redis加锁+注解+AOP

解决XXLJOB重复执行问题--Redis加锁+注解+AOP

基于Redis加锁注解AOP解决JOB重复执行问题 现象解决方案自定义注解定义AOP策略redis 加锁实践 现象 线上xxljob有时候会遇到同一个任务在调度的时候重复执行&#xff0c;如下图&#xff1a; 线上JOB服务运行了2个实例&#xff0c;有时候会重复调度到同一个实例&#xff0c;有…
阅读更多...
交换机端口灯常亮 端口up状态 服务器设置ip交换机获取不到服务器网卡mac地址 不能通信

交换机端口灯常亮 端口up状态 服务器设置ip交换机获取不到服务器网卡mac地址 不能通信

环境： 深信服防火墙 8.0.75 AF-2000-FH2130B-SC S6520X-24ST-SI交换机 version 7.1.070, Release 6530P02 问题描述： 交换机一个vlan下有3台服务器，连接端口2、3、4，2和3连接的服务器正常，交换机3端口灯常亮 端口up状态 服务器自动获取不了地址，改为手动设置ip后，交…
阅读更多...
Xubuntu16.04系统中安装create_ap创建无线AP

Xubuntu16.04系统中安装create_ap创建无线AP

1.背景说明 在Xubuntu16.04系统的设备上安装无线WIFI模块后&#xff0c;想通过设备自身的无线AP&#xff0c;进行和外部设备的连接&#xff0c;需要安装create_ap软件&#xff0c;并设置无线AP的名称和密码&#xff0c;并设置为开机自启动。 create_ap是一个用于在Linux系统上创…
阅读更多...
开源贡献难吗？

开源贡献难吗？

本文整理自字节跳动 Flink SQL 技术负责人李本超在 CommunityOverCode Asia 2023 上的 Keynote 演讲&#xff0c;李本超根据自己在开源社区的贡献经历&#xff0c;基于他在贡献开源社区过程中的一些小故事和思考&#xff0c;如何克服困难&#xff0c;在开源社区取得突破&#x…
阅读更多...
BetaFlight飞控AOCODAF435V2MPU6500固件编译

BetaFlight飞控AOCODAF435V2MPU6500固件编译

BetaFlight飞控AOCODAF435V2MPU6500固件编译 1. 源由2. 准备2.1 板子2.2 代码2.3 工具 3. 配置修改4. 编译4.1 获取代码4.2 获取配置4.3 编译固件4.4 DFU烧录4.5 版本核对 5. 总结 1. 源由 刚拿到一块Aocoda F405V2 (MPU6500) AT32F435飞控板(替换主控芯片)。 Aocoda-RC F40…
阅读更多...
金融机器学习方法：K-均值算法

金融机器学习方法：K-均值算法

目录 1.算法介绍 2.算法原理 3.python实现示例 1.算法介绍 K均值聚类算法是机器学习和数据分析中常用的无监督学习方法之一&#xff0c;主要用于数据的分类。它的目标是将数据划分为几个独特的、互不重叠的子集或“集群”&#xff0c;以使得同一集群内的数据点彼此相似&…
阅读更多...
tomcat 服务器

tomcat 服务器

tomcat 服务器 tomcat: 是一个开源的web应用服务器。区别nginx&#xff0c;nginx主要处理静态页面&#xff0c;那么动态请求&#xff08;连接数据库&#xff0c;动态页面&#xff09;并不是nginx的长处&#xff0c;动态的请求会交给tomcat进行处理。 nginx-----转发动态请求-…
阅读更多...
【5G PHY】5G SS/PBCH块介绍（一）

【5G PHY】5G SS/PBCH块介绍（一）

博主未授权任何人或组织机构转载博主任何原创文章&#xff0c;感谢各位对原创的支持&#xff01; 博主链接 本人就职于国际知名终端厂商&#xff0c;负责modem芯片研发。 在5G早期负责终端数据业务层、核心网相关的开发工作&#xff0c;目前牵头6G算力网络技术标准研究。 博客…
阅读更多...
使用crul库和R语言的下载器程序

使用crul库和R语言的下载器程序

以下是一个使用crul库和R语言的下载器程序&#xff0c;用于从下载音频。此程序使用了jshk.com.cn/get_proxy的代码。 // 导入必要的库 import ("fmt""github.com/cjlapa/crul""io""net/http""net/url""os" )// 主…
阅读更多...
在 Python 中使用 Pillow 进行图像处理【3/4】

在 Python 中使用 Pillow 进行图像处理【3/4】

第三部分 一、腐蚀和膨胀 您可以查看名为 的图像文件dot_and_hole.jpg&#xff0c;您可以从本教程链接的存储库中下载该文件&#xff1a; 该二值图像的左侧显示黑色背景上的白点&#xff0c;而右侧显示纯白色部分中的黑洞。 侵蚀是从图像边界去除白色像素的过程。您可以通过使用…
阅读更多...
运算符重载的三种实现方法

运算符重载的三种实现方法

一、重载为一般函数 格式&#xff1a;返回类型 operator 运算符(参数列表) struct Complex{//定义一个复数结构&#xff1a;包括实部与虚部两部分 double real;//实部 double imag;//虚部 }; Complex operator(Complex c1,Complex c2){//对加法运算的重载&#xff1a;将运算符…
阅读更多...
vue重修之路由【上】

vue重修之路由【上】

文章目录 单页应用程序: SPA - Single Page Application路由简介Vue Reouter简介VueRouter的使用&#xff08;52&#xff09;组件的存放目录问题组件分类存放目录 路由的封装抽离 单页应用程序: SPA - Single Page Application 单页面应用(SPA): 所有功能在 一个html页面 上 单…
阅读更多...
python调用astra进行人脸检测（使用CascadeClassifier）

python调用astra进行人脸检测（使用CascadeClassifier）

1、简述 方法&#xff1a;使用opecv中&#xff0c;CascadeClassifier 级联分类器实现人脸检测&#xff0c;CascadeClassifier就是opencv下objdetect模块中用来做目标检测的级联分类器的一个类&#xff0c;它可以帮助我们检测例如车牌、眼睛、人脸等物体。它的大概原理就是判别…
阅读更多...
JS类的继承和实现原理详解

JS类的继承和实现原理详解

一&#xff1a;前言 各位小伙伴在日常开发中&#xff0c;相信一定遇到过Class这种写法。这代表在JS中创建了一个类&#xff0c;并且可以通过这个类去 new 出一个新的对象。其实在JS中&#xff0c;这个类和java中的类是没有区别的&#xff0c;同样具有属性&#xff0c;方法&…
阅读更多...
前端多媒体处理工具——ffmpeg的使用

前端多媒体处理工具——ffmpeg的使用

写在前面 在前端领域&#xff0c;FFmpeg 是一个非常有用的工具&#xff0c;它提供了多种媒体格式的封装和解封装&#xff0c;包括多种音视频编码、多种协议的流媒体、多种色彩格式转换、多种采样率转换、多种码率切换等。可以在多种操作系统安装使用。 安装 下载FFmpeg 在网…
阅读更多...
深入探讨 Golang 中的追加操作

深入探讨 Golang 中的追加操作

通过实际示例探索 Golang 中的追加操作 简介 在 Golang 编程领域&#xff0c;append 操作是一种多才多艺的工具&#xff0c;使开发人员能够动态扩展切片、数组、文件和字符串。在这篇正式的博客文章中&#xff0c;我们将踏上一段旅程&#xff0c;深入探讨在 Golang 中进行追加…
阅读更多...
【VSCode】解决Open in browser无效

【VSCode】解决Open in browser无效

问题描述&#xff1a; 在VSCode中无论是点击右键&#xff0c;选择在默认浏览器中打开&#xff0c;还是按快捷键alt b都没有反应。 解决办法&#xff1a; 右击文件 --> 在文件资源管理器中显示 右击文件&#xff0c;选择属性 点击更改 选择用默认浏览器打开 最后 此时…
阅读更多...
音乐制作软件 Studio One 6 mac中文版软件特点

音乐制作软件 Studio One 6 mac中文版软件特点

Studio One mac是一款专业的音乐制作软件&#xff0c;该软件提供了全面的音频编辑和混音功能&#xff0c;包括录制、编曲、合成、采样等多种工具&#xff0c;可用于制作各种类型的音乐&#xff0c;如流行音乐、电子音乐、摇滚乐等。 Studio One mac软件特点 1. 直观易用的界面&…
阅读更多...
Defender Antivirus占用资源怎么禁止

Defender Antivirus占用资源怎么禁止

前言 有时Defender Antivirus 突然磁盘IO很高。导致机器卡得很&#xff0c;开发代码很不方便&#xff0c;本文就介绍如何禁用这个服务。 操作 下载Defender Control https://www.sordum.org/9480/defender-control-v2-1/ 这是当前的最新版本。下载不了就用云盘地址 &#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023