Java和C++的构造函数（的区别）

Brendan_001

已于 2023-11-01 11:57:26 修改

阅读量524

点赞数 8

文章标签： java 开发语言

于 2023-11-01 11:31:08 首次发布

本文链接：https://blog.csdn.net/weixin_63490470/article/details/134157276

版权

Java和C++的构造函数（的区别）

C++中的构造函数

在C++中，构造函数是一种特殊的成员函数，它在创建类的对象时自动调用。构造函数的名称与类的名称相同，它可以有参数，也可以没有参数。构造函数主要用于初始化对象的数据成员。

默认构造函数

如果你没有为类定义任何构造函数，编译器会自动为你生成一个默认的无参数构造函数。但是，如果你定义了一个或多个参数化构造函数，编译器就不会生成默认构造函数，除非你明确地定义了一个。以下是一个C++类的例子，它有一个默认构造函数：

cpp
class Box {
public:
    double length;
    double breadth;
    double height;

    // 默认构造函数
    Box() : length(1.0), breadth(1.0), height(1.0) {}

    double volume() {
        return length * breadth * height;
    }
};

int main() {
    Box box1;  // 使用默认构造函数创建对象
    cout << "Volume of box1: " << box1.volume() << endl;
    return 0;
}

在这个例子中，Box类有一个默认构造函数，它没有参数，将length、breadth和height初始化为1.0。

参数化构造函数

在C++中，你可以定义参数化构造函数，它接受一个或多个参数。参数化构造函数提供了一种方式，可以在创建对象时设置对象的状态。以下是一个C++类的例子，它有一个参数化构造函数：

cpp
class Box {
public:
    double length;
    double breadth;
    double height;

    // 参数化构造函数
    Box(double l, double b, double h) : length(l), breadth(b), height(h) {}

    double volume() {
        return length * breadth * height;
    }
};

int main() {
    Box box2(3.3, 1.2, 1.5);  // 使用参数化构造函数创建对象
    cout << "Volume of box2: " << box2.volume() << endl;
    return 0;
}

在这个例子中，Box类有一个参数化构造函数，它接受三个参数，用于初始化length、breadth和height。

复制构造函数

C++还支持复制构造函数，它用于创建一个新对象作为现有对象的副本。复制构造函数通常接受一个对同类型对象的引用作为参数。以下是一个C++类的例子，它有一个复制构造函数：

cpp
class Box {
public:
    double length;
    double breadth;
    double height;

    // 构造函数定义
    Box(double l=1.0, double b=1.0, double h=1.0) {
        length = l;
        breadth = b;
        height = h;
    }

    // 复制构造函数定义
    Box(const Box& box) {
        length = box.length;
        breadth = box.breadth;
        height = box.height;
    }

    double volume() {
        return length * breadth * height;
    }
};

int main() {
    Box box1(3.3, 1.2, 1.5);  // 使用构造函数创建对象
    Box box2 = box1;  // 使用复制构造函数创建对象
    cout << "Volume of box1: " << box1.volume() << endl;
    cout << "Volume of box2: " << box2.volume() << endl;
    return 0;
}

在这个例子中，Box类有一个复制构造函数，它接受一个对Box对象的引用作为参数，然后复制该对象的数据成员。

委托构造函数

从C++11开始，C++支持委托构造函数，这意味着一个构造函数可以调用同一个类中的另一个构造函数。这可以避免在多个构造函数中重复相同的初始化代码。以下是一个C++类的例子，它使用委托构造函数：
cpp

class Box {
public:
    double length;
    double breadth;
    double height;

    // 主构造函数
    Box(double l, double b, double h) : length(l), breadth(b), height(h) {}

    // 委托构造函数
    Box() : Box(1.0, 1.0, 1.0) {}
    Box(double side) : Box(side, side, side) {}

    double volume() {
        return length * breadth * height;
    }
};

int main() {
    Box box1;  // 使用默认构造函数创建对象
    Box box2(3.0);  // 使用委托构造函数创建立方体对象
    cout << "Volume of box1: " << box1.volume() << endl;
    cout << "Volume of box2: " << box2.volume() << endl;
    return 0;
}

在这个例子中，Box类有一个主构造函数，它接受三个参数，用于初始化length、breadth和height。此外，还有两个委托构造函数，它们分别调用主构造函数来初始化对象。

Java中的构造函数

在Java中，构造函数也是一种特殊的方法，它在创建类的对象时自动调用。构造函数的名称与类的名称相同，它可以有参数，也可以没有参数。构造函数主要用于初始化对象的状态。

默认构造函数

在Java中，如果你没有为类定义任何构造函数，编译器会自动为你生成一个默认的无参数构造函数。但是，如果你定义了一个或多个参数化构造函数，编译器就不会生成默认构造函数，除非你明确地定义了一个。

以下是一个Java类的例子，它有一个默认构造函数：
java

public class Box {
    double length;
    double breadth;
    double height;

