类比java学习c++ 语言的100条代码对比示例--持续更新（会java的关注起来）

BigDataMLApplication

已于 2023-12-13 23:37:20 修改

阅读量941

点赞数 26

分类专栏： cpp java 文章标签： java 学习 c++

于 2023-12-10 14:05:11 首次发布

本文链接：https://blog.csdn.net/wang2leee/article/details/134907793

版权

java 同时被 2 个专栏收录

117 篇文章 2 订阅

订阅专栏

cpp

8 篇文章 0 订阅

订阅专栏

类比java学习c++一百条示例–持续更新（会java的关注起来）

文章目录

类比java学习c++一百条示例--持续更新（会java的关注起来）
1.c++ namespace 和java中什么类似区别举例
- 举例说明：
2.c++ 继承和java中什么类似
- 举例说明：
3.c++ class 和java中什么类似
- 举例说明：
4.c++ explicit 和java中什么类似
- 示例说明
5.c++ 重载和java中什么类似
- 举例说明：
6.c++ 运算符重载和java中什么类似
- 举例说明：
7.c++ template 和java中什么类似
- 举例说明：
8.c++ std::vector 和java中什么类似
- 举例说明：
9.c++ const 和java中什么类似
- 举例说明：
10.c++ std::function 和java中什么类似
- 举例说明：
11.c++ absl:Span 和java中什么类似
- 举例说明：
12.c++ std::initializer_list 和java中什么类似
- 举例说明：
13.c++ ->和java中什么类似
14.c++ delete和java中什么类似
15.c++ absl::flat_hash_map和java中什么类似
16.c++ virtual和java中什么类似
17.c++ std::unique_ptr和java中什么类似
18.c++ ~和java中什么类似
19.c++ nullptr和java中什么类似
20.c++ :和java中什么类似

1.c++ namespace 和java中什么类似区别举例

C++中的命名空间（namespace）和Java中的包（package）具有一定的相似性，它们都是用于组织和管理代码的机制。然而，它们在一些方面存在区别。

相似之处：

组织和管理代码：命名空间和包都用于组织代码，将相关的类、函数或变量放在一起，提供更好的代码结构和可维护性。
避免命名冲突：命名空间和包都可以避免不同模块或者不同开发人员之间的命名冲突，通过定义独特的命名空间或包名来确保唯一性。

区别之处：

语法差异：
- C++中的命名空间使用关键字 namespace 进行声明和定义，可以嵌套使用多个命名空间。命名空间的内容可以跨越多个源文件。
- Java中的包使用关键字 package 进行声明和定义，只能单层嵌套。通常一个包对应一个目录，并且包名与目录结构相对应。
导入方式：
- C++中，可以使用 using 或者 using namespace 来导入命名空间中的符号（如类、函数、变量），使其可以直接使用而无需限定命名空间。
- Java中，需要使用 import 关键字导入其他包中的类，才能在代码中直接使用。

举例说明：

C++中的命名空间示例：

#include <iostream>

namespace Math {
    int add(int a, int b) {
        return a + b;
    }
}

int main() {
    using namespace Math;  // 导入Math命名空间

    int result = add(3, 4);
    std::cout << "Result: " << result << std::endl;

    return 0;
}
//Result: 7

Java中的包示例：

package com.example.math;

public class Calculator {
    public static int add(int a, int b) {
        return a + b;
    }
}

import com.example.math.Calculator;

public class Main {
    public static void main(String[] args) {
        int result = Calculator.add(3, 4);
        System.out.println("Result: " + result);
    }
}

在上述示例中，C++中的命名空间 Math 包含了一个 add 函数，在 main() 函数中通过使用 using namespace Math 来导入命名空间，使得可以直接调用 add 函数。

而在Java中，我们定义了一个名为 com.example.math 的包，并在其中创建了一个 Calculator 类。在 Main 类中，通过使用 import com.example.math.Calculator 来导入 Calculator 类，从而可以在 main() 方法中直接使用该类的静态方法。

总结：命名空间和包都是用于组织和管理代码的机制，避免命名冲突。它们在语法和导入方式上存在一些差异，但在目的和用法上具有相似性。

2.c++ 继承和java中什么类似

C++中的继承（inheritance）和Java中的继承有一定的相似性，都是面向对象编程中的重要概念。它们用于实现类与类之间的关系，以及代码的重用和组织。

相似之处：

实现类之间的关系：继承用于描述一个类从另一个类派生而来的关系，称为父类（基类、超类）和子类（派生类）。
继承的特性：子类可以继承父类的属性和方法，并且可以添加自己的新属性和方法。
代码的重用和组织：通过继承，可以在子类中重用父类的代码，减少重复编写相同的代码。

区别之处：

语法差异：
- C++中使用冒号 : 来表示继承关系，并且支持多继承（一个类可以从多个父类继承）。
- Java中使用关键字 extends 表示继承关系，并且只支持单继承（一个类只能有一个直接父类）。
访问控制：
- C++中，默认情况下，派生类可以访问父类的公共成员和保护成员，但不能访问私有成员。继承方式有三种：public（公有继承）、protected（保护继承）和private（私有继承）。
- Java中，子类可以访问父类的公共成员和受保护成员，但不能访问父类的私有成员。Java没有像C++那样明确的继承方式控制。

举例说明：

C++中的继承示例：

#include <iostream>

// 父类
class Animal {
public:
    void eat() {
        std::cout << "Animal is eating." << std::endl;
    }
};

// 子类
class Dog : public Animal {  // 公有继承
public:
    void bark() {
        std::cout << "Dog is barking." << std::endl;
    }
};

int main() {
    Dog dog;
    dog.eat();  // 继承自父类
    dog.bark(); // 子类自己的方法

    return 0;
}

//
//Animal is eating.
//Dog is barking.

Java中的继承示例：

class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

