是的，这是可能的：

public class Foo { private int x; public Foo() { this(1); } public Foo(int x) { this.x = x; } }

要链接到一个特定的超类构造函数而不是同一个类中的构造函数，请使用super而不是this 。 请注意， 您只能链接到一个构造函数 ， 它必须是构造函数体中的第一个语句 。

另请参阅相关的问题 ，这是关于C＃，但在相同的原则适用。

使用this(args) 。 首选模式是从最小的构造函数到最大的构造函数。

public class Cons { public Cons() { // A no arguments constructor that sends default values to the largest this(madeUpArg1Value,madeUpArg2Value,madeUpArg3Value); } public Cons(int arg1, int arg2) { // An example of a partial constructor that uses the passed in arguments // and sends a hidden default value to the largest this(arg1,arg2, madeUpArg3Value); } // Largest constructor that does the work public Cons(int arg1, int arg2, int arg3) { this.arg1 = arg1; this.arg2 = arg2; this.arg3 = arg3; } }

您也可以使用最近提倡的valueOf或“of”的方法：

public class Cons { public static Cons newCons(int arg1,...) { // This function is commonly called valueOf, like Integer.valueOf(..) // More recently called "of", like EnumSet.of(..) Cons c = new Cons(...); c.setArg1(....); return c; } }

要调用超类，请使用super(asdf) 。 对super的调用必须是构造函数中的第一个调用，否则将会出现编译器错误。

[ 注：我只是想添加一个方面，我没有在其他答案中看到：如何克服()必须在第一行)的要求的限制。 ]

在Java中，可以通过this()从构造函数中调用同一个类的另一个构造函数。 但请注意， this必须在第一行。

public class MyClass { public MyClass(double argument1, double argument2) { this(argument1, argument2, 0.0); } public MyClass(double argument1, double argument2, double argument3) { this.argument1 = argument1; this.argument2 = argument2; this.argument3 = argument3; } }

这必须出现在第一行看起来像一个很大的限制，但你可以通过静态方法构造其他构造函数的参数。 例如：

public class MyClass { public MyClass(double argument1, double argument2) { this(argument1, argument2, getDefaultArg3(argument1, argument2)); } public MyClass(double argument1, double argument2, double argument3) { this.argument1 = argument1; this.argument2 = argument2; this.argument3 = argument3; } private static double getDefaultArg3(double argument1, double argument2) { double argument3 = 0; // Calculate argument3 here if you like. return argument3; } }

当我需要从代码中调用另一个构造函数(而不是在第一行)时，我通常使用这样的帮助方法：

class MyClass { int field; MyClass() { init(0); } MyClass(int value) { if (value<0) { init(0); } else { init(value); } } void init(int x) { field = x; } }

但是大多数情况下，我会尽可能通过在第一行中调用更简单的构造函数来实现。 对于上面的例子

class MyClass { int field; MyClass(int value) { if (value<0) field = 0; else field = value; } MyClass() { this(0); } }

在构造函数中，可以使用this关键字来调用同一个类中的另一个构造函数。 这样做被称为显式构造函数调用 。

这里是另外一个Rectangle类，与Objects部分中的不同。

public class Rectangle { private int x, y; private int width, height; public Rectangle() { this(1, 1); } public Rectangle(int width, int height) { this( 0,0,width, height); } public Rectangle(int x, int y, int width, int height) { this.x = x; this.y = y; this.width = width; this.height = height; } }

这个类包含一组构造函数。 每个构造函数初始化矩形的一些或全部成员variables。

正如大家已经说过的，你使用this(…) ，这被称为显式的构造函数调用 。

但是，请记住，在这样一个显式的构造函数调用语句中， 您可能不会引用

任何实例variables或

任何实例方法或

在这个类或任何超类中声明的任何内部类，或者

this还是

super 。

正如JLS(§8.8.7.1)所述。

您可以使用“this”关键字从同一个类的另一个构造函数构造函数。 示例 –

class This1 { This1() { this("Hello"); System.out.println("Default constructor.."); } This1(int a) { this(); System.out.println("int as arg constructor.."); } This1(String s) { System.out.println("string as arg constructor.."); } public static void main(String args[]) { new This1(100); } }

输出 – string作为arg构造函数..默认构造函数.. int作为arg构造函数..

我给你打电话一个简单的方法

有两种types的构造函数：

默认的构造函数

参数化的构造函数

我将在一个例子中解释

class ConstructorDemo { ConstructorDemo()//Default Constructor { System.out.println("D.constructor "); } ConstructorDemo(int k)//Parameterized constructor { this();//-------------(1) System.out.println("P.Constructor ="+k); } public static void main(String[] args) { //this(); error because "must be first statement in constructor new ConstructorDemo();//-------(2) ConstructorDemo g=new ConstructorDemo(3);---(3) } }

在上面的例子中，我展示了三种types的调用

this()对此的调用必须是构造函数中的第一条语句

这是名称较less的对象。 这是自动调用默认的构造函数。 3.调用参数化的构造函数。

注意： 这必须是构造函数中的第一条语句。

是的，可以从另一个构造函数调用。 但有一个规则。 如果从一个构造函数向另一个构造函数调用，那么

新的构造函数调用必须是当前构造函数中的第一个语句

public class Product { private int productId; private String productName; private double productPrice; private String category; public Product(int id, String name) { this(id,name,1.0); } public Product(int id, String name, double price) { this(id,name,price,"DEFAULT"); } public Product(int id,String name,double price, String category){ this.productId=id; this.productName=name; this.productPrice=price; this.category=category; } }

所以像下面的东西不会工作。

public Product(int id, String name, double price) { System.out.println("Calling constructor with price"); this(id,name,price,"DEFAULT"); }

从另一个构造函数调用构造函数

class MyConstructorDemo extends ConstructorDemo { MyConstructorDemo() { this("calling another constructor"); } MyConstructorDemo(String arg) { System.out.print("This is passed String by another constructor :"+arg); } }

你也可以使用super()调用来调用父构造函数

关键字this可以用来从构造函数中调用构造函数，当为某个类编写几个构造函数时，有时候需要从另一个构造函数中调用一个构造函数来避免重复的代码。

贝娄是一个链接，我解释了关于构造函数和getters()和setters()的其他主题，我用了一个具有两个构造函数的类。 我希望这些解释和例子能帮助你。

Setter方法或构造函数

是的，可以使用this()从另一个构造器中调用另一个构造器。

class example{ private int a = 1; example(){ this(5) //here another constructor called based on constructor argument System.out.println("number a is "+a); } example(int b){ System.out.println("number b is "+b); }

是的，任何数量的构造函数都可以存在于一个类中，并且可以由另一个构造函数使用this()[请不要将this()构造函数调用与this关键字混淆]。

this()或this(args)应该是构造函数中的第一行。

Example: Class Test{ Test(){ this(10) // calls the constructor with integer args, Test(int a) } Test(int a){ this(10.5) // call the constructor with double arg, Test(double a) } Test(double a){ System.out.println("I am a double arg constructor"); } }

这被称为构造函数重载。

请注意，对于构造函数，只有重载概念是适用的，而不是inheritance或重写。

有一些devise模式可以满足复杂构build的需要 – 如果不能简洁地完成，可以创build工厂方法或工厂类。

随着最新的Java和lambda的添加，很容易创build一个构造函数，它可以接受任何你想要的初始化代码。

class LambdaInitedClass { public LamdaInitedClass(Consumer init) { init.accept(this); } }

与…通话

new LambdaInitedClass(l -> { // init l any way you want });