    // 默认构造函数
    Box() {
        length = 1.0;
        breadth = 1.0;
        height = 1.0;
    }

    double volume() {
        return length * breadth * height;
    }

    public static void main(String[] args) {
        Box box1 = new Box();  // 使用默认构造函数创建对象
        System.out.println("Volume of box1: " + box1.volume());
    }
}

在这个例子中，Box类有一个默认构造函数，它没有参数，将length、breadth和height初始化为1.0。

参数化构造函数

在Java中，你也可以定义参数化构造函数，它接受一个或多个参数。参数化构造函数提供了一种方式，可以在创建对象时设置对象的状态。以下是一个Java类的例子，它有一个参数化构造函数：

java

public class Box {
    double length;
    double breadth;
    double height;

    // 参数化构造函数
    Box(double l, double b, double h) {
        length = l;
        breadth = b;
        height = h;
    }

    double volume() {
        return length * breadth * height;
    }

    public static void main(String[] args) {
        Box box2 = new Box(3.3, 1.2, 1.5);  // 使用参数化构造函数创建对象
        System.out.println("Volume of box2: " + box2.volume());
    }
}

在这个例子中，Box类有一个参数化构造函数，它接受三个参数，用于初始化length、breadth和height。

构造函数重载

在Java中，你可以为同一个类定义多个构造函数，这被称为构造函数重载。构造函数重载允许你根据不同的参数列表创建对象，从而提供更多的灵活性。
以下是一个Java类的例子，它有多个构造函数：
java

public class Box {
    double length;
    double breadth;
    double height;

    // 默认构造函数
    Box() {
        length = 1.0;
        breadth = 1.0;
        height = 1.0;
    }

    // 参数化构造函数
    Box(double l, double b, double h) {
        length = l;
        breadth = b;
        height = h;
    }

    // 构造函数重载，接受一个参数
    Box(double side) {
        length = side;
        breadth = side;
        height = side;
    }

    double volume() {
        return length * breadth * height;
    }

    public static void main(String[] args) {
        Box box1 = new Box();  // 使用默认构造函数创建对象
        Box box2 = new Box(3.3, 1.2, 1.5);  // 使用参数化构造函数创建对象
        Box box3 = new Box(2.0);  // 使用重载的构造函数创建立方体对象
        System.out.println("Volume of box1: " + box1.volume());
        System.out.println("Volume of box2: " + box2.volume());
        System.out.println("Volume of box3: " + box3.volume());
    }
}

在这个例子中，Box类有三个构造函数：一个默认构造函数，一个参数化构造函数，以及一个接受一个参数的重载构造函数。这个重载构造函数用于创建立方体对象，它将length、breadth和height都初始化为相同的值。
通过构造函数重载，我们可以根据不同的需求和参数创建对象。这使得类的实例化更加灵活，同时也使得代码更加简洁和易于维护。
这些是C++和Java中构造函数的高级概念和用法。尽管这两种语言在语法和特性上有所不同，但它们的基本概念是相同的：构造函数是用于初始化新创建的对象的特殊方法。通过定义参数化构造函数、默认构造函数和重载构造函数，我们可以更灵活地初始化对象。

C++和Java构造函数之间的主要区别：

语法：C++和Java的构造函数语法略有不同。在C++中，构造函数的名称与类名相同，没有返回类型。在Java中，构造函数的名称也与类名相同，但是它们被视为特殊类型的方法，没有返回类型。

默认构造函数：在C++和Java中，如果没有为类定义任何构造函数，编译器都会自动生成一个默认的无参数构造函数。但是，如果你为类定义了一个或多个参数化构造函数，C++编译器不会生成默认构造函数，除非你明确地定义了一个。而在Java中，即使你定义了一个或多个参数化构造函数，编译器仍然会生成默认构造函数。

初始化列表：C++支持初始化列表，它允许在构造函数中直接初始化数据成员和基类。Java没有这个特性，所有的初始化都在构造函数体中进行。

委托构造函数：从C++11开始，C++支持委托构造函数，这意味着一个构造函数可以调用同一个类中的另一个构造函数。在Java中，一个构造函数也可以调用同一个类中的另一个构造函数，使用this()语法。

析构函数：C++有析构函数，它在对象被销毁时自动调用，通常用于释放资源。Java没有析构函数，但有一个叫做finalize的方法，它在垃圾收集器决定回收对象的内存之前被调用。然而，finalize方法的使用并不推荐，因为它的行为可能会因Java版本和垃圾收集器的实现而变化。

构造函数的访问修饰符：在Java中，构造函数可以有访问修饰符，例如public、private和protected。在C++中，构造函数也可以有访问修饰符。

复制构造函数：C++有复制构造函数，它用于创建一个新对象作为现有对象的副本。Java没有复制构造函数这个概念，但你可以通过其他方式复制一个对象，例如通过实现clone方法。

移动构造函数：C++11引入了移动语义和移动构造函数，它允许资源的所有权从一个对象转移到另一个对象，从而提高效率。Java没有这个概念。

