Java

Green 프로젝트와 Oak

Java의 기원은 1991년 Sun Microsystems에서 시작된 Green 프로젝트에 있다. 이 프로젝트는 당시의 주력 시장이었던 워크스테이션과 서버를 넘어, 대화형 텔레비전과 셋톱박스 같은 차세대 소비자 전자 기기를 위한 소프트웨어 환경을 연구하기 위해 조직되었다. 제임스 고슬링, 마이크 셰리던, 패트릭 노턴 등이 초기 팀에 참여했다.^[4]

소비자 전자 기기는 제조사와 프로세서 구성이 다양하고 제품 수명이 길었기 때문에, 특정 CPU나 운영체제에 종속되지 않으면서 제한된 자원에서도 안정적으로 실행되는 소프트웨어가 필요했다. Green 팀은 처음에는 C++를 이용하려 했지만, 복잡한 메모리 관리와 플랫폼 의존성, 당시 C++ 구현체의 차이로 인해 프로젝트의 요구를 충족하기 어렵다고 판단했다. 이에 고슬링은 C와 C++에 익숙한 개발자가 쉽게 접근할 수 있으면서도, 포인터 산술과 수동 메모리 해제 같은 기능을 제거한 새로운 언어를 설계하기 시작했다.^[5]

이 언어는 처음에 Oak라는 이름으로 불렸다. Oak 프로그램은 특정 프로세서의 기계어가 아니라 중간 명령 형식으로 컴파일되고, 장치마다 구현된 가상 머신이 이를 실행하도록 설계되었다. 객체 지향 모델과 자동 메모리 관리, 실행 전 코드 검증, 동적 클래스 적재도 이 시기의 설계에 포함되었다. 이러한 구조는 이후 Java 바이트코드와 JVM으로 발전했다.

Green 팀은 Oak와 전용 하드웨어를 이용하여 가정용 멀티미디어 기기를 제어하는 시제품을 제작했다. 대표적인 시제품인 Star7은 터치스크린 기반 사용자 인터페이스와 애니메이션 안내 캐릭터를 제공했으며, Oak가 네트워크에 연결된 소형 기기에서 동적인 사용자 인터페이스를 실행할 수 있음을 보여 주었다. 그러나 당시 소비자 전자 기기 시장에서는 이 기술을 상용화할 계약을 확보하지 못했고, 프로젝트는 새로운 활용 분야를 찾게 되었다.

인터넷과 Java로의 전환

1990년대 중반 웹이 빠르게 확산되면서 Green 팀은 Oak의 이식성과 네트워크 중심 실행 모델이 웹 환경에도 적합하다고 판단했다. 웹 브라우저가 서로 다른 운영체제에서 실행되더라도 동일한 중간 코드를 내려받아 실행할 수 있다는 점이 소비자 전자 기기를 위해 설계했던 구조와 잘 맞았다.

Oak라는 이름은 이미 다른 기업이 상표로 사용하고 있었기 때문에 언어의 이름은 Java로 변경되었다. Sun은 Java 언어와 함께 Java 코드를 웹 페이지 안에서 실행할 수 있는 브라우저 HotJava를 개발했다. HotJava는 브라우저가 네트워크에서 프로그램을 내려받아 즉시 실행할 수 있다는 개념을 시연했으며, 이렇게 웹 페이지에 포함된 소형 Java 프로그램은 애플릿이라고 불렸다.

Sun은 1995년 5월 23일 Java 기술을 공식 발표했다.^[6] 같은 시기 Netscape Navigator가 Java 지원 계획을 발표하면서 Java는 웹 브라우저를 통해 빠르게 알려졌다. Java의 초기 확산은 소스 코드를 운영체제별로 다시 작성하지 않고, JVM이 설치된 환경에서 같은 바이트코드를 실행한다는 이식성에 기반했다.

1996년 1월 23일 첫 정식 개발 키트인 JDK 1.0이 공개되었다.^[7] JDK 1.0에는 Java 컴파일러와 JVM, 기본 클래스 라이브러리, 애플릿 실행 도구와 개발 도구가 포함되었다. 이 시기의 Java는 애플릿으로 널리 알려졌지만, 독립 실행형 응용 프로그램과 서버 프로그램도 작성할 수 있는 범용 언어로 설계되어 있었다.

초기 플랫폼의 성장

1997년 공개된 JDK 1.1은 내부 클래스, 리플렉션, JavaBeans, JDBC, 새로운 이벤트 처리 모델과 국제화 기능 등을 추가했다. 초기 버전에서 빠르게 확장되던 API가 정리되면서 Java는 웹 애플릿뿐 아니라 데이터베이스와 연결되는 업무용 응용 프로그램에도 사용되기 시작했다.

1998년에는 J2SE 1.2가 공개되면서 플랫폼 이름에 Java 2가 사용되기 시작했다. Java 2는 Java 플랫폼을 용도에 따라 다음 계열로 나누는 체계를 확립했다.

• J2SE: 데스크톱과 범용 응용 프로그램을 위한 표준 플랫폼
• J2EE: 서버와 기업용 분산 시스템을 위한 플랫폼
• J2ME: 휴대전화와 임베디드 장치를 위한 축소 플랫폼

J2SE 1.2에는 컬렉션 프레임워크, Swing 그래픽 사용자 인터페이스 도구 모음, Java 2D, 보안 정책과 클래스 라이브러리 확장이 포함되었다. 이 시기부터 Java는 단일 언어를 넘어 JVM, 표준 API, 배포 형식과 다양한 실행 환경을 포함하는 플랫폼으로 발전했다.

서버 분야에서는 서블릿, JavaServer Pages, Enterprise JavaBeans와 트랜잭션 API 등이 J2EE로 통합되었다. 이는 Java가 브라우저의 애플릿 기술에서 기업용 웹 애플리케이션과 다계층 서버 시스템으로 활용 범위를 넓히는 계기가 되었다.

언어 기능의 확장

2004년 공개된 J2SE 5.0은 Java 언어 자체에 대규모 변화를 도입했다. 제네릭, 애너테이션, 열거형, 가변 인자, 오토박싱과 언박싱, 향상된 for 문, 정적 임포트가 이 버전에서 추가되었다. 버전 번호는 내부적으로 1.5를 사용했지만 제품명에는 5.0이 사용되었으며, 이후 일반적으로 Java 5라고 불렸다.

Java 5는 라이브러리와 프레임워크가 컴파일 시점 타입 정보를 더 적극적으로 활용할 수 있게 했다. 애너테이션과 리플렉션을 결합한 선언적 프로그래밍 방식도 널리 확산되었고, 이는 이후 기업용 Java 프레임워크의 구성 방식에 큰 영향을 주었다.

2006년 공개된 Java 6부터는 제품명에서 J2SE 대신 Java SE가 사용되었다. 기업용 플랫폼도 Java EE로, 소형 장치용 플랫폼도 Java ME로 이름이 바뀌었다. 이 시기 Java는 서버와 업무 시스템에서 강한 기반을 확보했으며, JVM의 JIT 컴파일과 가비지 컬렉션도 지속적으로 개선되었다.

OpenJDK와 공개 개발

Sun은 2006년 11월 JDK 소스 코드의 일부를 GPLv2로 공개하면서 OpenJDK 프로젝트를 시작했다. 이후 주요 구성 요소가 단계적으로 공개되었고, OpenJDK는 Java SE의 오픈 소스 참조 구현을 공동 개발하는 중심 프로젝트가 되었다.^[8]

OpenJDK의 공개는 여러 기업과 개발자가 JVM, 컴파일러, 클래스 라이브러리 개발에 직접 참여할 수 있는 기반을 마련했다. OpenJDK 소스를 바탕으로 서로 다른 운영체제와 지원 정책, 배포 방식에 맞춘 여러 JDK 배포판도 만들어졌다.

2010년 Oracle이 Sun Microsystems를 인수하면서 Java와 OpenJDK의 관리 주체도 Oracle로 넘어갔다. Oracle은 2010년 1월 Sun 인수를 완료했으며, 이후 Java 플랫폼의 표준화와 주요 OpenJDK 프로젝트를 주도했다.^[9]

인수 전후의 개발 지연으로 Java 7은 2011년에 공개되었다. Java 7은 try-with-resources, 다이아몬드 연산자, 문자열을 사용하는 switch, 새로운 파일 시스템 API인 NIO.2, Fork/Join 프레임워크 등을 도입했다.

Java 8과 함수형 기능

2014년 공개된 Java 8은 Java 5 이후 가장 큰 언어 변화 가운데 하나로 평가된다. 람다 표현식과 메서드 참조, 인터페이스 기본 메서드, 향상된 타입 추론이 도입되었으며, 표준 라이브러리에는 컬렉션 데이터를 선언적인 연산으로 처리하는 Stream API와 새로운 날짜·시간 API가 추가되었다.^[10]

람다 표현식은 Java의 기존 객체 지향 모델을 대체하지 않고, 동작을 함수형 인터페이스의 구현으로 전달하는 방식으로 통합되었다. 이를 통해 컬렉션 변환과 필터링, 병렬 처리, 비동기 API를 이전보다 간결하게 표현할 수 있게 되었다.

Java 8은 장기간 지원된 버전이었으며 많은 기업용 시스템과 Android 개발 환경에서 오랫동안 기준 버전으로 사용되었다. 그 결과 후속 Java 버전이 공개된 이후에도 Java 8을 대상으로 작성된 라이브러리와 응용 프로그램이 광범위하게 유지되었다.

모듈화와 정기 릴리스 체계

2017년 공개된 Java 9은 Java 플랫폼 모듈 시스템을 도입했다. 모듈 시스템은 JDK와 응용 프로그램을 명시적인 모듈 단위로 나누고, 모듈 사이의 의존성과 공개 패키지를 선언할 수 있도록 했다. Java 9에서는 JDK 자체도 모듈화되었으며, 대화형 Java 셸인 JShell도 추가되었다.

Java 9 이후 Java 개발은 기능이 완성될 때까지 대규모 버전을 장기간 준비하는 방식에서 벗어나, 일정한 시간에 맞추어 기능 릴리스를 제공하는 방식으로 전환되었다. OpenJDK는 6개월마다 새로운 JDK 기능 릴리스를 제공하는 시간 기반 개발 모델을 채택했으며, 이 체계는 2018년 Java 10부터 본격적으로 적용되었다.^[11]

정기 릴리스 체계에서는 준비가 완료된 기능만 해당 릴리스에 포함되고, 완료되지 않은 기능은 다음 릴리스로 이동한다. 영구 사양으로 확정하기 전에 실제 사용 경험을 수집할 필요가 있는 기능에는 프리뷰 기능 또는 인큐베이터 모듈이라는 형태가 사용되기 시작했다.

2018년 공개된 Java 11은 이 체계에서 제공된 첫 장기 지원 릴리스였다.^[12] Java 11에서는 Java EE와 CORBA 관련 모듈, Java Web Start와 브라우저 플러그인 등 일부 오래된 구성 요소가 JDK에서 제거되었다. 브라우저가 플러그인 실행 모델을 중단하면서 Java 애플릿도 사실상 역사적인 기술로 전환되었고, Java의 중심 활용 분야는 서버, 클라우드, 업무 시스템과 독립 실행형 응용 프로그램으로 이동했다.

현대 Java

정기 릴리스 체계 아래에서 Java는 기존 호환성을 유지하면서도 언어와 JVM 기능을 단계적으로 확장하고 있다. Java 14부터 16까지는 record가 프리뷰를 거쳐 정식 기능이 되었고, Java 15부터 17까지는 봉인 클래스가 도입되었다. switch 표현식과 instanceof 패턴 매칭도 여러 릴리스에 걸쳐 정식 기능으로 완성되었다.

2021년 공개된 Java 17은 장기 지원 릴리스로 자리 잡았으며, 모듈 체계 이후 축적된 언어 기능과 JVM 개선을 안정적인 기준으로 제공했다. 2023년의 Java 21은 레코드 패턴과 switch 패턴 매칭을 정식으로 포함했으며, 기존 운영체제 스레드보다 많은 동시 작업을 비교적 단순한 코드로 처리할 수 있도록 하는 가상 스레드를 도입했다.

2025년 공개된 Java 25는 장기 지원 릴리스로 지정되었으며, Java 26은 2026년 3월 공개된 후속 기능 릴리스다. 현재 OpenJDK의 JDK 프로젝트는 Java SE 참조 구현을 공개적으로 개발하면서 6개월 주기의 기능 릴리스를 계속 제공하고 있다.^[13]

현대 Java의 발전은 단일 버전에서 대규모 기능을 한꺼번에 도입하기보다, 언어 문법과 JVM, 가비지 컬렉터, 네이티브 연동, 동시성 모델을 여러 릴리스에 걸쳐 시험하고 완성하는 방식으로 이루어진다. Java는 초기의 소비자 전자 기기용 언어에서 웹 애플릿 플랫폼으로, 다시 기업용 서버와 범용 가상 머신 생태계로 중심 영역을 옮겨 왔으며, 오늘날에는 Java 언어뿐 아니라 다양한 JVM 언어와 도구가 공유하는 실행 기반으로 발전했다.

Java의 실행 모델은 Java 언어, 클래스 파일 형식, Java 가상 머신이라는 서로 구분된 계층으로 구성된다. Java 언어 명세는 소스 코드의 문법과 타입 검사, 이름 해석, 표현식 평가와 프로그램 동작을 정의하고, JVM 명세는 컴파일된 프로그램을 표현하는 클래스 파일 형식과 명령어 집합, 메모리 영역, 클래스 생명 주기와 실행 규칙을 정의한다.

따라서 Java 언어와 JVM은 동일한 개념이 아니다. Java 컴파일러는 Java 소스 코드를 JVM이 처리할 수 있는 형식으로 변환하지만, JVM은 Java 문법 자체를 직접 실행하지 않는다. 반대로 JVM이 실행하는 프로그램도 반드시 Java로 작성될 필요는 없으며, JVM 클래스 파일 형식을 생성할 수 있는 Kotlin, Scala, Clojure 등의 언어도 같은 실행 환경을 사용할 수 있다.

소스 코드와 컴파일 단위

Java 소스 프로그램은 하나 이상의 컴파일 단위로 구성된다. 일반적인 컴파일 단위는 선택적인 패키지 선언과 임포트 선언, 하나 이상의 최상위 클래스 또는 인터페이스 선언을 포함한다. 패키지는 관련된 타입을 계층적인 이름 공간으로 묶으며, 모듈은 여러 패키지와 그 의존 관계를 더 큰 배포 단위로 구성한다.^[14]

Java 소스 파일은 일반적으로 .java 확장자를 사용한다. public으로 선언된 최상위 클래스나 인터페이스가 있는 경우, 일반적인 파일 기반 구현에서는 파일 이름을 해당 타입의 단순 이름과 일치시킨다.

package example.application;

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, Java");
    }
}

