공돌이 출신 개발자

포함 관계(Composition)

공돌이 출신 개발자 — Tue, 6 May 2025 21:15:43 +0900

✍️ 시작하며

이전 글에서는 객체지향 프로그래밍의 핵심 개념 중 하나인 상속(Inheritance) 을 통해
기존 클래스를 확장하는 방법과 메서드 오버라이딩에 대해 알아보았습니다.
이번 글에서는 클래스 간의 관계 중 하나인 포함 관계(Composition) 를 학습해보겠습니다.

포함 관계는 객체가 다른 객체를 "포함(has-a)" 하는 구조로,
자동차가 엔진을 가지듯, 집이 여러 방을 가지듯 객체 간 구성 관계를 표현할 때 사용됩니다.

학습 목표

포함 관계(Composition)의 개념과 의미를 이해한다.
"has-a" 관계와 "is-a" 관계를 비교할 수 있다.
포함 관계를 실제 코드로 구현하는 방법을 익힌다.
컴포지션의 생명주기 및 UML 표기법을 이해한다.

개념 정리

포함 관계(Composition)란?

포함 관계는 한 클래스가 다른 클래스를 자신의 필드(속성)로 포함하는 구조를 의미합니다.
이는 “has-a” 관계로 표현되며, 구성된 객체가 의존적이고 강한 생명주기 결합을 가질 때 사용합니다.

예를 들어,

자동차는 엔진을 “가지고 있다” → 포함 관계
집은 여러 개의 방을 “가지고 있다” → 포함 관계

→ 포함된 객체는 주 객체가 소멸되면 함께 소멸되는 강한 의존 관계입니다.

문법 설명 – 포함 관계 vs 상속 관계 비교

구분	포함 관계 (Composition)	상속 관계 (Inheritance)
관계 표현	"has-a"	"is-a"
구현 방식	다른 클래스의 객체를 필드로 선언	extends 키워드로 클래스 확장
생명주기	포함 객체는 소유 객체에 종속	자식 객체는 독립적으로 존재 가능
사용 예시	자동차 → 엔진, 집 → 방	학생 → 사람, 개발자 → 직원
UML 표기	채워진 다이아몬드(◆)	빈 삼각형(△)

예시 코드 ① – 자동차와 엔진 (자동 구성 포함 관계)

package com.composition;

public class Engine {

    String name;
    int price;

    void start() {
        System.out.println("엔진이 시작 됩니다.");
    }

    void stop() {
        System.out.println("엔진을 멈춥니다.");
    }
}

package com.composition;

public class Car {

    String name;
    int price;
    // 포함관계(컴포지션)
    // car 클래스는 Engine 객체를 포함 합니다.
    Engine engine;

    public Car() {
        // 자동차 객체가 생성될 때 엔진 객체도 함께 생성 된다.
        // 강한 의존성
        engine = new Engine();
    }
    
    void startCar() {
        engine.start(); // car 객체를 통해 Engine 의 start() 메서드를 호출합니다. 
        System.out.println("자동차가 출발합니다");
    }

    void stopCar() {
        engine.stop();
        System.out.println("자동차가 멈춥니다.");
    }

    // 테스트 코드 작성
    public static void main(String[] args) {

        // **컴포지션 관계를**
        // 자동차 클래스 내부에서 엔진 객체를 생성 시켜야 콤포지션 관계이다.
        Car car = new Car();
        car.startCar();
        car.stopCar();

    } // end of main

}

✅ Car 클래스는 Engine 객체를 필드로 포함하고 있으며, Car가 생성될 때 Engine도 함께 생성됩니다.

예시 코드 ② – 집과 방 구조 (House has-a Room[])

package com.composition;

public class Room {

    private String type;

    public Room(String type) {
        this.type = type;
    }

    void describe() {
        System.out.println(type + " 방입니다.");
    }

}

package com.composition;

public class House {

    private String address;
    Room[] rooms;

    public House(String address) {
        this.address = address;
        this.rooms = new Room[3]; // 컴포지션 : House 가 Room 배열을 소유하고 있다.
        rooms[0] = new Room("거실");
        rooms[1] = new Room("침실");
        rooms[2] = new Room("주방");
        // 속성으로 선언되고 내부에서 객체 생성 했기 때문에 컴포지션이라 할 수 있다.
        //room = new Room("안방");
    }

    void showRooms() {
        System.out.println( address + " 에 있는 방 목록 : ");
        for(int i = 0; i < rooms.length; i++) {
            if(rooms[i] != null) {
                rooms[i].describe();
            }
        }
    }
    
    // 테스트 작성 
    public static void main(String[] args) {
        House house = new House("부산시 진구");
        house.showRooms();

        // house 객체가 소멸이 되면 rooms 도 Room 객체도 소멸 (GC 에 의해 소멸)
        house = null;
    }
    
}

UML에서의 컴포지션 표현

클래스 다이어그램에서는 포함 관계를 채워진 다이아몬드(◆) 로 표현합니다.

+---------------------+
|       House         |
+---------------------+
| - address: String   |
| - rooms: Room[]     |
+---------------------+
| + House()           |
| + showRooms()       |
+---------------------+
         ◆ 1
         |
         |
         | *
+---------------------+
|        Room         |
+---------------------+
| - type: String      |
+---------------------+
| + describe()        |
+---------------------+

House → Room: 1:N 포함 관계
House가 소멸되면 내부 Room들도 함께 사라짐 (강한 생명주기 결합)

정리 표

항목 설명

포함 관계 한 클래스가 다른 클래스를 필드로 포함하는 관계

대표 표현 “has-a” 관계

생명주기 포함된 객체는 소유 객체와 함께 생성/소멸됨

구현 방법 필드로 선언 후 생성자 또는 내부에서 인스턴스화

UML 표현 채워진 다이아몬드(◆) 사용

사용 예시 자동차 → 엔진, 집 → 방, 회사 → 부서 등

마무리하며

이번 글에서는 클래스가 다른 클래스를 포함하여 구성하는 포함 관계(Composition) 에 대해 알아보았습니다.
자동차와 엔진, 집과 방처럼 객체가 객체를 소유하는 구조를 통해
객체 간의 강한 생명주기 결합을 어떻게 코드로 표현하는지 배웠습니다.

다음 글에서는 클래스 간의 연결을 나타내는 연관 관계(Association) 를 다루어보겠습니다.
포함 관계와 달리 객체 간 느슨한 연결이나 참조만 존재하는 관계는 어떻게 설계하는지 함께 살펴보겠습니다.

다음 글 예고 : 연관 관계(Association)

객체지향 설계에서 연관 관계는 클래스 간의 연결을 의미하며,
한 객체가 다른 객체를 참조하거나 사용하는 구조를 표현합니다.
다음 글에서는 연관 관계의 기본 개념과 단방향/양방향 연관, 그리고 실전 예제 코드를 통해 구조를 학습해보겠습니다.

이전 글 다시 보기

상속(Inheritance)에 대해서 궁금하다면??

2025.05.05 - [Java] - 상속(Inheritance)이란?

상속(Inheritance)이란?

✍️ 시작하며이전 글에서는 같은 이름으로 다양한 매개변수를 처리하는 메서드 오버로딩(Overloading) 개념을 배웠습니다.이번 글에서는 객체지향 프로그래밍에서 가장 핵심적인 원칙 중 하나인

seohong.tistory.com

상속(Inheritance)이란?

공돌이 출신 개발자 — Mon, 5 May 2025 20:46:56 +0900

✍️ 시작하며

이전 글에서는 같은 이름으로 다양한 매개변수를 처리하는 메서드 오버로딩(Overloading) 개념을 배웠습니다.
이번 글에서는 객체지향 프로그래밍에서 가장 핵심적인 원칙 중 하나인 상속(Inheritance) 에 대해 알아보겠습니다.
상속은 기존 클래스를 확장하여 재사용할 수 있도록 도와주는 기능으로, 실제 현업 코드에서도 매우 많이 활용됩니다.

학습 목표

상속의 개념과 역할을 이해한다.
extends 키워드를 사용한 클래스 확장을 학습한다.
메서드 오버라이딩(Overriding)의 개념과 적용 방법을 익힌다.
상속을 활용한 클래스 다이어그램 구조와 코드를 이해한다.

개념 정리

상속(Inheritance)이란?

상속은 기존 클래스를 기반으로 새로운 클래스를 정의하는 방식입니다.
상속을 사용하면 기존 클래스의 속성과 기능을 물려받아 새로운 클래스를 확장할 수 있습니다.

부모 클래스(Superclass / Parent Class)
: 공통 속성과 기능을 정의한 기존 클래스
자식 클래스(Subclass / Child Class)
: 부모 클래스를 상속받아 확장한 새로운 클래스

자바에서는 단일 상속만 지원합니다. 즉, 한 클래스는 하나의 부모 클래스만 상속할 수 있습니다.

문법 설명

기본 문법

class 부모클래스 {
    // 공통 기능 및 속성
}

class 자식클래스 extends 부모클래스 {
    // 부모 클래스의 필드/메서드를 물려받고 추가 확장
}

