57

这是一段代码作为示例，剩下的只是方法（在底部查看迷宫类）。所以当它被实例化时，使用

Maze labyrinth = new Maze();

和

System.out.println (labyrinth);

这将打印出网格数组。这是合法的吗？我认为所有类都需要构造函数它如何打印出二维网格数组？

迷宫类：

public class Maze
{
    private final int TRIED = 3;
    private final int PATH = 7;
    private int[][] grid = { {1,1,1,0,1,1,0,0,0,1,1,1,1},
                             {1,0,1,1,1,0,1,1,1,1,0,0,1},
                             {0,0,0,0,1,0,1,0,1,0,1,0,0},
                             {1,1,1,0,1,1,1,0,1,0,1,1,1},
                             {1,0,1,0,0,0,0,1,1,1,0,0,1},
                             {1,0,1,1,1,1,1,1,0,1,1,1,1},
                             {1,0,0,0,0,0,0,0,0,0,0,0,0},
                             {1,1,1,1,1,1,1,1,1,1,1,1,1} };

    public String toString ()
    {
        String result = "\n";
        for (int row = 0; row < grid.length; row++)
        {
            for (int column=0; column < grid[row].length; column++)
            result += grid[row][column] + "";
            result += "\n";
        }
        return result;
    }

}
4

7 回答 7

68

不需要显式定义构造函数；但是，所有类都必须有一个构造函数，如果不提供任何构造函数，则会生成一个默认的空构造函数：

public Maze() {
}

请参阅默认构造函数。

于 2012-12-08T02:06:43.587 回答
15

如果你不显式编写构造函数，编译器会默认生成一个无参数的构造函数。

public Maze(){

}

如果你没有显式编写构造函数，编译器会默认生成一个无参数的构造函数。

public Maze(){

}

以上将由编译器包含。

例如检查这个类的字节码：

public class ABC {

}

字节码：

public class sorting/ABC {

  // compiled from: ABC.java

  // access flags 0x1
  public <init>()V         //Default no-args constructor included by the compiler
   L0
    LINENUMBER 7 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init>()V
    RETURN
   L1
    LOCALVARIABLE this Lsorting/ABC; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1
}
于 2012-12-08T02:06:57.673 回答
9

更准确地说，编译器会自动为没有构造函数的类提供无参数构造函数，这个构造函数调用超类的无参数构造函数，如果超类没有无参数构造函数，这是一个错误，如果是，那很好。

如果你的类没有显式超类，那么它有一个隐式 超类（Object），它确实有一个无参数的构造函数。

于 2015-04-26T11:58:32.633 回答
7

这个问题的典型答案是“如果你不声明构造函数，就会创建一个默认构造函数”。这通常是正确的，但并非总是如此。一个类可能没有构造函数。

（这里要画的一个重要区别是 JVM并不要求所有类文件都具有构造函数；但是，如果未显式声明构造函数，则Java 中定义的任何类都具有默认构造函数。这个答案提出了一个奇怪的地方，即前者的示例是从 Java 代码创建的）。

考虑以下代码，来自这个问题：

public class Outer
{
    private class Inner {}

    void someMethod()
    {
        Inner inObj = this.new Inner();
    }
}

如果你用 OpenJDK 编译它，你会发现 3 个类文件：

Outer.class
Outer$Inner.class
Outer$1.class

Outer$1其中最不寻常的是：它实际上什么都没有，甚至没有构造函数：

Compiled from "Outer.java"
class Outer$1 {
}

而InnerandOuter类具有生成的构造函数：

Compiled from "Outer.java"
class Outer {
  Outer();        <------------- Generated Constructor
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  void someMethod();
    Code:
       0: new           #2                  // class Outer$Inner
       3: dup
       4: aload_0
       5: aconst_null
       6: invokespecial #3                  // Method Outer$Inner."<init>":(LOuter;LOuter$1;)V
       9: astore_1
      10: return
}
Compiled from "Outer.java"
class Outer$Inner {
  final Outer this$0;

  Outer$Inner(Outer, Outer$1);        <------------- Generated Constructor
    Code:
       0: aload_0
       1: aload_1
       2: invokespecial #1                  // Method "<init>":(LOuter;)V
       5: return
}
于 2017-12-19T08:59:53.243 回答
4

如果不指定构造函数，编译器会生成一个默认的构造函数。

但是，任何在声明时未初始化的成员变量都将为空。

换句话说，如果您没有为网格分配值（就像您在示例中所做的那样），它将为空。

您的示例运行良好，因为您碰巧在声明网格后立即为其分配了一个值。

于 2012-12-08T02:09:55.417 回答
0

Java 实际上并不需要在类描述中显式构造函数。如果您不包含构造函数，那么 Java 编译器将创建一个带有空参数的默认构造函数。

于 2017-05-03T08:28:06.157 回答
-1

如果您的意思是您不希望任何人直接创建您的类的实例，我认为您可以创建一个构造函数将其访问修饰符设置为私有，并且您只能通过可以访问此私有的公共静态方法创建此类的实例构造函数

于 2020-02-12T10:49:15.463 回答