위 소스에서 example.application은 패키지 이름이고, Main은 최상위 클래스다. 전통적인 Java 애플리케이션은 JVM이 지정된 클래스의 public static void main(String[] args) 메서드를 호출하면서 시작한다. 최신 Java는 더 작은 프로그램을 위해 단순화된 소스 파일과 인스턴스 main 메서드도 지원하지만, 클래스와 정적 main 메서드를 사용하는 형식은 기존 프로그램과 실행 도구에서 계속 사용되는 기본 구조다.

Java 컴파일러는 소스 코드를 처리하면서 구문 분석, 이름 해석, 타입 검사와 접근 제어 검사를 수행한다. 지역 변수가 사용되기 전에 반드시 값이 할당되었는지를 검사하는 확정 할당, 검사 예외의 처리 여부, 제네릭 타입의 적합성 등도 컴파일 단계에서 확인된다. 이러한 정적 검사를 통과한 프로그램만 정상적인 클래스 파일로 변환된다.

바이트코드와 클래스 파일

javac과 같은 Java 컴파일러는 .java 소스 파일을 JVM의 클래스 파일 형식으로 변환한다. 클래스 파일은 보통 .class 확장자로 저장되며, JVM 명령어로 이루어진 바이트코드와 타입·필드·메서드·상수·부가 정보를 포함한다.^[15]

하나의 클래스 파일은 기본적으로 하나의 클래스 또는 인터페이스 정의를 나타낸다. 다만 JVM 명세에서 클래스 파일은 반드시 디스크에 존재하는 실제 파일만을 의미하지 않는다. 네트워크에서 전달되거나 실행 중 생성된 바이트 배열처럼, 클래스 로더가 JVM에 제공할 수 있는 유효한 바이너리 표현도 같은 클래스 파일 형식으로 취급된다.^[16]

클래스 파일에는 다음과 같은 정보가 저장된다.

• 클래스 파일 형식의 버전
• 현재 클래스와 상위 클래스 및 구현 인터페이스
• 필드와 메서드의 이름 및 디스크립터
• 접근 제한자와 기타 속성
• JVM 바이트코드 명령어
• 예외 처리 영역
• 디버깅과 애너테이션 정보
• 심벌 참조를 보관하는 상수 풀

클래스 파일의 상수 풀에는 문자열과 숫자 상수뿐 아니라 클래스, 필드와 메서드를 참조하기 위한 심벌 정보가 포함된다. 컴파일러는 다른 클래스의 실제 메모리 주소를 기록하지 않고 이름과 타입을 기반으로 한 심벌 참조를 남긴다. JVM은 프로그램을 로딩하고 링킹하는 과정에서 이러한 참조를 현재 실행 환경의 클래스와 멤버에 연결한다.

Java 바이트코드는 특정 CPU의 범용 레지스터를 직접 대상으로 하는 기계어가 아니다. JVM은 각 메서드의 지역 변수 배열과 피연산자 스택을 중심으로 명령을 실행하는 스택 기반 명령어 집합을 정의한다. 예를 들어 값을 지역 변수에서 스택으로 올리고, 연산 명령이 스택의 값을 소비한 뒤 결과를 다시 스택에 넣는 방식으로 계산이 진행된다.

다음과 같은 Java 메서드는 컴파일 후 여러 JVM 명령으로 표현된다.

static int add(int left, int right) {
    return left + right;
}

개념적으로는 두 매개변수를 피연산자 스택에 적재하고, 정수 덧셈을 수행한 다음 결과를 반환하는 명령 흐름으로 변환된다.

iload_0
iload_1
iadd
ireturn

실제 클래스 파일에는 명령어뿐 아니라 각 메서드의 최대 피연산자 스택 크기, 지역 변수 슬롯 수, 예외 처리 표와 검증에 필요한 타입 정보도 함께 저장될 수 있다.

JVM의 추상 구조

JVM은 특정 구현체의 내부 구조가 아니라 Java 프로그램을 실행하기 위한 추상 기계를 정의한다. JVM 명세는 프로그램에서 관찰할 수 있는 동작과 클래스 파일 형식, 명령어 의미를 규정하지만, 객체를 실제 메모리에 어떻게 배치하는지나 가비지 컬렉터와 JIT 컴파일러를 어떤 알고리즘으로 구현할지는 대부분 구현체에 맡긴다.

JVM의 주요 실행 시점 데이터 영역은 다음과 같다.^[17]

• 힙: 클래스 인스턴스와 배열이 할당되는 공유 메모리 영역
• 메서드 영역: 타입 정보와 메서드 코드, 런타임 상수 풀 등의 클래스 수준 정보를 저장하는 논리적 영역
• JVM 스택: 스레드마다 생성되며 메서드 호출 프레임을 저장하는 영역
• PC 레지스터: 각 스레드에서 현재 실행 중인 JVM 명령의 위치를 나타내는 영역
• 네이티브 메서드 스택: 네이티브 메서드 실행을 지원하기 위한 구현별 영역
• 런타임 상수 풀: 클래스 파일의 상수 풀을 실행 시점 표현으로 변환한 영역

각 Java 스레드는 독립된 JVM 스택을 가진다. 메서드가 호출되면 해당 스택에 새로운 프레임이 생성되고, 메서드가 정상적으로 반환하거나 예외로 종료되면 프레임이 제거된다.

프레임에는 일반적으로 다음 요소가 들어간다.

• 메서드 매개변수와 지역 변수를 저장하는 지역 변수 배열
• 계산 중간값을 저장하는 피연산자 스택
• 현재 클래스의 런타임 상수 풀에 대한 참조
• 메서드의 정상 반환과 예외 전파를 처리하기 위한 정보

인스턴스 메서드에서는 지역 변수 배열의 첫 번째 슬롯이 일반적으로 현재 객체를 가리키는 this 참조에 사용된다. 그 뒤에 메서드 매개변수와 지역 변수가 저장된다. 정적 메서드는 특정 인스턴스에 속하지 않으므로 this 슬롯을 사용하지 않는다.

클래스 로딩

JVM은 프로그램에 포함된 모든 클래스를 시작할 때 한꺼번에 메모리에 올릴 필요가 없다. 클래스와 인터페이스는 일반적으로 실제로 필요해질 때 동적으로 로딩된다.

클래스 로딩은 특정 바이너리 이름을 가진 클래스나 인터페이스의 바이너리 표현을 찾고, 그 표현으로부터 JVM 내부의 클래스 또는 인터페이스를 생성하는 과정이다. JVM은 부트스트랩 클래스 로더와 플랫폼 클래스 로더, 애플리케이션 클래스 로더 및 사용자가 정의한 클래스 로더를 통해 클래스를 가져올 수 있다.^[18]

클래스 로더는 파일 시스템 외에도 다음과 같은 위치에서 클래스를 제공할 수 있다.

• JAR 파일과 모듈 이미지
• 네트워크 응답
• 데이터베이스나 암호화된 저장소
• 실행 중 생성한 바이트코드
• 다른 프로그램 형식에서 변환한 클래스 정의

JVM에서 클래스의 실행 시점 정체성은 바이너리 이름만으로 결정되지 않는다. 같은 이름의 클래스라도 서로 다른 클래스 로더가 정의했다면 JVM에서는 서로 다른 타입으로 취급될 수 있다. 이 구조는 애플리케이션 서버와 플러그인 시스템, 모듈 격리, 동적 코드 교체와 같은 환경에서 독립적인 클래스 이름 공간을 구성하는 데 사용된다.

배열 클래스는 일반 클래스와 달리 클래스 로더가 클래스 파일에서 직접 정의하지 않는다. JVM이 필요할 때 배열 클래스를 생성하며, 배열 요소 타입의 클래스 로더와 접근 규칙을 기반으로 해당 배열 타입을 구성한다.

링킹

로드된 클래스는 실행에 사용되기 전에 링킹 과정을 거친다. 링킹은 클래스를 JVM의 실행 시점 상태에 결합하는 과정이며, 검증·준비·해결 단계로 구성된다.^[19]

검증

검증 단계에서는 클래스 파일이 구조적으로 올바르고 JVM의 타입 및 실행 규칙을 위반하지 않는지 확인한다. JVM은 파일 형식과 명령어 배열, 분기 대상, 지역 변수와 피연산자 스택의 타입 흐름 등을 검사한다.

검증기는 다음과 같은 조건을 확인할 수 있다.

• 클래스 파일의 구조와 버전이 유효한가
• 존재하지 않는 명령어나 잘못된 피연산자가 사용되지 않았는가
• 분기 명령이 유효한 명령 위치로 이동하는가
• 피연산자 스택이 넘치거나 부족해지지 않는가
• 각 명령에 전달되는 값의 타입이 적합한가
• 초기화되지 않은 객체 참조가 잘못 사용되지 않는가
• final 클래스와 메서드 등의 제약을 위반하지 않는가

이 검증을 통해 JVM은 이후 바이트코드를 실행할 때 모든 명령마다 동일한 타입 안전성 검사를 반복하지 않아도 된다. 다만 검증은 프로그램의 업무 논리나 모든 실행 시점 오류를 보장하는 과정은 아니며, 배열 경계 검사와 널 참조 검사, 실제 타입 변환 검사 등은 실행 중에도 수행된다.

준비

준비 단계에서는 클래스의 정적 필드를 위한 저장 공간을 만들고 JVM이 정한 기본값으로 초기화한다. 숫자 타입은 0, boolean은 false, 참조 타입은 null에 해당하는 값으로 준비된다.

class Counter {
    static int count = 10;
}

이 필드는 준비 단계에서 먼저 0으로 설정된다. 소스 코드에 작성된 10을 실제로 대입하는 작업은 일반적으로 이후 클래스 초기화 단계에서 수행된다. 다만 컴파일 시간 상수로 처리되는 일부 static final 필드는 클래스 파일의 상수 속성을 통해 준비 단계에서 지정된 값으로 설정될 수 있다.

해결

해결은 런타임 상수 풀에 저장된 클래스, 인터페이스, 필드와 메서드의 심벌 참조를 구체적인 실행 시점 참조로 바꾸는 과정이다.

해결은 링킹 과정에서 미리 수행될 수도 있고, 특정 참조가 실제로 처음 사용될 때까지 지연될 수도 있다. 이러한 지연 해결은 시작 시점에 필요한 작업을 줄이고, 사용되지 않는 클래스와 멤버를 불필요하게 처리하지 않게 한다.

심벌 참조를 해결하는 과정에서는 대상 타입이나 멤버가 존재하는지, 접근 가능한지, 필드와 메서드의 종류 및 디스크립터가 일치하는지 확인한다. 조건을 만족하지 않으면 NoClassDefFoundError, NoSuchMethodError, NoSuchFieldError, IllegalAccessError와 같은 링킹 오류가 발생할 수 있다.

클래스 초기화

링킹을 마친 클래스나 인터페이스는 특정한 적극적 사용이 발생할 때 초기화된다. 클래스 초기화는 정적 필드 초기화식과 static 초기화 블록을 소스 코드에 나타난 순서대로 실행하는 과정이다.

class RuntimeState {
    static int count = loadInitialCount();

    static {
        System.out.println("RuntimeState initialized");
    }

    private static int loadInitialCount() {
        return 100;
    }
}

컴파일러는 이러한 정적 초기화 작업을 JVM이 인식하는 특수한 클래스 초기화 메서드인 <clinit>에 해당하는 형태로 구성한다. <clinit>은 개발자가 직접 호출하는 일반 Java 메서드가 아니라 JVM이 필요한 시점에 실행하는 메서드다.

클래스 초기화를 유발하는 대표적인 동작은 다음과 같다.

• 클래스의 인스턴스를 처음 생성하는 경우
• 클래스에 선언된 정적 메서드를 처음 호출하는 경우
• 컴파일 시간 상수가 아닌 정적 필드를 처음 읽거나 쓰는 경우
• 특정 리플렉션 API를 통해 클래스를 적극적으로 사용하는 경우
• JVM이 애플리케이션의 시작 클래스를 초기화하는 경우

클래스를 초기화하기 전에 해당 클래스의 상위 클래스가 먼저 초기화된다. JVM은 여러 스레드가 같은 클래스를 동시에 초기화하려 할 때 초기화 절차가 한 번만 수행되도록 동기화한다. 초기화 도중 예외가 발생하면 해당 클래스는 오류 상태가 될 수 있으며, 이후 사용 시 NoClassDefFoundError 등이 발생할 수 있다.

클래스가 단순히 로드되거나 타입 선언이 참조되었다고 해서 항상 즉시 초기화되는 것은 아니다. 예를 들어 컴파일 시점에 값이 결정되는 static final 상수를 읽는 코드는 해당 값을 사용하는 클래스 파일에 상수가 직접 포함될 수 있으므로, 상수를 선언한 클래스의 초기화를 일으키지 않을 수 있다.

객체 생성과 메서드 호출

new 표현식으로 객체를 생성하면 JVM은 대상 클래스가 로딩·링킹·초기화되었는지 확인하고, 힙에서 객체를 위한 공간을 확보한다. 새 객체의 인스턴스 필드는 먼저 기본값으로 설정된 뒤, 상위 클래스부터 생성자 실행이 진행된다.

생성자 호출은 일반 메서드 호출과 비슷해 보이지만 JVM에서는 <init>이라는 특수한 인스턴스 초기화 메서드로 표현된다. 객체는 메모리 할당 직후부터 완전히 초기화된 것으로 간주되지 않으며, 바이트코드 검증기는 초기화되지 않은 객체 참조가 생성자 호출 전 잘못 사용되지 않도록 제한한다.

Java의 메서드 호출은 대상에 따라 서로 다른 JVM 명령으로 표현될 수 있다.

• invokestatic: 정적 메서드 호출
• invokevirtual: 일반적인 인스턴스 메서드의 동적 디스패치
• invokeinterface: 인터페이스를 통한 메서드 호출
• invokespecial: 생성자, 비공개 메서드와 특정 상위 클래스 메서드 호출
• invokedynamic: 실행 시점에 호출 대상을 연결하는 동적 호출 지점

가상 메서드 호출에서는 참조 변수의 선언 타입만으로 최종 메서드가 결정되지 않는다. JVM은 실제 객체의 클래스를 기준으로 오버라이딩된 메서드를 선택한다. 이 동적 디스패치가 Java의 런타임 다형성을 구성한다.

invokedynamic은 처음부터 고정된 클래스의 메서드만 호출하는 방식과 달리, 부트스트랩 메서드가 실행 시점에 호출 지점의 동작을 연결할 수 있도록 한다. Java 컴파일러는 람다 표현식과 문자열 연결 등을 구현할 때 이 명령을 활용할 수 있으며, 다른 JVM 언어도 동적 언어 기능을 구현하는 데 사용할 수 있다.

예외와 제어 흐름

Java의 예외는 JVM 수준에서 일반적인 분기 반환과 구분되는 비정상 제어 흐름으로 처리된다. 메서드 실행 중 예외 객체가 던져지면 JVM은 현재 명령 위치를 포함하는 적절한 예외 처리기를 찾는다.

