새싹

[Java(10)] 재귀 호출과 instanceof 연산자

Sangenie — Fri, 3 Jul 2026 14:23:44 +0900

안녕하세요~ 경제적 자유입니다.

더 자세히 공부하고 싶다면 아래 문서도 함께 참고해보세요.

참고 링크: Java Recursion
참고 링크: Java instanceof

1. 재귀 호출이란?

재귀 호출(Recursion)은 메서드가 실행되는 도중에 자기 자신을 다시 호출하는 방식입니다.

for (int number = 3; number >= 1; number--) {
    System.out.println(number);
}

재귀 호출에서는 메서드가 숫자 하나를 출력한 뒤, 더 작은 숫자를 전달하면서 자기 자신을 다시 호출합니다.

countDown(3);
→ countDown(2);
→ countDown(1);
→ 종료

즉, 하나의 메서드가 문제를 조금 더 작은 문제로 바꾼 뒤 같은 메서드에 다시 맡기는 흐름이라고 보면 됩니다.

다만 메서드가 계속 자기 자신을 호출하기만 하면 호출이 끝나지 않습니다.

따라서 재귀 메서드에는 반드시 다음 두 가지가 필요합니다.

재귀 호출: 메서드가 자기 자신을 다시 호출하는 부분
종료 조건: 더 이상 자기 자신을 호출하지 않고 멈추는 부분

기본 문법

반환타입 메서드이름(매개변수) {
    if (종료 조건) {
        return 반환값;
    }

    return 메서드이름(변경된 값);
}

종료 조건이 만족되면 메서드는 값을 반환하면서 호출을 멈춥니다.

종료 조건이 만족되지 않으면 값을 조금 변경한 뒤 같은 메서드를 다시 호출합니다.

재귀 호출에서 중요한 것은 호출할 때마다 종료 조건에 가까워져야 한다는 점입니다.

public class Main {

    public static void countDown(String name, int number) {
        // 종료 조건
        if (number == 0) {
            System.out.println(name + "의 카운트다운이 끝났습니다.");
            return;
        }

        System.out.println(name + ": " + number);

        // 숫자를 1 줄여서 자기 자신을 다시 호출
        countDown(name, number - 1);
    }

    public static void main(String[] args) {
        String name = "상구";

        countDown(name, 3);
    }
}

// 실행 결과:
// 상구: 3
// 상구: 2
// 상구: 1
// 상구의 카운트다운이 끝났습니다.

main() 메서드에서 countDown("상구", 3)을 호출하면 다음과 같은 순서로 실행됩니다.

countDown("상구", 3)
countDown("상구", 2)
countDown("상구", 1)
countDown("상구", 0)

숫자가 0이 되기 전까지는 number - 1을 전달하면서 같은 메서드를 다시 호출합니다.

마지막으로 숫자가 0이 되면 다음 조건이 참이 됩니다.

if (number == 0)

이때 return이 실행되면서 더 이상 재귀 호출을 하지 않습니다.

여기서 number == 0이 종료 조건, countDown(name, number - 1)이 재귀 호출에 해당합니다.

재귀 호출은 어떻게 돌아오는 걸까?

재귀 호출은 단순히 아래 방향으로만 계속 내려가는 것이 아닙니다.

호출된 메서드가 끝나면 이전에 실행 중이던 메서드로 다시 돌아옵니다.

public class Main {

    public static void printNumber(String name, int number) {
        if (number == 0) {
            return;
        }

        System.out.println(name + " 내려가는 중: " + number);

        printNumber(name, number - 1);

        System.out.println(name + " 돌아오는 중: " + number);
    }

    public static void main(String[] args) {
        String name = "상구";

        printNumber(name, 3);
    }
}

// 실행 결과:
// 상구 내려가는 중: 3
// 상구 내려가는 중: 2
// 상구 내려가는 중: 1
// 상구 돌아오는 중: 1
// 상구 돌아오는 중: 2
// 상구 돌아오는 중: 3

재귀 호출과 스택

Java에서 메서드가 호출되면 해당 메서드를 실행하는 데 필요한 정보가 호출 스택(Call Stack)에 저장됩니다.

재귀 메서드가 자기 자신을 호출할 때마다 새로운 메서드 호출 정보가 스택에 쌓입니다.

countDown(3)
└── countDown(2)
    └── countDown(1)
        └── countDown(0)

가장 마지막에 호출된 countDown(0)이 먼저 끝나고, 그다음 countDown(1), countDown(2), countDown(3) 순서로 종료됩니다.

스택은 마지막에 들어온 것이 먼저 나가는 구조이기 때문입니다.

종료 조건이 없다면 메서드 호출이 계속 쌓이게 됩니다.

public class Main {

    public static void repeat(String name) {
        System.out.println(name);

        // 종료 조건 없이 계속 자기 자신을 호출
        repeat(name);
    }

    public static void main(String[] args) {
        repeat("상구");
    }
}

// 실행 결과:
// 상구
// 상구
// 상구
// ...
// 종료되지 않고 호출이 계속되어 StackOverflowError가 발생할 수 있음

이 코드는 repeat() 메서드를 멈출 조건이 없습니다.

결국 호출 스택의 공간이 부족해지면서 StackOverflowError가 발생합니다.

따라서 재귀 메서드를 작성할 때는 다음 두 가지를 꼭 확인해야 합니다.

호출을 멈추는 종료 조건이 있는가?
재귀 호출을 반복할수록 종료 조건에 가까워지는가?

public class Main {

    public static void printName(String name, int index) {
        // 문자열의 끝에 도달하면 종료
        if (index == name.length()) {
            return;
        }

        System.out.println(name.charAt(index));

        // 다음 위치를 확인
        printName(name, index + 1);
    }

    public static void main(String[] args) {
        String name = "상구";

        printName(name, 0);
    }
}

// 실행 결과:
// 상
// 구

처음에는 index가 0이므로 name.charAt(0)에 해당하는 "상"이 출력됩니다.

그다음 index + 1을 전달해 printName(name, 1)을 호출하고, "구"를 출력합니다.

마지막에는 index와 name.length()가 같아지므로 재귀 호출이 종료됩니다.

이처럼 재귀 호출은 현재 위치를 처리하고 다음 위치를 같은 메서드에 맡기는 구조에서 사용할 수 있습니다.

재귀 호출은 언제 사용할까?

재귀 호출은 문제 자체가 반복적으로 작은 문제로 나누어지는 경우에 잘 어울립니다.

예를 들면 다음과 같은 상황이 있습니다.

팩토리얼 계산
폴더와 하위 폴더 탐색
트리 자료구조 탐색
그래프 탐색
분할 정복 알고리즘
백트래킹 문제

따라서 재귀가 문제 구조를 더 자연스럽게 표현할 때 사용하고, 호출 깊이가 지나치게 깊어지지 않는지 확인하는 것이 중요합니다.

2. instanceof 연산자란?

instanceof는 객체가 특정 타입으로 취급될 수 있는지 확인하는 연산자입니다.

기본적으로 다음과 같은 질문에 답한다고 보면 됩니다.

이 객체는 이 클래스 또는 인터페이스 타입에 해당하는가?

검사 결과는 boolean 값인 true 또는 false로 나옵니다.

객체 instanceof 타입

객체가 오른쪽에 적은 타입과 호환되면 true, 호환되지 않으면 false가 됩니다.

여기서 확인하는 것은 변수 선언부에 적힌 타입만이 아니라, 변수가 실제로 가리키는 객체의 타입입니다.

기본 문법

객체참조변수 instanceof 클래스 또는 인터페이스

예를 들어 다음과 같이 사용할 수 있습니다.

if (person instanceof Student) {
    System.out.println("Student 타입의 객체입니다.");
}

person이 가리키는 객체가 Student 클래스의 객체이거나 Student의 하위 클래스 객체라면 조건이 참이 됩니다.

instanceof는 객체의 타입을 확인한 뒤 형 변환해야 하는 상황에서 자주 사용합니다.

public class Main {

    public static void main(String[] args) {
        String name = "상구";

        boolean isString = name instanceof String;
        boolean isObject = name instanceof Object;

        System.out.println(isString);
        System.out.println(isObject);
    }
}

// 실행 결과:
// true
// true

상속 관계에서 instanceof 사용하기

class Person {
    String name;

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

class Student extends Person {
    Student(String name) {
        super(name);
    }

    void study() {
        System.out.println(name + "가 Java를 공부합니다.");
    }
}

public class Main {

    public static void main(String[] args) {
        Person person = new Student("상구");

        System.out.println(person instanceof Person);
        System.out.println(person instanceof Student);

        if (person instanceof Student) {
            Student student = (Student) person;
            student.study();
        }
    }
}

// 실행 결과:
// true
// true
// 상구가 Java를 공부합니다.

변수 선언만 보면 person의 타입은 Person입니다.

Person person

하지만 실제로 생성한 객체는 Student입니다.

new Student("상구")

따라서 다음 두 조건이 모두 참이 됩니다.

person instanceof Person
person instanceof Student

Student는 Person을 상속받으므로 Student 객체는 Student 타입이면서 동시에 Person 타입으로도 취급할 수 있습니다.

하지만 person 변수에서는 Person에 정의된 멤버만 바로 사용할 수 있습니다.

Student에만 존재하는 study() 메서드를 호출하려면 다음과 같이 다운캐스팅해야 합니다.

Student student = (Student) person;

이때 실제 객체가 Student인지 확인하지 않고 무조건 형 변환하면 ClassCastException이 발생할 수 있습니다.

그래서 일반적으로는 instanceof로 타입을 확인한 뒤 형 변환합니다.

if (person instanceof Student) {
    Student student = (Student) person;
    student.study();
}

변수의 타입과 객체의 실제 타입

다음 코드는 instanceof를 이해할 때 중요한 차이를 보여줍니다.

Person person = new Student("상구");

이 코드에는 두 가지 타입이 존재합니다.

참조변수의 타입: Person
실제 객체의 타입: Student

왼쪽의 Person은 변수를 통해 어떤 멤버에 접근할 수 있는지 결정합니다.

오른쪽의 new Student("상구")는 메모리에 실제로 만들어진 객체의 타입을 나타냅니다.

instanceof는 실행 중에 변수가 실제로 어떤 객체를 가리키는지 확인합니다.

person instanceof Student

따라서 변수의 선언 타입이 Person이어도 실제 객체가 Student라면 결과는 true입니다.

instanceof와 잘못된 형 변환 방지하기

다음과 같이 Person을 상속받는 클래스가 두 개 있다고 생각해보겠습니다.

class Person {
    String name;

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

class Student extends Person {
    Student(String name) {
        super(name);
    }

    void study() {
        System.out.println(name + "가 공부합니다.");
    }
}

class Developer extends Person {
    Developer(String name) {
        super(name);
    }

    void code() {
        System.out.println(name + "가 코드를 작성합니다.");
    }
}

public class Main {

    public static void main(String[] args) {
        Person person = new Developer("상구");

        if (person instanceof Student) {
            Student student = (Student) person;
            student.study();
        } else if (person instanceof Developer) {
            Developer developer = (Developer) person;
            developer.code();
        }
    }
}

// 실행 결과:
// 상구가 코드를 작성합니다.

person 변수가 실제로 가리키는 객체는 Developer입니다.

따라서 다음 조건은 거짓입니다.

person instanceof Student

반면 다음 조건은 참입니다.

person instanceof Developer

instanceof 검사 없이 아래와 같이 변환하면 문제가 발생합니다.

Student student = (Student) person;

person이 실제로 가리키는 것은 Developer 객체이므로 Student로 변환할 수 없습니다. 실행하면 ClassCastException이 발생합니다.

따라서 여러 하위 타입을 하나의 부모 타입으로 관리하고 있다면, 형 변환 전에 실제 객체 타입을 확인하는 것이 안전합니다.

null을 instanceof로 검사하면 어떻게 될까?

instanceof 왼쪽에 있는 참조변수의 값이 null이면 결과는 항상 false입니다.

public class Main {

    public static void main(String[] args) {
        String name = null;

        System.out.println(name instanceof String);
        System.out.println(name instanceof Object);
    }
}

// 실행 결과:
// false
// false

null은 어떤 객체도 가리키고 있지 않은 상태입니다.

따라서 String 객체인지 검사해도 false, Object 객체인지 검사해도 false가 됩니다.

이 검사 자체로 NullPointerException이 발생하지는 않습니다.

그래서 다음처럼 작성하면 객체가 null이 아닌지와 특정 타입인지 여부를 한 번에 확인할 수 있습니다.

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

조건이 참이라면 name은 null이 아니면서 String 타입의 객체를 가리킨다는 뜻입니다.

인터페이스도 instanceof로 검사할 수 있다

instanceof 오른쪽에는 클래스뿐 아니라 인터페이스도 사용할 수 있습니다.

interface Studyable {
    void study();
}

class Student implements Studyable {
    String name;

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