예시 코드 ① – 상속 없이 직접 필드 복붙한 경우

// A.java
public class A {
    String name;
    int height;
    int weight;
    int age;
}

// B.java
public class B {
    String name;
    int height;
    int weight;
    int age;
    int level;
    String nickName;
}

✅ 코드 중복이 심합니다. 유지보수가 어려워집니다.

예시 코드 ② – 상속 사용한 경우

// C.java
public class C extends A {
    // A 클래스의 name, height, weight, age 자동 상속
    int level;
    String nickName;
}

✅ C 클래스는 A의 필드를 모두 물려받아 재사용하고, 자신만의 필드를 추가로 선언할 수 있습니다.

예시 코드 ③ – 메서드 상속과 오버라이드(Override)

// Cal.java
public class Cal {
    public int sum(int n1, int n2) {
        return n1 + n2;
    }

    public int multiply(int n1, int n2) {
        return n1 * n2;
    }
}

// ChildCal.java
class ChildCal extends Cal {

    public int minus(int n1, int n2) {
        return n1 - n2;
    }

    // 오버라이딩: 부모 메서드 재정의
    @Override
    public int multiply(int n1, int n2) {
        if(n1 == 0 || n2 == 0) {
            System.out.println("0을 입력하지 마시오.");
        }
        return n1 * n2;
    }
}

@Override는 부모 클래스의 메서드를 동일한 시그니처로 재정의했다는 표시입니다.
이 기능을 메서드 오버라이딩(Overriding) 이라고 부르며, 상속에서 매우 중요합니다.

실전 예제 – Animal 클래스 상속 및 오버라이딩

class Animal {
    protected String name;

    void eat() {
        System.out.println(name + "이(가) 밥을 먹습니다.");
    }

    void bark() {
        System.out.println(name + "이(가) 짖습니다.");
    }
}

class Dog extends Animal {
    @Override
    void eat() {
        System.out.println("강아지가 사료를 먹습니다.");
    }
}

class Cat extends Animal {
    @Override
    void eat() {
        System.out.println("고양이가 츄르를 먹습니다.");
    }
}

public class Main1 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "바둑이";
        dog.eat();   // 오버라이드된 메서드 호출
        dog.bark();  // 상속된 메서드 호출
    }
}

정리 표

항목	설명
상속이란?	기존 클래스를 기반으로 새로운 클래스를 정의하는 기법
핵심 키워드	extends
오버라이딩 조건	이름, 매개변수, 반환형이 부모 메서드와 동일해야 함
대표 활용 예시	Animal → Dog, Cat / Cal → ChildCal 등
상속의 장점	코드 재사용, 확장성, 가독성 향상

️ 도전 과제 – 상속 활용 멤버십 클래스 구현

아래 다이어그램을 참고하여 Customer와 VIPCustomer 클래스를 상속 구조로 직접 구현해보세요.

이번에는 실제 상황을 반영한 상속 예제를 구현해보겠습니다.
회사에서는 고객 정보를 기반으로 서비스를 제공하고 있으며,
고객 등급에 따라 일반 고객(Customer)과 VIP 고객(VIPCustomer)으로 나뉩니다.

두 고객은 공통적인 속성과 기능이 존재하므로, Customer 클래스를 부모로 정의하고
VIP 고객은 VIPCustomer라는 자식 클래스로 확장해 구현할 수 있습니다.

다이어그램

---------------------------------
|           Customer            |
---------------------------------
| - customerID: int             |
| - customerName: String        |
| - customerGrade: String       |
| - bonusPoint: int             |
| - bonusRatio: double          |
---------------------------------
| + Customer()                  |
| + calcPrice(int): int         |
| + showCustomerInfo(): String  |
---------------------------------

---------------------------------
|          VIPCustomer          |
---------------------------------
| - agentID: int                |
| - salesRatio: double          |
---------------------------------
| + VIPCustomer()               |
| + getAgentID(): int           |
---------------------------------

일반 고객: 1% 보너스 적립
VIP 고객: 추가 할인율 + 전담 상담원 배정

요구사항 정리

항목	설명
공통 속성	고객 ID, 고객 이름, 등급, 보너스 포인트, 적립 비율
공통 기능	구매 금액 계산(calcPrice), 고객 정보 출력(showCustomerInfo)
VIP 전용 속성	전담 상담원 ID, 할인율(salesRatio)

✔️ 구현 코드

// 부모 클래스
public class Customer {

    protected int customerID;
    protected String customerName;
    protected String customerGrade;
    int bonusPoint;
    double bonusRatio;

    public Customer() {
        this.customerGrade = "SILVER";
        this.bonusRatio = 0.01;
    }

    public Customer(int customerID, String customerName) {
        this();
        this.customerID = customerID;
        this.customerName = customerName;
    }

    public int calcPrice(int price) {
        bonusPoint += price * bonusRatio;
        return price;
    }

    public String showCustomerInfo() {
        return customerName + "님의 등급은 " + customerGrade + "이며, 보너스 포인트는 " + bonusPoint + "점입니다.";
    }
}

// 자식 클래스
public class VIPCustomer extends Customer {

    private int agentID;
    double salesRatio;

    public VIPCustomer() {
        super(); // 부모 생성자 호출
        this.customerGrade = "VIP";
        this.bonusRatio = 0.05;
        this.salesRatio = 0.1;
    }

    public VIPCustomer(int customerID, String customerName, int agentID) {
        super(customerID, customerName);
        this.customerGrade = "VIP";
        this.bonusRatio = 0.05;
        this.salesRatio = 0.1;
        this.agentID = agentID;
    }

    @Override
    public int calcPrice(int price) {
        bonusPoint += price * bonusRatio;
        price -= price * salesRatio;
        return price;
    }

    public int getAgentID() {
        return agentID;
    }
}

// 실행 클래스
public class Main {
    public static void main(String[] args) {

        Customer customerLee = new Customer(10010, "이순신");
        System.out.println(customerLee.showCustomerInfo());
        System.out.println("지불 금액 : " + customerLee.calcPrice(10000));

        System.out.println("------------------------------");

        VIPCustomer customerKim = new VIPCustomer(10020, "김유신", 777);
        System.out.println(customerKim.showCustomerInfo());
        System.out.println("지불 금액 : " + customerKim.calcPrice(10000));
        System.out.println("상담원 ID : " + customerKim.getAgentID());
    }
}

✅ 결과 예시 (실행 출력)

이순신님의 등급은 SILVER이며, 보너스 포인트는 100점입니다.
지불 금액 : 10000
------------------------------
김유신님의 등급은 VIP이며, 보너스 포인트는 500점입니다.
지불 금액 : 9000
상담원 ID : 777

마무리하며

상속은 객체지향 설계에서 중복을 줄이고 코드를 재사용할 수 있게 도와주는 핵심 기능입니다.
자식 클래스는 부모의 필드와 메서드를 물려받아 사용할 수 있으며,
필요 시 오버라이딩(Overriding)을 통해 원하는 방식으로 재정의할 수 있습니다.

다음 포스팅에서는 포함관계(Composition)에 대해서 알아볼게요!

다음 글 예고 : 포함 관계(Composition)

객체 지향 설계에서는 객체 간의 관계를 표현하는 다양한 방식이 있습니다.
다음 글에서는 클래스 간의 "has-a" 관계를 나타내는 포함 관계(Composition) 를 중심으로,
자동차와 엔진, 집과 방(Room) 같은 예제를 통해 컴포지션의 개념과 코드를 함께 학습해보겠습니다.

이전 글 다시 보기

메서드 오버로딩에 대해서 궁금하다면??

2025.05.04 - [Java] - 메서드 오버로딩이란?

메서드 오버로딩이란?

✍️ 시작하며이전 글에서는 클래스와 메서드를 정의하는 방법을 살펴보았습니다.이번 글에서는 자바에서 같은 이름의 메서드를 다양한 방식으로 정의할 수 있는 기술,바로 **메서드 오버로딩(

seohong.tistory.com

메서드 오버로딩이란?

공돌이 출신 개발자 — Sun, 4 May 2025 23:51:29 +0900

✍️ 시작하며

이전 글에서는 클래스와 메서드를 정의하는 방법을 살펴보았습니다.
이번 글에서는 자바에서 같은 이름의 메서드를 다양한 방식으로 정의할 수 있는 기술,
바로 **메서드 오버로딩(Method Overloading)**에 대해 배워보겠습니다.

이 개념은 일상적으로 자주 쓰이며, 특히 실무에서 같은 기능을 다양한 방식으로 처리할 때 매우 유용합니다.
실제 예제로는 Calculator 클래스와 함께, 스타크래프트 유닛 전투를 코드로 설계한 예시도 함께 소개합니다.

학습 목표

메서드 오버로딩의 개념과 조건을 이해한다.
오버로딩이 언제 유용한지 파악한다.
실전 코드(Calculator, StarCraft 유닛)로 오버로딩을 익힌다.
오버라이딩과 차이를 구분할 수 있다.

개념 정리

메서드 오버로딩(Method Overloading)이란?

같은 이름의 메서드를 여러 개 정의하는 것입니다.

다만, 이름은 같지만 **매개변수(파라미터)**의 타입, 개수, 순서가 달라야 합니다.

이렇게 하면 다양한 입력을 하나의 이름으로 처리할 수 있어 코드 가독성이 향상됩니다.

메서드 시그니처(Method Signature)란?

메서드를 구분하는 고유한 정보입니다. 다음으로 구성됩니다:

메서드 이름
매개변수의 타입, 순서, 개수

※ 반환형(return type)은 시그니처에 포함되지 않습니다.

문법 설명

오버로딩이 성립하는 조건

구분	예시
매개변수 개수	add(int a), add(int a, int b)
매개변수 타입	add(int a), add(double a)
매개변수 순서	add(int, double), add(double, int)

※ 아래는 불가능한 경우입니다:

int add(int a, int b) {}
double add(int a, int b) {} // 오류 발생: 시그니처가 같음

예시 코드 – 기본 예제 (Calculator)

public class Calculator {

    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }

    public int add(int a, int b, int c) {
        return a + b + c;
    }

    public String add(String str1, String str2) {
        return str1 + str2;
    }

    public static void main(String[] args) {
        Calculator c = new Calculator();
        System.out.println(c.add(3, 4));           // 7
        System.out.println(c.add(2.5, 1.5));       // 4.0
        System.out.println(c.add(1, 2, 3));        // 6
        System.out.println(c.add("안녕", "하세요")); // 안녕하세요
    }
}

