[Effective Java] 클래스와 인터페이스 下

23. 태그 달린 클래스보다는 클래스 계층 구조 활용하기

태그 달린 클래스 👉 상수 필드나 인터페이스, 열거형(enum) 등을 활용해서 특정 객체가 어떤 카테고리에 속하는지 식별

class Figure {
    enum Shape {RECTANGLE, CIRCLE};

    // 태그 필드 - 현재 모양을 나타낸다.
    final Shape shape;

    // 다음 필드들은 모양이 사각형(RECTANGLE)일 때만 쓰인다.
    double length;
    double width;

    // 다음 필드는 모양이 원(CIRCLE)일 때만 쓰인다.
    double radius;

    // 원용 생성자
    Figure(double radius) {
        shape = Shape.CIRCLE;
        this.radius = radius;
    }

    // 사각형용 생성자
    Figure(double length, double width) {
        shape = Shape.RECTANGLE;
        this.length = length;
        this.width = width;
    }

    double area() {
        switch (shape) {
            case RECTANGLE:
                return length * width;
            case CIRCLE:
                return Math.PI * (radius * radius);
            default:
                throw new AssertionError(shape);
        }
    }
}

• 열거타입 선언, 태그 필드, switch 문 등 쓸데 없는 코드가 많음
• 여러 구현이 한 클래스 안에 혼합돼 있어서 가독성이 나쁨
• 다른 의미를 위한 코드도 언제나 함께 해 메모리를 많이 사용
• 새로운 의미를 추가할 때마다 모든 switch문을 찾아 새 의미를 처리하는 코드를 추가해야 함
• 인스턴스의 타입만으로는 현재 나타내는 의미를 알 수 없음 

👉 태그 달린 클래스는 장황하고 오류를 내기 쉽고, 비효율적임

---

✳️ 태그 달린 클래스를 클래스 계층 구조로 바꾸기  

• 계층 구조의 루트가 될 추상 클래스 정의하고 태그 값에 따라 동작이 달라지는 메서드들을 루트 클래스의 추상 메서드로 선언
  👉 위의 코드에서 area에 해당
• 태그 값에 상관없이 동작이 일정한 메서드들을 루트 클래스에 일반 메서드로 추가 
• 모든 하위 클래스에서 공통으로 사용하는 데이터 필드들을 전부 루트 클래스로 올림
• 루트 클래스를 확장한 구체 클래스를 의미별로 하나씩 정의

abstract class Figure{
	abstract double area();
}

class Circle extends Figure{
	final double radius;
    
    Circle(double radius) { this.radius = radius; }
    
    @Override 
    double area() {
    	return Math.PI * (radius * radius);
    }
}	

class Rectangle extends Figure{
	final double length;
    final double width;
    
    Rectangle(double length, double width) {
    	this.length = length;
        this.width = width;   
    }
    
    @Override 
    double area() {
    	return length * width;
    }
}

 

 

 

24. 멤버 클래스는 되도록이면 static으로 만들기 

중첩 클래스란 다른 클래스 안에 정의된 클래스
👉 종류 : 정적 멤버 클래스, (비정적) 멤버 클래스, 익명 클래스, 지역 클래스

 

✳️ 정적 멤버 클래스  

• 다른 클래스 안에 선언됨
• 바깥 클래스와 함께 쓰일 때만 유용한 public 도우미 클래스로 쓰임
• 외부 클래스의 인스턴스와 관계없이 독립적으로 사용

class OuterClass {
    private static String staticField = "Outer Static Field";
    private String instanceField = "Outer Instance Field";

    // 정적 멤버 클래스 선언
    static class HelperClass {
        public void display() {
            // 정적 멤버 클래스는 외부 클래스의 정적 필드에 접근 가능
            System.out.println("Accessing outer static field: " + staticField);
            
            // 외부 클래스의 인스턴스 필드는 접근 불가 (컴파일 에러 발생)
            // System.out.println("Accessing outer instance field: " + instanceField);
        }
        
        // 헬퍼 역할: 특정 작업을 처리하는 유틸리티 메서드 제공
        public static int add(int a, int b) {
            return a + b;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 정적 멤버 클래스는 외부 클래스의 인스턴스 없이 생성 가능
        OuterClass.HelperClass helper = new OuterClass.HelperClass();
        helper.display();
        
        // 정적 헬퍼 메서드 호출
        int result = OuterClass.HelperClass.add(5, 3);
        System.out.println("Result of addition: " + result);
    }
}

 

 

✳️ (비정적) 멤버 클래스 

• 인스턴스가 바깥 클래스의 인스턴스와 암묵적으로 연결됨 👉 바깥 인스턴스 없이는 생성 불가 
• 인스턴스 메서드에서 정규화된 this (= 클래스명.this)를 사용해 바깥 인스턴스의 메서드를 호출하거나 바깥 인스턴스의 참조를 가져올 수 있음
• 어떤 클래스의 인스턴스를 감싸 다른 클래스의 인스턴스처럼 보이게 하는 뷰로 사용

class OuterClass {
    private String message = "Hello from OuterClass";