    @Override
    public void study() {
        System.out.println(name + "가 Java를 공부합니다.");
    }
}

public class Main {

    public static void main(String[] args) {
        Student student = new Student("상구");

        System.out.println(student instanceof Student);
        System.out.println(student instanceof Studyable);
        System.out.println(student instanceof Object);
    }
}

// 실행 결과:
// true
// true
// true

Student 객체는 다음 세 가지 타입으로 취급할 수 있습니다.

자신의 클래스인 Student
구현한 인터페이스인 Studyable
모든 클래스의 최상위 클래스인 Object

따라서 세 개의 instanceof 검사 결과가 모두 true가 됩니다.

instanceof 패턴 매칭

비교적 최근 Java에서는 instanceof 검사와 형 변환을 한 문장으로 묶어 작성할 수도 있습니다.

다음은 기존 방식입니다.

if (person instanceof Student) {
    Student student = (Student) person;
    student.study();
}

person이 Student인지 확인한 뒤, 다시 명시적으로 형 변환하고 있습니다.

패턴 매칭을 사용하면 다음과 같이 줄일 수 있습니다.

class Person {
    String name;

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

class Student extends Person {
    Student(String name) {
        super(name);
    }

    void study() {
        System.out.println(name + "가 Java를 공부합니다.");
    }
}

public class Main {

    public static void main(String[] args) {
        Person person = new Student("상구");

        // 타입 검사와 변수 선언을 함께 처리
        if (person instanceof Student student) {
            student.study();
        }
    }
}

// 실행 결과:
// 상구가 Java를 공부합니다.

다음 표현식에서 student는 패턴 변수입니다.

person instanceof Student student

person이 실제로 Student 타입일 때만 조건이 참이 되고, 조건문 내부에서 student 변수를 사용할 수 있습니다.

따라서 별도의 다운캐스팅 코드를 작성하지 않아도 됩니다.

다만 이 문법은 Java 16부터 정식 기능으로 사용할 수 있으므로, 이전 Java 버전을 사용한다면 기존의 형 변환 방식을 사용해야 합니다.

instanceof를 지나치게 많이 사용해도 될까?

instanceof는 형 변환 전에 객체 타입을 안전하게 확인할 수 있는 유용한 연산자입니다.

하지만 코드 곳곳에서 타입을 계속 검사하는 구조는 객체지향적인 설계가 충분히 활용되지 않았다는 신호일 수도 있습니다.

예를 들어 다음처럼 객체의 종류를 하나씩 검사할 수 있습니다.

if (person instanceof Student) {
    // 학생의 행동
} else if (person instanceof Developer) {
    // 개발자의 행동
}

타입이 계속 추가되면 조건문도 함께 길어집니다.

공통된 행동을 부모 클래스나 인터페이스의 메서드로 정의할 수 있다면, 오버라이딩과 다형성을 활용하는 편이 더 자연스러울 수 있습니다.

abstract class Person {
    String name;

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

    abstract void introduce();
}

class Student extends Person {
    Student(String name) {
        super(name);
    }

    @Override
    void introduce() {
        System.out.println(name + "는 학생입니다.");
    }
}

public class Main {

    public static void main(String[] args) {
        Person person = new Student("상구");

        // 실제 객체의 오버라이딩된 메서드가 실행됨
        person.introduce();
    }
}

// 실행 결과:
// 상구는 학생입니다.

이 코드에서는 객체의 타입을 직접 검사하지 않아도 실제 객체에 맞는 introduce() 메서드가 실행됩니다.

따라서 instanceof는 무조건 피해야 하는 문법은 아니지만, 단순히 객체별 행동을 구분하기 위해 반복적으로 사용하고 있다면 다형성으로 바꿀 수 있는지 생각해볼 필요가 있습니다.

마무리

오늘은 Java의 재귀 호출과 instanceof 연산자에 대해 정리해봤습니다.

재귀 호출은 자주 사용되는 것인지는 잘 모르지만 알고리즘에서는 사용하는 것을 조금 볼 수는 있었습니다..

Instanceof는 이것이 어떤 자료형인지 그리고 어떠한 클래스에 속해있는 것인지에 대해서 알 수 있으며 많이 사용된다고 합니다만.. 조금 더 익숙해 지기를...

공부화이팅!

[Java(9)] 접근 제한자, this, final

Sangenie — Wed, 24 Jun 2026 16:12:07 +0900

안녕하세요~ 경제적 자유입니다.

더 자세히 공부하고 싶다면 아래 문서도 함께 참고해보세요.

참고 링크: https://www.programiz.com/java-programming/access-modifiers
참고 링크: https://www.programiz.com/java-programming/this-keyword
참고 링크: https://www.programiz.com/java-programming/final-keyword

1. 접근 제한자

접근 제한자는 클래스, 필드, 생성자, 메서드에 누가 접근할 수 있는지를 정하는 문법입니다.

Java에서도 모든 필드와 메서드를 아무 곳에서나 사용할 수 있게 두지 않고, 필요한 범위만 공개할 수 있습니다.

이렇게 접근 범위를 조절하면 객체 내부의 값이 외부에서 함부로 변경되는 것을 막을 수 있습니다.

Java의 접근 수준

Java의 접근 수준은 다음과 같이 나뉩니다.

접근 수준접근 가능한 범위

public	어디에서나 접근 가능
protected	같은 패키지 또는 상속받은 자식 클래스에서 접근 가능
package-private	같은 패키지 안에서 접근 가능
private	선언된 클래스 내부에서만 접근 가능

여기서 주의할 점은 package-private에는 별도의 키워드가 없다는 것입니다.

아무 접근 제한자도 작성하지 않았을 때 package-private 접근 수준이 적용됩니다.

흔히 이를 “default 접근 제한자”라고 부르기도 하지만, 코드에 default라고 작성하지는 않습니다.

기본 문법

class Person {

    public String publicName;
    protected String protectedName;
    String packageName;          // package-private
    private String privateName;
}

각 필드의 의미는 다음과 같습니다.

publicName은 다른 클래스에서도 접근할 수 있습니다.
protectedName은 같은 패키지 또는 자식 클래스에서 접근할 수 있습니다.
packageName은 같은 패키지 안에서만 접근할 수 있습니다.
privateName은 Person 클래스 내부에서만 접근할 수 있습니다.

private 필드와 getter

객체의 필드는 보통 private으로 선언하는 경우가 많습니다.

외부 코드가 필드에 직접 접근하지 못하게 막고, 필요한 경우 메서드를 통해 값을 읽거나 변경하게 만드는 방식입니다.

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    // 외부에서 이름을 읽을 수 있도록 공개한 메서드
    public String getName() {
        return name;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("상구");

        System.out.println(person.getName());

        // person.name처럼 직접 접근할 수는 없음
    }
}

// 실행 결과:
// 상구

name 필드는 private이므로 Person 클래스 밖에서는 직접 접근할 수 없습니다.

대신 public으로 선언된 getName() 메서드를 통해 이름을 가져옵니다.

이렇게 객체 내부의 데이터를 숨기고, 정해진 방법으로만 접근하게 만드는 것을 캡슐화라고 합니다.

캡슐화는 단순히 값을 숨기는 데서 끝나는 것이 아니라, 잘못된 값이 들어오는 것을 막거나 객체의 상태를 안전하게 관리하는 데도 사용됩니다.

setter를 사용할 때

값을 변경해야 한다면 setter 메서드를 만들 수 있습니다.

다만 setter를 만든다는 것은 외부에서 값을 변경할 수 있도록 허용한다는 뜻이므로, 모든 필드에 무조건 만드는 것은 좋지 않습니다.

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public void setName(String name) {
        if (name == null || name.isBlank()) {
            System.out.println("이름은 비워둘 수 없습니다.");
            return;
        }

        this.name = name;
    }

    public String getName() {
        return name;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("상구");

        person.setName("상구 수정");

        System.out.println(person.getName());
    }
}

// 실행 결과:
// 상구 수정

필드를 public으로 공개했다면 어떤 문자열이든 바로 넣을 수 있습니다.

하지만 setter를 사용하면 이름이 비어 있는지 검사한 뒤 값을 변경하는 식으로 객체의 상태를 관리할 수 있습니다.

2. this 키워드

this는 현재 실행 중인 객체 자신을 가리키는 참조입니다.

예를 들어 Person 객체가 자신의 이름을 저장하거나 자신의 메서드를 호출할 때, 그 객체 자신을 가리키는 표현이 this입니다.

특히 생성자나 setter에서 매개변수 이름과 필드 이름이 같을 때 자주 사용합니다.

기본 문법

class Person {
    private String name;

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

위 코드에는 이름이 같은 두 개의 name이 있습니다.

this.name = name;

왼쪽의 this.name은 현재 객체가 가지고 있는 인스턴스 변수입니다.

오른쪽의 name은 생성자로 전달받은 매개변수입니다.

따라서 이 코드는 다음과 같은 뜻입니다.

전달받은 name 값을 현재 객체의 name 필드에 저장한다.

this를 사용하지 않으면 어떻게 될까?

class Person {
    private String name;

    Person(String name) {
        name = name;
    }

    public String getName() {
        return name;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("상구");

        System.out.println(person.getName());
    }
}

// 실행 결과:
// null

name = name;이라고만 작성하면 두 name 모두 가까운 범위에 있는 매개변수를 의미합니다.

결국 매개변수 값을 다시 자기 자신에게 넣을 뿐, 객체의 필드에는 값이 저장되지 않습니다.

String 타입의 인스턴스 변수는 값이 저장되지 않으면 기본값인 null을 가지므로 출력 결과도 null이 됩니다.

이 문제를 해결하려면 필드 앞에 this를 붙여야 합니다.

예제

class Person {
    private String name;

    public Person(String name) {
        // 현재 객체의 name 필드에 매개변수 name을 저장
        this.name = name;
    }

    public void introduce() {
        System.out.println("제 이름은 " + this.name + "입니다.");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("상구");

        person.introduce();
    }
}

// 실행 결과:
// 제 이름은 상구입니다.

new Person("상구")가 실행되면 새로운 Person 객체가 만들어집니다.

그 객체의 생성자 안에서 this는 방금 만들어진 객체를 가리킵니다.

따라서 this.name = name;은 새 객체의 name 필드에 "상구"를 저장하는 코드입니다.

this로 현재 객체의 메서드 호출하기

this는 필드뿐 아니라 현재 객체의 다른 메서드를 호출할 때도 사용할 수 있습니다.

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public void greet() {
        System.out.println("안녕하세요.");
    }

    public void introduce() {
        this.greet();
        System.out.println("저는 " + this.name + "입니다.");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("상구");

        person.introduce();
    }
}

// 실행 결과:
// 안녕하세요.
// 저는 상구입니다.

this.greet()는 현재 객체가 가지고 있는 greet() 메서드를 호출한다는 뜻입니다.

같은 클래스 안에서는 this를 생략하고 greet()라고 작성해도 동작합니다.

따라서 꼭 필요한 문법은 아니지만, 현재 객체의 필드나 메서드를 사용한다는 점을 분명하게 나타낼 수 있습니다.

this()로 다른 생성자 호출하기

this와 this()는 모습이 비슷하지만 역할이 다릅니다.

this는 현재 객체를 가리킵니다.
this()는 같은 클래스의 다른 생성자를 호출합니다.

class Person {
    private String name;
    private int age;

    public Person() {
        // 매개변수 두 개를 받는 생성자 호출
        this("상구", 0);
    }

