Java this와 this() 차이점

Java 프로그래밍 언어에서 `this`와 `this()`는 중요한 역할을 합니다. 이 두 키워드는 클래스와 객체 지향 프로그래밍에서 객체 참조와 생성자 호출을 관리하는 데 사용됩니다. 아래에서는 `this`와 `this()`에 대해 자세히 설명하겠습니다.

 

### `this` 키워드

`this`는 Java에서 객체 자신을 참조하는 데 사용되는 키워드입니다. 이를 통해 객체 자신의 멤버 변수나 메서드에 접근할 수 있습니다. `this`는 다음과 같은 상황에서 주로 사용됩니다:

1. **인스턴스 변수와 로컬 변수의 구별:**
   클래스의 인스턴스 변수가 로컬 변수와 이름이 동일할 때, `this`를 사용하여 인스턴스 변수를 참조할 수 있습니다.

   ```java
   public class MyClass {
       private int value;

       public MyClass(int value) {
           this.value = value; // 인스턴스 변수 value에 로컬 변수 value를 할당
       }
   }
   ```

   여기서 `this.value`는 인스턴스 변수를 참조하고, `value`는 생성자의 매개변수입니다.

 

 

2. **메서드 체이닝:**
   `this`를 반환값으로 사용하여 메서드 체이닝을 구현할 수 있습니다. 이는 객체의 메서드를 연속적으로 호출할 수 있도록 합니다.

   ```java
   public class MyClass {
       private int value;

       public MyClass setValue(int value) {
           this.value = value;
           return this;
       }

       public MyClass incrementValue() {
           this.value++;
           return this;
       }
   }
   
   public class Main {
       public static void main(String[] args) {
           MyClass obj = new MyClass();
           obj.setValue(5).incrementValue();
       }
   }
   ```

   위의 코드에서 `setValue`와 `incrementValue` 메서드는 `this`를 반환하므로, 메서드를 연속적으로 호출할 수 있습니다.

 

 

3. **현재 객체의 참조 전달:**
   메서드에 현재 객체를 전달할 때 `this`를 사용할 수 있습니다.

   ```java
   public class MyClass {
       private int value;

       public void printValue(MyClass obj) {
           System.out.println("Value: " + obj.value);
       }

       public void display() {
           printValue(this); // 현재 객체를 전달
       }
   }
   ```

 

 

4. **중첩 클래스에서의 사용:**
   중첩 클래스(내부 클래스)에서 바깥 클래스의 인스턴스를 참조할 때 `OuterClass.this` 형식을 사용할 수 있습니다.

   ```java
   public class OuterClass {
       private int outerValue = 10;

       class InnerClass {
           private int innerValue = 20;

           public void display() {
               System.out.println("Outer value: " + OuterClass.this.outerValue);
               System.out.println("Inner value: " + this.innerValue);
           }
       }
   }
   ```

 

반응형

### `this()` 생성자 호출

`this()`는 현재 클래스의 다른 생성자를 호출하는 데 사용됩니다. 이를 통해 코드의 중복을 줄이고, 생성자 간의 초기화 로직을 공유할 수 있습니다. `this()`는 생성자의 첫 번째 줄에서만 호출할 수 있습니다.

 

 

1. **생성자 간 호출:**
   여러 생성자에서 공통적으로 수행해야 하는 초기화 작업이 있을 때, `this()`를 사용하여 코드 중복을 피할 수 있습니다.

   ```java
   public class MyClass {
       private int value;
       private String name;

       public MyClass() {
           this(0, "Default");
       }

       public MyClass(int value) {
           this(value, "Default");
       }

       public MyClass(int value, String name) {
           this.value = value;
           this.name = name;
       }
   }
   ```

   위의 예제에서 기본 생성자와 단일 매개변수 생성자는 `this()`를 통해 가장 파라미터가 많은 생성자를 호출하여 초기화 작업을 공유합니다.

 

 

2. **초기화 블록의 공유:**
   생성자들이 공통적인 초기화 블록을 공유해야 할 때 `this()`를 사용하면 유용합니다.

   ```java
   public class MyClass {
       private int value;

       public MyClass() {
           this(0);
           // 추가적인 초기화 작업
       }

       public MyClass(int value) {
           this.value = value;
           // 공통적인 초기화 작업
       }
   }
   ```

   여기서 기본 생성자는 다른 생성자를 호출한 후 추가적인 초기화 작업을 수행할 수 있습니다.

### 사용 예제

#### 예제 1: 인스턴스 변수와 로컬 변수 구분

```java
public class Employee {
    private String name;
    private int id;

    public Employee(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void display() {
        System.out.println("Name: " + this.name + ", ID: " + this.id);
    }
}
```

#### 예제 2: 메서드 체이닝

```java
public class Calculator {
    private int value;

    public Calculator add(int num) {
        this.value += num;
        return this;
    }

    public Calculator subtract(int num) {
        this.value -= num;
        return this;
    }

    public void display() {
        System.out.println("Value: " + this.value);
    }

    public static void main(String[] args) {
        Calculator calc = new Calculator();
        calc.add(5).subtract(3).display();
    }
}
```

#### 예제 3: 생성자 간 호출

```java
public class Book {
    private String title;
    private String author;
    private double price;

    public Book() {
        this("Unknown Title", "Unknown Author", 0.0);
    }

    public Book(String title) {
        this(title, "Unknown Author", 0.0);
    }

    public Book(String title, String author) {
        this(title, author, 0.0);
    }

    public Book(String title, String author, double price) {
        this.title = title;
        this.author = author;
        this.price = price;
    }

    public void display() {
        System.out.println("Title: " + this.title + ", Author: " + this.author + ", Price: " + this.price);
    }

    public static void main(String[] args) {
        Book book1 = new Book();
        Book book2 = new Book("Effective Java");
        Book book3 = new Book("Effective Java", "Joshua Bloch");
        Book book4 = new Book("Effective Java", "Joshua Bloch", 45.0);

        book1.display();
        book2.display();
        book3.display();
        book4.display();
    }
}
```

 

### 결론

Java에서 `this`와 `this()`는 객체 지향 프로그래밍의 핵심적인 역할을 합니다. `this` 키워드는 객체 자신의 참조를 제공하여 인스턴스 변수와 로컬 변수를 구분하고, 메서드 체이닝을 가능하게 하며, 중첩 클래스에서 바깥 클래스의 인스턴스를 참조할 수 있게 합니다. `this()` 생성자 호출은 생성자 간의 코드 중복을 줄이고, 공통적인 초기화 작업을 공유하는 데 유용합니다. 이를 통해 코드의 가독성과 유지보수성을 향상시킬 수 있습니다.