Java封装最佳实践：打造高内聚、低耦合的优雅代码~

​

                                                                                个人主页：秋风起，再归来~

                                                                                文章专栏：javaSE的修炼之路                                

                                                                        个人格言：悟已往之不谏，知来者犹可追

                                                                                        克心守己，律己则安！

1、封装

1.1 封装的概念

面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说 就是套壳屏蔽细节。

比如：对于电脑这样一个复杂的设备，提供给用户的就只是：开关机、通过键盘输入，显示器，USB插孔等，让用 户来和计算机进行交互，完成日常事务。但实际上：电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户 只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳 子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互

1.2 访问限定符

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认 知，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符：

比如：

public：可以理解为一个人的外貌特征，谁都可以看得到

default: 对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了

private：只有自己知道，其他人都不知道

【说明】

protected主要是用在继承中，继承部分详细介绍

default权限指：什么都不写时的默认权限

访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

注意：一般情况下成员变量设置为private，成员方法设置为public。

1.3 封装扩展之包

1.3.1 包的概念

在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件 包。有点类似于目录。比如：为了更好的管理电脑中的歌曲，一种好的方式就是将相同属性的歌曲放在相同文件 下，也可以对某个文件夹下的音乐进行更详细的分类。

在Java中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一 个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在 不同的包中即可。

1.3.2 导入包中的类

Java 中已经提供了很多现成的类供我们使用. 例如Date类：可以使用 java.util.Date 导入 java.util 这个包中的 Date 类.

public class Test {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
   }

但是这种写法比较麻烦一些, 可以使用 import语句导入包.

import java.util.Date;
public class Test {
    public static void main(String[] args) {
        Date date = new Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
   }
}

 如果需要使用 java.util 中的其他类, 可以使用 import java.util.*

import java.util.*;
public class Test {
    public static void main(String[] args) {
        Date date = new Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
   }
}

 但是建议显式的指定要导入的类名. 否则还是容易出现冲突的情况.

import java.util.*;
import java.sql.*;
public class Test {
    public static void main(String[] args) {
        // util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
        Date date = new Date();
        System.out.println(date.getTime());
   }
}
 
// 编译出错
Error:(5, 9) java: 对Date的引用不明确
  java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配

在这种情况下需要使用完整的类名

import java.util.*;
import java.sql.*;
public class Test {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        System.out.println(date.getTime());
   }
}

可以使用import static导入包中静态的方法和字段。

import static java.lang.Math.*;
public class Test {
 public static void main(String[] args) {
 double x = 30;
 double y = 40;
        
 // 静态导入的方式写起来更方便一些.
 // double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
 double result = sqrt(pow(x, 2) + pow(y, 2));
 System.out.println(result);
 }
}

 注意事项: import 和 C++ 的 #include 差别很大. C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要. import 只是为了写代码的时候更方便. import 更类似于 C++ 的 namespace 和 using

1.3.3 自定义包

基本规则

在文件的最上方加上一个 package 语句指定该代码在哪个包中.

包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 ).

包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储 代码.

如果一个类没有 package 语句, 则该类被放到一个默认包中.

操作步骤

1. 在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包

2. 在弹出的对话框中输入包名, 例如 Test.demo

3. 在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可.

4. 此时可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了

5. 同时我们也看到了, 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句

1.3.4 包的访问权限控制举例

1.3.5 常见的包

1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。

2. java.lang.reflect:java 反射编程包;

3. java.net:进行网络编程开发包。

4. java.sql:进行数据库开发的支持包。

5. java.util:是java提供的工具程序包。(集合类等) 非常重要

6. java.io:I/O编程开发包。

2. static成员

2.1 学生类举例

学生类实例化三个对象s1、s2、s3，每个对象都有自己特有的名字、性别，年龄，学分绩点等成 员信息，这些信息就是对不同学生来进行描述的，如下所示：

