일단 해보고 기록하는 블로그

[Java] 객체지향 기초 : 캡슐화, final, static 블록

지그농 — Fri, 22 May 2026 12:23:48 +0900

자바와 객체 지향 개념에 대해 공부할 때 항상 헷갈리는 핵심 개념들이 있습니다.

이번 게시글에서는 코드의 안전성을 높이는 접근 제한자와 캡슐화, 프로그램의 구조를 잡는 package와 import, 그리고 데이터의 변경을 막고 초기화를 돕는 final과 static 블록에 대해 정리했습니다.

목차
1. 접근제한자와 캡슐화
2. package와 import
3. final과 static 블록

1. 접근 제한자 (Access Modifier)와 캡슐화 (Encapsulation)

접근 제한자는 클래스, 변수, 메서드의 사용 범위를 제한하는 역할을 합니다.

1.1 접근 허용 범위 크기

public > protected > default > private

public: 다른 패키지를 포함해 어디서나 접근 가능합니다.
protected: 같은 패키지 내에서 접근 가능하며, 다른 패키지에 있더라도 상속 관계(자식 클래스)라면 접근 가능합니다.
default: 접근 제한자를 명시하지 않았을 때의 기본값입니다. 같은 패키지 내부에서만 접근할 수 있습니다.
private: 같은 클래스 내부에서만 접근이 가능하며, 외부에서는 절대 직접 접근할 수 없습니다.

1.2 캡슐화

외부에서 클래스의 데이터(변수)에 직접 접근해 값을 바꾸지 못하도록 막고, 내가 정해둔 규칙(메서드)을 통해서만 데이터에 접근하고 수정할 수 있도록 제한하는 것을 캡슐화라고 합니다.

이는 데이터의 무결성이 깨지는 것을 막고 안전성을 높이기 위해, 오직 검증된 public 메서드로만 데이터 접근을 허용하는 대표적인 객체지향 기법입니다.

Setter (설정자 메서드): 외부에서 값을 전달받아 조건문 등으로 유효성을 검증한 뒤 내부 멤버 변수에 대입합니다. (접근)
Getter (접근자 메서드): private 멤버 변수의 값을 외부로 반환하여 읽기 기능을 제공합니다. (읽기)

package com.library.model;

public class Book {
    // 1. 외부에서 직접 변경하지 못하도록 private 선언
    private String title;
    private int price;

    // 2. Setter: 내가 정해둔 규칙으로만 값을 저장하도록 제어
    public void setTitle(String title) {
        // 입력된 제목 앞에 반드시 "[종이책]"이라는 접두사가 붙도록 규칙 설정
        this.title = "[종이책]" + title;
    }

    public void setPrice(int price) {
        // 가격이 음수가 되지 않도록 검증 규칙 적용
        if (price < 0) {
            this.price = 0;
        } else {
            this.price = price;
        }
    }

    // 3. Getter: 안전하게 데이터를 외부로 출력
    public String getTitle() {
        return this.title;
    }

    public int getPrice() {
        return this.price;
    }
}

2. 패키지(Package)와 임포트(Import)

Package

정의: 물리적인 폴더 구조를 기반으로 관련 클래스들을 그룹화하여 관리하는 단위입니다.
목적: 클래스 이름의 중복 및 충돌을 방지합니다.
규칙: 소스 코드 최상단(첫 줄)에 명시해야 합니다.

Import

정의: 다른 패키지에 속한 클래스를 참조할 때 사용합니다.
권장사항: import 패키지명.*은 패키지 내 모든 클래스를 가리키지만, 코드의 가독성과 명확한 의존성 파악을 위해 사용하는 클래스명을 각각 명시하는 것을 권장합니다.
특징: java.lang 패키지는 기본 패키지이므로 import문 없이 사용 가능합니다. (lang 예시 - System, String, Math...)

package com.library.service; // 최상단 위치

import com.library.model.Book; // 명시적 클래스 import

public class LibraryService {
    public void createBook() {
        Book myBook = new Book(); 
        myBook.setTitle("자바 가이드");
        
        // java.lang 패키지의 String과 System은 import 생략
        String title = myBook.getTitle();
        System.out.println(title); 
    }
}

3. final 제어자

final 키워드는 대상의 상태를 확정하여 이후 변경이나 확장이 불가능하도록 만듭니다.

컴파일 시점에 변경 시도를 차단하므로 런타임 오류를 예방하고 개발 생산성을 높입니다.

final 변수: 상수가 되며, 초기화 이후 값을 변경(재할당)할 수 없습니다.
final 클래스: 다른 클래스가 상속(Inheritance)할 수 없는 클래스가 됩니다.
final 메서드: 자식 클래스에서 오버라이딩(Overriding)하여 재정의할 수 없습니다.

package com.library.util;

// final 클래스: 상속 불가능
public final class BookConfig {

    // final 변수: 값 변경 불가능한 상수
    public static final int MAX_RENTAL_DAYS = 14; 

    // final 메서드: 자식 클래스에서 오버라이딩 불가능
    public final void printPolicy() {
        System.out.println("도서관 대여 정책입니다.");
    }
}

4. Static 블록과 인스턴스(Instance) 블록

Static 초기화 블록

특징: 클래스가 메모리에 처음 로딩될 때 단 한 번만 실행됩니다. 객체 생성 여부와 무관하게 호출됩니다.
목적: static 멤버 변수(클래스 변수)의 복잡한 초기화 작업을 수행할 때 사용합니다.

인스턴스 초기화 블록

특징: 클래스 내부에 키워드 없이 { }로 작성하며, 인스턴스가 생성될 때마다 생성자보다 먼저 실행됩니다.
목적: 다중 생성자가 존재할 때, 생성자의 종류와 관계없이 공통적으로 실행되어야 하는 초기화 코드를 중복 없이 작성할 때 사용합니다.

package com.library.model;

public class EBook {
    public static String libraryName;
    public String bookTitle;

    // 1. Static 블록: 클래스 로딩 시 1회 실행
    static {
        libraryName = "중앙 디지털 도서관";
        System.out.println("Static 블록 실행: 클래스 변수 초기화");
    }

    // 2. 인스턴스 블록: 객체 생성 시 생성자 호출 전에 실행
    {
        System.out.println("인스턴스 블록 실행: 객체 공통 로직 실행");
    }

    public EBook() {
        System.out.println("기본 생성자 실행");
    }

    public EBook(String bookTitle) {
        this.bookTitle = bookTitle;
        System.out.println("매개변수 생성자 실행");
    }
}

public class Main {
    public static void main(String[] args) {
        // 인스턴스를 생성하기 위해 EBook 클래스를 처음 호출하는 순간 클래스가 로딩됩니다.
        System.out.println("--- 첫 번째 객체 생성 ---");
        EBook book1 = new EBook("자바의 정석");

        System.out.println("\n--- 두 번째 객체 생성 ---");
        EBook book2 = new EBook();
    }
}

--- 첫 번째 객체 생성 ---
Static 블록: 클래스 변수(libraryName) 초기화 완료  <-- 클래스 로딩 시 최초 1회만
인스턴스 블록: 객체 생성 시 공통 로직 실행          <-- 인스턴스 생성 시 실행
매개변수 생성자 실행                                <-- 생성자 실행

--- 두 번째 객체 생성 ---
인스턴스 블록: 객체 생성 시 공통 로직 실행          <-- static 블록은 건너뛰고 인스턴스 블록 실행
기본 생성자 실행                                    <-- 생성자 실행

5. 참고 링크

java.lang (Java SE 23 & JDK 23 [build 1])

Provides classes that are fundamental to the design of the Java programming language. The most important classes are Object, which is the root of the class hierarchy, and Class, instances of which represent classes at run time. Frequently it is necessary t

download.java.net

[지금 무료]비전공자를 위한 자바| 이신만 - 인프런 강의

현재 평점 4.9점 수강생 946명인 강의를 만나보세요. 비전공자, 초보 개발자들이 자바 문법을 쉽게 배울 수 있습니다. 예제를 분석하며 문법을 배우는 방식입니다. 자바 문법, 객체지향, 자료구조,

www.inflearn.com

[Java] 객체지향 기초 : 상속(Is-A), 포함(Has-A), super, 오버라이딩과 다형성

지그농 — Thu, 21 May 2026 17:47:58 +0900

오늘 자바 강의에서 객체지향 프로그래밍의 특징인 상속과 다형성에 대해 간단하게 배웠습니다.

모든 예제 코드는 '책(Book)'을 주제로 작성되었으며, 저처럼 객체지향 개념이 헷갈리는 분들께도 도움이 될 수 있도록 작성해보았습니다!

목차
1. 상속과 Is-A 관계
2. Has-A 관계 (포함 관계)
3. super 생성자
4. super 키워드
5. 메서드 오버라이딩
6. 다형성

1. 상속과 Is-A 관계

자바에서 상속은 기존 클래스의 변수와 메서드를 다른 클래스가 물려받는 것을 말하며,

extends 키워드를 사용합니다.

class B extends A { ... }

A 클래스 : 부모 클래스 (Super Class)
B 클래스 : 자식 클래스 (Sub Class)

위와 같이 상속 관계면, 부모와 자식 관계가 형성이 되며 특징은 아래와 같이 정리할 수 있습니다.

자식은 부모의 모든 것을 가진다.
- 자식 클래스(B)는 부모 클래스(A)의 모든 변수와 메서드를 물려받아 그대로 사용할 수 있음.
부모는 자식의 것을 사용할 수 없다.
- 부모 클래스로 인스턴스를 생성하면, 자식 클래스에만 정의된 변수나 메서드는 사용할 수 없음
자식끼리는 남남
- 같은 부모를 상속받은 자식 클래스들끼리는 서로의 변수나 메서드에 접근할 수 없음

왜 상속을 사용할까? (유지보수의 편의성)

부모 클래스에 공통된 성격이나 기능을 한 번만 정의해 두면, 자식 클래스들은 이를 자동으로 물려받습니다.

나중에 공통 기능에 수정, 추가, 삭제가 필요할 때 부모 클래스 한 곳만 수정하면 되기 때문에 유지보수가 매우 편리해집니다.

이러한 상속에 의한 객체 관계를 "Is-A 관계 (B는 A이다)"라고 부릅니다.

// 부모 클래스: Book
class Book {
    String title;
    int price;

    void read() {
        System.out.println(title + "을(를) 읽습니다.");
    }
}

// 자식 클래스 1: EBook (EBook은 Book이다 -> Is-A 관계)
class EBook extends Book {
    String device; // 전자책만의 고유 속성