class Dog extends Animal {  // 单继承
    public void bark() {
        System.out.println("Dog is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // 继承自父类
        dog.bark(); // 子类自己的方法
    }
}

在上述示例中，C++中的派生类 Dog 公有继承自父类 Animal，并且可以调用父类的 eat() 方法。同时，它还定义了自己的方法 bark()。在Java中，子类 Dog 继承自父类 Animal，同样可以调用父类的 eat() 方法，并且拥有自己的方法 bark()。

总结：C++和Java中的继承都是用于实现类之间的关系和代码的重用。它们在语法和访问控制上存在一些差异，C++支持多继承，而Java只支持单继承。

3.c++ class 和java中什么类似

C++中的类（class）和Java中的类具有相似性，它们都是面向对象编程的基本构造块，用于封装数据和行为。

相似之处：

封装数据和行为：类可以将相关的数据和函数（方法）组合在一起，形成一个独立的实体，用于表示某个概念或者对象。
面向对象特性：类是面向对象编程的核心，支持封装、继承和多态等面向对象特性。
实例化对象：通过类可以创建对象，每个对象都具有类定义的属性和行为。

区别之处：

语法差异：
- C++中使用关键字 class 来声明和定义类。类中的成员变量和成员函数默认情况下是私有的，需要使用访问修饰符（public、private、protected）进行访问控制。
- Java中同样使用关键字 class 来声明和定义类。类中的成员变量和成员函数默认情况下是包级私有的，需要使用访问修饰符（public、private、protected）进行访问控制。
继承差异：
- C++中支持单继承和多继承。子类可以从一个或多个父类派生而来。
- Java中只支持单继承。一个类只能直接继承自一个父类。

举例说明：

C++中的类示例：

#include <iostream>

class Circle {
private:
    double radius;

public:
    Circle(double r) : radius(r) {}

    double getArea() {
        return 3.14 * radius * radius;
    }
};

int main() {
    Circle circle(5.0);
    double area = circle.getArea();
    std::cout << "Area: " << area << std::endl;

    return 0;
}

Java中的类示例：

class Circle {
    private double radius;

    public Circle(double r) {
        radius = r;
    }

    public double getArea() {
        return 3.14 * radius * radius;
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle(5.0);
        double area = circle.getArea();
        System.out.println("Area: " + area);
    }
}

在上述示例中，C++中的类 Circle 封装了一个圆的半径，并提供了计算面积的方法。在Java中，同样定义了一个 Circle 类，封装了一个圆的半径，并提供了计算面积的方法。

总结：C++和Java中的类都用于封装数据和行为，并支持面向对象编程特性。它们在语法和继承方面存在一些差异，C++支持多继承，而Java只支持单继承。

4.c++ explicit 和java中什么类似

在C++中，explicit 关键字用于修饰类的单参数构造函数，以防止编译器进行隐式的类型转换。而在Java中，并没有直接对应的关键字或语法特性来达到相同的效果。

区别之处：

使用方式：
- C++中，可以将 explicit 关键字直接应用于单参数构造函数，用于防止隐式类型转换。
- Java中，并没有类似的关键字或语法来标记构造函数，以限制隐式类型转换。
类型转换机制：
- 在C++中，隐式类型转换是一种常见的行为，编译器会自动进行类型转换，使代码更灵活。而使用 explicit 关键字可以禁止这种隐式转换。
- 在Java中，类型转换需要显式地进行，不会自动发生隐式类型转换，因此通常情况下不需要类似于 explicit 的关键字来限制隐式类型转换。

虽然C++中的 explicit 关键字在防止隐式类型转换方面有其特殊的作用，但在Java中并没有直接的等价物。在Java中，开发者通常需要通过显示调用相应的转换方法或构造函数，来实现类型转换的需求。

由于Java和C++在类型转换机制上的差异，以及缺乏直接等价的语言特性，所以在Java中并不具备与C++中 explicit 关键字完全相同的功能。

示例说明

#include <iostream>

class MyInt {
public:
    explicit MyInt(int value) : m_value(value) {}

    int getValue() const {
        return m_value;
    }

private:
    int m_value;
};

void printValue(const MyInt& obj) {
    std::cout << obj.getValue() << std::endl;
}

int main() {
    MyInt obj1(10); // 直接调用构造函数进行对象初始化
    printValue(obj1);

    MyInt obj2 = 20; // 编译错误，禁止隐式类型转换
    printValue(obj2);

    MyInt obj3 = MyInt(30); // 显式调用构造函数进行对象初始化
    printValue(obj3);

    return 0;
}

//main.cpp: In function ‘int main()’:
//main.cpp:26:18: error: conversion from ‘int’ to non-scalar type ‘MyInt’ requested
//   26 |     MyInt obj2 = 20; // 编译错误，禁止隐式类型转换
//     |                  ^~

在上述示例中，我们定义了一个名为 MyInt 的类，并使用 explicit 关键字修饰了其构造函数。通过这样的方式，禁止了隐式类型转换，只允许使用显式方式来调用构造函数进行对象初始化。

5.c++ 重载和java中什么类似

C++中的函数重载（Function Overloading）和Java中的方法重载有一定的相似性，它们都允许在同一个类中定义多个同名但参数列表不同的方法。

相似之处：

同名方法：重载允许在同一个类中使用相同的方法名进行定义。
参数列表：重载要求方法的参数列表不同，可以是参数类型、参数个数或参数顺序的差异。

区别之处：

参数类型和返回值：
- C++中的函数重载仅依赖于参数的类型和数量，返回值类型不是重载的标准。因此，C++中的函数重载可以具有相同的返回类型，只要参数列表不同即可。
- Java中的方法重载不仅考虑参数的类型和数量，还包括返回值类型。因此，Java中的方法重载要求参数列表不仅在类型和数量上不同，返回值类型也必须不同。
编译器决策：
- C++中，函数重载的解析由编译器在编译期间完成，根据实际调用时的参数类型来决定调用哪个重载函数。
- Java中，方法重载的解析由编译器和虚拟机共同完成。编译器在编译期间会根据静态类型进行方法选择，而在运行期间则根据实际对象的动态类型来决定调用哪个重载方法。

举例说明：

C++中的函数重载示例：

#include <iostream>

void print(int num) {
    std::cout << "Printing an integer: " << num << std::endl;
}

void print(double num) {
    std::cout << "Printing a double: " << num << std::endl;
}

int main() {
    int intValue = 10;
    double doubleValue = 3.14;

    print(intValue);      // 调用print(int)
    print(doubleValue);   // 调用print(double)

    return 0;
}
//Printing an integer: 10
//Printing a double: 3.14

Java中的方法重载示例：

public class PrintUtils {
    public static void print(int num) {
        System.out.println("Printing an integer: " + num);
    }

