2장 객체의 생성과 파괴 - item1. 생성자 대신 정적 팩터리 메서드를 고려하라

생성자(constructor)와 정적 팩터리 메서드(static factory method)

다시 생성자부터

생성자란 클래스의 객체를 생성하고 이러한 인스턴스를 초기화하는 역할을 담당하는 특별한 메서드이다.

일반적으로 객체를 생성하고자 할 때 생성자를 사용하는데, 기본 생성자를 필요에 따라 오버로딩하여 다양한 형태의 생성자를 만들어 활용할 수 있다.

// 생성자(constructor)
class Blog {
    String user;
    int postNumber;
    List<String> visitorList;

    public Blog(String user, int postNumber) {
        this.user = user;
        this.postNumber = postNumber;
    }

    public Blog(String user, int postNumber, List<String> visitorList) {
		this(user, postNumber);
		this.visitorList = visitorList;
	}
}

정적 팩터리 메서드

그럼 정적 팩터리 메서드(static factory method)는 뭘까? 이름을 하나씩 뜯어보면 알 수 있듯이, 정적 팩터리 메서드는 객체 생성 역할을 하는 클래스 메서드라고 이해하면 쉽다.

클래스는 변수와 메서드 등 다양한 멤버를 가질 수 있고, 그 중 메서드는 인스턴스 메서드와 클래스 메서드로 나눌 수 있다. 인스턴스 메서드는 말 그대로 객체가 존재해야지만 사용할 수 있는 기능을 명시한 메서드이다. 반대로 클래스 메서드는 객체가 존재하지 않아도 실행할 수 있는 작업을 명시한 메서드로 클래스 관점에서의 행위를 표현한다. 클래스 메서드는 반드시 메서드 시그니처 앞에 static(정적) 예약어를 붙여줘야한다.

정적 메서드(static method)는 객체가 생성되지 않아도 사용할 수 있는 클래스 메서드이므로 정적 메서드로 객체 생성 역할을 하고자 하는 것이 정적 팩터리 메서드의 시작이다.

그렇다면 객체를 생성해주는 생성자라는 특별한 메서드가 이미 있는데 왜 정적 팩터리 메서드를 사용하라는 것일까?

간단하게 말하자면 1) 조금 더 다양한 객체를 유연하게 생성하고자, 2) 코드의 확장성을 높이고자 라고 말할 수 있을 것 같다.

정적 팩터리 메서드를 써야하는 이유

1. 메서드명을 통해 객체 생성 의미를 분명히한다.

생성자는 모두 클래스명과 동일해야한다. 이 규칙때문에 생기는 단점이 있는데, 하나는 객체를 생성할 때 매개변수를 달리하여 서로 다른 특징의 객체를 만들더라도 구별이 잘 안간다는 것이다. 즉, 의미가 불분명해진다. 두번째는 객체를 생성하는 입장(클라이언트)에서 생성자의 메서드 시그니처 순서를 모두 알아야하기 때문에 실수하기가 쉬워진다.

public class Shake {
	int ice;
	int shot;
    String milk;
    
    // 생성자에 의한 객체 생성
    private Shake(int ice, int shot) {
    	this.ice = ice;
    	this.shot = shot;
    }
    
    private Shake(int ice, String milk) {
    	this.ice = ice;
    	this.milk = milk;
    }

    // 정적 팩터리 메서드에 의한 객체 생성
    public static Shake getCoffeeShake(int ice, int shot) {
        return new Shake(ice, shot);
    }

    public static Shake getMilkShake(int ice, String milk) {
        return new Shake(ice, milk);
    }
}

위와 같은 예시를 보면 new Shake() 생성자를 사용하여 객체를 생성할 때보다 getCoffeeshake()나 getMilkshake() 메서드를 이용하는 것이 의미도 분명하고 실수할 가능성도 적다.

2. 인스턴스를 매번 새롭게 생성하는 것을 막을 수 있다.

프로그램 상에서 꼭 불변 클래스(immutable class)를 유지해야하는 경우가 있다. 이를 위해서는 인스턴스를 미리 생성해두고 이를 캐싱하여 재활용하는 형태를 취해야하는데 이때 적합한 것이 정적 팩터리 메서드이다.

인스턴스를 통제하여 싱글턴 패턴을 보장하고, 인스턴스화가 불가능한 상황을 유지할 수도 있으며, 동일한 인스턴스는 단 하나가 되도록 보장할 수 있다.