    public Person(String name) {
        // 매개변수 두 개를 받는 생성자 호출
        this(name, 0);
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void introduce() {
        System.out.println("이름: " + name);
        System.out.println("나이: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("상구");

        person.introduce();
    }
}

// 실행 결과:
// 이름: 상구
// 나이: 0

Person(String name) 생성자는 this(name, 0)을 통해 매개변수 두 개를 받는 생성자를 호출합니다.

이렇게 하면 각 생성자에서 필드에 값을 넣는 코드를 반복해서 작성하지 않아도 됩니다.

다른 생성자를 호출하는 this()는 생성자의 첫 번째 문장에 있어야 합니다.

public Person(String name) {
    System.out.println("생성 시작");
    this(name, 0); // 컴파일 오류
}

this()보다 앞에 다른 실행문이 있으면 컴파일 오류가 발생합니다.

3. final 키워드

final은 더 이상 변경하거나 확장하지 못하도록 제한할 때 사용하는 키워드입니다.

변수에 붙으면 재할당할 수 없습니다.
메서드에 붙으면 자식 클래스에서 오버라이딩할 수 없습니다.
클래스에 붙으면 다른 클래스가 상속할 수 없습니다.

final을 단순히 “상수로 만드는 키워드”라고만 외우면 메서드와 클래스에서의 역할을 놓칠 수 있습니다.

final 변수

변수에 final을 붙이면 값을 한 번 할당한 뒤 다른 값으로 다시 할당할 수 없습니다.

기본 문법

final 자료형 변수명 = 값;

예를 들면 다음과 같습니다.

final String NAME = "상구";

관례상 변하지 않는 상수처럼 사용하는 static final 변수는 대문자와 밑줄로 이름을 작성합니다.

다만 모든 final 지역 변수까지 반드시 대문자로 작성해야 하는 것은 아닙니다.

예제

public class Main {
    public static void main(String[] args) {
        final String name = "상구";

        System.out.println(name);

        // name = "민수";
        // 컴파일 오류: final 변수에는 새로운 값을 다시 할당할 수 없음
    }
}

// 실행 결과:
// 상구

name에는 처음에 "상구"가 저장됩니다.

그 뒤에는 "민수"처럼 새로운 문자열을 다시 할당할 수 없습니다.

final 참조 변수에서 주의할 점

객체를 저장하는 참조 변수에 final을 붙였다고 해서 객체 내부의 모든 값까지 변하지 않는 것은 아닙니다.

final이 막는 것은 참조 변수가 다른 객체를 가리키도록 바꾸는 것입니다.

class Person {
    String name;

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

public class Main {
    public static void main(String[] args) {
        final Person person = new Person("상구");

        // 객체 내부의 필드는 변경 가능
        person.name = "상구 수정";

        System.out.println(person.name);

        // person = new Person("민수");
        // 컴파일 오류: person이 다른 객체를 가리키도록 변경할 수 없음
    }
}

// 실행 결과:
// 상구 수정

person 변수는 처음 만들어진 Person 객체를 계속 가리켜야 합니다.

하지만 그 객체 안에 있는 name 필드가 final이 아니므로, person.name은 변경할 수 있습니다.

즉, final 참조 변수와 변경할 수 없는 객체는 서로 다른 개념입니다.

final 메서드

메서드에 final을 붙이면 자식 클래스가 해당 메서드를 오버라이딩할 수 없습니다.

오버라이딩은 부모 클래스에서 물려받은 메서드를 자식 클래스가 자신의 방식으로 다시 정의하는 것입니다.

기본 문법

class Parent {
    public final void methodName() {
        // 실행할 코드
    }
}

예제

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    // 자식 클래스에서 변경할 수 없는 메서드
    public final void printName() {
        System.out.println("이름: " + name);
    }
}

class Student extends Person {
    public Student(String name) {
        super(name);
    }

    /*
    public void printName() {
        System.out.println("학생 이름을 출력합니다.");
    }
    */

    // 위 메서드의 주석을 해제하면 컴파일 오류 발생
    // 부모의 final 메서드는 오버라이딩할 수 없음
}

public class Main {
    public static void main(String[] args) {
        Student student = new Student("상구");

        student.printName();
    }
}

// 실행 결과:
// 이름: 상구

Student는 Person을 상속받았으므로 printName()을 사용할 수 있습니다.

하지만 printName()이 final로 선언되어 있기 때문에, Student 클래스에서 같은 메서드를 새롭게 정의할 수는 없습니다.

부모 클래스에서 정한 동작을 자식 클래스가 바꾸면 안 되는 상황에서 사용합니다.

final 클래스

클래스에 final을 붙이면 다른 클래스가 해당 클래스를 상속할 수 없습니다.

기본 문법

final class ClassName {
    // 필드와 메서드
}

예제

final class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public void introduce() {
        System.out.println("저는 " + name + "입니다.");
    }
}

/*
class Student extends Person {
    public Student(String name) {
        super(name);
    }
}
*/

// 위 클래스의 주석을 해제하면 컴파일 오류 발생
// final 클래스는 상속할 수 없음

public class Main {
    public static void main(String[] args) {
        Person person = new Person("상구");

        person.introduce();
    }
}

// 실행 결과:
// 저는 상구입니다.

Person 클래스가 final로 선언되어 있으므로 다른 클래스가 extends Person으로 상속할 수 없습니다.

클래스의 동작을 상속으로 변경하거나 확장하는 것을 막고 싶을 때 사용할 수 있습니다.

Java의 String 클래스도 대표적인 final 클래스입니다.

final의 의미 정리

final은 사용하는 대상에 따라 의미를 구분해서 기억하는 것이 좋습니다.

final 변수	다른 값을 다시 할당할 수 없음
final 메서드	자식 클래스에서 오버라이딩할 수 없음
final 클래스	다른 클래스가 상속할 수 없음

결국 final은 무언가를 무조건 “상수”로 만드는 문법이라기보다, 변경 가능한 범위를 제한하는 문법이라고 보면 이해하기 쉽습니다.

접근 제한자, this, final을 함께 사용해보기

final class Person {
    private final String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    public void introduce() {
        System.out.println("저는 " + this.name + "입니다.");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("상구");

        person.introduce();
        System.out.println("저장된 이름: " + person.getName());
    }
}

// 실행 결과:
// 저는 상구입니다.
// 저장된 이름: 상구

먼저 Person 클래스가 final이므로 다른 클래스가 상속할 수 없습니다.

name 필드는 private이므로 클래스 밖에서 직접 접근할 수 없으며, 동시에 final이므로 생성된 뒤 다른 문자열로 다시 할당할 수 없습니다.

생성자에서는 this.name = name;을 사용해 전달받은 "상구"를 현재 객체의 name 필드에 저장합니다.

외부에서는 public으로 공개된 getName()과 introduce() 메서드만 사용할 수 있습니다.

마무리

오늘은 Java의 접근 제한자, this, final 키워드에 대해 정리해봤습니다.

제가 이해하기로는

접근 제한자(public, private)는 누가 사용할 수 있는지를 정한다.
this는 현재 어떤 객체를 가리키는지 나타낸다.
final은 어디까지 변경할 수 있는지를 제한한다.

로 이해가 됩니다.

또한 이러한 접근제한자와 키워드를 사용해 캡슐화를 시킬 수 있다는 점이 중요한 것 같다는 생각이 드네요.

공부화이팅!

[Java(8)] 생성자, static, string 클래스

Sangenie — Wed, 24 Jun 2026 00:09:25 +0900

안녕하세요~ 경제적 자유입니다.

오늘은 Java의 생성자(Constructor), static 키워드, String 클래스에 대해 정리해보려고 합니다.

더 자세히 공부하고 싶다면 아래 문서도 함께 참고해보세요.

참고 링크: Java Constructors
참고 링크: Java static Keyword
참고 링크: Java String

1. 객체가 만들어질 때 실행되는 생성자

생성자(Constructor)는 클래스를 이용해 객체를 만들 때 호출되는 특별한 코드입니다.

Person person = new Person("상구");

위 코드에서 new Person("상구")가 실행되면 새로운 Person 객체가 만들어지고, 그 과정에서 Person 클래스의 생성자가 호출됩니다.

생성자 이름은 클래스 이름과 같아야 합니다.
생성자에는 반환형을 작성하지 않습니다.
객체를 생성할 때 호출됩니다.

생성자의 기본 문법

class 클래스이름 {

    클래스이름() {
        // 객체가 생성될 때 실행할 코드
    }
}

예를 들어 클래스 이름이 Person이라면 생성자 이름도 Person이어야 합니다.

class Person {

    Person() {
        // Person 객체가 생성될 때 실행
    }
}

다음과 같이 반환형을 작성하면 생성자가 아니라 일반 메서드가 됩니다.

class Person {

    void Person() {
        // 생성자가 아니라 이름이 Person인 일반 메서드
    }
}

겉보기에는 비슷하지만 void가 붙어 있기 때문에 생성자가 아닙니다.

매개변수가 없는 생성자

생성자는 매개변수 없이 만들 수 있습니다.

이러한 생성자를 매개변수가 없는 생성자 또는 no-argument constructor라고 부릅니다.

class Person {
    String name;

    Person() {
        name = "상구";
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();

        System.out.println(person.name);
    }
}

// 실행 결과:
// 상구

new Person()이 실행되면 Person() 생성자가 호출됩니다.

생성자 안에서 name에 "상구"를 저장했기 때문에 새로 만들어진 객체의 이름은 처음부터 "상구"가 됩니다.

매개변수가 있는 생성자

객체를 만들 때 외부에서 값을 전달하려면 생성자에 매개변수를 선언할 수 있습니다.

class Person {
    String name;

    Person(String personName) {
        name = personName;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("상구");

        System.out.println(person.name);
    }
}

// 실행 결과:
// 상구

new Person("상구")에서 전달한 "상구"는 생성자의 personName 매개변수로 들어갑니다.

name = personName;

오른쪽의 personName에는 전달받은 "상구"가 들어 있고, 그 값이 객체의 name 변수에 저장되는 흐름입니다.

보통은 필드와 매개변수의 이름을 같게 작성하고 this를 사용하기도 합니다.

class Person {
    String name;

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

public class Main {
    public static void main(String[] args) {
        Person person = new Person("상구");

        System.out.println(person.name);
    }
}

// 실행 결과:
// 상구

여기에서 this.name은 현재 만들어지고 있는 객체의 name 변수를 의미합니다.

오른쪽의 name은 생성자로 전달받은 매개변수입니다.

따라서 다음 코드는 전달받은 이름을 현재 객체의 이름으로 저장한다는 뜻입니다.

this.name = name;

기본 생성자는 무엇일까?

클래스에 생성자를 하나도 작성하지 않으면 Java 컴파일러가 자동으로 매개변수가 없는 생성자를 제공합니다.

이렇게 컴파일러가 자동으로 제공하는 생성자를 기본 생성자(default constructor)라고 합니다.

class Person {
    String name;
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();

        System.out.println(person.name);
    }
}

// 실행 결과:
// null

Person 클래스에는 직접 작성한 생성자가 없지만 new Person()을 사용할 수 있습니다.

컴파일러가 다음과 비슷한 형태의 기본 생성자를 자동으로 제공하기 때문입니다.

Person() {
}

name에는 별도의 문자열을 저장하지 않았기 때문에 참조 자료형의 기본값인 null이 출력됩니다.

생성자를 하나라도 직접 작성하면 컴파일러는 기본 생성자를 자동으로 추가하지 않습니다.

class Person {
    String name;

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

public class Main {
    public static void main(String[] args) {
        // Person person = new Person();
        // 오류: 매개변수가 없는 생성자가 존재하지 않음

        Person person = new Person("상구");

        System.out.println(person.name);
    }
}

// 실행 결과:
// 상구

현재 Person 클래스에는 Person(String name) 생성자만 있습니다.

따라서 반드시 문자열을 전달해야 하며, new Person()처럼 매개변수 없이 객체를 만들 수는 없습니다.

생성자 오버로딩

하나의 클래스에 매개변수가 서로 다른 생성자를 여러 개 만들 수도 있습니다.

이를 생성자 오버로딩(Constructor Overloading)이라고 합니다.

class Person {
    String name;
    int age;

    Person() {
        name = "이름 없음";
        age = 0;
    }

    Person(String name) {
        this.name = name;
        age = 0;
    }

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person("상구");
        Person person3 = new Person("상구", 28);

        System.out.println(person1.name + ", " + person1.age);
        System.out.println(person2.name + ", " + person2.age);
        System.out.println(person3.name + ", " + person3.age);
    }
}

// 실행 결과:
// 이름 없음, 0
// 상구, 0
// 상구, 28

전달하는 값의 개수와 자료형에 따라 서로 다른 생성자가 호출됩니다.

2. 객체가 아니라 클래스에 속하는 static

필드(field)는 객체가 가지고 있는 데이터, 메서드(method)는 객체가 할 수 있는 행동

하지만 모든 객체가 같은 값을 공유해야 하는 경우에 사용할 수 있는 것이 static 키워드입니다.

static이 붙은 변수와 메서드는 특정 객체가 아니라 클래스 자체에 속합니다.

static 변수의 기본 문법

class 클래스이름 {
    static 자료형 변수이름;
}

예를 들어 다음과 같이 작성할 수 있습니다.

class Person {
    static int count = 0;
}

count는 각각의 Person 객체에 따로 만들어지는 변수가 아닙니다.

Person 클래스에 하나만 만들어지고, 모든 Person 객체가 그 값을 공유합니다.

static 변수 예제

class Person {
    String name;
    static int count = 0;

