gony-dev 님의 블로그

공유 자원 접근 시 일어나는 Race Condition?

minarinamu — Sun, 1 Feb 2026 14:39:31 +0900

Situation

프로젝트 리팩터링 작업 중, 댓글 생성 기능을 검토하다가 쿼리문에 문제 발생 우려가 제기되었다.

댓글 생성 기능은 댓글과 대댓글의 생성 로직이 달라 API를 분리하였다.

댓글 객체에는 댓글 그룹을 지정하기 위해 commentGroup 필드를 생성하였다.

@Entity
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Comment extends BaseEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "writer_id", nullable = false)
    private Member writer;

    @Column(nullable = false, length = 500)
    private String content;

    @Column(nullable = false)
    private Long authorId;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "feed_id", nullable = false)
    private Feed feed;

    @Column
    private Long commentGroup; // 대댓글을 위한 댓글 ID

    public Comment(Member writer, String content, Long author, Feed feed, Long commentGroup) {
        this.writer = writer;
        this.content = content;
        this.authorId = author;
        this.feed = feed;
        this.commentGroup = commentGroup;
    }
}

문제는 (대댓글이 아닌) 댓글 생성 로직이었다.

commentGroup을 지정하기 위해 repository 내에서 다음 그룹을 지정하는 쿼리문에서 "레이스 컨디션"이 일어난 것이다.

레이스 컨디션(Race Condition)이란?

레이스 컨디션은 2개 이상의 프로세스나 스레드가 공유 자원을 서로 사용하려고 경쟁하는 현상을 의미한다.

이때 공유 자원은 멀티 스레드 환경에서 프로세스 내의 자원 사용을 모두 공유한다는 점에서 동기화 문제가 발생한다.

public Long nextCommentGroup(Feed feed) {
        Long max = queryFactory
                .select(comment.commentGroup.max())
                .from(comment)
                .where(comment.feed.eq(feed))
                .fetchOne();
        return (max == null) ? 1L : max + 1;
}

위의 코드의 경우에는 댓글을 생성하기 위해 피드에 해당하는 댓글 그룹의 최대값 + 1을 반환하는 쿼리문이다. 이때 발생하게 될 문제를 알아보자.

동시에 댓글이 2개 이상 생성될 경우, 동시에 max를 읽을 것이고 둘다 같은 값을 반환한다.

이러면 동일한 commentGroup을 반환할 테고 동시성 문제가 발생하게 된다.

물론 댓글이 생성되지 않는 문제는 아니다. 현재 같은 commentGroup 내의 댓글은 만들어진 순서에 따라 댓글과 대댓글로 구분되기
때문에 조금이라도 더 늦은 댓글이 먼저 생성된 댓글에 대한 대댓글로 만들어지게 된다.

이러한 문제는 UX적으로도 사용자에게 불편함을 증대시키기 때문에 해결해야할 필요성을 느꼈다.

Task

우선 당장의 해결 방안을 모색하기 보다는 현재 주어진 상황을 다시 한 번 되새겨 보기로 했다.

댓글은 만들어진 댓글들에 대한 commentGroup 중 최댓값 다음으로 배치되어 생성된다. 그런 과정에서 querydsl을 사용하여 최댓값을 도출하게 되는데 이때 문제가 발생한다.

사실 이러한 문제는 "락(Lock)"을 사용하여 문제를 해결하는 흔한 동시성 문제이다.

하지만 락은 완벽한 기술이 아니다.

동시에 들어온 요청이 락 대기 상태에 걸림 -> TPS 저하
지연 시간 증가
데드락 위험
운영/디버깅 난이도 상승

위와 같은 단점으로 인해 필자는 구현시에 마지막 선택지로서 락을 선택한다.

그래서 락 대신 commentGroup 생성 기준을 다시 생각해보기로 했다.

Action

기존의 comment 객체는 comment 테이블 내에 있는 commentGroup 중 최댓값 + 1을 해서 만들어진다.
그리고 대댓글은 댓글의 commentGroup + 1씩하여 늘어나게 되는 구조였다.

~~지금 생각해보면 왜 저렇게 짰을까?~~

commentGroup은 주요 목적이 댓글에 대한 대댓글을 조회해주기 위한 것이다.

그래서 쿼리문으로 최댓값을 조회하는 것이 아닌 댓글 생성 시 만들어지는 pk를 기준으로 만들기로 하였다.

그렇게 되면 별도의 시퀀스가 없이도 동시성 이슈가 없다!

@Transactional
@Override
public void createComment(String email, Long postId, CommentReqDto reqDto) {

    Member writer = findIfEmailExists(email);
    Feed feed = findIfFeedExist(postId);
    Long authorId = feed.getMember().getId();

    Comment comment = new Comment(writer, reqDto.content(),
            authorId, feed);
    commentRepository.save(comment);
    comment.updateCommentGroup(comment.getId());

    log.info("{} 피드에 대한 댓글 생성 완료", feed.getId());
}


// Comment.updateCommentGroup
public void updateCommentGroup(Long groupId) {
    this.commentGroup = groupId;
}

Result

TestCode

@Test
void concurrentTest() {
	ExecutorService es = Executors.newFixedThreadPool(32);
    
    for(int i=0;i<10;i++){
    	es.submit(() -> {
        	commentService.createComment("email", "postId", CommentReqDto reqDto);
        });
    }
    
    assertThat(commentRepository.).isEqualTo(10);
}

테스트 결과 성공이었다!

추상 클래스? 알려드리겠습니다!

minarinamu — Tue, 20 Jan 2026 18:00:38 +0900

지난 시간에는 자바에서 빠질 수 없는 객체 지향 클래스에 대해 알아보고 실습해보았다!

[JAVA] - JAVA의 꽃, 객체 지향 프로그래밍(OOP)의 클래스 문법

이번에는 구체적이지 않지만 중요한 "Abstract"에 대해 알아보도록 하자.

추상화?

추상적이라는 단어는 현실의 구체적인 형태나 모습이 아닌 여러 사물에서 공통된 속성을 뽑아내어 만든 개념 또는 관념적인 것을 의미한다.

지금까지 우리가 실습하며 작성해왔던 클래스는 구체적으로 데이터를 담아 인스턴스화하여 다루었다.

이번에 배우게 될 추상 클래스는 구현부가 없는 메서드를 포함하여 자식 클래스에서 반드시 구현화해야하는 클래스이다.

당연히 인스턴스화가 불가능하며, 선언 시 "abstract" 키워드를 추가해야한다.

객체 지향 프로그래밍에서 듣게 되는 '추상화'랑 동일하며,

서울의 지리를 추상화시켜 보여주는 서울 지하철 노선도가 그 예시가 된다.

그럼 추상화를 클래스에 접목시킨 추상 클래스에 대해 더 자세히 알아보자.

추상 클래스

추상 클래스는 추상화 개념을 추가하여 구조적으로 객체를 설계하고, 기능 수정이나 추가를 포함하여 전체적인 유지보수성을 높여준다.

때문에 개별 프로젝트보다는 범용 라이브러리나 프레임워크 시스템을 설계하는데 유용하게 작용한다.

(ex. String.toUpperCase(), for, while)

아래는 추상 클래스를 간단하게 작성한 것이다.

// 추상 클래스
public abstract class Player {
	private int level;
    private int power;
    private String nickname;
    
    public Player(String nickname) {
        this.level = 1;
        this.power = 30;
        this.nickname = nickname;
    }
    
    public abstract void levelUp();
}

// 상속받은 클래스
class Archer extends Player {
	
    public void levelUp() {
    	System.out.println("궁수" + this.nickname + "님이 레벨업하였습니다.");
    }
}

추상 클래스 내에 선언된 abstract를 가진 메서드는 추상 메서드라고 하며, 저렇게 미완성인 채로 완성한다.(?)

미완성으로 남겨놓는 이유는 추상 클래스를 상속 받는 자식 클래스에 따라 상속 받는 메서드의 내용이 달라지기 때문이다.

즉, 실제 내용은 상속 받는 클래스에서 구체적으로 구현하도록 비워둔다고 생각하면 된다.

추상 클래스 생성자

추상 클래스는 인스턴스 객체를 생성할 수 없다.

추상 클래스는 구체화하지 않기 때문에 객체에서 구체적인 설정이 불가능하며,

오로지 부모 클래스로서 상속시키기 위한 개념으로 작용되기 때문이다.

따라서 반드시 추상 클래스를 어떤 자식 클래스에 상속시키고, 자식 클래스를 인스턴스화하여 사용해야만 한다.

// 추상 클래스
public abstract class Player {
    private int level;
    private int power;
    private String nickname;
    
    public Player(String nickname) {
        this.level = 1;
        this.power = 30;
        this.nickname = nickname;
    }
    
    public abstract void levelUp();
}

// 상속받은 클래스
class Archer extends Player {
	
    public Archer(String name) {
    	super(name);
        this.power = 20;
    }
    
    public void levelUp() {
    	System.out.println("궁수" + this.nickname + "님이 레벨업하였습니다.");
    }
}

추상화는 생각보다 어렵지 않은 개념이었다.

다만 OOP에서는 빠질 수 없는 개념이므로 확실히 이해하고 넘어가야 한다고 느꼈다.

추상 클래스를 기반으로 공통 기능들을 미리 정의해두고, 이를 상속받은 실제 클래스에서 필요한 부분만 확장하거나 구체화하면 코드 구조가 확실히 명확해진다. 결과적으로 중복 코드를 줄이고, 변경이 생겼을 때 영향 범위를 최소화할 수 있어 유지보수성을 높일 수 있다.

프로젝트 관점에서 추상 클래스를 잘 설계해주면, 개발자는 공통적으로 필요한 부분만 오버라이딩하여 구현만 하면 되기 때문에 개발 비용이 줄어들고, 구현에만 온전히 집중할 수 있다.

추상화는 단순한 문법이 아니다. 협업과 확장성을 위한 설계 도구임을 확실히 짚고 넘어가자!

JAVA의 꽃, 객체 지향 프로그래밍(OOP)의 클래스 문법

minarinamu — Mon, 12 Jan 2026 14:08:40 +0900

지난 시간에는 배열에 대해 알아보고 코드에 적용하는 시간을 가졌다.

[JAVA] - JAVA 배열을 모르겠다고? 알려드리겠습니다!

이번 시간에는 객체 지향 프로그래밍에서 필수적인 요소인 클래스에 대해 파헤쳐 보자!