    public static void print(double num) {
        System.out.println("Printing a double: " + num);
    }

    public static void main(String[] args) {
        int intValue = 10;
        double doubleValue = 3.14;

        print(intValue);      // 调用print(int)
        print(doubleValue);   // 调用print(double)
    }
}

在上述示例中，C++中的函数重载定义了两个同名但参数类型不同的函数 print，一个接受 int 类型参数，另一个接受 double 类型参数。在 main() 函数中，根据实际传递的参数类型，编译器会自动选择调用对应的重载函数。

而在Java中的方法重载示例中，我们在 PrintUtils 类中定义了两个同名但参数类型不同的静态方法 print，一个接受 int 类型参数，另一个接受 double 类型参数。在 main() 方法中，根据实际传递的参数类型，编译器会根据静态类型选择调用对应的重载方法。

总结：C++和Java中的函数/方法重载都允许在同一个类中定义多个同名但参数列表不同的函数/方法。它们在参数类型和返回值类型上存在一些差异，C++中只考虑参数类型和数量，而Java中还包括返回值类型。此外，C++中的函数重载由编译器在编译期间解析，而Java中的方法重载由编译器和虚拟机共同完成。

6.c++ 运算符重载和java中什么类似

C++中的运算符重载（Operator Overloading）和Java中的运算符重载类似。它们都允许对内置的操作符进行自定义行为，以适应特定类或对象的操作需求。

相似之处：

自定义操作符行为：运算符重载允许程序员为自定义的类类型或枚举类型定义操作符的行为，使其具有更直观和易用的语法。
语法形式：运算符重载的语法形式在C++和Java中都是通过定义特定的成员函数或静态函数来实现。

区别之处：

支持范围：
- C++中，运算符可以被重载为类的成员函数或非成员函数，包括一元操作符和二元操作符。
- Java中，并没有直接支持运算符重载的语法，只能使用已定义的操作符进行内置数据类型的操作。
运算符重载的方式：
- C++中，可以通过重载成员函数、非成员函数、友元函数等方式来实现运算符重载。
- Java中，并没有提供直接的语法来实现运算符重载，只能通过方法命名的约定来模拟部分运算符的功能，例如 add()、subtract() 等方法。

举例说明：

C++中的运算符重载示例：

#include <iostream>

class Vector {
public:
    int x;
    int y;

    Vector(int a, int b) : x(a), y(b) {}

    Vector operator+(const Vector& other) const {
        return Vector(x + other.x, y + other.y);
    }
};

int main() {
    Vector v1(2, 3);
    Vector v2(4, 5);
    Vector result = v1 + v2;

    std::cout << "Result: (" << result.x << ", " << result.y << ")" << std::endl;

    return 0;
}
//Result: (6, 8)

Java中的运算符重载模拟示例：

class Vector {
    private int x;
    private int y;

    public Vector(int a, int b) {
        x = a;
        y = b;
    }

    public Vector add(Vector other) {
        return new Vector(x + other.x, y + other.y);
    }
}

public class Main {
    public static void main(String[] args) {
        Vector v1 = new Vector(2, 3);
        Vector v2 = new Vector(4, 5);
        Vector result = v1.add(v2);

        System.out.println("Result: (" + result.x + ", " + result.y + ")");
    }
}

在上述示例中，C++中的类 Vector 重载了加法操作符 +，通过定义成员函数 operator+() 来实现向量的相加功能。

而在Java中，并没有直接支持运算符重载的语法。在示例中，我们使用了方法命名的约定，为 Vector 类添加了一个 add() 方法来模拟加法操作符的行为，从而实现向量的相加功能。

总结：C++和Java中都支持运算符重载的概念，但在语法和实现方式上存在差异。C++中提供了直接的语法来实现运算符重载，而Java中没有直接的语法，只能通过方法命名的约定来模拟部分运算符的功能。

7.c++ template 和java中什么类似

C++中的模板（Template）和Java中的泛型（Generics）具有一定的相似性，它们都用于实现参数化类型的概念，以增强代码的重用性和灵活性。

相似之处：

参数化类型：模板和泛型都允许在类或函数的定义中使用类型参数，使其能够适用于不同类型的数据。
类型安全：模板和泛型都提供了类型检查机制，确保在编译期间捕获类型错误，并提供更加类型安全的代码。

区别之处：

语法差异：
- C++中使用关键字 template 和尖括号 < > 来声明和定义模板。
- Java中使用尖括号 < > 来声明和定义泛型。
实例化方式：
- C++中，模板是在编译时进行实例化的，通过编译器根据实际使用情况生成对应的代码。
- Java中，泛型是在运行时进行类型擦除的，编译器会对泛型代码进行类型检查，但在运行时会将泛型类型信息擦除为原始类型。

举例说明：

C++中的模板示例：

#include <iostream>

template<typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    int result1 = add(3, 4);       // 隐式类型推断，实例化为 add<int>(3, 4)
    double result2 = add(1.5, 2.5); // 隐式类型推断，实例化为 add<double>(1.5, 2.5)

    std::cout << "Result 1: " << result1 << std::endl;
    std::cout << "Result 2: " << result2 << std::endl;

    return 0;
}
//Result 1: 7
//Result 2: 4

Java中的泛型示例：

public class Calculator<T> {
    public T add(T a, T b) {
        return a + b;   // 编译错误：运算符 '+' 不能应用于 T 类型
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator<Integer> calculator1 = new Calculator<>();
        int result1 = calculator1.add(3, 4);

        Calculator<Double> calculator2 = new Calculator<>();
        double result2 = calculator2.add(1.5, 2.5);

        System.out.println("Result 1: " + result1);
        System.out.println("Result 2: " + result2);
    }
}

在上述示例中，C++中的模板函数 add 可以接受相同类型的参数，并进行相加操作。在 main() 函数中，我们通过隐式类型推断调用了两次 add 函数，分别传入整数和浮点数。

而在Java中，我们定义了一个名为 Calculator 的泛型类，其中的 add 方法试图对两个泛型类型的对象进行相加操作。然而，由于Java的泛型类型擦除机制，在编译时会将 a 和 b 视为 Object 类型，因此无法使用运算符 + 进行操作。