    Person(String name) {
        this.name = name;
        count++;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("상구");
        Person person2 = new Person("민수");

        System.out.println(person1.name);
        System.out.println(person2.name);
        System.out.println(Person.count);
    }
}

// 실행 결과:
// 상구
// 민수
// 2

첫 번째 객체가 만들어질 때 count++가 실행되어 count가 1이 됩니다.

두 번째 객체가 만들어질 때 다시 count++가 실행되어 2가 됩니다.

count는 특정 객체의 값이 아니라 Person 클래스가 공유하는 값이기 때문에 다음과 같이 클래스 이름으로 접근했습니다.

Person.count

Java에서는 객체를 통해서도 static 변수에 접근할 수 있지만, 어떤 클래스의 값인지 명확하게 드러나도록 클래스 이름으로 접근하는 것이 좋습니다.

인스턴스 변수와 static 변수의 차이

class Person {
    String name;
    static int count = 0;
}

위 코드에서 두 변수는 소속이 다릅니다.

name은 객체마다 따로 존재하는 인스턴스 변수입니다.
count는 클래스에 하나만 존재하는 static 변수입니다.

class Person {
    String name;
    static int count = 0;

    Person(String name) {
        this.name = name;
        count++;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("상구");
        Person person2 = new Person("민수");

        System.out.println(person1.name);
        System.out.println(person2.name);
        System.out.println(Person.count);
    }
}

// 실행 결과:
// 상구
// 민수
// 2

static 메서드의 기본 문법

메서드에도 static을 붙일 수 있습니다.

class 클래스이름 {

    static 반환자료형 메서드이름() {
        // 실행할 코드
    }
}

static 메서드는 객체를 만들지 않고 클래스 이름으로 호출할 수 있습니다.

class Greeting {

    static void sayHello(String name) {
        System.out.println(name + "님, 안녕하세요!");
    }
}

public class Main {
    public static void main(String[] args) {
        Greeting.sayHello("상구");
    }
}

// 실행 결과:
// 상구님, 안녕하세요!

Greeting 객체를 생성하지 않았지만 다음과 같이 메서드를 호출할 수 있습니다.

Greeting.sayHello("상구");

sayHello()가 Greeting 객체가 아니라 Greeting 클래스에 속한 static 메서드이기 때문입니다.

static 메서드에서 인스턴스 변수에 바로 접근할 수 없는 이유

static 메서드는 객체를 만들지 않아도 호출할 수 있습니다.

그런데 인스턴스 변수는 객체가 만들어져야 존재합니다.

따라서 static 메서드에서는 특정 객체의 인스턴스 변수를 바로 사용할 수 없습니다.

class Person {
    String name = "상구";

    static void printName() {
        // System.out.println(name);
        // 오류: static 메서드에서 인스턴스 변수에 바로 접근할 수 없음
    }
}

printName()을 호출하는 시점에는 어떤 Person 객체의 name을 사용해야 하는지 알 수 없습니다.

인스턴스 변수에 접근하려면 먼저 객체를 만들어야 합니다.

class Person {
    String name = "상구";

    static void printName() {
        Person person = new Person();

        System.out.println(person.name);
    }
}

public class Main {
    public static void main(String[] args) {
        Person.printName();
    }
}

// 실행 결과:
// 상구

객체를 만든 다음 person.name처럼 접근하면 어떤 객체의 변수인지 분명해집니다.

main 메서드에 static이 붙는 이유

Java 프로그램을 실행할 때 JVM은 다음 메서드를 찾아서 호출합니다.

public static void main(String[] args)

프로그램이 시작되는 시점에는 아직 Main 객체가 만들어지지 않았습니다.

따라서 JVM이 객체를 생성하지 않고도 main()을 호출할 수 있도록 static이 붙어 있습니다.

public class Main {
    public static void main(String[] args) {
        System.out.println("프로그램 시작");
    }
}

// 실행 결과:
// 프로그램 시작

main()은 특정 Main 객체의 동작이라기보다 프로그램 실행을 시작하는 클래스 메서드라고 볼 수 있습니다.

3. 문자열을 객체로 다루는 String

Java에서 문자열은 String을 사용해 표현합니다.

String name = "상구";

겉으로 보기에는 int, double, boolean 같은 기본 자료형과 비슷해 보이지만, String은 기본 자료형이 아닙니다.

String은 문자열을 다루기 위해 Java에서 제공하는 클래스입니다.

String 클래스는 java.lang 패키지에 들어 있습니다.

java.lang 패키지는 Java에서 자동으로 불러오기 때문에 별도의 import 없이 사용할 수 있습니다.

String의 기본 문법

문자열 리터럴을 사용하면 다음과 같이 만들 수 있습니다.

String 변수이름 = "문자열";

예를 들어 이름을 저장한다면 다음과 같습니다.

String name = "상구";

new를 사용해 직접 String 객체를 만들 수도 있습니다.

String name = new String("상구");

두 코드 모두 문자열을 만들 수 있지만, 일반적인 문자열은 다음처럼 문자열 리터럴을 사용하는 방식이 더 간단하고 널리 사용됩니다.

String name = "상구";

문자열 출력과 연결

문자열은 + 연산자를 사용해 연결할 수 있습니다.

public class Main {
    public static void main(String[] args) {
        String name = "상구";
        String message = name + "님, 반갑습니다.";

        System.out.println(message);
    }
}

// 실행 결과:
// 상구님, 반갑습니다.

+ 연산자는 숫자끼리 사용하면 덧셈을 수행하지만, 문자열이 포함되면 값을 하나의 문자열로 연결합니다.

public class Main {
    public static void main(String[] args) {
        String name = "상구";
        int age = 28;

        System.out.println(name + "의 나이는 " + age + "살입니다.");
    }
}

// 실행 결과:
// 상구의 나이는 28살입니다.

문자열과 숫자를 함께 연결하면 숫자도 문자열 형태로 이어집니다.

자주 사용하는 String 메서드

String은 클래스이기 때문에 문자열을 다룰 수 있는 여러 메서드를 제공합니다.

public class Main {
    public static void main(String[] args) {
        String name = "상구";

        System.out.println(name.length());
        System.out.println(name.charAt(0));
        System.out.println(name.contains("상"));
    }
}

// 실행 결과:
// 2
// 상
// true

length()는 문자열의 길이를 반환합니다.

name.length()

"상구"는 두 글자이므로 2가 반환됩니다.

charAt(0)은 지정한 위치의 문자를 하나 가져옵니다.

name.charAt(0)

Java의 위치 번호는 0부터 시작하기 때문에 0번 위치에는 '상'이 있습니다.

contains("상")은 문자열 안에 해당 내용이 포함되어 있는지 확인합니다.

name.contains("상")

"상구" 안에는 "상"이 들어 있으므로 true가 반환됩니다.

문자열 비교에는 equals를 사용한다

문자열을 비교할 때는 ==보다 equals() 메서드를 사용해야 합니다.

public class Main {
    public static void main(String[] args) {
        String name = new String("상구");

        if (name.equals("상구")) {
            System.out.println("이름이 같습니다.");
        }
    }
}

// 실행 결과:
// 이름이 같습니다.

equals()는 문자열의 실제 내용이 같은지 비교합니다.

name.equals("상구")

반면 ==는 두 변수가 같은 객체를 가리키고 있는지 비교합니다.

public class Main {
    public static void main(String[] args) {
        String name1 = new String("상구");
        String name2 = new String("상구");

        System.out.println(name1 == name2);
        System.out.println(name1.equals(name2));
    }
}

// 실행 결과:
// false
// true

name1과 name2에는 같은 글자가 들어 있지만 new String()을 통해 서로 다른 객체가 만들어졌습니다.

따라서 객체의 위치를 비교하는 ==의 결과는 false입니다.

하지만 문자열 내용은 둘 다 "상구"이므로 equals()의 결과는 true입니다.

문자열의 내용을 비교하려는 상황에서는 다음과 같이 기억하면 됩니다.

문자열1.equals(문자열2)

String은 한 번 만들어지면 내용이 바뀌지 않는다

Java의 String 객체는 불변 객체(immutable object)입니다.

불변 객체는 한 번 만들어진 뒤 내부 내용이 바뀌지 않는 객체를 뜻합니다.

public class Main {
    public static void main(String[] args) {
        String name = "상구";

        name = name + "님";

        System.out.println(name);
    }
}

// 실행 결과:
// 상구님

위 코드만 보면 기존의 "상구"가 "상구님"으로 수정된 것처럼 보일 수 있습니다.

하지만 실제로는 기존 문자열의 내용이 바뀐 것이 아닙니다.

name + "님"

이 연산을 통해 "상구님"이라는 새로운 문자열이 만들어지고, name이 새 문자열을 가리키도록 변경된 것입니다.

흐름을 간단히 표현하면 다음과 같습니다.

name → "상구"

name = name + "님"

name → "상구님"

기존 "상구" 문자열을 직접 수정한 것이 아니라, 새로운 문자열을 만든 뒤 참조를 바꾼 것입니다.

반복문 안에서 문자열을 계속 이어 붙이면 새로운 String 객체가 여러 번 만들어질 수 있습니다.

문자열을 자주 수정해야 하는 상황에서는 StringBuilder를 사용하는 방법도 있지만, 간단한 문자열 연결에서는 String과 + 연산자만으로도 충분합니다.

String 메서드도 원본 문자열을 바꾸지 않는다

toUpperCase(), replace() 같은 메서드를 호출해도 원본 문자열 자체가 수정되는 것은 아닙니다.

새로운 문자열을 반환하는 흐름입니다.

public class Main {
    public static void main(String[] args) {
        String name = "상구";

        name.replace("상", "민");

        System.out.println(name);
    }
}

// 실행 결과:
// 상구

replace()를 호출했지만 반환된 문자열을 저장하지 않았기 때문에 name은 여전히 "상구"를 가리킵니다.

변경된 결과를 사용하려면 반환값을 다시 변수에 저장해야 합니다.

public class Main {
    public static void main(String[] args) {
        String name = "상구";

        name = name.replace("상", "민");

        System.out.println(name);
    }
}

// 실행 결과:
// 민구

replace()가 반환한 새로운 문자열을 다시 name에 저장했기 때문에 "민구"가 출력됩니다.

생성자, static, String을 함께 사용해보기

지금까지 정리한 세 가지 개념을 하나의 코드에 함께 사용해보겠습니다.

class Person {
    static int count = 0;

    String name;

    Person(String name) {
        this.name = name;
        count++;
    }

    void introduce() {
        String message = "안녕하세요. 제 이름은 " + name + "입니다.";

        System.out.println(message);
    }

    static void printCount() {
        System.out.println("생성된 사람 수: " + count);
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("상구");
        Person person2 = new Person("민수");

        person1.introduce();
        person2.introduce();

        Person.printCount();
    }
}

// 실행 결과:
// 안녕하세요. 제 이름은 상구입니다.
// 안녕하세요. 제 이름은 민수입니다.
// 생성된 사람 수: 2

new Person("상구")가 실행되면 생성자가 호출되고, 전달한 "상구"가 객체의 name에 저장됩니다.

객체가 만들어질 때마다 모든 객체가 공유하는 static 변수 count가 1씩 증가합니다.

introduce()에서는 String과 + 연산자를 사용해 인사 문장을 만들었습니다.

마지막에는 객체를 따로 지정하지 않고 다음과 같이 static 메서드를 호출했습니다.

Person.printCount();

정리하면 다음과 같은 흐름입니다.

생성자 → 객체가 만들어질 때 초기값 설정
static → 모든 객체가 함께 사용할 값이나 기능 관리
String → 이름이나 문장 같은 문자열 데이터 관리

각각 따로 보면 단순한 문법이지만, 실제 코드에서는 이렇게 서로 연결되어 사용됩니다.

마무리

오늘은 Java의 생성자, static 키워드, String 클래스에 대해 정리해봤습니다.

특히 문자열과 char이라는 것 그리고 그것을 사용할때 다르게 사용된다는 점이 가장 흥미로웠고 특히 이것은 알고리즘을 사용할 때 매우 편하다는 것을 알 수 있었습니다.

공부화이팅!

[비전공자를 위한 이해할 수 있는 IT 지식]개발 공부 전에 알아야 할 IT 전체 흐름 정리

Sangenie — Sat, 20 Jun 2026 22:48:33 +0900

안녕하세요. 경제적 자유입니다.

오늘 제가 읽고 정리한 책은 『비전공자를 위한 이해할 수 있는 IT 지식』입니다.

이 책은 제목 그대로 IT를 전공하지 않은 사람도 개발과 IT의 기본 흐름을 이해할 수 있도록 도와주는 책입니다. 저도 비전공자로 개발 공부를 시작하다 보니 처음에는 모르는 용어가 정말 많았습니다.

서버, 클라이언트, API, 데이터베이스, 프레임워크, 라이브러리, Git 같은 단어들은 개발 공부를 하다 보면 계속 나오지만, 막상 누군가에게 설명하려고 하면 쉽지 않았습니다.

『비전공자를 위한 이해할 수 있는 IT 지식』은 개발을 처음 공부하는 사람이 자주 마주치는 IT 기본 개념들을 쉽게 설명해주는 책입니다.

프로그래밍 언어, 운영체제, 네트워크, 서버와 클라이언트, API, JSON, 데이터베이스, 프레임워크와 라이브러리, Git 같은 내용이 나옵니다.

이 책이 좋았던 점은 하나의 개념을 너무 어렵게 설명하지 않는다는 점이었습니다. (특히 개발자가 말할 법한 한 문단을 하나씩 쪼개서 해석해주는 것은 정말 도움이 되었다고 생각이 드네요..)

이 책은 개발자가 정확히 어떤 일을 하는지 궁금한 분들에게 추천하고 싶습니다.

특히 비전공자로 개발 공부를 시작하려는 분, 서버나 API 같은 용어가 아직 낯선 분, 개발 공부를 하고 있지만 전체 흐름이 잘 잡히지 않는 분들에게 잘 맞는 책이라고 생각합니다.

저도 이 책을 통해서 굉장히 많은 부분을 알게 되었고 특히 개발자가 무엇을 하는지에 대해서 조금 더 깊게 알 수 있었습니다.

[Java(7)] 클래스, 메서드, 오버로딩

Sangenie — Fri, 19 Jun 2026 16:28:25 +0900

안녕하세요~ 경제적 자유입니다.

오늘은 Java의 클래스와 객체, 메서드, 메서드 오버로딩에 대해 정리해보려고 합니다.

더 자세히 공부하고 싶다면 아래 문서도 함께 참고해보세요.

참고 링크: https://www.programiz.com/java-programming/class-objects
참고 링크: https://www.programiz.com/java-programming/methods
참고 링크: https://www.programiz.com/java-programming/method-overloading

1. 클래스와 객체

Java는 객체 지향 프로그래밍 언어입니다.

간단히 말하면 프로그램을 여러 개의 객체로 나누어 생각하는 방식이라고 보면 됩니다.

Java에서는 이런 정보를 담고 행동을 정의하기 위해 클래스를 사용합니다.

클래스는 객체를 만들기 위한 설계도입니다.

그리고 그 설계도를 바탕으로 실제로 만들어진 것이 객체입니다.

클래스 = 설계도

객체 = 설계도로 만든 실제 대상

기본 문법

class 클래스이름 {
    // 필드
    // 객체가 가지는 데이터