public class Product() {
    private static Product productInstance;

    private Product() {}

    public static Product getInstance() {
        if (productInstance == null) {
            productInstance = new Product();
        }
        return productInstance;
    }
}

3. 클래스(인터페이스)의 하위 클래스 객체를 반환할 수 있다.

객체지향 언어 자바의 가장 큰 특징 중 하나인 다형성의 이점을 활용하면 얼마든지 원하는 타입의 객체를 생성할 수 있다. 상위 타입을 상속받은 다양한 하위 타입 클래스가 존재할 경우 같은 메서드로 서로 다른 객체를 생성할 수 있다. 또한 구현 클래스를 공개하지 않고도 반환 타입을 다양하게 하여 객체를 생성하는 입장(클라이언트)에서 클래스 사용이 훨씬 쉬워진다.

// 인터페이스
public interface Shake {
	static Shake getCoffeeShake() {
        return new CoffeeShake();
    }

	static Shake getMilkShake() {
        return new getMilkShake();
    }
}
// 인터페이스 구현체1
class CoffeeShake implements Shake {

}
// 인터페이스 구현체2
class MilkShake implements Shake {
    
}

4. 입력 매개변수에 따라 다른 하위 클래스 객체를 반환할 수 있다.

3번에서 설명한 이점과 비슷한 결이다. 역시 다형성 특징을 활용한 구현 방법으로 정적 팩터리 메서드는 전달받은 매개변수에 따라 적절한 하위 타입의 객체를 만들어 반환할 수 있다. 한편 객체를 생성하는 입장(클라이언트)에서는 팩터리가 정확히 어떤 객체를 어떻게 구현하여 반환하는지 알 필요 없이 원하는 객체를 생성할 수 있다.

이는 코드 확장성을 효과적으로 높일 수 있다. 프로그램 버전이 바뀌어 하위 클래스가 없어지거나 새로 생기더라도 객체를 생성하는 방법은 똑같다.(마치 인터페이스를 사용하는 것처럼)

// 상위 클래스
public abstract class Shoes {
	
	public abstract void getSize();
    
    public static Shake getShoes(int size) {
    	Shoes shoes = null;

        if (size <= 200) {
            shoes = new KidsShoes();
        } else {
            shoes = new AdultShoes();
        }
        return shoes;
    }

    public static void main(String[] args) {
    	Shoes s = getShoes(240);
    	s.getSize();
    }
}
// 하위 클래스1
class KidsShoes extends Shoes {
	@Override
	public void getSize() {
		System.out.println("아동용 신발사이즈는 150부터 200까지입니다.");
	}
}
// 하위 클래스2
class AdultShoes extends Shoes {
	@Override
	public void getSize() {
		System.out.println("성인용 신발사이즈는 205부터 270까지입니다.");
	}
}

5. 정적 팩터리 메서드를 작성하는 시점에는 반환할 객체의 클래스가 존재하지 않아도 된다.

서비스 제공자 프레임워크(service provider framework)를 구현하기 위한 특징이라고 볼 수 있다.

우선 서비스 제공자 프레임워크는 특정 서비스를 제공하는 제공자가 여럿일 때 이들이 모두 같은 방식으로 서비스를 제공하도록 인터페이스 차원으로 구현해둔 것이다. 예시로 가장 많이 언급되는 것이 JDBC(Java Database Connectivity)이다. 클라이언트는 MySQL, Oracle 등등 다양한 데이터베이스를 사용할 것이고, 각각의 데이터베이스 벤더에서 구현한 방식도 모두 제각기 다르다. 따라서 클라이언트가 각 데이터베이스 별 객체 생성 및 접근 방법을 모두 아는 것은 불가능하므로 JDBC라는 공통 데이터베이스 접근 서비스를 제공하는 것이다.

서비스 제공자 프레임워크 컴포넌트 구성