같은 이름의 add() 메서드를 다양한 타입과 개수로 정의하였고,
컴파일러는 전달된 인자에 따라 적절한 메서드를 자동 선택합니다.

️ 실전 활용 예 – 스타크래프트 유닛 공격 설계

유닛 간 전투를 설계할 때도 오버로딩은 강력한 기능입니다.
attack() 메서드를 유닛마다 다르게 정의할 수 있습니다.

✔️ Zealot 클래스

package com.startcraft_v02;
/**
 * ver02
 * 메서드 오버로딩 기법을 적용해서 코드를 설계해 보자.
 */
public class Zealot {
    private String name;
    private int power;
    private int hp;

    public Zealot(String name) {
        this.name = name;
        this.power = 4;
        this.hp = 70;
    }

    // read only --> getter
    public String getName() {
        return name;
    }

    public int getPower() {
        return power;
    }

    public int getHp() {
        return hp;
    }

    public void attack(Zealot zealot) {
        zealot.beAttacked(this.power);
        System.out.println(name + " 이 "+ zealot.getName() +"을 공격합니다 " );
    }
  public void attack(Zergling zergling) {
       zergling.beAttacked(this.power);
       System.out.println(name + " 이 " + zergling.getName() + "을 공격합니다 " );
  }

    public void beAttacked(int power) {
        if(this.hp <= 0 ) {
            System.out.println(name + " 이(가) 이미 사망하였습니다.");
            // 실행에 제어권을 반납하고 싶으면 키워드 !! (돌아가)
            return;
        }
        this.hp -= power;
        System.out.println(name + "이(가) 공격을 당합니다");
    }

    public void showInfo() {
        System.out.println("---------⭐상태창⭐----------");
        System.out.println("마린 이름 : " + name);
        System.out.println("마린 공격력 : " + power);
        System.out.println("마린 체력 : " + hp);
    }
}

✔️ Zergling 클래스

package com.startcraft_v02;

public class Zergling {
    private String name;
    private int power;
    private int hp;

    public Zergling(String name) {
        this.name = name;
        this.power = 3;
        this.hp = 50;
    }

    // read only --> getter
    public String getName() {
        return name;
    }

    public int getPower() {
        return power;
    }

    public int getHp() {
        return hp;
    }

    public void attack(Zealot zealot) {
        zealot.beAttacked(this.power);
        System.out.println(name + " 이 "+ zealot.getName() +"을 공격합니다 " );
    }

    public void attack(Marine marine) {
        System.out.println(name + " 이 " + marine.getName() + "을 공격합니다 " );
    }

    public void beAttacked(int power) {
        if(this.hp <= 0 ) {
            System.out.println(name + " 이(가) 이미 사망하였습니다.");
            // 실행에 제어권을 반납하고 싶으면 키워드 !! (돌아가)
            return;
        }
        this.hp -= power;
        System.out.println(name + "이(가) 공격을 당합니다");
    }

    public void showInfo() {
        System.out.println("---------⭐상태창⭐----------");
        System.out.println("저글링 이름 : " + name);
        System.out.println("저글링 공격력 : " + power);
        System.out.println("저글링 체력 : " + hp);
    }
}

✔️ Marine 클래스

package com.startcraft_v02;
/**
 * ver02
 * 메서드 오버로딩 기법을 적용해서 코드를 설계해 보자.
 */
// 클래스 측, 실행 측
public class Marine {

    private String name;
    private int power;
    private int hp;

    public Marine(String name) {
        this.name = name;
        this.power = 4;
        this.hp = 70;
    }

    // read only --> getter
    public String getName() {
        return name;
    }

    public int getPower() {
        return power;
    }

    public int getHp() {
        return hp;
    }

    public void attack(Zealot zealot) {
        zealot.beAttacked(this.power);
        System.out.println(name + " 이 "+ zealot.getName() +"을 공격합니다 " );
    }

    public void attack(Zergling zergling) {
        zergling.beAttacked(this.power);
        System.out.println(name + " 이 " + zergling.getName() + "을 공격합니다 " );
    }

    public void beAttacked(int power) {
        if(this.hp <= 0 ) {
            System.out.println(name + " 이(가) 이미 사망하였습니다.");
            // 실행에 제어권을 반납하고 싶으면 키워드 !! (돌아가)
            return;
        }
        this.hp -= power;
        System.out.println(name + "이(가) 공격을 당합니다");
    }

    public void showInfo() {
        System.out.println("---------⭐상태창⭐----------");
        System.out.println("마린 이름 : " + name);
        System.out.println("마린 공격력 : " + power);
        System.out.println("마린 체력 : " + hp);
    }


} // end of class

✅ 추가 설명

오버로딩 vs 오버라이딩 비교

항목	오버로딩 (Overloading)	오버라이딩 (Overriding)
정의	같은 클래스 내에서 메서드를 여러 개 정의	부모 클래스의 메서드를 자식에서 재정의
조건	이름 같고 매개변수 다르면 가능	시그니처(이름, 매개변수, 반환형) 모두 같아야 함
시점	컴파일 타임 결정	런타임 시점에 동작 결정
키워드	없음	@Override 사용
예시 활용	System.out.println(), 생성자	상속 구조에서 다형성 활용

정리 표

내용 구분	설명
정의	같은 이름의 메서드를 매개변수만 다르게 정의하는 것
시그니처	이름 + 매개변수의 타입/개수/순서
반환형 포함 여부	포함되지 않음
대표 활용	계산기 기능, 전투 시스템, 생성자
장점	가독성 향상, 일관성 있는 이름 사용 가능

마무리하며

메서드 오버로딩은 실무에서 자주 사용되는 기본이자 강력한 문법입니다.
다양한 입력을 하나의 이름으로 처리함으로써 코드의 일관성을 높이고
유지보수에 유리한 구조를 만드는데 큰 역할을 합니다.

다음 글에서는 이와 자주 비교되는 메서드 오버라이딩과 함께,
객체지향의 핵심 개념인 다형성(Polymorphism) 까지 확장해 보겠습니다.

다음 글 예고 : 상속(Inheritance)

자바의 객체지향 핵심 개념 중 하나인 '상속'은
부모 클래스의 속성과 기능을 자식 클래스가 물려받아 재사용하는 구조입니다.
다음 글에서는 extends 키워드를 중심으로 상속의 기본 문법과 예제를 함께 살펴보겠습니다.

이전 글 보기

배열과 배열 예제가 궁금하다면??

2025.05.02 - [Java] - Array(배열)에 대한 이해

Array(배열)에 대한 이해

시작하며이번 글에서는 자바의 기본 자료구조 중 가장 핵심인배열(Array) 에 대해 자세히 배워봅니다.지난 글에서는 static 키워드를 통해 클래스 수준의 공유 데이터를 다뤘다면,이번에는 다

seohong.tistory.com

2025.05.03 - [Java] - 배열 복습하기 - 도서 관리 프로그램 (CRUD 실습)

배열 복습하기 - 도서 관리 프로그램 (CRUD 실습)

✍️ 시작하며지난 시간에는 자바의 기본 자료구조 중 하나인 **배열(Array)**에 대해 배웠습니다.이번 글에서는 배열을 활용해 도서 데이터를 관리하는 간단한 콘솔 프로그램을 만들어 보겠습니

seohong.tistory.com

배열 복습하기 - 도서 관리 프로그램 (CRUD 실습)

공돌이 출신 개발자 — Sat, 3 May 2025 21:52:47 +0900

✍️ 시작하며

지난 시간에는 자바의 기본 자료구조 중 하나인 **배열(Array)**에 대해 배웠습니다.
이번 글에서는 배열을 활용해 도서 데이터를 관리하는 간단한 콘솔 프로그램을 만들어 보겠습니다.
이를 통해 프로그래밍의 가장 기본이 되는 개념 중 하나인 CRUD도 자연스럽게 복습할 수 있습니다.

