Java的高级特性

于 2024-08-31 23:44:37 发布
阅读量697 收藏 8
点赞数 22
分类专栏： java 文章标签： 枚举enume 异常处理 泛型 反射 lambda表达式 流streams java javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WZX17307935391/article/details/141760378
版权

Java的高级特性概述：

Lambda表达式

Lambda表达式是Java 8及更高版本中引入的一个重要特性，它提供了一种简洁的方式来表示匿名方法（即没有名称的方法）。Lambda表达式特别适用于实现仅有一个抽象方法的接口（这类接口被称为函数式接口）。Lambda表达式使得代码更加简洁、易于阅读，并且提高了编程效率。

Lambda表达式的基本语法

(参数列表) -> { 方法体 }

  • 参数列表：Lambda表达式接收的参数。如果参数列表为空，可以省略小括号()。如果只有一个参数，并且该参数的类型可以通过上下文推断出来，那么小括号和参数类型都可以省略。
  • ->：Lambda操作符，用于分隔参数列表和方法体。
  • 方法体：Lambda表达式需要执行的操作。如果方法体只包含一条语句，并且该语句的结果需要作为Lambda表达式的返回值，那么大括号{}可以省略，同时该语句的结束分号;也可以省略。但是，如果方法体包含多条语句，或者需要显式地返回结果，那么大括号{}和必要的分号;就不能省略。

使用Lambda表达式实现打印字符串的Runnable接口

Runnable runnable = () -> System.out.println("Hello, Lambda!");
new Thread(runnable).start();

在这个例子中，Runnable是一个函数式接口，它有一个无参数、无返回值的run方法。我们使用Lambda表达式() -> System.out.println("Hello, Lambda!")来实现了这个run方法，从而创建了Runnable接口的一个匿名实现。

Lambda表达式在Java中广泛应用于集合的遍历、筛选、映射等操作，以及并发编程中的线程池、CompletableFuture等场景。

在集合操作中使用Lambda表达式进行过滤和映射示例

假设我们有一个Person类，它有两个属性：name（姓名）和age（年龄），并且我们有一个Person对象的列表。我们的目标是找出列表中所有年龄大于30岁的人，并打印出他们的姓名。

首先，我们定义Person类：
public class Person {
    private String name;
    private int age;

    // 构造函数、getter和setter省略

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    // toString方法省略，但建议在实际类中实现以方便打印
}
其次，使用Lambda表达式实现过滤和打印的功能
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class LambdaExample {
    public static void main(String[] args) {
        // 创建一个Person对象的列表
        List<Person> people = Arrays.asList(
                new Person("Alice", 31),
                new Person("Bob", 25),
                new Person("Charlie", 35),
                new Person("David", 29)
        );

        // 使用Lambda表达式和stream API来过滤年龄大于30的人，并收集他们的姓名
        List<String> namesOfOldPeople = people.stream()
                .filter(person -> person.getAge() > 30) // 过滤操作
                .map(Person::getName) // 映射操作，使用方法引用
                .collect(Collectors.toList()); // 收集结果

        // 打印结果
        namesOfOldPeople.forEach(System.out::println);
    }
}

在这个例子中，我们首先通过Arrays.asList创建了一个Person对象的列表。然后，我们使用stream()方法将列表转换为流，以便进行链式操作。通过filter()方法，我们传入了一个Lambda表达式person -> person.getAge() > 30来过滤出年龄大于30的Person对象。接着，我们使用map()方法，并通过方法引用Person::getName将过滤后的Person对象映射为他们的姓名字符串。最后，我们使用collect(Collectors.toList())将映射后的流收集到一个新的列表中，并通过forEach()方法和System.out::println来打印出这些姓名。

这个例子展示了Lambda表达式在集合操作中的强大功能，以及如何与Java 8引入的流API结合使用来简化代码。

流（Streams）API

流（Streams）API是Java 8中引入的一个关键特性，它提供了一种高效且表达力强的方式来处理集合（如List、Set）以及数组等数据源。流API的设计初衷是为了让集合操作更加灵活、易于理解，并且可以利用多核处理器的优势进行并行处理。