현재 메서드의 예외 처리 표에서 호환되는 처리기를 찾지 못하면 현재 프레임이 제거되고 호출한 메서드로 예외가 전달된다. 이 과정은 적절한 처리기를 찾을 때까지 호출 스택을 거슬러 올라간다. 끝까지 처리되지 않은 예외는 해당 스레드를 종료하며, 애플리케이션의 실행 결과는 남아 있는 비데몬 스레드와 실행 환경에 따라 결정된다.

소스 수준의 try, catch, finally와 try-with-resources는 컴파일러가 JVM의 예외 처리 표와 분기 명령, 필요에 따라 추가적인 정리 코드로 변환한다. 검사 예외와 비검사 예외의 구분은 주로 Java 언어의 컴파일 시간 규칙이며, JVM은 두 종류를 별개의 예외 실행 메커니즘으로 처리하지 않는다.

인터프리터와 JIT 컴파일

JVM 명세는 바이트코드 명령의 의미와 프로그램에서 관찰되는 동작을 규정하지만, 모든 명령을 어떤 방식으로 실행해야 하는지는 강제하지 않는다. JVM 구현체는 바이트코드를 순차적으로 해석하거나, 실행 전에 또는 실행 중 네이티브 기계어로 컴파일할 수 있다.

대표적인 OpenJDK JVM 구현체인 HotSpot은 일반적으로 프로그램 실행을 빠르게 시작한 뒤, 실행 중 수집한 프로파일 정보를 바탕으로 자주 실행되는 메서드와 반복 구간을 네이티브 코드로 컴파일한다. 이 방식을 JIT 컴파일이라고 한다.

초기 실행에서는 인터프리터나 비교적 빠른 저단계 컴파일러가 코드를 처리할 수 있다. 실행 횟수와 분기 경향, 실제로 사용되는 객체 타입 등의 정보가 충분히 쌓이면 최적화 컴파일러가 해당 코드를 더 적극적으로 최적화한다. HotSpot은 이러한 여러 실행 단계를 조합하는 계층형 컴파일을 지원한다.^[20]

JIT 컴파일러는 실행 중 확인한 조건을 바탕으로 다음과 같은 최적화를 적용할 수 있다.

• 짧은 메서드의 인라인화
• 가상 메서드 호출의 직접 호출 전환
• 중복 계산과 도달할 수 없는 코드 제거
• 루프 최적화
• 범위 검사 제거
• 객체 할당과 잠금의 일부 제거
• CPU별 명령어와 레지스터 활용
• 탈출 분석을 이용한 객체 수명 최적화

이러한 최적화는 현재까지 관찰된 타입이나 실행 경로가 계속 유지된다는 가정 아래 적용될 수 있다. JVM은 이후 새로운 클래스가 로딩되거나 가정과 다른 실행 상황이 나타나면 최적화된 네이티브 코드를 무효화하고, 실행 상태를 다시 인터프리터나 덜 최적화된 코드로 되돌릴 수 있다. 이를 역최적화라고 한다.

이 구조 덕분에 JVM은 프로그램의 실제 실행 특성을 알 수 없는 정적 컴파일 시점보다 더 구체적인 정보를 사용해 최적화할 수 있다. 반면 프로그램 시작 직후에는 클래스 로딩과 프로파일 수집, JIT 컴파일이 진행되므로 장시간 실행 후의 최고 성능에 도달하기까지 준비 시간이 필요할 수 있다.

네이티브 코드와 사전 컴파일

Java 프로그램의 일반적인 배포 단위는 플랫폼 중립적인 클래스 파일이지만, 모든 실행이 항상 인터프리터와 JIT 컴파일만으로 이루어지는 것은 아니다. JVM과 관련 도구는 사용 목적에 따라 클래스 데이터와 실행 상태를 미리 준비하거나 일부 코드를 네이티브 형식으로 변환할 수 있다.

GraalVM Native Image와 같은 네이티브 이미지 도구는 애플리케이션과 필요한 라이브러리를 분석하여 특정 운영체제와 CPU를 대상으로 하는 실행 파일을 만들 수 있다. 이러한 방식은 JVM을 시작하고 코드를 단계적으로 최적화하는 전통적인 실행 방식과 달리 시작 시간과 메모리 사용량을 줄이는 데 초점을 둔다.

다만 네이티브 이미지에는 특정 플랫폼을 대상으로 다시 빌드해야 한다는 특성이 있으며, 실행 중 임의의 클래스를 로딩하거나 리플렉션으로 프로그램 구조를 탐색하는 기능은 빌드 시점 분석과 추가 설정의 영향을 받을 수 있다. 따라서 Java의 표준 클래스 파일 실행 모델과 네이티브 실행 파일 모델은 배포 환경과 성능 목표에 따라 선택되는 서로 다른 실행 경로다.

이식성과 플랫폼 의존성

Java의 이식성은 같은 소스 코드가 모든 환경에서 아무 조건 없이 동일하게 동작한다는 의미보다, 표준화된 클래스 파일과 JVM 동작 및 Java SE API를 기준으로 프로그램과 실행 환경 사이의 계약을 제공한다는 의미에 가깝다.

Java 컴파일러가 생성한 클래스 파일은 해당 클래스 파일 버전과 기능을 지원하는 JVM에서 실행할 수 있다. 일반적으로 새로운 JDK로 컴파일한 클래스 파일은 더 높은 클래스 파일 버전을 사용하므로 오래된 JVM에서 직접 실행되지 않는다. 필요한 경우 컴파일러의 --release 옵션을 사용하여 이전 Java SE 릴리스의 언어 기능, 클래스 파일 형식과 공개 API를 대상으로 컴파일할 수 있다.

실제 프로그램의 이식성은 다음 요소의 영향을 받는다.

• 사용하는 Java SE 버전과 클래스 파일 버전
• JVM 구현체가 지원하는 운영체제와 CPU
• 파일 경로와 문자 인코딩 및 로케일
• 네이티브 라이브러리와 JNI 사용 여부
• 운영체제별 프로세스와 네트워크 기능
• 그래픽 환경과 장치 접근
• 구현체별 명령행 옵션과 비표준 API
• 시간대 데이터와 보안 정책 및 외부 환경 설정

Java 프로그램이 JNI나 특정 운영체제 명령, 플랫폼 전용 파일 구조에 의존하면 해당 부분은 환경별 구현이나 배포 파일을 필요로 한다. 반대로 표준 Java API와 명세에서 보장하는 동작을 중심으로 구성하면 동일한 클래스 파일을 여러 JVM 구현체와 운영체제에서 실행할 수 있다.

Java의 실행 모델은 소스 언어를 특정 CPU에서 분리하면서도, JVM 구현체가 현재 시스템에 맞는 메모리 관리와 기계어 최적화를 수행할 수 있게 한다. 이 분리는 Java의 이식성을 형성하는 동시에, JVM을 Java 이외의 여러 언어가 공유할 수 있는 범용 실행 플랫폼으로 발전시킨 핵심 구조다.

Java는 모든 변수와 표현식의 타입이 컴파일 시점에 결정되는 정적 타입 언어다. 타입은 변수가 가질 수 있는 값의 범위와 사용할 수 있는 연산을 제한하며, 메서드 호출과 대입, 변환이 유효한지를 컴파일러가 검사한다. Java는 타입이 허용하는 연산과 값의 종류를 엄격하게 구분하므로 일반적으로 강한 타입 언어로 분류된다.^[21]

Java의 타입은 크게 기본 타입과 참조 타입으로 나뉜다.

• 기본 타입은 논리값과 숫자 값을 직접 나타낸다.
• 참조 타입의 값은 객체나 배열을 가리키는 참조 또는 null이다.
• 클래스와 인터페스, 배열, 타입 변수는 참조 타입을 구성한다.
• 객체의 실제 클래스는 실행 시점에 결정되지만, 표현식과 변수에는 컴파일 시점 타입이 존재한다.

Java의 객체 모델은 클래스 기반이다. 클래스는 객체의 필드와 메서드, 초기화 과정 및 상속 관계를 정의한다. 인터페이스는 구현체가 제공해야 하는 동작의 계약을 표현하며, 클래스와 분리된 다중 타입 계층을 구성한다. 모든 클래스는 직접 또는 간접적으로 java.lang.Object를 상속하지만, 기본 타입은 객체가 아니며 Object의 하위 타입도 아니다.

기본 타입

Java는 다음 여덟 개의 기본 타입을 정의한다.

Java의 정수 타입 크기와 표현 범위는 플랫폼에 따라 달라지지 않는다. 예를 들어 int는 모든 Java 구현에서 32비트 부호 있는 정수이며, C나 C++처럼 대상 시스템의 데이터 모델에 따라 크기가 달라지지 않는다.

boolean active = true;
byte level = 10;
short port = 8080;
int count = 1_000_000;
long distance = 9_000_000_000L;
char initial = 'J';
float ratio = 0.5F;
double temperature = 21.75;

boolean은 정수 타입과 서로 변환되지 않는다. 조건식에는 boolean 값만 사용할 수 있으며, 0과 1을 거짓과 참으로 취급하지 않는다.

char는 하나의 Unicode 문자를 일반적인 의미에서 완전히 표현하는 타입이 아니라 하나의 UTF-16 코드 단위를 저장한다. 기본 다국어 평면 밖의 문자는 서로 이어지는 두 개의 char 값인 서로게이트 쌍으로 표현될 수 있다. 전체 Unicode 코드 포인트를 처리할 때는 int와 Character의 코드 포인트 API를 사용할 수 있다.

기본 타입은 객체가 아니므로 직접 메서드를 가지지 않는다. 다만 각 기본 타입에는 대응하는 래퍼 클래스가 있다.

컴파일러는 필요한 문맥에서 기본 타입 값을 래퍼 객체로 변환하는 박싱과 래퍼 객체를 기본 타입 값으로 변환하는 언박싱을 자동으로 삽입할 수 있다.

Integer boxed = 42;  // int 값을 Integer 객체로 박싱
int value = boxed;   // Integer 객체를 int 값으로 언박싱

자동 박싱은 문법을 단순화하지만 기본 타입과 객체의 차이를 없애지는 않는다. 래퍼 참조는 null일 수 있으며, 이를 자동 언박싱하면 NullPointerException이 발생한다. 래퍼 객체에 ==를 사용하면 숫자 값이 아니라 객체 참조의 동일성을 비교할 수 있으므로 값 비교에는 일반적으로 equals를 사용한다.

참조 타입과 객체 참조

참조 타입에는 클래스 타입, 인터페이스 타입, 배열 타입과 타입 변수가 포함된다. 참조 타입 변수는 객체 자체를 변수 안에 직접 포함하기보다 객체나 배열을 가리키는 참조 값을 가진다.

String first = new String("Java");
String second = first;
String empty = null;

위 코드에서 first와 second는 같은 String 객체를 가리킨다. second에 다른 값을 대입해도 first 자체가 변경되는 것은 아니다. 참조를 메서드에 전달할 때도 참조 값이 복사되므로 Java의 인수 전달 방식은 기본 타입과 참조 타입 모두 값에 의한 전달이다.

static void replace(StringBuilder value) {
    value = new StringBuilder("new");
}

static void append(StringBuilder value) {
    value.append(" updated");
}

replace는 매개변수에 저장된 참조 사본만 바꾸므로 호출자의 변수가 가리키는 객체를 교체하지 않는다. append는 복사된 참조를 통해 원래 객체의 상태를 변경하므로 호출자에서도 변화가 관찰된다.

참조 타입에는 특별한 널 타입의 값인 null을 대입할 수 있다. null은 어떤 객체도 가리키지 않으며 클래스나 인터페이스의 인스턴스가 아니다. null 참조를 통해 인스턴스 필드나 메서드에 접근하면 NullPointerException이 발생한다.

Java의 타입 체계는 일반 참조 타입에서 널 가능성을 타입 인수로 직접 구분하지 않는다. 따라서 String 타입 변수에는 String 객체와 null이 모두 들어갈 수 있다. 애너테이션과 정적 분석 도구를 이용하여 널 가능성을 별도로 표현할 수 있지만, 이는 전통적인 Java 타입 체계의 내장 구분과는 다르다.

클래스와 객체

클래스는 필드, 메서드, 생성자, 초기화 블록과 중첩 타입을 선언할 수 있는 객체 설계 단위다. 클래스의 인스턴스는 해당 클래스와 상위 클래스에서 정의된 인스턴스 상태를 가지며, 객체의 실제 동작은 실행 시점 클래스와 메서드 오버라이딩 관계에 따라 결정된다.^[22]

class Account {
    private final String owner;
    private long balance;

    Account(String owner, long balance) {
        this.owner = owner;
        this.balance = balance;
    }

    String owner() {
        return owner;
    }

    long balance() {
        return balance;
    }

    void deposit(long amount) {
        balance += amount;
    }
}

owner와 balance는 각 객체에 속하는 인스턴스 필드다. 서로 다른 Account 인스턴스는 같은 클래스 정의를 공유하지만 각자 독립적인 필드 값을 가진다.

클래스 멤버에 static을 붙이면 특정 객체가 아니라 클래스 자체에 속한다.

class IdGenerator {
    private static long nextId;

    static long next() {
        return ++nextId;
    }
}

정적 메서드는 현재 객체를 나타내는 this 참조를 가지지 않으며 인스턴스 없이 호출할 수 있다. 정적 멤버는 클래스 로더와 클래스 정의 단위로 존재하므로, 같은 이름의 클래스를 서로 다른 클래스 로더가 각각 정의하면 정적 상태도 분리될 수 있다.

생성자와 객체 초기화

생성자는 새 객체의 초기 상태를 구성하는 특별한 선언이다. 생성자는 클래스와 같은 이름을 가지며 반환 타입을 선언하지 않는다.

class Point {
    private final int x;
    private final int y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

객체 생성 과정에서는 메모리가 할당된 뒤 모든 인스턴스 필드가 기본값으로 설정된다. 이후 상위 클래스 생성자가 먼저 실행되고, 현재 클래스의 필드 초기화식과 인스턴스 초기화 블록 및 생성자 본문이 정해진 순서로 실행된다.

생성자의 첫 문장은 같은 클래스의 다른 생성자를 호출하는 this(...) 또는 직접 상위 클래스 생성자를 호출하는 super(...)가 될 수 있다. 명시하지 않으면 컴파일러는 가능한 경우 인수가 없는 super() 호출을 삽입한다.

class Rectangle {
    private final int width;
    private final int height;

    Rectangle() {
        this(1, 1);
    }

    Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }
}

생성자는 상속되지 않으며 일반 메서드처럼 오버라이딩되지 않는다. 같은 클래스 안에서 매개변수 목록이 다른 여러 생성자를 선언하는 생성자 오버로딩은 가능하다.

상속

Java 클래스는 extends를 사용하여 하나의 직접 상위 클래스만 지정할 수 있다. 상위 클래스를 명시하지 않은 일반 클래스는 암시적으로 Object를 직접 상속한다. Object 자체만 상위 클래스가 없다.

class Animal {
    void speak() {
        System.out.println("sound");
    }
}

class Dog extends Animal {
    @Override
    void speak() {
        System.out.println("bark");
    }
}