✅ CRUD란?

CRUD는 데이터 처리의 기본적인 네 가지 동작을 의미합니다.

C: Create (생성)
R: Read (조회)
U: Update (수정)
D: Delete (삭제)

이 개념은 웹, 앱, DB 등 모든 프로그래밍 영역에서 반복적으로 사용됩니다.
이번 실습에서는 배열과 클래스를 활용해 이 동작들을 직접 구현해볼 거예요.

학습 목표

배열을 이용한 도서 목록 관리 시스템 구현
자바의 객체 배열과 null 체크를 통한 방어적 코드 작성
while문 + switch 또는 if문을 이용한 메뉴 처리 흐름 익히기
static 변수와 메서드를 이용한 데이터 관리의 흐름 이해

1단계 - Book 클래스 만들기

도서 정보를 담을 Book 클래스를 먼저 정의합니다.

package books;

public class Book {
    private String title;
    private String author;

    // 생성자
    public Book(String title, String author) {
        this.title = title;
        this.author = author;
    }

    // getter 메서드
    public String getTitle() {
        return title;
    }

    public String getAuthor() {
        return author;
    }

    // 도서 정보 출력
    public void showInfo() {
        System.out.println(">> 책 정보 <<");
        System.out.println("제목 : " + title);
        System.out.println("저자 : " + author);
    }
}

설명
Book 클래스는 도서 정보를 표현하는 데이터 모델입니다.
생성자에서 제목과 저자를 받아 저장하고, getter를 통해 외부에서 접근할 수 있도록 했습니다.
showInfo()는 도서 정보를 깔끔하게 출력해주는 메서드입니다.

2단계 - 메인 클래스 설계

MyBookStore 클래스를 만들고, 콘솔 메뉴를 통해 사용자의 입력을 받아 기능을 실행하도록 구성합니다.

Scanner scanner = new Scanner(System.in);
Book[] books = new Book[100];
boolean flag = true;

while (flag) {
    System.out.println("1.저장 2.전체조회 3.선택조회 4.전체삭제 5.종료");
    String selectedNumber = scanner.nextLine();

    if (selectedNumber.equals("1")) {
        save(scanner, books);
    } else if (selectedNumber.equals("2")) {
        readAll(books);
    } else if (selectedNumber.equals("3")) {
        readByTitle(scanner, books);
    } else if (selectedNumber.equals("4")) {
        deleteAll(books);
    } else if (selectedNumber.equals("5")) {
        flag = false;
    }
}

✅ 메뉴를 선택하면 해당 기능이 호출되는 구조입니다.
사용자가 "1"을 입력하면 save()가 실행되고, "5"를 입력하면 프로그램이 종료됩니다.

3단계 - CRUD 기능 구현

Create - 도서 정보 저장

public static void save(Scanner scanner, Book[] books) {
    System.out.println("책 제목을 입력하세요:");
    String title = scanner.nextLine();
    System.out.println("저자를 입력하세요:");
    String author = scanner.nextLine();

    books[currentBookIndex] = new Book(title, author);
    currentBookIndex++;
}

✅ 사용자의 입력을 받아 Book 객체를 만들고 배열에 저장합니다.

Read - 전체 도서 목록 조회

public static void readAll(Book[] books) {
    for (int i = 0; i < books.length; i++) {
        if (books[i] != null) {
            System.out.println(books[i].getTitle() + ", " + books[i].getAuthor());
        }
    }
}

✅ 배열을 순회하며 등록된 도서만 출력합니다.

Read - 도서 제목으로 검색

public static void readByTitle(Scanner scanner, Book[] books) {
    System.out.println("책 제목 입력:");
    String title = scanner.nextLine().trim();
    boolean found = false;

    for (Book book : books) {
        if (book != null && book.getTitle().equals(title)) {
            System.out.println(book.getTitle() + ", " + book.getAuthor());
            found = true;
            break;
        }
    }

    if (!found) System.out.println("해당 책은 존재하지 않습니다.");
}

✅ 특정 제목을 가진 도서를 배열에서 검색합니다.

️ Delete - 전체 삭제

public static void deleteAll(Book[] books) {
    for (int i = 0; i < books.length; i++) {
        books[i] = null;
    }
}

✅ 배열의 모든 요소를 null로 초기화하여 도서를 논리적으로 삭제합니다.
저장된 도서 정보는 사라지며, readAll() 실행 시 출력되지 않습니다.

4단계 - 참조형 배열 활용 (BookTest1)

배열은 단순한 숫자만 저장하는 것이 아니라, 우리가 만든 클래스의 객체도 저장할 수 있습니다. Book 객체를 배열에 저장하고 활용하는 예제를 보며 배열의 특징을 정리해 봅시다.

public class BookTest1 {
    public static void main(String[] args) {
        // 배열 안에 요소는 기본형 또는 참조형일 수 있다.
        Book[] books = new Book[10]; // 길이는 10 (0~9)

        // 객체 저장
        books[0] = new Book("개발자가되고싶습니다.", "앨런");
        books[1] = new Book("무궁화꽃이피었습니다.", "김진명");
        books[2] = new Book("흐르는강물처럼.", "파울로코엘료");
        books[3] = new Book("리딩으로리드하라.", "이지성");
        books[4] = new Book("사피엔스.", "유발하라리");
        books[9] = new Book("홍길동전.", "허균");

        // 단일 요소 조회
        String title9 = books[9].getTitle();
        String author9 = books[9].getAuthor();

        System.out.println("title9: " + title9);
        System.out.println("author9: " + author9);

        // 반복문을 이용한 전체 조회 (null 방어)
        for (int i = 0; i < books.length; i++) {
            if (books[i] != null) {
                System.out.println(books[i].getTitle());
            }
        }
    }
}

✅ 참조형 배열은 우리가 만든 클래스의 인스턴스를 저장할 수 있습니다.
✅ 배열 전체 길이와 실제로 저장된 요소 수는 다를 수 있으므로 null 체크는 필수입니다.

배열의 특징과 한계 정리

항목	설명
고정 길이	한 번 생성된 배열의 길이는 변경할 수 없음
순차 저장	인덱스를 통해 빠르게 접근 가능
null 처리	비어있는 인덱스는 null이므로 방어적 코드 필요
참조형 저장	객체를 배열에 저장하여 구조적인 데이터 관리 가능

마무리하며

이번 실습을 통해 자바 배열과 객체를 활용하여 도서 관리 프로그램을 직접 구현해보았습니다.
배열은 단순한 숫자 저장을 넘어, 우리가 만든 객체 데이터를 체계적으로 관리할 수 있는 유용한 자료구조임을 확인할 수 있었죠.

특히, 이번 프로젝트에서는 프로그램의 핵심 개념인 CRUD를 실제 코드로 체험하며 그 동작 방식을 익힐 수 있었습니다.

다시 정리하면,

C (Create) : 도서를 배열에 추가
R (Read) : 저장된 도서를 전체 또는 선택적으로 조회
U (Update) : (선택적으로) 특정 도서 정보를 수정
D (Delete) : 배열 데이터를 null 처리하여 삭제

CRUD는 프로그래밍의 기본 중의 기본입니다. 반드시 기억해두세요!

다음 글 예고 : 메서드 오버로딩

다음 글에서는 자바의 중요한 문법 개념인
메서드 오버로딩(Method Overloading) 에 대해 다룹니다.
같은 이름의 메서드를 다양한 입력 방식으로 처리하는 방법을 함께 배워보세요!

이전 글 다시 보기

배열(Array)에 대해서 궁금하다면??

2025.05.02 - [Java] - Array(배열)에 대한 이해

Array(배열)에 대한 이해

seohong.tistory.com

Array(배열)에 대한 이해

공돌이 출신 개발자 — Fri, 2 May 2025 16:41:31 +0900

시작하며

이번 글에서는 자바의 기본 자료구조 중 가장 핵심인
배열(Array) 에 대해 자세히 배워봅니다.

지난 글에서는 static 키워드를 통해 클래스 수준의 공유 데이터를 다뤘다면,
이번에는 다수의 데이터를 효율적으로 저장하고 관리하기 위한
배열의 개념과 사용 방법을 실습 중심으로 정리합니다.

학습 목표

배열의 개념과 선언, 초기화 방법을 이해한다.
반복문과 함께 배열을 효율적으로 사용하는 방법을 익힌다.
문자(char), 문자열(String), 정수형(int), 실수형(double) 배열을 활용해본다.
배열 인덱스와 길이 차이를 이해한다.

1️⃣ 배열이란?

같은 타입의 데이터를 연속된 메모리 공간에 저장하는 자료구조입니다.
자바에서 배열은 객체로 간주되며, 크기가 고정되어 있고 인덱스를 통해 요소에 접근합니다.

int[] numbers = new int[3];  // 정수형 배열 선언 및 공간 3칸 확보