public class Student{
    // ...
    public static void main(String[] args) {
        Student s1 = new Student("Li leilei", "男", 18, 3.8);
        Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
        Student s3 = new Student("Jim", "男", 18, 2.6);
   }
}

 假设三个同学是同一个班的，那么他们上课肯定是在同一个教室，那既然在同一个教室，那能否给类中再加一个成 员变量，来保存同学上课时的教室呢？答案是不行的。

 之前在Student类中定义的成员变量，每个对象中都会包含一份(称之为实例变量)，因为需要使用这些信息来描述 具体的学生。而现在要表示学生上课的教室，这个教室的属性并不需要每个学生对象中都存储一份，而是需要让所 有的学生来共享。在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对 象，是所有对象所共享的。

2.2 static修饰成员变量

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共 享的。

【静态成员变量特性】

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问

3. 类变量存储在方法区当中

4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

public class Student{
    public String name;
    public String gender;
    public int  age;
    public double score;
    public static String classRoom = "306";
    
    // ...
    
    public static void main(String[] args) {
        // 静态成员变量可以直接通过类名访问
        System.out.println(Student.classRoom);
 
        Student s1 = new Student("Li leilei", "男", 18, 3.8);
        Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
        Student s3 = new Student("Jim", "男", 18, 2.6);
 
        // 也可以通过对象访问：但是classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom)
    }
}

以调试方式运行上述代码，然后在监视窗口中可以看到，静态成员变量并没有存储到某个具体的对象中。

2.3 static修饰成员方法

一般类中的数据成员都设置为private，而成员方法设置为public，那设置之后，Student类中classRoom属性如何 在类外访问呢？

class Student{
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom = "306";
    public Student(String name, String gender, int age, double score) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.score = score;
    }
}
public class TestStudent {

    public static void main(String[] args) {
        System.out.println(Student.classRoom);
    }
}

那static属性应该如何访问呢？

Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过 静态方法来访问的。

class Student{
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom = "306";

    public static String getClassRoom(){
        return classRoom;
    }
    public Student(String name, String gender, int age, double score) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.score = score;
    }
}
public class TestStudent {

    public static void main(String[] args) {
        System.out.println(Student.getClassRoom());
    }
}

【静态方法特性】

1. 不属于某个具体的对象，是类方法

2. 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者

3. 不能在静态方法中访问任何非静态成员变量  

public static String getClassRoom(){
    System.out.println(this);
    return classRoom;
}
 
// 编译失败：Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 this
 
public static String getClassRoom(){
    age += 1;
    return classRoom;
}
 
// 编译失败：Error:(35, 9) java: 无法从静态上下文中引用非静态 变量 age

4. 静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用  

public static String getClassRoom(){
    doClass();
    return classRoom;
}
 
// 编译报错：Error:(35, 9) java: 无法从静态上下文中引用非静态 方法 doClass()

5. 静态方法无法重写，不能用来实现多态(此处暂时细讲，后序多态位置详细讲解)。  

2.4 static成员变量初始化

注意：静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性

静态成员变量的初始化分为两种：就地初始化 和 静态代码块初始化。

1. 就地初始化 就地初始化指的是：在定义时直接给出初始值

public class Student{
    private String name;
    private String gender;
    private int  age;
    private double score;
    private static String classRoom = "Bit306";  
    
    // ...

2. 静态代码块初始化 那什么是代码块呢？继续往后看 :) ~~~  

3. 代码块

3.1 代码块的概念以及分类

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：

1、普通代码块

2、构造块

3、静态块

4、同步代码块（这里不细讲）

3.2 普通代码块

public class Main{
 public static void main(String[] args) {
 { //直接使用{}定义，普通方法块
 int x = 10 ;
 System.out.println("x1 = " +x);
 }
 int x = 100 ;
 System.out.println("x2 = " +x);
 }
}
 
// 执行结果
x1 = 10
x2 = 100

这种用法较少见  

3.3 构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

public class Person {
    //实例成员变量
    public String name;
    public String sex;
    public int age;
    //示例代码块
    {
        this.name="zhangsan";
        this.sex="男";
        this.age=18;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }
    public static void main(String[] args) {
        Person p1=new Person();
        System.out.println(p1.toString());
    }
}