总结：C++和Java中都提供了用于实现参数化类型的机制，即模板和泛型。它们在语法和实例化方式上存在一些差异，C++中的模板是在编译时进行实例化的，而Java中的泛型是在运行时进行类型擦除的。

8.c++ std::vector 和java中什么类似

C++中的 std::vector 和Java中的 ArrayList 类似，它们都是动态数组容器，用于存储和操作一组元素。

相似之处：

动态数组：std::vector 和 ArrayList 都提供了动态数组的功能，可以根据需要自动调整大小。
顺序访问：可以通过索引来访问容器中的元素，并支持添加、删除和修改元素的操作。
可变长度：可以随时向容器中添加或移除元素，而无需事先指定容器的大小。

区别之处：

语言和库：
- std::vector 是C++标准库中的容器，提供了一系列的成员函数和操作符重载来操作容器中的元素。
- ArrayList 是Java的集合框架中的一部分，在Java语言中直接使用，提供了一系列的方法来操作容器中的元素。
元素类型：
- std::vector 在C++中可以存储任意类型的元素，包括内置类型、自定义类型和指针等。
- ArrayList 在Java中只能存储对象类型的元素，不能直接存储基本数据类型（如int、char等），需要使用其对应的包装类。

举例说明：

C++中的 std::vector 示例：

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers;  // 创建一个存储整数的 vector

    // 添加元素
    numbers.push_back(1);
    numbers.push_back(2);
    numbers.push_back(3);

    // 访问元素
    std::cout << "First element: " << numbers[0] << std::endl;

    // 修改元素
    numbers[0] = 10;

    // 删除元素
    numbers.pop_back();

    // 遍历元素
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}
//First element: 1
//10 2

Java中的 ArrayList 示例：

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();  // 创建一个存储整数的 ArrayList

        // 添加元素
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);

        // 访问元素
        System.out.println("First element: " + numbers.get(0));

        // 修改元素
        numbers.set(0, 10);

        // 删除元素
        numbers.remove(numbers.size() - 1);

        // 遍历元素
        for (int num : numbers) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

在上述示例中，C++中的 std::vector 和Java中的 ArrayList 都用于存储一组整数。我们通过添加元素、访问元素、修改元素和删除元素等操作来展示它们的基本用法。

需要注意的是，C++中的 std::vector 可以存储任意类型的元素，而Java中的 ArrayList 只能存储对象类型的元素。如果需要存储基本数据类型（如int、char等），在Java中需要使用其对应的包装类（如Integer、Character等）进行封装。

9.c++ const 和java中什么类似

C++中的const关键字和Java中的final关键字类似，它们都用于声明常量（不可修改的变量）。尽管功能相似，但在语法和使用方式上存在一些区别。

相似之处：

常量声明：const关键字和final关键字都用于声明常量。
不可修改性：声明为const或final的变量在初始化后不能再被修改。
类成员常量：可以将const或final关键字用于类成员变量的声明，以指定其为常量。

区别之处：

语法差异：
- C++中使用关键字const来修饰常量，可以在变量声明时直接赋值或在构造函数中进行初始化。
- Java中使用关键字final来修饰常量，必须在变量声明时进行初始化。
编译期确定：
- C++中的const常量是在编译期间确定的，编译器会对其进行优化处理，并可能将其替换为实际的值。
- Java中的final常量也是在编译期间确定的，但并不进行优化处理，而是保留了对原始变量的引用。

举例说明：

C++中的const示例：

#include <iostream>

int main() {
    const int MAX_VALUE = 100;
    const int* ptr = &MAX_VALUE;

    // 错误示例：尝试修改const常量的值
    // MAX_VALUE = 200;

    std::cout << "MAX_VALUE: " << MAX_VALUE << std::endl;
    std::cout << "ptr: " << *ptr << std::endl;

    return 0;
}
//main.cpp: In function ‘int main()’:
//main.cpp:8:15: error: assignment of read-only variable ‘MAX_VALUE’
//    8 |     MAX_VALUE = 200;
//      |     ~~~~~~~~~~^~~~~

Java中的final示例：

public class Main {
    public static void main(String[] args) {
        final int MAX_VALUE = 100;
        final int[] arr = {1, 2, 3};

        // 错误示例：尝试修改final常量的值
        // MAX_VALUE = 200;

        // 错误示例：尝试修改final数组元素的值
        // arr[0] = 10;

        System.out.println("MAX_VALUE: " + MAX_VALUE);
        System.out.println("arr[0]: " + arr[0]);
    }
}

在上述示例中，C++中的const关键字用于声明一个名为MAX_VALUE的常量，并且不能再修改其值。同时，我们还可以通过指针来访问这个常量。

而在Java中，我们使用final关键字声明一个名为MAX_VALUE的常量，并且初始化为100。与C++类似，Java中的final常量也不能再修改其值。此外，我们还声明了一个final数组，并尝试修改数组元素的值，但由于声明为final，导致编译错误。

总结：C++中的const关键字和Java中的final关键字都用于声明常量，具有相似的功能。它们的语法和使用方式略有不同，C++中的const关键字更灵活，可以在变量声明时或构造函数中进行初始化；而Java中的final关键字必须在变量声明时进行初始化。此外，在编译期间，C++中的const常量可能会被优化处理，而Java中的final常量保留了对原始变量的引用。

10.c++ std::function 和java中什么类似

C++中的std::function和Java中的函数式接口（Functional Interface）类似，它们都用于定义可作为参数传递的函数对象。

相似之处：

函数对象：std::function和函数式接口都可以将函数或Lambda表达式封装成一个对象，使其能够作为参数传递给其他函数或方法。
可替代性：通过使用std::function或函数式接口，可以以更灵活的方式实现回调机制，将具体的行为传递给其他函数或方法。

区别之处：

语言特性：
- std::function是C++11引入的标准库类，提供了一种通用的函数封装机制，可以存储任意可调用对象（函数、函数指针、成员函数指针等）。
- 函数式接口是Java 8引入的特性，通过注解@FunctionalInterface来定义，限制接口只能包含一个抽象方法。
类型安全性：
- std::function在编译期间不会对函数的参数类型进行检查，因此使用时需要保证传递的函数对象与std::function的类型匹配。
- 函数式接口在Java中是类型安全的，编译器会对函数的参数类型进行检查，确保传递的函数对象与接口的抽象方法类型匹配。

举例说明：