항목	설명
배열 선언 문법	타입[] 변수명 또는 타입 변수명[] 형태 모두 가능
크기 지정	new 키워드와 함께 크기를 지정해야 메모리에 공간이 할당됨
길이 확인	.length 속성을 통해 배열의 총 길이를 확인할 수 있음
인덱스 범위	인덱스는 항상 0부터 시작하며, 마지막 인덱스는 length - 1이 됨

2️⃣ 배열 선언과 다양한 초기화 방식

기본 선언 후 값 대입

int[] numbers = new int[3];  // 3개의 공간만 확보되고 값은 초기화되지 않음
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;

선언과 동시에 초기화

int[] grades = new int[] {1, 2, 3};
int[] grades2 = {1, 2, 3, 4, 5, 6}; // 더 축약된 표현

배열 초기화는 이렇게 다양한 형태로 가능합니다. 다만 new int[] {} 방식은 선언과 동시에만 사용 가능하다는 점에 주의!

3️⃣ 실수형 배열 연습

✅ 문제: 5개의 double 값을 담는 배열을 만들고 초기화하시오.

double[] doubles = new double[5];
doubles[0] = 1.0;
doubles[1] = 1.1;
doubles[2] = 1.2;
doubles[3] = 1.3;
doubles[4] = 1.4;

포인트

배열의 길이는 5지만, 마지막 인덱스는 4입니다.
배열.length는 전체 길이이며, 유효한 인덱스 범위는 0 ~ length-1

반복문 출력

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

4️⃣ String 배열과 출력 반복문

String[] stringBox = new String[3];
stringBox[0] = "가";
stringBox[1] = "나";
stringBox[2] = "다";

System.out.println(stringBox.length); // 3

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

문자열도 배열로 저장 가능하며, null 값이 들어가지 않도록 방어적 코드가 필요할 수 있습니다.

5️⃣ 문자(char) 배열과 아스키코드

✅ 문자 저장 및 ASCII 변환 확인

char[] alphabet = new char[26];
alphabet[0] = 'A';  // 정수값 65
alphabet[1] = 'B';

System.out.println((int)alphabet[0]); // 출력: 65
System.out.println((int)alphabet[1]); // 출력: 66

✅ 인코딩 vs 디코딩

개념	설명	예시
인코딩	문자를 숫자로 변환	(int)'A' → 65
디코딩	숫자를 문자로 변환	(char)66 → 'B'

알파벳 a ~ z 반복 출력

for(int i = 0; i < alphabet.length; i++) {
    alphabet[i] = (char)('a' + i);  // 97부터 시작
}

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

6️⃣ 정수 배열 + 랜덤 숫자 + 정렬

Random random = new Random();
int[] intBoxes = new int[6];

for (int i = 0; i < intBoxes.length; i++) {
    intBoxes[i] = random.nextInt(45) + 1;  // 1 ~ 45 사이의 수
}

정렬 후 출력

Arrays.sort(intBoxes); // 오름차순 정렬

for (int i = 0; i < intBoxes.length; i++) {
    System.out.printf(intBoxes[i] + "\t");
}

java.util.Arrays.sort()는 배열 정렬을 위한 유용한 메서드이며, 다양한 자료형에도 적용 가능

7️⃣ 문자열 배열 + 랜덤 인덱스 출력

String[] fruits = {"Apple", "Banana", "Orange", "Mango"};
Random random = new Random();

int choice = random.nextInt(4); // 0~3
System.out.println("오늘의 과일은 : " + fruits[choice]);

랜덤 인덱스를 통해 배열에서 무작위 값을 선택하는 실습으로, 배열과 Random 클래스를 함께 연습할 수 있습니다.

✅ 정리

구분	설명
배열 선언	타입[] 변수명 = new 타입[크기];
초기화 방법	선언 후 개별 할당 또는 {값, 값, ...} 축약
인덱스 시작	항상 0부터 시작, 끝은 length - 1
반복문 사용	for문을 통한 순회가 일반적
기타	.length, Arrays.sort(), Random 클래스 등과 함께 자주 활용

⏭️ 다음 글 예고 : 배열 복습(도서 관리 프로그램)

다음 글에서는 지금 배운 배열 개념을 활용하여
도서 관리 프로그램을 직접 만들어보며 배열과 반복문의 실전 감각을 키워볼 예정입니다.
CRUD(Create, Read, Update, Delete) 패턴을 배열로 어떻게 구현하는지 함께 학습해봅시다!

이전 글 바로가기

static 키워드에 대해서 궁금하다면??

2025.05.01 - [Java] - static 키워드에 대한 이해

static 키워드에 대한 이해

시작하며지금까지 우리는 객체 지향 프로그래밍에서 클래스와 인스턴스를 중심으로 학습을 진행해왔습니다.하지만 어떤 경우에는 객체마다 값이 달라질 필요 없이, 모든 객체가 공유하는

seohong.tistory.com

static 키워드에 대한 이해

공돌이 출신 개발자 — Thu, 1 May 2025 23:55:28 +0900

시작하며

지금까지 우리는 객체 지향 프로그래밍에서 클래스와 인스턴스를 중심으로 학습을 진행해왔습니다.
하지만 어떤 경우에는 객체마다 값이 달라질 필요 없이, 모든 객체가 공유하는 값이 필요한 상황도 있습니다.

이번 글에서는 그런 역할을 수행하는 static 키워드에 대해 알아보고,
어디에 쓰이고 왜 중요한지 예제를 통해 배워보겠습니다.

학습 목표

static 키워드의 의미와 역할을 이해한다
static 변수와 static 메서드의 차이를 배운다
static이 메모리에서 어떻게 관리되는지 개념을 익힌다
실제 예제를 통해 클래스 변수의 사용법을 익힌다

1️⃣ static이란?

static 키워드는 "고정된"이라는 뜻을 가지고 있으며,
자바에서는 **클래스에 고정된 멤버(변수나 메서드)**를 의미합니다.

✅ static 변수 = 클래스 변수

특징	설명
소속	클래스에 소속됨 (객체가 아닌 클래스에)
공유 여부	생성된 모든 객체가 같은 static 변수 하나를 공유
접근 방법	객체 없이도 클래스이름.변수명으로 바로 접근 가능
메모리 위치	Method Area(Class Area)에 저장됨

2️⃣ static이 필요한 상황

✔️ 여러 객체가 하나의 기준 값을 공유해야 할 때 사용합니다.

예를 들어,

학생마다 새로운 학번이 필요할 때
회사에서 사원이 입사할 때마다 새로운 사번이 필요할 때
카드회사가 새로운 카드를 발급할 때 고유 번호를 부여할 때
은행에서 여러 기기가 같은 대기번호 기준을 공유해야 할 때

3️⃣ static 변수 예제: 번호표 발급기

package com._static;

public class NumberPrinter {

    /**
     *  static 변수는, static 메서드는 객체 생성 없이 클래스 이름으로 바로 접근 가능 하다.
     *  왜? heap 메모리에 들어가기 위해서는 new 키워드와 생성자를 호출한 뒤
     *  동작할 수 있지만 method area 영역은 프로그램을 실행 시키면
     *  바로 메모리를 할당 받아 실행되는 영역이기 때문이다. 
     */

    private int id;
    // 멤버 변수 (NumberPrinter 소속된 변수)
    // public int waitNumber;

    // waitNumber <-- 멤버 변수가 아니라 class area 영역에 포함된다.
    public static int waitNumber; // static 변수 선언(클래스 변수)

    public NumberPrinter(int id) {
        this.id = id;
        this.waitNumber = 1;
    }

    // 번호표를 출력합니다.
    public void printWaitNumber() {
        System.out.println(id + " 기기에 대기 순번은 : " + waitNumber);
        waitNumber++;
    }

}

이 코드는 여러 대기표 기기(객체)가 하나의 waitNumber 변수를 공유해서
같은 기준의 대기 번호를 순서대로 출력하게 합니다.

정리

static 변수는 모든 객체들이 공유할 수 있는 변수 이다.

비공식 이름 static 메모리 
공식적인 이름 * Method area * Class area

4️⃣ static 변수 예제: 직원 ID 부여 시스템

package com._static;

public class Employee {
    private int employeeId;
    private String name; // 이름
    private String department; // 부서

    // 생성자
    public Employee(String name) {
        this.name = name;
        // 클래스 변수를 활용해보자. Company.empSerialNumber
        // 클래스 이름으로 접근할 수 있다.
        employeeId = Company.empSerialNumber;
        Company.empSerialNumber++;
        // employeeId = 1;
    }

    // getter
    public int getEmployeeId() {
        return employeeId;
    }

    public String getName() {
        return name;
    }

    public String getDepartment() {
        return department;
    }
}

package com._static;

public class Company {

    // 클래스 변수(static) → 모든 직원에게 공통으로 사용됨
    static int empSerialNumber = 1;

    public static void main(String[] args) {
        Employee e1 = new Employee("야스오");
        Employee e2 = new Employee("티모");
        Employee e3 = new Employee("샤코");
        Employee e4 = new Employee("홍길동");

        System.out.println("야스오: " + e1.getEmployeeId());
        System.out.println("티모: " + e2.getEmployeeId());
        System.out.println("샤코: " + e3.getEmployeeId());
        System.out.println("홍길동: " + e4.getEmployeeId());
    }
}