    void download() {
        System.out.println(device + " 기기로 책을 다운로드합니다.");
    }
}

// 자식 클래스 2: MajorBook (MajorBook은 Book이다 -> Is-A 관계)
class MajorBook extends Book {
    String subject; // 전공서적만의 고유 속성
}

public class Main {
    public static void main(String[] args) {
        // 1. 자식 객체 생성 및 부모 메서드 사용
        EBook myEBook = new EBook();
        myEBook.title = "자바의 정석 전자책"; // 부모의 변수 사용
        myEBook.read();                   // 부모의 메서드 사용
        
        myEBook.device = "크레마";         // 자식 본인의 변수 사용
        myEBook.download();               // 자식 본인의 메서드 사용

        // 2. 부모 인스턴스로는 자식의 변수/메서드 접근 불가
        Book generalBook = new Book();
        generalBook.title = "일반 소설책";
        // generalBook.download(); // ❌ 컴파일 에러! 부모는 자식의 기능을 모릅니다.

        // 3. 자식 클래스끼리는 서로 접근 불가
        MajorBook myMajor = new MajorBook();
        // myMajor.download(); // ❌ 컴파일 에러! EBook과 MajorBook은 서로 남남입니다.
    }
}

2. Has-A 관계 (포함 관계)

클래스를 확장하는 또 다른 방법은 상속이 아니라, 한 클래스 내부에서 다른 클래스의 인스턴스를 생성하여 활용하는 방법입니다.

이를 "Has-A 관계 (A는 B를 가지고 있다)"라고 합니다.

class User {
    String name = "홍길동";
}

class Cart {
    Book book;    // Cart는 Book을 가지고 있다. (Has-A)
    User owner;   // Cart는 User를 가지고 있다. (Has-A)

    void showCartInfo() {
        System.out.println(owner.name + "님의 장바구니에 담긴 책: " + book.title);
    }
}

왜 상속 대신 포함(Has-A)을 사용할까?

상속은 부모와 자식의 결합도가 너무 높아지는 치명적인 단점이 있기 때문에, 아래와 같은 경우는 포함을 사용하게 됩니다.

논리적인 오류를 방지
- 만약 Cart extends Book의 형태로 상속을 받으면 구조상 "장바구니는 책이다(Cart is a Book)"라는 비논리적인 관계가 형성
- 장바구니는 책의 종류가 아니라 책을 '포함'하는 개념이므로 Has-A 관계가 자연스러움
유연성과 변경에 유리 (느슨한 결합)
- Has-A 관계는 필요한 클래스를 부품처럼 가져다 쓰기 때문에, 내부에서 참조하는 클래스가 바뀌어도 Cart 클래스 자체의 구조를 크게 뜯어고칠 필요가 없음
다중 상속의 한계를 극복
- 자바는 클래스의 다중 상속을 지원하지 않음. 즉, Cart가 Book과 User를 동시에 상속받을 수 없음
- Has-A 관계를 사용하면 위 예시 코드처럼 여러 크래스를 변수로 선언해 조합하여 사용할 수 있음

3. super 생성자

자바에서 자식 객체를 생성할 때, 컴파일러는 내부적으로 부모의 기본 생성자를 자동으로 먼저 호출합니다.

만약 부모 클래스에 기본 생성자가 없거나, 특정 생성자를 직접 호출하고 싶다면 super() 생성자를 사용해야 합니다.

이 때, super()생성자는 자식 생성자 코드의 가장 첫번째 문장에 위치해야 합니다.

컴파일 첫 단계에서 부모의 인스턴스 공간이 먼저 만들어져야 하기 때문입니다.

class ParentBook {
    String title;

    // 1. 부모 클래스에 매개변수가 있는 생성자를 직접 정의했습니다.
    // 이 경우 자바 컴파일러는 '기본 생성자'를 자동으로 만들어주지 않습니다!
    ParentBook(String title) {
        this.title = title;
    }
}

class ComicBook extends ParentBook {
    boolean isAdult;

    ComicBook(String title, boolean isAdult) {
        // 2. 부모 클래스에 기본 생성자가 없기 때문에, 
        // 자식 클래스에서는 자동으로 super()를 호출할 수 없어 에러가 발생합니다.
        // 따라서 개발자가 직접 매개변수가 있는 부모 생성자를 호출해 주어야 합니다.
        super(title); // 반드시 첫 줄에 위치해야 합니다!
        
        this.isAdult = isAdult;
    }
}

즉 위 코드 처럼 부모에게 기본생성자가 없으면 자식 생성자에서 반드시 super 생성자를 통해 직접 부모 생성자를 지정하여 호출해야 컴파일 에러가 나지 않습니다.

단, 부모에게 기본 생성자가 있으면 자식 생성자에서 super()를 생략해도 컴파일러가 자동으로 호출해 주기 때문에, 필요하지 않다면 따로 안적어도 됩니다.

// 부모 클래스
class ParentBook {
    String title;

    // 부모의 기본 생성자 (매개변수가 없음)
    ParentBook() {
        System.out.println("1. 부모(ParentBook)의 기본 생성자 호출 완료!");
        this.title = "미정"; // 기본값 설정
    }
}

// 자식 클래스
class ComicBook extends ParentBook {
    boolean isAdult;

    // 자식의 생성자
    ComicBook(boolean isAdult) {
        // 겉보기에는 아무것도 없어 보이지만, 
        // 자바 컴파일러가 이 자리에 super(); 를 자동으로 추가하여 호출합니다!
        // super(); //   눈에 안 보이지만 자동으로 작동 중!
        
        System.out.println("2. 자식(ComicBook)의 생성자 호출 완료!");
        this.isAdult = isAdult;
    }
}

4. super 키워드

super 생성자가 부모의 생성자를 호출하는 거라면, super 키워드는 부모 클래스의 속성(변수)이나 기능(메서드)에 접근할 때 사용합니다.

특히 자식 클래스와 부모 클래스의 변수 이름이 같아서 구분이 필요할 때 유용합니다.

class Book4 {
    int price; // 부모의 책 가격
}

class EBooks extends Book4 {
    int price; // 자식에서 똑같은 이름으로 변수를 선언 (변수 오버라이딩)

    void setPrice(int price) {
        this.price = price;             // 현재 자식 인스턴스의 price에 저장
        super.price = price + 10000;    // 부모 인스턴스의 price에 저장
    }

    void printPrices() {
        System.out.println("자식 EBook 가격: " + this.price);
        System.out.println("부모 Book 가격: " + super.price);
    }
}

this.price : 현재 자식 클래스의 인스턴스 변수
super.price : 부모 클래스의 인스턴스 변수

5. 메서드 오버라이딩 (Method Overriding)

부모 클래스로부터 물려받은 메서드의 내용을 자식 클래스에 맞게 변형하여 재정의하는 것을 오버라이딩이라고 합니다.

즉, 부모가 물려준 기능이 자식 클래스에서 더 구체적인 행동을 해야 할 때 코드를 덮어쓰는 것입니다.

오버라이딩 규칙은 다음가 같습니다.

부모 메서드와 이름, 매개변수, 반환타입이 완전히 같아야 한다.
메서드 위에 @Override 어노테이션을 붙여준다. (생략 가능하지만, 컴파일러가 문법 오류를 체크해 주기 때문에 작성해주는 것이 좋음)

class Book5 {
    String title;

    void displayInfo() {
        System.out.println("책 제목: " + title);
    }
}

class ComicBook5 extends Book5 {
    boolean isAdult;

    // 부모의 displayInfo() 메서드를 만화책에 맞게 덮어씁니다!
    @Override
    void displayInfo() {
        System.out.println("[만화책] 제목: " + title + " (성인인증 여부: " + isAdult + ")");
    }
}

public class OverridingMain {
    public static void main(String[] args) {
        ComicBook5 myComic = new ComicBook5();
        myComic.title = "원피스";
        myComic.isAdult = false;

        // 오버라이딩되었기 때문에 부모의 메서드가 아닌 자식의 메서드가 호출됩니다.
        myComic.displayInfo(); 
    }
}

6. 다형성

다형성이란 "부모 타입의 참조 변수로 자식 타입의 객체를 다룰 수 있는 성질"을 말하며, 자세한 설명은 아래 코드에서 주석으로 작성하였습니다.

class RealBook {
    String title;

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

    void display() {
        System.out.print("북 타이틀: " + title);
    }
}

class ITBook extends RealBook {
    ITBook(String title) {
        super(title);
    }

    @Override
    void display() {
        // super를 활용해 부모의 원래 기능을 먼저 작동시키고
        super.display(); 
        // 자식만의 고유 기능을 덧붙입니다.
        System.out.println(" -> [카테고리: 컴퓨터/IT 프로그래밍 서적]"); 
    }
}

public class PolymorphismMain {
    public static void main(String[] args) {
        // 다형성: 부모 타입(RealBook) 변수에 자식 객체(ITBook)를 대입!
        RealBook myBook = new ITBook("자바의 정석");
        
        // [규칙 1] 자식 고유의 멤버에는 직접 접근할 수 없습니다. (컴파일 에러)
        // 컴퓨터는 컴파일 단계에서 변수 타입인 'RealBook'만 검사하기 때문에 language의 존재를 모릅니다.
        // myBook.language = "Python"; 
        
        // [규칙 2] 오버라이딩된 메서드는 '실제 객체(자식)'의 것이 최우선으로 실행됩니다!
        // 프로그램이 실행되는 런타임 단계에서는 메모리에 실제로 생성된 ITBook 인스턴스를 찾아가기 때문에,
        // ITBook에서 재정의된 display()가 작동합니다.
        myBook.display(); 
        
        // 실행 결과
        // 북 타이틀: 자바의 정석 -> [카테고리: 컴퓨터/IT 프로그래밍 서적]
    }
}

[Java] 프로그래머스 코딩테스트 연습 : 배열과 리스트

지그농 — Tue, 12 May 2026 01:11:37 +0900

프로그래머스 연습 문제 두 가지를 통해 자바의 자료구조인 배열과 리스트로 접근하여 학습해 보았습니다.

문제는 아래와 같습니다.

코딩테스트 연습 - 나누어 떨어지는 숫자 배열

알고리즘 문제 연습 카카오톡 친구해요! 프로그래머스 교육 카카오 채널을 만들었어요. 여기를 눌러, 친구 추가를 해주세요. 신규 교육 과정 소식은 물론 다양한 이벤트 소식을 가장 먼저 알려

school.programmers.co.kr

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

1. 제일 작은 수 제거하기

이 문제는 데이터의 '삭제'가 발생할 때, 크기가 고정된 배열과 크기가 변하는 리스트가 각각 어떻게 대응하는지를 보여줍니다.