3.4 静态代码块

使 用 s t a tic 定 义 的 代 码 块 称 为 静 态 代 码 块 。

一 般 用 于 初 始 化 静 态 成 员 变 量 。

public class Person {
    //实例成员变量
    static String name;
    static String sex;
    static int age;

    //示例代码块
    static{
        name="zhangsan";
        sex="男";
        age=18;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }
    public static void main(String[] args) {
        Person p1=new Person();
        System.out.println(p1.toString());
    }
}

注意事项：

1. 静态代码块不管生成多少个对象，其只会执行一次

2. 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的

3. 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)

4. 实例代码块只有在创建对象时才会执行

4. 内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服 务，那么这个内部的完整结构最好使用内部类。在 Java 中，可以将一个类定义在另一个类或者一个方法的内部， 前者称为内部类，后者称为外部类。内部类也是封装的一种体现。

public class OutClass {
    class InnerClass{
 
   }
}
 
// OutClass是外部类
// InnerClass是内部类

【注意事项】

1. 定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类  

public class A{
    
}
 
class B{
    
}
 
// A 和 B是两个独立的类，彼此之前没有关系

2. 内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件  

内部类的分类：

先来看下，内部类都可以在一个类的那些位置进行定义

根据内部类定义的位置不同，一般可以分为以下几种形式：

1. 成员内部类(普通内部类：未被static修饰的成员内部类 和 静态内部类：被static修饰的成员内部类)

2. 局部内部类(不谈修饰符)、匿名内部类  

注意：内部类其实日常开发中使用并不是非常多，大家在看一些库中的代码时候可能会遇到的比较多，日常开始中 使用最多的是匿名内部类。

public class OutClass {
    // 成员位置定义：未被static修饰 --->实例内部类
    public class InnerClass1{
   }
 
    // 成员位置定义：被static修饰 ---> 静态内部类
    static class InnerClass2{
 
   }
 
 
    public void method(){
        // 方法中也可以定义内部类 ---> 局部内部类：几乎不用
        class InnerClass5{
 
       }
   }
}

4.1 实例内部类 

即未被static修饰的成员内部类。

1. 外部类中的任何成员都可以在实例内部类方法中直接访问

public class OutClass {
    public int data1=1;
    private int data2=2;
    int data3=3;
    public static int data4=4;
    public void outMethodA(){
        System.out.println("data1:"+data1);
    }
    public static void outMethodB(){
        System.out.println("data4:"+data4);
    }
    //定义一个实例内部类
    class innerClass{
    //在实例内部类当中：可以访问任意访问修饰限定符的成员
    //在实例内部类当中创建一个方法
       public void innerMethod(){
           // 在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
           data1=10;
           data2=20;
           data3=30;
           data4=40;
           outMethodA();
           outMethodB();
           System.out.println("data1:"+data1);
           System.out.println("data2:"+data2);
           System.out.println("data3:"+data3);
           System.out.println("data4:"+data4);
       }
    }
    public static void main(String[] args) {
        //OutClass.innerClass inner=new OutClass().new innerClass();
        OutClass out=new OutClass();
        OutClass.innerClass inner=out.new innerClass();
        inner.innerMethod();
    }
}

2. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束

3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名 称.this.同名成员 来访问

public class OutClass {
    public int data1=1;
    private int data2=2;
    int data3=3;
    public static int data4=4;
    public void outMethodA(){
        System.out.println("data1:"+data1);
    }
    public static void outMethodB(){
        System.out.println("data4:"+data4);
    }
    //定义一个实例内部类
    class innerClass{
    //在实例内部类当中：可以访问任意访问修饰限定符的成员
    //在实例内部类当中创建一个方法
       public void innerMethod(){
           // 在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
           data1=10;
           data2=20;
           data3=30;
           data4=40;
           outMethodA();
           outMethodB();
           System.out.println("data1:"+data1);
           System.out.println("data2:"+data2);
           System.out.println("data3:"+data3);
           System.out.println("data4:"+data4);
           // 如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的
           int data1=1;
           System.out.println("内部：data1:"+data1);
           // 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
           System.out.println("外部：data1:"+OutClass.this.data1);
       }
    }
    public static void main(String[] args) {
        //OutClass.innerClass inner=new OutClass().new innerClass();
        OutClass out=new OutClass();
        OutClass.innerClass inner=out.new innerClass();
        inner.innerMethod();
    }
}