    // 메서드
    // 객체가 할 수 있는 동작
}

클래스 안에는 보통 필드와 메서드가 들어갑니다.

필드는 객체가 가지는 데이터입니다. 메서드는 객체가 수행할 수 있는 동작입니다.

예제

class Person {
    String name;

    void introduce() {
        System.out.println("안녕하세요. 제 이름은 " + name + "입니다.");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();

        person.name = "상구";
        person.introduce();
    }
}

// 실행 결과:
// 안녕하세요. 제 이름은 상구입니다.

위 코드에서는 Person이라는 클래스를 만들었습니다.

Person 클래스 안에는 name이라는 필드가 있고, introduce()라는 메서드가 있습니다.

그리고 main 메서드 안에서 new Person()을 사용해 실제 객체를 만들었습니다.

Person person = new Person();

이 문장은 Person 클래스를 바탕으로 person이라는 객체를 만드는 코드입니다.

그다음 person.name = "상구";를 통해 객체의 이름을 넣고, person.introduce();를 통해 객체가 가진 메서드를 실행했습니다.

즉, 클래스는 틀이고 객체는 그 틀로 만들어진 실제 값이라고 보면 됩니다.

2. 메서드

메서드는 특정 작업을 수행하는 코드 묶음입니다.

메서드는 코드를 깔끔하게 나누고, 같은 기능을 재사용할 때 사용합니다.

기본 문법

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

반환타입은 메서드가 실행된 뒤 돌려주는 값의 타입입니다.

만약 돌려줄 값이 없다면 void를 사용합니다.

메서드이름은 말 그대로 메서드의 이름입니다.

매개변수는 메서드가 실행될 때 외부에서 전달받는 값입니다.

예제

public class Main {
    static void sayHello(String name) {
        System.out.println(name + "님, 안녕하세요!");
    }

    public static void main(String[] args) {
        sayHello("상구");
    }
}

// 실행 결과:
// 상구님, 안녕하세요!

위 코드에서는 sayHello라는 메서드를 만들었습니다.

static void sayHello(String name)

여기서 String name은 메서드가 전달받는 값입니다.

main 메서드에서 sayHello("상구");를 실행하면 "상구"라는 문자열이 name으로 전달됩니다.

System.out.println("상구" + "님, 안녕하세요!");

// 상구님 안녕하세요!

값을 반환하는 메서드

이번에는 메서드가 값을 돌려주는 경우를 보겠습니다.

public class Main {
    static String makeMessage(String name) {
        return name + "님, Java 공부를 시작했습니다.";
    }

    public static void main(String[] args) {
        String message = makeMessage("상구");

        System.out.println(message);
    }
}

// 실행 결과:
// 상구님, Java 공부를 시작했습니다.

이번 코드에서는 makeMessage 메서드가 문자열을 반환합니다.

그래서 반환 타입이 String입니다.

static String makeMessage(String name)

메서드 안에서 return을 만나면 그 값을 메서드를 호출한 쪽으로 돌려줍니다.

String message = makeMessage("상구");

이 코드는 makeMessage("상구")의 결과를 message 변수에 저장하는 흐름입니다.

즉, 메서드는 단순히 출력만 하는 것이 아니라, 계산하거나 조합한 결과를 다시 돌려줄 수도 있습니다.

3. 메서드 오버로딩

메서드 오버로딩은 같은 이름의 메서드를 여러 개 만드는 것입니다.

다만 아무렇게나 같은 이름을 사용할 수 있는 것은 아닙니다.

Java에서 메서드 오버로딩이 되려면 매개변수의 개수, 타입, 순서 중 하나가 달라야 합니다.

이럴 때 메서드 이름을 매번 다르게 만들기보다, 같은 이름을 유지하면서 매개변수만 다르게 만들 수 있습니다.

이것이 메서드 오버로딩입니다.

기본 문법

void 메서드이름(String name) {
    // 문자열 하나를 받는 메서드
}

void 메서드이름(String name, int age) {
    // 문자열 하나와 정수 하나를 받는 메서드
}

두 메서드는 이름이 같습니다.

하지만 첫 번째 메서드는 String 하나를 받고, 두 번째 메서드는 String과 int를 받습니다.

Java는 메서드를 호출할 때 전달된 값의 개수와 타입을 보고 어떤 메서드를 실행할지 판단합니다.

예제

public class Main {
    static void introduce(String name) {
        System.out.println("제 이름은 " + name + "입니다.");
    }

    static void introduce(String name, int age) {
        System.out.println("제 이름은 " + name + "이고, 나이는 " + age + "살입니다.");
    }

    public static void main(String[] args) {
        introduce("상구");
        introduce("상구", 25);
    }
}

// 실행 결과:
// 제 이름은 상구입니다.
// 제 이름은 상구이고, 나이는 25살입니다.

매개변수 타입이 다른 오버로딩

메서드 오버로딩은 매개변수의 개수뿐만 아니라 타입이 달라도 가능합니다.

public class Main {
    static void printInfo(String name) {
        System.out.println("이름: " + name);
    }

    static void printInfo(int age) {
        System.out.println("나이: " + age);
    }

    public static void main(String[] args) {
        printInfo("상구");
        printInfo(25);
    }
}

// 실행 결과:
// 이름: 상구
// 나이: 25

이번에는 printInfo라는 이름의 메서드가 두 개 있습니다.

하나는 String 타입을 받고, 다른 하나는 int 타입을 받습니다.

호출할 때 "상구"를 넣으면 문자열을 받는 메서드가 실행되고, 25를 넣으면 정수를 받는 메서드가 실행됩니다.

즉, Java는 전달된 값의 타입을 보고 어떤 메서드를 사용할지 결정합니다.

반환 타입만 다르면 오버로딩이 아니다

메서드 오버로딩은 반환 타입만 다르게 한다고 성립하지 않습니다.

public class Main {
    static int getNumber() {
        return 10;
    }

    // 오류 발생
    // 반환 타입만 다르고 매개변수가 같기 때문에 오버로딩이 아니다.
    static String getNumber() {
        return "10";
    }

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

위 코드는 메서드 이름도 같고, 매개변수도 없습니다. 차이는 반환 타입뿐입니다.

하지만 Java는 메서드를 구분할 때 반환 타입만으로 구분하지 않습니다.

그래서 오버로딩을 하려면 반드시 매개변수의 개수나 타입, 순서가 달라야 합니다.

마무리

오늘은 Java의 클래스와 객체, 메서드, 메서드 오버로딩에 대해 정리해봤습니다.

처음 main이라는 단어를 치게 되면 public statics를 보면서 클래스 안에 메서드를 만드는 것을 볼 수 있는데 그것이 무엇을 의미하는지 몰랐네요..

그래도 하나씩 알아가니 다행입니다.. 추가로 공부해야 할 것들은 아마 그 용어들의 의미와 심화 과정이지 않을가 싶네요

공부화이팅!

[Java(5)] 흐름제어: break, continue, switch

Sangenie — Thu, 18 Jun 2026 18:00:14 +0900

안녕하세요~ 경제적 자유입니다.

오늘은 Java의 break문, continue문, switch문에 대해 정리해보려고 합니다.

더 자세히 공부하고 싶다면 아래 문서도 함께 참고해보세요.

참고 링크: https://www.programiz.com/java-programming/break-statement
참고 링크: https://www.programiz.com/java-programming/continue-statement
참고 링크: https://www.programiz.com/java-programming/switch-statement

1. break문

break는 반복문이나 switch문 안에서 흐름을 즉시 끊을 때 사용합니다.

기본 문법

if (조건식) {
    break;
}

조건식이 true가 되는 순간 break가 실행되고, 현재 반복문은 즉시 종료됩니다.

예제

public class Main {
    public static void main(String[] args) {
        String[] names = {"민수", "지훈", "상구", "철수"};

        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i] + " 확인 중");

            // 이름이 "상구"라면 반복문 종료
            if (names[i].equals("상구")) {
                System.out.println("상구를 찾았습니다.");
                break;
            }
        }
    }
}

// 실행 결과:
// 민수 확인 중
// 지훈 확인 중
// 상구 확인 중
// 상구를 찾았습니다.

2. continue문

break가 반복문을 완전히 끝낸다면, continue는 현재 반복만 건너뛰고 다음 반복으로 넘어갑니다.

쉽게 말하면 이런 느낌입니다.

break: “이제 반복 그만하자.”
continue: “이번 차례는 넘어가고 다음 차례로 가자.”

기본 문법

if (조건식) {
    continue;
}

조건식이 true가 되면 그 아래 코드는 실행하지 않고, 다음 반복으로 넘어갑니다.

예제

public class Main {
    public static void main(String[] args) {
        String[] names = {"민수", "상구", "지훈", "철수"};

        for (int i = 0; i < names.length; i++) {

            // 이름이 "상구"라면 이번 반복은 건너뜀
            if (names[i].equals("상구")) {
                continue;
            }

            System.out.println(names[i] + " 출력");
        }
    }
}

// 실행 결과:
// 민수 출력
// 지훈 출력
// 철수 출력

3. switch문

switch문은 하나의 값에 따라 실행할 코드를 나누고 싶을 때 사용합니다.

기본 문법

switch (값) {
    case 값1:
        // 값이 값1과 같을 때 실행
        break;

    case 값2:
        // 값이 값2와 같을 때 실행
        break;

    default:
        // 어떤 case에도 해당하지 않을 때 실행
}

예제

public class Main {
    public static void main(String[] args) {
        String name = "상구";
        String level = "GOLD";

        switch (level) {
            case "VIP":
                System.out.println(name + "님은 VIP 회원입니다.");
                break;

            case "GOLD":
                System.out.println(name + "님은 GOLD 회원입니다.");
                break;

            case "BASIC":
                System.out.println(name + "님은 BASIC 회원입니다.");
                break;

            default:
                System.out.println(name + "님의 회원 등급을 확인할 수 없습니다.");
        }
    }
}

// 실행 결과:
// 상구님은 GOLD 회원입니다.

만약 break가 없다면 어떻게 될까요?

기존 switch-case 문법에서는 일치한 case 이후의 코드가 이어서 실행될 수 있습니다.

이 흐름을 fall-through라고 부르기도 합니다.

그래서 특별히 의도한 상황이 아니라면 각 case 끝에 break를 넣어주는 것이 안전합니다.

public class Main {
    public static void main(String[] args) {
        String name = "상구";
        int menu = 2;

        switch (menu) {
            case 1:
                System.out.println(name + "님이 아메리카노를 선택했습니다.");
                break;

            case 2:
                System.out.println(name + "님이 카페라떼를 선택했습니다.");
                break;

            case 3:
                System.out.println(name + "님이 바닐라라떼를 선택했습니다.");
                break;

            default:
                System.out.println("없는 메뉴입니다.");
        }
    }
}