객체 지향 프로그래밍(Object Oriented Programming)이란?

"객체" 개념을 기반으로 데이터를 속성과 기능으로 묶어 프로그램을 설계하는 방식으로 줄여서 OOP라고 부른다.

객체는 현실 세계에서의 의미 그대로 '사물'을 의미하며, 클래스라는 '설계도'를 기반으로 만들어진다.

다형성(Polymorphism), 추상화(Abstraction), 상속(Inheritance), 캡슐화(Encapsulation)의 4대 특징을 통해 코드 재사용성 및 유지보수, 확장성을 높히는 것이 목표이다.

우리는 객체 지향 프로그래밍을 설계하기 위해 클래스에 대해 자세히 알아볼 예정이다.

클래스(Class)

~~클래스 지리구욘~~~

클래스를 알아보기 전에 클래스가 왜 필요한지에 대해 알아보자.

클래스란 객체를 정의하는 설계도란 의미로 사용된다.

자바에서는 설계도를 통해 여러 객체를 생성하여 사용하는 식으로 프로그래밍을 진행한다.

게임을 예로 들어보자.
게임을 시작하면 모든 플레이어의 체력, 공격력, 스킬 같은 ‘속성의 종류’는 모두 동일한 구조를 가진다.
하지만 플레이가 진행되면서 플레이어마다 체력 수치가 오르고, 새로운 스킬을 배우는 등 값(=데이터)은 달라진다.즉, 변하는 건 “속성 자체”가 아니라 “속성에 들어있는 값”이다.
이때, 플레이어가 생성될 때마다 매번 새로 설계해서 만드는 건 비효율적이다.
그래서 플레이어의 공통 구조를 ‘설계도’로 정의해두고, 공장처럼 필요할 때마다 찍어내듯 생성하는데,
이 설계도가 "클래스"이고, 설계도로 만들어진 실제 플레이어가 "객체"다.

클래스는 객체의 속성을 나타내는 필드와 객체의 함수를 나타내는 메서드로 구성되어 있다.

프로그래밍을 하며 클래스, 인스턴스, 객체 등 많은 용어들이 나온다.
용어들을 정리해보자.

클래스 | 객체를 생성하는 설계도
객체 | 클래스와 new 연산자를 통해 만든 실제 데이터가 들어있는 변수
인스턴스 | 클래스로부터 생성된 특정 개체, 관계적인 표현
필드(속성) | 클래스 내에 있는 변수
메서드 | 클래스 내에 있는 함수
생성자 | 클래스로 객체를 만들 때 각 객체의 변수를 초기 생성해 줄 수 있는 메서드

(객체 == 인스턴스) ? true : false

앞서 언급했듯이 클래스를 통해 객체와 인스턴스가 생성된다.

그런데 객체는 클래스를 통해 만들어지고, 인스턴스도 클래스를 통해서 만들어진다.

과연 이 둘은 같은 걸까?

코드를 통해 알아보자.

class Player { // 클래스(설계도) 선언
    	int level;
        int healthPower;
        
        public Player() {
        	this.level = 1;
            this.healthPower = 10;
        }
        
        public String levelUp() {
        	return "Level Up!";
        }
    }
public class MyClass {
    
    public static void main(String[] args) {
    	
        Player p1 = new Player(); // 객체 생성, p1은 Player의 인스턴스
        Player p2 = new Player();
    }
}

Player 클래스를 선언하고, p1이라는 객체를 생성하였다.

p1은 힙 영역에 할당된 구체적인 실체를 가지며, 이때부터 "p1은 Player의 인스턴스"라고 부른다.

즉, 객체는 개념적이고, 인스턴스는 실제적인 개념을 갖는 관점이라고 이해하면 된다.

필드(Field)란?

클래스 필드는 클래스에 선언된 변수를 의미한다.

또한 클래스 필드는 선언된 위치와 선언자에 따라 아래와 같이 구분된다.

클래스 변수 | static 키워드로 선언된 변수
인스턴스 변수 | static 키워드로 선언되지 않은 변수
지역 변수 | 메서드나 블록 내에서 선언되고 소멸되는 변수

JVM에서 변수 종류에 대해 학습하였을 때 나온 변수들로 다시 한 번 상기시켜보자.

[JVM] - 자바 코드의 메모리 영역

구분	생성 시기	소멸 시기	저장 영역
클래스 변수	클래스가 메모리에 올라갈 때	프로그램이 종료될 때	Method Area
인스턴스 변수	인스턴스가 생성될 때	인스턴스가 소멸할 때	Heap Area
지역 변수	블록 내 선언문이 실행될 때	블록을 벗어날 때	Stack Area

메서드(Method)란?

메서드는 우리가 흔히 접하게 될 개념으로 클래스 내의 함수를 의미한다.

특정 작업을 수행하기 위해 선언하며, 클래스의 기능을 정의한다.

자바의 모체 언어인 C에서는 '메서드'가 아닌 '함수'로서 작용하지만, 이름만 다를 뿐이니 크게 신경 쓰지 않아도 된다.

메서드는 생성 및 호출 시 다음과 같은 구성요소들을 필요로 한다.

접근 제어자 | 해당 메서드에 접근할 수 있는 외부 범위 명시
반환 타입 | 메서드가 코드를 실행하고 최종적으로 반환할 데이터 타입 명시
메서드명 | 메서드를 호출하기 위한 이름 명시
매개변수 | 메서드를 정의할 때 입력으로 전달된 값을 받는 변수
인수 | 메서드 호출 시 넘겨주는 입력값

class Player {

    private String nickname = ""; // 인스턴스 변수

    public String getNickname() {
        return nickname;
    }

    public Player(String nickname) { // 생성자 생성
        this.nickname = nickname;
    }

    public static String noti(){ // 클래스 메서드 생성
        return "캐릭터가 생성되었습니다!";
    }
}
public class MyClass {

    public static void main(String[] args) {

        Player p1 = new Player("John"); // 생성자 호출
        System.out.println(Player.noti()); // 클래스 메서드 호출
        System.out.println("해당 플레이어 이름은 " +p1.getNickname()); // 인스턴스 메서드 호출
        Player p2 = new Player("Jane");
        System.out.println(Player.noti());
        System.out.println("해당 플레이어 이름은 " + p2.getNickname());


    }
}

메서드도 변수와 마찬가지로 클래스 메서드와 인스턴스 메서드가 존재한다.

static 선언 유무에 따라 구분이 가능하며, 클래스 메서드는 메서드 내부에서 인스턴스 변수를 사용할 수 없다는 특징이 있다.

그렇기 때문에 메서드 내부에서 인스턴스 변수나 인스턴스 메서드를 사용하지 않는 메서드를 클래스 메서드로 정의하는 것을 권장한다.

위의 코드를 보면 noti를 통해 플레이어가 생성될 때마다 생성 알림을 출력하였다.

이처럼 클래스 메서드는 모든 인스턴스에 공통으로 적용되는 정보나 로직을 실행할 경우에만 사용하고,
인스턴스 메서드인 getNickname은 유동적으로 변할 수 있는 인스턴스 변수를 다루는 경우에 사용하는 것이 좋다.

생성자(Constructor)

이미 위에서 몇 번의 실습을 통해 경험해 봤지만 다시 정리해보면,
생성자는 객체가 생성될 때 동적으로 인스턴스 변수 초기화를 위해 실행되는 메서드이다.

생성자에는 몇 가지 특징이 존재한다.

생성자의 목적은 객체 초기화임.
생성자 이름은 클래스명과 반드시 동일해야함.
new를 통해 객체 생성 시, 생성자는 객체당 한 번만 호출함.
생성자는 객체가 생성될 때 반드시 호출됨.
생성자는 리턴 타입이 없으며, 지정할 수도 없음.
개발자가 생성자를 작성하지 않았으면 컴파일러가 자동으로 생성자를 생성해줌.
생성자는 오버로딩을 통해 여러 개 작성이 가능함.

오버로딩(Overloading)이란?
자바의 한 클래스 내에서 생성된 메서드에 대해 같은 이름을 가진 메서드가 있더라도 매개변수의 개수나 타입이 다르면 같은 이름을 사용하여 메서드를 정의하는 개념

메서드명이 같고, 매개변수의 개수나 타입이 달라야 하는 것이 필수 조건이며, 리턴 값만 다른 경우에는 오버로딩을 할 수 없다.

class Player {
	int level;
    int power;
    int job;
    
    public Player(int lv, int po, String job) { // 생성자 생성
        this.level = lv;
        this.power = po;
        this.job = job;
    }
}
public class MyClass {
	
    public static void main(String[] args) {
    	Player p1 = new Player(1, 40, "궁수");
        Player p2 = new Player(1, 80, "전사");
    }
}

코드를 구현해 간단한 클래스를 작성해 보았다.

이때 생성자 안의 this를 볼 수 있는데, 해당 키워드는 클래스(=설계도) 자신을 나타내는 키워드이다.

'this' 자체가 인스턴스의 주소를 가리키고 있기 때문에 자기 자신에게 접근이 가능하다.

this를 변수가 아닌 메서드로도 적용할 수 있다!

생성자 내부에서만 사용 가능하며, this() 메서드에 인수를 전달하면, 이미 정의되어 있는 다른 생성자를 찾아 호출해 준다!

class Player {
	int level;
    int power;
    int job;
    
    public Player(int lv, int po, String job) { // 생성자 생성
        this.level = lv;
        this.power = po;
        this.job = job;
    }
    
    Player() {
    	this(1, 50, "도적"); // this 메서드 사용
    }
}

클래스 상속(Extend)

상속이란 개념은 자바 문법 작성 시 매우 많이 보게 될 요소 중 하나이다.

자바에서의 상속은 상위 클래스와 자식 클래스 간의 관계를 나타내는 단어로,
자식 클래스가 부모 클래스의 특징을 상속받아 사용할 수 있다는 의미이다.

[출처] https://coding-factory.tistory.com/865

상속을 통해 클래스 재사용 효율을 높혀주고, 코드 시간을 단축시킬 수 있다.

다만 상속에도 몇 가지 제한이 있다.

부모 클래스의 private 접근 제어자에 대한 요소들은 자식 클래스가 상속 받을 수 없다.
부모와 자식 클래스가 서로 다른 패키지에 있다면, 부모의 default 접근 제한을 갖는 필드나 메서드를 자식이 상속 받을 수 없다.