4. 实例内部类对象必须在先有外部类对象前提下才能创建

 public static void main(String[] args) {
        // 要访问实例内部类中成员，必须要创建实例内部类的对象
        // 而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类
        // 创建实例内部类对象
        //OutClass.innerClass inner=new OutClass().new innerClass();
        // 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例内部类对象
        OutClass out=new OutClass();
        OutClass.innerClass inner=out.new innerClass();
        inner.innerMethod();
    }

5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用

6. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

4.2 静态内部类

被static修饰的内部成员类称为静态内部类。

1. 在静态内部类中只能访问外部类中的静态成员（字段和方法）

如果确实想访问，我们该如何做？

我们可以在静态方法内部新建一个外部类的对象就可以访问了~

2. 创建静态内部类对象时，不需要先创建外部类对象

public static void main(String[] args) {
        // 静态内部类对象创建(不需要先创建外部类的对象)
        OutClass.innerClass2 inner=new OutClass.innerClass2();
        //静态内部类的成员访问
        innerClass2.innerMethod();
    }

4.3 局部内部类

定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用，一般使用的非常少，此处简单了解下语法 格式。

public class OutClass {
    int a = 10;
    public void method(){
        int b = 10;
 
        // 局部内部类：定义在方法体内部
        // 不能被public、static等访问限定符修饰
        class InnerClass{
            public void methodInnerClass(){
                System.out.println(a);
                System.out.println(b);
           }
       }
 
        // 只能在该方法体内部使用，其他位置都不能用
        InnerClass innerClass = new InnerClass();
        innerClass.methodInnerClass();
   }
 
    public static void main(String[] args) {
        // OutClass.InnerClass innerClass = null; 编译失败
   }
}

【注意事项】

1. 局部内部类只能在所定义的方法体内部使用

2. 不能被public、static等修饰符修饰

3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class

4. 几乎不会使用  

4.4 匿名内部类

5、对象的打印

public class Person {
    String name;
    String gender;
    int age;
 
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
}
 
    public static void main(String[] args) {
        Person person = new Person("Jim","男", 18);
        System.out.println(person);
   }
}
 
// 打印结果：day20210829.Person@1b6d3586

我们可以简单的认为打印了一个类似与地址的东西（实际上是该类所创建对象的哈希值） 

如果想要默认打印对象中的属性该如何处理呢？答案：重写toString方法即可。 

public class Person {
    String name;
    String gender;
    int age;
 
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
   }
 
    @Override
    public String toString() {
        return "[" + name + "," + gender + "," + age + "]";
   }
 
    public static void main(String[] args) {
        Person person = new Person("Jim","男", 18);
        System.out.println(person);
   }
}
 
// 输出结果：[Jim,男,18]

 当然在IDEA中也有快速重写toString方法的方式~

（1）右击鼠标点击生成

（2）弹出此窗口点击toString()

(3)点击确定即可

（4）看一下效果~

 6、 完结散花

好了，这期的分享到这里就结束了~

如果这篇博客对你有帮助的话，可以用你们的小手指点一个免费的赞并收藏起来哟~

如果期待博主下期内容的话，可以点点关注，避免找不到我了呢~

我们下期不见不散~~

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

python练习二

python练习二

# Demo85def pai_xu(ls_test):#创建一个列表排序函数命名为pai_xu# 对创建的函数进行注释"""这是一个关于列表正序/倒序排列的函数:param ls_test: 需要排序的列表:return:"""ls1 [int(ls_test[i]) for i in range(len(ls_test))]#对input输入的…
阅读更多...
surfer绘制等值线图

surfer绘制等值线图