클래스 단일 상속은 객체의 구현 상태와 클래스 계층이 여러 경로로 중복되는 문제를 피한다. 다만 하나의 클래스는 여러 인터페이스를 구현할 수 있으므로 동작 계약과 타입 관계는 다중으로 구성할 수 있다.

상위 클래스의 접근 가능한 필드와 메서드는 하위 클래스에 상속된다. 생성자와 비공개 멤버는 직접 상속되지 않는다. private 멤버는 상위 클래스 객체 상태의 일부로 존재할 수 있지만 하위 클래스 코드에서 이름으로 직접 접근할 수 없다.

final 클래스는 상속할 수 없으며, final 메서드는 하위 클래스에서 오버라이딩할 수 없다.

final class ImmutableToken {
}

// class DerivedToken extends ImmutableToken {}  // 컴파일 오류

Java의 클래스 상속은 명목적이다. 두 클래스가 우연히 같은 필드와 메서드 구조를 가지더라도 명시적인 상속이나 인터페이스 구현 관계가 없다면 서로 대입 가능한 타입으로 취급되지 않는다.

메서드 오버로딩과 오버라이딩

오버로딩은 같은 이름을 가지지만 매개변수 타입이나 개수가 다른 여러 메서드를 선언하는 기능이다. 어떤 오버로드를 호출할지는 컴파일 시점의 인수 타입을 기준으로 결정된다.

class Printer {
    void print(int value) {
        System.out.println("int: " + value);
    }

    void print(String value) {
        System.out.println("String: " + value);
    }
}

반환 타입만 다른 메서드는 오버로딩할 수 없다. 호출 문맥만으로 반환 타입을 항상 구분할 수 없기 때문이다.

오버라이딩은 하위 클래스가 상위 클래스에서 상속한 인스턴스 메서드의 구현을 교체하는 기능이다. 호출할 실제 메서드는 실행 시점 객체의 클래스에 따라 선택된다.

Animal animal = new Dog();
animal.speak();  // Dog.speak 호출

변수 animal의 컴파일 시점 타입은 Animal이지만 실제 객체의 클래스는 Dog다. 컴파일러는 Animal 타입에 speak 메서드가 존재하는지 검사하고, JVM은 실행 시점에 Dog가 오버라이딩한 구현을 선택한다.

정적 메서드는 객체에 대한 동적 디스패치 대상이 아니다. 하위 클래스가 상위 클래스와 같은 서명의 정적 메서드를 선언하면 오버라이딩이 아니라 이름 숨김이 발생하며, 호출 대상은 참조 표현식의 컴파일 시점 타입을 기준으로 결정된다.

필드도 다형적으로 오버라이딩되지 않는다. 하위 클래스가 같은 이름의 필드를 선언하면 상위 필드를 숨기지만 두 필드는 별도로 존재할 수 있다.

추상 클래스

abstract 클래스는 직접 인스턴스를 생성할 수 없는 클래스다. 일부 동작을 구현하면서 나머지 동작을 추상 메서드로 남겨 하위 클래스가 완성하도록 할 수 있다.

abstract class Shape {
    abstract double area();

    void printArea() {
        System.out.println(area());
    }
}

class Circle extends Shape {
    private final double radius;

    Circle(double radius) {
        this.radius = radius;
    }

    @Override
    double area() {
        return Math.PI * radius * radius;
    }
}

추상 클래스는 인스턴스 필드와 생성자, 구체 메서드, 정적 멤버를 모두 가질 수 있다. 따라서 공통 상태와 구현을 공유해야 하는 클래스 계층에 사용할 수 있다.

추상 클래스의 구체적인 하위 클래스는 상속받은 모든 추상 메서드를 구현해야 한다. 구현하지 않으면 해당 하위 클래스도 abstract로 선언해야 한다.

인터페이스

인터페이스는 클래스와 별도의 참조 타입이며, 클래스가 제공하는 동작의 계약을 표현한다. 클래스는 여러 인터페이스를 구현할 수 있고, 하나의 인터페이스도 여러 상위 인터페이스를 확장할 수 있다.^[23]

interface Drawable {
    void draw();
}

interface Transformable {
    void move(int x, int y);
}

class Sprite implements Drawable, Transformable {
    @Override
    public void draw() {
        System.out.println("draw sprite");
    }

    @Override
    public void move(int x, int y) {
        System.out.println("move to " + x + ", " + y);
    }
}

인터페이스의 인스턴스 메서드는 선언 형태에 따라 추상 메서드, 기본 메서드, 정적 메서드 또는 비공개 메서드가 될 수 있다.

• 추상 메서드는 구현 클래스가 제공할 동작을 선언한다.
• default 메서드는 인터페이스가 기본 구현을 제공한다.
• static 메서드는 인터페이스 자체에 속한다.
• private 메서드는 인터페이스 내부 구현을 공유하는 데 사용한다.

인터페이스에 선언된 필드는 암시적으로 public static final이며 객체별 상태를 저장하는 인스턴스 필드가 아니다.

interface Named {
    String name();

    default String displayName() {
        return "[" + name() + "]";
    }
}

클래스가 여러 인터페이스에서 같은 서명의 기본 메서드를 상속하여 충돌이 발생하면 구현 클래스가 해당 메서드를 명시적으로 오버라이딩해야 한다. 클래스의 구체 메서드와 인터페이스 기본 메서드가 경쟁하는 경우에는 클래스 계층의 메서드가 우선한다.

인터페이스 타입 변수는 해당 인터페이스를 구현한 어떤 클래스의 객체든 참조할 수 있다. 이를 통해 구현 클래스에 직접 의존하지 않는 다형적 API를 구성할 수 있다.

함수형 인터페이스와 람다 표현식

추상 인스턴스 메서드를 하나만 가지는 인터페이스는 함수형 인터페이스가 될 수 있다. 함수형 인터페이스는 람다 표현식이나 메서드 참조의 대상 타입으로 사용된다.

@FunctionalInterface
interface IntOperation {
    int apply(int left, int right);
}

IntOperation add = (left, right) -> left + right;
int result = add.apply(10, 20);

람다 표현식 자체는 독립적인 함수 타입을 선언하지 않는다. 람다의 매개변수와 반환 타입은 대입이나 메서드 호출 문맥에서 요구되는 함수형 인터페이스를 기준으로 결정된다. 같은 람다 표현식도 호환되는 서로 다른 함수형 인터페이스 타입을 대상으로 사용할 수 있다.

함수형 인터페이스는 default 메서드와 정적 메서드를 여러 개 가질 수 있다. 함수형 인터페이스 여부를 결정하는 것은 상속된 메서드까지 고려한 하나의 추상 함수 계약이다.

Object와 공통 객체 동작

모든 일반 클래스는 직접 또는 간접적으로 java.lang.Object를 상속한다. 따라서 모든 객체는 Object에 정의된 공통 메서드를 가진다.

대표적인 메서드는 다음과 같다.

• equals(Object): 논리적 동등성 비교
• hashCode(): 해시 기반 자료구조에 사용하는 해시 값
• toString(): 객체의 문자열 표현
• getClass(): 객체의 실행 시점 클래스
• clone(): 조건부 객체 복제
• wait(), notify(), notifyAll(): 객체 모니터 기반 스레드 협력

Object의 기본 equals 구현은 참조 동일성을 비교한다. 값 객체는 필요한 경우 equals와 hashCode를 함께 오버라이딩하여 논리적 동등성을 정의한다.

final class UserId {
    private final long value;

    UserId(long value) {
        this.value = value;
    }

    @Override
    public boolean equals(Object other) {
        return other instanceof UserId id
            && value == id.value;
    }

    @Override
    public int hashCode() {
        return Long.hashCode(value);
    }
}

equals가 같다고 판단하는 두 객체는 같은 hashCode 값을 반환해야 한다. 이 계약을 지키지 않으면 HashMap과 HashSet 같은 해시 기반 컬렉션에서 객체를 정상적으로 찾지 못할 수 있다.

참조 동일성과 객체 동등성

참조 타입에서 ==는 두 피연산자가 같은 객체를 가리키는지 비교한다. 객체의 내용이나 의미가 같은지는 자동으로 판단하지 않는다.

String first = new String("Java");
String second = new String("Java");

System.out.println(first == second);       // false
System.out.println(first.equals(second));  // true

첫 번째 비교는 두 참조가 서로 다른 객체를 가리키므로 false다. 두 번째 비교는 String이 구현한 내용 기반 동등성에 따라 true다.

String 리터럴은 문자열 풀을 통해 같은 객체가 재사용될 수 있으므로 일부 코드에서 ==가 우연히 true가 될 수 있다. 문자열 내용 비교에는 이러한 객체 재사용 여부와 관계없이 equals를 사용한다.

배열 타입

Java 배열은 객체이며 고정된 길이와 하나의 구성 요소 타입을 가진다. 배열 타입은 별도의 클래스 선언 없이 JVM이 생성하지만 Object의 하위 타입이며 Cloneable과 java.io.Serializable을 구현한다.

int[] numbers = {1, 2, 3};
String[] names = new String[10];

기본 타입 배열은 기본 타입 값을 직접 구성 요소로 가진다. 참조 타입 배열의 각 요소는 객체 참조이며 생성 직후 null로 초기화된다.

배열은 참조 타입이므로 클래스 배열에 공변성이 적용된다. 예를 들어 String[]은 Object[]에 대입할 수 있다.

Object[] values = new String[1];
values[0] = "Java";

그러나 실제 배열 객체의 구성 요소 타입은 계속 String이다. 호환되지 않는 객체를 저장하면 실행 시점에 ArrayStoreException이 발생한다.

Object[] values = new String[1];
values[0] = Integer.valueOf(10);  // ArrayStoreException

배열 공변성은 일부 오류를 컴파일 시점이 아니라 실행 시점에 발견하게 만든다. 제네릭 컬렉션은 기본적으로 불공변이므로 이와 다른 타입 안전성 모델을 사용한다.

타입 변환

Java의 타입 변환은 모든 타입 사이에서 자유롭게 이루어지지 않으며, 언어가 정의한 변환 문맥에 따라 허용 여부가 결정된다.^[24]

주요 변환은 다음과 같다.

• 기본 타입 확대 변환
• 기본 타입 축소 변환
• 참조 타입 확대 변환
• 참조 타입 축소 변환
• 박싱과 언박싱 변환
• 문자열 문맥 변환
• 메서드 호출 변환
• 대입과 캐스팅 변환

작은 정수 타입에서 더 넓은 정수 타입으로의 변환은 일반적으로 명시적인 캐스트 없이 가능하다.

int count = 100;
long total = count;
double average = total;

반대 방향은 값의 범위나 정밀도를 잃을 수 있으므로 명시적인 캐스트가 필요하다.

long total = 3_000_000_000L;
int count = (int) total;

참조 타입 확대 변환은 하위 타입 참조를 상위 타입으로 다루는 변환이다.

Dog dog = new Dog();
Animal animal = dog;
Object object = animal;

상위 타입 참조를 더 구체적인 하위 타입으로 바꾸려면 캐스트가 필요하다. 실제 객체가 대상 타입과 호환되지 않으면 ClassCastException이 발생한다.

Animal animal = new Dog();
Dog dog = (Dog) animal;

instanceof와 타입 패턴

instanceof는 참조 값이 특정 타입의 인스턴스인지 실행 시점에 검사한다. 전통적인 형태에서는 검사 후 별도의 캐스트가 필요했다.

if (value instanceof String) {
    String text = (String) value;
    System.out.println(text.length());
}

타입 패턴을 사용하면 검사와 지역 변수 선언을 하나로 결합할 수 있다.

if (value instanceof String text) {
    System.out.println(text.length());
}

패턴 변수 text는 컴파일러가 패턴 일치가 확실하다고 판단하는 흐름 범위 안에서만 사용할 수 있다. 조건식의 논리 구조도 패턴 변수의 유효 범위에 반영된다.

if (value instanceof String text && !text.isEmpty()) {
    System.out.println(text);
}

오른쪽 피연산자는 왼쪽의 타입 패턴이 성공한 경우에만 평가되므로 text를 사용할 수 있다.

Java SE 26에서는 기본 타입 패턴과 기본 타입을 대상으로 하는 instanceof 및 switch 확장이 프리뷰 기능으로 제공된다. 이는 참조 타입 중심이던 기존 패턴 매칭을 기본 타입으로 확장하는 단계이며, 프리뷰 기능을 사용하려면 컴파일과 실행 시 별도 옵션이 필요하다.^[25]

제네릭

제네릭은 클래스, 인터페이스와 메서드가 특정 참조 타입을 매개변수처럼 받아 타입 안전한 재사용 구조를 구성하도록 한다.

class Box<T> {
    private T value;

    Box(T value) {
        this.value = value;
    }

    T get() {
        return value;
    }

    void set(T value) {
        this.value = value;
    }
}

T는 타입 변수다. Box<String>에서 T는 String으로, Box<Integer>에서는 Integer로 사용된다.

Box<String> textBox = new Box<>("Java");
String text = textBox.get();

Box<Integer> numberBox = new Box<>(42);
Integer number = numberBox.get();

제네릭은 기본적으로 참조 타입만 타입 인수로 받는다. Box<int>는 사용할 수 없으므로 기본 타입을 저장하려면 Box<Integer>와 같은 래퍼 타입을 사용한다.

제네릭 타입은 불공변이다. Integer가 Number의 하위 타입이어도 List<Integer>는 List<Number>의 하위 타입이 아니다.

List<Integer> integers = new ArrayList<>();

// List<Number> numbers = integers;  // 컴파일 오류

이 제한은 List<Number> 참조를 통해 Double 같은 다른 숫자 타입이 List<Integer>에 삽입되는 상황을 방지한다.

타입 변수의 경계

타입 변수에는 extends를 사용하여 상한을 지정할 수 있다.

class NumericBox<T extends Number> {
    private final T value;

    NumericBox(T value) {
        this.value = value;
    }

    double doubleValue() {
        return value.doubleValue();
    }
}

T extends Number는 T가 Number 또는 그 하위 타입이어야 한다는 뜻이다. 클래스 하나와 여러 인터페이스를 결합한 다중 경계도 사용할 수 있다.

static <T extends Comparable<T> & java.io.Serializable>
T select(T first, T second) {
    return first.compareTo(second) >= 0 ? first : second;
}

다중 경계에서 클래스 타입이 있다면 가장 먼저 와야 하며 클래스 경계는 하나만 지정할 수 있다. 여러 인터페이스 경계는 뒤에 이어서 지정할 수 있다.

와일드카드

와일드카드 ?는 정확히 어떤 타입 인수인지 알 필요가 없거나 타입의 허용 범위만 표현할 때 사용한다.

static int sizeOf(List<?> values) {
    return values.size();
}

List<?>는 어떤 타입 인수를 사용하는 List도 받을 수 있다. 다만 실제 요소 타입을 알 수 없으므로 null 이외의 임의 값을 안전하게 추가할 수 없다.

상한 와일드카드는 특정 타입의 하위 타입을 읽는 데 사용한다.

static double sum(List<? extends Number> values) {
    double total = 0;

    for (Number value : values) {
        total += value.doubleValue();
    }

    return total;
}

