다운캐스팅으로 자식 메서드 호출하기

앞 글에서 본 것처럼 부모 타입 변수는 여러 자식 객체를 담을 수 있어서, Post 배열 하나로 모든 게시글을 처리할 수 있습니다. 그 대가로 변수가 Post 타입이면 컴파일러가 Post에 선언된 메서드만 허락합니다. 그런데 게시판 관리 화면에서 코드 게시글의 브랜치를 보여 주어야 한다면 어떨까요? 객체는 분명히 CodePost이고 branch() 메서드도 있는데, Post 변수로는 그 메서드를 부를 수 없습니다.

이럴 때 '이 변수가 가리키는 객체는 사실 CodePost다'라고 컴파일러에게 알려 주는 문법이 다운캐스팅(downcasting)입니다. 부모 타입을 자식 타입으로 좁히므로, 업캐스팅과 반대로 상속 관계의 아래쪽으로 내려간다는 뜻입니다. 이 글에서는 다운캐스팅이 왜 필요하고, 실행될 때 무슨 일이 일어나며, 무엇이 바뀌고 무엇이 바뀌지 않는지를 살펴봅니다. 미리 말하면 캐스팅은 새 객체를 만들지도, 객체를 다른 클래스로 바꾸지도 않습니다. 바뀌는 것은 그 객체를 다루는 타입뿐입니다.

부모 타입 변수를 자식 타입 변수에 바로 담을 수 없는 이유

먼저 형변환 없이 대입해 보겠습니다. post에는 CodePost 객체가 들어 있으니 CodePost 변수에 옮겨 담으면 될 것 같습니다.

public final class ParentToChildAssignment {
    public static void main(String[] args) {
        Post post = new CodePost();
        CodePost codePost = post;
        codePost.commit();
    }

    private static class Post {}

    private static final class CodePost extends Post {
        void commit() {
            System.out.println("commit");
        }
    }
}

ParentToChildAssignment.java:4: error: incompatible types: Post cannot be converted to CodePost
        CodePost codePost = post;
                            ^
1 error

컴파일러는 post의 타입이 Post라는 것만 보고 판단합니다. Post 변수에는 Post 객체 자체가 들어 있을 수도, TextPost가 들어 있을 수도, CodePost가 들어 있을 수도 있습니다. 그중 CodePost 변수에 담아도 되는 것은 CodePost 객체뿐이니, 언제나 성공한다고 장담할 수 없는 대입은 자동으로 허용하지 않습니다. 바로 윗줄에서 new CodePost()를 대입한 것이 사람 눈에는 보이지만, 앞 글에서 보았듯 컴파일러는 변수에 실제로 무엇이 들어 있는지 따라가지 않고 변수의 타입만 봅니다.

담긴 객체가 CodePost라는 것을 개발자가 알고 있다면, 괄호 안에 타입을 적어 명시적으로 형변환할 수 있습니다. 이렇게 괄호에 타입을 적는 것을 캐스트(cast)라고 합니다.

CodePost codePost = (CodePost) post;

캐스트를 쓰면 컴파일러는 '실제 객체가 CodePost일 수 있다'는 이유로 대입을 허락합니다. 대신 정말로 CodePost인지는 실행할 때 확인합니다. JVM이 post가 가리키는 객체의 클래스를 보고, CodePost이거나 그 하위 클래스이면 같은 참조값을 codePost에 담습니다. 그렇지 않으면 ClassCastException을 던집니다. 변수가 null이면 확인할 객체가 없으므로 캐스트는 예외 없이 null을 그대로 넘기는데, 이 경우는 다음 글에서 따로 다룹니다. 정리하면 캐스트는 검사를 없애는 것이 아니라, 컴파일할 때 하던 검사를 실행할 때로 미루는 것입니다. 그 사이에 실제 객체가 맞는지는 코드를 쓴 개발자가 확인해야 합니다.

다운캐스팅해도 객체는 그대로다

다운캐스팅이 실제로 무엇을 바꾸는지 확인해 보겠습니다. 다음 예제는 CodePost 객체 하나를 세 변수로 다룹니다. original로 객체를 만들고, Post 타입 parentView에 업캐스팅해 담은 뒤, 그것을 다시 CodePost 타입 childView로 다운캐스팅합니다.

public final class ValidDowncast {
    public static void main(String[] args) {
        CodePost original = new CodePost("feature/login");
        Post parentView = original;

        parentView.publish();
        CodePost childView = (CodePost) parentView;
        childView.commit();

        System.out.println("same=" + (original == childView));
    }