C++中的std::function示例：

#include <iostream>
#include <functional>

void printMessage(const std::string& message) {
    std::cout << "Message: " << message << std::endl;
}

int main() {
    std::function<void(const std::string&)> func = printMessage;

    func("Hello, world!");

    return 0;
}
//Message: Hello, world!

Java中的函数式接口示例：

@FunctionalInterface
interface Printer {
    void print(String message);
}

public class Main {
    public static void main(String[] args) {
        Printer printer = message -> System.out.println("Message: " + message);

        printer.print("Hello, world!");
    }
}
//Message: Hello, world!

在上述示例中，C++中的std::function用于封装函数printMessage，并将其赋值给一个名为func的对象。通过调用func来实现回调。

而在Java中，我们定义了一个函数式接口Printer，其中包含一个抽象方法print。我们通过Lambda表达式来实现该接口，并将其赋值给一个名为printer的变量。通过调用printer.print来实现回调。

总结：std::function和函数式接口都用于实现可作为参数传递的函数对象。它们在语言特性和类型安全性上存在差异，C++中的std::function更通用，可以存储任意可调用对象，但在编译期间不会对函数参数类型进行检查；而Java中的函数式接口是类型安全的，只能包含一个抽象方法，并在编译期间对参数类型进行检查。

11.c++ absl:Span 和java中什么类似

C++中的absl::Span和Java中的java.util.List类似，它们都用于表示连续的一段数据。尽管功能相似，但在语法和使用方式上存在一些区别。

相似之处：

表示连续数据：absl::Span和List都可以表示一段连续的数据，并提供了相关操作方法。
可变长度：absl::Span和List都支持动态添加、删除和修改元素。

区别之处：

底层数据结构：
- absl::Span是一个**轻量级的非拥有式容器，**它只是对现有数据的包装，不负责管理底层数据的生命周期。
- List是Java集合框架中的接口，有多种实现类（如ArrayList、LinkedList），它们会自动管理底层数据的内存。
内存安全性：
- absl::Span不提供边界检查，用户需要自行确保访问不越界。
- List在访问或修改元素时会进行边界检查，以确保操作的安全性。

举例说明：

C++中的absl::Span示例：

#include <iostream>
#include "absl/types/span.h"

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    absl::Span<int> span(arr, 5);

    for (int num : span) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

Java中的List示例：

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        for (int num : list) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

在上述示例中，C++中使用absl::Span包装了一个名为arr的整型数组，并通过迭代遍历输出了其中的元素。

而在Java中，我们创建了一个ArrayList对象，并添加了一组整数元素。然后通过迭代遍历输出了列表中的元素。

需要注意的是，C++中的absl::Span只是对现有数据的包装，不会自动管理底层数据的内存；而Java中的List接口及其实现类会自动管理底层数据的内存。

12.c++ std::initializer_list 和java中什么类似

C++中的std::initializer_list和Java中的数组初始化类似，它们都用于在创建对象时提供一组初始值。尽管功能相似，但在语法和使用方式上存在一些区别。

相似之处：

提供初始值：std::initializer_list和数组都可以用于在对象创建时提供一组初始值。
顺序访问：可以通过索引来访问初始值，并进行相关操作。

区别之处：

类型和长度：
- std::initializer_list是C++中的模板类，可以接受任意类型的初始值，并且长度是固定的。
- 数组是Java中的特殊数据类型，只能存储相同类型的元素，并且长度也是固定的。
内存管理：
- std::initializer_list并不分配内存，它只是提供了对初始值的访问接口。
- 数组在Java中会自动分配内存，需要手动指定长度或使用动态数组。

举例说明：

C++中的std::initializer_list示例：

#include <iostream>

void printValues(std::initializer_list<int> values) {
    for (int value : values) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
}

int main() {
    printValues({1, 2, 3, 4, 5});

    return 0;
}

Java中的数组初始化示例：