// 실행 결과:
// 상구님이 카페라떼를 선택했습니다.

마무리

오늘은 Java의 break문, continue문, switch문에 대해 정리해봤습니다.

JavaScript와 문법이 동일해서 크게 어렵지는 않는 것 같네요..

그래도 하나씩 복습하면서 가는 것이 중요하다고 생각하고 실제로 기입해보면서 복습하면서 더 이해가 잘되는 것 같네요

공부화이팅!

[Java(6)] 배열, 한번에 여러 값을 다루는 가장 기본적인 방법

Sangenie — Thu, 18 Jun 2026 17:53:09 +0900

안녕하세요~ 경제적 자유입니다.

오늘은 Java의 배열, 다차원 배열, 배열 복사에 대해 정리해보려고 합니다.

더 자세히 공부하고 싶다면 아래 문서도 함께 참고해보세요.

참고 링크: https://www.programiz.com/java-programming/arrays
참고 링크: https://www.programiz.com/java-programming/multidimensional-array
참고 링크: https://www.programiz.com/java-programming/copy-arrays

1. 배열

배열은 같은 타입의 값을 여러 개 저장할 때 사용하는 자료 구조입니다.

String name1 = "상구";
String name2 = "민수";
String name3 = "지훈";

이럴 때 배열을 사용하면 하나의 변수 이름으로 여러 값을 묶어서 관리할 수 있습니다.

배열을 사용할 때 가장 중요한 특징은 두 가지입니다.

첫 번째, Java 배열은 같은 타입의 값만 저장할 수 있습니다.

String[] 배열에는 문자열을 넣고, int[] 배열에는 정수를 넣는 식입니다.

두 번째, 배열의 길이는 한 번 정하면 기본적으로 바꿀 수 없습니다.

new String[3]으로 만들면 공간은 3칸입니다.

나중에 값을 더 많이 넣고 싶다면 더 큰 배열을 새로 만들거나, ArrayList 같은 컬렉션을 사용해야 합니다.

기본 문법

자료형[] 배열이름 = new 자료형[길이];

예를 들어 문자열을 3개 저장할 배열은 이렇게 만들 수 있습니다.

String[] names = new String[3];

여기서 String[]은 문자열 배열이라는 뜻입니다.

names는 배열의 이름이고, new String[3]은 문자열을 저장할 공간 3개를 만든다는 의미입니다.

배열은 값을 꺼낼 때 인덱스를 사용하며, 인덱스는 위치 번호라고 보면 됩니다.

다만 Java 배열의 인덱스는 1이 아니라 0부터 시작합니다.

names[0] = "상구";
names[1] = "민수";
names[2] = "지훈";

첫 번째 값은 names[1]이 아니라 names[0]입니다.

예제

public class Main {
    public static void main(String[] args) {
        String[] names = new String[3];

        names[0] = "상구";
        names[1] = "민수";
        names[2] = "지훈";

        System.out.println(names[0]);
        System.out.println(names[1]);
        System.out.println(names[2]);

        System.out.println("배열 길이: " + names.length);
    }
}

// 실행 결과:
// 상구
// 민수
// 지훈
// 배열 길이: 3

names.length를 사용하면 배열의 길이를 알 수 있습니다. 여기서 주의할 점은 length 뒤에 괄호를 붙이지 않는다는 것입니다.

public class Main {
    public static void main(String[] args) {
        String[] names = {"상구", "민수", "지훈"};

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

// 실행 결과:
// 상구
// 민수
// 지훈

여기서는 i가 0부터 시작해서 배열의 마지막 인덱스까지 이동합니다.

배열의 길이가 3이면 인덱스는 0, 1, 2입니다.

그래서 조건식은 i <= names.length가 아니라 i < names.length로 작성해야 합니다.

만약 i <= names.length라고 쓰면 마지막에 names[3]을 찾으려고 하면서 오류가 발생합니다.

2. 다차원 배열

다차원 배열은 배열 안에 배열이 들어 있는 구조입니다.

가장 많이 보는 형태는 2차원 배열이며, 2차원 배열은 표처럼 생각하면 이해하기 쉽습니다.

예를 들어 학생별 점수를 저장한다고 해보겠습니다.

한 명의 점수만 저장한다면 1차원 배열로 충분합니다.

int[] scores = {90, 80, 70};

그런데 여러 학생의 점수를 저장한다면 이런 구조가 필요할 수 있습니다.

int[][] scores = {
    {90, 80, 70},
    {85, 95, 75},
    {60, 70, 80}
};

여기서 바깥 배열은 학생들을 묶고, 안쪽 배열은 각 학생의 점수들을 묶는다고 보면 됩니다.

즉, scores[0]은 첫 번째 학생의 점수 배열이고, scores[0][1]은 첫 번째 학생의 두 번째 점수입니다.

기본 문법

자료형[][] 배열이름 = new 자료형[행의개수][열의개수];

예를 들어 2행 3열짜리 정수 배열은 이렇게 만들 수 있습니다.

int[][] numbers = new int[2][3];

또는 값을 바로 넣어서 만들 수도 있습니다.

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

Java의 다차원 배열은 정확히 말하면 배열의 배열입니다.

그래서 각 행의 길이가 반드시 같아야 하는 것은 아닙니다.

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

이런 식으로 행마다 길이가 다른 배열도 만들 수 있습니다.

이 구조를 처음 보면 이상해 보일 수 있지만, Java에서는 가능한 형태입니다.

예제

public class Main {
    public static void main(String[] args) {
        String[][] students = {
            {"상구", "90", "85"},
            {"민수", "80", "75"},
            {"지훈", "70", "95"}
        };

        System.out.println("이름: " + students[0][0]);
        System.out.println("Java 점수: " + students[0][1]);
        System.out.println("알고리즘 점수: " + students[0][2]);
    }
}

// 실행 결과:
// 이름: 상구
// Java 점수: 90
// 알고리즘 점수: 85

public class Main {
    public static void main(String[] args) {
        String[][] students = {
            {"상구", "90", "85"},
            {"민수", "80", "75"},
            {"지훈", "70", "95"}
        };

        for (int i = 0; i < students.length; i++) {
            for (int j = 0; j < students[i].length; j++) {
                System.out.print(students[i][j] + " ");
            }
            System.out.println();
        }
    }
}

// 실행 결과:
// 상구 90 85
// 민수 80 75
// 지훈 70 95

바깥쪽 반복문은 행을 움직이며, 안쪽 반복문은 각 행 안에 있는 값을 하나씩 움직입니다.

여기서 중요한 부분은 students[i].length입니다.

2차원 배열에서는 각 행의 길이가 다를 수도 있기 때문에, 안쪽 반복문의 조건을 students[i].length로 잡는 것이 안전합니다.

3. 배열 복사

배열 복사는 생각보다 조심해야 하는 부분입니다.

처음에는 이렇게 작성하면 배열이 복사된다고 생각하기 쉽습니다.

String[] copiedNames = names;

하지만 이 코드는 배열의 값을 새로 복사하는 것이 아니라, 같은 배열을 함께 가리키게 만드는 코드입니다.

쉽게 말하면 배열이 하나 더 생긴 것이 아니라, 같은 배열을 보는 이름표가 하나 더 생긴 느낌입니다.

그래서 한쪽에서 값을 바꾸면 다른 쪽에서도 바뀐 것처럼 보입니다.

기본 문법

배열 복사는 여러 방식으로 할 수 있습니다.

가장 직접적인 방식은 반복문을 사용하는 방법입니다.

자료형[] 새배열 = new 자료형[원본배열.length];

for (int i = 0; i < 원본배열.length; i++) {
    새배열[i] = 원본배열[i];
}

Java에서 제공하는 기능을 사용할 수도 있습니다.

System.arraycopy(원본배열, 원본시작인덱스, 대상배열, 대상시작인덱스, 복사할개수);

또는 Arrays.copyOfRange()를 사용할 수도 있습니다.

Arrays.copyOfRange(원본배열, 시작인덱스, 끝인덱스);

여기서 끝인덱스는 포함되지 않습니다.

예를 들어 Arrays.copyOfRange(names, 0, 2)라고 쓰면 인덱스 0과 1까지만 복사됩니다.

예제 1: =로 복사하면 생기는 문제

public class Main {
    public static void main(String[] args) {
        String[] names = {"상구", "민수", "지훈"};

        String[] copiedNames = names;

        copiedNames[0] = "상구 수정";

        System.out.println(names[0]);
        System.out.println(copiedNames[0]);
    }
}

// 실행 결과:
// 상구 수정
// 상구 수정

분명 copiedNames[0]만 수정했는데 names[0]도 같이 바뀐 것처럼 보입니다.

이유는 두 배열 변수가 같은 배열 객체를 가리키고 있기 때문입니다.

그래서 배열의 값을 독립적으로 복사하고 싶다면 =만 사용하는 방식은 피하는 것이 좋습니다.

예제 2: 반복문으로 배열 복사하기

public class Main {
    public static void main(String[] args) {
        String[] names = {"상구", "민수", "지훈"};
        String[] copiedNames = new String[names.length];

        for (int i = 0; i < names.length; i++) {
            copiedNames[i] = names[i];
        }

        copiedNames[0] = "상구 수정";

        System.out.println(names[0]);
        System.out.println(copiedNames[0]);
    }
}

// 실행 결과:
// 상구
// 상구 수정

이번에는 copiedNames라는 새 배열을 만들고, 반복문으로 값을 하나씩 옮겼습니다.

그래서 copiedNames[0]을 수정해도 names[0]은 그대로 유지됩니다.

이런 흐름이 실제 값을 복사하는 방식에 더 가깝습니다.

예제 3: System.arraycopy()로 배열 복사하기

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String[] names = {"상구", "민수", "지훈"};
        String[] copiedNames = new String[names.length];

        System.arraycopy(names, 0, copiedNames, 0, names.length);

        System.out.println(Arrays.toString(copiedNames));
    }
}

// 실행 결과:
// [상구, 민수, 지훈]

System.arraycopy()는 배열의 일부 또는 전체를 다른 배열로 복사할 때 사용합니다.

System.arraycopy(names, 0, copiedNames, 0, names.length);

이 코드는 names 배열의 0번 인덱스부터 시작해서, copiedNames 배열의 0번 인덱스에, names.length개만큼 복사한다는 뜻입니다.

처음에는 인자가 많아서 복잡해 보이지만, 순서만 기억하면 됩니다.

원본 배열, 원본 시작 위치, 대상 배열, 대상 시작 위치, 복사할 개수

예제 4: Arrays.copyOfRange()로 원하는 구간만 복사하기

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String[] names = {"상구", "민수", "지훈", "영희"};

        String[] copiedNames = Arrays.copyOfRange(names, 0, 2);

        System.out.println(Arrays.toString(copiedNames));
    }
}

// 실행 결과:
// [상구, 민수]

Arrays.copyOfRange()는 원하는 구간만 잘라서 새 배열로 만들 때 사용하기 좋습니다.

Arrays.copyOfRange(names, 0, 2)

이 코드는 인덱스 0부터 시작해서 인덱스 2 전까지 복사합니다.

즉, names[0], names[1]만 복사됩니다.

여기서도 끝 인덱스는 포함되지 않는다는 점을 기억해야 합니다.

배열 문제를 풀 때 특정 구간만 잘라야 하는 경우가 자주 나오는데, 그때 많이 사용하게 되는 메서드입니다.

마무리

오늘은 Java의 배열, 다차원 배열, 배열 복사에 대해 정리해봤습니다.

우앙! 일단 너무 어렵네요.. 근데 아마 배열도 좋기는 한데 List를 빠르게 정리하는 것이 필요하다는 생각이 들었습니다.

배열도 많이 사용되는데 리스트도 엄청 사용되는 것 같더라구요..

저는 공부를 순서대로 하긴 할건데 일단.. 오늘 Arrays.copyOfRange를 이용해서 알고리즘도 풀었고 너무 즐겁습니다.

공부화이팅!

[Java(4)] 반복문, for문부터 do-while문까지 흐름으로 이해하기

Sangenie — Thu, 18 Jun 2026 17:50:38 +0900

안녕하세요~ 경제적 자유입니다.

오늘은 Java의 for문, enhanced for문, do-while문에 대해 정리해보려고 합니다.

더 자세히 공부하고 싶다면 아래 문서도 함께 참고해보세요.

참고 링크: https://www.programiz.com/java-programming/for-loop
참고 링크: https://www.programiz.com/java-programming/enhanced-for-loop
참고 링크: https://www.programiz.com/java-programming/do-while-loop

1. for문