배열 접근 (Solution 1)

배열은 생성 시 크기가 고정되는 정적 자료구조입니다.
따라서 요소 삭제는 “제거”가 아니라 새 배열을 만들어 재구성하는 방식으로 처리됩니다.

public int[] solution1(int[] arr) {
        // 배열의 길이가 1인 경우 처리
        if (arr.length <= 1) return new int[]{-1};

        // 최솟값 찾기
        int min = arr[0];
        for (int n : arr){
            if (n < min) min = n ;
        }

        // 최솟값을 제외한 크기의 새 배열 생성
        int[] answer = new int[arr.length - 1];
        int index = 0;
        for (int m : arr){
            // 최솟값인 경우 건너뛰기
            if (min == m) continue;

            answer[index++] = m;
        }

        return answer;
    }

참고 메서드 및 개념

직접 순회: for-each 문과 index 변수를 활용해 데이터를 수동으로 저장
배열의 불변성: arr 자체에서 요소를 제거할 수 없으므로 new 키워드를 통해 크기 만큼 생성

리스트 접근 (Solution 2)

ArrayList는 내부적으로 크기가 자동 조절되는 동적 자료구조입니다.
따라서 삭제 연산을 메서드 기반으로 간단하게 처리할 수 있습니다.

public int[] solution2(int[] arr) {
        // 1. 조건 처리: 빈 배열이 되거나 요소가 하나면 [-1] 반환
        if (arr.length <= 1) return new int[]{-1};

        // 2. int 배열을 ArrayList로 변환
        ArrayList<Integer> list = new ArrayList<>();
        for (int x : arr) list.add(x);

        // 3. Collections.min() 활용한 최솟값 찾기
        int min = Collections.min(list);

        // 4. 리스트에서 최솟값 삭제
        // 인덱스 접근이 아니기 때문에 객체 변환
        list.remove(Integer.valueOf(min));

        // 5. 다시 int[] 배열로 변환하여 반환
        int[] answer = new int[list.size()];
        for (int i =0 ; i < list.size(); i++){
            answer[i] = list.get(i);
        }
        return answer;
    }

참고 메서드 및 개념

Collections.min(list): 리스트 내의 최솟값을 한 줄로 찾아줍니다.
list.remove(Object) vs list.remove(int):
- list.remove(10)이라고 작성하면 10번째 인덱스에 있는 요소를 삭제하라는 의미가 됩니다.
- 우리는 '10'이라는 값을 삭제하고 싶은 것이므로, Integer.valueOf(10)을 통해 기본형을 객체(Wrapper Object)로 감싸서 전달해야 합니다.
  - 값 객체화(Boxing): int와 같은 기본 타입을 Integer라는 객체 타입으로 변환하는 과정입니다. 리스트의 remove 메서드는 매개변수가 객체일 때만 인덱스가 아닌 '값'으로 찾아 삭제를 수행합니다.

2. 나누어 떨어지는 숫자 배열

이 문제는 조건에 맞는 데이터를 '필터링'하고 '정렬'하는 과정에서의 차이를 보여줍니다.

배열 접근 (Solution 1)

배열은 크기를 미리 알아야 생성할 수 있기 때문에
“조건에 맞는 데이터 개수 계산 → 배열 생성 → 채우기”의 2단계 구조가 필요합니다.

class Solution1 {
        public int[] solution(int[] arr, int divisor) {
            // 1. 나누어지는 숫자 카운트 초기화
            int count = 0 ;

            for (int x : arr){
                if (x % divisor == 0) count++;
            }

            // 2. 카운트가 0일 경우 [-1] 반환
            if (count == 0) return new int[]{-1};

            // 3. 카운트만큼 배열 초기화 후 추가
            int[] answer = new int[count];
            int index = 0 ;
            for (int x : arr) {
                if (x % divisor == 0) answer[index++] = x;
            }

            // 4. 배열 정렬
            Arrays.sort(answer);
            return answer;
        }
    }

참고 메서드 및 개념

Arrays.sort(): 기본 배열(Array)을 오름차순으로 정렬할 때 사용하는 java.util.Arrays 클래스의 핵심 메서드입니다.

리스트 접근 (Solution 2)

리스트는 조건을 만족하는 데이터를 바로 추가할 수 있어 구조가 단순합니다.

대신, 배열을 반환하는 것을 요구하는 문제이기 때문에 리스트 → 배열 변환 과정이 필요합니다.

public int[] solution(int[] arr, int divisor) {
            // 1. ArrayList 생성
            ArrayList<Integer> list = new ArrayList<>();
            // 2. 배열 순회하며 나누어 떨어지는 경우 list 추가
            for (int x : arr){
                if (x % divisor == 0) list.add(x);
            }
            // 3.리스트 크기 확인
            int n = list.size();

            // 4.만약 하나도 없다면 -1 반환
            if (n == 0) return new int[]{-1};

            // 5.list 오름차순 정렬
            Collections.sort(list);

            // 6. answer 크기 만큼 생성 후 반환
            int[] answer = new int[n];
            for (int i = 0 ; i < n ; i++){
                answer[i] = list.get(i);
            }
            return answer;
        }
    }

참고 메서드 및 개념

Collections.sort(): ArrayList와 같은 컬렉션 인터페이스를 구현한 자료구조를 정렬할 때 사용합니다.

3. 리뷰

이번 문제는 알고리즘의 복잡한 효율성을 따지기보다, 자바의 가장 기본이 되는 자료구조를 어떻게 선택하고 다룰 것인지 고민해 볼 수 있는 시간이었습니다.

배열을 다룰 때의 Arrays.sort(), 리스트에서의 Collections.sort()나 Collections.min() 등 상황에 맞는 필수 메서드들을 직접 활용하며 익힐 수 있었습니다.
크기가 고정된 배열과 동적으로 변하는 리스트의 차이를 체감했습니다. 특히 리스트에서 요소를 삭제할 때 인덱스가 아닌 값 객체(Object)로 변환하여 접근해야 하는 디테일을 배운 것이 큰 수확이었습니다.
스스로 어떤 메서드가 더 적합할지 생각하며 풀이한 덕분에 자바 알고리즘 공부를 위한 기본기를 탄탄히 다진 기분입니다. 단순한 정답 맞추기를 넘어 언어의 특성을 이해하는 과정이었습니다.

* 참고 링크 (Github)

GitHub - jung-jinyoung/java-algo-study: Language : Java

Language : Java. Contribute to jung-jinyoung/java-algo-study development by creating an account on GitHub.

github.com

[Java] 알고리즘 기초 : 배열과 리스트, 언제 무엇을 쓸까?

지그농 — Mon, 11 May 2026 23:58:32 +0900

배열은 크기가 고정되고 접근이 빠르며, 리스트는 크기 변경과 삽입/삭제가 용이하다.

코딩 테스트에서 배열과 리스트 중 무엇을 선택해야 할까?

이미지 생성 : 릴리스 AI

코딩 테스트에서 배열과 리스트는 가장 흔하게 사용되는 자료 구조이며, 문제 유형에 따라 적절히 선택하는 것이 중요하다.

1. 배열(Array): 정해진 크기와 빠른 접근

배열은 메모리의 연속적인 공간에 데이터가 일렬로 배치되는 자료구조입니다. 한 번 생성하면 그 크기를 변경할 수 없는 '정적(Static)'인 특징을 가진다.

// 배열 선언 방식의 예
int[] arr = new int[5]; // 크기가 5인 배열 선언

주요 특징

빠른 접근 : 인덱스(Index)를 통해 데이터의 위치에 즉시 접근할 수 있습니다. (O(1))
- 예를 들어, arr 배열에서 값 4에 접근하려면 인덱스 3을 사용하여 arr[3]으로 표현한다.
고정된 크기 : 선언 시점에 크기를 정해야하며, 실행 도중 크기를 늘리거나 줄일 수 없다.
비효율적인 삽입/삭제: 중간에 값을 추가하거나 삭제하려면, 나머지 요소들의 위치를 모두 이동시켜야 하므로 비효율적이다 (O(n))
- 예를 들어, 배열의 두 번째 자리에 있는 값을 삭제하려면 뒤에 있는 값들을 앞으로 한 칸씩 당겨야 한다.
- 값을 삽입할 때도 기존 데이터를 뒤로 밀어 공간을 확보해야 한다
구조가 간단하여 코딩 테스트에서 가장 많이 사용된다.

Java 배열 선언 및 사용 코드

// 1. 크기를 지정하여 선언 (기본값 0으로 초기화됨)
int[] arr1 = new int[5];

// 2. 선언과 동시에 데이터 초기화 (크기는 자동으로 5가 됨)
int[] arr2 = {10, 20, 30, 40, 50};

// 3. 데이터 접근 및 수정
arr1[0] = 100;            // 0번 인덱스에 100 할당
int firstItem = arr2[0];  // 0번 인덱스의 값(10) 읽기

// 주의: 배열의 길이를 초과하는 인덱스에 접근하면 에러(ArrayIndexOutOfBoundsException) 발생
// arr1[5] = 60; // Error

2. 리스트(List): 유연한 크기와 편리한 편집

리스트는 값과 포인터를 묶은 노드를 포인터로 연결한 자료 구조이다. 각 노드는 자신의 값(데이터)과 다음 노드를 가리키는 포인터로 구성된다.

** 참고

자바에서는 List 인터페이스를 구현한 ArrayList를 가장 널리 사용한다.

ArrayList는 내부적으로 배열을 사용하지만, 공간이 꽉 차면 자동으로 더 큰 배열을 만들어 데이터를 복사하는 방식으로 가변적인 크기를 지원한다.

주요 특징

빠른 삽입 및 삭제: 중간에 데이터를 추가하거나 삭제할 때, 물리적인 데이터를 이동시킬 필요 없이 해당 위치 앞뒤 노드의 포인터(연결 고리)만 새로운 방향으로 바꿔주면 된다.(O(1))
느린 조회 속도: 데이터가 메모리상에 흩어져 있고 포인터로만 연결되어 있기 때문에, 인덱스를 통한 직접 접근이 불가능하다.
- 특정 위치의 데이터를 찾으려면 항상 리스트의 처음(Head)부터 포인터를 따라 순차적으로 탐색해야 한다.(O(n))
가변적인 크기: 데이터가 추가될 때마다 메모리를 동적으로 할당하여 연결하므로, 선언 시점에 전체 크기를 미리 알 필요가 없다.
- 선언 시 크기를 별도로 지정하지 않아도 되며, 크기가 변하기 쉬운 데이터를 다룰 때 적절하다.
실제 코딩 테스트에서는 ArrayList나 LinkedList와 같이 기본적으로 제공되는 리스트를 주로 사용한다.
- 이러한 구현체들은 삽입, 삭제, 접근 등의 기능이 내부적으로 구현되어 있다.
- 리스트의 내부 동작 방식을 깊이 이해해야 하는 경우는 매우 어렵고 난이도가 높은 문제에 한정된다.