출력 결과: 각 직원에게 고유한 ID가 자동으로 부여됩니다.
클래스 변수 empSerialNumber는 모든 Employee 인스턴스가 공유합니다.

5️⃣ static 메서드

static 메서드는 객체 없이 클래스 이름으로 바로 호출할 수 있는 메서드입니다.

주의: static 메서드 안에서는 인스턴스 변수에 접근할 수 없습니다.

예제: 카드 고유번호 부여

public class Card2 {

    private static int cardCounter = 0; // 모든 객체가 공유하는 변수
    private final int cardId;
    private final String cardName;

    public Card2(String cardName) {
        this.cardName = cardName;
        this.cardId = ++cardCounter;
    }

    // static 메서드
    public static int getTotalCards() {
        return cardCounter;
    }

    public void showInfo() {
        System.out.println(cardName + "의 고유 번호는 " + cardId + "입니다.");
    }
}

public class CardMain {

    public static void main(String[] args) {
        // static 변수는 객체 생성전에 사용가능
        // static 메서드는 객체 생성전에 사용 가능
        // 사용하는 방법 (클래스의 이름으로 접근 가능하다)
        System.out.println(Card2.getTotalCards());
        // 인스턴스 메서드 일까 static 메서드 이다.
        // 그래서 객체 생성전에 호출해 볼 수 있다.
        Card2 c1 = new Card2("우리카드");
        Card2 c2 = new Card2("하나카드");

        c1.showInfo();
        c2.showInfo();

        System.out.println("총 발급된 카드 수: " + Card2.getTotalCards());
    }
}

6️⃣ static 변수와 메서드는 어디에 저장될까?

구분	저장 위치	특징
static 변수/메서드	Method Area (클래스 영역)	프로그램 시작 시 메모리 할당
인스턴스 변수/메서드	Heap (객체 영역)	객체 생성 시에만 메모리 할당됨

✨ 마무리하며

이번 글에서는

static 변수와 메서드가 왜 필요하고,
어떤 상황에서 사용하는지
어떻게 메모리에 저장되는지

를 예제와 함께 배웠습니다.

기억하세요!
static은 클래스에 고정된 값이고,
객체들끼리 공유하는 값입니다.
그래서 절대 함부로 인스턴스 상태를 변경하는 데 쓰면 안 돼요!

⏭️ 다음 글 예고: Array(배열)에 대한 이해

이번 글에서는 클래스 변수인 static 키워드를 통해
공유되는 데이터와 메모리 영역에 대해 배웠습니다.

이제부터는 자바에서 데이터를 더 효율적으로 저장하고 관리하는 방법,
즉 **자료구조(Data Structure)**에 대해 알아볼 차례입니다.

그 첫 걸음은 바로 **배열(Array)**입니다.

✔️ 배열이란 무엇일까?
✔️ 어떻게 선언하고 값을 넣을까?
✔️ 반복문과 함께 배열을 어떻게 활용할까?

다음 글에서는 배열의 기본 개념부터 실습 예제까지 탄탄하게 정리해드릴게요

이전 글 바로가기

this의 3가지 사용방법이 궁금하다면?

2025.04.29 - [Java] - this 3가지 사용 방법

this 3가지 사용 방법

시작하며지난 글에서는 **접근 제어 지시자(Access Modifier)**에 대해 배웠습니다.변수와 메서드의 접근 범위를 설정해 코드의 안정성과 보안성을 높였죠.이번 글에서는✔️ this 키워드의 개념,

seohong.tistory.com

this 3가지 사용 방법

공돌이 출신 개발자 — Wed, 30 Apr 2025 10:50:04 +0900

시작하며

지난 글에서는 **접근 제어 지시자(Access Modifier)**에 대해 배웠습니다.
변수와 메서드의 접근 범위를 설정해 코드의 안정성과 보안성을 높였죠.

이번 글에서는
✔️ this 키워드의 개념,
✔️ this의 3가지 주요 사용 방법,
✔️ 코드 예제
를 통해 this에 대해 확실히 이해해보겠습니다.

학습 목표

this 키워드의 3가지 사용 방법을 이해한다
생성자에서 this()를 활용하는 방법을 익힌다
객체 자신의 주소를 반환하거나 사용하는 상황을 학습한다

1️⃣ this란?

this는 클래스 내부에서 인스턴스(객체) 자신을 가리키는 키워드입니다.
주로 다음 세 가지 상황에서 사용됩니다.

구분	설명
1	인스턴스(객체) 자신의 메모리를 가리킬 때
2	생성자 내부에서 또 다른 생성자를 호출할 때
3	자신의 주소(참조값)를 반환할 때

2️⃣ this.를 이용해 멤버변수 구분하기

같은 이름의 지역변수와 멤버변수가 있을 때,
this를 이용해 멤버변수를 명확하게 가리킬 수 있습니다.

Person.java

package com._this;

public class Person {

    private String name;
    private int age;
    private String phone;
    private String gender; // F, M

    // this를 이용한 멤버변수 초기화
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("1번 생성자 호출 됨");
    }

    // 다른 생성자 호출(this())
    public Person(String name, int age, String phone) {
        this(name, age);
        this.phone = phone;
        System.out.println("2번 생성자 호출 됨");
    }

    public Person(String name, int age, String phone, String gender) {
        this(name, age, phone);
        this.gender = gender;
        System.out.println("3번 생성자 호출 됨");
    }
}

✅ 이 코드에서는 this.name = name 처럼,
멤버변수와 매개변수를 명확하게 구분하기 위해 this를 사용했습니다.

3️⃣ 생성자에서 this()로 다른 생성자 호출하기

생성자 안에서 this()를 사용하면
같은 클래스 안에 있는 다른 생성자를 호출할 수 있습니다.

PersonMainTest.java

package com._this;

public class PersonMainTest {

    public static void main(String[] args) {
        Person p1 = new Person("홍길동", 10, "010-1234-1234", "F");
    }
}

️ 실행 결과

1번 생성자 호출 됨
2번 생성자 호출 됨
3번 생성자 호출 됨

✅ this(name, age, phone)처럼 생성자 안에서 또 다른 생성자를 호출하고,
순차적으로 초기화가 이뤄지는 모습을 볼 수 있습니다.

4️⃣ UserInfo 클래스 예제 (this 활용 심화)

UserInfo.java

package com._this;

public class UserInfo {

    private String userId;
    private String userPassword;
    private String userName;
    private String userAddress;
    private String phoneNumber;

    public UserInfo(String userId) {
        System.out.println("1번 생성자 호출");
        this.userId = userId;
    }

    public UserInfo(String userId, String userPassword) {
        this(userId);
        System.out.println("2번 생성자 호출");
        this.userPassword = userPassword;
    }

    public UserInfo(String userId, String userPassword, String userName) {
        this(userId, userPassword);
        System.out.println("3번 생성자 호출");
        this.userName = userName;
    }

    public UserInfo(String userId, String userPassword, String userName, String userAddress) {
        this(userId, userPassword, userName);
        System.out.println("4번 생성자 호출");
        this.userAddress = userAddress;
    }

    public UserInfo(String userId, String userPassword, String userName, String userAddress, String phoneNumber) {
        this(userId, userPassword, userName, userAddress);
        System.out.println("마지막 5번 생성자 호출");
        this.phoneNumber = phoneNumber;
    }
}

✅ this()를 통해 생성자끼리 코드를 재사용하면서,
반복되는 초기화 코드를 줄이고 있는 것을 알 수 있습니다.

5️⃣ Student, Bus 예제 (this와 객체 간 상호작용)

Student.java

package com.oop1;

public class Student {

    private String name;
    private int money;

    public Student(String name, int money) {
        this.name = name;
        this.money = money;
    }

    public void takeBus(Bus bus) {
        bus.take(1500);
        this.money -= 1500;
    }

    public void showInfo() {
        System.out.println("학생 이름 : " + name);
        System.out.println("학생 소지금 : " + money);
    }
}

Bus.java

package com.oop1;

public class Bus {

    private int busNumber;
    private int count;
    private int money;

    public Bus(int busNumber) {
        this.busNumber = busNumber;
    }

    public void take(int money) {
        this.money += money;
        count++;
    }

    public void showInfo() {
        System.out.println("버스 번호 : " + busNumber);
        System.out.println("승객 수  : " + count);
        System.out.println("버스 수익금 : " + money);
    }
}

MainTest.java

package com.oop1;

public class MainTest {

    public static void main(String[] args) {

        Student s1 = new Student("티모", 10_000);
        Bus bus1 = new Bus(100);
        Bus bus2 = new Bus(133);

        s1.takeBus(bus2);

        s1.showInfo();
        System.out.println("-------------");
        bus2.showInfo();
    }
}

️ 실행 결과

학생 이름 : 티모
학생 소지금 : 8500
-------------
버스 번호 : 133
승객 수  : 1
버스 수익금 : 1500