流的基本概念

  • 流（Stream）：流是数据源到数据汇（比如另一个集合、累加器或终端操作）的序列。流操作可以是中间操作（如过滤、映射）或终端操作（如收集、归约）。
  • 数据源：流的数据源可以是集合、数组、生成器函数等。
  • 中间操作：中间操作会返回一个新的流，并且可以被链式调用。中间操作包括过滤（filter）、映射（map）、排序（sorted）等。
  • 终端操作：终端操作会处理流中的元素，并产生一个结果，比如集合（collect）、值（reduce）、无结果（forEach）等。终端操作会触发流的执行。

流的特点

  • 惰性求值：流操作是惰性的，即中间操作不会立即执行，而是会等到终端操作时才会实际处理流中的元素。
  • 不可变性：流操作不会修改数据源，而是返回一个新的流。
  • 函数式编程：流API的设计符合函数式编程的原则，允许你以声明式的方式处理数据集合。

流的常见操作

  • 过滤（Filter）：通过给定的条件过滤流中的元素。
  • 映射（Map）：将流中的每个元素转换成另一种形式。
  • 排序（Sorted）：对流中的元素进行排序。
  • 收集（Collect）：将流中的元素收集到集合中，如List、Set等。
  • 归约（Reduce）：通过某种操作将流中的元素归约成一个单一的值。
  • 匹配（Match）：检查流中的元素是否满足某些条件，如anyMatch、allMatch、noneMatch。

示例

假设我们有一个Person对象的列表，我们想要找出所有年龄大于30岁的人的姓名列表：

List<Person> people = // 假设这是我们的Person对象列表
List<String> namesOfOldPeople = people.stream()
    .filter(p -> p.getAge() > 30) // 过滤操作
    .map(Person::getName) // 映射操作，使用方法引用
    .collect(Collectors.toList()); // 收集结果

// 现在namesOfOldPeople包含了所有年龄大于30岁的人的姓名

在这个例子中，我们首先通过stream()方法将列表转换为流，然后链式调用了filter()和map()两个中间操作，最后通过collect()终端操作将结果收集到一个新的列表中。

方法引用

与Lambda表达式紧密相关的是方法引用，它是对Lambda表达式的一种更简洁的写法，是Lambda表达式的一个简洁表示形式，它允许你直接引用已存在的方法或构造函数。当Lambda表达式的主体只是调用一个已存在的方法时，你可以使用方法引用来代替Lambda表达式。

方法引用主要几种形式：

静态方法引用

使用类名来引用静态方法。

Integer::parseInt // 相当于 x -> Integer.parseInt(x)

特定对象的实例方法引用

使用特定对象来引用其实例方法。

String str = "Hello";
Consumer<String> greeting = str::length; // 注意：这里实际上是不常见的用法，因为greeting没有使用到外部定义的str对象，更常见的是下面的形式
// 更常见的实例方法引用形式是在流操作中使用，比如list.forEach(System.out::println);

特定类型的任意对象的实例方法引用

使用类名来引用其任意对象的实例方法。这要求Lambda表达式中的参数是类类型的一个实例，并且该实例方法没有修改除参数以外的对象状态。

List<String> list = Arrays.asList("apple", "banana", "cherry");
list.forEach(String::toUpperCase); // 相当于 list.forEach(s -> s.toUpperCase());

构造器引用

使用类名来引用其构造器。

Supplier<List<String>> listSupplier = ArrayList::new; // 相当于 Supplier<List<String>> 

注解

Java从1.5版本开始引入了注解，注解是Java中的一个重要特性，它为代码提供了元数据。这些元数据可以在编译时、加载时或运行时被读取，以执行各种任务，如自动生成代码、生成文档、进行编译时检查、在运行时处理类等。Java提供了内置的注解，如@Override、@Deprecated等，同时也允许你定义自己的注解。

在Java中，注解是通过@interface关键字定义的，它看起来很像接口，但实际上是一种特殊的类型。注解可以附加在类、方法、参数、变量、包等程序元素上，以提供关于这些元素的额外信息。

Java标准库提供了许多内置的注解，比如@Override（表示某个方法是重写了父类中的方法）、@Deprecated（表示某个程序元素（类、方法等）已过时，不建议使用）、@SuppressWarnings（指示编译器忽略特定的警告）等。