Java 리스트 선언 및 사용 코드

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

// 1. 크기 지정 없이 동적 선언
List<Integer> arrayList = new ArrayList<>();

// 2. 데이터 추가 (끝에 추가) - 평균적으로 빠름
arrayList.add(10);
arrayList.add(20);

// 3. 특정 위치 삽입 및 삭제 - O(n) (데이터 이동 발생)
arrayList.add(1, 15); // 1번 위치에 15 삽입 (뒤로 한 칸씩 밀림)
arrayList.remove(0);  // 0번 위치 삭제 (앞으로 한 칸씩 당겨짐)

// 4. 데이터 조회 - O(1) 인덱스 기반의 빠른 접근
int target = arrayList.get(1);

3. 비교 요약과 선택 기준

연산	배열 (Array)	ArrayList (배열 기반 리스트)	LinkedList (연결 리스트)
조회 (Access)	O(1)	O(1)	O(n)
수정 (Update)	O(1)	O(1)	O(n)
삽입 (Insert)	O(n)	O(n)	O(1)
삭제 (Delete)	O(n)	O(n)	O(1)
크기 할당	고정 (Static)	동적 (Dynamic)	동적 (Dynamic)

배열은 다음과 같은 경우에 사용하는 것이 유리하다.

데이터의 크기가 늘어나거나 줄어들지 않고 고정되어 있을 때 사용한다.
데이터에 접근하는 경우가 많을 때 사용한다.

리스트(ArrayList, LinkedList 등)는 다음과 같은 경우에 사용하는 것이 좋다.

크기가 변하는 데이터를 다룰 때 사용한다.
데이터의 삽입 및 삭제가 빈번하게 일어날 때 사용한다.

4. 마치며

최근 자바 언어를 새롭게 학습하기 시작했다.

그런데 본격적인 문법을 채 익히기도 전에 이틀 뒤, 급하게 코딩 테스트를 자바로 응시해야 하는 상황이 있었다.

기존에는 파이썬을 주력으로 알고리즘 스터디를 진행해 왔던 터라, 그동안 쌓아왔던 경험들을 바탕으로 문제에 접근했다.

하지만 결과는 처참했다. 로직의 문제가 아니라, 자바에서 '배열'과 '리스트'를 다루는 방법에 대한 이해 부족이 발목을 잡았다. 파이썬의 유연한 자료구조에만 익숙해져 있다 보니, 자바의 엄격한 타입과 메모리 구조 앞에서는 코드를 시작조차 하기 어려웠다.

이번 실패를 교훈 삼아 자바의 배열과 리스트를 다시 공부해보니, 데이터의 성격에 따라 어떤 자료구조를 선택해야 하는지 그 기준을 명확히 이해할 수 있었다.

앞으로는 파이썬으로 이미 풀어보았던 익숙한 알고리즘 문제들을 자바로 다시 구현해 볼 계획이다.

이러한 훈련을 반복하다 보면, 문제의 요구사항을 읽자마자 적절한 배열과 리스트를 떠올리는 감각이 자연스럽게 쌓이고 한 단계 더 성장할 수 있을 것이라 생각한다.

(참고 링크 - Github)

https://github.com/jung-jinyoung/java-algo-study

GitHub - jung-jinyoung/java-algo-study: Language : Java

Language : Java. Contribute to jung-jinyoung/java-algo-study development by creating an account on GitHub.

github.com

[Java] 메서드 파라미터 전달 방식 : Call by Value - 값과 주소값 전달 차이

지그농 — Mon, 11 May 2026 22:52:12 +0900

자바에서 메서드에 변수를 전달할 때, 원본 값이 변하는 경우와 변하지 않는 경우가 있습니다.

헷갈리기 쉬운 이 두가지 현상을 기본형과 참조형 변수의 차이로 정리해 보았습니다.

1. 자바는 오직 'Call by Value'

자바에는 C++과 같은 진정한 의미의 'Call by Reference(참조에 의한 호출)'가 없습니다.

항상 값을 복사해서 전달(Call by Value)하지만, 변수 타입에 따라 복사되는 대상이 다릅니다.

기본형 (Primitive Type): 실제 데이터 값을 복사하여 전달. (원본에 영향 없음)
참조형 (Reference Type): 클래스, 배열 등은 객체가 위치한 메모리의 주소값(Address)을 복사하여 전달합니다. (주소를 통해 원본 객체 수정 가능)

즉, 어떤 타입의 파라미터로 메서드를 호출하느냐에 따라 "원본 데이터가 수정되는가?"라는 결과를 결정짓는 핵심 원인이 됩니다.

2. 코드 비교

동일한 기능의 메서드를 오버로딩하여, 기본형과 참조형을 전달했을 때의 결과를 비교해 보았습니다.

class NumberBox {
    int value;
    public NumberBox(int value) { this.value = value; }
}

public class CallByTest {
    public static void main(String[] args) {
        int primitiveNum = 10;
        NumberBox refBox = new NumberBox(10);
        
        changeValue(primitiveNum); // 기본형 전달: 값(10) 복사
        changeValue(refBox);       // 참조형 전달: 주소값 복사
        
        System.out.println("기본형 변수: " + primitiveNum);     // 10 (변경 안 됨)
        System.out.println("참조형 객체 값: " + refBox.value);  // 999 (원본 변경됨)
    }

    // 기본형 파라미터
    static void changeValue(int num) {
        num = 999; 
    }

    // 참조형 파라미터
    static void changeValue(NumberBox box) {
        box.value = 999; 
    }
}

참조형 변수를 넘길 때는 '주소값'이 복사되어 전달되기 때문에 메서드 내부에서 원본 객체의 상태를 변경할 수 있습니다.

객체를 넘겼다가 원본 데이터가 훼손되는 부작용이 발생할 수 있으므로, 이 점을 인지하고 코드를 작성해야 합니다.

3. 참고 링크

코드 시각화 도구: Java Visualizer

작성한 코드가 메모리에서 어떻게 움직이는지 단계별로 확인할 수 있어 추천합니다.

2번 예시 코드를 실행한 화면

[Java] 기본 문법 정리 : final, 오버로딩, 생성자, 가변인자 정리

지그농 — Mon, 11 May 2026 00:01:00 +0900

자바 기초 문법 중 실무와 협업 환경에서 코드의 안정성과 재사용성을 높이는 데 필수적인

5가지 핵심 개념(상수, 오버로딩, 생성자, this 생성자, 가변인자)을 정리했습니다.

1. 상수 (final)

final 키워드는 변수를 선언할 때 할당된 값을 더 이상 변경할 수 없도록 고정합니다.

왜 사용하는가?

협업 시 절대 변경되어서는 안 되는 설정값이나 기준값을 정의할 때 사용합니다.

누군가 값을 수정하려고 시도하면 컴파일 단계에서 에러가 발생하므로, 런타임 이전에 코드의 훼손을 방지할 수 있습니다.

예시 코드

도서 관리 시스템에서 도서의 '최대 대여 가능 일수'는 모든 책에 동일하게 적용되며, 로직 내에서 임의로 변경되어서는 안 됩니다.

public class Book {
    // 1. final을 활용한 상수 선언
    // 네이밍 관례에 따라 대문자와 언더스코어(_)를 사용하여 명확히 구분합니다.
    public static final int MAX_BORROW_DAYS = 14;

    public void tryToChangePolicy() {
        // 2. 상수에 새로운 값을 할당하려는 시도
        // MAX_BORROW_DAYS = 21; 
        
        // 컴파일 에러 발생: Cannot assign a value to final variable 'MAX_BORROW_DAYS'
    }
}

비즈니스 로직상 절대 변하면 안 되는 설정값(예: 타임아웃, 최대 접속 횟수 등)을 정의할 때 사용합니다.

런타임 환경에서 발생할 수 있는 데이터 오염을 코드 작성 단계(컴파일 타임)에서 완벽하게 차단할 수 있습니다.

2. 메서드 오버로딩 (Method Overloading)

동일한 클래스 내에서 메서드 이름이 같더라도 파라미터의 개수나 타입이 다르면 자바 컴파일러는 이를 서로 다른 메서드로 인식합니다.

예시 코드

하나의 목적(예: 정보 설정)을 가진 메서드들을 같은 이름으로 묶어냅니다.

public class Product {
    public void setInfo() { ... } // 파라미터 없음
    public void setInfo(String title) { ... } // 파라미터 1개 (String)
    public void setInfo(int price) { ... } // 파라미터 1개, 타입 다름 (int)
    public void setInfo(String title, int price) { ... } // 파라미터 2개
}

메서드 호출자는 파라미터의 조합이 달라도 setInfo라는 하나의 일관된 메서드 이름만 기억하면 됩니다.

이는 API 설계 시 사용자 편의성을 높이고 인터페이스의 일관성을 유지하는 데 크게 기여합니다.

3. 생성자 (Contstructor)

생성자는 객체(인스턴스)가 메모리에 생성되는 순간 최초로 단 한 번만 호출되는 특수한 메서드입니다.

일반 메서드와 달리 임의로 계속 호출할 수 없습니다.

클래스 내에 생성자가 하나도 없다면, 컴파일러가 내용이 없는 '기본 생성자'를 자동으로 만들어줍니다.

단, 생성자 역시 오버로딩이 가능하기 때문에 파라미터가 있는 생성자를 하나라도 명시적으로 정의했다면,

컴파일러는 더 이상 기본 생성자를 자동으로 제공하지 않습니다.

예시 코드

public class User {
    private String name;

    // 파라미터가 있는 생성자를 명시적으로 정의
    public User(String name) { 
        this.name = name; 
    }
}

public class Main {
    public static void main(String[] args) {
        // 컴파일 에러 발생: Expected 1 arguments but found 0
        // 컴파일러가 기본 생성자를 지워버렸기 때문에 에러가 발생합니다.
        // User user1 = new User(); 

        // 정상적인 객체 생성
        User user2 = new User("홍길동");
    }
}

객체가 생성될 때 반드시 필요한 필수 값(위 예제에서는 name)을 강제로 주입받도록 설계하여,

속성값이 비어있는 불완전한 상태의 객체가 생성되는 것을 구조적으로 방지합니다.