public class Main {
    public static void printValues(int[] values) {
        for (int value : values) {
            System.out.print(value + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        printValues(new int[]{1, 2, 3, 4, 5});
    }
}

在上述示例中，C++中的std::initializer_list用于在函数调用时提供一组整数初始值，并通过迭代遍历输出了这些值。

而在Java中，我们使用数组来初始化方法参数，并通过迭代遍历输出了数组中的元素。

需要注意的是，C++中的std::initializer_list并不分配内存，它只是提供了对初始值的访问接口；而Java中的数组会自动分配内存来存储元素。

总结：std::initializer_list和数组都用于在对象创建时提供一组初始值。它们在类型、长度和内存管理等方面存在差异，std::initializer_list可以接受任意类型的初始值，长度是固定的，并不分配内存；而数组在Java中只能存储相同类型的元素，长度也是固定的，并会自动分配内存。

13.c++ ->和java中什么类似

C++中的箭头运算符（->）和Java中的点运算符（.）类似，它们都用于访问对象的成员。尽管功能相似，但在语法和使用方式上存在一些区别。

相似之处：

访问对象成员：箭头运算符和点运算符都用于访问对象的成员变量和方法。
对象引用：通过使用箭头运算符或点运算符，可以通过对象引用来访问对象的成员。

区别之处：

语法差异：
- C++中的箭头运算符(->)用于访问指针所指向的对象的成员，通常用于指针类型的对象。
- Java中的点运算符(.)用于访问对象的成员，包括实例对象和静态对象。
空指针处理：
- C++中的箭头运算符(->)可以在对象为空指针时进行处理，并避免出现空指针异常。
- Java中的点运算符(.)不支持空对象，如果对象为空，会抛出NullPointerException异常。

下面分别举例说明：

C++中的箭头运算符示例：

#include <iostream>

struct Person {
    std::string name;
    int age;

    void displayInfo() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main() {
    Person* person = new Person;
    person->name = "Alice";
    person->age = 25;

    person->displayInfo();

    delete person;

    return 0;
}

//Name: Alice, Age: 25

Java中的点运算符示例：

class Person {
    String name;
    int age;

    void displayInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "Alice";
        person.age = 25;

        person.displayInfo();
    }
}
//Name: Alice, Age: 25

在上述示例中，C++中的箭头运算符(->)用于通过指针person访问结构体Person对象的成员变量和成员方法。

而在Java中，我们使用点运算符(.)通过实例对象person来访问类Person的成员变量和成员方法。

需要注意的是，C++中的箭头运算符(->)可以在对象为空指针时进行处理，并避免出现空指针异常；而Java中的点运算符(.)不支持空对象，如果对象为空，会抛出NullPointerException异常。

总结：C++中的箭头运算符和Java中的点运算符都用于访问对象的成员。它们在语法和使用方式上存在差异，C++中的箭头运算符用于访问指针所指向的对象的成员，可以处理空指针；而Java中的点运算符用于访问对象的成员，不支持空对象，会抛出NullPointerException异常。

14.c++ delete和java中什么类似

C++中的delete运算符和Java中的垃圾回收（Garbage Collection）机制类似，它们都用于释放动态分配的内存资源。尽管功能相似，但在语法和使用方式上存在一些区别。

相似之处：

内存释放：delete运算符和垃圾回收机制都用于释放不再使用的动态分配的内存资源。
防止内存泄漏：通过释放不再需要的内存，可以避免内存泄漏问题。

区别之处：

使用方式：
- C++中的delete运算符是显式地由程序员手动调用来释放动态分配的内存。
- Java中的垃圾回收机制是由JVM自动管理的，无需程序员手动调用。
内存管理：
- C++中的delete运算符必须与对应的动态内存分配运算符（如new）配对使用，确保释放正确的内存块。
- Java中的垃圾回收机制会自动检测不再使用的对象，并在合适的时机进行内存回收，无需手动释放。

下面分别举例说明：

C++中的delete示例：

#include <iostream>

int main() {
    int* ptr = new int;  // 动态分配内存

    *ptr = 5;
    std::cout << "Value: " << *ptr << std::endl;

    delete ptr;  // 释放内存

    return 0;
}

//Value: 5

Java中的垃圾回收机制示例：

public class Main {
    public static void main(String[] args) {
        Integer value = new Integer(5);  // 创建对象

        System.out.println("Value: " + value);

        value = null;  // 不再使用对象

        // 在合适的时机，垃圾回收机制会自动回收不再使用的对象的内存
    }
}
//Value: 5

在上述示例中，C++中使用new运算符动态分配了一个整数的内存，并通过指针ptr访问该内存。然后通过delete运算符释放了该内存。

而在Java中，我们创建了一个Integer对象，并将其赋值给变量value。当不再需要该对象时，将变量value置为null，表示不再引用该对象。在适当的时候，垃圾回收机制会自动检测并回收不再使用的对象的内存。

需要注意的是，C++中的delete运算符必须与对应的动态内存分配运算符（如new）配对使用；而Java中的垃圾回收机制会自动检测不再使用的对象，并在合适的时机进行内存回收，无需手动释放。

总结：delete运算符和Java中的垃圾回收机制都用于释放动态分配的内存资源。它们在语法和使用方式上存在差异，C++中的delete运算符必须与对应的动态内存分配运算符（如new）配对使用；而Java中的垃圾回收机制会自动检测并回收不再使用的对象的内存，无需手动释放。

15.c++ absl::flat_hash_map和java中什么类似

C++中的absl::flat_hash_map和Java中的HashMap类似，它们都是用于实现键值对映射的数据结构。尽管功能相似，但在语法和使用方式上存在一些区别。

相似之处：

键值对映射：absl::flat_hash_map和HashMap都提供了将键与值关联起来的能力。
高效查找：它们都可以通过键快速查找对应的值。

区别之处：

语法差异：
- absl::flat_hash_map是C++中的数据结构，属于Google开源库ABSL（Abseil）的一部分。
- HashMap是Java标准库中的类，用于存储键值对映射。
内存管理：
- absl::flat_hash_map在C++中使用动态内存管理，并需要手动释放内存。
- HashMap在Java中使用垃圾回收机制，自动管理内存，无需手动释放。

下面分别举例说明：

C++中的absl::flat_hash_map示例：

#include <iostream>
#include <unordered_map>

int main() {
    absl::flat_hash_map<std::string, int> scores;
    scores["Alice"] = 95;
    scores["Bob"] = 80;

    std::cout << "Alice's score: " << scores["Alice"] << std::endl;

    return 0;
}

Java中的HashMap示例：

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> scores = new HashMap<>();
        scores.put("Alice", 95);
        scores.put("Bob", 80);

        System.out.println("Alice's score: " + scores.get("Alice"));
    }
}

//Alice's score: 95

在上述示例中，C++中使用absl::flat_hash_map创建了一个键为字符串、值为整数的映射，并通过索引操作符（[]）进行赋值和访问。

而在Java中，我们使用HashMap创建了一个键为字符串、值为整数的映射，并通过put方法进行赋值，通过get方法进行访问。

需要注意的是，C++中的absl::flat_hash_map需要手动管理内存，包括插入和删除键值对时的内存分配和释放；而Java中的HashMap使用垃圾回收机制自动管理内存，无需手动释放。

总结：absl::flat_hash_map和HashMap都是用于实现键值对映射的数据结构。它们在语法和使用方式上存在差异，absl::flat_hash_map是C++中的数据结构，需要手动管理内存；而HashMap是Java中的类，使用垃圾回收机制自动管理内存。

16.c++ virtual和java中什么类似

C++中的virtual关键字和Java中的方法重写（Method Overriding）类似，它们都用于实现多态性。尽管功能相似，但在语法和使用方式上存在一些区别。

相似之处：

多态性：virtual关键字和方法重写都允许在派生类中重新定义基类中的同名方法，以实现多态性。
动态绑定：通过virtual关键字或方法重写，可以在运行时根据对象的实际类型来调用适当的方法。

区别之处：

语法差异：
- virtual关键字是C++中的关键字，在基类中使用，用于声明可被子类重写的虚函数。
- Java中的方法重写是通过在子类中创建一个具有相同名称和参数的方法来实现的，无需使用特定的关键字进行声明。
默认行为：
- 在C++中，如果不使用virtual关键字声明基类的函数，派生类中的同名函数将会隐藏基类的函数，而不是重写。
- 在Java中，所有非静态方法默认都是可重写的，无需显式声明。

下面分别举例说明：

C++中的virtual示例：

#include <iostream>

