java - parameter - 자바 생성자란




Java에서 다른 생성자를 호출하는 방법은 무엇입니까? (12)

다른 클래스로부터 생성자를 호출 할 수 있습니까 (서브 클래스가 아닌 동일한 클래스 내에서)? 그렇다면 어떻게? 다른 생성자를 호출하는 가장 좋은 방법은 무엇입니까 (여러 가지 방법이 있다면)?


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

출력 - arg 생성자로서의 문자열 .. 디폴트 생성자 .. arg 생성자로서의 int ..


Telescoping Constructor anti-pattern 또는 생성자 체인이라고합니다. 예, 당신은 확실히 할 수 있습니다. 위의 많은 예제를 보았습니다. 두 개 또는 세 개의 생성자 만 필요하다는 것을 알고 있으면 괜찮을 수도 있습니다. 그러나 더 필요한 경우 Builder 패턴과 같은 다른 디자인 패턴을 사용해보십시오. 예를 들면 다음과 같습니다.

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

더 필요할 수도 있습니다. 이 경우 빌더 패턴은 훌륭한 솔루션이 될 것입니다. 다음은 유용한 정보입니다. https://medium.com/@modestofiguereo/design-patterns-2-the-builder-pattern-and-the-telescoping-constructor-anti-pattern-60a33de7522e design- https://medium.com/@modestofiguereo/design-patterns-2-the-builder-pattern-and-the-telescoping-constructor-anti-pattern-60a33de7522e the- https://medium.com/@modestofiguereo/design-patterns-2-the-builder-pattern-and-the-telescoping-constructor-anti-pattern-60a33de7522e pattern- https://medium.com/@modestofiguereo/design-patterns-2-the-builder-pattern-and-the-telescoping-constructor-anti-pattern-60a33de7522e the- https://medium.com/@modestofiguereo/design-patterns-2-the-builder-pattern-and-the-telescoping-constructor-anti-pattern-60a33de7522e constructor- https://medium.com/@modestofiguereo/design-patterns-2-the-builder-pattern-and-the-telescoping-constructor-anti-pattern-60a33de7522e pattern- https://medium.com/@modestofiguereo/design-patterns-2-the-builder-pattern-and-the-telescoping-constructor-anti-pattern-60a33de7522e


가능합니다.

public class Foo {
    private int x;

    public Foo() {
        this(1);
    }

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

같은 클래스의 하나가 아닌 특정 수퍼 클래스 생성자에 연결하려면 this 대신 super 를 사용 this . 한 생성자에만 연결할 수 있으며 생성자 본문의 첫 번째 문이어야합니다 .

C #에 관한이 같은 질문을 참조하십시오. 그러나 동일한 원칙이 적용됩니다.


다른 생성자에서 생성자 호출

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

또한 super() 호출을 사용하여 상위 생성자를 호출 할 수 있습니다.


복잡한 구조의 필요성을 커버하는 디자인 패턴이 있습니다. 간략하게 수행 할 수없는 경우 팩토리 메소드 또는 팩토리 클래스를 작성하십시오.

최신 자바와 람다 (lambda)를 추가하면 원하는 초기화 코드를 받아 들일 수있는 생성자를 만드는 것이 쉽습니다.

class LambdaInitedClass {

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

전화 해 ...

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

생성자 내에서 this 키워드를 사용하여 동일한 클래스에서 다른 생성자를 호출 할 수 있습니다. 이렇게하는 것은 명시 적 생성자 호출 이라고합니다.

여기에 객체 섹션에있는 것과 다른 구현을 가진 또 다른 Rectangle 클래스가 있습니다.

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

}

이 클래스에는 일련의 생성자가 포함되어 있습니다. 각 생성자는 사각형의 멤버 변수 일부 또는 전체를 초기화합니다.


예, 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) 는 생성자의 첫 번째 줄이어야합니다.

예:

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

이를 생성자 오버로딩이라고합니다.
생성자의 경우 오버로딩 개념 만 적용 가능하고 상속이나 재정의는 적용되지 않습니다.


이 질문에 대한 많은 예가 있다는 것을 알고 있습니다 만, 나는 아이디어를 공유하기 위해 여기에 올리는 것을 발견했습니다. 생성자를 체인화하는 데는 두 가지 방법이 있습니다. Same 클래스에서이 키워드를 사용할 수 있습니다. 상속에서 super 키워드를 사용해야합니다.

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

이 키워드는 생성자에서 생성자를 호출하는 데 사용할 수 있습니다. 클래스에 대해 여러 생성자를 작성할 때 중복 코드를 피하기 위해 다른 생성자를 호출하려는 경우가 있습니다.

Bellow는 생성자와 getters () 및 setters ()에 대한 다른 주제를 설명하는 링크이며 두 생성자가있는 클래스를 사용했습니다. 설명과 예제가 도움이되기를 바랍니다.

Setter 메서드 또는 생성자


this(...) 키워드 (동일한 클래스에서 생성자를 호출해야하는 경우) 또는 super(...) 키워드 ( super(...) 클래스에서 생성자를 호출해야하는 경우 this(...) 를 통해 다른 생성자를 호출 할 수 있습니다.

그러나 이러한 호출은 생성자의 첫 번째 문이어야합니다. 이 제한을 극복 하려면 이 대답을 사용 하십시오 .


this(args) 사용 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(someValue) . super에 대한 호출은 생성자의 첫 번째 호출이어야합니다. 그렇지 않으면 컴파일러 오류가 발생합니다.







constructor