除了内置注解外，Java还允许开发者定义自己的注解。自定义注解时，可以通过元注解（如@Target、@Retention、@Inherited等）来指定注解的适用范围、保留策略等。

  • @Target：用于指定注解可以应用的Java元素类型（如类、方法、参数等）。
  • @Retention：用于指定注解的保留策略，即注解在何时生效。常见的保留策略有SOURCE（仅在源码中保留，编译时丢弃）、CLASS（在源码和class文件中保留，但运行时不可见）和RUNTIME（在源码、class文件和运行时都保留，因此可以通过反射读取）。
  • @Inherited：表示注解类型会被自动继承。如果在一个类上使用了一个被@Inherited注解的注解类型，那么这个类的子类也会继承这个注解。

注解本身不直接影响代码的执行，但它们可以被编译器或运行时环境读取，以执行各种任务。例如，在Java的持久化框架（如JPA）中，注解被用来描述实体类与数据库表之间的映射关系；在Spring框架中，注解被用来实现依赖注入等功能。

反射（Reflection）

在Java中，反射（Reflection）是一种强大的机制（特性），它允许程序在运行时检查和操作类的行为和对象的属性。通过反射，你可以在运行时获取类的信息（如类的字段、方法、构造函数等），并动态地创建对象、调用方法或访问字段。这种机制为Java语言提供了高度的灵活性和动态性。然而，反射也会降低程序的性能，并可能破坏封装性，因此在使用时需要谨慎。

反射的主要用途包括：

  1. 动态创建对象：使用Class.forName()加载类，然后使用Class对象的newInstance()方法创建该类的实例。

  2. 动态调用方法：通过Method类的实例，可以调用类中的任何方法，包括私有方法。

  3. 动态访问字段：通过Field类的实例，可以访问类的私有字段，并对其进行修改。

  4. 获取类的信息：使用反射可以获取类的名称、父类、实现的接口、构造函数、方法和字段等信息。

反射的常用类和方法：

  • Class：代表类的本身，包含创建对象、获取方法、字段等信息的方法。
  • Method：表示类和接口中的方法，可以动态调用方法。
  • Field：表示类和接口中的字段，可以访问和修改字段的值。
  • Constructor：表示类的构造函数，可以用来动态创建对象。

反射的示例代码

// 动态加载类并创建对象
try {
    Class<?> clazz = Class.forName("com.example.MyClass");
    Object obj = clazz.newInstance();

    // 调用方法
    Method method = clazz.getMethod("myMethod", String.class);
    method.invoke(obj, "Hello, Reflection!");

    // 访问字段
    Field field = clazz.getDeclaredField("myField");
    field.setAccessible(true); // 如果字段是私有的，需要设置为可访问
    Object fieldValue = field.get(obj);
    System.out.println(fieldValue);
} catch (Exception e) {
    e.printStackTrace();
}

注意事项：

  • 反射会牺牲一些性能，因为它涉及到了类型检查等动态操作。
  • 使用反射访问私有字段和方法时，应谨慎处理，以避免破坏封装性。
  • 反射可以绕过Java的访问控制检查，因此应仅在必要时使用，并确保代码的安全性。

泛型（Generics）

在Java中，泛型（Generics）是Java 5引入的一个特性，泛型是一种强大的特性，它提供了编译时类型安全检测机制，允许程序员在类、接口、方法创建时定义一个或多个类型参数（这些类型参数在声明时指定，并在使用时具体化）。通过使用泛型，你可以编写更加灵活、可重用的代码，同时避免了在运行时出现ClassCastException。

泛型的主要优点包括：

  1. 类型安全：通过泛型，你可以在编译时期就检查到类型错误，而不是在运行时。
  2. 消除强制类型转换：在使用泛型之前，我们经常需要对集合中的元素进行强制类型转换，而使用泛型后，你可以在获取元素时自动获得正确的类型。
  3. 提高代码的重用性：你可以编写一套泛型代码来操作多种类型的数据，提高了代码的重用性。

泛型的使用场景：

  • 集合类（如List、Set、Map等）的泛型化，使得你可以在编译时期就指定集合中元素的类型。
  • 泛型方法，允许你定义在方法内部操作的类型。
  • 泛型接口，可以定义一个接口，其中的类型参数在实现类或子类中被具体化。
  • 泛型类，可以定义一个类，其中的类型参数在创建类的实例时被具体化。

