JAVA-接口(一万四千字讲解)

目录

一、接口的概念

二、语法规则

三、接口使用 

四、接口特性

五、实现多个接口

 六、接口间的继承

七、接口使用实例 

 1.Comparable

 2.写一个自己的sort

3.Comparator

八、类的克隆Clonable

1.Clonable接口

2.浅拷贝

3.深拷贝

九、抽象类和接口的区别

十、 Object类

1.toString

2.对象比较equals方法

3.hashcode方法

一、接口的概念

在现实生活中，接口的例子比比皆是，比如：笔记本上的USB口

电脑的USB口上，可以插：U盘、鼠标、键盘...所有符合USB协议的设备

通过上述例子可以看出：接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。 在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

二、语法规则

接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。

public interface 接口名称{// 抽象方法public abstract void method1(); // public abstract 是固定搭配，可以不写public void method2();    //自动加上abstractabstract void method3();  //自动加上publicvoid method4();           //自动加上public abstract// 注意：在接口中上述写法都是抽象方法，跟推荐方式4，代码更简洁
}

只能是public abstract类型

提示:

1. 创建接口时, 接口的命名一般以大写字母 I 开头.

2. 接口的命名一般使用 "形容词" 词性的单词.

3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性

三、接口使用 

接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法。

注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。 

实现接口用：implements，继承类用：extends 

public class 类名称 implements 接口名称{// ...
}

请实现笔记本电脑使用USB鼠标、USB键盘的例子

1. USB接口：包含打开设备、关闭设备功能

2. 笔记本类：包含开机功能、关机功能、使用USB设备功能

3. 鼠标类：实现USB接口，并具备点击功能

4. 键盘类：实现USB接口，并具备输入功能

 以下代码需要多态的知识可以看我这篇文章：JAVA-多态 和 重写 (彻底给你讲明白)_多态和重写的区别-CSDN博客

