是的，有可能：

public class Foo {
    private int x;

    public Foo() {
        this(1);
    }

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

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

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

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

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

当我需要从代码内部调用另一个构造函数时（不是在第一行），我通常使用这样的助手方法：

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

是的，您可以从另一个构造函数调用构造函数。例如：

public class Animal {
    private int animalType;

    public Animal() {
        this(1); //here this(1) internally make call to Animal(1);
    }

    public Animal(int animalType) {
        this.animalType = animalType;
    }
}

您还可以从Java中的构造函数链接

可以通过this（…）关键字（当需要从同一类调用构造函数时）或super（…）关键词调用另一个构造函数（当您需要从超类调用构造函数时）。

但是，这样的调用必须是构造函数的第一条语句。要克服这个限制，请使用这个答案。

是的，一个类中可以存在任意数量的构造函数，它们可以由另一个构造函数使用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");
    }
}

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