• 구현체의 동작을 정의한 서비스 인터페이스 ex) JDBC의 Connection
• 제공자가 구현체를 등록할 때 사용하는 제공자 등록 API ex) JDBC의 DriverManager.registerDriver()
• 클라이언트가 서비스의 인스턴스를 얻을 때 사용하는 서비스 접근 API ex) JDBC의 DriverManager.getConnection()
• 서비스 인터페이스 인스턴스를 생성하는 서비스 제공자 인터페이스 ex) JDBC의 Driver

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class RegisterDriverExample {
   public static void main(String args[]) throws SQLException {
      // 매개변수로 들어온 문자열 이름을 가진 클래스를 메모리에 로드한다.
      // 클래스가 메모리에 로드되면 자동적으로 드라이버를 등록한다.
      Class.forName("com.mysql.jdbc.Driver");

      // 클라이언트는 등록된 드라이버를 이용하여 db에 연결한다.
      String url = "jdbc:mysql://localhost/mydatabase";
      Connection con = DriverManager.getConnection(url, "root", "password");

      System.out.println("Connection established: "+con);
   }
}

위의 코드는 JDBC를 사용해 mysql 데이터베이스에 접근하는 방법을 보여준다. 먼저 Class.forName()을 통해 적절한 Driver 클래스를 메모리에 로드한다면 서비스 제공자인 JDBC Driver가 정적 팩터리 메서드인 DriverManager.registerDriver() 메서드를 통해 자기 자신을 단 한번 등록한다. 이후 클라이언트는 DriverManager.getConnection() 메서드를 이용해 Connection 객체를 받아 사용하는 구조이다.

위에서 알 수 있듯이 클라이언트가 JDBC를 사용하여 DB에 접근하는 코드를 작성했다면 이는 컴파일 시에 어떤 DB 드라이버를 사용할지 결정할 수 없고, main() 함수가 실행된 뒤 런타임 시 동적으로 맞춤형 DB 드라이버를 로딩해야 한다. 다시 말해 정적 팩터리 메서드인 DriverManager.registerDriver()를 작성할 때는 어떤 드라이버 클래스인지 알 수 없고 이 클래스 객체도 존재하지 않는다. 하지만 main()의 Class.forName() 메서드가 실행되면 그제서야 클래스가 로드되고 드라이버 객체도 등록되므로 정적 팩터리 메서드를 작성할 때는 반환할 객체 클래스가 존재하지 않아도 되는 것이다.

그럼에도 불구하고

정적 팩터리 메서드에도 몇가지 한계가 있다.

1. 정적 팩터리 메서드만 제공하는 클래스는 상속이 불가능하다.

상속을 위해서는 정적 팩터리 메서드만 존재해서는 안되고, public 혹은 protected 범위의 생성자가 필요하다.

하지만 이 단점은 오히려 불변 타입의 클래스를 만들 때 장점으로 작용하기도 한다.

2. 프로그래머 간 코드를 공유할 때 생성자에 비해 코드를 이해하기 힘들다.

여기서 이해가 힘들다는 것은 정적 팩터리 메서드가 코드가 어려워서 이해하기 힘들다는 것이 아니다. 생성자는 특별한 메서드로 API에 설명이 분명하게 명시되지만 정적 팩터리 메서드는 말 그대로 메서드이므로 다른 메서드와 분리하여 표현하기 힘들다.

따라서 다른 프로그래머에게 정적 팩터리 메서드 클래스를 배포하거나 공유할 때는 정적 팩터리 메서드의 존재와 목적을 잘 알리기 위해 널리 사용되는 명명 방식을 따르는 것이 좋다.

정적 팩터리 메서드 명명 방식

• from : 매개변수를 하나 받아 해당 타입의 인스턴스를 반환하는 형변환 메서드
• of : 여러 매개변수를 받아 적합한 타입의 인스턴스를 반환하는 집계 메서드
• valueOf : from과 of의 자세한 버전
• instance 혹은 getInstance : 매개변수로 명시한 인스턴스를 반환. 단, 같은 인스턴스임을 보장하지는 않음.
• create 혹은 newInstance : 매개변수로 명시한 인스턴스를 매번 새롭게 생성해 반환함을 보장.
• getType : 매개변수로 명시한 인스턴스를 반환하되, 생성할 클래스가 아닌 다른 클래스에 팩터리 메서드를 정의할 때 사용. Type은 팩터리 메서드가 반환할 객체의 타입
• newType : 매개변수로 명시한 인스턴스를 매번 새롭게 생성해 반환하되, 생성할 클래스가 아닌 다른 클래스에 팩터리 메서드를 정의할 때 사용. Type은 팩터리 메서드가 반환할 객체의 타입
• type : getType과 newType의 간결한 버전