    // 비정적 멤버 클래스
    class InnerClass {
        void display() {
            // 바깥 클래스의 인스턴스 필드에 접근
            System.out.println("Accessing: " + message);

            // 바깥 클래스의 인스턴스 메서드 호출
            OuterClass.this.outerMethod();
        }
    }

    void outerMethod() {
        System.out.println("Outer method called");
    }
}

public class Main {
    public static void main(String[] args) {
        // OuterClass 인스턴스 생성
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();  // InnerClass 인스턴스 생성
        inner.display();  // display 메서드 호출
    }
}

• 비정적 멤버 클래스는 외부 클래스의 인스턴스와 연결되어 있어, 외부 클래스의 인스턴스 필드와 메서드에 접근할 수 있음
• 이 경우, 비정적 멤버 클래스의 인스턴스가 생성될 때마다 외부 클래스의 인스턴스에 대한 숨은 참조가 자동으로 생성됨

멤버 클래스에서 바깥 인스턴스에 접근할 일이 없다면 무조건 static 붙여서 정적 멤버 클래스로 만들기 ! 
👉 static 생략 시 바깥 인스턴스로의 숨은 외부 참조를 갖게 되므로 시간과 공간이 소비되거나 메모리 누수 발생 가능 

 

✳️ 익명 클래스 

• 이름이 없음
• 바깥 클래스의 멤버가 아님
• 쓰이는 시점에 선언과 동시에 인스턴스가 만들어짐 
• 비정적인 문맥에서 사용될 때만 바깥 클래스의 인스턴스 참조 가능
• 선언한 지점에서만 인스턴스 생성 가능
• instanceof 검사나 클래스의 이름이 필요한 작업은 수행 불가
• 여러 인터페이스 구현 불가
• 인터페이스를 구현하는 동시에 다른 클래스 상속 불가 
• 익명 클래스를 사용하는 클라이언트는 그 익명 클래스가 상위 타입에서 상속한 멤버 외에는 호출 불가 
• 정적 팩토리 메서드를 구현할 때 주로 사용됨 

class OuterClass {
    void display() {
        // 익명 내부 클래스
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("This is an anonymous inner class.");
            }
        };

        // 실행
        runnable.run();
    }
}

public class Main {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.display();
    }
}

✳️ 지역 클래스 

• 가장 드물게 사용
• 지역 변수를 선언할 수 있는 곳이면 실질적으로 어디서든 선언 가능
• 이름이 있고 반복해서 사용 가능
• 비정적 문맥에서 사용될 때만 바깥 인스턴스를 참조할 수 있음
• 정적 멤버를 가질 수 없으며 가독성을 위해 짧게 작성해야 함

class OuterClass {

	private String outerField = "Outer Field";
    
    void display() {
        class LocalInnerClass {
            void print() {
            
            	// 비정적 문맥에서는 외부 클래스의 인스턴스 필드 접근 가능
                System.out.println("Accessing outer class field: " + outerField);
                System.out.println("This is a local inner class.");
            }
        }

        // 지역 내부 클래스는 메서드 내에서만 생성 및 사용 가능
        LocalInnerClass localInner = new LocalInnerClass();
        localInner.print();
    }
}

public class Main {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.display();
    }
}

메서드 밖에서도 사용해야 하거나 메서드 안에 정의하기엔 너무 길면 👉 멤버 클래스
멤버 클래스의 인스턴스 각각이 바깥 인스턴스를 참조한다면 👉 비정적 멤버 클래스
그렇지 않으면 👉 정적 멤버 클래스

중첩 클래스가 한 메서드 안에서만 쓰이면서 그 인스턴스를 생성하는 지점이 단 한 곳이고 해당 타입으로 쓰기에 적합한 클래스나 인터페이스가 이미 있다면 👉 익명 클래스 
그렇지 않으면 👉 지역 클래스 

 

 

 

25. 톱레벨 클래스는 한 파일에 하나만 담기

컴파일러가 한 클래스에 대한 정의를 여러 개 만들어 내는 일 X
👉 소스 파일을 어떤 순서로 컴파일하든 바이너리 파일이나 프로그램의 동작이 달라지는 일 X