for문은 반복 횟수가 어느 정도 정해져 있을 때 자주 사용하는 반복문입니다.

기본 문법

for (초기식; 조건식; 증감식) {
    // 반복해서 실행할 코드
}

각 부분은 이렇게 보면 됩니다.

초기식은 반복을 시작할 때 한 번만 실행됩니다.

조건식은 반복을 계속할지 판단하는 부분입니다. 조건식이 true이면 반복하고, false이면 반복을 멈춥니다.

증감식은 반복이 한 번 끝날 때마다 실행됩니다. 보통 숫자를 1씩 증가시키거나 감소시킬 때 사용합니다.

흐름으로 보면 아래와 같습니다.

초기식 실행
조건식 검사
조건식이 true이면 코드 실행
증감식 실행
다시 조건식 검사
조건식이 false이면 반복 종료

예제

public class Main {
    public static void main(String[] args) {
        String name = "상구";

        for (int day = 1; day <= 5; day++) {
            System.out.println(name + "가 Java 공부를 한 지 " + day + "일차입니다.");
        }
    }
}

// 실행 결과:
// 상구가 Java 공부를 한 지 1일차입니다.
// 상구가 Java 공부를 한 지 2일차입니다.
// 상구가 Java 공부를 한 지 3일차입니다.
// 상구가 Java 공부를 한 지 4일차입니다.
// 상구가 Java 공부를 한 지 5일차입니다.

2. enhanced for문

enhanced for문은 Java에서 for-each문이라고도 부릅니다.

일반 for문이 인덱스를 직접 다루는 방식이라면, enhanced for문은 배열이나 컬렉션에 들어 있는 값을 하나씩 바로 꺼내서 사용하는 방식입니다.

예를 들어 배열 안에 이름들이 들어 있을 때, 굳이 names[0], names[1]처럼 인덱스를 직접 쓰지 않아도 됩니다.

배열 안의 값을 처음부터 끝까지 하나씩 꺼내고 싶다면 enhanced for문이 훨씬 읽기 좋습니다.

기본 문법

for (자료형 변수명 : 배열또는컬렉션) {
    // 반복해서 실행할 코드
}

여기서 자료형은 배열이나 컬렉션 안에 들어 있는 값의 타입입니다.

변수명은 반복할 때마다 하나씩 꺼낸 값을 담는 변수입니다.

콜론 :의 오른쪽에는 반복할 배열이나 컬렉션이 옵니다.

배열에서 첫 번째 값을 꺼냄
변수에 담음
반복문 안의 코드 실행
다음 값을 꺼냄
다시 실행
꺼낼 값이 없으면 반복 종료

예제

public class Main {
    public static void main(String[] args) {
        String name = "상구";
        String[] topics = {"for문", "enhanced for문", "do-while문"};

        for (String topic : topics) {
            System.out.println(name + "가 공부할 Java 개념: " + topic);
        }
    }
}

// 실행 결과:
// 상구가 공부할 Java 개념: for문
// 상구가 공부할 Java 개념: enhanced for문
// 상구가 공부할 Java 개념: do-while문

이 코드에서는 topics 배열 안에 문자열 3개가 들어 있습니다.

enhanced for문은 배열의 첫 번째 값인 "for문"을 topic에 담고 출력합니다.

그다음 "enhanced for문"을 꺼내고, 마지막으로 "do-while문"을 꺼냅니다.

배열 안의 모든 값을 다 꺼내면 반복문은 자연스럽게 끝납니다.

이 방식은 배열이나 컬렉션의 모든 값을 처음부터 끝까지 순서대로 확인할 때 사용하기 좋습니다.

다만 인덱스 번호가 꼭 필요한 상황이라면 일반 for문이 더 적절합니다.

예를 들어 “몇 번째 요소인지 같이 출력해야 하는 경우”에는 for (int i = 0; i < 배열.length; i++) 형태가 더 편할 수 있습니다.

3. do-while문

일반적인 반복문은 조건을 먼저 확인한 뒤 실행할지 말지 결정합니다.

하지만 do-while문은 일단 한 번 실행한 다음 조건을 확인합니다.

그래서 조건이 처음부터 거짓이어도, 반복문 안의 코드는 최소 한 번 실행됩니다.

이런 구조는 “일단 한 번은 보여줘야 하는 코드”에 잘 어울립니다.

기본 문법

do {
    // 먼저 한 번 실행할 코드
} while (조건식);

여기서 중요한 점은 while (조건식); 뒤에 세미콜론(;)이 붙는다는 것입니다.

일반 while문과 다르게 do-while문은 문장 끝에 세미콜론이 필요합니다.

do 블록 실행
조건식 검사
조건식이 true이면 다시 do 블록 실행
조건식이 false이면 반복 종료

예제

public class Main {
    public static void main(String[] args) {
        String name = "상구";
        int count = 1;

        do {
            System.out.println(name + " 출석 체크 " + count + "회 완료");
            count++;
        } while (count <= 3);
    }
}

// 실행 결과:
// 상구 출석 체크 1회 완료
// 상구 출석 체크 2회 완료
// 상구 출석 체크 3회 완료

이 코드는 먼저 do 블록 안의 문장을 실행합니다.

처음에는 count가 1이므로 "상구 출석 체크 1회 완료"가 출력됩니다.

그다음 count++로 값이 2가 되고, while (count <= 3) 조건을 검사합니다.

조건이 참이면 다시 실행하고, count가 4가 되는 순간 조건이 거짓이 되어 반복문이 끝납니다.

조건이 처음부터 거짓이어도 한 번은 실행된다

do-while문의 특징을 더 확실히 보려면 조건이 처음부터 거짓인 예제를 보면 됩니다.

public class Main {
    public static void main(String[] args) {
        String name = "상구";
        int count = 5;

        do {
            System.out.println(name + "는 일단 한 번 실행됩니다.");
        } while (count < 3);
    }
}

// 실행 결과:
// 상구는 일단 한 번 실행됩니다.

count 는 5, 조건식은 count < 3이므로 처음부터 거짓이지만 출력문은 한 번 실행됩니다.

왜냐하면 do-while문은 조건을 먼저 검사하지 않고, 코드를 먼저 실행한 뒤 조건을 검사하는 구조이기 때문입니다.

이 점이 일반 while문과 가장 큰 차이입니다.

for문, enhanced for문, do-while문은 언제 사용할까?

반복문은 모두 “코드를 여러 번 실행한다”는 공통점이 있습니다.

하지만 실제로 사용할 때는 상황에 따라 조금씩 다르게 선택합니다.

for문은 반복 횟수나 인덱스가 중요할 때 사용하기 좋습니다.

public class Main {
    public static void main(String[] args) {
        String name = "상구";

        for (int i = 1; i <= 3; i++) {
            System.out.println(i + "번째 반복: " + name);
        }
    }
}

// 실행 결과:
// 1번째 반복: 상구
// 2번째 반복: 상구
// 3번째 반복: 상구

enhanced for문은 배열이나 컬렉션의 값을 하나씩 꺼내서 사용할 때 좋습니다.

public class Main {
    public static void main(String[] args) {
        String[] names = {"상구", "민수", "지훈"};

        for (String name : names) {
            System.out.println(name + "님 안녕하세요.");
        }
    }
}

// 실행 결과:
// 상구님 안녕하세요.
// 민수님 안녕하세요.
// 지훈님 안녕하세요.

do-while문은 조건과 상관없이 최소 한 번은 실행해야 할 때 사용합니다.

public class Main {
    public static void main(String[] args) {
        String name = "상구";
        boolean keepGoing = false;

        do {
            System.out.println(name + "에게 메뉴를 한 번 보여줍니다.");
        } while (keepGoing);
    }
}

// 실행 결과:
// 상구에게 메뉴를 한 번 보여줍니다.

마무리

오늘은 Java의 for문, enhanced for문, do-while문에 대해 정리해봤습니다.

뭔가 for문은 동일하게 사용을 할 수 있었는데 enhancedfor문 부터는 어려움이 있는것 같네요.. do-while은 무조건 첫번째는 실행한다는 특징이 있는 것도 새로운 것 같아요.

enhancedfor문을 조금 더 복습하면서 알고리즘에 사용할 수 있을때까지 한번 해봐야죠..

공부화이팅!

[Java(1)] Java 변수와 자료형

Sangenie — Wed, 17 Jun 2026 18:00:20 +0900

안녕하세요~ 경제적 자유입니다.

오늘은 Java의 변수, 리터럴, 기본 자료형을 리뷰해보려고 합니다.

Java를 처음 공부할 때 가장 먼저 만나는 개념 중 하나가 바로 변수입니다.
변수는 쉽게 말하면 값을 담아두는 상자라고 생각하면 됩니다.

예를 들어 사람 이름을 저장하고 싶다면 이름을 담을 상자가 필요하고, 나이를 저장하고 싶다면 나이를 담을 상자가 필요합니다.
Java에서는 이 상자를 만들 때 “어떤 종류의 값을 담을 것인지”를 먼저 정해줘야 합니다.

추가로 더 자세히 공부하고 싶다면 아래 Java 문서를 참고해보세요.

참고 링크: Programiz - Java Variables and Literals
참고 링크: Programiz - Java Primitive Data Types
참고 링크: Oracle Java Tutorial - Primitive Data Types

1. 변수란?

변수란 값을 저장하기 위한 메모리 공간에 붙인 이름입니다.

조금 쉽게 말하면, 변수는 데이터를 담는 상자입니다.

String name = "상구";
int age = 20;

위 코드에서 name은 "상구"라는 문자열을 저장하는 변수이고,
age는 20이라는 숫자를 저장하는 변수입니다.

Java에서는 변수를 만들 때 보통 아래와 같은 형태를 사용합니다.

자료형 변수이름 = 값;

예를 들면 다음과 같습니다.

int number = 10;

여기서 각각의 의미는 다음과 같습니다.

int : 정수를 저장하겠다는 뜻
number : 변수 이름
10 : 변수에 저장할 값

변수가 필요한 이유는 값을 한 번 저장해두고, 그 값을 여러 번 재사용할 수 있기 때문입니다.

예를 들어 이름을 여러 번 출력해야 할 때 매번 "상구"라고 직접 쓰는 것보다, 변수에 담아두고 사용하는 것이 더 편합니다.

public class Main {
    public static void main(String[] args) {
        String name = "상구";

        System.out.println(name);
        System.out.println(name + "님 안녕하세요!");
        System.out.println(name + "님 공부 화이팅!");
    }
}

코드로 이해하기

public class Main {
    public static void introduce(String 상구) {
        System.out.println("안녕하세요. 제 이름은 " + 상구 + "입니다.");
    }

    public static void main(String[] args) {
        introduce("상구");
    }
}

위 코드에서 상구는 introduce 메서드의 parameter입니다.

parameter는 메서드가 실행될 때 외부에서 값을 받아오는 변수라고 생각하면 됩니다.

introduce("상구");

이렇게 호출하면 "상구"라는 값이 상구라는 parameter에 들어가고, 출력 결과는 다음과 같습니다.

안녕하세요. 제 이름은 상구입니다.

실무에서는 보통 parameter 이름을 영어로 작성하지만, Java에서는 한글 변수명도 사용할 수 있습니다.
다만 협업과 가독성을 생각하면 영어 변수명을 사용하는 경우가 훨씬 많습니다.

2. 리터럴이란?

리터럴이란 코드에 직접 적은 고정된 값입니다.

예를 들어 아래 코드에서 10, "상구", true가 리터럴입니다.

int age = 10;
String name = "상구";
boolean isStudent = true;

변수는 값을 담는 상자이고, 리터럴은 그 상자 안에 넣는 실제 값이라고 이해하면 쉽습니다.

int number = 100;

여기서 number는 변수이고, 100은 리터럴입니다.

리터럴이 필요한 이유

프로그램은 결국 값을 다루기 위해 존재합니다.

나이, 이름, 점수, 참/거짓, 소수점 숫자 같은 값을 코드 안에서 직접 표현해야 하는데, 이때 사용하는 것이 리터럴입니다.

int score = 95;
double temperature = 36.5;
char grade = 'A';
boolean passed = true;
String name = "상구";

각각의 값은 코드에 직접 적혀 있으므로 리터럴입니다.

초보자가 헷갈릴 수 있는 부분

문자 하나를 표현할 때는 작은따옴표를 사용합니다.

char grade = 'A';

문자열을 표현할 때는 큰따옴표를 사용합니다.

String name = "상구";

즉, Java에서는 'A'와 "A"가 다릅니다.

char oneLetter = 'A';
String text = "A";

char는 문자 하나이고, String은 문자열입니다.

코드로 이해하기

public class Main {
    public static void printName(String 상구) {
        System.out.println("이름: " + 상구);
    }

