[Effective Java] 객체 생성과 파괴 上

1. 생성자 대신 정적 팩토리 메서드 !

 

🔹 정적 팩토리 메서드 (static factory method) 

👉 해당 클래스의 인스턴스 반환
이미 캐시된 객체 반환하여 객체 생성 줄임

👍 장점

• 이름을 가질 수 있어서 반환될 객체의 특성을 제대로 설명 가능 
  ex) BigInteger(int, int, Random) vs BigInteger.probablePrime
  👉 둘 중 '값이 소수인 BigInteger를 반환하다'는 의미를 더 잘 설명할 수 있는 것을 바로 파악 가능 
  
  
• 한 클래스에 시그니처가 같은 생성자가 여러 개 필요할 시 정적 팩토리 메서드를 활용하는 것이 더욱 유용

public class Account {
    private String owner;
    private double balance;

    // private 생성자
    private Account(String owner, double balance) {
        this.owner = owner;
        this.balance = balance;
    }

    // 일반 계좌 생성용 팩토리 메서드
    public static Account createNormalAccount(String owner, double initialDeposit) {
        return new Account(owner, initialDeposit);
    }

    // VIP 계좌 생성용 팩토리 메서드
    public static Account createVIPAccount(String owner, double initialDeposit) {
        return new Account(owner, initialDeposit + 1000); // VIP 보너스 추가
    }

    @Override
    public String toString() {
        return "Account{owner='" + owner + "', balance=" + balance + "}";
    }

    public static void main(String[] args) {
        // 정적 팩토리 메서드를 통한 계좌 생성
        Account normalAccount = Account.createNormalAccount("John Doe", 1000);
        Account vipAccount = Account.createVIPAccount("Jane Doe", 2000);

        System.out.println(normalAccount);
        System.out.println(vipAccount);
    }
}

• 호출될 때마다 인스턴스 새로 생성 X 👉 불필요한 메모리 낭비 줄이고 성능 최적화 가능
  
  
• 반환타입의 하위 타입 객체를 반환할 수 있어 반환할 객체의 클래스를 자유롭게 선택 가능
   
• 입력 매개변수에 따라 매번 다른 클래스의 객체 반환 가능

public class Main {
    public static void main(String[] args) {
        // 정적 팩토리 메서드를 통해 Animal 타입 반환
        Animal animal1 = AnimalFactory.createAnimal("dog");
        animal1.speak();  // 출력: Woof!

        Animal animal2 = AnimalFactory.createAnimal("cat");
        animal2.speak();  // 출력: Meow!
    }
}

 

👎 단점

• 정적 팩토리 메서드를 프로그래머가 찾기 어려움 👉 생성자처럼 API 설명에 명확히 드러나지 X
• 선택적 매개변수가 많을 때 적절히 반응 어려움 (생성자도 마찬가지)

---

✳️ 흔히 사용하는 명명 방식 

• from : 매개변수를 하나 받아서 해당 타입의 인스턴스 반환 👉 형변환 메서드
• of : 여러 매개변수를 받아 적합한 타입의 인스턴스 반환 👉 집계 메서드 
• valueOf : from과 of의 더 자세한 버전
• instance 또는 getInstance : 매개변수로 명시한 인스턴스 반환하지만 같은 인스턴스임 보장 X
• create 또는 newInstance : 매번 새로운 인스턴스를 생성해 반환함 보장
• getType : getInstance와 같으나 생성할 클래스가 아닌 다른 클래스에 팩토리 메서드를 정의할 때 사용
• newType : newInstance와 같으나, 생성할 클래스가 아닌 다른 클래스에 팩토리 메서드를 정의할 때 사용
  👉 FileStore fs = Files.getFileStore(path)
• type : getType과 newType의 간결한 버전
  👉 List<Complaint> litany = Collections.list(legacyLitany)
  ➡️ "Type" 은 팩토리 메서드가 반환할 객체의 타입

 

2. 생성자에 매개변수가 많으면 Builder로 !

• 점층적 생성자 패턴
  : 선택 매개변수를 전부 다 받는 생성자까지 늘려가는 방식
  ➔ 확장하기 어려움
  매개변수 개수가 많아지면 클라이언트 코드를 작성하거나 읽기 어려움
  클라이언트가 실수로 매개변수의 순서를 바꿔 건네줘도 컴파일러는 알아채지 못함
  
  