    private static class Post {
        void publish() {
            System.out.println("publish");
        }
    }

    private static final class CodePost extends Post {
        private final String branch;

        CodePost(String branch) {
            this.branch = branch;
        }

        void commit() {
            System.out.println("commit=" + branch);
        }
    }
}

publish
commit=feature/login
same=true

첫 줄은 parentView.publish()가 출력했습니다. publish는 Post에 있으므로 Post 변수로 호출할 수 있습니다. 둘째 줄은 다운캐스팅한 childView로 commit()을 호출한 결과입니다. 여기서 branch 값 feature/login이 그대로 출력된다는 점이 중요합니다. 업캐스팅하는 동안 CodePost가 덧붙인 필드가 사라졌다가 다운캐스팅할 때 다시 만들어진 것이 아니라, 객체는 처음부터 끝까지 branch를 가진 채 그대로 있었던 것입니다. 셋째 줄의 same=true는 original과 childView가 같은 객체를 가리킨다는 뜻입니다. ==는 참조형에서 두 변수에 든 참조값이 같은지 비교합니다.

그림처럼 세 변수는 모두 하나의 CodePost 객체를 가리킵니다. 업캐스팅과 다운캐스팅은 객체를 복사하지도, 새로 만들지도 않았습니다. 달라진 것은 각 변수의 타입, 그리고 그 타입으로 호출할 수 있는 메서드의 범위뿐입니다. parentView로는 publish()만, original과 childView로는 publish()와 commit()을 모두 부를 수 있습니다. 캐스팅이 끝난 뒤에도 parentView의 타입은 계속 Post입니다.

한 번만 쓸 때는 캐스트 식으로

자식 메서드를 한 번만 부를 거라면 자식 타입 변수를 따로 만들지 않고, 캐스트한 결과에 바로 메서드를 호출할 수도 있습니다. 다음 코드의 ((CodePost) post).commit()이 그런 호출입니다. 캐스트는 이 식 안에서만 효과가 있으므로, 다음 줄의 post.publish()에서 post는 여전히 Post 타입 변수로 쓰입니다.

public final class TemporaryDowncast {
    public static void main(String[] args) {
        Post post = new CodePost();

        ((CodePost) post).commit();
        post.publish();
    }

    private static class Post {
        void publish() {
            System.out.println("publish");
        }
    }

    private static final class CodePost extends Post {
        void commit() {
            System.out.println("commit");
        }
    }
}

commit
publish

((CodePost) post).commit()에서 바깥 괄호는 꼭 필요합니다. Java에서 .으로 메서드를 호출하는 것은 캐스트보다 먼저 묶이기 때문입니다. 괄호 없이 (CodePost) post.commit()이라고 쓰면 Java는 post.commit()을 먼저 계산한 뒤 그 결과를 CodePost로 캐스트하려고 합니다. post는 여전히 Post 타입이니 commit()을 찾을 수 없다는 컴파일 오류가 나고, 이 예제처럼 그것이 문장 전체라면 not a statement 오류가 먼저 납니다. 바깥 괄호로 (CodePost) post를 먼저 묶어야 캐스트한 결과에서 commit()을 찾습니다.

캐스트로 타입이 바뀌는 것은 (CodePost) post라는 식의 결과뿐이고, 변수 post의 타입은 바뀌지 않습니다. 그래서 다음 줄의 post.publish()는 여전히 Post 타입 변수로 하는 호출이고, 이 줄을 post.commit()으로 바꾸면 앞 글에서 본 cannot find symbol 오류가 다시 납니다. 아래 그림에서 두 호출의 타입을 단계별로 비교할 수 있습니다.

이렇게 변수에 담지 않고 한 식에서만 쓰는 캐스트를 일시적 다운캐스팅이라고 부르기도 합니다. 한 번 쓸 때는 간단하지만, 같은 객체의 자식 메서드를 여러 번 불러야 한다면 매번 괄호를 겹쳐 쓰는 것보다 CodePost codePost = (CodePost) post;처럼 자식 타입 변수에 이름을 붙여 두는 편이 읽기 쉽습니다.

타입을 확인하고 캐스트하기

지금까지는 post에 CodePost가 들어 있다는 것을 바로 윗줄에서 보았기 때문에 안심하고 캐스트했습니다. 하지만 배열이나 매개변수로 받은 Post에는 무엇이 들어 있을지 미리 알 수 없습니다. 다음 예제는 게시글 목록을 돌면서 모든 게시글의 제목을 출력하고, 코드 게시글일 때만 브랜치를 함께 출력합니다.