class Animal {
public:
    virtual void makeSound() {
        std::cout << "Animal makes sound." << std::endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() override {
        std::cout << "Dog barks." << std::endl;
    }
};

int main() {
    Animal* animal = new Dog();
    animal->makeSound();  // 动态绑定，调用派生类的方法

    delete animal;

    return 0;
}
//Dog barks.

Java中的方法重写示例：

class Animal {
    public void makeSound() {
        System.out.println("Animal makes sound.");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.makeSound();  // 动态绑定，调用子类的方法
    }
}
//Dog barks.

在上述示例中，C++中使用virtual关键字在基类Animal中声明了虚函数makeSound()，而在派生类Dog中对该函数进行了重写。

而在Java中，我们通过在子类Dog中创建了一个具有相同名称和参数的方法来实现方法重写。

需要注意的是，在C++中，如果不使用virtual关键字声明基类的函数，派生类中的同名函数将会隐藏基类的函数，而不是重写；而在Java中，所有非静态方法默认都是可重写的。

总结：virtual关键字和方法重写都用于实现多态性。它们在语法和使用方式上存在差异，virtual关键字是C++中的关键字，用于声明可被子类重写的虚函数；而Java中的方法重写是通过在子类中创建一个具有相同名称和参数的方法来实现的。此外，在C++中，如果不使用virtual关键字声明基类的函数，派生类中的同名函数将会隐藏基类的函数，而在Java中，默认情况下所有非静态方法都是可重写的。

17.c++ std::unique_ptr和java中什么类似

C++中的std::unique_ptr和Java中的自动内存管理机制类似，它们都用于管理动态分配的内存资源。尽管功能相似，但在语法和使用方式上存在一些区别。

相似之处：

内存管理：std::unique_ptr和Java的自动内存管理机制都用于自动管理动态分配的内存资源。
避免内存泄漏：通过使用std::unique_ptr或Java的自动内存管理机制，可以避免因忘记释放内存而导致的内存泄漏问题。

区别之处：

语法差异：
- std::unique_ptr是C++标准库提供的智能指针，用于管理动态分配的对象。
- Java的自动内存管理机制是通过垃圾回收器（Garbage Collector）实现的，无需手动管理指针。
所有权转移：
- std::unique_ptr具有所有权转移的特性，即它可以拥有并管理一个对象，并在其生命周期结束时自动释放所占用的内存。
- Java的自动内存管理机制没有明确的所有权概念，通过垃圾回收器来确定对象是否可被回收。

下面分别举例说明：

C++中的std::unique_ptr示例：

#include <iostream>
#include <memory>

class Person {
public:
    Person(const std::string& name) : name_(name) {
        std::cout << "Person " << name_ << " created." << std::endl;
    }

    ~Person() {
        std::cout << "Person " << name_ << " destroyed." << std::endl;
    }

    void displayInfo() const {
        std::cout << "Name: " << name_ << std::endl;
    }

private:
    std::string name_;
};

int main() {
    std::unique_ptr<Person> person(new Person("Alice"));
    person->displayInfo();

    // 不需要手动释放内存，std::unique_ptr在作用域结束时会自动释放所占用的内存

    return 0;
}

//Person Alice created.
//Name: Alice
//Person Alice destroyed.

Java中的自动内存管理示例：

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
        System.out.println("Person " + name + " created.");
    }

    public void displayInfo() {
        System.out.println("Name: " + name);
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("Person " + name + " destroyed.");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice");
        person.displayInfo();

        // 不需要手动释放内存，Java的垃圾回收器会在适当的时机自动回收不再使用的对象

        person = null;  // 将person引用设为null，表示不再引用该对象

        // 在合适的时机，垃圾回收器会自动回收不再使用的对象的内存

        // 可以通过System.gc()主动触发垃圾回收，但并不保证立即执行
         System.gc();

    }
}
//Person Alice created.
//Name: Alice
//Person Alice destroyed.

在上述示例中，C++中使用std::unique_ptr来管理动态分配的Person对象，并在作用域结束时自动释放所占用的内存。

而在Java中，我们创建了一个Person对象，并将其赋值给变量person。当不再需要该对象时，将变量person置为null，表示不再引用该对象。在适当的时机，垃圾回收器会自动检测并回收不再使用的对象的内存。

需要注意的是，std::unique_ptr具有所有权转移的特性，在使用过程中必须谨慎处理所有权的转移和释放；而Java的自动内存管理机制没有明确的所有权概念，通过垃圾回收器来确定对象是否可被回收。

总结：std::unique_ptr和Java的自动内存管理机制都用于管理动态分配的内存资源。它们在语法和使用方式上存在差异，std::unique_ptr是C++标准库提供的智能指针，具有所有权转移的特性；而Java的自动内存管理机制通过垃圾回收器实现，无需手动管理指针。

18.c++ ~和java中什么类似

在C++中，~用于表示析构函数（Destructor），而在Java中，没有直接对应的符号来表示析构函数。这是C++和Java之间的一个区别。

相似之处：

析构函数：C++中的析构函数和Java中的垃圾回收机制都用于释放对象所占用的资源，并进行清理工作。

区别之处：

语法差异：
- 在C++中，析构函数使用波浪号 ~ 后跟类名的方式定义，例如 ~ClassName()。
- 在Java中，没有直接对应的符号来表示析构函数。Java使用垃圾回收机制自动管理对象的生命周期，无需手动编写析构函数。
触发时机：
- C++中的析构函数是在对象销毁时被调用的，可以显式地控制对象的销毁。
- Java中的垃圾回收器决定了对象何时被销毁，程序员无法精确地控制对象的销毁时机。

下面分别举例说明：

C++中的析构函数示例：

#include <iostream>

class MyClass {
public:
    MyClass() {
        std::cout << "Constructor called." << std::endl;
    }

    ~MyClass() {
        std::cout << "Destructor called." << std::endl;
    }
};

int main() {
    {
        MyClass obj;  // 创建一个MyClass对象

        // 在作用域结束时，析构函数会被调用，输出 "Destructor called."
    }

    return 0;
}
//Constructor called.
//Destructor called.

Java中的垃圾回收机制示例：

class MyClass {
    public MyClass() {
        System.out.println("Constructor called.");
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("Finalize method called.");
    }
}