코드를 통해 이해해보자.

class Player {

    int level;
    int power;
    String nickname;

    public Player(String nickname) { // 부모 클래스 생성자
        this.level = 1;
        this.power = 30;
        this.nickname = nickname;
    }
}
class Archer extends Player {
    public Archer(String nickname) { // 자식 클래스 생성자
        super(nickname); // super 메서드로 부모 클래스 생성자 특징 가져가기
        this.power = 40;
    }

    void kingShot(){...}
}
class Warrior extends Player {
    public Warrior(String nickname) {
        super(nickname);
        this.power = 80;
    }

    void strike() {...}
}
class Thief extends Player {
    public Thief(String nickname) {
        super(nickname);
        this.power = 50;
    }
    void stealth() {...}
}
public class MyClass {

    public static void main(String[] args) {

        Archer p1 = new Archer("Jane");
        Warrior p2 = new Warrior("타락파워전사");
        Thief p3 = new Thief("백엔드 개발자");


    }
}

Player를 상속받은 Archer, Warrior, Thief 자식 클래스를 생성했다.

이렇게 각각의 자식 클래스는 부모 클래스의 특성을 물려받아 level, power, nickname 필드를 재생성할 필요가 없으며,
클래스 생성 목적에 맞게 유용하게 다루어 사용하면 된다!

이때 보지 못했던 것이 있는데, 바로 'super()'이다.

this처럼 목적에 따라 키워드 또는 메서드로 사용할 수 있다.

super 키워드 | 자식 클래스가 부모 클래스의 필드나 메서드를 참조하는데 사용
super 메서드 | 부모 클래스의 생성자를 호출

상대적으로 super가 this보다 빈번하게 사용되기 때문에 사용법을 확실히 알아두는 것이 좋다!

메서드 재정의(Method Overriding)

메서드 재정의란 상위 클래스가 가지고 있는 메서드를 하위 클래스가 재정의해서 사용하는 것을 의미한다.

오버로딩과 다소 어감이 비슷하나,

오버로딩은 기존에 없던 새로운 메서드를 정의하는 것이고,
오버라이딩은 상속받은 클래스의 메서드를 재정의하는 것이다.

class Player {

    int level;
    int power;
    String nickname;

    public Player(String nickname) { // 부모 클래스 생성자
        this.level = 1;
        this.power = 30;
        this.nickname = nickname;
    }
    
    public void intro() {
    	System.out.println("Player가 무직 클래스로 생성되었습니다!");
    }
}
class Archer extends Player {
    public Archer(String nickname) { // 자식 클래스 생성자
        super(nickname); // super 메서드로 부모 클래스 생성자 특징 가져가기
        this.power = 40;
    }
    
    public void intro() { // 메서드 오버라이딩
    	System.out.println("Player가 궁수 클래스로 생성되었습니다!");
    }

    void kingShot(){...}
}
public class MyClass {

	public static void main(String[] args) {
    	Archer ar = new Archer();
        ar.intro();
    }

}
/*
Player가 궁수 클래스로 생성되었습니다!
*/

Import

'import'란 키워드는 클래스 내에서 코드 상단에 패키지를 명시해주면 해당 패키지 내의 클래스 파일을 사용할 수 있게 해준다.

클래스 파일을 가져올 때 특정 파일만 가져올 지, 해당 패키지의 모든 클래스 파일을 가져올지 선택할 수 있다.

바로 패키지 뒤에 '*' 키워드만 붙혀주면 모든 클래스 파일을 사용할 수 있다!

import java.util.Arrays; // java.util에 있는 Arrays 클래스 파일을 가져와 사용한다.
import java.lang.*; //  java.lang 패키지 내에 있는 모든 클래스 파일을 가져와 사용한다.

위의 코드처럼 import를 꺼낼 수 있는데, 이때 "java.*"를 하면 그냥 코드 한 줄만 입력할 수 있지 않을까라는 생각을 할 수 있다.

정답은 "안된다"이다.

'*'는 모든 클래스 파일들을 포함하게 하지만, 해당 패키지에 포함된 하위 패키지의 클래스까지 포함시켜 주지는 않는다.

즉, 위에 코드처럼 java.utils와 java.lang에 있는 클래스 파일들을 사용하고 싶다면, 따로따로 명시해 주어야 한다.

static import

"import static" 문을 사용하면 정적 메서드나 필드를 클래스명 없이 사용할 수 있다.

아래 코드를 보자.

import static java.lang.System.out; // static 선언

public class MyClass {
	
    public static void main(String[] args) {
    	out.println("Hello World!");
    }
}

위를 보면 static import를 통해 System.out을 가져왔다.

그렇게 되면 출력 코드 작성 시에는 System.out을 제외한 out부터 사용하면 된다.

제어자(Modifier)

제어자란 클래스와 메서드 등 다양한 곳에서 사용되는 키워드이다.

이 포스트에서 직접적으로 언급했던 제어자는 접근 제어자 밖에 없었다.

하지만 static이나 final 같은 키워드도 제어자라고 부른다.

접근 제어자 | private, protected, public, default
기타 제어자 | static, final, abstract etc.

1. 접근 제어자

OOP에서는 사용자로부터 숨겨야 하는 정보들이 존재한다.

접근 제어자는 클래스와 클래스의 멤버를 사용할 때, 접근할 수 있는 범위를 지정해 주는 역할을 한다.

접근 제어자는 4가지로 접근 범위 지정이 가능하다.

private | 같은 클래스 내에서만 접근 가능
default | 같은 패키지 내에서만 접근 가능
protected | 같은 패키지나 다른 패키지의 자손 클래스에서 접근이 가능
public | 접근 제한 X

2. 기타 제어자

2-1. Static

static 멤버는 메모리 영역 내 메서드 영역에 생성된다.

동일한 클래스의 모든 객체에 의해 공유가 가능하며, this 사용이 불가능하다.(인스턴스가 아니기 때문이다.)

2-2. final

final 키워드는 값의 변경이 불가능하다는 것을 명시하는 키워드이다.

final은 상수(=constant) 풀에 저장되며, 오버라이딩을 통한 재정의가 불가능하다.

클래스에 final을 명시할 시, 해당 클래스에 대한 다른 클래스가 상속을 받을 수 없다.

3. 제어자 조합

제어자끼리의 조합은 다양하게 사용될 수 있다.

하지만 사용이 불가능한 제어자 조합이 있으며, 대상에 따라 다르게 적용된다

클래스에 final과 abstract는 함께 사용 불가
메서드에 static과 abstract는 함께 사용 불가
메서드에 private과 abstract는 함께 사용 불가
메서드에 private과 final에 함께 사용 불가

출처

1- Inpa Dev

2- https://velog.io/@dongvelop

JAVA 배열을 모르겠다고? 알려드리겠습니다!

minarinamu — Tue, 6 Jan 2026 12:00:58 +0900

이전 시간에는 기본형 타입의 실수, 정수형에 대해 형변환하는 원리와 실습을 학습해보았다.

[JAVA] - JAVA 타입 형변환

이번 시간에는 프로그래밍을 하며 결코 빠질 수 없는 배열에 대해 알아보자!

배열 자료형이란?

배열은 이전 시간까지 배웠던 Primitive Type이 아닌 Reference Type에 해당하는 자료형으로,
하나의 타입에 대해 여러 데이터들을 모아 구조적으로 다룰 수 있게 한다.

구성하는 각각의 값을 배열 요소(element)라고 하며, 위치를 가리키는 숫자를 인덱스(index)라고 한다.

배열을 생성해보자!

int[] nums = new int[100]; // int형 배열 생성
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;

char[] chArr = new char[100]; // char형 배열 생성
chArr[0] = 'a';
chArr[1] = 'b';

위의 코드는 자바 프로그램에서 int와 char형의 배열을 각각 생성하는 코드이다.

자바의 배열은 선언 시, 고정된 크기를 가져야 하며 배열 길이를 반드시 지정해야 한다!

수동으로 선언하고 초기화해야 한다는 단점이 있기 때문에 배열의 길이를 처음부터 지정하지 않으면 컴파일 오류가 발생한다.

이렇게 생성한 배열은 인덱스 번호를 통해 특정 데이터에 접근하여 데이터 삽입 또는 수정 작업을 실행할 수 있다.

배열 출력

배열에 데이터를 넣어주면서 테스트나 결과물을 보기 위해 배열 내 데이터를 출력하고 싶을 때가 있다.

int[] nums = {1, 2, 3, 4, 5};

System.out.println(nums);
// 출력 결과 : [I@3fee733d

이렇게 배열 변수를 출력해보면 원하던 결과는 나오지 않는다.

위의 결과처럼 이상한 값이 나오게 되는데, 이것은 배열의 주소값을 의미한다.

"그렇다면 내가 원하는 결과는??"

배열 내 데이터를 출력하고 싶다면 보통 두 가지 방법을 많이 사용한다.

for문을 사용하여 배열 순회
Arrays.toString() 메서드 사용

import java.util.Arrays;

public class MyClass {
	int[] nums = {1, 2, 3, 4, 5};

	for(int i=0;i<nums.length;i++){
		System.out.println(nums[i]);
	}