public final class PostDetails {
    public static void main(String[] args) {
        Post[] posts = {
                new CodePost("로그인 구현", "feature/login"),
                new TextPost("가입 인사", 120)
        };

        for (Post post : posts) {
            System.out.println(post.title());
            if (post instanceof CodePost) {
                CodePost codePost = (CodePost) post;
                System.out.println("branch=" + codePost.branch());
            }
        }
    }

    private static class Post {
        private final String title;

        Post(String title) {
            this.title = title;
        }

        String title() {
            return title;
        }
    }

    private static final class CodePost extends Post {
        private final String branch;

        CodePost(String title, String branch) {
            super(title);
            this.branch = branch;
        }

        String branch() {
            return branch;
        }
    }

    private static final class TextPost extends Post {
        private final int bodyLength;

        TextPost(String title, int bodyLength) {
            super(title);
            this.bodyLength = bodyLength;
        }
    }
}

로그인 구현
branch=feature/login
가입 인사

post instanceof CodePost는 post가 가리키는 객체가 CodePost와 호환되는지, 즉 CodePost이거나 그 하위 클래스인지를 실행 중에 검사해 true나 false를 돌려줍니다. 첫 원소는 CodePost라서 검사가 참이 되고, 캐스트한 뒤 브랜치를 출력합니다. 둘째 원소는 TextPost라서 검사가 거짓이 되므로 제목만 출력하고 캐스트는 실행하지 않습니다.

if 줄과 그 닫는 중괄호를 지워 모든 원소를 캐스트하면 어떻게 될까요? 첫 원소는 그대로 성공하지만, 둘째 원소에서 실행이 멈춥니다.

로그인 구현
branch=feature/login
가입 인사
Exception in thread "main" java.lang.ClassCastException: class PostDetails$TextPost cannot be cast to class PostDetails$CodePost (PostDetails$TextPost and PostDetails$CodePost are in unnamed module of loader 'app')
	at PostDetails.main(PostDetails.java:10)

TextPost와 CodePost는 같은 부모를 둔 형제일 뿐, TextPost 객체에는 CodePost가 덧붙인 branch가 없습니다. 그래서 캐스트를 실행하는 순간 JVM의 검사가 실패해 ClassCastException이 납니다. 메시지에 나오는 PostDetails$TextPost는 PostDetails 안에 중첩된 TextPost 클래스의 이름입니다. 캐스트 문법은 컴파일을 통과시켜 줄 뿐, 실제 객체가 맞는지까지 확인해 주지는 않습니다. 업캐스팅과 다운캐스팅의 성공 조건, 그리고 이 예외가 나는 경우는 다음 글에서 더 자세히 따져 보고, instanceof의 검사와 캐스트를 한 번에 하는 패턴 매칭은 instanceof와 오버라이딩에서 다룹니다.

캐스팅이 자주 필요하다면 설계를 다시 보기

캐스팅은 필요할 때 쓰는 도구이지만, 캐스팅이 자꾸 늘어난다면 설계를 다시 볼 신호이기도 합니다. 게시글 목록을 돌 때마다 다음처럼 게시글 종류를 하나씩 확인하고 캐스트하는 코드를 생각해 봅시다.

if (post instanceof CodePost) {
    ((CodePost) post).commit();
} else if (post instanceof TextPost) {
    ((TextPost) post).previewBody();
}

이 코드는 새 게시글 종류가 생길 때마다 else if를 하나씩 늘려야 하고, 이런 분기가 여러 곳에 있다면 그 모두를 찾아 고쳐야 합니다. 하나라도 빠뜨리면 새 게시글은 그 자리에서 아무 일도 하지 않고 지나갑니다. 만약 commit과 previewBody가 사실 '게시글을 게시판에 공개한다'는 같은 목적을 게시글마다 다르게 처리하는 것이라면, 부모 Post에 publish()를 두고 각 자식이 오버라이딩하는 편이 낫습니다. 그러면 위 분기 전체가 post.publish(); 한 줄이 되고, 새 게시글은 자기 publish만 구현하면 됩니다.