만약 프레임워크나 라이브러리 사용 등의 이유로 파라미터가 없는 기본 생성자도 함께 필요하다면,

public User() {} 형태로 반드시 직접 명시해 주어야 합니다.

4. this() 생성자

this() 키워드는 클래스 내부의 한 생성자에서 자신의 또 다른 생성자를 호출할 때 사용합니다.

파라미터의 개수와 타입에 일치하는 다른 생성자를 찾아 실행합니다.

예시 코드

public class BookData {
    private String title;
    private int price;

    public BookData(String title) {
        // 제목만 입력받을 경우, 가격을 기본값 10000원으로 고정하여 아래 생성자 호출
        this(title, 10000); 
    }

    public BookData(String title, int price) {
        this.title = title;
        this.price = price;
    }
}

여러 생성자에서 공통으로 처리해야 하는 초기화 로직을 하나의 생성자에 몰아두고 this()로 호출합니다.

이는 코드의 중복을 제거하고, 추후 로직 변경 시 수정 포인트를 하나로 줄여 유지보수성을 극대화합니다.

5. 가변인자

'타입... 변수명' 형태로 선언하며, 파라미터로 전달받는 인자의 개수가 몇 개이든 동적으로 모두 수용할 수 있는 문법입니다.

내부적으로는 배열 형태로 안전하게 처리됩니다.

예시 코드

public class Logger {
    public void printLogs(String... messages) {
        for (String msg : messages) {
            System.out.println(msg);
        }
    }

    public void run() {
        printLogs("Error Code: 404"); // 1개 전달
        printLogs("Start", "Loading", "Done"); // 개수 제한 없이 쉼표로 나열하여 전달
    }
}

호출 시 전달할 데이터의 개수가 유동적일 때, 번거롭게 배열을 따로 생성해서 넘길 필요 없이

쉼표(,)를 통해 직접 값들을 나열할 수 있어 유연하고 깔끔한 API를 설계할 수 있습니다.

[Java] 객체지향 기초: this와 static (클래스 변수와 클래스 메서드)

지그농 — Wed, 6 May 2026 14:00:56 +0900

지난 글에서는 클래스와 객체의 생성에 대해 알아봤습니다.

[Java] 객체지향 기초 - 클래스와 메서드