	System.out.println(Arrays.toString(nums));
}
/* 출력 결과
1
2
3
4
5
[1, 2, 3, 4, 5];
/*

예외적으로, char형 배열은 println()으로 바로 출력이 가능하다.

배열 복사

앞서 말했듯 자바에서 배열은 선언 시 고정된 크기를 가진다.

그렇다면 원래 계획했던 것보다 배열 공간이 추가로 필요하다면 어떻게 해야할까?

기본적으로 세 가지의 해결방법이 제공된다.

기존의 배열을 새로 만든 배열에 복사
Arrays.copyOf() 메서드 사용
System.arraycopy() 메서드 사용

하나씩 살펴보자.

1. 기존 배열을 새로 생성한 배열에 복사

public class MyClass {
	
    public static void main(String[] args){
    	int[] nums = {1, 2, 3, 4, 5};
        int[] newArr = new int[nums.length * 2];
        
        for(int i=0;i<nums.length;i++){
        	newArr[i] = nums[i];
        }
        nums = newArr;
    }
}

새 배열을 생성하고, for-loop를 통해 기존 배열의 값들을 새 배열에 넣어주었다.

그리고 원래의 배열을 가리키던 nums가 새로 생성된 newArr을 가리키도록 지정하였다.

사실 이 방법은 3가지 방법 중 성능이 가장 떨어진다.

그렇기 때문에 복사하면서 추가 작업이 필요하거나 실습용으로 사용하는 것을 권장한다.

2. System.arraycopy() 메서드 사용

public class MyClass {

	public static void main(String[] args) {
    	int[] nums = {1, 2, 3, 4, 5};
        int[] newArr = new int[nums.length * 2];
        
        // System.arraycopy(복사할 배열, 복사를 시작할 배열 인덱스 값, 복사받을 배열, 복사된 배열값들이 붙여질 시작위치, 지정된 길이만큼 값들이 복사)
        System.arraycopy(nums, 0, newArr, 0, nums.length);
    }
}

System.arraycopy() 메서드는 방법들 중 가장 빠르며, 부분 복사 지원이 명확하다는 특징이 있다.

기본형 타입 뿐만 아니라 참조형 타입에서도 사용이 가능하지만, 5개의 인자를 정확히 입력하는 것을 주의해야 한다.

3. Arrays.copyOf() 메서드 사용

import java.util.Arrays;

public class MyClass {
	
    public static void main(String[] args){
    	int[] nums = {1, 2, 3, 4, 5};
        
        // Arrays.copyOf(복사할 배열, 할당받을 배열 길이);
        int[] newArr = Arrays.copyOf(nums, nums.length * 2);
        System.out.println(Arrays.toString(newArr));
        
    }
}
/* 출력결과
[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
*/

Arrays.copyOf() 메서드는 기존의 배열을 특정 길이만큼 복사하여 새로운 배열에 할당하는 메서드이다.

가장 간결하고 가독성이 좋으며, 새로운 배열의 길이가 더 길다면 나머지는 기본값으로 채워진다.

깔끔한 코드를 구현하고 싶다면 제일 권장되는 방식이다.

배열 정렬

무작위로 배치된 배열 값들을 Arrays.sort()를 이용해 정리할 수 있다.

코드를 통해 알아보자.

import java.util.Arrays;

public class MyClass {

    public static void main(String[] args) {
        int[] nums = {6, 3, 2, 5, 4};

        // 오름차순
        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));

        // 부분 정렬
        int[] arr = {9, 1, 4, 2, 6};
        Arrays.sort(arr, 0, 3);
        System.out.println(Arrays.toString(arr));
    }
}
/* 출력결과
[2, 3, 4, 5, 6]
[1, 4, 9, 2, 6]
*/

복사와 마찬가지로 Arrays 메서드를 사용하면 정렬이 가능하다.

하지만 여기서 내림차순 구현은 보이지 않는데 이는 자바 기본형 타입에 대한 내림차순 정렬 메서드가 존재하지 않기 때문이다.

그래서 오름차순 정렬 후 뒤집거나 Integer 같은 객체 타입을 사용하여 Comparator 클래스를 사용하면 된다.

(이 부분은 후에 다루어질 예정이다.)

import java.util.Arrays;

public class MyClass {

	public static void main(String[] args){
    	int[] nums = {6, 3, 2, 5, 4};
        Arrays.sort(nums); // 오름차순 정렬
        
        // 오름차순 정렬 후 뒤집기 구현
        for(int i=0, j = nums.length-1; i<j; i++, j--) {
        	int tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
        }
    }
}

배열 비교

만일 두 배열을 서로 비교하고 싶다면 두 가지 방안 중 하나를 사용하면 된다.

for-loop를 통해 순회하여 비교
Arrays.equals() 메서드 사용

import java.util.Arrays;

public class MyClass {

    public static void main(String[] args) {
        int[] nums = {6, 3, 2, 5, 4};
        int[] nums2 = {6, 3, 2, 5, 4};

        // 1. for-loop를 통해 배열 순회
        for(int i = 0; i<nums.length; i++){
            if(nums[i] != nums2[i]){
                System.out.println("Not equal to " + nums[i] + " and " + nums2[i]);
                return;
            }
        }

        // 2. Arrays.equals() 메서드로 배열 비교
        System.out.println(Arrays.equals(nums, nums2)); // 배열 내 인덱스마다의 요소들이 같으므로 true

        Arrays.sort(nums);
        System.out.println(Arrays.equals(nums, nums2)); // nums의 오름차순 정렬 후 요소들이 인덱스마다 같지 않으므로 false
    }
}

두 방법 모두 성능은 비슷하지만, 동작이나 안정성의 차이가 있다.

for-loop의 경우, 일부 구간만 비교가 필요한 경우나 특정 규칙을 적용하는 커스텀 방식을 이용할 수 있지만
코드 일부분 누락이나 인덱스 실수로 인해 비교적 버그가 나기 쉽다.

Arrays.equals()의 경우에는 배열 요소들이 같은지에 대한 유무가 명확하며 동일성 체크를 깔끔하게 처리한다.
또한 타입별로 정의가 명확하기 때문에 "두 배열이 같은지"만 비교한다면 Arrays.equals() 메서드를 사용하는 것을 권장한다.

다차원 배열

지금까지 배운 배열은 모두 1차원 배열이다.

배열은 좀더 고차원적으로 설계하는 것이 가능한데 2차원 이상의 배열을 정의하는 것을 다차원 배열이라고 하며,

배열 요소로 배열을 갖는 배열이라고 생각하면 된다.

2차원 배열

2차원 배열은 점에서 선이 되는 것처럼 1차원 배열이 모여 만들어지는 개념이라고 보면 된다.

한 학생의 과목 점수를 배열에 담기 위해서는 {90, 80, 80, 85} 처럼 1차원 배열을 생성하면 된다.

그러면 여러 명의 학생을 담기 위해서는 어떻게 하면 될까? 2차원 배열을 생성하면 된다.

2차원 배열은 테이블 형태의 데이터를 적재하기 위해 사용되며, 행(row)과 열(column)의 개념만 알면된다.

	국어	영어	수학
철수	90	85	90
영희	70	90	90
영수	85	100	80

위의 표가 곧 테이블이며, 이를 2차원 배열로 생성하면 다음과 같다.

import java.util.Arrays;

public class MyClass {

    public static void main(String[] args) {
        int[][] students = {{90, 85, 90}, {70, 90, 90}, {85, 100, 80}}; // 학생당 국영수 점수

        for(int i=0; i<students.length; i++){
            System.out.println("학생" + (i+1) + " 의 국영수 점수는 " + Arrays.toString(students[i]));
        }
        // or
        
        System.out.println(Arrays.deepToString(students);
    }
}
/*
학생1 의 국영수 점수는 [90, 85, 90]
학생2 의 국영수 점수는 [70, 90, 90]
학생3 의 국영수 점수는 [85, 100, 80]
[[90, 85, 90], [70, 90, 90], [85, 100, 80]]
*/

위의 코드는 선언과 동시에 데이터를 넣어주었지만,

사전에 초기화를 진행하고 싶다면, 1차원 배열 초기화에 대괄호를 한 번 더 추가하면 된다.

이렇게 new int[3][3]이라는 첫번째 괄호는 행 개수를, 두번째 괄호는 열의 개수를 나타내는 배열이 생성된다.

출력방법에는 2가지가 있는데 1차원 배열 출력과 비슷하다.

for-loop를 이용해 배열 내 배열 출력
Arrays.deepToString() 메서드를 사용

가변 배열

배열은 기본적으로 고정된 길이를 가지고 있어야 하는 것이 맞다.

2차원 배열 역시 테이블 형태라고 해서 가로와 세로의 길이가 모두 같아야 할 것 같은데, 그렇지 않다.

자바에서 다차원 배열은 각 요소로 들어가는 1차원 배열의 길이를 각기 다르게 해도 2차원 배열을 생성하는데 문제가 없다.

(물론 2차원 배열이 아닌 다차원 배열도 가능하다!)

import java.util.Arrays;

public class MyClass {

    public static void main(String[] args) {
        int[][] score = {
                {100, 100, 100, 100},
                {20, 20, 20},
                {30, 30},
                {40, 40},
                {50, 50, 50}
        };

        System.out.println(Arrays.deepToString(score));
    }
}
/* 출력결과
[[100, 100, 100, 100], [20, 20, 20], [30, 30], [40, 40], [50, 50, 50]]
*/

객체 배열

지금까지 기본형 타입들에 대해 배열을 생성해보았다.

이제 객체 타입을 배열에 넣어 사용하는 방법에 대해 알아보자.

객체 또한 하나의 자료형으로 취급되기에 배열을 생성하는데 문제가 없다.

다만 알아두어야 하는 점은 객체 타입은 참조를 사용한다는 점을 유의해야 한다.

아래 코드를 살펴보자.

import java.util.Arrays;

public class MyClass {

    public static void main(String[] args) {

        class Obj{
            String str;
            int num;

            public Obj(String str, int num) {
                this.str = str;
                this.num = num;
            }
        }

        Integer[] arr = {1, 3, 5, 7};

        System.out.println("Integer Array : " + Arrays.toString(arr));

        Obj[] objArr = {new Obj("str1", 1), new Obj("str2", 2)};
        System.out.println("Obj Array : " + Arrays.toString(objArr));
    }
}
/* 출력 결과
Integer Array : [1, 3, 5, 7]
Obj Array : [MyClass$1Obj@4617c264, MyClass$1Obj@36baf30c]

*/

다음과 같이 두 객체 타입(Integer, Obj)에 대해 배열을 생성하고 출력해보았다.

Integer에 대해서는 실제값이 잘 출력되는 반면, Obj에 대해서는 주소값 형태가 출력되었다.

이와 같이 서로 다른 값의 타입이 출력되는 것은 toString에 대한 메서드 유무에 따라 달라지기 때문이다.

Integer 같은 래퍼 클래스는 toString()이 내부에서 이미 구현되어 있어 실제 값이 출력되지만,

Obj는 toString()이 구현되어 있지 않아 저런 형태가 출력되는 것이다.

얼핏 보면 주소값 같지만 정확히는 "해시 기반 식별 문자열"이라는 점을 알아두자.

객체 배열 복사

import java.util.Arrays;

public class MyClass {