✅ 객체 간 상호작용에서도 this를 사용해 객체 내부 상태를 수정하는 모습을 확인할 수 있습니다.

✨ 마무리하며

이번 글에서는
this 키워드가 무엇이고,
어디서 어떻게 사용하는지를 정리했습니다.

특히 생성자 안에서 this()를 호출하는 방식은
코드 중복을 줄이고, 생성자 체인(chain)을 만드는 데 매우 유용하니 꼭 기억해두세요.

⏭️ 다음 글 예고 : static 키워드 이해

다음 글에서는 static 키워드가 무엇인지, 왜 모든 객체가 공유할 수 있는지,
그리고 static 변수와 메서드가 어떤 상황에서 유용하게 쓰이는지를
실제 예제를 통해 알아보겠습니다.

이전 글 바로가기

접근 제어 지시자(Access Modifier)에 대해서 궁금하다면??

2025.04.29 - [Java] - 접근 제어 지시자(Access Modifier)

접근 제어 지시자(Access Modifier)

시작하며지난 글에서는 함수, 메서드, 생성자의 차이를 복습했습니다.이번 글에서는 **접근 제어 지시자(Access Modifier)**를 배워보겠습니다.접근 제어 지시자는 클래스나 멤버 변수, 메서드에

seohong.tistory.com

접근 제어 지시자(Access Modifier)

공돌이 출신 개발자 — Tue, 29 Apr 2025 15:54:41 +0900

시작하며

지난 글에서는 함수, 메서드, 생성자의 차이를 복습했습니다.
이번 글에서는 **접근 제어 지시자(Access Modifier)**를 배워보겠습니다.

접근 제어 지시자는 클래스나 멤버 변수, 메서드에 접근할 수 있는 범위를 결정하는 중요한 문법입니다.
객체지향 설계에서 아주 기본적이지만 꼭 필요한 개념입니다.

학습 목표

접근 제어 지시자의 종류와 특징을 이해한다
각 접근 제어 지시자의 사용 방법을 익힌다
캡슐화(정보은닉)를 위한 설계 방법을 배운다

1️⃣ 접근 제어 지시자란?

클래스, 변수, 메서드에 대해

"누가 어디까지 접근할 수 있는지"를 설명하는 키워드입니다.

주요 접근 제어 지시자

지시자	접근 범위 설명
public	어디서나 접근 가능
default	같은 패키지 내에서만 접근 가능
private	해당 클래스 내부에서만 접근 가능
protected	(상속을 배운 뒤 다룹니다)

가장 많이 사용하는 것은 public, private입니다.

2️⃣ Bank 클래스 예제

Bank.java

package com.access;

// Bank 클래스를 설계하는 측 코드
public class Bank {
    
    // public: 어디서나 접근 가능
    public String name;
    
    // default: 같은 패키지 내에서만 접근 가능
    int balance;
    
    // private: 오직 Bank 클래스 내부에서만 접근 가능
    private String number;
    
    public void showInfo() {
        System.out.println("현재 계좌 번호는 : " + number + " 입니다");
    }
}

✅ 위 코드를 보면, name, balance, number 각각 다른 접근 제어 지시자가 설정되어 있는 것을 볼 수 있습니다.

3️⃣ Account 클래스 설계 예제

Account.java

package com.access;

public class Account {

    private String name;
    private int balance;

    // getter 메서드
    public int getBalance() {
        return balance;
    }

    public String getName() {
        return name;
    }

    // setter 메서드
    public void setBalance(int b) {
        if (b < 0) {
            System.out.println("0 이하 값을 넣을 수 없습니다.");
        } else {
            balance = b;
        }
    }

    public void setName(String n) {
        name = n;
    }

    // 입금 메서드
    public void deposit(int money) {
        balance += money;
    }

    // 출금 메서드
    public void withdraw(int money) {
        balance -= money;
    }

    // 현재 잔액 출력
    public void showInfo() {
        System.out.println("현재 계좌 잔액은 : " + balance + " 입니다");
    }
}

✅ balance와 name 변수를 private로 선언하여 외부 직접 접근을 차단하고, 대신 메서드를 통해 간접적으로 접근하게 만들었습니다.

4️⃣ AccountTest 클래스 (접근 제어 필요성)

AccountTest.java

package com.access;

public class AccountTest {

    public static void main(String[] args) {

        Account account = new Account();
        account.deposit(10_000);
        account.withdraw(6_000);
        account.showInfo();

        // 과거: 직접 접근 (문제점 발생 가능성)
        // account.balance = 10_000;  // 이런 직접 접근은 위험

        // 현재: 메서드를 통해서만 접근 가능 (캡슐화)
        account.showInfo();
    }
}

5️⃣ .(dot) 연산자 연결 예제

객체 간 연결을 통해 내부 기능을 호출하는 예제를 살펴봅니다.

A.java

package com.dot;

public class A {

    B b;

    public A() {
        System.out.println("A 생성자 호출");
        b = new B();
    }
}

B.java

package com.dot;

public class B {

    C c;

    public B() {
        // 생성자
    }
}

C.java

package com.dot;

public class C {

    public void callFinal() {
        System.out.println("callFinal() 메소드가 호출 되었다.");
    }
}

MainTest.java

package com.dot;

public class MainTest {

    public static void main(String[] args) {
        System.out.println(" . 연산자의 여행!!! ");

        A a1 = new A();

        a1.b.c.callFinal();
    }
}

️ 실행 결과

. 연산자의 여행!!!
A 생성자 호출
callFinal() 메소드가 호출 되었다.

✅ a1.b.c.callFinal() 처럼 객체 → 객체 → 객체 식으로 연결하며 최종 메서드까지 접근하는 것을 볼 수 있습니다.

✨ 마무리하며

이번 글에서는
접근 제어 지시자란 무엇이고,
public, default, private 지시자가 각각 어떻게 적용되는지를 학습했습니다.

캡슐화를 통해 실수나 잘못된 접근을 막고,
코드를 더 안전하고 견고하게 만들 수 있다는 점을 기억하세요.

⏭️ 다음 글 예고 : this 키워드

다음 글에서는 this 키워드가 무엇이고,
this의 3가지 사용 방법(자기자신 가리키기, 다른 생성자 호출하기, 주소 반환하기)에 대해 배워보겠습니다.

다양한 예제와 함께 this 키워드를 확실히 이해해봅시다!

이전 글 바로가기

함수,메서드,생성자가 궁금하다면??

2025.04.28 - [Java] - 함수, 메서드, 생성자 복습

함수, 메서드, 생성자 복습

시작하며지난 글에서는 객체를 초기화하는 **생성자(Constructor)**에 대해 배웠습니다.생성자는 객체가 생성될 때 처음으로 호출되어 초기값을 설정해주는 역할을 했었죠.이번 글에서는✔️

seohong.tistory.com

함수, 메서드, 생성자 복습

공돌이 출신 개발자 — Mon, 28 Apr 2025 23:46:11 +0900

시작하며

지난 글에서는 객체를 초기화하는 **생성자(Constructor)**에 대해 배웠습니다.
생성자는 객체가 생성될 때 처음으로 호출되어 초기값을 설정해주는 역할을 했었죠.

이번 글에서는
✔️ 함수(Function),
✔️ 메서드(Method),
✔️ 생성자(Constructor)
이 세 가지를 함께 복습하면서 각각의 차이점을 깔끔하게 정리해보겠습니다.

학습 목표

함수와 메서드의 차이를 이해한다
생성자의 역할을 다시 복습한다
각각의 개념을 코드와 함께 명확히 구분할 수 있다

1️⃣ 함수(Function)

함수란?

함수는 데이터를 입력받아 연산을 수행하고 결과를 반환하는 코드 블록입니다.
static 키워드를 붙이면 객체를 생성하지 않고 호출할 수 있습니다.

예제 코드

package com.function;

/**
 * 함수란? 데이터를 받아서 처리하고 결과를 돌려주는 코드 블록이야.
 * static 을 사용하면 객체 없이 바로 호출 가능 해!
 */
public class CalculatorMain {

    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 5;
        int testNumber = 7;

        int sum = add(num1, num2);
        int difference = subtract(num1, num2);
        int product = multiply(num1, num2);
        double quotient = divide(num1, num2);
        boolean odd = isOdd(testNumber);
        boolean even = isEven(testNumber);

        System.out.println(num1 + " + " + num2 + " = " + sum);
        System.out.println(num1 + " - " + num2 + " = " + difference);
        System.out.println(num1 + " * " + num2 + " = " + product);
        System.out.println(num1 + " / " + num2 + " = " + quotient);
        System.out.println(testNumber + "은(는) 홀수인가요? " + odd);
        System.out.println(testNumber + "은(는) 짝수인가요? " + even);
    }

    static int add(int a, int b) { return a + b; }
    static int subtract(int a, int b) { return a - b; }
    static int multiply(int a, int b) { return a * b; }
    static double divide(int a, int b) {
        if (b == 0) {
            System.out.println("0으로 나눌 수 없습니다.");
            return 0;
        }
        return (double) a / b;
    }
    static boolean isEven(int number) { return number % 2 == 0; }
    static boolean isOdd(int number) { return number % 2 != 0; }
}