• Java Beans
  : 매개변수가 없는 생성자로 객체를 만든 후, setter 메서드를 호출해 원하는 매개변수의 값 설정
  ➔ 일관성이 깨지고 불변으로 만들 수 없음
  객체 하나를 만드려면 메서드를 여러 개 호출해야함 
  객체가 완전히 생성되기 전까지는 일관성 무너짐

여기서 일관성이 무너진다는 것은...?

👉 중간에 일부 값만 설정된 상태에서 객체가 존재해 불완전한 상태임
👉 만약 객체가 여러 필드를 가져야 하는데, setter를 통해 필드가 차례로 설정되는 동안 다른 코드에서 이 객체에 접근할 수 있다면, 객체가 아직 완전히 초기화되지 않은 상태에서 사용되므로 오류 발생 
👉 setter 메서드로 인해 객체가 생성된 이후에도 그 상태가 변경될 수 있음 

 

👉 위와 같은 방법이 있으나 빌더 패턴을 사용하면 효율적이다 !

---

✳️ Builder 패턴 

• 필요한 객체를 직접 만드는 대신, 필수 매개변수만으로 생성자 혹은 정적 팩토리를 호출해 빌더 객체를 얻음
  그 후 빌더 객체가 제공하는 일종의 setter 메서드로 원하는 선택 매개변수 설정하고,  매개변수가 없는 build 메서드를 호출해 필요한 객체를 얻음
• builder는 생성할 클래스 안에 정적 멤버 클래스로 만들어 둠

class Person {
    // 필드들 (모든 필드는 불변으로 설정)
    private final String name;
    private final int age;
    private final String address;

    // Person의 private 생성자 (Builder가 호출)
    private Person(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
        this.address = builder.address;
    }

    // Builder 내부 클래스
    public static class Builder {
        private String name;     // 필드들 (기본값 설정 가능)
        private int age;
        private String address;

        // name 필드를 설정하는 메서드 (Builder 객체 반환)
        public Builder setName(String name) {
            this.name = name;
            return this;  // 메서드 체이닝을 위해 this 반환
        }

        // age 필드를 설정하는 메서드 (Builder 객체 반환)
        public Builder setAge(int age) {
            this.age = age;
            return this;
        }

        // address 필드를 설정하는 메서드 (Builder 객체 반환)
        public Builder setAddress(String address) {
            this.address = address;
            return this;
        }

        // build() 메서드: 완성된 Person 객체를 반환
        public Person build() {
            return new Person(this);  // 완전한 Person 객체 생성
        }
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + ", address='" + address + "'}";
    }
}

public class Main {
    public static void main(String[] args) {
        // 빌더 패턴을 통해 Person 객체 생성
        Person person = new Person.Builder()
                            .setName("John")
                            .setAge(30)
                            .setAddress("123 Main St")
                            .build();  // 완성된 Person 객체 생성

        // 결과 출력
        System.out.println(person); 
		// Person{name='John', age=30, address='123 Main St'}
    }
}

import lombok.Builder;
import lombok.ToString;

@Builder    // 롬복의 @Builder 어노테이션 적용
@ToString   // 객체 내용을 출력하기 위해 @ToString 어노테이션 적용
class Person {
    private String name;
    private int age;
    private String address;
}

public class Main {
    public static void main(String[] args) {
        // @Builder 어노테이션으로 생성된 빌더 패턴 사용
        Person person = Person.builder()
                              .name("John")
                              .age(30)
                              .address("123 Main St")
                              .build();

        // 결과 출력
        System.out.println(person);  // Person(name=John, age=30, address=123 Main St)
    }
}

 

✨ Builder 패턴은 계층적으로 설계된 클래스와 함께 쓰기 좋음 !

 

• 추상 빌더 클래스를 통해 다양한 종류의 피자 객체를 유연하게 생성 가능 

public abstract class Pizza{
	public enum Topping {HAM, SAUSAGE, MUSHROOM, ONION, PEPPER}
    final Set<Topping> toppings;
    