示例代码

// 泛型集合示例
List<String> stringList = new ArrayList<>();
stringList.add("Hello");
// stringList.add(123); // 编译错误，因为泛型集合指定了元素类型为String

// 泛型方法示例
public static <T> T getFirstElement(List<T> list) {
    if (list != null && !list.isEmpty()) {
        return list.get(0);
    }
    return null;
}

// 使用泛型方法
List<Integer> intList = new ArrayList<>();
intList.add(1);
Integer firstInt = getFirstElement(intList);

异常处理

Java的异常处理机制是一种结构化的错误处理方式。通过try-catch-finally语句块，你可以捕获并处理在程序执行过程中发生的异常。Java还提供了自定义异常的功能，允许你根据实际需要定义新的异常类。

异常处理的基本结构

Java中的异常处理是通过try、catch和finally（可选）块来实现的。

  • try块：包含可能引发异常的代码。
  • catch块：紧跟在try块之后，用于捕获并处理try块中抛出的异常。可以有多个catch块来处理不同类型的异常。
  • finally块（可选）：无论是否发生异常，finally块中的代码都会被执行。它通常用于执行清理操作，如关闭文件流或数据库连接。

示例代码

try {
    // 尝试执行的代码，可能引发异常
    int result = 10 / 0; // 这里会抛出ArithmeticException
} catch (ArithmeticException e) {
    // 处理ArithmeticException
    System.out.println("发生了算术异常: " + e.getMessage());
} catch (Exception e) {
    // 处理其他类型的异常（可选）
    System.out.println("发生了异常: " + e.getMessage());
} finally {
    // 清理代码，无论是否发生异常都会执行
    System.out.println("执行清理操作");
}

注意事项

  • 异常类型：在catch块中，你应该尽可能具体地指定异常类型，而不是简单地使用Exception类。这有助于你更精确地了解异常的原因，并编写更有针对性的处理代码。
  • 避免过度使用异常：异常处理虽然强大，但过度使用会使代码变得难以理解和维护。在可能的情况下，应该通过其他方式（如返回值、断言等）来处理错误情况。
  • 资源泄露：在使用finally块时，要确保即使在发生异常的情况下也能正确释放资源。

枚举（Enumerations）

枚举（Enumerations）在Java中是一种特殊的类，它用于表示一组常量。通过枚举，你可以定义一组命名的整型常量，使得代码更加清晰易读。枚举在Java 5（JDK 1.5）中被引入，自那以来，它们已经成为了处理固定集合的常用工具。枚举不仅比传统的常量定义方式更加类型安全，还提供了丰富的功能，如枚举方法、枚举构造函数、枚举集合等。

枚举的基本用法：

  1. 定义枚举：使用enum关键字来定义一个枚举。枚举中可以直接定义常量，这些常量默认是public static final的。

    enum Color {
    RED, GREEN, BLUE;
}

  2. 枚举的构造函数：虽然枚举中的常量看起来像是静态字段，但实际上它们是通过枚举类型的构造函数创建的实例。枚举可以有构造函数，但构造函数必须是私有的，以防止外部代码创建枚举的实例。

    enum Color {
    RED("红色"), GREEN("绿色"), BLUE("蓝色");

    private final String description;

    Color(String description) {
        this.description = description;
    }

    public String getDescription() {
        return description;
    }
}

  3. 实现接口：枚举类型可以实现接口，并且每个枚举常量都可以有自己的实现。

    interface Printable {
    void print();
}

enum Color implements Printable {
    RED {
        @Override
        public void print() {
            System.out.println("红色");
        }
    },
    GREEN {
        @Override
        public void print() {
            System.out.println("绿色");
        }
    },
    BLUE {
        @Override
        public void print() {
            System.out.println("蓝色");
        }
    };

    @Override
    public void print() {
        // 默认实现（可选）
    }
}

  4. 枚举的方法：枚举可以包含抽象方法和具体方法，使得每个枚举常量可以有自己的行为。

  5. 枚举的遍历：可以使用values()方法遍历枚举的所有常量，或者使用EnumSet和EnumMap等集合类来操作枚举。

    for (Color c : Color.values()) {
    System.out.println(c + " - " + c.getDescription());
}

