Java 随笔记: 面向对象编程(三)

目录

1. 类变量

2. 类方法

3. main 方法

4. 代码块

5. 单例设计模式

6. final 关键字

8. 抽象类

9. 模板设计模式

10. 接口

11. 内部类

1. 类变量

在Java中，类变量也被称为静态变量，用关键字“static”声明。类变量属于整个类，而不是某个特定的实例对象。这意味着，类变量只有一份拷贝，被该类的所有实例对象所共享。

类变量可以用于存储与类相关的数据，例如常量、配置参数等。它们在类加载时被初始化，并且在整个程序运行期间都存在。类变量可以直接通过类名来访问，而无需创建该类的实例对象。

可以通过以下方式定义和使用类变量：

  1. 在类内部，在方法之外声明一个静态变量。例如：

    public class MyClass {
    public static int myVariable;
}

    在这个例子中，myVariable就是一个类变量。

  2. 通过类名直接访问类变量。例如：

    MyClass.myVariable = 10;

    这个例子中，将myVariable的值设置为10。

类变量的一些特点如下：

  • 类变量在内存中只有一份拷贝，被该类的所有实例对象所共享。
  • 类变量可以在类的任何地方进行访问，包括类的方法、构造函数、静态代码块等。
  • 类变量的生命周期与类的生命周期相同，即在类加载时被初始化，直到程序退出或类被卸载时才会被销毁。
  • 类变量可以通过类名直接访问，也可以通过对象名访问，但建议使用类名直接访问，以便明确表达该变量是一个类变量。
  • 类变量可以被继承，并且可以被子类中的同名类变量所隐藏。

需要注意的是，类变量的使用应该遵循合适的命名规范和访问权限。一般情况下，类变量应该使用私有访问权限，并提供公共的getter和setter方法来访问和修改该变量的值。这样可以封装类变量的实现细节，同时也能保证对类变量的访问具有一定的控制能力。

2. 类方法

在Java中，类方法是与类相关联的方法，而不是与类的实例相关联的方法。类方法可以通过类名直接调用，而不需要创建类的实例。类方法通常用来执行通用的操作，不依赖于特定的对象状态。

以下是一些关于Java中类方法的详细介绍：

  1. 声明类方法： 在Java中，通过在方法前面添加static关键字来声明类方法。静态方法属于类本身，而不属于类的实例。例如：

    public class MyClass {
    public static void myMethod() {
        // 方法体
    }
}

  2. 调用类方法： 可以通过类名直接调用类方法，而不需要创建类的实例。例如：

    MyClass.myMethod();

  3. 类方法的特点：

    • 类方法可以访问类的静态变量，但不能访问实例变量。
    • 类方法不能使用this关键字，因为this关键字代表当前对象实例，而类方法不依赖于对象实例。
    • 类方法可以调用其他类方法，包括其他类的静态方法。
    • 类方法可以被继承，子类可以重写父类的类方法。

  4. 例子：

    public class MathUtils {
    public static int add(int a, int b) {
        return a + b;
    }
    
    public static int subtract(int a, int b) {
        return a - b;
    }
}

    可以通过类名直接调用MathUtils类的add和subtract方法：

    int result1 = MathUtils.add(5, 3);
int result2 = MathUtils.subtract(10, 7);

类方法通常用于执行与整个类相关的通用操作，例如数学计算、工具类中的常用功能等。由于类方法不依赖于对象实例，可以直接通过类名调用，而无需创建类的实例。这种特性使得类方法非常适合用于定义那些不需要访问对象状态的操作。

3. main 方法

在Java中，main方法是一个特殊的方法，是程序的入口点。每个Java程序都必须包含一个名为main的方法，以便能够运行程序。

main方法的声明如下：

public static void main(String[] args) {
    // 程序代码
}

其中：

  • public 表示main方法是公共的，可以被其他类访问。
  • static 表示main方法是静态的，可以直接通过类名调用。
  • void 表示main方法不返回任何值。
  • main 是方法的名称，是Java程序的入口点。
  • String[] args 是main方法的参数，是一个字符串数组，可以在命令行中传递参数给程序。

