이펙티브 자바 : Item1. 생성자 대신 정적 팩터리 메서드를 고려하라

📝 Effective Java: 생성자 대신 정적 팩터리 메서드를 고려하라

Effective Java의 저자 조슈아 블로크(Joshua Bloch)는 생성자 대신 정적 팩터리 메서드를 사용하는 것을 권장하며, 그 이유로 여러 가지 장점을 제시하고 있습니다. 아래에서 각 장점과 단점을 코드 예시와 함께 자세히 설명하겠습니다.

정적 팩토리 메서드의 장점

1. 이름을 가질 수 있다

생성자는 클래스 이름을 가지므로, 여러 생성자가 있을 경우 구분이 어렵습니다. 반면, 정적 팩토리 메서드는 의미 있는 이름을 가질 수 있어 코드 가독성이 향상됩니다.

예시:

public class User {
    private String username;
    private String email;

    private User(String username, String email) {
        this.username = username;
        this.email = email;
    }

    // 정적 팩토리 메서드
    public static User fromUsername(String username) {
        return new User(username, username + "@example.com");
    }

    public static User fromEmail(String email) {
        String username = email.substring(0, email.indexOf("@"));
        return new User(username, email);
    }

    @Override
    public String toString() {
        return "User{username='" + username + "', email='" + email + "'}";
    }
}
    

사용 예:

public class Main {
    public static void main(String[] args) {
        User user1 = User.fromUsername("john_doe");
        User user2 = User.fromEmail("jane@example.com");

        System.out.println(user1); // User{username='john_doe', email='john_doe@example.com'}
        System.out.println(user2); // User{username='jane', email='jane@example.com'}
    }
}
    

2. 호출될 때마다 인스턴스를 새로 생성하지는 않아도 된다

정적 팩토리 메서드는 필요에 따라 기존 인스턴스를 재사용할 수 있습니다. 이는 메모리 절약과 성능 향상에 도움이 됩니다.

예시:

public class BooleanWrapper {
    private final boolean value;

    private static final BooleanWrapper TRUE = new BooleanWrapper(true);
    private static final BooleanWrapper FALSE = new BooleanWrapper(false);

    private BooleanWrapper(boolean value) {
        this.value = value;
    }

    public static BooleanWrapper valueOf(boolean value) {
        return value ? TRUE : FALSE;
    }

    @Override
    public String toString() {
        return Boolean.toString(value);
    }
}
    

사용 예:

public class Main {
    public static void main(String[] args) {
        BooleanWrapper bw1 = BooleanWrapper.valueOf(true);
        BooleanWrapper bw2 = BooleanWrapper.valueOf(true);
        BooleanWrapper bw3 = BooleanWrapper.valueOf(false);

        System.out.println(bw1 == bw2); // true
        System.out.println(bw1 == bw3); // false
    }
}
    

3. 반환 타입의 하위 타입 객체를 반환할 수 있는 능력이 있다

정적 팩토리 메서드는 반환 타입의 하위 타입 객체를 반환할 수 있어 유연성이 높습니다.

예시:

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
}

public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Square");
    }
}

public class ShapeFactory {
    public static Shape createShape(String type) {
        switch(type.toLowerCase()) {
            case "circle":
                return new Circle();
            case "square":
                return new Square();
            default:
                throw new IllegalArgumentException("Unknown shape type");
        }
    }
}
    

사용 예:

public class Main {
    public static void main(String[] args) {
        Shape shape1 = ShapeFactory.createShape("circle");
        Shape shape2 = ShapeFactory.createShape("square");

        shape1.draw(); // Drawing Circle
        shape2.draw(); // Drawing Square
    }
}
    

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

입력 매개변수에 따라 다양한 클래스의 인스턴스를 반환할 수 있어 유연한 객체 생성을 할 수 있습니다.

예시:

public interface Connection {
    void connect();
}

public class HttpConnection implements Connection {
    @Override
    public void connect() {
        System.out.println("Connecting via HTTP");
    }
}

public class FtpConnection implements Connection {
    @Override
    public void connect() {
        System.out.println("Connecting via FTP");
    }
}

public class ConnectionFactory {
    public static Connection getConnection(String protocol) {
        switch(protocol.toLowerCase()) {
            case "http":
                return new HttpConnection();
            case "ftp":
                return new FtpConnection();
            default:
                throw new IllegalArgumentException("Unsupported protocol");
        }
    }
}
    

사용 예:

public class Main {
    public static void main(String[] args) {
        Connection conn1 = ConnectionFactory.getConnection("http");
        Connection conn2 = ConnectionFactory.getConnection("ftp");

        conn1.connect(); // Connecting via HTTP
        conn2.connect(); // Connecting via FTP
    }
}
    

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

정적 팩토리 메서드는 인터페이스를 반환 타입으로 사용할 수 있어, 반환할 구체적인 클래스가 나중에 추가되더라도 코드 수정 없이 사용할 수 있습니다.

예시:

public interface Logger {
    void log(String message);
}

public class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("ConsoleLogger: " + message);
    }
}