️ 실행결과

10 + 5 = 15
10 - 5 = 5
10 * 5 = 50
10 / 5 = 2.0
7은(는) 홀수인가요? true
7은(는) 짝수인가요? false

✅ 이 코드를 보면, 함수를 통해 다양한 연산 작업을 수행하고 있는 걸 알 수 있습니다.

2️⃣ 메서드(Method)

메서드란?

메서드는 클래스 내부에 작성된 함수입니다.
객체의 속성(멤버 변수)을 변경하거나, 객체가 수행할 동작을 정의합니다.

예제 코드

package com.method;

/**
 * 메서드 연습
 * 메서드란? 객체에 소속된 함수로, 클래스의 상태(데이터)를 활용하거나 객체와 관련된
 * 작업을 처리할 때 사용한다 
 */
public class CoffeeMachine {

    int water;
    int coffee;

    public void refillWater(int amount) {
        if (amount > 0) {
            water += amount;
            System.out.println(amount + "ml의 물을 채웠습니다");
        } else {
            System.out.println("0보다 큰 양의 물을 채워주세요");
        }
    }

    public void refillCoffee(int amount) {
        if (amount > 0) {
            coffee += amount;
            System.out.println(amount + "g의 커피 원두를 채웠습니다");
        } else {
            System.out.println("0보다 큰 양의 원두를 채워주세요");
        }
    }

    public String makeCoffee() {
        if (water >= 100 && coffee >= 10) {
            water -= 100;
            coffee -= 10;
            return "맛있는 커피 한 잔 완성";
        } else {
            return "재료가 부족해요! 물이나 원두를 채워주세요";
        }
    }

    public CoffeeMachine() {}

    public CoffeeMachine(int w, int c) {
        water = w;
        coffee = c;
    }
}

️ 실행 결과

200ml의 물을 채웠습니다
30g의 커피 원두를 채웠습니다
-----------------
커피 주문!
맛있는 커피 한 잔 완성
또 커피 주문!
맛있는 커피 한 잔 완성
마지막 커피 주문
재료가 부족해요! 물이나 원두를 채워주세요

✅ 이 코드를 보면, 메서드를 통해 객체의 상태를 조작하고 동작을 수행하는 모습을 알 수 있습니다.

3️⃣ 생성자(Constructor)

생성자란?

생성자는 객체를 생성할 때 자동으로 호출되는 특별한 메서드입니다.
주로 객체의 초기값을 설정하거나 필요한 준비 작업을 처리합니다.

✅ 생성자의 특징

특징	설명
이름이 클래스와 같아야 한다	public CoffeeMachine() {...}
반환 타입이 없다	void조차 쓰지 않는다
객체 생성 시 자동 호출된다	new CoffeeMachine();

생성자 오버로딩을 통해 다양한 형태의 객체 초기화도 가능합니다.

✨ 마무리하며

이번 글에서는
함수, 메서드, 생성자 각각의 개념을 복습하고,
예제 코드를 통해 구체적으로 어떻게 사용하는지 확인했습니다.

특히 함수와 메서드는 비슷해 보이지만,
메서드는 객체 소속이라는 점이 다르다는 것을 기억해두세요.

⏭️ 다음 글 예고 : 접근 제어 지시자(access modifier)

다음 글에서는

접근 제어 지시자(access modifier) 에 대해 자세히 정리해보겠습니다.

이전 글 바로가기

생성자(Constructor) 란??

2025.04.23 - [Java] - 생성자(Constructor)란?

생성자(Constructor)란?

시작하며지난 글에서는 객체의 행동(기능)을 표현하는 **메서드(Method)**에 대해 배웠습니다.객체는 속성(멤버 변수)과 행동(메서드)을 가지며,이 속성들에 처음 어떤 값이 들어갈지를 설정해

seohong.tistory.com

생성자(Constructor)란?

공돌이 출신 개발자 — Sun, 27 Apr 2025 16:29:43 +0900

시작하며

지난 글에서는 객체의 행동(기능)을 표현하는 **메서드(Method)**에 대해 배웠습니다.
객체는 속성(멤버 변수)과 행동(메서드)을 가지며,
이 속성들에 처음 어떤 값이 들어갈지를 설정해주는 게 바로 **생성자(Constructor)**입니다.

이번 글에서는
✔️ 생성자의 기본 개념,
✔️ 기본 생성자와 사용자 정의 생성자,
✔️ 생성자 오버로딩까지
예제와 함께 깔끔하게 정리해보겠습니다.

학습 목표

기본 생성자와 사용자 정의 생성자의 차이를 이해한다
생성자의 역할과 규칙을 학습한다
생성자 오버로딩이 무엇인지 알고 직접 활용해본다

1️⃣ 생성자(Constructor)란?

생성자는

객체를 생성할 때 자동으로 호출되는 특별한 메서드입니다.

객체가 생성될 때
필요한 초기값을 설정하거나, 필요한 초기화 작업을 처리합니다.

✅ 생성자의 특징

특징	설명
이름이 클래스와 동일해야 한다	public Bus { ... }
반환 타입이 없다	void조차 쓰지 않는다
객체 생성 시 new 키워드와 함께 호출	new Bus();
기본 생성자와 사용자 정의 생성자 존재	직접 만들 수도 있고, 안 만들면 자동 생성됨

2️⃣ 기본 생성자 (default constructor)

생성자를 작성하지 않아도 자동으로 만들어짐
아무 매개변수도 없는 형태

public class Student {
    // 기본 생성자 (자동 생성됨)
    public Student() {
        // 아무 코드 없어도 존재함
    }
}

클래스에 생성자가 하나도 없으면, 컴파일러가 기본 생성자를 자동 추가해줍니다.

3️⃣ 사용자 정의 생성자 (Overloaded Constructor)

직접 생성자 코드를 작성해서
객체 생성 시 초기값을 강제하거나, 유연하게 설정할 수 있습니다.

예제 코드

package ch09;

public class Bus {

    // 속성
    int busId;  // 버스 ID
    String busType; // 버스 종류 (시내버스, 고속버스)
    String company; // 운영 회사

    // 생성자가 여러가 있으면 생성자 오버로딩이라 한다.

    // 매개변수 1 받는 생성자
    public Bus(int id) {
        busId = id;
    }

    public Bus(int id, String type) {
        busId = id;
        busType = type;
    }

    public Bus(int id, String type, String com) {
        busId = id;
        busType = type;
        company = com; 
    }

    // 메서드
    public void showInfo() {
        System.out.println("-----상태창------");
        System.out.println("버스 ID : " + busId);
        System.out.println("버스 type : " + busType);
        System.out.println("버스 company : " + company);
    }

}

4️⃣ 생성자 호출 예제

package ch09;

public class BusMainTest {

    public static void main(String[] args) {

        // 객체 생성과 동시에 초기값 설정
        Bus b1 = new Bus(133, "시내버스", "텐코");

        // 객체의 상태 확인
        b1.showInfo();
    }
}

실행 결과 예시

----- 상태창 ------
버스 ID : 133
버스 type : 시내버스
버스 company : 텐코

✅ 생성자의 목적:
→ 객체 생성 시 초기값을 꼭 넣게 만들기 (강제성 부여!)
→ 생성과 동시에 필요한 설정을 할 수 있음

5️⃣ 생성자 오버로딩이란?

같은 이름의 생성자를 여러 개 만들 수 있는데,
매개변수의 개수나 타입이 다르면 가능!

public Bus(int id) { ... }
public Bus(int id, String type) { ... }
public Bus(int id, String type, String com) { ... }

→ 이렇게 여러 개의 생성자를 만들어두면,
→ 상황에 따라 필요한 생성자를 선택해서 사용할 수 있어요.

✨ 마무리하며

이번 글에서는

생성자가 무엇인지,
기본 생성자와 사용자 정의 생성자의 차이,
생성자 오버로딩에 대해 배웠습니다.

생성자는 객체가 생성될 때 가장 먼저 호출되어
객체가 올바르게 사용될 수 있도록 준비시켜줍니다.

객체 설계 시 반드시 알아야 할 기본 중 기본이니 꼭 익혀두세요

⏭️ 다음 글 예고 : 메서드, 생성자 복습

지금까지 배운

함수
메서드
생성자

이 세 가지는 헷갈리기 쉬운 개념이죠.
다음 글에서는

"이 셋은 어떻게 다르고, 각각 어디에 쓰이는 걸까?"
깔끔하게 정리해보면서 복습해보겠습니다.

이전 글 바로가기

메서드(Method)란 뭘까??

2025.04.23 - [분류 전체보기] - 메서드(Method)란 뭘까?

항목	설명
포함 관계	한 클래스가 다른 클래스를 필드로 포함하는 관계
대표 표현	“has-a” 관계
생명주기	포함된 객체는 소유 객체와 함께 생성/소멸됨
구현 방법	필드로 선언 후 생성자 또는 내부에서 인스턴스화
UML 표현	채워진 다이아몬드(◆) 사용
사용 예시	자동차 → 엔진, 집 → 방, 회사 → 부서 등