surfer介绍 Surfer软件，是美国Golden Software公司编制的一款以画三维图的软件。该软件具有强大的插值功能和绘制图件能力，可用来处理XYZ数据，是地质工作者常用的专业成图软件（来源于百度百科）。 surfer可以用来绘制…
阅读更多...
计算机网络—TCP协议详解：特性、应用（1）

计算机网络—TCP协议详解：特性、应用（1）

🎬慕斯主页：修仙—别有洞天 ♈️今日夜电波：マリンブルーの庭園—ずっと真夜中でいいのに。 0:34━━━━━━️💟──────── 3:34 🔄 ◀️…
阅读更多...
Java中常见的锁策略

Java中常见的锁策略

目录 乐观锁 vs 悲观锁 悲观锁: 乐观锁： 重量级锁 vs 轻量级锁 ⾃旋锁（Spin Lock） 公平锁 vs 非公平锁 可重⼊锁 vs 不可重入锁 读写锁 乐观锁 vs 悲观锁 悲观锁: 总是假设最坏的情况，每次去拿数据的时候都认为别…
阅读更多...
3d整体模型怎么拆图---模大狮模型网

3d整体模型怎么拆图---模大狮模型网

3D整体模型怎么拆图 一、模型准备 在进行3D整体模型的拆图之前，首先需要确保模型的构造清晰明了，各个部件之间的连接关系明确，并且模型的层级结构已经建立完成。 二、确定拆图方式 拆解方向：根据模型的结构和设计需求&#xff…
阅读更多...
教你用Fiddler捕获HTTPS请求

教你用Fiddler捕获HTTPS请求

安装Fiddler 这里不特别说明了，网上搜索一大把，根据安装引导一步步安装即可。（这里采用的是fiddler v4.6） 配置Fiddler 1、打开fiddler配置Tools –>Telerik Fiddler Options。 2、打开HTTPS配置项，勾选“Captur…
阅读更多...
Leetcode-2580-统计将重叠区间合并成组的方案数-c++

Leetcode-2580-统计将重叠区间合并成组的方案数-c++

题目详见https://leetcode.cn/problems/count-ways-to-group-overlapping-ranges/ 题目要求将最后的ranges分为两个组。也就是说当你的ranges已经满足题目要求的时候，这两个组怎么分是随意的，这里也就引出了 2 k 2^k 2k 的由来，其实就是每组…
阅读更多...
Leetcode-2810-故障键盘-c++

Leetcode-2810-故障键盘-c++

题目详见https://leetcode.cn/problems/faulty-keyboard/ 题解 这道题的关键是如何合理地使用STL，毕竟是一道简单题。 之前常用到的Vector容器是单向开口的连续内存空间 deque则是一种双向开口的连续线性空间，又称双端动态数组。所谓的双向开口&#x…
阅读更多...
Windows Server 2022 使用ApacheDS用户远程桌面登录服务器

Windows Server 2022 使用ApacheDS用户远程桌面登录服务器

Windows Server 2022 使用ApacheDS用户远程桌面登录服务器 1、接上篇 Windows Server 2022 使用ApacheDS用户认证 使用Administrator用户远程登录192.168.1.100windows server，打开pGina软件 2、输入刚刚在ApacheDS中的新添加的用户测试一下，会自动添加…
阅读更多...
200个有趣的HTML前端游戏项目合集（持续更新中）

200个有趣的HTML前端游戏项目合集（持续更新中）

💂 个人网站:【 摸鱼游戏】【神级代码资源网站】【工具大全】🤟 一站式轻松构建小程序、Web网站、移动应用：👉注册地址🤟 基于Web端打造的：👉轻量化工具创作平台💅 想寻找共同学习交…
阅读更多...
[实时流基础 flink] 窗口

[实时流基础 flink] 窗口

在批处理统计中，我们可以等待一批数据都到齐后，统一处理。但是在实时处理统计中，我们是来一条就得处理一条，那么我们怎么统计最近一段时间内的数据呢？引入“窗口”。 文章目录 6.1 窗口的概念6.2 窗口的分类**1&#x…
阅读更多...
让接口自动化测试更简单