객체지향 프로그래밍(OOP)은 현대 소프트웨어 개발의 표준입니다.오늘은 자바에서 객체지향을 구성하는 2가지 핵심 요소를 한 페이지에 정리해 보려 합니다.1. 클래스2. 메서드1.클래스(Class)객체(

jignonne.tistory.com

이어서 객체 내부에서 자기 자신을 가리키는 this의 역할과, 모든 객체가 공유하는 static(클래스 변수/메서드)의 차이점을 학습하여 정리해 보았습니다.

1. 메서드와 this

this 키워드가 필요한 이유

메서드를 작성하다 보면 매개변수(파라미터)와 인스턴스 변수의 이름이 동일한 경우가 발생할 수 있습니다.

이 경우 자바는 기본적으로 가장 가까운 범위의 변수(지역 변수, 매개변수) 를 우선적으로 사용합니다.

class Book {
    int price; // 인스턴스 변수

    void setPrice(int price) { // 매개변수
        // 여기서 price는 둘 다 매개변수를 가리키게 되어 
        // 실제 객체의 price 필드값은 변하지 않는 논리 오류가 발생합니다.
        
        Sytem.out.println(price); // 매개변수 price가 출력됨
        return;
    }
}

따라서 별도의 구분 없이 사용할 경우, 개발자가 의도한 인스턴스 변수가 아닌 매개변수 값이 사용되는 문제가 발생할 수 있습니다.

이러한 문제를 해결하기 위해 사용되는 키워드가 this 입니다.

this 키워드의 역할

this는 현재 인스턴스(자기 자신)의 메모리 주소를 가리키는 참조 변수입니다.

즉, this를 사용함으로써 현재 객체의 변수에 접근하고 있다는 것을 명확하게 표현할 수 있습니다.

this.price라고 쓰면 "이 객체가 가진 price 필드"라는 의미가 되어 외부에서 들어온 매개변수와 명확히 구분됩니다.

void printPrice(int price) {
    System.out.println(price);        // 매개변수
    System.out.println(this.price);   // 인스턴스 변수
}

이처럼 동일한 이름의 변수가 존재할 경우, this를 통해 두 변수를 명확하게 구분할 수 있습니다.

뿐만 아니라 해당 객체의 변수값을 수정하는 메서드에서도 this는 활용될 수 있습니다.

class Book {
    String title;
// 책 이름 수정 메서드
    void setTitle(String title) {
        this.title = title;
    }
}

이 메서드는 다음과 같은 흐름으로 동작합니다:

외부에서 전달받은 title 값을
현재 객체의 title 변수에 저장

이처럼 this는 객체 자신의 상태를 변경할 때 필수적으로 사용되는 키워드입니다.

2. static : 클래스 변수와 클래스 메서드

클래스 변수란 무엇인가?

클래스 변수는 static 키워드를 사용하여 선언된 변수로,

객체마다 개별적으로 존재하는 것이 아니라 모든 객체가 공유하는 클래스에 속하는 변수를 말합니다.

class Book {
    static float tax;
}

위와 같이 인스턴스 변수 앞에 static을 붙이면, 해당 변수는 특정 객체가 아닌 클래스 자체에 속하는 변수가 됩니다.

따라서 클래스 변수는 인스턴스 생성과 관계없이 클래스 이름을 통해 직접 접근할 수 있습니다.

// Book 객체 생성 전 접근 가능 

Book.tax = 1.2f;

클래스 변수가 필요한 이유

객체를 여러 개 생성할 때, 모든 객체에 동일하게 적용되어야 하는 값이 존재할 수 있습니다.

이러한 값을 인스턴스 변수로 관리할 경우,

객체마다 따로 값을 설정해야 하는 불편함이 발생합니다.

반면 클래스 변수를 사용하면 하나의 값을 모든 객체가 공유하기 때문에,

한 번의 설정으로 전체 객체에 동일한 값을 적용할 수 있습니다.

class Book {
    int price;
    static float tax;

    float taxPrice() {
        return this.price * tax;
    }
}

Book.tax = 1.2f; // 인스턴스 생성 전 설정

Book b1 = new Book();
b1.price = 10000;

System.out.println(b1.taxPrice()); // 12000

위 예시에서 tax는 클래스 변수이기 때문에
객체 생성 이전에 값을 설정할 수 있으며, 이후 생성된 모든 객체에서 동일하게 사용됩니다.

따라서 b1은 별도로 세율을 설정하지 않아도 공통으로 정의된 tax 값을 활용하여 계산할 수 있습니다.

이러한 구조는 공통 값을 한 곳에서 관리할 수 있기 때문에
유지보수 측면에서도 효율적인 장점을 가집니다.

어떻게 생성 전에 접근할 수 있는가?

클래스 변수는 인스턴스 변수와 메모리 동작 방식이 다릅니다.

인스턴스 변수 : 객체 생성 시 생성되어 Heap 영역에 저장
클래스 변수 : 프로그램 실행 시 생성되어 Data 영역에 저장

인스턴스 변수는 객체 생성시 Heap 영역에 저장됩니다.

이와 반대로 클래스 변수는 프로그램 실행시 생성되어 Data 영역에 저장됩니다.

즉, 클래스 변수는 객체가 만들어지기 전에 이미 메모리에 올라가 있기 때문에

인스턴스 생성 이전에 값에 접근할 수 있게 됩니다.

클래스 메서드란 무엇인가?

클래스 메서드는 클래스 변수와 마찬가지로

메서드 앞에 static 키워드를 붙여 선언한 메서드로, 객체가 아닌 클래스에 속하는 메서드입니다.

class Book {
    static int generateBookNo() {
        return (int)(Math.random() * 10);
    }
}

클래스 메서드도 마찬가지로 인스턴스를 생성하지 않아도

클래스 이름을 통해 바로 호출할 수 있습니다.

int number = Book.generateBookNo();

즉, 클래스 메서드는 객체 상태와 관계없이 동작하는 기능을 정의할 때 사용됩니다.

클래스 메서드 사용시 제한 사항

클래스 메서드 내부에서는 인스턴스 변수와 인스턴스 메서드를 직접 사용할 수 없습니다.

이러한 제한은 메서드의 생성 시점과 관련이 있습니다.

클래스 메서드 → 프로그램 실행 시 Data 영역에 생성
인스턴스 변수 → 객체 생성 이후 Heap 영역에 생성

따라서 클래스 메서드가 실행되는 시점에는 참조할 인스턴스가 존재하지 않을 수 있기 때문에,
인스턴스에 속한 값이나 기능에 접근할 수 없습니다.

3. 참고 링크

Java this Keyword - GeeksforGeeks

Your All-in-One Learning Portal: GeeksforGeeks is a comprehensive educational platform that empowers learners across domains-spanning computer science and programming, school education, upskilling, commerce, software tools, competitive exams, and more.

www.geeksforgeeks.org

Understanding Class Members (The Java™ Tutorials > Learning the Java Language > Classes and Objects)

The Java Tutorials have been written for JDK 8. Examples and practices described in this page don't take advantage of improvements introduced in later releases and might use technology no longer available. See Dev.java for updated tutorials taking advantag

docs.oracle.com

[지금 무료]비전공자를 위한 자바| 이신만 - 인프런 강의

현재 평점 4.9점 수강생 944명인 강의를 만나보세요. 비전공자, 초보 개발자들이 자바 문법을 쉽게 배울 수 있습니다. 예제를 분석하며 문법을 배우는 방식입니다. 자바 문법, 객체지향, 자료구조,

www.inflearn.com

[Java] 객체지향 기초 : 클래스와 메서드

지그농 — Wed, 6 May 2026 13:02:26 +0900

객체지향 프로그래밍(OOP)은 현대 소프트웨어 개발의 표준입니다.

오늘은 자바에서 객체지향을 구성하는 2가지 핵심 요소를 한 페이지에 정리해 보려 합니다.

1. 클래스
2. 메서드

1.클래스(Class)

객체(Object)를 활용하는 이유 : 코드의 '유지 보수성'

프로그래밍에서 가장 중요한 문제 중 하나는 데이터의 일관성과 유지보수입니다.
만약 객체를 사용하지 않고 “책(Book)” 정보를 관리한다면 어떻게 될까요?

예를 들어 다음과 같이 데이터를 분리해서 관리해야 합니다.

// 책을 10권 저장한다고 가정

String[] titleList = new String[10];// 책 제목 저장 리스트
String[] authorList = new String[10]; // 작가 이름 저장 리스트
int[] priceList = new int[10]; // 책 가격 저장 리스트


// 책 데이터 추가
titleList[0] = "자바의 정석";
authorList[0] = "정진영";
priceList[0] = 30000;

겉으로 보기에는 문제가 없어 보이지만, 실제로는 다음과 같은 문제가 발생합니다.

같은 인덱스를 항상 수동으로 맞춰야 함
하나라도 어긋나면 데이터 불일치 발생
데이터가 늘어날수록 구조가 복잡해짐

예를 들어 인덱스 하나라도 밀리면

제목은 A 책인데
가격은 B 책 값이 들어가는 상황이 발생할 수 있습니다

즉, 데이터 간의 “연결 관계”가 보장되지 않습니다.

이처럼 데이터가 파편화되면 유지보수가 불가능해지기 때문에, 이를 해결하기 위해 연관된 데이터를 하나로 묶는 '객체'가 필요합니다.

클래스(Class)란 무엇인가?

클래스는 객체를 생성하기 위한 설계도이며, 동시에 프로그래머가 직접 정의하는 사용자 정의 자료형입니다.

위와 같은 경우 클래스 활용하면 아래와 같이 설계도를 작성할 수 있습니다.

class Book {
// 인스턴스 변수 정의
    String title;
    String author;
    int price;
}

이제 Book은 단순한 구조가 아니라 하나의 새로운 데이터 타입이 됩니다.

중요한 점은 클래스 자체에는 실제 데이터가 존재하지 않는다는 것입니다.
클래스는 “값을 저장하는 공간”이 아니라, 객체가 어떤 구조를 가져야 하는지 정의하는 코드입니다.

객체 생성과 인스턴스

클래스를 기반으로 실제 데이터를 사용하기 위해서는 객체를 생성해야 합니다.

Book book1 = new Book();

이 과정을 인스턴스 생성이라고 합니다.

이 상태에서는 아직 “빈 객체”만 만들어진 상태이며, 각 필드에는 기본값이 들어가 있습니다.

객체를 생성한 이후에는 점(.) 연산자를 통해 해당 객체 내부의 변수(필드)에 접근할 수 있습니다.

Book book1 = new Book();

book1.title = "자바의 정석";
book1.author = "정진영";
book1.price = 30000;

이 경우 book1에는 실제 객체가 아니라 메모리 영역에 생성된 객체를 가리키는 주소값이 저장됩니다.

따라서 book1은 실제값이 아닌 주소값을 참조하는 참조변수라고도 합니다.

클래스 배열의 활용

클래스는 배열 형태로도 사용할 수 있으며, 여러 객체를 하나의 구조로 관리할 수 있습니다.

예를 들어 Book 객체를 여러 개 관리해야 하는 경우, 다음과 같이 객체를 저장할 수 있는 배열을 생성할 수 있습니다.

Book[] arrBooks = new Book[2];

이 코드는 Book 객체를 담을 수 있는 배열 공간 2개를 생성한 것입니다.

arrBooks[0] = book1; // 이전에 생성한 객체 저장

이후 이미 생성된 객체를 배열에 저장할 수도 있습니다.

arrBooks[1] = new Book();
arrBooks[1].title = "클린 코드";

또는 새로운 객체를 직접 생성하여 저장할 수도 있습니다.

여기서 중요한 점은 new Book[2] 자체는 객체를 생성하는 것이 아니라는 점입니다.

이 코드는 실제 Book 객체를 만드는 것이 아니라, Book 객체를 참조할 수 있는 공간(참조 변수 배열) 을 생성하는 것입니다.

따라서 각 배열 요소에는 반드시 다음 중 하나가 필요합니다:

이미 생성된 객체를 저장하거나
new Book()을 통해 새로운 객체를 생성하여 저장해야 함

2. 메서드 (Method)

메서드란 무엇인가?

메서드는 객체가 수행할 수 있는 기능을 독립적인 코드 블록으로 정의한 것입니다.

즉, 단순히 코드를 작성하는 것이 아니라 특정 기능을 하나의 단위로 묶어 필요할 때마다 호출하여 사용할 수 있도록 만든 구조입니다.

메서드를 사용하는 이유는 크게 두 가지로 나눌 수 있습니다.

코드의 재사용성 : 메서드로 한 번 정의해 두면 해당 이름을 호출하는 것만으로 동일한 기능을 사용
유지보수의 효율성 : 메서드 내부의 코드만 수정하면 해당 기능을 사용하는 모든 부분에 즉시 반영

메서드 작성 및 기본 구조

자바의 모든 메서드는 반드시 클래스 내부에 정의되어야 합니다.

기본 구조는 다음과 같습니다.

반환타입 메서드이름(매개변수) {
    실행 코드
}

기본 구조를 활용해서 이전 Book 클래스에 메서드를 작성해본다면, 아래와 같습니다.

class Book {
    String title;
    int price;

    // 1. 정보 출력 메서드
    void printInfo() {
        System.out.println("제목: " + title + " | 가격: " + price);
    }

    // 2. 가격 수정 메서드 : 매개변수 newPrice
    void setPrice(int newPrice) {
        price = newPrice * 1.0;
        System.out.println(title + "의 가격이 수정되었습니다.");
    }

    // 3. 환율 변환 메서드 : 지역변수 활용과 return 구조
    float getDollarPrice() {
        float dollarPrice = (float) price / 1400;
        return dollarPrice;
    }

    // 4. 메서드 간 호출
    void printInfoEng() {
        System.out.print("[ENG INFO] ");
        printInfo();
        System.out.println("Price in USD: $" + getDollarPrice());
    }
}

1. 정보 출력 메서드

void printInfo() {
    System.out.println("제목: " + title + " | 가격: " + price);
}

이 메서드는 객체에 저장된 정보(인스턴스 변수)를 출력하는 역할을 수행합니다.
즉, 객체가 가진 상태를 외부로 보여주는 기능입니다.

2. 값 변경 메서드

void setPrice(int newPrice) {
    price = newPrice * 1.0;
}

이 메서드는 객체 내부의 값을 변경하는 역할을 합니다.

매개변수로 새로운 값을 전달받고
해당 값을 객체의 price 변수에 저장합니다.

※ 여기서는 단순 구조 이해를 위해 this는 사용하지 않고 표현했습니다.

3. 계산 및 반환 메서드

float getDollarPrice() {
    float dollarPrice = (float) price / 1400;
    return dollarPrice;
}

이 메서드는 객체 내부 데이터를 기반으로 계산을 수행하고 그 결과값을 반환하는 역할을 합니다.

이때 dollarPrice는 메서드 내부에서만 사용되는 지역 변수이며, 지역변수의 특징에 따라 아래와 같이 생성-사용-소멸 됩니다.

메서드 실행 시 생성됨
메서드 종료 시 소멸됨
다른 메서드에서는 사용할 수 없음

4. 메서드 간 호출

void printInfoEng() {
    System.out.print("[ENG INFO] ");
    printInfo();
    System.out.println("Price in USD: $" + getDollarPrice());
}

메서드는 독립적으로 동작하는 것뿐만 아니라, 다른 메서드를 호출하여 기능을 조합할 수도 있습니다.

3. 참고 링크

Lesson: Classes and Objects (The Java™ Tutorials > Learning the Java Language)

docs.oracle.com

[지금 무료]비전공자를 위한 자바| 이신만 - 인프런 강의

www.inflearn.com

[Java] 기본 문법 학습 정리

지그농 — Tue, 5 May 2026 14:59:38 +0900

0. 들어가며

그동안 프론트엔드와 데이터 분석을 중심으로 Python을 주로 활용해왔지만, 최근 전산 직무 면접 과정에서 Java 기반 경험의 필요성을 체감하게 되었습니다.

하지만 면접에서 떨어지고

스스로 써보지 않으면 내 것이 되지 않으니 면접 결과가 나오자마자 입문 강의와 관련 IDE를 설치하며, 백엔드 학습을 위한 5월 한달 로드맵도 작성해봤습니다.

해당 글은 이러한 학습 과정의 일환으로, Java의 기본 구조와 동작 방식을 정리한 내용입니다.

정보처리기사와 SQLD 취득 과정에서 쌓은 기초 지식을 바탕으로, 개념을 코드로 연결하는 데 집중했습니다.

1. 기본 세팅

Java 버전

Java 21 (LTS) : 최신 장기 지원 버전, 신규 프로젝트에서 사용하려는 추세
Java 17 (LTS) : 실무, 교육에서 많이 사용되는 안정된 버전

입문 단계에서는 어떤 버전을 사용하더라도 기본 문법은 동일하기 때문에, 큰 영향은 없으나 버전에 대한 업데이트 사항은 알고 있는게 좋을 것 같다.

IDE

코드 작성, 실행, 디버깅을 효율적으로 수행할 수 있도록 도와주는 통합 개발 환경입니다.

대표적으로 Eclipse, IntelliJ IDEA 등이 있으며, 본 글에서는 IntelliJ IDEA를 사용했습니다.

IntelliJ IDEA 다운로드

www.jetbrains.com

IntelliJ IDEA는 Community(무료)와 Ultimate(유료) 에디션으로 구분되며, Java 학습 단계에서는 Community 버전만으로도 충분합니다. (현재 통합 단일 버전으로 다운로드하여 community 기능을 편하게 사용할 수 있습니다.)

특히 이후 Spring Boot 기반 백엔드 학습까지 고려했을 때, 프로젝트 실행 환경 구성과 코드 자동완성, 문법 검사 기능이 잘 갖춰져 있어 학습 효율을 높일 수 있다고 생각해서 선택했습니다.

기본 실행 구조

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

Java 프로그램은 main 메서드에서 실행이 시작됩니다.
즉, 해당 메서드는 프로그램의 진입점(entry point) 역할을 합니다.

현재 단계에서는 “프로그램이 시작되는 위치” 정도로 이해하고,
이후 클래스와 객체지향 개념을 학습하면서 class, static, 메서드 구조에 대해 함께 정리하는 것이 좋습니다.

2. 출력

System.out.print("Hello");      // 줄바꿈 없음
System.out.println("Hello");   // 출력 후 줄바꿈
System.out.printf("나이: %d", 20); // 형식 지정 출력

print : 줄바꿈 없이 출력
println : 출력 후 자동 줄바꿈
printf : 형식을 지정하여 출력

printf는 다양한 데이터 타입을 포맷에 맞게 출력할 때 사용됩니다.

System.out.printf("이름: %s, 나이: %d", "진영", 25);

%d : 정수
%s : 문자열
%f : 실수

단, printf 역시 줄바꿈을 포함하지 않기 때문에 필요 시 \n을 함께 사용해야 합니다.

System.out.printf("나이: %d\n", 20);

3. 변수와 리터럴

int age = 25;
double height = 180.5;
String name = "진영";

변수 : 값을 저장하기 위해 이름을 붙인 공간
리터럴 : 코드에 직접 작성한 값 자체

예를 들어 해당 코드 맨 첫째 줄에서, age는 변수가 되고 25는 정수 리터럴입니다.

리터럴은 타입과 관련하여 다음과 같이 부를 수 있습니다.

10 : 정수 리터럴
180.5 : 실수 리터럴
"진영" : 문자열 리터럴

Java는 변수를 선언할 때 반드시 타입을 지정해야 하며, 이를 통해 저장할 수 있는 값의 종류가 결정됩니다.

(타입에 맞지 않는 값은 저장할 수 없습니다.)

4. 입력 (Scanner)

Scanner는 사용자로부터 입력을 받기 위해 사용하는 클래스입니다.

주로 콘솔 입력 (System.in)을 통해 데이터를 읽어올 때 사용합니다. (입력 테스트 링크)

W3Schools.com

W3Schools offers free online tutorials, references and exercises in all the major languages of the web. Covering popular subjects like HTML, CSS, JavaScript, Python, SQL, Java, and many, many more.

www.w3schools.com

import java.util.Scanner; // Scanner 클래스를 사용하기 위해 반드시 import 필요

Scanner sc = new Scanner(System.in);

int num = sc.nextInt();
String str = sc.next();

nextInt() : 정수 입력
next() : 공백 전까지 문자열 입력
nextLine() : 한줄 전체 입력

next()와 nextLine() 비교

next() : 공백(스페이스, 엔터)을 기준으로 한 단어만 입력
nextLine() : 줄바꿈(엔터)까지 포함하여 한 줄 전체 입력

String a = sc.next();      // 입력: Hello World → "Hello"
String b = sc.nextLine();  // 입력: Hello World → "Hello World"

따라서 입력값을 공백 기준으로 나누어 처리할지, 한 줄 전체를 그대로 받을지에 따라 메서드를 선택해야 합니다.

5. 데이터 타입과 형변환

데이터 타입

데이터 타입은 변수에 저장할 값의 종류와 메모리 저장 방식을 결정합니다.

Java의 데이터 타입은 크게 기본 타입(Primitive)과 참조 타입(Reference)로 나뉩니다.

기본 타입
정수형
타입	크기	표현 범위
byte	1 byte	-128 ~ 127
short	2 byte	-32,768 ~ 32,767
int (기본 사용)	4 byte	약 -21억 ~ 21억
long	8 byte	매우 큰 정수 (약 ±9×10¹⁸)
실수형
float	4 byte	약 7자리 유효 숫자
double (기본 사용)	8 byte	약 15~16자리 유효 숫자
문자형
char	2byte	단일 문자 저장
논리형
boolean		true / false

** 참고로 char는 내부적으로는 정수 값을 기반으로 단일 문자가 표현됩니다.

char ch = 'A';
int num = ch; // 65 (문자 'A'의 코드 값)

즉, char는 문자처럼 사용되지만, 내부적으로는 문자에 대응되는 숫자(코드 값)로 저장됩니다.

참조 타입
String	문자열 (문자들의 집합)

String은 기본 타입이 아니라 객체이며, 변수에는 실제 문자열 값이 아니라 해당 객체가 저장된 위치(참조값)가 저장됩니다.

참조 타입에는 배열, 객체 등이 있으며, 현재 단계에서는 'String은 값을 직접 저장하는 것이 아니라, 주소를 참조하는 타입이다'정도로 이해하면 충분할 것 같습니다.

형변환 (Type Casting)

Java에서는 타입이 다른 변수 간에 값을 할당할 때 형변환이 발생합니다.

작은 범위의 타입에서 큰 범위의 타입으로는 자동으로 변환됩니다.

더 넓은 범위의 타입이 기존 값을 모두 표현할 수 있기 때문입니다.

int a = 10;
double b = a;

이렇게 자동 형변환을 묵시적 형변환이라고 합니다.

반대로 큰 범위의 타입을 작은 범위로 변환할 경우, 직접 변환을 명시해야 하며

이 때 데이터가 손실 될 가능성이 있습니다.

double a = 10.5;
int b = (int) a; // 10

이렇게 강제로 앞에 타입을 선언하여 변환하는 경우 명시적 형변환이라고 합니다.

6. 연산자

연산자는 값을 계산하거나 비교할 때 사용하는 기호입니다.

산술 연산자

기본적인 사칙연산(+, -, *, /)을 수행할 때 사용되며, 특히 %는 나머지 연산자입니다.

int a = 10;
int b = 3;

System.out.println(a / b); // 3 (정수 나눗셈)
System.out.println(a % b); // 1

이 때 타입이 둘 중 하나라도 실수가 아니면, 결과는 반드시 정수로 나옵니다.

단항 연산자

++, -- 형태로 값을 1 증가하거나 감소시킬 때 사용하는 연산자이며 위치에 따라 전치 연산과 후치 연산으로 구분됩니다.

int a = 5;

int b = ++a; // a를 먼저 증가 → b = 6, a = 6
int c = a++; // a를 먼저 사용 → c = 6, 이후 a = 7

비교 연산자

==, !=, >, <, >=, <= 형태로 두 값을 비교할 때 사용하며 true 또는 false를 반환합니다.

int a = 10;
int b = 20;

System.out.println(a < b); // true

논리 연산자

&& : AND 연산자 (모든 조건이 참일 때만 true)
|| : OR 연산자 (하나라도 참이면 true)
! : NOT 연산자 (결과를 반대로 뒤집음)

int a = 10;
int b = 20;

boolean result1 = (a < b) && (b > 0); // true && true → true
boolean result2 = (a > b) || (b > 0); // false || true → true
boolean result3 = !(a < b);           // !(true) → false

삼항 연산자

조건에 따라 값을 선택할 때 사용하는 연산자입니다.

// 조건 ? 참일 때 값 : 거짓일 때 값

int a = 10;
int b = 20;

int result = (a > b) ? a : b ; // 더 큰 값 선택

동일한 코드를 if문으로 표현하면 다음과 같습니다.

int result;

if (a > b) {
    result = a;
} else {
    result = b;
}

비교해서 보면, 간단한 조건에서는 if문 보다 삼항 연산자를 사용할 때 더 간결하게 표현할 수 있습니다.

복합 할당 연산자

연산과 대입을 동시에 수행하는 연산자로 +=, -=, *-, /=, %= 가 있습니다.

int a = 10;

a += 5; // a = a + 5
a *= 2; // a = a * 2

일반 연산과 비교하였을 때 코드를 더 간결하게 작성할 수 있다는 특징이 있습니다.

7. 배열

배열은 같은 타입의 여러 값을 하나의 변수로 묶어서 관리할 수 있는 자료구조입니다.
여러 개의 데이터를 반복적으로 다룰 때 사용됩니다.

배열 선언 방식

1. 크기 지정 후 선언 (하나 씩 값 입력하는 방식)

int[] arr = new int[3];

arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

배열의 크기를 먼저 정하고, 이후 인덱스를 통해 값을 하나씩 할당합니다.

배열은 인덱스를 통해 접근 가능하며, 0부터 시작합니다.

2. 초기값과 함께 선언

int[] arr = {1, 2, 3};

또한 배열은 선언과 동시에 값을 초기화할 수 있습니다.

2차원 배열 (다차원 배열)

2차원 배열은 행과 열 구조를 가지며, 배열 안에 배열이 포함된 형태이며, arr[행][열]로 값에 접근할 수 있습니다.

1차원 배열 선언 방식과 마찬가지로 2가지 선언 방식이 있습니다.

1. 크기 지정 후 선언 (값 개별 입력)

int[][] arr = new int[2][2];

arr[0][0] = 1;
arr[0][1] = 2;
arr[1][0] = 3;
arr[1][1] = 4;

행과 열의 크기를 먼저 지정한 뒤, 인덱스를 통해 값을 할당합니다.

2. 초기값과 함께 선언

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

선언과 동시에 행/열 구조를 한 번에 초기화할 수 있습니다.

8. 조건문

조건문은 특정 조건에 따라 실행 흐름을 제어할 때 사용합니다.

if문

조건식의 결과가 true일 때 해당 코드가 실행되는 제어문입니다.

기본적으로 if - else if - else 구조로 조건을 분기할 수 있습니다.

if (score >= 90) {
    System.out.println("A");
} else if (score >= 80) {
    System.out.println("B");
} else {
    System.out.println("C");
}

switch문

하나의 값에 따라 여러 경우를 분기할 때 사용하는 조건문입니다.

case 값과 일치하는 경우 실행
default는 어떤 case에도 해당하지 않을 때 실행

// 기본 switch문

int num = 2;

switch (num) {
    case 1:
        System.out.println("one");
        break;
    case 2:
        System.out.println("two");
        break;
    default:
        System.out.println("other");
}

이 때 break가 없다면 다음 case 까지 실행되는 fall-through 현상이 발생하기 때문에

대부분의 경우 각 case마다 break를 작성해줘야 하는데,

이때 발생하는 가독성 문제를 개선하기 위해 사용되는 표현이 바로 ->입니다.

// break없이 간결하게 작성 가능한 -> 사용 switch문

int num = 2;

switch (num) {
    case 1 -> System.out.println("one");
    case 2 -> System.out.println("two");
    default -> System.out.println("other");
}

-> 를 사용하면 break 없이도 각 case가 독립적으로 실행되며 (fall-through 발생하지 않음)

실행되는 코드가 여러 줄 일 경우 {} 블록으로 묶어서 사용합니다.

if와 switch 차이

if : 범위 조건, 복잡한 조건 → 유연하지만 가독성이 떨어질 수 있음
switch : 특정 단일 값 비교 (복잡한 조건 불가) → 구조가 명확하고 가독성이 좋음

// if문 예시

if (score >= 90) {
    System.out.println("A");
} else if (score >= 80) {
    System.out.println("B");
}


// switch문 예시

switch (grade) {
    case "A" -> System.out.println("우수");
    case "B" -> System.out.println("보통");
    default -> System.out.println("기타");
}

9. 반복문

반복문은 특정 조건이 만족되는 동안 코드를 반복 실행할 때 사용합니다.

for문

반복 횟수가 정해져 있을 때 주로 사용하며, 초기식 -> 조건식 -> 증감식 순으로 실행됩니다.

/**
 * for (초기식; 조건식; 증감식) {
 *     코드
 * }
 *
 * 실행 순서
 * 1. 초기식 실행 (처음 한 번만)
 * 2. 조건식 검사 (true이면 실행, false이면 종료)
 * 3. 코드 실행
 * 4. 증감식 실행
 * 5. 다시 조건식 검사 → 반복
 */
 
 
for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

while문

for문과 달리 반복 횟수가 정해지지 않는 반복문이며, 조건이 참인 동안 계속 반복합니다.

/**
 * while (조건식) {
 *     코드
 * }
 *
 * 실행 순서
 * 1. 조건식 검사
 * 2. 조건이 true이면 코드 실행
 * 3. 코드 실행 후 다시 조건식 검사 → 반복
 * 4. 조건이 false이면 반복 종료
 */
 

int i = 0;

while (i < 5) {
    System.out.println(i);
    i++;
}

do-while문

이 때 조건과 관계없이 최소 한 번은 실행되는 반복문이 필요할 경우 do-while문을 사용합니다.

즉, while문과 달리 조건을 나중에 검사하기 때문에, 최소 한 번은 반드시 실행됩니다.

/**
 * do {
 *     코드
 * } while (조건식);
 *
 * 실행 순서
 * 1. 코드 실행 (무조건 1회 실행)
 * 2. 조건식 검사
 * 3. 조건이 true이면 다시 실행 → 반복
 * 4. 조건이 false이면 종료
 */
 
 
do {
    System.out.println("실행");
} while (false);

break / continue

반복문 흐름을 제어할 때 사용합니다.

break : 반복문을 즉시 종료
continue: 현재 반복을 건너뛰고 다음 반복으로 이동

for (int i = 0; i < 10; i++) {
    if (i == 5) break;        // 반복문 즉시 종료
    if (i % 2 == 0) continue; // 현재 반복 건너뛰기
    System.out.println(i);
}

// 실행 결과 : 1, 3 출력 후 종료

[취준기록] 2026 상반기 한국고용정보원 필기시험 & 1차면접 후기

지그농 — Tue, 28 Apr 2026 13:53:30 +0900

지원 기간 정보
- 기관명 : 한국고용정보원
- 직무 : 정보화
- 일정: 2026.03 (서류) - 2026.04 (필기시험) - 2026.04 (1차면접)
- 서류 스펙 : 정보처리기사, 컴퓨터활용능력 1급, 한국사 1급, OPIc IH
- 기타 : 고용노동부 공공데이터 활용 공모전 장려상

안녕하세요! 최근에 한국고용정보원 1차면접을 다녀왔습니다.

상반기 첫 면접이자 공공기관 IT 직무는 처음이라 긴장도 됐지만, 준비 과정에서 제 역량을 다시 정리해 볼 수 있는 좋은 기회였습니다.

참고) 지원 직무 상세 요강