    public static void main(String[] args) {

        Obj[] objArr = {new Obj("str1", 1), new Obj("str2", 2)};
        System.out.println("Obj Array : " + Arrays.toString(objArr));

        Obj[] objArr2 = objArr.clone();
        System.out.println("Obj Array2 : " + Arrays.toString(objArr2));
    }
}
/* 출력 결과
Obj Array : [MyClass$1Obj@5acf9800, MyClass$1Obj@4617c264]
Obj Array2 : [MyClass$1Obj@5acf9800, MyClass$1Obj@4617c264]
*/

객체 타입으로 이루어진 배열도 복사가 가능하다!

하지만 출력 결과를 보면 식별 문자열이 같은 것을 알 수 있다.

이는 실제값의 복사와 함께 참조값이 함께 복사되었기 때문이다.

(배열 변수명).clone() 메서드는 배열만 새로 만들고 배열 안의 원소는 그대로 같은 객체를 가리키는 참조값을 복사한다.

그래서 출력 시 각 원소가 같은 객체를 가리키기 때문에 똑같은 문자열이 출력되는 것이다.

이런 경우, 한쪽 배열에서 원소 객체를 수정하면 다른 배열에서도 객체가 수정되기 때문에

Obj 객체 자체를 새로 생성하여 넣어주는 것을 권장한다.

객체 배열 정렬

객체 배열에서 객체들을 정렬하기 위해서는 Arrays.sort() 메서드만으로 정렬되지 않는다.

Obj 클래스만 해도 str과 num 중 어느 것을 정렬할 것인지에 따라 정렬 기준이 달라지기 때문에

이러한 경우 Comparable 인터페이스와 Comparator 클래스를 이용한 객체 배열 정렬 방법을 사용한다.

1. Comparable 인터페이스

자바에서 같은 타입의 인스턴스를 서로 비교해야 할때 Comparable 인터페이스를 구현하여 compareTo() 메서드를 재정의한다.

import java.util.Arrays;

public class MyClass {

    public static void main(String[] args) {

        class Obj implements Comparable<Obj> {
            String str;
            int num;

            public Obj(String str, int num) {
                this.str = str;
                this.num = num;
            }

            @Override
            public int compareTo(Obj o) {

                if(this.num > o.num) {
                    return 1;
                } else if(this.num == o.num) {
                    return 0;
                } else {
                    return -1;
                }
            }
        }

        Obj[] objArr = {new Obj("str1", 9), new Obj("str2", 2), new Obj("str3", 4)};
        System.out.println("정렬 전");
        for (Obj obj : objArr) {
            System.out.println("str : " + obj.str + "  num : " + obj.num);
        }

        Arrays.sort(objArr);
        System.out.println("정렬 후");
        for(Obj obj : objArr) {
            System.out.println("str : " + obj.str + "  num : " + obj.num);
        }
    }
}
/* 출력 결과
정렬 전
str : str1  num : 9
str : str2  num : 2
str : str3  num : 4
정렬 후
str : str2  num : 2
str : str3  num : 4
str : str1  num : 9
*/

compareTo 메서드의 비교는 -1, 0, 1로 결정된다.

반드시 -1, 0, 1로 나눌 필요는 없으며, 두 값을 비교하여 나온 결과에 따라 값을 반환해도 된다.

this.num > o.num | 양수 -> this가 뒤
this.num == o.num | 0 -> 정렬 x
this.num < o.num | 음수 -> this가 앞

하지만 프로젝트에 적용하거나 코딩 테스트 시에는 오버플로우의 위험 때문에 Integer.compare 메서드를 사용하는 것을 권장한다.

2. Comparator 클래스

Comparator 클래스를 통해 객체 정렬이 가능하다.

import java.util.Arrays;
import java.util.Comparator;

public class MyClass {

    public static void main(String[] args) {

        class Obj {
            String str;
            int num;

            public Obj(String str, int num) {
                this.str = str;
                this.num = num;
            }
        }

        Obj[] objArr = {new Obj("str1", 9), new Obj("str2", 2), new Obj("str3", 4)};
        System.out.println("정렬 전");
        for (Obj obj : objArr) {
            System.out.println("str : " + obj.str + "  num : " + obj.num);
        }

        Comparator<Obj> byNumAsc = new Comparator<>() {
            @Override
            public int compare(Obj a, Obj b) {
                return Integer.compare(a.num, b.num);
            }
        };
        /* 람다 표현식으로 교체
		Comparator<Obj> byNumAsc = (a, b) -> Integer.compare(a.num, b.num);
        -> 메서드로 교체
        Comparator<Obj> byNumAsc = Comparator.comparingInt(a -> a.num);
        */
        

        Arrays.sort(objArr, byNumAsc);
        System.out.println("정렬 후");
        for(Obj obj : objArr) {
            System.out.println("str : " + obj.str + "  num : " + obj.num);
        }
    }
}
/* 출력 결과
정렬 전
str : str1  num : 9
str : str2  num : 2
str : str3  num : 4
정렬 후
str : str2  num : 2
str : str3  num : 4
str : str1  num : 9
*/

Compareable에서 설명했던 compareTo() 메서드를 사용하여 Compartor를 구현했다.

지금은 직접 구현을 했지만 주석처리한 코드를 보면 람다로 더 짧게 코딩하거나 메서드만으로도 구현이 가능하다!

내림차순은 Comparator에 reversed 메서드만 추가하면 되니 어렵게 생각하지 말고 구현해보자!!

출처

1- Inpa Dev

2- simplex3510.tistory

JAVA 타입 형변환

minarinamu — Sun, 4 Jan 2026 16:32:53 +0900

지난 시간에는 JAVA 기본형 타입들에 대해 자세히 알아보았다.

[JAVA] - JAVA 기본형 데이터 타입

이번에는 JAVA 타입들의 형변환 원리에 대해 알아보고 이를 어떻게 적용하는지 알아보도록 하겠다.

타입 변환

하나의 타입을 본인 타입 제외하고 다른 타입으로 바꾸는 것을 타입 변환 or 형변환이라고 한다.
프로그래밍 실행 동안에는 반드시 같은 타입끼리 값의 대입이나 연산을 수행할 수 있다.
그래서 같은 기본형 타입 정수형이라고 해도 타입(int, long..)이 다르면 같은 타입으로 변환해주어야하기 때문에 형변환 작업이 필요하다.

타입 변환에는 규칙이 존재한다. 메모리에 할당받은 바이트의 크기가 상대적으로 작은 타입에서 큰 타입으로의 변환은 생략할 수 있다.

하지만 메모리에 할당받은 바이트의 크기가 큰 타입에서 작은 타입으로의 변환은 데이터 손실이 발생한다.

따라서 상대적으로 바이트의 크기가 작은 타입으로 형변환을 할 경우 자바 컴파일러는 오류를 발생시킨다.

자바 형변환에는 두 가지 방법이 있다.

하나는 묵시적 형변환과, 다른 하나는 명시적 형변환이 있다.

묵시적 형변환 | 높은 자료형으로 변환
명시적 형변환 | 낮은 자료형으로 변환

묵시적 형변환

프로그램 실행 도중에 컴파일러가 자동으로 타입 변환을 일으키는 것을 의미하는 형변환이며, 자동 형변환, 묵시적 형변환, 암시적 형변환 다양한 이름으로 불린다.

단, 작은 크기의 자료형에서 큰 크기의 자료형으로 변환할 때만 자동 타입이 변환한다. 왜냐하면 자바에서는 데이터 손실이 발생하지 않거나, 데이터 손실이 최소화되는 방향으로 자동 타입 변환을 진행하기 때문이다.(ex. short -> int)

아래에서 계속 이 도식화 자료를 사용할 예정이니 참고!!

위의 플로우를 통해 이해해보자.

byte 타입은 1 byte 크기를 갖고, long 타입은 8 byte 크기를 가진다.

그래서 아래 코드처럼 구현해도 자동으로 형변환이 된다.

위의 도식화된 변환표를 보면 이상한 점이 있을 것이다.

바로 long에서 float로의 변환이다.

long 타입은 8 byte이고, float는 4 byte인데 어떻게 변환이 될까? 그 이유는 메모리 설계상 정수 타입보다 실수 타입이 더 크게 되어 있기 때문이다.

구분	타입	할당되는 메모리 크기	데이터 표현 범위
정수형	long	8 byte	-9,223,272,036,854,775,808 ~ 9,223,272,036,854,775,807
실수형	float	4 byte	(3.4 X 10^-38) ~ (3.4 X 10^38)의 근사값

4 byte의 float가 더 큰 수를 표현할 수 있는 가장 큰 이유는 부동소수점 방식으로 표현하기 때문이다.

부동소수점 방식에서는 지수부와 가수부를 나누고, 가수부에서는 실제 값을 지수부에는 제곱을 얼마나 곱할지 표현하기 때문에 표현 범위가 long 타입보다 더 커지게 된다.

char과 byte

위의 도식화된 표현을 보면 char과 short가 동일선상에 있는 것을 볼 수 있다.

이는 char과 short 모두 2 byte의 크기를 갖고 있기 때문이다.

또한 char 타입은 기본형 타입의 문자형이지만 아스키 코드 숫자를 저장하기에 사실상 정수형 타입이다.

아이러니하게도 1 byte인 바이트 타입은 2 byte인 char 타입으로 변환할 수가 없다. 왜냐하면 char 타입은 음수를 표현할 수 없기 때문이다.

즉, byte는 표현할 수 있는 데이터 표현 범위는 적지만 음수까지 표현하기 때문에, 음수를 표현할 수 없는 char에는 저장할 수 없다.

명시적 형변환

사용자가 타입 캐스트 연산자를 사용하여 어떤 자료형으로 선언된 변수를 다른 자료형으로 강제적으로 변환해주는 것을 의미한다.

강제 형변환으로 많이 불리우며, 묵시적 형변환과 비슷하지만 큰 데이터는 작은 데이터로 변환될 때 데이터 손실로 인해 자동 타입 변환을 할 수 없다.

강제적인 동작이기 때문에 데이터의 손실이 일어난다면, 정확한 연산은 수행할 수 없기 때문에 예상치 못할 결과를 얻을 수도 있다.

아래의 코드처럼 명시적으로 작성을 해준다면 강제 형변환이 일어나게 된다.

위의 코드처럼 기본 자료형 중 boolean을 제외하면 모든 자료형은 명시적 형변환이 가능하다.

정수 -> 실수 형변환 주의점

명시적 형변환 시 데이터 손실 외에도 정밀도 손실이라는 주의점이 존재한다.

위의 코드 과정은 다음과 같다.

int형 변수 num1, num2 생성 후 123456789 값 대입
float형 변수에 num2 값 대입(묵시적 형변환)
num2에 num3 값 대입(명시적 형변환)
num1에 num2를 뺀 값 출력

머릿속으로 생각하면 분명 0이 나와야 할텐데, 왜 -3이 나오게 된 것일까?

그 원인은 형변환에 있다.

int 값을 손실 없이 float로 변환하려면 가수 23 bit로 표현 가능한 값이어야 한다. 23 bit로 표현할 수 있는 최대값은 16,777,215이기 때문에 123,456,789는 근사치로 변환된다. 이것이 바로 정밀도 손실이다.

그래서 float 값을 다시 int 값으로 변환할 때 num2에 처음 저장하였던 본래의 값을 가져올 수 없었던 것이다.

만일 정말 가져오고 싶다면 double을 사용하여 가수부에 52비트를 할당받아 변환시키면 된다.

double과 float

면접에서 나오는 빈도 높은 질문들 중 형변환에 관한 질문이 있다.

"double형 변수 a1, a2에는 각각 1.1과 0.1이 담겨 있다. 이때 이 둘을 더했을 때 1.2이라는 결과에 대해 true인가? false인가?"

모두들 느낌상 false라는 것을 알겠지만 그 이유도 알고 있는가?

코드를 통해 알아보자.

public class MyClass {