List<? extends Number>에는 List<Integer>, List<Long>, List<Double> 등을 전달할 수 있다. 요소를 Number로 읽을 수 있지만 정확한 구성 요소 타입을 알 수 없어 일반적으로 값을 추가할 수 없다.

하한 와일드카드는 특정 타입이나 그 상위 타입의 컬렉션에 값을 쓰는 데 사용한다.

static void addDefaults(List<? super Integer> values) {
    values.add(0);
    values.add(1);
}

List<? super Integer>에는 List<Integer>, List<Number>, List<Object>를 전달할 수 있다.

일반적으로 값을 생산하는 쪽에는 extends, 값을 소비하는 쪽에는 super를 사용하는 규칙을 PECS라고 부르기도 한다.

타입 소거

Java 제네릭은 대부분 타입 소거를 통해 구현된다. 컴파일러는 타입 인수를 이용해 소스 수준의 타입 안전성을 검사한 뒤, 클래스 파일에서는 타입 변수를 상한 또는 Object에 가까운 표현으로 변환하고 필요한 캐스트를 삽입한다.^[26]

따라서 List<String>과 List<Integer>는 실행 시점에 서로 별도의 JVM 클래스로 생성되지 않는다. 두 객체 모두 일반적으로 List 구현 클래스의 인스턴스다.

이 구조는 제네릭 도입 이전에 작성된 Java 라이브러리와의 바이너리 호환성을 유지하는 데 기여했지만 다음과 같은 제약도 만든다.

• 실행 시점에 구체적인 타입 인수를 직접 검사하기 어렵다.
• new T()와 같은 타입 변수의 직접 인스턴스 생성이 불가능하다.
• 제네릭 타입의 배열을 직접 생성하기 어렵다.
• 기본 타입을 타입 인수로 사용할 수 없다.
• 타입 인수만 다른 메서드를 같은 소거 서명으로 오버로딩할 수 없다.
• 일부 경우 컴파일러가 브리지 메서드를 생성해야 한다.

if (value instanceof List<?>) {
    System.out.println("List instance");
}

// if (value instanceof List<String>) {}  // 허용되지 않음

실행 시점에는 객체가 List<String>인지 List<Integer>인지 일반적인 instanceof로 구분할 수 없으므로 비한정 와일드카드 형태를 사용한다.

원시 타입

제네릭 도입 이전 코드와의 호환성을 위해 타입 인수를 생략한 원시 타입을 사용할 수 있다.

List values = new ArrayList();
values.add("Java");
values.add(42);

원시 타입은 제네릭 타입 검사의 일부를 우회하므로 컴파일러가 비검사 경고를 발생시킬 수 있다. 값을 꺼낼 때 잘못된 캐스트가 삽입되면 실행 시점에 ClassCastException이 발생할 수 있다.

List values = new ArrayList();
values.add(42);

String text = (String) values.get(0);  // ClassCastException

원시 타입은 기존 API와의 상호 운용을 위한 기능이며, 새 코드에서는 구체적인 타입 인수나 와일드카드를 사용하는 방식이 일반적이다.

타입 추론

Java 컴파일러는 대입 문맥과 메서드 인수, 반환 타입을 분석하여 일부 타입 인수를 추론할 수 있다.

List<String> names = new ArrayList<>();

다이아몬드 연산자 <>를 사용하면 오른쪽 생성자 호출의 타입 인수 String을 대입 대상에서 추론한다.

제네릭 메서드에서도 타입 인수를 생략할 수 있다.

static <T> T first(T left, T right) {
    return left;
}

String value = first("Java", "JVM");

지역 변수에는 var를 사용하여 초기화식으로부터 타입을 추론하도록 할 수 있다.

var names = new ArrayList<String>();
var count = names.size();

var는 동적 타입이나 새로운 타입이 아니다. 컴파일러가 초기화식을 통해 구체적인 정적 타입을 결정하며, 이후 변수의 타입은 바뀌지 않는다. 필드와 메서드 매개변수 및 일반 반환 타입에는 사용할 수 없다.

열거형

열거형 클래스는 정해진 수의 이름 있는 인스턴스를 선언하는 특수한 클래스다.

enum Direction {
    NORTH,
    EAST,
    SOUTH,
    WEST
}

각 열거형 상수는 해당 열거형 클래스의 public static final 인스턴스다. 열거형은 필드와 메서드, 생성자를 가질 수 있다.

enum HttpStatus {
    OK(200),
    NOT_FOUND(404),
    INTERNAL_SERVER_ERROR(500);

    private final int code;

    HttpStatus(int code) {
        this.code = code;
    }

    int code() {
        return code;
    }
}

열거형 생성자는 외부에서 직접 호출할 수 없으며 상수 인스턴스는 클래스 초기화 과정에서 생성된다. 모든 열거형은 암시적으로 java.lang.Enum의 하위 클래스가 되므로 다른 클래스를 직접 상속할 수 없지만 여러 인터페이스를 구현할 수 있다.

열거형 상수에는 각자 별도의 클래스 본문을 부여하여 동작을 다르게 구현할 수도 있다. 이러한 경우 열거형 클래스는 허용된 상수별 하위 클래스만 가지는 암시적 봉인 계층으로 취급될 수 있다.

레코드

레코드는 고정된 데이터 구성 요소를 표현하기 위한 특수한 클래스다. 레코드 선언은 상태 설명을 기반으로 접근자와 생성자, equals, hashCode, toString을 자동으로 제공한다.^[27]

record Point(int x, int y) {
}

위 선언은 x와 y라는 레코드 구성 요소를 가지며 다음 요소를 자동으로 제공한다.

• 구성 요소에 대응하는 비공개 최종 필드
• x()와 y() 접근자
• 모든 구성 요소를 받는 표준 생성자
• 구성 요소 값을 기반으로 하는 equals
• 구성 요소 값을 기반으로 하는 hashCode
• 구성 요소 이름과 값을 포함하는 toString

레코드는 암시적으로 final이므로 다른 클래스가 상속할 수 없다. 모든 레코드는 java.lang.Record를 직접 상속하며 다른 클래스를 직접 상속할 수 없지만 인터페이스는 구현할 수 있다.

record Range(int start, int end) {
    Range {
        if (start > end) {
            throw new IllegalArgumentException(
                "start must not exceed end"
            );
        }
    }
}

위와 같은 압축 생성자는 매개변수 목록을 반복하지 않고 레코드 구성 요소를 검증하거나 정규화할 수 있다.

레코드는 참조 타입이며 자동으로 깊은 불변성을 제공하지 않는다. 레코드 필드의 참조 자체는 최종이지만, 해당 참조가 가리키는 객체가 변경 가능한 경우 내부 상태의 변화가 외부에서 관찰될 수 있다.

record NameList(List<String> names) {
}

names 필드에 다른 목록을 다시 대입할 수는 없지만 전달된 목록 자체의 요소는 변경될 수 있다. 완전한 불변 값 객체가 필요하면 방어적 복사나 불변 컬렉션을 사용할 수 있다.

봉인 클래스와 봉인 인터페이스

봉인 타입은 직접 하위 타입이 될 수 있는 클래스를 제한한다. sealed 클래스나 인터페이스는 허용되는 직접 하위 타입을 선언하거나 같은 컴파일 단위와 모듈 규칙을 통해 제한된 계층을 구성한다.^[28]

sealed interface Shape
    permits Circle, Rectangle, Triangle {
}

record Circle(double radius) implements Shape {
}

record Rectangle(double width, double height)
    implements Shape {
}

final class Triangle implements Shape {
}

봉인 타입의 직접 하위 타입은 다음 중 하나를 명시해야 한다.

• final: 더 이상 상속을 허용하지 않는다.
• sealed: 다시 제한된 하위 계층을 선언한다.
• non-sealed: 이후 하위 클래스에 대한 제한을 해제한다.

sealed class Message
    permits TextMessage, SystemMessage {
}

non-sealed class TextMessage extends Message {
}

final class SystemMessage extends Message {
}

봉인 클래스는 기존 클래스 단일 상속 모델을 유지하면서도 특정 도메인의 가능한 구현 종류를 명시적으로 제한한다. 컴파일러는 봉인 계층 정보를 이용해 패턴 switch가 모든 가능한 하위 타입을 처리하는지 검사할 수 있다.

패턴 매칭과 데이터 지향 처리

패턴은 값이 특정 구조와 조건에 맞는지 검사하면서 그 구성 요소를 변수에 바인딩하는 기능이다. 타입 패턴, 레코드 패턴과 switch 패턴을 조합하면 객체 계층을 검사하고 데이터를 추출하는 코드를 선언적으로 작성할 수 있다.

static double area(Shape shape) {
    return switch (shape) {
        case Circle(double radius) ->
            Math.PI * radius * radius;

        case Rectangle(double width, double height) ->
            width * height;

        case Triangle triangle ->
            triangle.area();
    };
}

레코드 패턴은 레코드 객체가 가진 구성 요소를 직접 분해한다.^[29]

record Point(int x, int y) {
}

static int coordinateSum(Object value) {
    if (value instanceof Point(int x, int y)) {
        return x + y;
    }

    return 0;
}

레코드 패턴은 중첩될 수 있다.

record Point(int x, int y) {
}

record Line(Point start, Point end) {
}

static int startX(Object value) {
    if (value instanceof Line(
        Point(int x, int y),
        Point end
    )) {
        return x;
    }

    return 0;
}

패턴을 사용하는 switch는 타입에 따라 분기하면서 패턴 변수를 제공한다. 봉인 타입과 함께 사용하면 컴파일러가 가능한 직접 하위 타입을 파악하여 완전성을 검사할 수 있다.^[30]

패턴 switch에서는 더 일반적인 패턴이 앞에 와서 뒤의 구체적인 패턴을 가리지 않도록 지배 관계를 검사한다.

static String describe(Object value) {
    return switch (value) {
        case String text -> "text: " + text;
        case CharSequence sequence ->
            "sequence: " + sequence;
        default -> "other";
    };
}

String은 CharSequence의 하위 타입이므로 더 구체적인 String 패턴이 먼저 와야 한다.

중첩 클래스

클래스와 인터페이스는 다른 클래스나 인터페이스 안에 중첩될 수 있다. 중첩 클래스는 정적 중첩 클래스와 내부 클래스로 나뉜다.

class Container {
    static class Entry {
        private final String key;

        Entry(String key) {
            this.key = key;
        }
    }
}

정적 중첩 클래스는 바깥 클래스의 인스턴스와 자동으로 연결되지 않는다. 바깥 클래스의 정적 멤버처럼 클래스 이름을 통해 접근한다.

비정적 멤버 클래스는 내부 클래스이며 바깥 객체에 대한 참조를 가진다.

class Document {
    private String title;

    class Section {
        String documentTitle() {
            return title;
        }
    }
}

내부 클래스의 인스턴스는 일반적으로 특정 Document 인스턴스와 연결된다. 내부 클래스 메서드는 연결된 바깥 객체의 인스턴스 멤버에 접근할 수 있다.

메서드 안에는 지역 클래스를 선언할 수 있고, 이름 없는 일회성 하위 클래스나 인터페이스 구현체가 필요할 때는 익명 클래스를 사용할 수 있다.

Runnable task = new Runnable() {
    @Override
    public void run() {
        System.out.println("running");
    }
};

함수형 인터페이스를 구현하는 단순한 익명 클래스는 람다 표현식으로 대체할 수 있지만, 익명 클래스와 람다는 this의 의미와 클래스 생성 여부 등에서 동일한 구조는 아니다.

접근 제어

Java는 멤버와 최상위 타입의 접근 범위를 제어하기 위해 접근 제한자를 제공한다.

최상위 클래스와 인터페이스는 public 또는 패키지 접근 수준만 가질 수 있다. 중첩 타입은 다른 멤버처럼 private과 protected도 사용할 수 있다.

protected 멤버는 같은 패키지에서는 일반적인 패키지 접근처럼 사용할 수 있다. 다른 패키지의 하위 클래스에서는 상속 관계를 통한 접근에 추가 규칙이 적용되며, 임의의 상위 클래스 인스턴스를 통해 자유롭게 접근할 수 있는 것은 아니다.

Java의 접근 제어는 컴파일 시점과 링킹 및 실행 시점에 모두 검사될 수 있다. 리플렉션과 모듈 시스템도 별도의 접근 및 캡슐화 규칙을 적용한다.

불변성과 final

final은 적용 위치에 따라 의미가 달라진다.

• final 변수는 한 번만 대입할 수 있다.
• final 필드는 생성 과정에서 한 번 설정한 뒤 다시 대입할 수 없다.
• final 메서드는 하위 클래스에서 오버라이딩할 수 없다.
• final 클래스는 상속할 수 없다.

final List<String> names = new ArrayList<>();
names.add("Java");

// names = new ArrayList<>();  // 다시 대입할 수 없음

참조 변수를 final로 선언해도 참조 대상 객체가 자동으로 불변이 되는 것은 아니다. 위 코드에서는 names가 다른 목록을 가리키도록 바꿀 수 없지만 현재 목록의 요소는 수정할 수 있다.

불변 객체는 보통 다음 요소를 함께 사용해 구성한다.

• 객체 상태를 외부에서 변경할 수 없도록 필드를 비공개로 선언
• 필요한 필드를 final로 선언
• 변경 메서드를 제공하지 않음
• 변경 가능한 객체를 입력받거나 반환할 때 방어적 복사 사용
• 상속을 통한 상태 변경을 막도록 클래스 계층 제한
• 생성 과정에서 유효성 조건 확인

레코드는 이러한 구조의 일부를 자동으로 제공하지만 참조 구성 요소의 깊은 불변성까지 보장하지는 않는다.

타입과 실행 시점 클래스

참조 표현식에는 컴파일 시점 타입과 실행 시점 클래스가 함께 존재할 수 있다.

Animal animal = new Dog();

• 변수의 컴파일 시점 타입은 Animal이다.
• 객체의 실행 시점 클래스는 Dog다.
• 접근 가능한 멤버는 주로 Animal 타입을 기준으로 검사된다.
• 오버라이딩된 인스턴스 메서드 구현은 Dog를 기준으로 선택된다.

getClass()는 객체의 실제 실행 시점 클래스를 나타내는 Class 객체를 반환한다.

System.out.println(animal.getClass().getName());

Class 객체는 리플렉션 API와 클래스 로딩, 애너테이션 조회 및 실행 시점 타입 조사에 사용된다. 다만 일반적인 다형성 코드에서는 구체 클래스 이름을 직접 비교하기보다 인터페이스와 오버라이딩, 패턴 매칭을 사용하는 편이 타입 계층의 확장에 더 자연스럽다.

배열과 제네릭의 객체 모델 차이

배열과 제네릭 컬렉션은 모두 여러 값을 다루지만 타입 모델에는 중요한 차이가 있다.

Number[] numberArray = new Integer[10];
List<? extends Number> numberList =
    new ArrayList<Integer>();