构造函数的继承：在C++中，子类不会继承父类的构造函数。但是，从C++11开始，子类可以使用using语句来显式地继承父类的构造函数。在Java中，子类也不会继承父类的构造函数，但子类的构造函数可以使用super关键字来调用父类的构造函数。

异常处理：在C++中，构造函数和析构函数都可以抛出异常。但是，如果析构函数抛出异常，这通常被认为是一种糟糕的编程实践，因为析构函数通常在对象销毁或清理资源时调用，此时抛出异常可能会导致资源泄露或其他问题。在Java中，构造函数可以抛出异常，但finalize方法（类似于析构函数）不能抛出被检查的异常。

对象的创建：在C++中，对象可以在堆（使用new）或栈（直接声明）上创建。构造函数在对象创建时自动调用。在Java中，对象只能在堆上创建（使用new），并且构造函数在对象创建时自动调用。

对象的销毁：在C++中，如果对象在堆上创建，需要使用delete来销毁对象并释放内存，此时会调用析构函数。如果对象在栈上创建，当对象超出范围时，会自动销毁对象并调用析构函数。在Java中，对象的销毁由垃圾收集器自动处理，不需要（也不能）手动销毁对象。

构造函数的调用：在C++中，可以使用初始化列表、赋值语句或直接调用来调用构造函数。在Java中，构造函数只能通过new操作符来调用。

构造函数的重载：C++和Java都支持构造函数的重载，即在同一个类中定义多个名称相同但参数列表不同的构造函数。但是，Java对构造函数的重载有一些额外的规则，例如，不能有两个构造函数只在参数的类型顺序上有所不同。

构造函数的可见性：在Java中，构造函数可以被声明为public、protected、private或默认（包私有），这为类的设计者提供了更大的灵活性，可以控制哪些类或对象可以创建类的实例。例如，如果一个类的构造函数被声明为private，那么只有类自己的方法可以创建这个类的实例。这是实现单例模式的一种常见方法。在C++中，构造函数也可以被声明为public、protected或private，具有类似的效果。

参数默认值：在C++中，构造函数的参数可以有默认值。这意味着如果在创建对象时没有提供某些参数，那么将使用这些参数的默认值。这提供了一种灵活的方式来初始化对象。在Java中，构造函数的参数不能有默认值。如果你想在不提供某些参数的情况下创建对象，你需要创建一个额外的无参数构造函数或者提供少量参数的构造函数。

构造函数和继承：在C++和Java中，子类不会继承父类的构造函数。但是，子类的构造函数通常需要调用父类的一个构造函数来确保父类部分的正确初始化。在C++中，这是通过在子类构造函数的初始化列表中调用父类构造函数来完成的。在Java中，这是通过在子类构造函数的第一行使用super关键字来完成的。

构造函数和多态：在C++和Java中，构造函数都不是虚函数，也不能被覆盖。这是因为在调用构造函数时，对象的动态类型总是与构造函数所在的类相匹配。换句话说，你不能通过父类引用或指针来调用子类的构造函数，因此没有必要（也没有意义）将构造函数声明为虚函数。

C++中的构造函数和异常处理

在C++中，构造函数可以抛出异常。当构造函数抛出异常时，对象的创建被中止，已经构造的部分将被销毁。这意味着在构造函数中，你需要确保在抛出异常之前正确地清理已经分配或初始化的资源。
以下是一个C++类的例子，它的构造函数可能抛出异常：
cpp

class MyClass {
public:
    int* data;

    MyClass(int size) {
        data = new int[size];
        if (size < 0) {
            delete[] data;
            throw std::invalid_argument("Size must be non-negative");
        }
    }

    ~MyClass() {
        delete[] data;
    }
};

int main() {
    try {
        MyClass obj(-1);
    } catch (const std::invalid_argument& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }
    return 0;
}

在这个例子中，MyClass的构造函数接受一个size参数。如果size为负数，构造函数将抛出一个std::invalid_argument异常。在抛出异常之前，我们需要确保已经分配的data数组被正确地删除。
Java中的构造函数和异常处理
在Java中，构造函数也可以抛出异常。当构造函数抛出异常时，对象的创建被中止。与C++不同，Java有垃圾回收机制，因此在抛出异常之前，你不需要手动清理已经分配或初始化的资源。但是，你可能需要关闭已经打开的文件、网络连接等资源。
以下是一个Java类的例子，它的构造函数可能抛出异常：
java

public class MyClass {
    int[] data;

    MyClass(int size) throws IllegalArgumentException {
        if (size < 0) {
            throw new IllegalArgumentException("Size must be non-negative");
        }
        data = new int[size];
    }

    public static void main(String[] args) {
        try {
            MyClass obj = new MyClass(-1);
        } catch (IllegalArgumentException e) {
            System.out.println("Caught exception: " + e.getMessage());
        }
    }
}

在这个例子中，MyClass的构造函数接受一个size参数。如果size为负数，构造函数将抛出一个IllegalArgumentException异常。