    // 추상 빌더 클래스
	// 빌더 패턴의 메서드 체이닝을 가능하게 함
    abstract static class Builder<T extends Builder<T>> {
    	EnumSet<Topping> toppings = EnumSet.noneOf(Topping.class); // 초기에는 아무 토핑도 없는 상태
        
        public T addTopping(Topping topping){
        	toppings.add(Objects.requireNonNull(topping));
            return self(); // 자기 자신(하위 클래스의 빌더)을 반환하여 메서드 체이닝이 가능하도록 함
        }
        
        abstract Pizza build(); // 하위 클래스에서 이 메서드를 구체적으로 구현해야함
        
        // 하위 클래스는 이 메서드를 overriding하여 "this"(자기 자신)를 반환하도록 해야함
        // 메서드 체이닝을 가능하게 하고, 빌더 클래스의 하위 클래스에서 자신을 반환하도록 강제
        protected abstract T self();
    }
    
    Pizza(Builder<?> builder) {
    	toppings = builder.toppings.clone();
    }
}

public class VeggiePizza extends Pizza {

	public enum Size {SMALL, MEDIUM, LARGE}
    private final Size size;
    
    public static class Builder extends Pizza.Builder<Builder> {
    	private final Size size;
        
        public Builder(Size size){
        	this.size = Objects.requireNonNull(size);
        }
        
        @Override
        public VeggiePizza build() {
            return new VeggiePizza(this);
        }

        @Override
        protected Builder self() {
            return this;
        }
    }

    private VeggiePizza(Builder builder) {
        super(builder);  // 상위 클래스 Pizza의 생성자 호출
        size = builder.size;
    }
}

VeggiePizza pizza = new VeggiePizza.Builder(SMALL)
									.addTopping(SAUSAGE)
                                    .addTopping(PEPPER).build();

 

👍 장점 

• 가독성 향상
• 불변 객체 생성
• 필드 선택적 설정
• 확장성 및 유연성

 

👎 단점

• 객체를 만들려면 그에 앞서 빌더부터 만들어야 함 (매개변수가 4개 이상은 되어야 값어치를 함) 
  👉 Lombok에서 제공하는 @Builder 어노테이션으로 빌더 패턴 쉽게 구현해 해결 !

 

 

3.  private 생성자나 열거 타입으로 singleton임을 보증 

Singleton이란 ?
👉 인스턴스를 오직 하나만 생성할 수 있는 클래스

 

✳️ Singleton을 만드는 방식 

• public static final 필드 방식
  👉 해당 클래스가 싱글턴임이 API에 명백히 드러나고 간결함 

public class Singleton {
    // 1. 싱글턴 인스턴스를 static final로 선언하여 클래스 로드 시점에 초기화
    private static final Singleton INSTANCE = new Singleton();

    // 2. private 생성자로 외부에서 인스턴스화할 수 없도록 함
    private Singleton() {
        // private constructor to prevent instantiation
    }

    // 3. 정적 팩토리 메서드를 통해 인스턴스 제공
    public static Singleton getInstance() {
        return INSTANCE;
    }

    // 인스턴스가 가지는 메서드
    public void doSomething() {
        System.out.println("Singleton instance method.");
    }
}

👉 private 생성자가 public static final 필드를 초기화할 때 딱 한 번만 초기화됨

public class SingletonDemo {
    public static void main(String[] args) {
        // 싱글턴 인스턴스를 가져옴
        Singleton singleton = Singleton.getInstance();

        // 싱글턴 메서드를 호출
        singleton.doSomething();

        // 두 개의 Singleton 인스턴스가 동일함을 확인
        Singleton anotherSingleton = Singleton.getInstance();
        System.out.println(singleton == anotherSingleton); // true
    }
}

 

• 정적 팩토리 방식
  👉 Singleton.getInstance는 항상 같은 객체의 참조를 반환 
  
  
• 열거 타입 방식
  👉 enum 활용하여 가장 안전하고 간결한 방식

public enum Singleton {
    // 유일한 싱글턴 인스턴스
    INSTANCE;

    // 인스턴스가 가지는 메서드
    public void doSomething() {
        System.out.println("Singleton instance method.");
    }
}

➔ enum 타입은 public static final 인스턴스 필드를 기본적으로 생성