public class Main {
    public static void main(String[] args) {
        {
            MyClass obj = new MyClass();  // 创建一个MyClass对象

            // 在适当的时机，垃圾回收器会自动回收不再使用的对象，并调用finalize方法
        }

        // 垃圾回收器在合适的时机自动回收对象，并调用finalize方法

        // 可以通过System.gc()主动触发垃圾回收，但并不保证立即执行
         System.gc();
    }
}
//Constructor called.

在上述示例中，C++中的析构函数~MyClass()在对象销毁时被调用，在作用域结束时输出"Destructor called."。

而在Java中，我们没有直接定义析构函数。相反，Java的垃圾回收器会自动检测并回收不再使用的对象，并在适当的时候调用对象的finalize方法进行清理工作。在示例中，当不再引用MyClass对象时，垃圾回收器会在适当的时机自动回收该对象，并调用finalize方法。

需要注意的是，Java中的垃圾回收器决定了对象何时被销毁，程序员无法精确地控制对象的销毁时机；而C++中的析构函数可以在对象销毁前进行一些特定的清理工作，并可以显式地控制对象的销毁。

总结：C++中使用~表示析构函数，用于在对象销毁时进行资源释放和清理工作；而Java中没有直接对应的符号来表示析构函数，使用垃圾回收机制自动管理对象的生命周期。这是C++和Java之间的一个区别。

19.c++ nullptr和java中什么类似

C++中的nullptr和Java中的null类似，它们都用于表示空指针。尽管功能相似，但在语法和使用方式上存在一些区别。

相似之处：

空指针：nullptr和null都表示一个无效的指针或引用，即不指向任何有效的对象或数据。
用于判断：可以使用nullptr或null来检查指针或引用是否为空，以避免访问空指针而导致的错误。

区别之处：

语法差异：
- nullptr是C++11引入的关键字，用于表示空指针。
- null是Java中的保留关键字，用于表示空引用。
类型系统：
- C++中的指针类型可以直接赋值为nullptr，并且可以与其他指针类型进行比较。
- Java中的引用类型可以直接赋值为null，并且可以与其他引用类型进行比较。

下面分别举例说明：

C++中的nullptr示例：

#include <iostream>

int main() {
    int* ptr = nullptr;

    if (ptr == nullptr) {
        std::cout << "Pointer is null." << std::endl;
    }

    return 0;
}
//Pointer is null.

Java中的null示例：

public class Main {
    public static void main(String[] args) {
        String str = null;

        if (str == null) {
            System.out.println("Reference is null.");
        }
    }
}
//Reference is null.

在上述示例中，C++中使用nullptr初始化一个指向int类型的指针，并使用条件语句检查该指针是否为空。

而在Java中，我们将一个字符串引用str赋值为null，并使用条件语句检查该引用是否为空。

需要注意的是，C++中的指针类型可以直接赋值为nullptr，并且可以与其他指针类型进行比较；而Java中的引用类型可以直接赋值为null，并且可以与其他引用类型进行比较。

总结：nullptr和null都表示空指针或空引用。它们在语法和使用方式上存在差异，nullptr是C++11引入的关键字，用于表示空指针；null是Java中的保留关键字，用于表示空引用。此外，C++中的指针类型可以直接赋值为nullptr，并且可以与其他指针类型进行比较；而Java中的引用类型可以直接赋值为null，并且可以与其他引用类型进行比较。

20.c++ :和java中什么类似

C++中的:和Java中的冒号 : 有不同的用法和含义。

C++中的:主要用于以下几个方面：

命名空间限定符：

在C++中，::（双冒号）被用作命名空间限定符，用于访问命名空间中的成员。

示例：

#include <iostream> 

namespace MyNamespace {
    int num = 42;
}

int main() {
    std::cout << MyNamespace::num << std::endl;  // 使用 :: 访问 MyNamespace 中的 num
    return 0;
}
//42

成员初始化列表：

在C++的构造函数中，使用初始化列表语法来对类的成员变量进行初始化。

示例：

#include <iostream>

class MyClass {
private:
    int num;
    double value;

public:
    MyClass(int n, double v) : num(n), value(v) { }  // 使用 : 进行成员初始化

    int getNum() const {
        return num;
    }

    double getValue() const {
        return value;
    }
};

int main() {
    MyClass obj(42, 3.14);
    std::cout << "num: " << obj.getNum() << ", value: " << obj.getValue() << std::endl;

    return 0;
}
//num: 42, value: 3.14

继承关系：

在C++中，使用冒号 : 来指示派生类继承基类，同时还可以指定继承方式（public、protected或private）。

示例：

#include <iostream>

class BaseClass {
public:
    void baseMethod() {
        std::cout << "BaseClass method called." << std::endl;
    }
};

class DerivedClass : public BaseClass {
public:
    void derivedMethod() {
        std::cout << "DerivedClass method called." << std::endl;
    }
};

int main() {
    DerivedClass obj;
    obj.baseMethod();     // 调用继承自基类的方法
    obj.derivedMethod();  // 调用派生类自己的方法

    return 0;
}

Java中的冒号 : 主要用于以下几个方面：

在 Java 中，冒号 : 主要用于以下几个方面：

增强 for 循环（Enhanced For Loop）：

在 Java 中，使用冒号 : 来遍历数组或集合中的元素。

示例：

int[] numbers = {1, 2, 3, 4, 5};

for (int num : numbers) {  // 使用 : 遍历数组中的元素
    System.out.println(num);
}

分隔符（Separator）：

在 Java 中，冒号 : 可以作为分隔符使用，例如在 switch 语句中的 case 分支和 default 分支之间。

示例：

int dayOfWeek = 1;

switch (dayOfWeek) {
    case 1:
        System.out.println("Monday");
        break;
    case 2:
        System.out.println("Tuesday");
        break;
    default:
        System.out.println("Other day");
}

标签语句（Label Statement）：

在 Java 中，可以使用冒号 : 定义标签语句，用于在循环或跳转语句中指定目标位置。

示例：

public class Main {
    public static void main(String[] args) {
        outerLoop:
        for (int i = 0; i < 5; i++) {
            innerLoop:
            for (int j = 0; j < 5; j++) {
                if (j == 3) {
                    break outerLoop;  // 使用 : 指定跳出外层循环的位置
                }
                System.out.println("i: " + i + ", j: " + j);
            }
        }
    }
}
//i: 0, j: 0
//i: 0, j: 1
//i: 0, j: 2