内部类

内部类（Inner Class）是Java编程语言中一个非常重要的概念，它允许你定义在另一个类（称为外部类）里面的类。内部类可以是静态的（Static Inner Class）或非静态的（Non-static Inner Class，也称为实例内部类 Instance Inner Class）。内部类提供了更好的封装性，并且可以方便地访问外部类的成员（包括私有成员）。

非静态内部类

非静态内部类会隐式地持有其外部类的一个引用。因此，你不能在没有外部类实例的情况下创建非静态内部类的实例。创建非静态内部类实例的通常语法是：

OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.new InnerClass();

静态内部类

静态内部类不会持有外部类的引用，因此它可以像其他任何类一样被创建，而不需要外部类的实例。创建静态内部类实例的语法类似于其他类的实例化：

OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();

局部内部类

局部内部类是在方法内部定义的类。它的作用域被限定在定义它的方法或代码块中。局部内部类同样可以访问外部类的成员，但不能访问外部类的非final局部变量（在Java 8及以后版本中，可以使用effectively final的局部变量）。

匿名内部类

匿名内部类是没有名字的内部类，它通常用于实现简单的接口或继承一个类，并在需要时立即使用其实例。匿名内部类常用于GUI编程、事件监听器等场景。

使用内部类的优点

  • 更好的封装：内部类可以隐藏起来，不被外部类以外的其他类访问。
  • 方便访问外部类的成员：内部类可以直接访问外部类的所有成员（包括私有成员），而不需要使用外部类的公共getter和setter方法。
  • 实现多重继承：通过内部类，Java可以间接地实现多重继承（因为Java本身不支持多重继承）。外部类可以继承一个类，而内部类可以实现多个接口。

自动装箱与拆箱

Java 5引入了自动装箱与拆箱机制，它允许自动地将基本数据类型与其对应的包装类进行转换。这简化了代码编写，但也需要注意自动装箱与拆箱可能会导致的性能问题。

自动装箱（Autoboxing）

自动装箱是指将基本数据类型（如int、double等）自动转换为它们对应的包装类（如Integer、Double等）的过程。这个过程是自动完成的，你不需要显式地调用包装类的构造函数。

示例：

int i = 5;
Integer integer = i; // 自动装箱

在上面的例子中，int类型的变量i被自动装箱成了Integer类型的对象integer。

拆箱（Unboxing）

拆箱则是自动装箱的逆过程，即将包装类对象自动转换为它们对应的基本数据类型。这个过程同样是自动完成的，你不需要显式地调用包装类的方法（如intValue()）来获取基本数据类型的值。

示例：

Integer integer = 10;
int i = integer; // 拆箱

在上面的例子中，Integer类型的对象integer被拆箱成了int类型的变量i。

注意事项

  • 自动装箱和拆箱虽然简化了编程，但也可能导致性能问题，因为涉及到对象的创建和销毁。
  • 在进行拆箱时，如果包装类对象为null，则会抛出NullPointerException。
  • 在进行大量数值计算时，建议使用基本数据类型以提高性能。