public class FileLogger implements Logger {
    @Override
    public void log(String message) {
        // 파일에 로그를 기록하는 코드
        System.out.println("FileLogger: " + message);
    }
}

public class LoggerFactory {
    public static Logger getLogger(String type) {
        switch(type.toLowerCase()) {
            case "console":
                return new ConsoleLogger();
            case "file":
                return new FileLogger();
            default:
                throw new IllegalArgumentException("Unknown logger type");
        }
    }
}
    

사용 예:

public class Main {
    public static void main(String[] args) {
        Logger logger = LoggerFactory.getLogger("console");
        logger.log("This is a log message."); // ConsoleLogger: This is a log message.
    }
}
    

정적 팩토리 메서드의 단점

1. 상속을 하려면 public이나 protected 생성자가 필요하니 정적 팩토리 메서드만 제공하면 하위 클래스를 만들 수 없다

정적 팩토리 메서드만 제공하고 공개 생성자가 없으면, 외부에서 클래스를 상속받아 확장할 수 없습니다. 이는 클래스의 유연성을 제한할 수 있습니다.

예시:

public class ImmutableClass {
    private final int value;

    private ImmutableClass(int value) {
        this.value = value;
    }

    public static ImmutableClass of(int value) {
        return new ImmutableClass(value);
    }

    public int getValue() {
        return value;
    }
}

// 상속 시도
public class ExtendedClass extends ImmutableClass {
    public ExtendedClass(int value) {
        super(value); // 오류: ImmutableClass의 생성자가 private이라 접근 불가
    }
}
    

해결 방안:

하위 클래스를 허용하려면 적절한 접근 제어자를 사용하여 생성자를 제공해야 합니다. 그러나 이는 정적 팩토리 메서드의 이점을 일부 포기해야 함을 의미합니다.

2. 정적 팩토리 메서드는 프로그래머가 찾기 어렵다

정적 팩토리 메서드는 클래스의 API에 숨겨져 있을 수 있으며, 이름이 직관적이지 않으면 사용자가 이를 찾기 어려울 수 있습니다. 반면, 생성자는 클래스 이름과 동일한 이름을 가지므로 쉽게 찾을 수 있습니다.

예시:

public class ComplexNumber {
    private final double real;
    private final double imaginary;

    private ComplexNumber(double real, double imaginary) {
        this.real = real;
        this.imaginary = imaginary;
    }

    // 정적 팩토리 메서드의 예
    public static ComplexNumber ofCartesian(double real, double imaginary) {
        return new ComplexNumber(real, imaginary);
    }

    public static ComplexNumber ofPolar(double magnitude, double angle) {
        return new ComplexNumber(magnitude * Math.cos(angle), magnitude * Math.sin(angle));
    }
}

// 사용자가 정적 팩토리 메서드를 찾기 어려운 경우
public class Main {
    public static void main(String[] args) {
        // ComplexNumber cn = new ComplexNumber(1, 2); // 오류: 생성자가 private
        ComplexNumber cn1 = ComplexNumber.ofCartesian(1, 2);
        ComplexNumber cn2 = ComplexNumber.ofPolar(1, Math.PI / 2);

        System.out.println("Cartesian: " + cn1.real + " + " + cn1.imaginary + "i");
        System.out.println("Polar: " + cn2.real + " + " + cn2.imaginary + "i");
    }
}
    

해결 방안:

정적 팩토리 메서드의 이름을 직관적으로 지정하고, 클래스 문서에 이를 명확히 명시하여 프로그래머가 쉽게 찾을 수 있도록 합니다.

결론

정적 팩토리 메서드는 생성자에 비해 여러 가지 장점을 제공하지만, 일부 단점도 존재합니다. 특히 상속과 API 사용의 편의성 측면에서 고려해야 할 사항이 있습니다. 이러한 장단점을 잘 이해하고 상황에 맞게 사용하는 것이 중요합니다. 아래는 위의 개념을 종합한 간단한 예제입니다.

종합 예시:

// 인터페이스 정의
public interface Animal {
    void speak();
}

// 구체적인 클래스들
public class Dog implements Animal {
    @Override
    public void speak() {
        System.out.println("Woof!");
    }
}

public class Cat implements Animal {
    @Override
    public void speak() {
        System.out.println("Meow!");
    }
}

// 정적 팩토리 메서드를 제공하는 팩토리 클래스
public class AnimalFactory {
    public static Animal createAnimal(String type) {
        switch(type.toLowerCase()) {
            case "dog":
                return new Dog();
            case "cat":
                return new Cat();
            default:
                throw new IllegalArgumentException("Unknown animal type");
        }
    }
}

// 사용 예
public class Main {
    public static void main(String[] args) {
        Animal dog = AnimalFactory.createAnimal("dog");
        Animal cat = AnimalFactory.createAnimal("cat");

        dog.speak(); // Woof!
        cat.speak(); // Meow!
    }
}
    

이 예제에서는 AnimalFactory의 정적 팩토리 메서드 createAnimal을 사용하여 Animal 인터페이스의 다양한 구현체를 생성합니다. 이를 통해 코드의 유연성과 가독성을 높일 수 있습니다.