배열은 실제 구성 요소 타입이 Integer라는 정보를 실행 중에도 유지하므로 잘못된 저장을 검사할 수 있다. 제네릭 컬렉션은 타입 소거를 사용하지만 컴파일러가 소스 수준에서 허용되는 읽기와 쓰기 연산을 제한한다.

객체 모델의 성격

Java의 객체 모델은 모든 값을 객체로 통일하지 않는다. 기본 타입은 객체와 분리되어 있으며 성능과 표현 효율을 위해 직접적인 값으로 처리된다. 래퍼 클래스와 자동 박싱이 두 영역을 연결하지만 의미와 실행 비용은 완전히 같지 않다.

클래스는 구현 상태와 단일 상속 계층을 구성하고, 인터페이스는 여러 타입 계약을 결합한다. 제네릭은 컴파일 시점의 타입 안전성을 확장하며, 레코드는 데이터 중심 클래스를 간결하게 표현한다. 봉인 타입과 패턴 매칭은 가능한 하위 타입을 제한하고 객체의 구조를 안전하게 분해하는 기능을 제공한다.

이 구조는 Java의 초기 클래스 중심 객체 지향 모델을 유지하면서도, 인터페이스 기반 설계와 함수형 인터페이스, 명시적인 데이터 모델 및 패턴 기반 분기를 함께 사용할 수 있도록 확장된 형태다.

Java는 C (프로그래밍 언어)와 C++에서 이어진 중괄호 기반 문법을 사용한다. 문장은 일반적으로 세미콜론으로 끝나며, 중괄호는 클래스와 메서드, 조건문, 반복문 등의 범위를 나타낸다. 그러나 Java의 문법은 단순한 표기법만 정의하지 않고 이름의 유효 범위, 표현식 평가 순서, 타입 변환, 예외 전파와 객체 초기화 같은 실행 의미까지 함께 규정한다.

Java 프로그램은 전통적으로 클래스와 인터페이스 등의 타입 선언으로 구성된다. 메서드 밖에는 일반 실행문을 직접 작성하지 않으며, 애플리케이션의 실행은 시작 메서드인 main을 통해 이루어진다. Java 25부터는 작은 프로그램을 위한 간결한 소스 파일과 인스턴스 main 메서드가 정식 기능으로 추가되었지만, 이 경우에도 소스의 필드와 메서드는 컴파일러가 암시적으로 선언하는 클래스의 멤버로 처리된다.^[31]

소스 코드의 어휘 구조

Java 소스 코드는 유니코드 문자로 작성된다. 컴파일러는 입력 문자를 유니코드 이스케이프, 줄 구분자, 토큰의 순서로 처리하며, 토큰은 식별자와 키워드, 리터럴, 구분자, 연산자로 나뉜다.^[32]

package example;

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, Java");
    }
}

공백과 줄바꿈은 대부분 토큰을 구분하는 역할만 한다. 따라서 다음 두 표현은 문법적으로 같은 의미를 가진다.

int result = left + right;

int result
    =
    left
    +
    right;

다만 문자열과 문자 리터럴, 텍스트 블록, 주석 내부에서는 공백과 줄바꿈이 데이터의 일부가 되거나 별도의 규칙을 따른다.

주석

Java는 세 종류의 주석을 지원한다.

// 한 줄 주석

/*
 * 여러 줄에 걸친
 * 블록 주석
 */

/**
 * 문서화 주석
 */

// 주석은 현재 줄의 끝까지 이어지고, /* ... */ 주석은 여러 줄을 포함할 수 있다. 블록 주석은 중첩되지 않는다.

/** ... */ 형태는 일반 블록 주석으로도 처리되지만, javadoc 도구가 클래스와 메서드, 필드 등의 API 문서를 생성할 때 사용하는 문서화 주석이기도 하다.

/**
 * 두 정수의 합을 계산한다.
 *
 * @param left 첫 번째 값
 * @param right 두 번째 값
 * @return 두 값의 합
 */
public static int add(int left, int right) {
    return left + right;
}

문서화 주석의 @param, @return, @throws 등의 태그는 Java 언어의 실행 문법은 아니지만, 소스 코드와 API 문서를 함께 관리하는 표준적인 방식으로 사용된다.

식별자와 키워드

식별자는 변수와 메서드, 클래스, 인터페이스, 패키지 등의 이름이다.

int count;
String userName;
class NetworkClient {
}

식별자는 숫자로 시작할 수 없으며 키워드와 true, false, null을 이름으로 사용할 수 없다.

// int 1stValue;  // 숫자로 시작할 수 없음
// int class;     // 키워드를 사용할 수 없음
// int null;      // null은 식별자가 아님

Java 식별자는 ASCII 영문자에 한정되지 않고 유니코드 문자도 사용할 수 있다. 다만 여러 언어와 도구를 함께 사용하는 프로젝트에서는 영문자와 숫자, 밑줄을 중심으로 이름을 구성하는 경우가 일반적이다.

Java의 키워드에는 class, interface, if, switch, return, new, public, private 등이 있다. 일부 단어는 모든 위치에서 항상 예약되는 키워드가 아니라 특정 문법 위치에서만 특별한 의미를 갖는 문맥 키워드다.

대표적인 문맥 키워드는 다음과 같다.

• var
• record
• sealed
• permits
• yield
• module
• requires
• exports
• opens
• transitive

예를 들어 record는 레코드 선언이 시작되는 위치에서는 특별한 의미를 갖지만, 일부 다른 문맥에서는 기존 코드와의 호환성을 위해 일반 이름으로 사용될 수 있다.

리터럴

리터럴은 소스 코드에 직접 작성하는 값이다.

int decimal = 42;
int hexadecimal = 0x2A;
int binary = 0b101010;
long large = 9_000_000_000L;

double ratio = 0.75;
float progress = 0.75F;

boolean enabled = true;
char grade = 'A';
String language = "Java";
Object missing = null;

정수 리터럴은 10진수와 16진수, 8진수, 2진수로 표현할 수 있다.

int decimal = 255;
int hexadecimal = 0xFF;
int octal = 0377;
int binary = 0b1111_1111;

숫자 리터럴에는 가독성을 위해 밑줄을 넣을 수 있다. 밑줄은 숫자의 값에 영향을 주지 않지만 리터럴의 시작과 끝, 소수점이나 접미사 바로 주변처럼 허용되지 않는 위치가 있다.

정수 리터럴은 기본적으로 int이며, L 또는 l 접미사가 붙으면 long이다. 소문자 l은 숫자 1과 구분하기 어려우므로 대문자 L이 일반적으로 사용된다.

부동소수점 리터럴은 기본적으로 double이며 F 접미사를 붙이면 float가 된다.

double first = 3.14159;
double scientific = 1.25e3;
float second = 3.14F;

문자 리터럴은 작은따옴표, 문자열 리터럴은 큰따옴표를 사용한다.

char newline = '\n';
char unicode = '\u004A';
String message = "Hello\nJava";

이스케이프 시퀀스는 줄바꿈과 탭, 따옴표, 역슬래시 등의 문자를 표현한다.

텍스트 블록

여러 줄 문자열은 세 개의 큰따옴표를 사용하는 텍스트 블록으로 표현할 수 있다.

String html = """
    <html>
        <body>
            <h1>Hello</h1>
        </body>
    </html>
    """;

텍스트 블록은 JSON과 HTML, SQL, 코드 조각처럼 여러 줄로 이루어진 텍스트를 기존 문자열 연결보다 읽기 쉽게 작성하는 데 사용된다.

String query = """
    SELECT id, name
    FROM users
    WHERE active = true
    ORDER BY name
    """;

컴파일러는 닫는 구분자의 위치와 각 줄의 공통 들여쓰기를 기준으로 부수적인 들여쓰기를 제거한다. 텍스트 블록도 결과적으로는 String 값을 생성하며 별도의 문자열 타입을 만들지 않는다.

변수 선언

변수 선언은 타입과 이름, 선택적인 초기화식으로 구성된다.

int count;
int limit = 100;
String name = "Java";

하나의 문장에서 같은 타입의 변수를 여러 개 선언할 수도 있다.

int x = 10, y = 20;

그러나 각 변수의 초기화와 수정이 독립적인 경우에는 별도 문장으로 나누는 편이 일반적으로 읽기 쉽다.

변수는 선언 위치에 따라 다음과 같이 구분된다.

• 인스턴스 필드
• 정적 필드
• 메서드 매개변수
• 생성자 매개변수
• 지역 변수
• 예외 매개변수
• 람다 매개변수
• 패턴 변수

필드는 객체나 클래스가 유지하는 상태이며 자동으로 기본값을 받는다. 지역 변수는 사용 전에 컴파일러가 값이 확실히 할당되었다고 판단할 수 있어야 한다.

int value;

// System.out.println(value);  // 초기화되지 않아 컴파일 오류

value = 10;
System.out.println(value);

지역 변수 타입 추론

지역 변수 선언에서는 명시적인 타입 대신 var를 사용할 수 있다.

var name = "Java";
var count = 10;
var values = new ArrayList<String>();

컴파일러는 초기화식으로부터 변수의 정적 타입을 추론한다. var는 동적 타입이나 모든 값을 담는 범용 타입이 아니다.

var value = 10;

// value = "Java";  // value의 타입은 int이므로 컴파일 오류

var 선언에는 초기화식이 필요하며 여러 변수를 한 번에 선언할 수 없다.

// var value;
// var left = 1, right = 2;
// var nothing = null;

null만으로는 구체적인 타입을 추론할 수 없으므로 var nothing = null도 허용되지 않는다.

var는 지역 변수와 향상된 for 문의 변수, 일부 람다 매개변수에 사용할 수 있지만 클래스 필드와 일반 메서드 매개변수, 반환 타입에는 사용할 수 없다.

상수와 final

변수에 final을 붙이면 초기화된 뒤 다시 대입할 수 없다.

final int maxConnections = 128;

static final 필드는 클래스 수준 상수를 표현할 때 자주 사용된다.

class Protocol {
    static final int DEFAULT_PORT = 8080;
}

기본 타입 또는 String 타입의 static final 필드가 상수 표현식으로 초기화되면 컴파일 시간 상수가 될 수 있다. 컴파일러는 이러한 값을 사용하는 클래스 파일에 직접 포함할 수 있다.

static final int BUFFER_SIZE = 1024 * 8;

참조 변수의 final은 참조를 다시 대입하지 못하게 할 뿐, 참조 대상 객체를 자동으로 불변으로 만들지는 않는다.

final List<String> names = new ArrayList<>();

names.add("Java");

// names = new ArrayList<>();  // 다시 대입할 수 없음

연산자

Java는 산술과 비교, 논리, 비트, 대입, 조건 연산자를 제공한다.^[33]

산술 연산자

int sum = left + right;
int difference = left - right;
int product = left * right;
int quotient = left / right;
int remainder = left % right;

정수 나눗셈은 소수 부분을 버리고 0 방향으로 절단한다.

int result = 7 / 2;  // 3

정수를 0으로 나누면 ArithmeticException이 발생한다. 부동소수점 나눗셈은 IEEE 754 규칙에 따라 무한대 또는 NaN을 생성할 수 있다.

double infinity = 1.0 / 0.0;
double notANumber = 0.0 / 0.0;

+ 연산자는 숫자 덧셈뿐 아니라 문자열 연결에도 사용된다.

String message = "count = " + count;

피연산자 중 하나가 문자열이면 다른 값도 문자열 표현으로 변환되어 연결된다. 연산은 왼쪽부터 결합되므로 순서에 따라 결과가 달라질 수 있다.

System.out.println(1 + 2 + " Java");  // 3 Java
System.out.println("Java " + 1 + 2);  // Java 12

증가와 감소

count++;
count--;
++count;
--count;

후위 연산자는 기존 값을 표현식 결과로 사용한 뒤 값을 변경하고, 전위 연산자는 값을 먼저 변경한 뒤 변경된 값을 결과로 사용한다.

int value = 10;

int first = value++;  // first는 10, value는 11
int second = ++value; // value는 12, second도 12

한 표현식 안에서 같은 변수에 여러 부수 효과를 섞으면 평가 순서를 이해하기 어려워질 수 있으므로 보통 별도 문장으로 분리한다.

비교와 논리 연산자

boolean same = left == right;
boolean different = left != right;
boolean less = left < right;
boolean valid = enabled && count > 0;
boolean fallback = primary || secondary;
boolean disabled = !enabled;

&&와 ||는 단락 평가를 수행한다. 결과가 왼쪽 피연산자만으로 결정되면 오른쪽 피연산자를 평가하지 않는다.

if (value != null && !value.isEmpty()) {
    System.out.println(value);
}

value가 null이면 두 번째 조건을 평가하지 않으므로 NullPointerException이 발생하지 않는다.

&와 |도 boolean 값에 사용할 수 있지만 양쪽 피연산자를 모두 평가한다. 정수 타입에 사용하면 비트 단위 연산을 수행한다.

비트와 이동 연산자

int and = left & right;
int or = left | right;
int xor = left ^ right;
int inverted = ~left;

int shiftedLeft = value << 2;
int shiftedRight = value >> 2;
int unsignedRight = value >>> 2;

>>는 부호를 유지하는 산술 오른쪽 이동이고, >>>는 왼쪽을 0으로 채우는 논리 오른쪽 이동이다.

Java에는 정수 타입의 부호 없는 표현 타입이 별도로 없지만, Integer와 Long의 부호 없는 비교·나눗셈·문자열 변환 API를 이용하여 비트 패턴을 부호 없는 값처럼 처리할 수 있다.

대입 연산자

count = 10;
count += 5;
count -= 2;
count *= 3;
count /= 2;
count %= 4;

복합 대입 연산자는 단순히 왼쪽 피연산자를 두 번 작성한 문법과 완전히 같지는 않다. 왼쪽 표현식은 한 번만 평가되며, 필요한 경우 연산 결과를 왼쪽 변수의 타입으로 암시적으로 변환한다.

byte value = 10;

value += 1;

// value = value + 1;  // value + 1은 int이므로 명시적 변환 필요

조건 연산자

조건 연산자는 조건에 따라 두 표현식 중 하나의 값을 선택한다.

String status = active ? "enabled" : "disabled";

조건 연산자는 값을 생성하는 표현식이므로 변수 초기화나 메서드 인수, 반환문 안에서 사용할 수 있다. 복잡한 분기를 중첩하면 읽기 어려워질 수 있으므로 단순한 값 선택에 주로 사용된다.

표현식 평가 순서

Java는 표현식의 피연산자를 일반적으로 왼쪽에서 오른쪽으로 평가한다. 이는 컴파일러 구현에 따라 순서가 달라질 수 있는 일부 언어와 구분되는 특성이다.

int result = first() + second();

위 표현식에서는 first()가 먼저 호출되고 정상적으로 값을 반환한 뒤 second()가 호출된다.

메서드 호출에서도 대상 표현식을 먼저 평가한 뒤 인수를 왼쪽에서 오른쪽으로 평가한다. 평가 도중 예외가 발생하면 이후 피연산자는 평가되지 않는다.

연산자 우선순위는 표현식이 어떤 구조로 묶이는지를 결정하지만 실제 코드에서는 괄호를 사용해 의도를 명확히 할 수 있다.