关于main方法的一些重要事项：

  1. main方法必须是public访问权限的，这是因为JVM需要通过反射机制来调用它。
  2. main方法必须是static静态的，这是因为在程序启动时，对象还没有被创建，只能直接调用静态方法。
  3. main方法的返回类型是void，即无返回值。
  4. main方法的参数是一个字符串数组，可以接收命令行参数。字符串数组可以用来传递程序运行时的参数。
  5. main方法是程序执行的起点，程序从main方法开始执行，一直到main方法结束。

下面是一个简单的示例：

public class Main {
    public static void main(String[] args) {
        // 打印命令行参数
        for (String arg : args) {
            System.out.println(arg);
        }
        
        // 调用其他方法
        printHello();
    }
    
    public static void printHello() {
        System.out.println("Hello, World!");
    }
}

在上面的示例中，main方法首先打印命令行参数，然后调用printHello方法打印"Hello, World!"。可以通过命令行传递参数给程序，例如：

java Main arg1 arg2

运行结果会打印出传递的参数：

arg1
arg2
Hello, World!

4. 代码块

在Java中，代码块是一段被花括号包围的代码，也被称为代码组或语句组。主要有三种类型的代码块：方法块、构造块和静态块。

  1. 方法块（普通块）： 方法块是位于方法内的一段代码，用于执行特定任务。它可以在方法内的任何地方定义，并在方法被调用时被执行。方法块可以包括变量定义、条件判断、循环等语句。方法块的作用域仅限于所属方法，不可以被其他方法访问。

    示例代码如下： 
    public class Example {
    public void method() {
        // 方法块开始
        {
            int x = 10;
            System.out.println(x);
        }
        // 方法块结束
    }
}
  2. 构造块（实例块）： 构造块是位于类中的一段代码，用于初始化实例变量或执行其他任务。它在对象创建时被执行，而且每次创建对象时都会执行一次。构造块可以在类中的任何地方定义，且在构造方法之前执行。构造块的作用域仅限于所属类，不可以被其他类访问。

    示例代码如下： 
    public class Example {
    {
        // 构造块开始
        int x = 10;
        System.out.println(x);
    }
    
    public Example() {
        // 构造方法
    }
}
  3. 静态块： 静态块是位于类中的一段代码，用于初始化静态变量或执行其他任务。它在类被加载时执行，且只执行一次。静态块可以在类中的任何地方定义，且在静态变量初始化之前执行。静态块的作用域仅限于所属类，不可以被其他类访问。

    示例代码如下： 
    public class Example {
    static {
        // 静态块开始
        int x = 10;
        System.out.println(x);
    }
    
    public static void main(String[] args) {
        // 主方法
    }
}

需要注意的是，方法块的作用域仅限于所属方法，构造块和静态块的作用域仅限于所属类。此外，方法块和构造块可以多次定义和执行，而静态块只执行一次。

5. 单例设计模式

单例设计模式是一种创建型设计模式，用于保证一个类只有一个实例，并提供一个全局访问点来获取该实例。这种模式通常被用于需要对资源进行集中管理或避免频繁创建对象的情况。

实现单例设计模式的关键是：

  1. 将类的构造方法私有化，防止外部通过new关键字创建实例。
  2. 在类内部创建一个私有的静态成员变量来保存唯一实例的引用。
  3. 提供一个公共的静态方法来获取该实例。