interface USB {void openDevice();void closeDevice();
}//实现鼠标类
class Mouse implements USB {@Overridepublic void openDevice() {System.out.println("打开鼠标");}@Overridepublic void closeDevice() {System.out.println("关闭鼠标");}public void click(){System.out.println("鼠标点击");}}
//实现键盘类
class KeyBoard implements USB {@Overridepublic void openDevice() {System.out.println("打开键盘");}@Overridepublic void closeDevice() {System.out.println("关闭键盘");}public void inPut(){System.out.println("键盘输入");}
}class Computer {public void powerOn() {System.out.println("打开电脑");}public void powerOff() {System.out.println("关闭电脑");}public void useDevice(USB usb){usb.openDevice();if(usb instanceof Mouse) {//向下转型((Mouse) usb).click();
//            Mouse mouse = (Mouse)usb;
//            mouse.click();}else if(usb instanceof KeyBoard) {//向下转型((KeyBoard) usb).inPut();
//            KeyBoard keyBoard = (KeyBoard)usb;
//            keyBoard.inPut();}usb.closeDevice();}
}public class Test {public static void main(String[] args) {Computer computer = new Computer();computer.powerOn();//打开键盘computer.useDevice(new KeyBoard());System.out.println("====================");//打开鼠标computer.useDevice(new Mouse());computer.powerOff();}
}

 结果：

四、接口特性

1. 接口类型是一种引用类型，但是不能直接new接口的对象

public class TestUSB {public static void main(String[] args) {USB usb = new USB();}
}
// Error:(10, 19) java: day20210915.USB是抽象的; 无法实例化

2.接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错)

public interface USB {// Error:(4, 18) java: 此处不允许使用修饰符privateprivate void openDevice();void closeDevice();
}

3.接口中的方法是不能在接口中实现的，只能由实现接口的类来实现 

interface USB {void openDevice();// 编译失败：因为接口中的方式默认为抽象方法// Error:(5, 23) java: 接口抽象方法不能带有主体void closeDevice(){System.out.println("关闭USB设备");}default void test(){//可以实现方法}
}

4. 重写接口中方法时，不能使用默认的访问权限

public interface USB {void openDevice(); // 默认是public的void closeDevice(); // 默认是public的
}
public class Mouse implements USB {@Overridevoid openDevice() {System.out.println("打开鼠标");}// ...
}
// 编译报错，重写USB中openDevice方法时，不能使用默认修饰符
// 正在尝试分配更低的访问权限; 以前为public

5. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量(必须附初始值)

public interface USB {double brand = 3.0; // 默认被：public static final 修饰void openDevice();void closeDevice();
}
public class TestUSB {public static void main(String[] args) {System.out.println(USB.brand); // 可以直接通过接口名访问，说明是静态的// 编译报错：Error:(12, 12) java: 无法为最终变量brand分配值USB.brand = 2.0; // 说明brand具有final属性}
}

6. 接口中不能有静态代码块和构造方法

public interface USB {// 编译失败public USB(){}{} // 编译失败void openDevice();void closeDevice();
}

7. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

8. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类.(抽象类再被继承，子类必须实现全部抽象方法)

9. jdk8中：接口中还可以包含default方法。

五、实现多个接口

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。下面通过类来表示一组动物

class Animal {public String name;public Animal(String name) {this.name = name;}
}

另外我们再提供一组接口, 分别表示 "会飞的", "会跑的", "会游泳的"

interface ISwimming {void swim();
}
interface IFly {void fly();
}
interface IRunning {void run();
}

我们一般会单独建一个文件放接口

接下来我们创建几个具体的动物 ：(我在打印时加上动物种类，方便观看)

猫, 是会跑的.

lass Cat extends Animal implements IRunning {public Cat(String name) {super(name);}@Overridepublic void run() {System.out.println(super.name +"小猫正在跑");}
}

 青蛙, 既能跑, 又能游(两栖动物)

class Frog extends Animal implements IRunning, ISwimming {public Frog(String name) {super(name);}@Overridepublic void run() {System.out.println(super.name +"青蛙正在跑");}@Overridepublic void swim() {System.out.println(super.name +"正在游泳");}
}

注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。

 提示, IDEA 中使用 ctrl + i 快速实现接口

还有一种神奇的动物, 水陆空三栖, 叫做 "鸭子"

class Duck extends Animal implements IRunning, ISwimming, IFly {public Duck(String name) {super(name);}@Overridepublic void run() {System.out.println(super.name +"鸭子正在跑");}@Overridepublic void fly() {System.out.println(super.name +"鸭子正在飞");}@Overridepublic void swim() {System.out.println(super.name + "鸭子正在游泳");}
}

上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口.

继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性 .

这样设计有什么好处呢? 时刻牢记多态的好处, 让程序员忘记类型. 有了接口之后, 类的使用者就不必关注具体类型, 而只关注某个类是否具备某种能力.

例如, 现在实现一个方法, 叫 "散步"

public static void walk(IRunning running) {System.out.println("我带着伙伴去散步");running.run();
}

在这个 walk 方法内部, 我们并不关注到底是哪种动物, 只要参数是会跑的, 就行

    Cat cat = new Cat("小猫");walk(cat);Frog frog = new Frog("小青蛙");walk(frog);// 执行结果我带着伙伴去散步小猫正在用四条腿跑我带着伙伴去散步小青蛙正在往前跳

 六、接口间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到 多继承的目的。

接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字.

interface IRunning {void run();
}
interface ISwimming {void swim();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
class Frog implements IAmphibious {...
}

通过接口继承创建一个新的接口 IAmphibious 表示 "两栖的". 此时实现接口创建的 Frog 类, 就继续要实现 run 方 法, 也需要实现 swim 方法。

接口间的继承相当于把多个接口合并在一起

七、接口使用实例 

题目：给接口数组排序

对象数组排序是应该靠什么来排序？对象的地址？

实际是根据实际的开发场景对对象里面的成员变量来进行排序的。

列如学生类：

public class Student {public String name;public int age;public Student(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}}

那么这还不简单：

  public static void main(String[] args) {Student[] students = new Student[3];students[0] = new Student("zhangsan",25);students[1] = new Student("lisi",22);students[2] = new Student("wangwu",21);if(students[0].age > students[1].age) {System.out.println(students[0].name + ">" + students[1].name);}//……}

虽然这样可以，但是会有一些问题：

  • 在实际开发中，写main方法和类的可能不是一个程序员。这对写main方法的程序员工作加大
  • java是一个开发效率高的语言，这样开发效率太低

 1.Comparable

那么就给大家介绍一个接口

class Student implements Comparable<Student>{public String name;public int age;public Student(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic int compareTo(Student o) {return this.age - o.age;}
}

代码解释：

  • 尖括号里面的是泛型知识，后面来写
  • 实现此接口需要重写compareTo方法，里面用于你控制判断类大小的条件

    public static void main(String[] args) {Student[] students = new Student[3];students[0] = new Student("zhangsan",25);students[1] = new Student("lisi",22);students[2] = new Student("wangwu",21);//        Arrays.sort会调用你Student里面的compareTo来判断大小Arrays.sort(students);System.out.println(Arrays.toString(students));}

结果：

 我们也可以用名字来排序：

class Student implements Comparable<Student>{public String name;public int age;public Student(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic int compareTo(Student o) {
//        谁调用，this.name就是谁return this.name.compareTo(o.name);
//        提醒，name.出来的compareTo是Sting类里面重写了的方法
//        和这里的comparaTo不同，它底层是对每一个字符挨个比较，
//        直到不同}//    @Override
//    public int compareTo(Student o) {
//        return this.age - o.age;
//    }
}

结果：

 2.写一个自己的sort

我们用冒泡排序来实现：

 //用接口做为参数可以让，实现了这个接口的所有类，都可以使用此方法public static void MySort(Comparable[] comparable) {for (int i = 0; i < comparable.length; i++) {for (int j = 0; j < comparable.length - 1 - i; j++) {if(comparable[j].compareTo(comparable[j+1]) > 0) {Comparable tmp = comparable[j];comparable[j] = comparable[j+1];comparable[j+1] = tmp;}}}}

这里的compareTo调用的是自己Student类里面的，以他的返回值来做判断。

我们就用名字来排序，看是否一样：

public static void main(String[] args) {Student[] students = new Student[3];students[0] = new Student("zhangsan",25);students[1] = new Student("lisi",22);students[2] = new Student("wangwu",21);MySort(students);System.out.println(Arrays.toString(students));}

 可以看到确实是可以排序。

但其实我们发现，一旦写好不易更改。如果对名字和年龄都会用到就不好办了。很不灵活

所以我再给大家介绍一个接口，可以很好的解决这个问题

3.Comparator

Student类不变:

class Student implements Comparable<Student>{public String name;public int age;public Student(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic int compareTo(Student o) {return this.age - o.age;}
}

我们单独定义一个文件：

package demo3;import java.util.Comparator;public class AgeComparator implements Comparator<Student> {@Overridepublic int compare(Student o1, Student o2) {return o1.age - o2.age;}
}

在这里实现Comparator方法，这个接口需要重写compare方法，一样是决定着判断类大小的方法。

我们再写一个关于年龄的比较方法，依然需要重新开一个文件：

package demo3;import java.util.Comparator;public class AgeComparator implements Comparator<Student> {@Overridepublic int compare(Student o1, Student o2) {return o1.age - o2.age;}
}

写好了我们就可以在main方法中操作了

 public static void main(String[] args) {Student student1 = new Student("zhangsan",10);Student student2 = new Student("lisi",15);//年龄比较器AgeComparator ageComparator = new AgeComparator();int ret1 = ageComparator.compare(student1,student2);System.out.println(ret1);//名字比较强NameComparator nameComparator = new NameComparator();int ret2 = nameComparator.compare(student1,student2);System.out.println(ret2);}

结果：

八、类的克隆Clonable

1.Clonable接口

Java 中内置了一些很有用的接口, Clonable 就是其中之一.

Object是所有类的父类，Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 "拷贝". 但是要想合法调用 clone 方法, 必须要 先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常.

class Student implements Cloneable{public int age;public Student(int age) {this.age = age;}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}@Overridepublic String toString() {return "Student{" +"age=" + age +'}';}
}public class Test {public static void main(String[] args) throws CloneNotSupportedException{Student student1 = new Student(12);Student student2 = (Student) student1.clone();System.out.println(student2.age);}
}

 那么实现克隆必须要有这几条件：

  1. 必须在类中实现Cloneable接口这个接口里并没有什么东西，只是做为标记接口或者称为空接口。只要实现了这个克隆接口证明当前类才能被克隆 
  2. 必须重新clone方法
  3. 父类给到子类必须向下转型
  4. 异常

2.浅拷贝

将类改一下：

class Name {public String name = "张三";
}class Student implements Cloneable{public int age;public Name n = new Name();public Student(int age) {this.age = age;}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}}
public static void main(String[] args) throws CloneNotSupportedException{Student student1 = new Student(20);Student student2 = (Student) student1.clone();System.out.println(student1.n.name);System.out.println(student2.n.name);System.out.println("========");student1.n.name = "李四";System.out.println(student1.n.name);System.out.println(student2.n.name);}

结果：

什么是浅拷贝，里面引用类型指向的地址不变。就是浅拷贝

深拷贝，就是引用类型指向的地址的空间也拷贝一份出来，重新划分空间并指向他

内存图解： 

所以一定要注意这一点

3.深拷贝

class Name implements Cloneable{//写好拷贝条件public String name = "张三";@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}class Student implements Cloneable{public int age;public Name n = new Name();public Student(int age) {this.age = age;}@Overrideprotected Object clone() throws CloneNotSupportedException {Student tmp = (Student) super.clone();//放到临时变量中tmp.n = (Name) this.n.clone();//将里面的对象也拷贝一份return tmp;}}
public static void main(String[] args) throws CloneNotSupportedException{Student student1 = new Student(20);Student student2 = (Student) student1.clone();System.out.println(student1.n.name);System.out.println(student2.n.name);System.out.println("========");student1.n.name = "李四";System.out.println(student1.n.name);System.out.println(student2.n.name);}

结果：

这样就是深拷贝了

内存图解：

九、抽象类和接口的区别

抽象类和接口都是 Java 中多态的常见使用方式. 都需要重点掌握. 同时又要认清两者的区别(重要!!! 常见面试题)

核心区别: 抽象类中可以包含抽象方法、普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中 不能包含普通方法, 子类必须重写所有的抽象方法 。接口只能是抽象的方法，或者default、static修饰的方法。

再次提醒:

抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类. 万一不小心创建了 Animal 的实例, 编译器会及时提醒我们. 

十、 Object类

Object是Java默认提供的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认会继承Object父 类。即所有类的对象都可以使用Object的引用进行接收。

范例：使用Object接收所有类的对象

class Person{}
class Student{}
public class Test {public static void main(String[] args) {function(new Person());function(new Student());}public static void function(Object obj) {System.out.println(obj);}
}
//执行结果：
Person@1b6d3586
Student@4554617c

所以在开发之中，Object类是参数的最高统一类型。但是Object类也存在有定义好的一些方法。如下：

对于整个Object类中的方法需要实现全部掌握。

本小节当中，我们主要来熟悉这几个方法：toString()方法，equals()方法，hashcode()方法 

1.toString

这个比较简单这个就不多说了

2.对象比较equals方法

在Java中，==进行比较时：

a.如果==左右两侧是基本类型变量，比较的是变量中值是否相同

b.如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同

c.如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的： 

// Object类中的equals方法
public boolean equals(Object obj) {return (this == obj); // 使用引用中的地址直接来进行比较
}

那么我们想要比较对象中的内容就要自己写：

class Student {public String name;public int age;public Student(String name, int age) {this.name = name;this.age = age;}@Overridepublic boolean equals(Object o) {Student student = (Student) o;if(this.name.equals(student.name)) {return true;}return false;}}
public class Test {public static void main(String[] args) {Student student1 = new Student("zhangsan",10);Student student2 = new Student("zhangsan",12);System.out.println(student1.equals(student2));}
}

结果：

public class Test {public static void main(String[] args) {Student student1 = new Student("zhangsan",10);Student student2 = new Student("lisi",12);System.out.println(student1.equals(student2));}
}

结果：

写详细点的还有

class Student{...@Overridepublic boolean equals(Object obj) {if (obj == null) {//地址为空肯定不相等return false ;}if(this == obj) {//地址都一样一定相等return true ;}// 不是Student类对象if (!(obj instanceof Student)) {//是同一类型 = !true也就是false，不进入ifreturn false ;}Person person = (Person) obj ; // 向下转型，比较属性值return this.name.equals(person.name) && this.age==person.age ;}
}

结论：比较对象中内容是否相同的时候，一定要重写equals方法。

3.hashcode方法

回忆刚刚的toString方法的源码：

public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

我们看到了hashCode()这个方法，他帮我算了一个具体的对象位置，这里面涉及数据结构，但是我们还没学数据结 构，没法讲述，所以我们只能说它是个内存地址。然后调Integer.toHexString()方法，将这个地址以16进制输出。

hashcode方法源码：

public native int hashCode();

该方法是一个native方法，底层是由C/C++代码写的。我们看不到。 

    public static void main(String[] args) {Student student1 = new Student("zhangsan",10);Student student2 = new Student("lisi",12);System.out.println(student1.hashCode());System.out.println(student2.hashCode());}

结果： 

注意事项：两个对象的hash值不一样。

从业户逻辑上来说，我们认为两个名字相同，年龄相同的对象，将存储在同一个位置，需要重写hashcode()方法，我们可以来看示例 代码：

class Person {public String name;public int age;public Person(String name, int age) {this.name = name;this.age = age;}@Overridepublic int hashCode() {return Objects.hash(name, age);}
}
public class TestDemo4 {public static void main(String[] args) {Person per1 = new Person("gaobo", 20) ;Person per2 = new Person("gaobo", 20) ;System.out.println(per1.hashCode());System.out.println(per2.hashCode());}
}
//执行结果
460141958
460141958

注意事项：哈希值一样。

结论：

1、hashcode方法用来确定对象在内存中存储的位置是否相同

2、事实上hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的 散列码，进而确定该对象在散列表中的位置

 我们一般可以通过idea自带的工具实现hashcode和equals步骤：

生成：

    @Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return age == student.age && Objects.equals(name, student.name);}@Overridepublic int hashCode() {return Objects.hash(name, age);}

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

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

相关文章

芯片时钟树评估的关键性能参数

芯片时钟树评估的关键性能参数

前面有很多文章都介绍了PI性能的影响&#xff0c;也介绍了PSIJ对信号或时钟性能的影响&#xff0c;对于SOC设计&#xff0c;为了更好的理解电源完整性在芯片设计中的重要作用&#xff0c;对芯片的时钟树设计需要足够理解才能更好的明白电源完整性的影响。 时钟分布网络设计一直…
阅读更多...
最基本的SELECT...FROM结构

最基本的SELECT...FROM结构

第0种&#xff1a;最基本的查询语句 SELECT 字段名&#xff0c;字段名 FROM 表名 SELECT 1&#xff1b; SELECT 11,3*2&#xff1b; FROM SELECT 11,3*2 FROM DUAL&#xff1b;#dual&#xff1a;伪表 我们可以用它来保持一个平衡 这里我们的值不需要在任何一个表里&#xf…
阅读更多...
9、类和对象

9、类和对象

9.1 封装 9.1.1 封装的例子 class Student { public:string name;int age; public:void setName(string name_) {name name_;} }; int main() {Student s1;s1.setName("zhangsan");return 0; }类中的行为都叫做成员&#xff0c;例如成员属性&#xff0c;成员变量&…
阅读更多...
飞速（FS）S5800-48T4S：如何使用MLAG？

飞速（FS）S5800-48T4S：如何使用MLAG？

MLAG&#xff08;多机箱链路聚合组&#xff09;可实现无缝故障转移并优化带宽利用率&#xff0c;从而增强网络冗余和提高可扩展性。它允许多台交换机作为一个统一实体运行&#xff0c;从而降低停机风险并确保网络运行不中断。飞速&#xff08;FS&#xff09;S5800-48T4S是一款支…
阅读更多...
二维高斯函数的两种形式

二维高斯函数的两种形式

第一种形式很常见 多元正态分布 多元正态分布&#xff08;Multivariate Normal Distribution&#xff09;&#xff0c;也称为多变量正态分布或多维正态分布&#xff0c;是统计学中一种重要的概率分布&#xff0c;用于描述多个随机变量的联合分布。 假设有 n n n 个随机变量…
阅读更多...
【LabVIEW学习篇 - 18】：人机界面交互设计02

【LabVIEW学习篇 - 18】：人机界面交互设计02

文章目录 错误处理函数简单错误处理器通用错误处理器清楚错误合并错误错误代码至错误簇转换查找第一个错误 鼠标指针 错误处理函数 在LabVIEW中&#xff0c;是通过错误输入簇和错误输出簇来传递错误信息&#xff0c;可以将底层错误信息传递到上层VI。设计人员需要对不同程度的…
阅读更多...
2024 数学建模高教社杯 国赛（C题）| 农作物的种植策略 | 建模秘籍文章代码思路大全

2024 数学建模高教社杯 国赛（C题）| 农作物的种植策略 | 建模秘籍文章代码思路大全

铛铛&#xff01;小秘籍来咯&#xff01; 小秘籍团队独辟蹊径&#xff0c;运用等多目标规划等强大工具&#xff0c;构建了这一题的详细解答哦&#xff01; 为大家量身打造创新解决方案。小秘籍团队&#xff0c;始终引领着建模问题求解的风潮。 抓紧小秘籍&#xff0c;我们出发…
阅读更多...
高并发内存池（一）：项目介绍与定长内存池的实现

高并发内存池（一）：项目介绍与定长内存池的实现

目录​​​​​​​ 项目介绍 池化技术 内存池 内存碎片 malloc工作原理 定长内存池 申请内存 释放内存 定位new VirtualAlloc函数 封装VirtualAlloc 定长内存池的最终代码 项目介绍 项目原型&#xff1a;goole的开源项目tcmalloc&#xff08;Thread-Caching Mal…
阅读更多...
CIOE中国光博会＆电巢科技即将联办“智能消费电子创新发展论坛”

CIOE中国光博会＆电巢科技即将联办“智能消费电子创新发展论坛”

在科技浪潮汹涌澎湃的当下&#xff0c;从通信领域的高速光传输&#xff0c;到消费电子中的高清显示与先进成像技术&#xff0c;光电技术的应用范围不断拓展且日益深化。而AIGC 凭借其丰富的内容供给与个性化反馈能力&#xff0c;正为新一代消费电子及智能穿戴产品开辟崭新的发展…
阅读更多...
前端请求的路径baseURL怎么来的 ？nodejs解决cors问题的一种方法

前端请求的路径baseURL怎么来的 ？nodejs解决cors问题的一种方法

背景&#xff1a;后端使用node.js搭建&#xff0c;用的是express 前端请求的路径baseURL怎么来的 &#xff1f; 前后端都在同一台电脑上运行&#xff0c;后端的域名就是localhost&#xff0c;如果使用的是http协议&#xff0c;后端监听的端口号为3000&#xff0c;那么前端请求…
阅读更多...
S3C2440开发板：时钟，PWM定时器控制蜂鸣器发声

S3C2440开发板：时钟，PWM定时器控制蜂鸣器发声

时钟 时钟和电源管理模块由三部分组成&#xff1a;时钟控制&#xff0c;USB 控制和电源控制。 S3C2440A 中的时钟控制逻辑可以产生必须的时钟信号&#xff0c;包括 CPU 的 FCLK&#xff0c;AHB 总线外设的 HCLK 以及 APB 总线外设的 PCLK。S3C2440A 包含两个锁相环&#xff08…
阅读更多...
VBA进行excel坐标转换

VBA进行excel坐标转换

在Excel里利用坐标绘图时&#xff0c;可以比较容易想到采用数据透视表&#xff0c;但是数据透视表生成的图不可更改&#xff0c;因此本案例采用VBA进行坐标变换而不改变原始值来转换图像&#xff0c;即实现图像的左右翻转和上下翻转&#xff0c;如下图所示&#xff0c;选择map的…
阅读更多...
fastadmin 文件上传腾讯云

fastadmin 文件上传腾讯云

1-安装腾讯云SDK composer require qcloud/cos-sdk-v5 2-腾讯云配置 <?phpnamespace app\common\controller;use Qcloud\Cos\Client; use think\Controller; use think\Db;class Tencent extends Controller {/*** 上传文件* param $config* param $key* return array*/p…
阅读更多...
Linux下快速判断当前终端使用的是bash or csh

Linux下快速判断当前终端使用的是bash or csh

在Linux下设置环境变量的时候&#xff0c;可能你也遇到过export: Command not found一类的错误。这是因为当前终端使用的不是bash&#xff0c;如何快速判断当前终端使用的是哪种类型的shell呢&#xff1f; echo $0判断shell类型 最简单的方法就是在终端输入echo $0&#xff0…
阅读更多...
每日一题，零基础入门FPGA——工程师在线精讲来咯

每日一题，零基础入门FPGA——工程师在线精讲来咯

传送门&#xff1a;zzfpga.com/StudentPlatform/Train/StudentArticleDetails?id149
阅读更多...
M3U8工作原理以及key解密视频流详解

M3U8工作原理以及key解密视频流详解

文章目录 前言一、M3U8是什么&#xff1f;二、HLS—M3U8的工作原理1.分段视频流2.生成播放列表3.客户端请求和解析4.片段下载和播放 三、.m3u8文件内部是什么样的&#xff1f;四、简单介绍下AES-128算法五、拿到KEY后如何去解密&#xff1f;1.手动解密.ts文件2.前人栽树&#x…
阅读更多...
spring security 如何解决跨域的

spring security 如何解决跨域的

一、什么是 CORS CORS(Cross-Origin Resource Sharing) 是由 W3C制定的一种跨域资源共享技术标准&#xff0c;其目就是为了解决前端的跨域请求。在JavaEE 开发中&#xff0c;最常见的前端跨域请求解决方案是早期的JSONP&#xff0c;但是JSONP 只支持 GET 请求&#xff0c;这是一…
阅读更多...
深度学习从入门到精通——基于unet++算法实现细胞分割

深度学习从入门到精通——基于unet++算法实现细胞分割

模型定义 import torch from torch import nn__all__ [UNet, NestedUNet]class VGGBlock(nn.Module):def __init__(self, in_channels, middle_channels, out_channels):super().__init__()self.relu nn.ReLU(inplaceTrue)self.conv1 nn.Conv2d(in_channels, middle_channe…
阅读更多...
FPGA速度优化

FPGA速度优化

速度优化 文章目录 速度优化前言一、时序优化1.1 减少关键路径上的时序1.1.1 关键路径重组1.1.2 解决扇出问题1.1.3 路径上插入寄存器1.1.4 寄存器平衡1.1.5 并行结构1.1.6 消除代码优先级 总结 前言 速度优化&#xff0c;主要就是设计时序进行优化 吞吐量&#xff1a;每个时…
阅读更多...
web渗透：RCE漏洞

web渗透：RCE漏洞

RCE漏洞&#xff0c;即远程代码执行漏洞&#xff0c;是一种安全缺陷&#xff0c;它允许攻击者通过网络在目标系统上执行任意代码。一旦成功利用&#xff0c;攻击者可以完全控制受影响的系统&#xff0c;包括读取敏感数据、安装恶意软件、修改系统配置等。RCE漏洞通常发生在应用…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023