Vraag Hoe noem ik de ene constructor van een andere in Java?


Is het mogelijk om een ​​constructor van een andere te bellen (binnen dezelfde klasse, niet van een subklasse)? Zo ja, hoe? En wat is de beste manier om een ​​andere constructeur te bellen (als er verschillende manieren zijn om dit te doen)?


1823
2017-11-12 20:10


oorsprong


antwoorden:


Ja, het is mogelijk:

public class Foo {
    private int x;

    public Foo() {
        this(1);
    }

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

Gebruik om te ketenen naar een bepaalde superklasseconstructor in plaats van één in dezelfde klasse super in plaats van this. Let daar op je kunt alleen aan één constructeur koppelen, en het moet de eerste verklaring zijn in het lichaam van je constructeur.

Zie ook deze gerelateerde vraag, dat gaat over C # maar waar dezelfde principes van toepassing zijn.


2464
2017-11-12 20:12



Gebruik makend van this(args). Het geprefereerde patroon is om van de kleinste constructeur naar de grootste te werken.

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

U kunt ook een meer recent bepleite benadering van valueOf of gewoon "van" gebruiken:

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

Gebruik om een ​​superklasse te bellen super(asdf). De aanroep naar super moet de eerste aanroep in de constructor zijn of u krijgt een compileerfout.


198
2018-03-11 20:33



[Opmerking: ik wil slechts één aspect toevoegen, dat ik niet zag in de andere antwoorden: hoe beperk ik de beperkingen van de eis dat dit () op de eerste regel moet staan).]

In Java kan door een constructeur via een andere constructor van dezelfde klasse worden gebeld this(). Merk echter op dat this moet op de eerste regel staan.

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

Dat this moet verschijnen op de eerste regel lijkt een grote beperking, maar je kunt de argumenten van andere constructeurs construeren via statische methoden. Bijvoorbeeld:

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;

  }

}

177
2018-04-23 23:12



Wanneer ik vanuit de code een andere constructor moet bellen (niet op de eerste regel), gebruik ik gewoonlijk een helpermethode als deze:

class MyClass {
   int field;


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

Maar meestal probeer ik het andersom te doen door de meer complexe constructeurs van de eenvoudigere op de eerste regel te bellen, voor zover mogelijk. Voor het bovenstaande voorbeeld

class MyClass {
   int field;

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

36
2018-05-26 15:09



Binnen een constructor kunt u de this sleutelwoord om een ​​andere constructor in dezelfde klasse aan te roepen. Dit wordt een expliciete aanroep van een constructeur.

Hier is nog een klasse Rectangle, met een andere implementatie dan die in de sectie 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;
    }

}

Deze klasse bevat een aantal constructors. Elke constructor initialiseert een aantal of alle lidvariabelen van de rechthoek.


23
2018-05-07 22:52



Zoals iedereen al zei, gebruik je this(…), dat een wordt genoemd expliciete aanroep van een constructeur.

Houd daar echter rekening mee binnen zo'n expliciete constructoraanroepverklaring u mag niet verwijzen naar

  • ieder instantievariabelen of
  • ieder instantiemethoden of
  • ieder innerlijke klassen aangegeven in deze klasse of een superklasse, of
  • this of
  • super.

Zoals vermeld in JLS (§8.8.7.1).


12
2017-11-21 13:14



Ik zal het je op een gemakkelijke manier vertellen

Er zijn twee soorten constructeurs:

  1. Standaard constructor
  2. Geparameteriseerde constructor

Ik zal het in één voorbeeld uitleggen

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

In het bovenstaande voorbeeld liet ik 3 soorten oproepen zien

  1. deze () aanroep hiervan moet de eerste verklaring in de constructor zijn
  2. Dit is Naam minder object. dit roept automatisch de standaard constructor aan. 3. Dit roept de geparameteriseerde constructor aan.

Notitie: dit moet de eerste verklaring zijn in de constructor.


7
2017-11-27 19:01