纣王家子迎新
关注
  • 22
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Educoder题目：Java高级特性 - IO流答案解析
bingeho的博客
06-16 876
Educoder题目解析：Java高级特效 - IO流
头歌——Java高级特性 - Java反射
weixin_62440328的博客
12-27 2088
【代码】头歌——Java高级特性 - Java反射。
java高级特性总结（复习自用）
qq_41995845的博客
08-20 717
一、
java高级特性有哪些_Java高级特性总结（一）
weixin_33914679的博客
02-16 1520
Java高级特性总结(I/O&&Thread篇)1.File类可以完成对文件、目录的操作，新建、删除、重命名文件、目录等，但不能访问文件本身的内容，访问文件本身内容需要使用输入输出流，对于Java来说文件和目录都是一个概念。2.Window的路径分隔符使用反斜线(\)，而Java的程序中反斜线表示转义字符，所以如果要使用反斜线应该用两条线(\\),或者只是用正斜线(/)。3.字节流...
JAVA高级特性总结
我爱大海V5的专栏
11-28 4990
1.File类可以完成对文件、目录的操作，新建、删除、重命名文件、目录等，但不能访问文件本身的内容，访问文件本身内容需要使用输入输出流，对于Java来说文件和目录都是一个概念。 2.Window的路径分隔符使用反斜线（\），而Java的程序中反斜线表示转义字符，所以如果要使用反斜线应该用两条线（\\）,或者只是用正斜线（/）。 3.字节流一InputStream和OutStream作为
Java高级特性 - 集合框架（1）
xu_tingfang的博客
05-20 1653
什么是泛型呢？类型参数，那什么又是类型参数呢？我们知道一个方法如果指定了一个字符串类型的参数，那方法的调用者就只能传递String类型的参数才能正确的使用这个方法了，否则就报错，其实泛型也是一样，只不过在这里泛型用在集合上，即指定集合中只能放某一种类型的元素你要往ATM机中存钱，就只能放毛爷爷，而不能放冥币，这就是泛型，指定只能用一种类型。
头歌——Java高级特性 - JDBC（上）
weixin_62440328的博客
12-15 2879
【代码】头歌——Java高级特性 - JDBC（上）
Educoder/头歌JAVA——JAVA高级特性：集合框架（1）
舟舟的博客
12-20 5653
Java集合框架对于数据的操作提供了良好的接口，是Java语言中非常普遍，也是非常重要的部分，熟练掌握很重要。 本实训将从整个集合框架的体系介绍重要的集合框架类，及其基本原理和使用方法。
头歌Educoder——Java高级特性 - Java反射
热门推荐
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
03-28 1万+
文章目录第1关：了解 Class 对象任务描述相关知识Class 对象三种获取Class类型的实例的方法三种方法获取的 Class 对象之间的区别编程要求测试说明代码样例Reflect_stu.javaReflect_run.javaPerson.java第2关：利用反射分析类的能力任务描述相关知识反射的基本概念Class 对象与反射之间的关系Class 的类结构利用反射分析类的能力编程要求测试说明代码样例Reflect_stu.javaReflect_run.javaPerson.java第3关：在运行时
头歌 Java高级特性 - IO流
weixin_74284876的博客
12-08 1956
字节是指一小组相邻的二进制数码。通常是8位作为一个字节。它是构成信息的一个小单位，并作为一个整体来参加操作，比字小，是构成字的单位。字节(Byte) 是一种计量单位，表示数据量的多少，它是计算机信息技术用于计量存储容量的一种计量单位.我们想象一下，给你一串二进制码，要你来分辨它是什么含义，是代表数字还是字母还是汉字，你能有效的分辨吗？显然不能，一般来说，我们是比较难以理解一串二进制码代表的含义的，而且一串二进制码是代表什么含义也无法很直观的表示出来。我们比较好识别的是文字，字母和符号。所以就有了。
Java高级特性
08-30
Java高级特性 Java高级特性是指Java语言中的一些高级特性，这些特性对于Java开发者来说是非常重要的。本文将详细介绍Java高级特性中的HashMap与HashTable的区别、随机数生成、字符串连接、线程安全类等知识点。 一...
详解Java高级特性之反射
08-19
"详解Java高级特性之反射" Java反射机制是Java语言中一个非常重要的概念，它允许程序在运行时检查和修改其他类的行为。Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意...
java高级特性增强
03-27
java多线程、反射、代理等基础知识详细介绍，通过此文档可快速进阶为中级工程师
Java 高级特性
02-28
一. 集合 框架 API 二、 实用类 三、 输入/输出、序列化和反射
java高级特性增强（源码展示）
01-27
本教程将深入探讨几个关键的Java高级特性，包括多线程、并发包下的队列、Java消息服务（JMS）、虚拟机（JVM）技术和反射与动态代理。下面将对这些主题进行详细的讲解。 1. **多线程**：Java提供了强大的多线程支持...
Java基础（6）- Java代码笔记3
最新发布
weixin_47062560的博客
08-30 566
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 7022
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 7482
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
操作系统原子操作
zzt_is_me的博客
08-28 5042
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

纣王家子迎新

有钱的捧个钱场，没钱的捧个人场

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值