int result = left + right * scale;

int explicit = left + (right * scale);

블록과 유효 범위

블록은 중괄호로 묶인 문장과 선언의 집합이다.

{
    int temporary = 10;
    System.out.println(temporary);
}

지역 변수는 선언된 위치부터 해당 블록의 끝까지 사용할 수 있다.

int outer = 10;

if (outer > 0) {
    int inner = 20;
    System.out.println(outer + inner);
}

// System.out.println(inner);  // 범위 밖이므로 컴파일 오류

내부 블록에서는 바깥 지역 변수와 같은 이름의 지역 변수를 다시 선언할 수 없는 경우가 있다. 필드와 지역 변수의 이름이 같다면 this를 사용하여 현재 객체의 필드를 명시할 수 있다.

class User {
    private String name;

    User(String name) {
        this.name = name;
    }
}

조건문

if 문은 boolean 조건에 따라 문장을 실행한다.

if (temperature > 30) {
    System.out.println("hot");
} else if (temperature < 10) {
    System.out.println("cold");
} else {
    System.out.println("normal");
}

조건식은 반드시 boolean 타입이어야 한다.

int count = 1;

// if (count) {}  // 정수를 조건으로 사용할 수 없음

if (count != 0) {
    System.out.println("non-zero");
}

중괄호는 문장이 하나일 때 생략할 수 있다.

if (enabled)
    start();

그러나 이후 문장을 추가할 때 범위를 잘못 해석할 수 있으므로 일반적으로 중괄호를 유지한다.

전통적인 switch 문

switch는 하나의 선택자 값을 여러 case와 비교한다.

switch (command) {
    case "start":
        start();
        break;

    case "stop":
        stop();
        break;

    default:
        showHelp();
        break;
}

콜론 형식의 case에서는 break를 만나거나 switch가 끝날 때까지 다음 레이블의 문장으로 실행이 이어질 수 있다.

switch (level) {
    case 3:
        enableAdvanced();

    case 2:
        enableStandard();

    case 1:
        enableBasic();
        break;

    default:
        break;
}

이러한 폴스루는 여러 조건에서 공통 작업을 수행할 때 사용할 수 있지만, 의도하지 않은 누락과 혼동을 만들 수 있다.

switch 표현식

화살표 레이블을 사용하는 switch는 각 분기가 독립적으로 실행되며 값을 생성하는 표현식으로 사용할 수 있다.

String label = switch (status) {
    case 200 -> "OK";
    case 404 -> "Not Found";
    case 500 -> "Internal Server Error";
    default -> "Unknown";
};

화살표 오른쪽에는 표현식과 블록 또는 throw 문을 사용할 수 있다.

int score = switch (grade) {
    case "A" -> 100;
    case "B" -> 80;

    case "C" -> {
        int base = 60;
        int bonus = calculateBonus();
        yield base + bonus;
    }

    default -> throw new IllegalArgumentException(
        "unknown grade: " + grade
    );
};

블록 형태의 분기에서 값을 반환하려면 return이 아니라 yield를 사용한다. return은 현재 메서드 전체를 종료하지만 yield는 현재 switch 표현식의 값을 제공한다.

switch 표현식은 가능한 입력을 모두 처리해야 한다. 열거형이나 봉인 타입에서는 컴파일러가 알려진 가능한 값을 이용해 완전성을 검사할 수 있다.

패턴 switch

패턴 매칭을 사용하는 switch는 값의 실행 시점 타입을 검사하면서 패턴 변수를 선언할 수 있다.

static String describe(Object value) {
    return switch (value) {
        case Integer number ->
            "integer: " + number;

        case String text ->
            "text: " + text;

        case null ->
            "null";

        default ->
            "other";
    };
}

패턴에는 추가 조건인 when 가드를 붙일 수 있다.

static String classify(Object value) {
    return switch (value) {
        case Integer number when number > 0 ->
            "positive integer";

        case Integer number when number < 0 ->
            "negative integer";

        case Integer number ->
            "zero";

        default ->
            "not an integer";
    };
}

더 일반적인 패턴이 먼저 등장해 뒤의 구체적인 패턴을 항상 가리는 경우 컴파일 오류가 발생한다. 따라서 하위 타입이나 구체적인 조건을 먼저 배치하고 상위 타입과 기본 분기를 뒤에 배치한다.

while과 do-while

while 문은 조건이 참인 동안 본문을 반복한다.

int count = 0;

while (count < 10) {
    System.out.println(count);
    count++;
}

조건은 본문 실행 전에 검사되므로 처음부터 거짓이면 본문이 한 번도 실행되지 않는다.

do-while은 본문을 먼저 실행한 뒤 조건을 검사한다.

int value;

do {
    value = readValue();
} while (value < 0);

따라서 do-while의 본문은 최소 한 번 실행된다.

기본 for 문

기본 for 문은 초기화, 조건, 갱신 표현식을 한곳에 배치한다.

for (int index = 0; index < 10; index++) {
    System.out.println(index);
}

세 부분은 각각 생략할 수 있다.

for (;;) {
    process();

    if (shouldStop()) {
        break;
    }
}

초기화 영역에 선언한 변수는 for 문의 조건과 갱신, 본문 안에서만 사용할 수 있다.

향상된 for 문

배열이나 Iterable을 순회할 때는 향상된 for 문을 사용할 수 있다.

List<String> languages = List.of(
    "Java",
    "Kotlin",
    "Scala"
);

for (String language : languages) {
    System.out.println(language);
}

배열에도 같은 형식을 사용한다.

int[] values = {10, 20, 30};

for (int value : values) {
    System.out.println(value);
}

향상된 for 문의 변수에는 각 요소의 값 또는 참조가 대입된다. 변수 자체에 다른 값을 대입해도 원래 배열이나 컬렉션의 요소를 교체하지 않는다.

컬렉션을 순회하면서 구조를 변경해야 한다면 Iterator의 제거 기능이나 컬렉션이 제공하는 별도 연산을 사용할 수 있다.

break, continue와 레이블

break는 현재 반복문이나 switch를 종료한다.

for (String value : values) {
    if (value.equals(target)) {
        break;
    }
}

continue는 현재 반복의 남은 부분을 건너뛰고 다음 반복으로 이동한다.

for (String value : values) {
    if (value.isBlank()) {
        continue;
    }

    process(value);
}

Java 문장에는 레이블을 붙일 수 있으며, 레이블이 지정된 break와 continue로 중첩된 구조의 바깥쪽 반복문을 제어할 수 있다.

search:
for (int row = 0; row < matrix.length; row++) {
    for (int column = 0;
         column < matrix[row].length;
         column++) {

        if (matrix[row][column] == target) {
            break search;
        }
    }
}

레이블은 제한적으로 유용하지만 중첩 흐름이 복잡해질 경우 메서드 추출이나 별도 탐색 함수로 구조를 분리할 수도 있다.

메서드 선언

메서드는 수정자와 반환 타입, 이름, 매개변수 목록, 선택적인 throws 절과 본문으로 구성된다.

public static int add(int left, int right) {
    return left + right;
}

값을 반환하지 않는 메서드는 반환 타입으로 void를 사용한다.

static void printMessage(String message) {
    System.out.println(message);
}

반환 타입이 void가 아닌 메서드의 정상적인 모든 실행 경로는 호환되는 값을 반환해야 한다.

static int absolute(int value) {
    if (value < 0) {
        return -value;
    }

    return value;
}

메서드 호출 시 인수 표현식은 왼쪽에서 오른쪽으로 평가되고, 계산된 값이 매개변수로 전달된다. Java에서는 기본 타입의 값과 객체 참조 모두 값으로 전달된다.

메서드 시그니처와 오버로딩

Java 언어에서 메서드 시그니처는 주로 메서드 이름과 타입 매개변수, 형식 매개변수 타입으로 결정된다. 반환 타입만 다른 메서드는 같은 클래스에 함께 선언할 수 없다.

static int parse(String value) {
    return Integer.parseInt(value);
}

static int parse(String value, int radix) {
    return Integer.parseInt(value, radix);
}

컴파일러는 호출 위치의 인수 개수와 정적 타입, 허용되는 변환을 이용해 가장 구체적인 오버로드를 선택한다.

static void print(Object value) {
    System.out.println("Object");
}

static void print(String value) {
    System.out.println("String");
}

String text = "Java";
print(text);  // String 오버로드

오버로딩은 컴파일 시점에 결정되므로 인수 객체의 실행 시점 클래스가 아니라 표현식의 컴파일 시점 타입이 기준이 된다.

가변 인자

마지막 매개변수에 ...를 사용하면 호출자가 여러 인수를 전달할 수 있다.

static int sum(int... values) {
    int result = 0;

    for (int value : values) {
        result += value;
    }

    return result;
}

호출할 때는 개별 인수 또는 배열을 전달할 수 있다.

int first = sum(1, 2, 3);
int second = sum(new int[]{4, 5, 6});

가변 인자는 메서드 내부에서 배열로 처리된다. 가변 인자 매개변수는 매개변수 목록의 마지막에 하나만 선언할 수 있다.

제네릭 가변 인자는 타입 소거와 배열의 실행 시점 타입이 결합되면서 힙 오염 경고를 만들 수 있다. 구현이 안전한 경우 @SafeVarargs를 사용하여 조건을 명시할 수 있다.

람다 표현식

람다 표현식은 함수형 인터페이스의 구현을 간결하게 작성한다.

Function<String, Integer> length =
    text -> text.length();

매개변수가 하나일 때 타입과 괄호를 생략할 수 있다.

Predicate<String> empty = text -> text.isEmpty();

BiFunction<Integer, Integer, Integer> add =
    (left, right) -> left + right;

여러 문장을 실행하려면 블록 본문을 사용한다.

Consumer<String> printer = text -> {
    String normalized = text.trim();
    System.out.println(normalized);
};

값을 반환하는 블록 람다에서는 return을 사용한다.

Function<String, Integer> parser = text -> {
    String normalized = text.trim();
    return Integer.parseInt(normalized);
};

람다는 바깥 지역 변수에 접근할 수 있지만 해당 변수는 final이거나 사실상 최종이어야 한다.

int offset = 10;

Function<Integer, Integer> addOffset =
    value -> value + offset;

// offset++;  // 람다에서 사용했으므로 변경할 수 없음

인스턴스 필드는 지역 변수와 다른 수명을 가지므로 람다 내부에서 읽고 변경할 수 있다.

메서드 참조

기존 메서드를 함수형 인터페이스의 구현으로 사용할 때는 :: 메서드 참조를 사용할 수 있다.

Function<String, Integer> parser =
    Integer::parseInt;

Consumer<String> printer =
    System.out::println;

대표적인 형태는 다음과 같다.

ClassName::staticMethod
object::instanceMethod
ClassName::instanceMethod
ClassName::new
TypeName[]::new

메서드 참조의 실제 대상은 대입 문맥의 함수형 인터페이스 타입을 기준으로 결정된다. 따라서 :: 표현식만으로 독립된 함수 타입이 생성되는 것은 아니다.

패키지 선언

패키지는 타입 이름을 구분하고 관련 코드를 묶는 이름 공간이다.

package com.example.application;

패키지 선언은 일반 소스 파일에서 주석과 공백을 제외하면 파일의 앞부분에 배치한다. 패키지 선언이 없으면 이름 없는 패키지에 속한다.

패키지 이름은 일반적으로 조직의 인터넷 도메인을 역순으로 사용한다.

com.example.project
org.openjdk.tools
io.wave.runtime

패키지 구조와 파일 시스템 디렉터리가 언어 차원에서 반드시 동일해야 하는 것은 아니지만, 일반적인 컴파일러와 빌드 도구는 패키지 이름에 맞춘 디렉터리 구조를 사용한다.

임포트 선언

임포트는 다른 패키지나 타입의 이름을 현재 컴파일 단위에서 단순 이름으로 사용할 수 있게 한다.

import java.util.ArrayList;
import java.util.List;

임포트는 클래스를 메모리에 로딩하거나 다른 파일의 코드를 현재 파일에 복사하지 않는다. 컴파일러의 이름 해석에 사용할 별칭 범위를 제공한다.

별표를 사용하면 한 패키지의 공개 최상위 타입을 필요할 때 이름으로 찾을 수 있다.

import java.util.*;

이 형식은 하위 패키지를 가져오지 않는다. java.util.*은 java.util.concurrent의 타입을 포함하지 않는다.

정적 임포트는 다른 타입의 정적 멤버를 단순 이름으로 사용할 수 있게 한다.

import static java.lang.Math.PI;
import static java.lang.Math.sqrt;

double radius = 10;
double circumference = 2 * PI * radius;
double diagonal = sqrt(2);

같은 단순 이름을 가진 여러 타입이 임포트되어 모호해지면 정규화된 이름을 직접 사용해야 한다.

java.util.Date utilDate = new java.util.Date();
java.sql.Date sqlDate =
    java.sql.Date.valueOf("2026-07-18");

java.lang 패키지의 공개 타입은 일반 소스 파일에 자동으로 임포트되므로 String, Object, System, Integer 등을 별도 임포트 없이 사용할 수 있다.

모듈 임포트

Java 25부터 import module 선언을 사용하여 모듈이 내보내는 여러 패키지의 공개 최상위 타입을 한 번에 임포트할 수 있다.^[34]

import module java.base;

이는 모듈 자체를 변수나 이름 공간으로 가져오는 문법이 아니다. 대상 모듈이 현재 모듈에 내보내는 패키지와 전이적으로 읽을 수 있는 관련 모듈의 공개 최상위 타입을 필요에 따라 단순 이름으로 사용할 수 있게 한다.

import module java.base;

class Example {
    List<String> names =
        List.of("Java", "Kotlin", "Scala");

    BigInteger value =
        new BigInteger("12345678901234567890");
}

명시적인 단일 타입 임포트는 패키지 단위나 모듈 단위의 요구 시 임포트보다 구체적이므로 이름 해석에서 우선할 수 있다. 동일한 단순 이름이 여러 경로에서 제공되어 모호하면 정규화된 이름이나 명시적인 임포트가 필요하다.

접근 제한자

Java는 타입과 멤버의 접근 범위를 제한하기 위해 public, protected, private와 패키지 접근을 제공한다.

public class Account {
    private long balance;

    protected void validate() {
    }

    public long balance() {
        return balance;
    }

    void updateInternalState() {
    }
}

제한자를 생략한 멤버는 같은 패키지에서 접근할 수 있다.

접근 제한은 단순히 이름을 숨기는 표기가 아니라 컴파일러와 JVM이 검사하는 규칙이다. 모듈 시스템에서는 패키지가 public 타입을 포함하더라도 해당 패키지를 다른 모듈에 내보내지 않았다면 모듈 외부에서 일반적으로 접근할 수 없다.

애너테이션

애너테이션은 프로그램 선언이나 타입 사용 위치에 구조화된 메타데이터를 붙이는 기능이다.^[35]

@Override
public String toString() {
    return "Example";
}