    public static void main(String[] args) {
        printName("상구");

        int age = 20;
        double height = 175.5;
        boolean isStudent = true;
        char grade = 'A';

        System.out.println("나이: " + age);
        System.out.println("키: " + height);
        System.out.println("학생 여부: " + isStudent);
        System.out.println("등급: " + grade);
    }
}

여기서 "상구", 20, 175.5, true, 'A'는 모두 리터럴입니다.

3. 기본 자료형이란?

기본 자료형은 Java에서 미리 정해둔 가장 기본적인 데이터 타입입니다.

Java에는 대표적으로 8개의 기본 자료형이 있습니다.

byte
short
int
long
float
double
char
boolean

이 자료형들은 숫자, 문자, 참/거짓 같은 기본적인 값을 저장할 때 사용합니다.

기본 자료형이 필요한 이유

Java는 변수를 만들 때 어떤 종류의 값을 저장할지 정해야 합니다.

예를 들어 나이는 정수이므로 int를 사용할 수 있습니다.

int age = 20;

키는 소수점이 필요할 수 있으므로 double을 사용할 수 있습니다.

double height = 175.5;

참/거짓은 boolean을 사용합니다.

boolean isStudent = true;

이렇게 자료형을 명확하게 정하면, Java가 잘못된 값이 들어가는 것을 미리 막아줄 수 있습니다.

예를 들어 int 변수에는 문자열을 넣을 수 없습니다.

int age = "스무 살"; // 오류 발생

Java는 정적 타입 언어이기 때문에 변수의 자료형이 중요합니다.

4. 정수형 자료형이란?

정수형 자료형은 소수점이 없는 숫자를 저장할 때 사용합니다.

대표적으로 다음과 같은 자료형이 있습니다.

byte
short
int
long

일반적으로 정수를 저장할 때는 가장 많이 int를 사용합니다.

int age = 20;
int score = 95;

숫자가 아주 큰 경우에는 long을 사용합니다.

long population = 5000000000L;

여기서 숫자 뒤에 붙은 L은 이 값이 long 타입이라는 것을 알려주는 표시입니다.

초보자가 헷갈릴 수 있는 부분

정수라고 해서 무조건 아무 숫자나 저장할 수 있는 것은 아닙니다.
각 자료형마다 저장할 수 있는 범위가 다릅니다.

처음 Java를 공부할 때는 너무 복잡하게 외우기보다는 이렇게 이해하면 좋습니다.

일반적인 정수는 int
아주 큰 정수는 long
메모리를 세밀하게 관리해야 하는 상황에서는 byte, short

초보 단계에서는 int와 long을 먼저 익히는 것이 좋습니다.

코드로 이해하기

public class Main {
    public static void printAge(String 상구, int age) {
        System.out.println(상구 + "의 나이는 " + age + "살입니다.");
    }

    public static void main(String[] args) {
        int age = 20;
        long money = 10000000000L;

        printAge("상구", age);
        System.out.println("보유 금액: " + money);
    }
}

5. 실수형 자료형이란?

실수형 자료형은 소수점이 있는 숫자를 저장할 때 사용합니다.

대표적으로 다음 두 가지가 있습니다.

float
double

Java에서는 소수점 숫자를 사용할 때 보통 double을 많이 사용합니다.

double height = 175.5;
double temperature = 36.5;

float을 사용할 때는 숫자 뒤에 F를 붙여야 합니다.

float weight = 70.5F;

float과 double의 차이

둘 다 소수점 숫자를 저장하지만, double이 더 정밀한 값을 저장할 수 있습니다.

그래서 특별한 이유가 없다면 소수점 숫자는 보통 double을 사용하면 됩니다.

코드로 이해하기

public class Main {
    public static void printHeight(String 상구, double height) {
        System.out.println(상구 + "의 키는 " + height + "cm입니다.");
    }

    public static void main(String[] args) {
        double height = 175.5;
        float weight = 70.5F;

        printHeight("상구", height);
        System.out.println("몸무게: " + weight + "kg");
    }
}

6. char와 boolean이란?

char는 문자 하나를 저장하는 자료형입니다.

char grade = 'A';

주의할 점은 char는 반드시 작은따옴표를 사용한다는 것입니다.

char firstLetter = 'S';

반면 boolean은 참 또는 거짓을 저장하는 자료형입니다.

boolean isStudent = true;
boolean isFinished = false;

boolean은 조건문에서 자주 사용됩니다.

if (isStudent) {
    System.out.println("학생입니다.");
}

초보자가 헷갈릴 수 있는 부분

boolean에는 true 또는 false만 들어갈 수 있습니다.

boolean result = true;

코드로 이해하기

public class Main {
    public static void checkStudent(String 상구, boolean isStudent) {
        if (isStudent) {
            System.out.println(상구 + "는 학생입니다.");
        } else {
            System.out.println(상구 + "는 학생이 아닙니다.");
        }
    }

    public static void main(String[] args) {
        char grade = 'A';
        boolean isStudent = true;

        System.out.println("등급: " + grade);
        checkStudent("상구", isStudent);
    }
}

7. String은 기본 자료형일까?

초보자가 자주 헷갈리는 부분이 바로 String입니다.

String name = "상구";

String은 정말 자주 사용되기 때문에 기본 자료형처럼 보일 수 있습니다.

하지만 Java에서 String은 기본 자료형이 아니라 참조 자료형입니다.

기본 자료형은 다음 8개입니다.

byte, short, int, long, float, double, char, boolean

String은 이 8개에 포함되지 않습니다.

그렇다고 해서 어렵게 생각할 필요는 없습니다.

처음에는 “문자열을 저장할 때는 String을 사용한다” 정도로 이해해도 충분합니다.

코드로 이해하기

public class Main {
    public static void sayHello(String 상구) {
        System.out.println("안녕하세요, " + 상구 + "님!");
    }

    public static void main(String[] args) {
        String name = "상구";
        sayHello(name);
    }
}

여기서 String name = "상구";는 문자열을 저장하는 코드입니다.

다만 String은 기본 자료형이 아니라 참조 자료형이라는 점만 기억하면 좋습니다.

8. final로 상수 만들기

JavaScript에는 const가 있지만, Java에서는 보통 final을 사용해서 한 번 정한 값을 바꾸지 못하게 합니다.

final int MAX_SCORE = 100;

final이 붙은 변수는 값을 다시 바꿀 수 없습니다.

final int MAX_SCORE = 100;
MAX_SCORE = 90; // 오류 발생

그래서 변하지 않아야 하는 값에는 final을 사용할 수 있습니다.

예를 들어 최대 점수, 고정 할인율, 변하지 않는 설정값 등에 사용할 수 있습니다.

코드로 이해하기

public class Main {
    public static void printMaxScore(String 상구) {
        final int MAX_SCORE = 100;

        System.out.println(상구 + "가 받을 수 있는 최대 점수는 " + MAX_SCORE + "점입니다.");
    }

    public static void main(String[] args) {
        printMaxScore("상구");
    }
}

상수 이름은 보통 대문자와 언더스코어를 사용해서 작성합니다.

final int MAX_SCORE = 100;
final double PI = 3.14;

마무리

오늘은 Java의 변수, 리터럴, 기본 자료형에 대해 정리해봤습니다.
변수는 값을 담는 상자이고, 리터럴은 코드에 직접 적은 값이며, 기본 자료형은 Java가 미리 준비해둔 가장 기본적인 값의 종류입니다.
처음에는 int, double, boolean, char, String부터 익숙해지는 것을 추천합니다.

공부화이팅!

[Java(3)]조건문, 코드가 스스로 판단하게 만드는 첫 번째 문법

Sangenie — Wed, 17 Jun 2026 17:22:41 +0900

안녕하세요~ 경제적 자유입니다.

오늘은 Java의 if문, if...else문, else if문, 중첩 if문, 삼항 연산자를 리뷰해보려고 합니다.

추가로 더 자세히 공부하고 싶다면 아래 JAVA 문서를 참고해보세요.

참고 링크: Programiz - Java if...else Statement
참고 링크: Programiz - Java Ternary Operator
참고 링크: Oracle Java Tutorial - if-then and if-then-else Statements

1. if문이란?

if문은 Java에서 조건이 true일 때만 특정 코드를 실행하는 문법입니다.

즉, 조건이 맞으면 실행하고, 조건이 맞지 않으면 그냥 넘어갑니다.

기본 문법

if (조건식) {
    // 조건식이 true일 때 실행되는 코드
}

여기서 중요한 점은 조건식의 결과가 반드시 true 또는 false가 되어야 한다는 것입니다.

예를 들어 age >= 20은 나이가 20 이상인지 검사하고, 결과는 true 또는 false가 됩니다.

public class Main {
    public static void main(String[] args) {
        String name = "상구";
        int age = 22;

        if (age >= 20) {
            System.out.println(name + "님은 성인입니다.");
        }

        System.out.println("프로그램이 종료되었습니다.");
    }
}

2. if...else문이란?

if...else문은 조건이 true일 때 실행할 코드와, false일 때 실행할 코드를 나누는 문법입니다.

if문은 조건이 맞지 않으면 아무것도 하지 않고 넘어갑니다.

하지만 if...else문은 조건이 맞지 않을 때 실행할 코드까지 정할 수 있습니다.

기본 문법

if (조건식) {
    // 조건식이 true일 때 실행
} else {
    // 조건식이 false일 때 실행
}

public class Main {
    public static void main(String[] args) {
        String name = "상구";
        int score = 55;

        if (score >= 60) {
            System.out.println(name + "님은 합격입니다.");
        } else {
            System.out.println(name + "님은 불합격입니다."); // 상구님은 불합격입니다.
        }
    }
}

3. else if문이란?

else if문은 조건이 여러 개일 때 사용하는 문법입니다.

단순히 두 가지 상황만 나누는 것이 아니라, 여러 조건을 순서대로 검사할 수 있습니다.

기본 문법

if (조건식1) {
    // 조건식1이 true일 때 실행
} else if (조건식2) {
    // 조건식1은 false이고 조건식2가 true일 때 실행
} else {
    // 모든 조건이 false일 때 실행
}

public class Main {
    public static void main(String[] args) {
        String name = "상구";
        int score = 85;

        if (score >= 90) {
            System.out.println(name + "님의 등급은 A입니다.");
        } else if (score >= 80) {
            System.out.println(name + "님의 등급은 B입니다.");
        } else if (score >= 70) {
            System.out.println(name + "님의 등급은 C입니다.");
        } else {
            System.out.println(name + "님의 등급은 D입니다.");
        }
    }
}

else if문은 위에서 아래로 순서대로 검사합니다.

그리고 한 번 조건이 true가 되면 그 블록만 실행하고 전체 조건문을 빠져나갑니다. 그래서 조건 순서가 중요합니다.

4. 중첩 if문이란?

중첩 if문은 if문 안에 또 다른 if문을 작성하는 문법입니다.

쉽게 말하면 조건을 한 번 검사한 뒤, 그 안에서 다시 한 번 조건을 검사하는 방식입니다.

public class Main {
    public static void main(String[] args) {
        String name = "상구";
        boolean isMember = true;
        int age = 22;

        if (isMember) {
            if (age >= 20) {
                System.out.println(name + "님은 성인 회원입니다.");
            } else {
                System.out.println(name + "님은 미성년자 회원입니다.");
            }
        } else {
            System.out.println(name + "님은 회원이 아닙니다."); // 상구님은 성인 회원입니다.
        }
    }
}

5. 삼항 연산자란?

삼항 연산자는 간단한 if...else문을 한 줄로 줄여서 쓸 수 있는 문법입니다.

Java에서는 다음과 같은 형태로 사용합니다.

조건식 ? 값1 : 값2

의미는 다음과 같습니다.

조건식이 true이면 값1을 사용한다.
조건식이 false이면 값2를 사용한다.

왜 삼항 연산자라고 부를까?

삼항 연산자는 이름 그대로 항이 3개입니다.

조건식 ? true일 때 값 : false일 때 값

조건식
true일 때 사용할 값
false일 때 사용할 값

if...else문과 비교하기

public class Main {
    public static void main(String[] args) {
        String name = "상구";
        int score = 75;
        String result;

        if (score >= 60) {
            result = "합격";
        } else {
            result = "불합격";
        }

        System.out.println(name + "님은 " + result + "입니다.");
    }
}

두 코드는 같은 결과를 출력합니다.

마무리

오늘은 Java에서 조건에 따라 실행 흐름을 나누는 if문, if...else문, else if문, 중첩 if문, 그리고 간단한 조건을 한 줄로 표현하는 삼항 연산자를 정리했습니다.

조건문은 프로그램이 상황을 판단하게 만드는 가장 기본적인 문법입니다.

처음에는 if...else문으로 흐름을 정확히 이해하고, 익숙해진 뒤 간단한 경우에만 삼항 연산자를 사용하는 것이 좋습니다.

공부화이팅!