반대로 commit이 코드 게시글에만 의미가 있고, 관리 화면처럼 특정한 곳에서만 필요하다면 instanceof로 확인한 뒤 캐스트하는 것이 자연스러운 선택일 수 있습니다. 앞의 PostDetails가 그런 경우입니다. 모든 게시글에 공통인 동작은 부모의 메서드와 오버라이딩으로 처리하고, 캐스트는 자식만의 정보가 꼭 필요한 몇몇 자리에 모아 둡니다. 사용하는 쪽이 구체적인 자식 클래스를 많이 알수록, 새 하위 클래스를 추가할 때 고쳐야 할 곳도 늘어납니다.

더 깊이: 기본형 형변환과 참조형 캐스트는 다르다

(int) 3.9와 (CodePost) post는 생김새가 같지만 하는 일이 다릅니다. 기본형 형변환은 값 자체를 다른 표현으로 바꿉니다. double 값 3.9를 int로 바꾸면 소수 부분을 버린 새 값 3이 만들어지고, 원래 값의 정보 일부가 사라집니다. 반면 참조형 캐스트는 참조값을 전혀 바꾸지 않습니다. 같은 참조값을 다른 타입으로 다룰 수 있는지 검사하고, 통과하면 그대로 넘겨줄 뿐입니다. 그래서 참조형 캐스트에서는 정보가 잘려 나가는 일이 없고, 대신 검사에 실패하면 예외가 납니다.

참조형 캐스트는 상속 관계로 이어진 타입 사이에서만 의미가 있습니다. Post 타입 값을 String으로 캐스트하면 incompatible types: Post cannot be converted to String이라는 컴파일 오류가 납니다. Post와 String은 어느 쪽도 다른 쪽의 하위 클래스가 아니라서 성공할 가능성이 전혀 없기 때문입니다. 컴파일러는 이렇게 절대 성공할 수 없는 캐스트는 미리 막고, 성공할 수도 있는 캐스트만 실행할 때 검사하도록 남겨 둡니다. 이 규칙은 다음 글에서 다시 다룹니다.

정리

• 부모 타입 변수를 자식 타입 변수에 그냥 대입하면 컴파일 오류가 납니다. 변수에 어떤 하위 클래스의 객체가 들어 있을지 컴파일러가 알 수 없기 때문입니다.
• (CodePost) post처럼 캐스트를 쓰면 컴파일은 통과하고, 실제 객체가 그 타입과 호환되는지는 실행할 때 JVM이 검사합니다. 호환되지 않으면 ClassCastException이 납니다.
• 캐스트는 객체를 복사하거나 바꾸지 않습니다. 같은 참조값을 다른 타입으로 다룰 뿐이며, 원래 변수의 타입도 그대로입니다.
• 캐스트한 결과에 바로 메서드를 부를 때는 ((CodePost) post).commit()처럼 바깥 괄호가 필요합니다.
• 무엇이 들어 있을지 모르는 변수는 instanceof로 먼저 확인하고 캐스트합니다. 같은 분기가 여러 곳에 반복된다면 부모의 메서드와 오버라이딩으로 바꿀 수 있는지 먼저 검토합니다.

다음 글에서는 업캐스팅이 언제나 안전한 이유와 다운캐스팅이 실패하는 조건을 계층이 더 깊은 예제로 정리합니다.

연습 문제

문제 1: 영상 게시글에 자막 추가하기

Post를 상속하는 VideoPost에 addCaption(String language) 메서드를 만드세요. Post 타입 변수에 VideoPost 객체를 담은 뒤, 다운캐스팅해서 addCaption을 호출합니다. 그다음 원래 Post 변수로 publish()를 호출하고, 두 변수가 같은 객체를 가리키는지도 출력해 확인하세요.

public final class VideoPostCast {
    public static void main(String[] args) {
        Post post = new VideoPost();
        VideoPost video = (VideoPost) post;

        video.addCaption("ko");
        // post.addCaption("en");  // 컴파일 오류: Post에는 addCaption이 없다
        post.publish();
        System.out.println("same=" + (post == video));
    }

    private static class Post {
        void publish() {
            System.out.println("publish");
        }
    }

    private static final class VideoPost extends Post {
        void addCaption(String language) {
            System.out.println("caption=" + language);
        }
    }
}

caption=ko
publish
same=true

문제 2: 캐스트는 언제 실패할까

Post를 상속하는 TextPost와 CodePost가 있습니다. 다음 코드는 컴파일될까요? 실행하면 어느 줄까지 출력하고, 어디서 어떤 일이 일어날까요?

Post post = new TextPost();
TextPost textPost = (TextPost) post;
System.out.println("text ok");
CodePost codePost = (CodePost) post;
System.out.println("never");