实现单例设计模式的方法有多种，下面介绍其中两种常用的方式：

  1. 饿汉式单例模式： 在类加载时就创建实例对象，并将其保存在静态变量中。这种方式的优点是实现简单，线程安全，但缺点是会在类加载时就创建实例，可能会造成不必要的资源浪费。

    示例代码： 
    public class Singleton {
    // 在类加载时就创建实例对象
    private static final Singleton instance = new Singleton();
    
    // 私有构造方法，防止外部创建实例
    private Singleton() {}
    
    // 提供静态方法来获取实例对象
    public static Singleton getInstance() {
        return instance;
    }
}
  2. 懒汉式单例模式： 在获取实例对象时才创建实例。这种方式的优点是延迟了实例的创建，在需要时再进行创建，减少了资源的浪费。但缺点是在多线程环境下可能会出现线程安全问题，需要额外的处理。

    示例代码： 
    public class Singleton {
    private static Singleton instance;
    
    // 私有构造方法，防止外部创建实例
    private Singleton() {}
    
    // 提供静态方法来获取实例对象
    public static Singleton getInstance() {
        if (instance == null) {
            // 在多线程环境下需要进行同步处理
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

使用单例模式时需要注意以下几点：

  • 单例实例需要是线程安全的，尤其在多线程环境下使用懒汉模式时要进行同步处理。
  • 单例实例需要是唯一的，不能通过其他方式创建实例。
  • 避免使用全局变量的方式实现单例模式，这会造成资源的浪费或无法正确管理资源。

单例设计模式在实际开发中广泛应用，例如数据库连接池、日志管理等场景。

6. final 关键字

final关键字在Java中用于修饰类、方法和变量，具有不同的作用和用法。

  1. 修饰类 ：使用final修饰的类是不可继承的，即该类不能再有子类。这是为了防止其他类对该类进行扩展或修改。

    示例代码： 
    final class FinalClass {
    // 类的内容
}
  2. 修饰方法： 使用final修饰的方法是不可重写的，即子类不能对该方法进行覆盖。这是为了防止子类修改父类的实现逻辑。

    示例代码： 
    class SuperClass {
    final void finalMethod() {
        // 方法的实现
    }
}

class SubClass extends SuperClass {
    // 编译错误，无法重写final方法
    // void finalMethod() {}
}
  3. 修饰变量： 使用final修饰的变量是不可修改的，即该变量的值不能被改变。一旦被赋值后，就不能再次修改。该变量可以在声明时直接赋值，或在构造函数中进行赋值，但之后不可再修改。

    示例代码： 
    class TestFinalVariable {
    final int number = 10;
    
    void modifyVariable() {
        // 编译错误，无法修改final变量
        // number = 20;
    }
}

需要注意的是，final修饰的引用变量并不是不可变的，而是引用的对象不可变。即引用变量所指向的对象的状态是可以改变的，但引用变量本身不能再指向其他对象。

示例代码：

class TestFinalReference {
    final StringBuilder stringBuilder = new StringBuilder("Hello");
    
    void modifyReference() {
        // 可以修改引用变量指向的对象的状态
        stringBuilder.append(" World");
        
        // 编译错误，无法修改final引用变量指向其他对象
        // stringBuilder = new StringBuilder("Hello");
    }
}

8. 抽象类

在Java中，抽象类是一种特殊的类，用于定义具有部分或全部抽象方法的类。抽象类不能被实例化，只能被继承，并且子类必须实现抽象类中的所有抽象方法才能创建对象。

下面详细介绍Java中的抽象类：

  1. 定义抽象类：
    • 使用abstract关键字修饰类，表示该类是一个抽象类。
    • 可以包含普通成员变量、普通方法、静态成员变量和静态方法。
    • 可以包含抽象方法，抽象方法没有方法体，只有方法签名。
    • 代码示例： 
      public abstract class AbstractClass {
    // 普通成员变量
    private int number;
    
    // 抽象方法
    public abstract void doSomething();

    // 普通方法
    public void printNumber() {
        System.out.println("Number: " + number);
    }
}
  2. 继承抽象类：
    • 一个普通的类可以继承抽象类，并且必须实现抽象类中的所有抽象方法。
    • 如果不实现抽象方法，则该类也必须声明为抽象类。
    • 代码示例： 
      public class ConcreteClass extends AbstractClass {
    // 实现抽象方法
    public void doSomething() {
        // 方法的具体实现
    }
}
  3. 使用抽象类：
    • 由于抽象类不能被实例化，我们通常使用它的子类进行对象的创建和调用。
    • 抽象类可以作为变量的类型、方法的参数类型或返回值类型。
    • 代码示例： 
      public class Main {
    public static void main(String[] args) {
        // 使用抽象类的子类创建对象
        AbstractClass obj = new ConcreteClass();
        obj.doSomething();
        obj.printNumber();
    }
}

特殊注意事项：

  • 抽象类可以有构造方法，但不能直接实例化。子类的构造方法会隐式调用父类的构造方法。
  • 抽象类中的抽象方法必须在子类中被实现，否则子类也必须声明为抽象类。
  • 抽象类可以拥有普通方法的实现，子类可以直接继承或重写这些方法。
  • 抽象类可以拥有成员变量，可以被子类继承和访问。

抽象类的主要目的是作为其他类的父类，提供一种模板或蓝图，规定子类必须实现的方法，从而实现代码的重用和规范。它可以为子类提供一些通用的属性和行为，同时也可以使用多态的方式操作抽象类对象。

9. 模板设计模式

模版设计模式是一种行为设计模式，它定义了一个操作中的算法框架，将一些步骤的具体实现推迟到子类中。模版设计模式是基于继承的，通过抽象类或接口定义一个算法的骨架，具体的实现则由子类来完成。

以下是模版设计模式的详细介绍：

  1. 模版类：
    • 模版类是一个抽象类或接口，定义了一个算法的骨架。
    • 模版类中包含一个或多个抽象方法，这些方法需要由子类实现。
    • 模版类中可以包含一些具体实现的方法，这些方法是固定的，并且在算法框架中不会改变。
    • 代码示例： 
      public abstract class AbstractTemplate {
    // 固定实现的方法
    public void preProcess() {
        // 子类无法改变的操作
    }
    
    // 抽象方法，由子类实现
    public abstract void processData();
    
    // 固定实现的方法
    public void postProcess() {
        // 子类无法改变的操作
    }
    
    // 模版方法，定义算法的骨架，调用固定实现的方法和抽象方法
    public void execute() {
        preProcess();
        processData();
        postProcess();
    }
}
  2. 具体实现类：
    • 具体实现类继承或实现模版类，实现其中的抽象方法。
    • 具体实现类可以根据需要重写模版类中的固定实现的方法。
    • 代码示例： 
      public class ConcreteTemplate extends AbstractTemplate {
    // 实现抽象方法
    public void processData() {
        // 子类实现的操作
    }
    
    // 重写固定实现的方法
    public void postProcess() {
        // 子类自定义的操作
    }
}
  3. 使用模版类：
    • 创建具体实现类的对象，调用模版类的方法来执行算法。
    • 在模版方法中，固定实现的方法会被全部执行，抽象方法的实现会根据具体实现类的不同而有所变化。
    • 代码示例： 
      public class Main {
    public static void main(String[] args) {
        AbstractTemplate template = new ConcreteTemplate();
        template.execute();
    }
}

模版设计模式的优点包括：

  • 提供了一种固定的算法框架，可以减少代码的重复。
  • 提供了一种简化算法实现的方式，将具体实现推迟到子类中。

模版设计模式的缺点包括：

  • 可能会导致子类之间的耦合性增加，因为模版类固定了一些方法的调用顺序和方式。
  • 由于使用了继承，可能会限制代码的灵活性。

模版设计模式在许多框架和库中都有广泛的应用，例如在Java中，常见的应用场景包括数据库操作、网络请求等。通过使用模版设计模式，可以提高代码的可维护性、可扩展性和复用性，同时也能够将变化和不变的部分分离，使代码更加易于理解和维护。

10. 接口

在Java中，接口是一种特殊的引用类型，它定义了一组方法的签名（即方法名、参数列表和返回类型），但没有具体的实现。接口提供了一种契约机制，用于定义类的行为和功能，并实现多态和代码复用。

以下是Java中接口的详细介绍：

  1. 定义接口：
    • 使用 interface 关键字来定义接口。
    • 接口中可以包含常量和抽象方法。
    • 接口中的方法默认为 public abstract，并且不能有具体的实现。
    • 接口中的常量默认为 public static final，并且只能是基本类型或字符串，不能被修改。
    • 示例代码： 
      public interface MyInterface {
    // 常量
    int MY_CONSTANT = 10;
    
    // 抽象方法
    void myMethod();
}
  2. 实现接口：
    • 使用 implements 关键字来实现接口。
    • 类实现接口时，必须实现接口中的所有抽象方法。
    • 类可以实现多个接口，使用逗号分隔。
    • 示例代码： 
      public class MyClass implements MyInterface {
    // 实现抽象方法
    public void myMethod() {
        // 方法的具体实现
    }
}
  3. 接口的特点：
    • 接口可以继承其他接口，使用 extends 关键字。
    • 接口之间可以形成继承关系，从而实现多态。
    • 一个类可以同时实现多个接口。
    • 示例代码： 
      public interface AnotherInterface extends MyInterface {
    // 接口继承其他接口
    void anotherMethod();
}

public class MyClass implements AnotherInterface {
    // 实现抽象方法
    public void myMethod() {
        // 方法的具体实现
    }
    
    // 实现额外的方法
    public void anotherMethod() {
        // 方法的具体实现
    }
}
  4. 接口的应用：
    • 接口可以用于实现多态，通过接口引用不同的实现类来实现灵活的对象调用。
    • 接口可以用于定义回调方法，使得对象能够在特定情况下调用其他对象的方法。
    • 接口可以用于实现类之间的解耦，通过依赖接口而不是具体实现类，提高代码的灵活性和可扩展性。

接口在Java中被广泛应用于各种场景，特别是在面向对象的设计中，用于定义类之间的契约和约定。通过接口，可以提供统一的方法集合，使得不同的类能够实现相同的接口并具备相同的行为。接口的使用可以提高代码的可读性、重用性和可维护性。

11. 内部类

在Java中，内部类是定义在另一个类内部的类。内部类可以访问外部类的成员（包括私有成员），并且可以隐藏在外部类中，从而提供更好的封装性和代码组织性。Java中的内部类主要有以下几种类型：

  1. 成员内部类（Member Inner Class）：
    • 成员内部类是定义在类内部且直接在类的成员位置上的类。
    • 成员内部类可以使用外部类的成员变量和方法，并且可以访问外部类的私有成员。
    • 成员内部类的实例必须依赖于外部类的实例，需要通过外部类的实例创建内部类的对象。
    • 示例代码： 
      public class OuterClass {
    private int outerVariable;
    
    public void outerMethod() {
        // ...
    }
    
    public class InnerClass {
        private int innerVariable;
        
        public void innerMethod() {
            // 可以访问外部类的成员
            outerVariable = 10;
            outerMethod();
            
            // ...
        }
    }
}
  2. 静态内部类（Static Inner Class）：
    • 静态内部类是定义在类内部但使用 static 修饰的类。
    • 静态内部类与外部类的实例无关，可以直接访问外部类的静态成员，但无法访问外部类的非静态成员。
    • 静态内部类可以在外部类的静态方法中直接创建对象，无需依赖于外部类的实例。
    • 示例代码： 
      public class OuterClass {
    private static int outerStaticVariable;
    
    public static void outerStaticMethod() {
        // ...
    }
    
    public static class InnerClass {
        private int innerVariable;
        
        public void innerMethod() {
            // 可以访问外部类的静态成员
            outerStaticVariable = 10;
            outerStaticMethod();
            
            // ...
        }
    }
}
  3. 局部内部类（Local Inner Class）：
    • 局部内部类是定义在方法内部的类，也可以在代码块内部定义。
    • 局部内部类只能在定义它的方法或代码块中使用，对外部类和其他方法不可见。
    • 局部内部类可以访问外部类和方法的成员，但只能访问 final 或事实上为 final 的局部变量。 
    • 示例代码： 
      public class OuterClass {
    public void outerMethod() {
        final int localVar = 10; // 局部变量
        
        class LocalInnerClass {
            public void innerMethod() {
                // 可以访问外部类的成员
                outerMethod();
                
                // 可以访问局部变量（注意需要为 final 或事实上为 final）
                int sum = localVar + 20;
                
                // ...
            }
        }
        
        // 在方法内部创建局部内部类的对象
        LocalInnerClass innerClass = new LocalInnerClass();
        innerClass.innerMethod();
    }
}
  4. 匿名内部类（Anonymous Inner Class）：
    • 匿名内部类是没有名字的内部类，直接在创建对象时定义并实现。
    • 匿名内部类通常用于实现接口或继承抽象类，并重写其方法。
    • 匿名内部类可以访问外部类的成员，但只能访问 final 或事实上为 final 的局部变量。
    • 示例代码： 
      public class OuterClass {
    public void methodWithCallback() {
        Callback callback = new Callback() {
            public void onCallback() {
                // 匿名内部类重写接口方法
                // ...
            }
        };
        
        // 调用接口方法
        callback.onCallback();
    }
}

事实上为 final 的局部变量指的是在代码中虽然没有明确使用 final 关键字来修饰该局部变量，但其实质上在编译时是不可被修改的。这种情况通常发生在以下两种情况下：

  1. 如果局部变量在声明后没有被重新赋值，即在整个作用域内保持不变。
  2. 局部变量被传递给局部内部类的方法中，而该方法中没有对局部变量进行修改。

这是因为局部内部类的对象可能会在方法执行完毕后仍然存在，而非 final 的局部变量可能会被修改或销毁，导致局部内部类访问的变量状态不确定。

内部类在Java中被广泛应用于各种场景，例如：实现事件处理、实现回调机制、封装复杂的数据结构等。内部类提供了更好的封装性和代码组织性，可以在类内部定义一些逻辑相关的辅助类，使得代码更加清晰和可读。同时，内部类能够访问外部类的成员，并且可以实现多重继承或实现多个接口，从而增加了代码的灵活性和可复用性。

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

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

相关文章

本地主机搭建服务器后如何让外网访问？快解析内网端口映射

本地主机搭建服务器后如何让外网访问？快解析内网端口映射

本地主机搭建应用、部署服务器后，在局域网内是可以直接通过计算机内网IP网络地址进行连接访问的，但在外网电脑和设备如何访问呢？由于内网环境下，无法提供公网IP使用，外网访问内网就需要一个内外网转换的介质。这里介绍…
阅读更多...
stm32开发之netxduo组件之mqtt客户端的使用记录

stm32开发之netxduo组件之mqtt客户端的使用记录

前言 1使用mqtt协议的简单示例记录 代码 MQTT服务端(C# 编写,使用MQTTnet提供的示例代码) 主程序 namespace ConsoleApp1;public class Program {public static async Task Main(string[] args){await Run_Server_With_Logging();}}public static async Task Run_Server_Wi…
阅读更多...
CERLAB无人机自主框架: 1-环境搭建

CERLAB无人机自主框架: 1-环境搭建

前言：更多更新文章详见我的个人博客主页【MGodmonkeyの世界】 描述：欢迎来到CERLAB无人机自主框架，这是一个用于自主无人飞行器 (UAV) 的多功能模块化框架。该框架包括不同的组件 (模拟器，感知，映射，规划和…
阅读更多...
后台管理系统加水印（react）

后台管理系统加水印（react）

效果 代码图片 代码 window.waterMark function (config) {var defaultConfig {content: 我是水印,fontSize: 16px,opacity: 0.3,rotate: -15,color: #ADADAD,modalId: J_waterMarkModalByXHMAndDHL,};config Object.assign({}, defaultConfig, config);var existMarkModal…
阅读更多...
亚信安全入选中国数据安全市场图谱

亚信安全入选中国数据安全市场图谱

近日，全球领先的IT市场研究和咨询公司IDC发布了《IDC Market Glance：中国数据安全市场图谱，2024》报告（以下简称“报告”），报告展示了中国数据安全市场的构成和格局，遴选出不同细分市场领域的主…
阅读更多...
rabbitmq 使用SAC队列实现顺序消息

rabbitmq 使用SAC队列实现顺序消息

rabbitmq 使用SAC队列实现顺序消息 前提 SAC: single active consumer, 是指如果有多个实例，只允许其中一个实例消费，其他实例为空闲 目的 实现消息顺序消费，操作： 创建4个SAC队列,消息的路由key 取队列个数模，这…
阅读更多...
java调用讯飞星火认知模型

java调用讯飞星火认知模型

前往讯飞开发平台选择产品，获取appId、apiKey、APISecret，这里我选择的是v3.0模型。 java后端实现 本项目以及实现了基本的会话功能，小伙伴可以自己扩充其他的例如绘画功能。 注意：星火模型的api使用的是websocket协议&#xf…
阅读更多...
C++11(下篇)

C++11(下篇)

文章目录 C111. 模版的可变参数1.1 模版参数包的使用 2. lambda表达式2.1 Lambda表达式语法捕获列表说明 2.2 lambda的底层 3. 包装器3.1 function包装器3.2 bind 4. 线程库4.1 thread类4.2 mutex类4.3 atomic类4.4 condition_variable类 C11 1. 模版的可变参数 C11支持模版的…
阅读更多...
数据结构习题-- 相交链表

数据结构习题-- 相交链表

数据结构习题-- 相交链表 给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 如上图，返回c1结点 注意：这两个链表非环形 方法：集合 分析 由…
阅读更多...
关于ERA5气压和温度垂直补偿公式的对比情况

关于ERA5气压和温度垂直补偿公式的对比情况

1. 气压和温度垂直补偿对比 「谨代表给个人观点，杠精请自测，对对对，好好好，你说啥都对」。 使用2020-2022陆态网GNSS与探空站并址的48个站点实验，以探空站为真值，验证ERA5精度。怎么确定并址请看前面文章…
阅读更多...
Django中的实时通信：WebSockets与异步视图的结合

Django中的实时通信：WebSockets与异步视图的结合

👽发现宝藏 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。【点击进入巨牛的人工智能学习网站】。 在现代Web应用程序中，实时通信已经成为了必不可少的功能之一。无论是在线聊天、…
阅读更多...
UKP3D，出轴 /平面图时，选项中出图比例，绘图比例，打印比例的区别

UKP3D，出轴 /平面图时，选项中出图比例，绘图比例，打印比例的区别

Q:用户问，轴测图正常，平面图位置不对，这个也需要在xml里面调整吗？ 在此，先不回复上述问题，而是解释在出图规则里的选项意思。 1.图框比例：图框比例1:100，例如选中的图幅是A0横式&…
阅读更多...
现代图形API综合比较：Vulkan | DirectX | Metal | WebGPU

现代图形API综合比较：Vulkan | DirectX | Metal | WebGPU

Vulkan、DirectX、Metal 和 WebGPU 等低级图形 API 正在融合为类似于当前 GPU 构建方式的模型。 图形处理单元 (GPU) 是异步计算单元，可以处理大量数据，例如复杂的网格几何形状、图像纹理、输出帧缓冲区、变换矩阵或你想要计算的任何数据。 NSDT工具推荐…
阅读更多...
TFS(淘宝分布式存储引擎

TFS(淘宝分布式存储引擎

TFS（淘宝分布式存储引擎） 什么是TFS？ ​ 根据淘宝2016年的数据分析，淘宝卖家已经达到900多万，有上十亿的商品。每一个商品有包括大量的图片和文字(平均：15k)，粗略估计下，数据所占的…
阅读更多...
编译一个基于debian/ubuntu,centos,arhlinux第三方系统

编译一个基于debian/ubuntu,centos,arhlinux第三方系统

目录 前言 准备工作 下载linux源码进行编译 linux源码下载 网站 问题 解决办法 编译 可能会遇到的问题 chroot下载debian环境 进入虚拟环境 把chroot的根目录文件打包为.gz文件 编译init文件（用于系统启动时的一系列引导） 给予文件夹权限 …
阅读更多...
pip下载包opencv出错（报错failed building wheel for opencv-python解决方法）

pip下载包opencv出错（报错failed building wheel for opencv-python解决方法）

文章目录 1 报错2 原因3 解决方法参考 1 报错 ERROR: Could not build wheels for opencv-python, which is required to install pypr2 原因 版本不兼容的问题,当使用pip install opencv-python命令安装的是最新版本，当前python版本不支持。需要安装当前版本pyth…
阅读更多...
34. 【Android教程】菜单：Menu

34. 【Android教程】菜单：Menu

作为 Android 用户，你一定见过类似这样的页面： 它就是我们今天的主角——菜单，它的使用场景和作用不用多说，几乎每个 App 都会用到它，今天我们就一起来看看 Android 提供的几种菜单类型及用法。 1. 菜单的几种类型 根…
阅读更多...
✌粤嵌—2024/4/12—插入区间✌

✌粤嵌—2024/4/12—插入区间✌

代码实现： 解题思路：先将数组 newInterval 插入到数组 intervals 的末尾，再转换成合并区间 /*** Return an array of arrays of size *returnSize.* The sizes of the arrays are returned as *returnColumnSizes array.* Note: Both returne…
阅读更多...
LabVIEW专栏六、LabVIEW项目

LabVIEW专栏六、LabVIEW项目

一、梗概 项目：后缀是.lvproj，在实际开发的过程中，一般是要用LabVIEW中的项目来管理代码，也就是说相关的VI或者外部文件，都要放在项目中来管理。 在LabVIEW项目中，是一个互相依赖的整体，可以包…
阅读更多...
319_C++_使用QT自定义的对话框，既能选择文件也能选择文件夹，为什么使用QListView和QTreeView来达成目的？

319_C++_使用QT自定义的对话框，既能选择文件也能选择文件夹，为什么使用QListView和QTreeView来达成目的？

解析 1： 在 Qt 中，QFileDialog::setOption 方法用于设置文件对话框的一些选项，以改变其行为或外观。QFileDialog::DontUseNativeDialog 是这些选项之一，当设置为 true 时，它会告诉 QFileDialog 不要使用操作系统提供的原生文件对话框，而是使用 Qt 自己实现的对话框样式。…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站