Como faço para chamar um construtor de outro em Java?

É possível chamar um construtor de outro (dentro da mesma class, não de uma subclass)? Se sim como? E qual poderia ser a melhor maneira de chamar outro construtor (se há várias maneiras de fazer isso)?

Sim, é possível:

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

Para encadear a um construtor de superclass em particular, em vez de um na mesma class, use super vez this . Observe que você só pode encadear em um construtor e deve ser a primeira instrução no corpo do construtor .

Veja também esta questão relacionada , que é sobre C #, mas onde os mesmos princípios se aplicam.

Usando this(args) . O padrão preferido é trabalhar do menor construtor para o maior.

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

Você também pode usar uma abordagem mais recentemente defendida de valueOf ou apenas “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; } } 

Para chamar uma superclass, use super(asdf) . A chamada para super deve ser a primeira chamada no construtor ou você receberá um erro do compilador.

[ Nota: Eu só quero adicionar um aspecto, que eu não vi nas outras respostas: como superar as limitações do requisito de que this () tem que estar na primeira linha). ]

Em Java, outro construtor da mesma class pode ser chamado de um construtor através this() . Note, no entanto, que this tem que estar na primeira linha.

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

Que this tenha que aparecer na primeira linha parece uma grande limitação, mas você pode construir os argumentos de outros construtores através de methods estáticos. Por exemplo:

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

Quando eu preciso chamar outro construtor de dentro do código (não na primeira linha), eu costumo usar um método auxiliar como este:

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

Mas na maioria das vezes eu tento fazer o inverso chamando os construtores mais complexos dos mais simples na primeira linha, na medida do possível. Para o exemplo acima

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

Dentro de um construtor, você pode usar a palavra-chave this para invocar outro construtor na mesma class. Fazer isso é chamado de invocação de construtor explícito .

Aqui está outra class Rectangle, com uma implementação diferente daquela na seção 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; } } 

Esta class contém um conjunto de construtores. Cada construtor inicializa algumas ou todas as variables ​​de membro do retângulo.

Como todos já disseram, você usa this(…) , que é chamado de invocação de construtor explícito .

No entanto, lembre-se de que dentro de tal instrução de invocação de construtor explícito você não pode se referir a

  • quaisquer variables ​​de instância ou
  • quaisquer methods de instância ou
  • quaisquer classs internas declaradas nesta class ou em qualquer superclass, ou
  • this ou
  • super

Como afirmado no JLS (§8.8.7.1).

Eu vou te contar uma maneira fácil

Existem dois tipos de construtores:

  1. Construtor padrão
  2. Construtor parametrizado

Vou explicar em um exemplo

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

No exemplo acima mostrei 3 tipos de chamadas

  1. esta () chamada para isso deve ser a primeira declaração no construtor
  2. Este é o nome menos object. isso chama automaticamente o construtor padrão. 3. Isso chama o construtor Parameterized.

Nota: esta deve ser a primeira instrução no construtor.

Sim, qualquer número de construtores pode estar presente em uma class e eles podem ser chamados por outro construtor usando this() [Por favor, não confunda this() construtor com this palavra this chave]. this() ou this(args) deve ser a primeira linha no construtor.

Exemplo:

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

Isso é conhecido como sobrecarga de construtor.
Por favor, note que para o construtor, apenas o conceito de sobrecarga é aplicável e não inheritance ou substituição.

Você pode um construtor de outro construtor da mesma class usando a palavra-chave “this”. Exemplo –

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

Saída – string como construtor arg .. Construtor padrão .. int como construtor arg ..

Chamando o construtor de outro construtor

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

Além disso, você pode chamar o construtor pai usando a chamada super()

Sim, é possível chamar um construtor de outro com o uso 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); } 

Sim, é possível chamar um construtor de outro. Mas há uma regra para isso. Se uma chamada é feita de um construtor para outro, então

essa nova chamada de construtor deve ser a primeira instrução no construtor atual

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

Então, algo como abaixo não funcionará.

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

Além disso, no caso de inheritance, quando o object da subclass é criado, o construtor de superclass é chamado primeiro.

 public class SuperClass { public SuperClass() { System.out.println("Inside super class constructor"); } } public class SubClass extends SuperClass { public SubClass () { //Even if we do not add, Java adds the call to super class's constructor like // super(); System.out.println("Inside sub class constructor"); } } 

Assim, nesse caso, outra chamada de construtor é declarada primeiro antes de qualquer outra instrução.

A palavra chave this pode ser usada para chamar um construtor de um construtor, ao escrever vários construtores para uma class, há momentos em que você gostaria de chamar um construtor de outro para evitar código duplicado.

Abaixo está um link que eu explico outro tópico sobre construtor e getters () e setters () e usei uma class com dois construtores. Espero que as explicações e exemplos o ajudem.

Métodos ou construtores de setter

Existem padrões de projeto que cobrem a necessidade de uma construção complexa – se isso não puder ser feito de forma sucinta, crie um método de fábrica ou uma class de fábrica.

Com o java mais recente e a adição de lambdas, é fácil criar um construtor que aceite qualquer código de boot desejado.

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

Chame isso com …

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

Bem simples

 public class SomeClass{ int number; String someString; public SomeClass(){ number = 0; } public SomeClass(int number){ this(); //set the class to 0 this.setNumber(number); } public SomeClass(int number, String someString){ this(number); //call public SomeClass( int number ) } public void setNumber(int number){ this.number = number; } public void setString(String someString){ this.someString = someString; } //.... add some accessors } 

agora aqui está um pequeno crédito extra:

 public SomeOtherClass extends SomeClass { public SomeOtherClass(int number, String someString){ super(number, someString); //calls public SomeClass(int number, String someString) } //.... Some other code. } 

Espero que isto ajude.

Eu sei que existem muitos exemplos desta questão, mas o que eu encontrei estou colocando aqui para compartilhar minha idéia. Existem duas maneiras de encadear o construtor. Na mesma class, você pode usar essa palavra-chave. em Herança, você precisa usar super palavra-chave.

  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 ie 0 args Constructor. Dog cs = new Dog("Bite"); // Both Calling Same Constructor of Parent Class ie 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"); } } 

Você pode chamar outro construtor através da palavra-chave this(...) (quando precisar chamar um construtor da mesma class) ou da palavra-chave super(...) (quando precisar chamar um construtor de uma superclass).

No entanto, essa chamada deve ser a primeira instrução do seu construtor. Para superar essa limitação, use essa resposta .

É chamado encurtamento de construtor anti-padrão ou encadeamento de construtor. Sim, você pode definitivamente fazer. Vejo muitos exemplos acima e quero acrescentar dizendo que, se você sabe que precisa de apenas dois ou três construtores, tudo bem. Mas se você precisar de mais, por favor, tente usar um padrão de design diferente, como o padrão Builder. Como por exemplo:

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

Você pode precisar de mais. O padrão do construtor seria uma ótima solução nesse caso. Aqui está um artigo, pode ser útil https://medium.com/@modestofiguereo/design-patterns-2-the-builder-pattern-and-the-telescoping-constructor-anti-pattern-60a33de7522e