정보화 직무 일반 전형을 준비하시는 분들께 도움이 되고자 기록을 남깁니다!

참고로 저는 비전공자이지만, 필수 지원 자격인 정보처리기사를 보유하고 있어 서류 접수가 가능했습니다.

1. 필기 시험 (4/11)

서류 전형 결과 - 통과

저는 개포고등학교에서 필기시험을 쳤습니다. 전반적인 구성과 과목별 특징을 정리해 보았습니다.

전형 구성 및 시간 배분

항목	상세내용	문항수	시험시간
직업기초능력(NCS)	문제해결 / 자원관리 / 의사소통 / 조직이해	40문항	50분
직무수행능력(전공)	소프트웨어공학, 전산일반	40문항	40분

후기

사실 이번 시험을 위해 전공 공부를 특별히 따로 준비하거나 특정 파트에 집중하지는 않았습니다.

대신 평소에 꾸준히 컴퓨터공학 전공 지식을 학습해온 루틴을 믿고 시험에 임했습니다.

이전 후기를 찾아보니 인공지능, 빅데이터, 정보 보안 비중이 높아 당황했다는평이 많아 관련 핵심 내용을 가볍게 훑고 갔습니다.

다만 냉정하게 말해 '공부한 내용이 딱 맞춰 나왔다'는 느낌은 적었습니다. (빅분기나 보안기사 자격증이 있으신 분들이라면 기본 개념 수준에서 도움을 받으셨을 것 같습니다.)