让接口自动化测试更简单

HTTP 接口测试很简单，不管工具、框架、还是平台，只要很的好的几个点就是好工具。 测试数据问题：比如删除接口，重复执行还能保持结果一致，必定要做数据初始化。接口依赖问题：B 接口依赖 A 的返回值&#xf…
阅读更多...
新model开发记录

新model开发记录

模型使用 -- 用blender导出为 fbx ，修改渲染方式（点击模型->Materials->Extract Materials(将材质从fbx中 单独提取出来了)->Materials 选择 Shader -> SimpleURPToonLitExample 点开脸的材质，勾选第一条） 解决角色…
阅读更多...
【C++的奇迹之旅（二）】C++关键字命名空间使用的三种方式C++输入输出命名空间std的使用惯例

【C++的奇迹之旅（二）】C++关键字命名空间使用的三种方式C++输入输出命名空间std的使用惯例

文章目录 📝前言🌠 C关键字(C98)🌉 命名空间🌠命名空间定义🌉命名空间使用 🌠命名空间的使用有三种方式：🌉加命名空间名称及作用域限定符🌠使用using将命名空间中某个成员…
阅读更多...
MATLAB绘制堆叠填充图--巧用句柄

MATLAB绘制堆叠填充图--巧用句柄

MATLAB绘制堆叠填充图–巧用句柄 目录 MATLAB绘制堆叠填充图--巧用句柄1. 主要原理讲解1.1 主要函数1.2 句柄原理 2. 绘图示例2.1 准备数据2.2 绘制堆叠填充图-使用句柄控制图形属性2.3 设置填充颜色和样式2.4 添加标题和标签2.5 绘图效果 3. 结语 堆叠填充图是一种常见的数据可…
阅读更多...
StringBuffer与StringBuilder

StringBuffer与StringBuilder

1.区别 (1). String : 不可变字符序列. (2). StringBuffer : 可变字符序列.线程安全，但效率低. (3). StringBuilder : 可变字符序列.线程不安全，但效率高. 既然StringBuffer与StringBuilder都是可变字符序列，但二者咋区分开呢&#xff1f…
阅读更多...
Dimitra：基于区块链、AI 等前沿技术重塑传统农业

Dimitra：基于区块链、AI 等前沿技术重塑传统农业

根据 2023 年联合国粮食及农业组织（FAO）、国际农业发展基金（IFAD）等组织联合发布的《世界粮食安全和营养状况》报告显示，目前全球约有 7.35 亿饥饿人口，远高于 2019 年的 6.13 亿，这意味着农业仍…
阅读更多...
碳素光线疗法与宠物健康

碳素光线疗法与宠物健康

碳素光线与宠物健康 生息在地球上的所有动物、在自然太阳光奇妙的作用下、生长发育。太阳光的能量使它们不断进化、繁衍种族。现在、生物能够生存、全仰仗于太阳的光线。太阳光线中、包含有动物健康所需要的极为重要的波长。因此、和户外饲养的动物相比、在室内喂养的观赏动物、…
阅读更多...
【机器学习300问】59、计算图是如何帮助人们理解反向传播的？

【机器学习300问】59、计算图是如何帮助人们理解反向传播的？

在学习神经网络的时候，势必会学到误差反向传播，它对于神经网络的意义极其重大，它是训练多层前馈神经网络的核心算法，也是机器学习和深度学习领域中最为重要的算法之一。要正确理解误差反向传播，不妨借助一个工具——计…
阅读更多...
初始C语言最后一章《编译、链接与预处理详解》

初始C语言最后一章《编译、链接与预处理详解》

前言 感谢老铁们的陪伴和支持，初始C语言专栏在本章内容也是要结束了，这创作一路下来也是很不容易，如果大家对 Java 后端开发感兴趣，欢迎各位老铁来我的Java专栏！当然了，我也会更新几章C语言实现简单的数据结…
阅读更多...
最新文章

Copyright @ 2022~2023