    public static void main(String[] args) {
        float a1 = 1.1F;
        float a2 = 0.1F;

        boolean a3 = a1 + a2 == 1.2F;
        System.out.println("a1과 a2의 값은 " + (a1 + a2));
        System.out.println(a3 + "\n");

        double b1 = 1.1;
        double b2 = 0.1;
        boolean b3 = b1 + b2 == 1.2;
        System.out.println("b1과 b2의 값은 " + (b1 + b2));
        System.out.println(b3);
    }
}
/*
a1과 a2의 값은 1.2
true

b1과 b2의 값은 1.2000000000000002
false
*/

자바는 실수형 타입은 기본적으로 double로 설정되어있다.

그래서 float 변수에 소수를 대입하려면 'f'를 붙혀주거나, 명시적 형변환을 통해 double -> float로 강제 변환하여야 한다.

현재 a1과 a2의 경우에는 true가 나온다.

이는 '정확한 계산 결과다."가 아닌 "근사값이 우연히 같았다."가 맞는 표현이다.

부동소수점으로 값을 저장하는 float나 double은 10진수 소수를 이진수로 정확히 표현할 수 없어서 근사값으로 저장된다. 그래서 덧셈 결과도 근사값이 되어 정확도가 떨어지지만 이번 경우에 대해서는 연산 결과와 비교 대상이 같은 비트 대상으로 떨어져 true가 나온 것이다.

즉, 다른 값의 조합이라면 false가 나올 것이다.

double의 경우는 어떨까?

double는 가수부에 52비트를 할당받는다. 이는 가수부를 23비트 갖는 float 타입보다 정밀도가 높다는 것을 의미한다. 하지만 float 타입과 마찬가지로 10진수 소수를 정확히 표현하지 못하기 때문에 b1과 b2를 더했을 때, 1.2000000000000002가 출력되는 것을 볼 수 있다.

정리하면 float든 double이든 실수는 '정확한 결과'가 아닌 근사값이기 때문에 직접적인 비교는 가급적이면 피하고, 오차 허용 비교 개념으로 사용하는 것이 권장되는 방식이다.

출처

1- Inpa Dev

2- backendcode

JAVA 기본형 데이터 타입

minarinamu — Wed, 31 Dec 2025 15:00:10 +0900

지난 시간에는 JAVA 데이터 자료형의 기본형 타입과 참조형 타입에 대해 각 종류와 특징에 대해 알아보았다.
[JAVA] - JAVA 변수 종류
이번 시간에는 기본형 타입에 대해 더 자세히 알아보도록 하겠다.

1. 기본형 타입 - 정수형

자바 언어의 기본형 타입 중 정수형은 총 4가지로, byte, short, int, long이다.

int, long이 대부분 사용되며, byte, short는 나도 프로젝트에서 사용해 본 적이 거의 없다..

타입	기본값	할당되는 메모리 크기	데이터 표현 범위
byte	0	1 byte	-128 ~ 127
short	0	2 byte	-32,768 ~ 32,767
int	0	4 byte	-2,147,483,648 ~ 2,147,483,647
long	0L	8 byte	-9,223,272,036,854,775,808 ~ 9,223,272,036,854,775,807

long 변수에 값을 대입할 때는 int 자료형의 최대 크기보다 큰 경우, 'L'을 반드시 붙혀주어야 한다.

'L'이 누락된다면, 컴파일 에러가 발생한다.

정수 오버플로우 / 언더플로우

메모리 크기를 고려하지 않는다는 가정하에 정수형 데이터를 모두 long으로 치부해도 되겠지만,
그렇지 않은 경우에 자신이 사용하고자 하는 데이터의 최소/최대 크기를 반드시 고려해야 한다.

이를 고려하지 않고 데이터를 저장하게 되면, 오버플로우/언더플로우가 발생하여 전혀 다른 값이 저장될 수 있기 때문이다.

오버플로우 | 해당 타입이 표현할 수 있는 최대 표현 범위보다 큰 수를 저장할 때 발생하는 에러
언더플로우 | 해당 타입이 표현할 수 있는 최소 표현 범위보다 작은 수를 저장할 때 발생하는 에러

예시 코드를 통해 알아보자.

public class MyClass {

