标签: default-constructor

可能有人请解释一下何谓以下？

如果类定义成员变量且没有其他构造函数,则必须定义默认构造函数.否则编译器会为你做这件事,非常糟糕.

他们所谓的"严重"是什么？

考虑以下代码:

// Create a Item oject
item item = new item();

编译器错误消息:

错误 - 找不到符号 - 构造函数项();

课程item:

public class item
{
    // Attributes
    private String Itemcode;
    private String Itemname;
    private String Description;
    private String Style;
    private String Finish;
    private float  Unitprice;
    private float  Stock;
    private String Suppliercode;
    private String Suppliername;
    private String Address;

    public item(String ItemcodeIn, String ItemnameIn, String DescriptionIn,
                String StyleIn, String FinishIn, float UnitpriceIn, float StockIn,
                String SuppliercodeIn,
                String SuppliernameIn, String AddressIn)
    {
        Itemcode = …

我有一个类与另一个类的成员变量:

class MeasurementUnit {
private:
    MeasurementMultiplier _multiplier;

实际上我不需要一个默认的构造函数MeasurementMultiplier,因为实际上我会用参数初始化MeasurementMultiplier(a,b,c),我会 - 但不能直接:

C2864: 'MeasurementUnit::_multiplier' :
only static const integral data members can be initialized within a class

所以我需要默认的构造函数,没有它不编译 error: C2512: 'MeasurementUnit' : no appropriate default constructor available

我可以避免需要默认构造函数吗？

我对以下代码有一个简短的问题

http://www.androidhive.info/2013/09/android-sqlite-database-with-multiple-tables/

这里使用了两个构造函数，一个带有id，另一个没有-我不明白为什么。有什么好处？

我已经读过这个线程：

为什么此类有两个构造函数？

我能理解的答案是，我可以创建一个不带id的Tag，但我试图理解，如何知道它将使用哪个构造函数？仅仅是根据参数的数量？

    public class Tag {

    int id;
    String tag_name;

    // constructors
    public Tag() {

    }

    public Tag(String tag_name) {
        this.tag_name = tag_name;
    }

    public Tag(int id, String tag_name) {
        this.id = id;
        this.tag_name = tag_name;
    }

    // ...     
}

我在Java编译器中长大,只要类中没有显式构造函数,就会自动生成一个默认构造函数; 当我有任何显式构造函数时不生成.

据我所知,构造函数定义了所需的依赖项,属性定义了可选的依赖项(很可能是默认值...由构造函数设置).如果你坚持上述规则(我在职业生涯中根据经验选择),那么在面向对象的代码中能够在<init>() 没有定义时调用是完全错误的.

这是一个我尝试过的简单测试,并注意到即使使用显式构造函数,也可以很容易地实例化没有args的对象.如何在编译时或运行时在标有???？的行上使该程序失败？

class TestGroovy {
    private final String name
    TestGroovy(String name) {
        this.name = name
    }

    static void main(String[] args) {
        testStatic()
        println()
        testDynamic()
        println()
        testReflection()
    }

    @groovy.transform.CompileStatic
    static void testStatic() {
        println new TestGroovy("static");
        println "compile error"
        // Groovyc: [Static type checking] - Cannot find matching method TestGroovy#<init>().
        // Please check if the declared type is right and if the method exists.
        //println new TestGroovy(); // correct
    }

    static void testDynamic() …

我有这个非常简单的课程

class myclass {

public:
    int id;
    double x, y, z;

    myclass() = default; // If I omit this line I get an error
    myclass(int ID, double X, double Y, double Z): id(ID), x(X), y(Y), z(Z) {};
};

如果我省略了该行的行myclass() = default;,然后尝试创建一个对象

#include <vector>
using namespace std;
int main() {

    int ID = 0;
    double X = 1.0, Y = 2.0, Z = 3.0;
    vector<myclass> a_vector(10);

    myclass an_object(ID,X,Y,Z);

    return 0;
}

我收到一个错误no matching function for call to ‘myclass::myclass() …

所有类至少有一个构造函数.如果类没有显式声明任何类,那么Java编译器会自动提供一个无参构造函数,称为默认构造函数.此默认构造函数调用类parent的无参数构造函数,如果类没有其他父级,则调用Object构造函数.如果父级没有构造函数(Object确实有构造函数),编译器将拒绝该程序.

(来源)

但是,它Object是Java中每个类的(直接或间接)超类.

假设,我们有一个类A,它不会显式扩展任何类,因此它会隐式扩展Object.另外假设,A没有明确地提供构造函数,因此编译器会自动添加一个默认构造函数,它将调用其超类的构造函数Object(并且Object具有构造函数).

现在假设我们有一个B扩展类的类A,它不提供显式构造函数,因此编译器自动为它提供默认构造函数; 此默认构造函数尝试从中调用构造函数A.

现在为什么一个编译器错误B,当编译器已经提供了一个(默认)构造函数A(被调用Object的构造函数,并Object有一个)？

编辑:

测试:成功编译!这是否意味着教程中的最后一句不正确？

class A extends B {
    public static void main(String [] args) {
        //A a = new A();
        System.out.println("Yayyy");
    }
}

class B {
}

Java11中默认构造函数的可见性是什么？这与构造函数的默认可见性不同。

我有以下 Graph 类：

class Graph {
private:
    struct Edge {
        string vertex1{}, vertex2{};
        int val{};

        Edge() = default;
        ~Edge() = default;
        explicit Edge(string v1, string v2, int value) : vertex1(std::move(v1)), vertex2(std::move(v2)), val(value) {};
        bool operator==(const Edge&) const;
    };

    unordered_map<Edge, Edge*> edges;

public:
    Graph() = default;
    ~Graph();
}

当我想用默认构造函数构造一个 Graph 时，它说Explicitly defaulted default constructor of 'Graph' is implicitly deleted because field 'edges' has a deleted default constructor. 我应该如何更改我的代码，以便能够使用 Graph 的默认构造函数？

问题

我试图在另一个类的构造函数的参数的默认赋值中调用一个类的构造函数，但是我遇到了构造函数未正确调用的问题。这里发生了什么？

代码说明

本Bad类是不工作的情况和Good类是一个丑陋的解决办法来解决这个问题。Base.i每次Base.__init__调用构造函数时，该值都会增加，并且可以看出，它没有为o2对象正确增加，但似乎为每个o1,o3和正确增加o4。

代码

class Base:
    i = 0
    def __init__(self):
        Base.i += 1
        self.i = Base.i

class Bad:
    def __init__(self, base = Base()):
        self.base = base

class Good:
    def __init__(self, base = None):
        if base is None:
            self.base = Base()
        else:
            self.base = base

if __name__ == "__main__":
    o1 = Bad()
    o2 = Bad()

    print("Bad:")
    print(f"o1.i: {o1.base.i}")
    print(f"o2.i: {o2.base.i}")

    o3 = Good() …