@Override는 해당 메서드가 상위 클래스나 인터페이스의 메서드를 오버라이딩한다는 의도를 컴파일러에 전달한다. 실제로 오버라이딩하지 않으면 컴파일 오류가 발생한다.

대표적인 표준 애너테이션은 다음과 같다.

• @Override
• @Deprecated
• @SuppressWarnings
• @SafeVarargs
• @FunctionalInterface

사용자 정의 애너테이션은 @interface로 선언한다.

@interface Route {
    String path();

    String method() default "GET";
}

애너테이션 요소는 매개변수가 없는 메서드와 비슷한 형태로 선언한다.

@Route(
    path = "/users",
    method = "POST"
)
class UserController {
}

value라는 이름의 요소 하나만 지정할 때는 요소 이름을 생략할 수 있다.

@interface Author {
    String value();
}

@Author("James Gosling")
class LanguageHistory {
}

메타 애너테이션

애너테이션 선언 자체에 붙여 동작을 지정하는 애너테이션을 메타 애너테이션이라고 한다.

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target({
    ElementType.TYPE,
    ElementType.METHOD
})
@interface Audited {
}

@Target은 애너테이션을 사용할 수 있는 위치를 지정한다.

• TYPE
• FIELD
• METHOD
• PARAMETER
• CONSTRUCTOR
• LOCAL_VARIABLE
• ANNOTATION_TYPE
• PACKAGE
• MODULE
• TYPE_PARAMETER
• TYPE_USE
• RECORD_COMPONENT

@Retention은 애너테이션 정보가 어느 단계까지 유지되는지를 지정한다.

@Inherited는 클래스에 붙은 애너테이션을 하위 클래스 조회에서 상속된 것처럼 취급하도록 한다. 인터페이스와 메서드, 필드의 애너테이션을 일반적으로 상속시키는 기능은 아니다.

@Repeatable은 같은 선언에 같은 종류의 애너테이션을 여러 번 사용할 수 있게 한다.

타입 애너테이션

애너테이션은 선언뿐 아니라 타입이 사용되는 위치에도 붙을 수 있다.

List<@NonNull String> names;

@NonNull String loadName() {
    return "Java";
}

타입 애너테이션은 Java 언어가 자체적으로 널 안전성이나 불변성 의미를 부여하는 기능이 아니다. 정적 분석기와 컴파일러 플러그인, 프레임워크가 애너테이션을 해석하여 별도의 규칙을 적용할 수 있게 한다.

선언 애너테이션과 타입 애너테이션은 같은 @ 문법을 사용하지만 적용 대상과 리플렉션에서 조회되는 경로가 다르다.

리플렉션

실행 시점까지 유지된 애너테이션은 리플렉션 API로 조회할 수 있다.

if (UserController.class
        .isAnnotationPresent(Audited.class)) {
    System.out.println("audited component");
}

Class, Method, Field, Constructor, Parameter, RecordComponent 등은 애너테이션을 조회할 수 있는 AnnotatedElement를 구현한다.^[36]

Audited annotation =
    UserController.class.getAnnotation(Audited.class);

var annotations =
    UserController.class.getDeclaredAnnotations();

리플렉션은 클래스와 멤버의 구조를 실행 중에 조사하고 메서드를 호출하거나 필드에 접근하는 기능도 제공한다. 다만 접근 제어와 모듈 캡슐화가 적용되며, 일반적인 정적 호출보다 실행 시점 검사가 많고 최적화 조건도 다를 수 있다.

예외 계층

예외는 정상적인 반환과 다른 경로로 메서드 실행을 중단하고 호출자에게 오류 상태를 전달한다. Java에서 던질 수 있는 객체는 Throwable의 하위 타입이어야 한다.^[37]

주요 계층은 다음과 같다.

Throwable
├── Error
└── Exception
    └── RuntimeException

Error는 JVM과 실행 환경 수준의 심각한 상태를 나타내는 데 주로 사용된다.

OutOfMemoryError
StackOverflowError
LinkageError

Exception은 프로그램이 처리할 수 있는 예외 상황을 나타낸다. 그중 RuntimeException과 그 하위 타입은 비검사 예외다.

NullPointerException
IllegalArgumentException
IndexOutOfBoundsException
ClassCastException

검사 예외와 비검사 예외

Java는 예외를 컴파일러가 처리 여부를 검사하는지에 따라 구분한다.

검사 예외는 RuntimeException의 하위 타입이 아닌 일반적인 Exception 하위 타입이다. 메서드가 검사 예외를 발생시킬 수 있다면 해당 예외를 잡거나 throws로 선언해야 한다.

static String read(Path path)
        throws IOException {
    return Files.readString(path);
}

호출자는 예외를 처리하거나 다시 선언한다.

try {
    String content = read(path);
    System.out.println(content);
} catch (IOException exception) {
    System.err.println(exception.getMessage());
}

비검사 예외는 RuntimeException, Error와 그 하위 타입이다. 컴파일러는 이들의 처리나 선언을 강제하지 않는다.

static void setPort(int port) {
    if (port < 0 || port > 65535) {
        throw new IllegalArgumentException(
            "invalid port: " + port
        );
    }
}

검사 여부는 예외의 심각도와 동일한 개념이 아니다. 비검사 예외도 프로그램을 종료시킬 수 있고, 검사 예외도 상위 계층에서 일괄 처리될 수 있다.

throw와 throws

throw는 예외 객체를 실제로 발생시킨다.

if (name == null) {
    throw new NullPointerException("name");
}

throws는 메서드나 생성자가 호출자에게 전달할 수 있는 검사 예외 타입을 선언한다.

static Configuration load(Path path)
        throws IOException, ParseException {
    String content = Files.readString(path);
    return parseConfiguration(content);
}

throws 선언은 예외를 자동으로 처리하지 않는다. 현재 메서드에서 잡지 않은 예외가 호출자 방향으로 전파될 수 있음을 타입 계약에 표시한다.

메서드 오버라이딩에서는 하위 클래스 메서드가 상위 메서드보다 더 넓은 새로운 검사 예외를 선언할 수 없다. 같은 예외나 더 구체적인 하위 예외는 선언할 수 있다.

try, catch, finally

try 블록에서 발생한 예외는 호환되는 catch 절에서 처리할 수 있다.

try {
    process();
} catch (IOException exception) {
    log(exception);
}

여러 예외 타입을 서로 다른 방식으로 처리할 수 있다.

try {
    loadConfiguration();
} catch (FileNotFoundException exception) {
    createDefaultConfiguration();
} catch (IOException exception) {
    reportReadFailure(exception);
}

더 구체적인 예외 타입을 상위 타입보다 먼저 배치해야 한다. 상위 타입이 먼저 오면 뒤의 하위 타입 catch는 도달할 수 없기 때문이다.

여러 예외를 같은 방식으로 처리할 때는 다중 catch를 사용할 수 있다.

try {
    processInput();
} catch (IOException | ParseException exception) {
    reportFailure(exception);
}

finally 블록은 정상 종료와 예외 종료에 관계없이 자원 정리 등의 작업을 수행한다.

Connection connection = openConnection();

try {
    useConnection(connection);
} finally {
    connection.close();
}

다만 finally 안에서 return하거나 새로운 예외를 던지면 원래 반환값이나 예외를 가릴 수 있으므로 일반적으로 정리 작업만 수행한다.

try-with-resources

AutoCloseable을 구현한 자원은 try-with-resources 문으로 관리할 수 있다.

try (BufferedReader reader =
         Files.newBufferedReader(path)) {

    String line;

    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
}

try 블록을 벗어나면 컴파일러가 자원의 close() 호출을 보장한다. 여러 자원을 선언하면 선언의 역순으로 닫힌다.

try (
    InputStream input = Files.newInputStream(source);
    OutputStream output = Files.newOutputStream(target)
) {
    input.transferTo(output);
}

본문에서 예외가 발생하고 자원을 닫는 중에도 다른 예외가 발생하면, 본문의 예외가 기본 예외로 유지되고 닫기 예외는 억제된 예외로 연결된다.

for (Throwable suppressed :
        exception.getSuppressed()) {
    log(suppressed);
}

이미 선언된 final 또는 사실상 최종 지역 변수도 자원으로 사용할 수 있다.

BufferedReader reader =
    Files.newBufferedReader(path);

try (reader) {
    System.out.println(reader.readLine());
}

사용자 정의 예외

도메인에 맞는 예외 타입은 Exception이나 RuntimeException을 상속하여 정의할 수 있다.

class ConfigurationException extends Exception {
    ConfigurationException(String message) {
        super(message);
    }

    ConfigurationException(
        String message,
        Throwable cause
    ) {
        super(message, cause);
    }
}

비검사 예외로 정의하려면 RuntimeException을 상속한다.

class InvalidStateException
        extends RuntimeException {

    InvalidStateException(String message) {
        super(message);
    }
}

원인이 된 예외를 cause로 보존하면 상위 계층에서 전체 오류 경로를 확인할 수 있다.

try {
    return parse(content);
} catch (ParseException exception) {
    throw new ConfigurationException(
        "configuration parsing failed",
        exception
    );
}

단언

assert 문은 개발자가 프로그램 내부에서 참이라고 기대하는 조건을 검사한다.

assert count >= 0;

조건이 거짓이면 AssertionError가 발생한다. 추가 메시지를 지정할 수도 있다.

assert index < values.length
    : "index out of range: " + index;

단언은 실행 옵션에 따라 비활성화될 수 있으므로 외부 입력 검증이나 반드시 실행되어야 하는 상태 검사에 사용하지 않는다.

if (port < 0 || port > 65535) {
    throw new IllegalArgumentException(
        "invalid port: " + port
    );
}

단언은 주로 개발 중 내부 불변 조건과 도달할 수 없다고 가정한 상태를 확인하는 보조 수단이다.

전통적인 애플리케이션 시작점

일반적인 Java 애플리케이션은 다음 형태의 main 메서드를 시작점으로 사용한다.

public class Application {
    public static void main(String[] args) {
        System.out.println("Application started");
    }
}

args에는 명령행 인수가 문자열 배열로 전달된다.

public class Arguments {
    public static void main(String[] args) {
        for (String argument : args) {
            System.out.println(argument);
        }
    }
}

JDK 실행 도구에서는 다음과 같이 실행할 수 있다.

java Arguments first second third

main 메서드는 일반적으로 public static void로 선언하고 String[] 또는 String... 매개변수를 사용한다.

public static void main(String... args) {
}

인스턴스 main 메서드

Java 25부터 실행 가능한 main 메서드는 반드시 public static void main(String[] args) 형식일 필요가 없다. 인스턴스 메서드와 인수가 없는 형태도 시작점으로 사용할 수 있다.^[38]

class Application {
    void main() {
        System.out.println("Application started");
    }
}

인스턴스 main을 실행할 때 런처는 시작 클래스의 인스턴스를 생성한 뒤 해당 메서드를 호출한다. 클래스는 사용할 수 있는 인수 없는 생성자를 제공해야 한다.

명시적인 클래스 안에서도 인스턴스 main을 사용할 수 있다.

class CounterApplication {
    private int count;

    void main() {
        count++;
        System.out.println(count);
    }
}

인스턴스 시작점은 작은 프로그램에서 모든 필드와 보조 메서드에 static을 반복하지 않고 객체의 일반적인 구조로 확장할 수 있게 한다.

간결한 소스 파일

작은 프로그램은 명시적인 클래스 선언 없이 필드와 메서드를 작성하는 간결한 소스 파일로 구성할 수 있다.

void main() {
    System.out.println("Hello, Java");
}

다른 메서드와 필드도 함께 선언할 수 있다.

String greeting = "Hello, Java";

void printGreeting() {
    System.out.println(greeting);
}

void main() {
    printGreeting();
}

이 코드는 최상위 실행문을 허용하는 별도 Java 방언이 아니다. 컴파일러는 필드와 메서드를 이름이 소스 코드에서 직접 사용되지 않는 암시적 클래스의 멤버로 처리한다.

간결한 소스 파일은 다음과 같은 성격을 가진다.

• 이름 없는 패키지에 속한다.
• 암시적으로 선언된 최종 클래스를 사용한다.
• 실행 가능한 main 메서드를 포함해야 한다.
• 필드와 메서드는 암시적 클래스의 멤버가 된다.
• 일반적인 Java 컴파일러와 실행 도구를 사용한다.
• 프로그램이 커지면 명시적인 클래스 선언으로 감쌀 수 있다.

간결한 소스 파일에서는 java.base 모듈이 자동으로 모듈 임포트된 것처럼 처리된다. 따라서 java.util, java.io, java.math 등 java.base가 내보내는 패키지의 공개 타입을 별도 임포트 없이 사용할 수 있다.

void main() {
    var languages = List.of(
        "Java",
        "Kotlin",
        "Scala"
    );

    for (var language : languages) {
        IO.println(language);
    }
}

간결한 소스 파일도 실행문을 파일 최상위에 직접 나열하지 않는다. 실행할 코드는 main 또는 다른 메서드의 본문에 작성한다.

단일 소스 파일 실행

java 실행 도구는 소스 파일 하나를 명시적으로 컴파일하지 않고 직접 실행하는 형태도 지원한다.

java Application.java

실행 도구는 메모리 안에서 소스를 컴파일한 뒤 시작 클래스를 실행한다. 이는 별도의 스크립트 언어가 아니라 일반 Java 소스를 간편하게 실행하는 경로다.

class Application {
    public static void main(String[] args) {
        System.out.println("single-file program");
    }
}

간결한 소스 파일과 결합하면 다음처럼 실행할 수 있다.

void main() {
    IO.println("single-file program");
}

java Application.java

이 방식은 작은 명령행 도구와 예제, 실험용 프로그램에 사용할 수 있으며, 같은 파일을 javac으로 컴파일하여 일반 클래스 파일로 만들 수도 있다.

핵심 문법의 구성

Java의 핵심 문법은 선언과 표현식, 문장을 분리하면서 서로 결합한다.

• 선언은 타입과 변수, 메서드, 패키지 등의 이름과 구조를 만든다.
• 표현식은 값을 계산하거나 객체를 생성하고 메서드를 호출한다.
• 문장은 표현식 실행과 분기, 반복, 반환, 예외 처리를 구성한다.
• 블록은 선언과 문장을 범위 단위로 묶는다.
• 타입 검사는 대입과 호출, 반환 및 연산이 허용되는지 컴파일 시점에 확인한다.
• 예외 처리는 정상 반환과 다른 제어 흐름을 호출 계층으로 전달한다.
• 애너테이션은 컴파일러와 도구, 실행 환경이 사용할 메타데이터를 선언에 결합한다.

이 구조는 클래스 중심의 대규모 프로그램뿐 아니라 람다와 패턴 매칭, switch 표현식, 간결한 소스 파일을 사용하는 작은 프로그램에도 동일한 언어 규칙을 적용한다. Java의 문법은 기능이 추가되면서 확장되어 왔지만, 새 기능을 별도 언어로 분리하지 않고 기존 타입 체계와 블록, 표현식 및 클래스 모델 위에 통합하는 방향을 유지한다.