	public static void main(String[] args){
		
            byte max = (byte) 245;
            System.out.println(max);
    }

}

byte 자료형의 데이터 표현 범위는 -128 ~ 127이다.

하지만 max 변수에 32637을 저장한다면 크기 범위를 넘어서는 행위이기에 오버플로우가 발생하여 잘못된 결과가 저장된다.

2진수 / 8진수 / 16진수

int 자료형은 10진수로 제공되지만 2진수, 8진수, 16진수로 변환하고 싶다면 다음과 같이 약속된 기호를 도입하면 된다.

2. 기본형 타입 - 실수형

자바의 실수 자료형은 float, double이 있다.

과거에는 실수를 표현할 때 float를 많이 사용했지만, 기술의 발달로 메모리 공간이 증가하게 되면서 double형의 사용 빈도수가 늘어나
현재는 double형을 가장 많이 사용한다.

타입	할당되는 메모리 크기	데이터 표현 범위	literal 타입 접미사
float	4 byte	(3.4 X 10^-38) ~ (3.4 X 10^38)의 근사값	F 또는 f
double	8 byte	(1.7 X 10^-308) ~ (1.7 X 10^308)의 근사값	D 또는 d(생략 가능)

실수의 표현 오차

정수형에도 표현할 수 있는 표현 범위가 제한되어 있듯이, 실수형에도 소숫점을 표현하는 범위가 존재한다.

소숫점은 경우에 따라 무수히 많은 숫자를 포함한 계산 결과를 제공한다. 이러한 한계를 최소화하기 위해서 컴퓨터는 소수를 이진법으로 표현할 때 고정 소수점 방식이 아닌 부동 소수점 방식을 사용한다.

(부동 소수점 방식은 소수점 위치를 고정하지 않고, 가수와 지수로 나누어 표현하는 방식이다.

부동 소수점 방식을 사용하여 큰 범위의 실수까지도 표현이 가능하다는 장점이 있지만, 100% 정확하게 표현하는 것이 아니라서, 소수 연산 시 부정확한 실수의 계산값을 초래할 수 있다.

이러한 문제에 대해 자바는 두 가지 방법을 제안한다.

실수를 int, long 정수형 타입으로 치환하여 계산
BigDecimal 클래스 사용

1번의 경우에는 소수점의 실수들을 정수로 바꿀 만큼의 10의 n제곱 연산을 하여 나온 두 정수들을 연산한 후에 다시 실수형으로 되돌리는 방식이다.(ex. 12.34 + 23.45 (치환)-> 1234 + 2345 -> 3579 (다시 변환)-> 35.79)

2번의 경우에는 소수의 크기가 9자리를 넘지 않으면 int를, 18자리를 넘지 않으면 long 타입을 사용하면 되지만 그 이상 넘어갈 경우에는 BigDecimal 클래스를 사용하여 표현 범위를 늘릴 수 있다.

실수의 유효 자릿수

실수의 유효 자릿수는 곧 정밀도를 의미한다.

타입	지수의 길이	가수의 길이	유효 자릿수
float	8 bit	23 bit	소수점 약 6~7자리까지 높은 확률로 정확히 표현
double	11 bit	52 bit	소수점 약 15~16자리까지 높은 확률로 정확히 표현

타입에 따라 유효 자릿수가 달라지며, 이 유효 자릿수는 좌측부터 시작되는 숫자 개수이다.

실수 오버플로우 / 언더플로우

실수형에서도 정수형과 마찬가지로 오버플로우, 언더플로우가 발생할 수 있다.

오버플로우 | 무한대
언더플로우 | 양의 최소값보다 작은 값으로 0이 된다.

3. 기본형 타입 - 논리형

2진수처럼 두 결과를 제공하는 논리형 자료형은 연산 결과에 대한 결과값이 제공된다.

진위를 가려내는 용도로 많이 사용되므로 if 연산자와 함께 종종 사용된다.

4. 기본형 타입 - 문자형

char형은 하나의 문자에 대한 자료형으로 사용된다.(문장이 아닌 문자 하나이다!)

char a = 'a';

위와 같이 사용되며 주의할 점은 작은 따옴표를 사용해야 한다는 점이다.

큰 따옴표는 문장을 의미하므로 char에 사용한다면 에러가 난다.

현재 위의 char형인 a는 문자 그대로 'a'를 출력하지만, 아스키코드나 유니코드를 통해서도 'a'를 출력할 수 있다.

아스키코드 | 1962년 "ANSI"가 정의한 미국 표준 정보교환 코드이며, 1963년 ASA에 의해 미국의 표준 부호가 됨.
- 7비트의 이진수 조합으로 만들어져 총 129개의 부호 사용 가능
- 아스키코드의 처음 32개는 프린터나 전송 제어용으로 사용되며, 나머지는 숫자와 로마 글자, 문장 기호를 나타낸다.
유니코드 | 각 나라별 언어를 모두 표현하기 위해 나온 코드 체계
- 사용 중인 운영체제, 프로그램, 언어에 관계없이 문자마다 고유한 코드 값을 제공
- 모든 문자를 16bit로 표현

아스키코드와 유니코드

5. 문자열 자료형

문장을 의미하는 자료형으로, char형이 작은 따옴표로 감쌌던 대신 문자열 자료형은 큰 따옴표로 감싼다.

자바에서 사용되는 String 클래스는 문자열을 위해 제공되었으며, char[] 배열과 같은 동작 방식을 갖는다.

String 자료형을 이용하여 문자열 변수를 표현하는 방법은 두 가지가 있다.

String str1 = "Hello World!";
String str2 = new String("Hello World!");

두 객체를 비교하였을 때, 이 둘은 같다고 말할 수 있을까? 정답은 "아니다."

str1은 리터럴 표기 방식이며, JVM 내 힙 영역의 String Constant Pool에 저장된다.

상수풀에 저장되기 때문에 같은 문자열 value를 가진다면 재사용이 가능하다.

str2는 생성자 방식이며, str1과 마찬가지로 JVM 내 힙 영역의 String Constant Pool에 저장되고,
추가로 객체로 생성된다는 차이가 있다.

때문에 동일한 내용이라도 매번 새로운 객체가 생성된다. 이는 메모리 사용의 증가로 이어지므로 리터럴 표기를 권장한다.

또한 String 인스턴스는 한 번 생성되면 변경할 수 없다는 특징이 있다.

이를 불변 객체(Immutable Object)라고 불리며, 만약 자바에서 덧셈 연산자를 사용하여 문자열 결합을 수행하면, 기존 문자열의 내용이 변경되는 것이 아닌 내용이 합쳐진 새로운 String 인스턴스가 생성되게 한다.

출처

1- Inpa Dev

2- velog.io/@hyeonseob22

JAVA 변수 종류

minarinamu — Tue, 30 Dec 2025 17:18:18 +0900

지난 시간에는 자바 소스 파일의 구성 요소들을 알아보았다.

[JAVA] - 자바 소스 코드 구조

이번 시간에는 자바 내에서 사용되는 변수의 타입과 차이를 알아보도록 하자.

1. 변수(Variable)란?

'변수'는 데이터를 저장하기 위해 프로그램에 의해 이름을 할당받은 메모리 공간이다.
자바 언어에서도 변수를 사용하며 변수는 '데이터 타입'에 의해 그 목적이 정해진다.

데이터 타입(자료형)은 크게 기본형 타입과 참조형 타입으로 나뉜다.

2. 기본형 타입(Primitive Type)

기본형 타입은 계산을 위해 실제 값을 저장하는 타입을 의미한다.

크게 논리형(boolean), 문자형(char), 정수형(byte, short, int, long), 실수형(float, double)으로 나뉜다.

기본형 타입은 비객체 타입으로 null이 될 수 없으며, 변수의 선언과 동시에 메모리가 생성된다.

또한 후에 나올 참조형 타입과 다르게 모든 값은 메모리의 스택 영역에 저장된다.

구분	타입	할당되는 메모리 크기	기본값	데이터 표현 범위
논리형	boolean	1 byte	false	true or false
문자형	char	2 byte	'\u0000'	0 ~ 65,535
정수형	byte	1 byte	0	-128 ~ 127
	short	2 byte	0	-32,768 ~ 32,767
	int(default)	4 byte	0	-2,147,483,648 ~ 2,147,483,647
	long	8 byte	0L	-9,223,272,036,854,775,808 ~ 9,223,272,036,854,775,807
실수형	float	4 byte	0.0F	(3.4 X 10^-38) ~ (3.4 X 10^38)의 근사값
실수형	double(default)	8 byte	0.0	(1.7 X 10^-308) ~ (1.7 X 10^308)의 근사값

3. 참조형 타입(Reference Type)

참조형 타입은 객체의 주소를 저장하는 타입을 의미한다.

값은 null을 허용하며, 객체의 주소를 갖는다.

클래스, 인터페이스, 배열, enum 타입이 이에 해당된다.

참조형 타입은 기본형과는 달리 실제 값이 저장되지 않고, 자료가 저장된 공간의 주소를 저장한다.

JVM 내의 힙 영역에 실제 값을 저장하고, 그 참조값을 갖는 주소는 스택에 저장한다.

arr은 참조형 배열 타입으로 스택에 저장, 주소의 실제 값은 힙에 저장

타입	기본값	할당되는 메모리 크기
클래스	Null	4 byte
인터페이스	Null
열거	Null
배열	Null

참고

1. https://velog.io/@minseojo/Java-데이터 타입-기본형-참조형

2. Inpa Dev

자바 소스 코드 구조

minarinamu — Mon, 29 Dec 2025 23:53:31 +0900

자바 문법을 이해하기 전에 자바 소스 코드가 어떻게 구성되어 있는지 알아보자.
(자바 소스 코드는 JVM 컴파일러를 통해 바이트 코드로 컴파일링 되기 전의 상태이다.)

0. 시작하기 전에..

자바로 프로그래밍을 하기 위해서는 JDK라는 개발 도구가 필요하다.

OS에 JDK를 설치하면 JVM과 JRE 등 자바 개발에 필요한 프로그램들이 설치된다.

이해가 되지 않는다면 아래의 글을 참고해보자.

2025.11.24 - [JVM] - JDK / JRE / JVM 개념

JDK / JRE / JVM 개념

Java 언어를 사용하여 프로젝트를 사용하는 것은 우리에게 기본적인 행위이지만어떤 식으로 돌아가는지 아는 이들은 과연 얼마나 될까?Java 프로그램이 돌아가게 하는 JDK와 JRE, 그리고 이 둘을 합

gony-dev.tistory.com

1. 자바 소스 파일 구조

자바에서 모든 소스 코드는 class 안에 작성하도록 명시되어 있다.

그리고, 자바 프로그램은 많은 class의 집합으로 이루어져 있다.

보통 일반적인 자바 소스 코드는 다음과 같은 형태로 구성되어 있다.

// 1. 패키지 선언
package com.hello.helloworld

// 2. import 선언
import java.lang.*;

// 3. Class 선언
public class MyClass {

	// 4. main 메서드 선언
	public static void main(String[] args) {
    	String str = hello("Hello World!");
        System.out.println(str);
    }
    
    // 5. hello 메서드 선언
    public static String hello(String msg) {
    	return msg + " My name is Park!";
    }
}

1-1. 패키지(package) 선언

패키지는 클래스가 위치한 경로를 의미하며, 하나의 패키지 안에는 여러 패키지가 존재할 수도 있고, 여러 클래스가 존재할 수 있다.

패키지 명명 규칙에 대해서는 다음과 같다. 하지만 암묵적으로 규칙이 되어 있을 뿐, 무조건적으로 따를 강제적 제약은 아니다.

패키지는 자바 소스 파일의 최상단에 선언해야하며, 두 번 이상 허용되지 않는다.
패키지명은 영어 대소문자를 모두 사용(=camel case)할 수 있으나, 대부분 영어 소문자만으로 구성하는 것을 권장한다.
동일한 이름의 클래스가 여러 존재하는 경우, 패키지를 기준으로 클래스를 구분할 수 있다.
패키지는 OS 내의 폴더와 같이 물리적인 경로를 의미하며, 패키지 선언에 포함되는 '.'은 OS에서 폴더를 구분하는 '\'와 동일하다.

이러한 규칙으로 서로 연관된 클래스들을 패키지 단위로 묶으면, 프로젝트 내 클래스들을 효율적으로 관리할 수 있다.

1-2. import 선언

'import'는 특정 클래스에서 다른 클래스를 참조하고 싶을 때 선언하는 키워드이다.

즉 코드에서 사용할 클래스 패키지에 대한 정보를 미리 제공하는 역할을 하며, 참조할 패키지에 대해서는 경로를 포함한 풀 네임을 명시해야한다.

만일 자바에서 import를 사용할 수 없다면(그럴 일은 없겠지만..),
아래 코드처럼 String 클래스와 같이 클래스의 전체 경로를 선언하면 된다.

package com.hello.helloworld;

public class Hello {
	
    public static void main(String args[]){
    	java.lang.String str = hello("Hello World!");
        
    }
    
    public static java.lang.String hello(String msg){
    	return msg + " My name is Park!";
    }
}

위는 예시 코드로서 보여준 것이지만, java.lang 패키지에 대해서는 import문을 사용하지 않아도 클래스 이름만으로 사용할 수 있도록 하고 있다.

import를 선언할 때에는 주의할 점이 있는데, 선언 시 '*'를 사용하면 해당 패키지에 포함된 모든 클래스를 가져오지만 모든 하위 패키지의 클래스까지 포함시켜주지 않는다.

따라서 하위 클래스까지 가져오고 싶다면 직접 하위 도메인 경로를 지정해 표현하는 것이 좋다.

1-3. 클래스 선언

클래스는 객체를 정의해 둔 설계도로 정의할 수 있다.

클래스 명은 반드시 소스 파일명과 일치해야하며, 접근제어자에 따라 동일한 클래스명을 가질 수도 있다.

위의 MyClass 클래스명은 public으로 지정하여 다른 패키지 내에서 사용할 수 있기 때문에 중복 문제가 발생하지 않도록 하나만 존재해야한다.

클래스 구성은 아래의 4가지로 구성되어 있다.

필드 | 객체의 데이터를 저장
생성자 | 생성된 객체를 초기화
메서드 | 객체의 동작을 실행
내부 클래스 | 클래스나 인터페이스의 내부에 선언

1-4. main 메서드 선언

main 메서드는 프로그램을 실행하는 메인 스레드 역할을 하며 구성된 바는 아래와 같다.

public static void main(String[] args) {
	// psvm이라는 단축어로 메서드 자동 생성이 가능하다!
}

public | 모든 클래스에서 사용 가능한 의미의 접근 제어자
static | 컴파일 시 가장 빠르게 정의되어 별도의 객체 생성 없이 모든 객체와 공유가 가능
void | 반환값이 존재하지 않는 메서드
main | 메서드명
String[] args | 연속적인 문자열 데이터가 들어가는 저장 공간

참고

1. Inpa dev

2. Congsong

클래스 로드 및 초기화 시점

minarinamu — Mon, 22 Dec 2025 18:04:06 +0900

지난 시간에는 JVM의 프로그램 상에서 작동하는 파라미터 전달 방법 두 가지의 차이를 알아보고,
힙/스택 영역에서 어떻게 동작하는지 알아보았다.

[JVM] - Call by Value / Call by Reference

이번 시간에는 자바 클래스 파일들이 어느 시점에 로딩되고 초기화되는지 알아보도록 하자.
출처 - Inpa Dev

Class Loader

로드와 초기화라는 키워드를 듣고 클래스 로더가 생각난다면 JVM에 대해 어느정도 이해를 하고 있다고 할 수 있다.

클래스 로더는 동적 로딩을 통해 필요한 클래스들을 로딩 및 링크하여 Runtime Data Area에 올리는 작업을 수행한다.

동작 방식은 크게 3가지로 나뉜다.

Loading
- 클래스 파일들을 가져와 JVM의 메모리에 로드한다.
Linking
1. Verifying - JVM 명세에 명시된 대로 작성되어 있는지 검증한다.
2. Preparing - 클래스가 필요로 하는 메모리를 할당한다.
3. Resolving - 클래스의 상수 풀 내 모든 심볼릭 레퍼런스를 다이렉트 레퍼런스로 변경한다.
Initialization
1. 클래스 변수들을 적절한 값으로 초기화한다.

동적으로 할당한다는 것이 클래스 로더에서 중요한 부분인데,
Loading 과정은 모든 메모리를 한 번에 올리지 않고 필요한 경우 동적으로 메모리를 적재한다.

이는 static 멤버들을 소스를 실행하자마자 한 번에 메모리에 올리게 될 경우 비효율적인 성능을 낼 수 있기 때문에 클래스 내의 멤버를 호출하게 되면 그때 클래스가 동적으로 메모리에 로드하는 것이다.

클래스 로딩 시점

그럼 클래스를 JVM에 언제 로드할까?

클래스 로딩 시점은 크게 3가지로 나뉜다.

1. 클래스의 인스턴스가 생성될 때

2. 클래스의 static 변수가 사용될 때

3. 클래스의 static method가 호출될 때

위의 경우들을 예제 코드로 하나씩 살펴보자.

다음은 static 멤버를 로드 및 초기화하기 위해 준비한 Outer.class이다.

public class Outer {

    // 일반 static 필드
    static String value = init("Outer.class", "Outer static 필드");

    // 컴파일 타임 상수 (String literal): Method Area의 상수 풀로 인라인되어
    static final String CONST = "Outer constant 필드";

    Outer() {
        log("Outer 생성자 초기화");
    }

    static void getInstance() {
        log("Outer.getInstance() 메서드 호출");
    }

    // ---- Holder ----
    static class Holder {

        // 클래스 변수
        static String value = "Holder static 필드";

        // 상수
        static final String VALUE_CONST = "Holder constant 필드";

        Holder() {
            log("Holder 생성자 초기화");
        }
    }

    // ---- Inner ----
    class Inner {
        Inner() {
            log("Inner 생성자 초기화");
        }
    }

    // ====== 관찰용 유틸 ======
    private static String init(String name, String v) {
        log("init field -> " + name);
        return v;
    }

    private static void log(String msg) {
        // 어떤 ClassLoader로 로드됐는지까지 같이 출력
        System.out.printf("[%s] %s%n",
                Outer.class.getClassLoader(),
                msg
        );
    }
}

클래스 로드의 동작을 자세히 관찰하기 위해서 두 가지 메서드를 추가하였다.

init
- 해당 객체가 어디로부터 초기화되었는지 출력한다.
log
- 어떤 클래스로더로 로더되었고, 어떤 동작을 나타내는지 출력한다.

1. 아무것도 출력하지 않았을 경우

public class MyClass {

    public static void main(String[] args) {
        System.out.println("=== main start ===");
    }
}

출력결과

보는 바와 같이 MyClass만 로드되고 있는 것을 확인할 수 있다.

Outer 클래스의 어떤 객체도 사용하지 않았기 때문에 Outer 클래스는 로드되지 않는다.

2. static 변수 호출하기

public class MyClass {

    public static void main(String[] args) {
        System.out.println("=== main start ===");
        System.out.println("static 필드인 value 값은 " + Outer.value + "입니다.");
        System.out.println("=== main end ===");
    }
}

출력결과

main 메서드가 실행되자 MyClass를 할당하고 Outer 클래스가 로드되어 static 필드를 출력한다.

3. static final 상수 호출하기

static final 필드의 값은 과연 Outer 클래스를 로드할까?

public class MyClass {

    public static void main(String[] args) {
        System.out.println("=== main start ===");
        System.out.println("static final 상수 CONST는 " + Outer.CONST + "입니다.");
        System.out.println("=== main end ===");
    }
}

예상했겠지만 Outer Class를 로드하지 않는다.

static final과 같이 선언된 상수는 JVM의 Method Area의 Constant Pool에 따로 저장되어 관리되기 때문이다.

3. 내부 클래스 / static 메서드 호출

public class MyClass {

    public static void main(String[] args) {
        System.out.println("=== main start ===");
        Outer.getInstance();
        new Outer().new Inner();
        System.out.println("=== main end ===");
    }
}

위의 코드는 Outer의 static 메서드와 Outer의 내부 클래스를 각각 선언했을 때의 결과이다.

getInstance()의 경우에는 Outer 클래스만 로드하며,

Outer 클래스의 내부 클래스인 Inner 클래스를 생성할 때는 Outer과 Inner 클래스 모두 로드가 된다.

모두 로드가 되기 때문에 Inner 클래스에 static을 설정하지 않는다면 메모리 누수가 발생하게 된다.

클래스 초기화 시점

클래스 초기화는 static에 대한 필드 및 메서드의 값을 할당하는 것을 의미한다.

클래스 로더는 클래스 초기화 과정을 3단계로 나누어져 있지만,
클래스 초기화는 클래스 로드 시점과 거의 동일하게 일어남을 위의 예시 코드를 통해 알 수 있었다.

클래스 로더에 대한 단계를 설명하기 위해 기술되어 있었지만 거의 로드와 초기화는 거의 동시에 진행되었다고 보면 된다.

Call by Value / Call by Reference

minarinamu — Sun, 14 Dec 2025 23:02:21 +0900

지난 시간에는 JVM 내에서 사용되는 메모리 영역들인
Method Area, Heap Area, Stack Area를 알아보았다.

[JVM] - 자바 코드의 메모리 영역

이번 시간에는 Java의 Call by Value와 Call by Reference에 대해 알아보자.
출처 - Inpa Dev

Java의 Call by Value / Call by Reference

자바에서 메서드를 호출할 때 파라미터를 전달하는 방법에는 두 가지가 존재한다.

1. Call by Value

2. Call by Reference

이는 프로그래밍 시 반드시 마주하게 되는 개념으로 함수의 매개변수에서 값을 복사하느냐 주소값을 참조하느냐에 따라

반환 결과가 달라지기 때문에 중요하다.

데이터형에 따라 동작 차이가 나는데,

자바의 데이터형을 먼저 알아보면 크게 두 가지로 나뉜다.

기본형(Primitive Type)
- Boolean Type - boolean
- Nemuric Tyep - int, short, long, double, char
참조형(Reference Type)
- Class Type, Interface Type, Array Type, Enum Type

예시 코드로 진행해보자.

public class MyClass {

	public static void main(String[] args){
    	
        int num = 0;
        int[] arr = { 0 };
        
        add_num(num);
        add_arr(arr);
        
        System.out.println("num의 값은 " + num + "입니다.");
        System.out.println("arr[0]의 값은 " + arr[0] + "입니다.");
    }
    
    static void add_num(int num){
    	
        num += 100;
    }
    
    static void add_arr(int[] array){
    	
        array[0] += 100;
    }
}

위의 코드의 출력 결과는 다음과 같다.

num의 값은 0입니다.
arr[0]의 값은 100입니다.

위의 처리 결과가 바로 Call by Value와 Call by Reference가 일어난 것이다.

1. Call by Value

Call by Value는 메서드를 호출할 때 값을 넘겨주기 때문에 Pass by Value라고도 불린다.

메서드를 호출하는 호출자의 변수와 호출 당하는 수신자의 파라미터는 복사된 서로 다른 변수이다.

그러므로 값만 전달하기 때문에 수신자의 파라미터를 수정해도 호출자의 변수에는 아무런 영향이 없다.

2. Call by Reference

Call by Reference는 주소를 직접 넘기기 때문에 호출자의 변수와 수신자의 파라미터는 완전히 동일한 변수이다.

그러므로 메서드 내에서 파라미터를 수정하면 그대로 원본 변수에도 적용이 된다.

코드를 다시 살펴보며 알아보도록 하자.

먼저 num 변수는 Primitive Type이고, arr 배열 변수는 Reference Type으로 선언된다.

arr 배열 변수의 실제 데이터는 heap 영역에 저장되어 이를 참조할 주소값을 지니게 된다.

후에 add_num 메서드를 호출하면 add_num의 스택 프레임이 생성되며 메서드 내의 지역 변수 num에 100을 더하게 된다.

이때 add_num 스택 프레임 내에 있는 지역 변수 num의 값이 바뀐 것이지 main 스택 프레임 내의 num의 값이 바뀐 것이 아니다.

매개변수인 num은 그저 main의 num으로부터 원시값을 복사하여 받았기 때문이다.

이게 바로 call by value이다.

다시 말해 add_num의 지역 변수인 num과 main의 num은 상관없는 별개의 객체라는 것이다.

arr에 대한 경우는 다르다.
add_arr을 호출하는데 같은 방식으로 add_arr 스택 프레임이 생성되고 매개변수인 array가 생성된다.

add_num처럼 변수의 값이 복사되어 파라미터에 넘겨지게 되는데, 이때 arr 변수가 들고있는 값은 '원시값'이 아닌 '주소값'이다.

즉, arr의 주소값이 매개변수로 넘겨지게 되어 add_arr에서의 값 변경은 힙 영역의 주소 참조 데이터를 변경하게 되는것이다.

Call by Reference 개념이 없는 Java

사실 자바 프로그래밍에서는 call by reference가 존재하지 않는다.

그 이유는 C 언어와 달리 포인터를 숨겨 개발자가 직접 메모리 주소에 접근하지 못하게 막아놓았기 때문이다.

(C언어는 '*' 과 '&' 기호를 통해 주소 접근이 가능하다!)

자바 프로그래밍은 매개변수의 복사된 값에 따라 동적으로 연산을 수행한다고 보면 된다.