대신 시험 전 국가직무능력표준(NCS)의 직무 상세 내용을 다시 확인하며 전체적인 흐름을 파악한 것이 큰 도움이 되었습니다.

생소한 문제가 나와도 당황하지 않고 직무 관점에서 접근할 수 있었거든요.

정보화 직무 직무능력 상세 내용 일부

최근 치렀던 타 기관 시험들과 비교했을 때 난이도가 아주 높지는 않았습니다.

NCS에서는 산술 계산 문제가 거의 없었지만, 지문이 길어 보기에서 정답을 빠르게 골라내는 스킬이 필요했습니다.

(하지만 이건 모든 기관 NCS

전공 관련 팁

전공 시험에서는 SQL 관련 비율이 높게 나왔습니다. DB 쿼리문에 익숙해지는 게 도움이 될 것 같습니다.

(필기 시험 바로 직전에 SQLD를 준비했어서 비교해 보자면, SQLD 기본 문제 정도 수준이었던 것 같습니다.)

그 외 일반 문제는 정보처리기사 실기/필기 유형과 유사했습니다.

해당 자격증을 준비하면서 Java나 C언어에 약했던 분들이라면 포인터나 코드 빈칸 채우기 문제를 복습하세요!

(무조건 출제된다는 아니지만, 저는 C언어 보자마자 또 막히더라구요..ㅠㅠ)

참고

처음 전공 필기 시험 관련해서 방향성을 잡기 막막하다면 구글링을 통해 '컴퓨터일반 정리본'을 참고하는 것을 추천합니다.

저는 요약 교재(e-book)를 활용했는데, 관련 상세 후기는 [이전 게시글]을 참고해 주세요!

2026년 한국산업단지공단 디지털/ICT 직무 필기 시험 후기

한국산업단지공단 2026년 상반기 4급 채용 후기 직무 전환 후 처음으로 필기시험을 쳤습니다! 디지털/ICT 직무에 지원했으며 직무 분야별 모집 공고는 아래 이미지를 참고해주세요. 서류 전형은

jignonne.tistory.com

2. 1차면접 (PT & 실무 역량 면접)

필기시험 결과 안내문

솔직히 필기 시험을 치고 나서 머리에 많이 남아 있지 않아 큰 기대 없이 봤는데 합격이라 엄청 기뻤습니다!

안내문에는 필기 점수와 함께 다음 면접 전형에 대한 상세 가이드가 포함되어 있었습니다.

1차 면접은 충북 음성에 위치한 한국고용정보원 본사에서 진행되었습니다.

(저의 집에서 거리가 좀 있는 편이라 면접 당일 컨디션 관리가 중요했습니다.)

한국고용정보원 충북 음성군 맹동면 태정로 6

버스 예매할 때 음성터미널이 아니라 충북혁신도시터미널을 검색하셔야 합니다!
처음에 당연히 음성만 생각해서 음성터미널행으로 예매했다가, 위치를 다시 확인하고 급하게 취소 후 재예매했습니다..ㅎㅎ...
아마 다들 알고 계실 것 같지만, 저같은 실수를 하는 분들이 없길 바라며..

합격의 기쁨도 잠시, 1차 면접은 사실상 시간 싸움이었는데, 일정이 정말 타이트했습니다.

수요일에 합격 & PT 주제 공개 - 금요일까지 PPT 선제출 - 그 다음주 금요일 PT 면접 으로 진행되었습니다.

이틀 만에 주제 분석부터 자료 제작까지 마쳐야 했고, 발표시간도 제한되었기 때문에 (발표 시간도 안내문에 기재되어 있었습니다.)

PT 구성과 면접 질문 대비까지 짧은 시간 집중을 해야 했습니다.

주제는 해당 원과 직무에 대한 나의 실무 역량을 고민해볼 수 있는 내용이었습니다.

PT 준비

저는 주제를 보고 브레인 스토밍(What-Why-How)을 많이 했습니다.

고용정보원의 주요 서비스, 미션, 정보화 직무의 상세 업무를 나열했습니다. 내가 가진 역량이 이 서비스에 어떻게 기여할 수 있을지 '논리적 근거'를 찾는 데 집중했습니다.

발표 시간은 5분으로 제한되어 있었습니다. (해당 부분은 지원 시기별 상이할 수 있으나, 제가 참여한 전형에서는 5분이었습니다.)

스크립트 없이 진행해야 했기 때문에 며칠 간 목이 쉴 정도로 반복 연습하며 내용을 몸에 익혔습니다.

면접 당일

다른 분들의 후기들을 보니 면접장에 입장하면 휴대폰과 전자기기를 제출해야 한다고 해서 저는 발표 전날 PPT랑 스크립트를 프린트해서 계속 연습했습니다.

본사는 터미널에서 약 5분 정도 거리에 있었고, 찾아 가는 길은 어렵지 않았습니다.

휴대폰을 제출하고 대기실에서 피피티 스크립트를 계속 보면서 차분하게 마인드 세팅 했습니다.

면접 분위기

면접은 엄격한 분위기 보다, 지원자의 긴장을 풀어주시려는 편안한 분위기였습니다.

발표 이후 질문들은 PPT 내용을 검증하는 질문들이 중심이었습니다.

브레인스토밍 단계에서 '고용정보원과 이 직무가 왜 나를 필요로 하는가'를 깊게 고민했던 덕분에 질문에 크게 당황하지는 않았습니다.

마치며

상반기 첫 면접이라 긴장도 많이 했고, 두서없이 말한 부분도 좀 잇어서 아쉬움이 남습니다. (면접은 늘 준비한 것 만큼 해내는게 어려운 것 같습니다)

하지만 "집중한 만큼 발표는 긴장하지 않고 잘 마쳤다"는 점에 의의를 두려고 합니다.

KEEP : 타이트한 일정 속에서도 논리적인 PPT 구성과 반복 연습으로 발표를 완수
PROBLEM : 질문에 대해 준비한 내용을 더 정제해서 빠르게 핵심만 말하는 연습이 필요
TRY : 다음 면접에서는 일방적인 답변이 아닌, 면접관과 소통하는 '대화형 면접'으르 목표로 준비해보겠습니다

긴 글 읽어주셔서 감사합니다.

글을 쓰고 있는 지금, 결과가 아직 나오지 않았지만 한 단계 더 성장할 수 있는 기회가 된 것 같습니다.

준비하시는 모든 분들에게 좋은 결과가 있길 바랍니다!