它被称为伸缩构造函数反模式或构造函数链接。是的，你肯定可以。我看到了上面的许多示例，我想补充一点，如果你知道你只需要两个或三个构造函数，那可能没问题。但是如果你需要更多，请尝试使用不同的设计模式，如Builder模式。例如：

 public Omar(){};
 public Omar(a){};
 public Omar(a,b){};
 public Omar(a,b,c){};
 public Omar(a,b,c,d){};
 ...

你可能需要更多。在这种情况下，生成器模式将是一个很好的解决方案。这是一篇文章，可能会有所帮助https://medium.com/@型号figuereo/设计图案-2-建筑图案和电梯结构-防图案-60a33de7522e

是的，一个类中可以存在任意数量的构造函数，它们可以由另一个构造函数使用this（）调用[请不要将this（）构造函数调用与this关键字混淆]。this（）或this（args）应该是构造函数中的第一行。

例子：

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");
    }
}

这被称为构造函数重载。请注意，对于构造函数，只有重载概念才适用，而不是继承或重写。

是的，有可能：

public class Foo {
    private int x;

    public Foo() {
        this(1);
    }

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

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

另请参阅这个相关的问题，它是关于C#的，但在相同的原则适用的地方。

我更喜欢这种方式：

    class User {
        private long id;
        private String username;
        private int imageRes;

    public User() {
        init(defaultID,defaultUsername,defaultRes);
    }
    public User(String username) {
        init(defaultID,username, defaultRes());
    }

    public User(String username, int imageRes) {
        init(defaultID,username, imageRes);
    }

    public User(long id, String username, int imageRes) {
        init(id,username, imageRes);

    }

    private void init(long id, String username, int imageRes) {
        this.id=id;
        this.username = username;
        this.imageRes = imageRes;
    }
}

我知道这个问题有很多例子，但我把我的发现放在这里是为了分享我的想法。有两种方法可以链接构造函数。在同一类中，可以使用此关键字。在继承中，需要使用超级关键字。

    import java.util.*;
    import java.lang.*;

    class Test
    {  
        public static void main(String args[])
        {
            Dog d = new Dog(); // Both Calling Same Constructor of Parent Class i.e. 0 args Constructor.
            Dog cs = new Dog("Bite"); // Both Calling Same Constructor of Parent Class i.e. 0 args Constructor.

            // You need to Explicitly tell the java compiler to use Argument constructor so you need to use "super" key word
            System.out.println("------------------------------");
            Cat c = new Cat();
            Cat caty = new Cat("10");

            System.out.println("------------------------------");
            // Self s = new Self();
            Self ss = new Self("self");
        }
    }

    class Animal
    {
        String i;

        public Animal()
        {
            i = "10";
            System.out.println("Animal Constructor :" +i);
        }
        public Animal(String h)
        {
            i = "20";
            System.out.println("Animal Constructor Habit :"+ i);
        }
    }

    class Dog extends Animal
    {
        public Dog()
        {
            System.out.println("Dog Constructor");
        }
        public Dog(String h)
        {
            System.out.println("Dog Constructor with habit");
        }
    }

    class Cat extends Animal
    {
        public Cat()
        {
            System.out.println("Cat Constructor");
        }
        public Cat(String i)
        {
            super(i); // Calling Super Class Paremetrize Constructor.
            System.out.println("Cat Constructor with habit");
        }
    }

    class Self
    {
        public Self()
        {
            System.out.println("Self Constructor");
        }
        public Self(String h)
        {
            this(); // Explicitly calling 0 args constructor. 
            System.out.println("Slef Constructor with value");
        }
    }

最初来自米尔科·克莱姆（Mirko Klemm）的回答，为了解决这个问题，稍作修改：

为了完整起见：还有实例初始化块，它总是在调用任何其他构造函数之前执行。它只是由类定义正文中某个位置的语句块“｛…｝”组成。你甚至可以有不止一个。你不能调用它们，但如果你想在构造函数之间重用一些代码，它们就像“共享构造函数”代码，类似于调用方法。

所以在你的情况下

{ 
  System.out.println("this is shared constructor code executed before the constructor");
  field1 = 3;
}

还有一个“静态”版本用于初始化静态成员：“静态｛…｝”