[250306] JAVA 기본 - 객체지향 프로그래밍(OOP): 다형성(polymorphism)과 캡슐화(encapsulation)

 

자바의 객체지향프로그래밍을 이해할 때 중요한 개념으로 꼽히는 것이 네가지 있다. 

 

1. 클래스

2. 상속

3. 다형성

4. 캡슐화 

 

이중에서 클래스와 상속은 지난 게시글들을 통해 다루어봤으니

오늘은 다형성과 캡슐화에 대해 정리하는 시간을 가져보자.  

 

 

먼저, 📌 다형성(polymorphism)이란? 

- Polymorphism = Poly (많은, 여러 개) + Morphism (형태, 구조)
즉, 여러 가지 형태를 가질 수 있다는 의미로 자바의 다형성 개념에서는

- 같은 메서드(또는 인터페이스) 가 서로 다른 객체에서 다르게 동작할 수 있는 것을 의미한다.

- 같은 부모 클래스를 가진 객체가 여러 형태(다양한 타입)로 동작할 수 있는 것
- 자식 클래스가 부모 클래스의 타입으로 참조될 수 있음 (Bicycle myBike = new MountainBike();)

- "부모 타입으로 자식을 다루고 오버라이딩을 활용하는 것"

 

 

 

 

다형성(polymorphism) 예제 

// 부모 클래스 
class Animal {
    void makeSound() {
        System.out.println("Some sound...");
    }
}


// 자식 클래스 1 - dog 
class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Bark! Bark!");
    }
}


// 자식 클래스 2 - cat 
class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Meow! Meow!");
    }
}


// 메인 메소드 
public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

		// 같은 메소드를 두개의 클래스에서 다르게 구현하였다. 
        myDog.makeSound();  // 출력: Bark! Bark!
        myCat.makeSound();  // 출력: Meow! Meow!
    }
}

 

- Animal 클래스의 makeSound() 메서드를 상속 받은 Dog, Cat 클래스에서 각각 오버라이딩(재정의) 함. 

- 여기서 중요한 것은, Dog과 Cat 의 타입이 부모 클래스 타입임

- 동일한 makeSound() 메서드를 호출해도 객체 타입에 따라 다른 결과가 나온다. 

- 다형성의 핵심은 오버라이딩(Overriding) 과 인터페이스(interface) 활용

- 부모 타입으로 자식 객체를 다루면서 오버라이딩된 메서드를 실행하는 것이 다형성의 핵심!

 

 

📌 캡슐화(encapsulation) 란?

Encapsulation = En-(안에) + Capsule(캡슐) + -ation(명사형 접미사)

즉, 캡슐 안에 가둠, 포장함, 감싸서 보호함이라는 의미를 갖고 있음 

프로그래밍에서는 객체의 데이터(필드)를 외부에서 직접 접근하지 못하도록 감싸는 것을 의미하며

필요한 메서드를 통해서만 데이터 변경이 가능하도록 제한하는 것을 말한다. 

 

-자바에서는, 객체의 필드를 직접 접근하지 못하도록 private 키워드를 추가한 뒤 데이터에 안전하게 접근하도록 getter/setter 를 제공하거나, 메서드를 제공한다. 

- 캡슐화의 핵심은 데이터를 보호하고, 안전한 접근 방식을 제공한다. 

 

 

캡슐화(Encapsulation) 예제 

class BankAccount {
    private int balance = 0;  // 직접 접근 불가능 (private)

    // balance 값을 변경하는 메서드 (setter)
    public void deposit(int amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println(amount + "원이 입금되었습니다.");
        } else {
            System.out.println("올바른 금액을 입력하세요.");
        }
    }

    // balance 값을 읽는 메서드 (getter)
    public int getBalance() {
        return balance;
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        account.deposit(1000);
        System.out.println("현재 잔액: " + account.getBalance());
    }
}

 

 

 

---

 

위 내용을 지피티한테 먼저 물어봐서 개념을 다시 한번 머리에 넣고

공식문서 읽는 버릇을 들이기 위해 공식 문서를 찾아봤다 

 

 

다형성(polymorphism)

 

📝공식 문서 내용 정리 

다형성(Polymorphism)은 생물학에서 하나의 종이나 개체가 여러 다른 형태를 가질 수 있는 특성을 의미한다. 

Java 같은 언어에서 부모 클래스의 기능을 공유하면서도, 각 자식 클래스가 고유한 동작을 정의할 수 있도록 하는 원리

+ 자식 클래스에서 부모 클래스의 메소드를 오버라이딩 해야함. 

 

예제1 - 부모 클래스 (Bicycle) 

public class Bicycle {
    private int gear;
    private int cadence;
    private int speed;

    public Bicycle(int startCadence, int startSpeed, int startGear) {
        this.cadence = startCadence;
        this.speed = startSpeed;
        this.gear = startGear;
    }

    public void printDescription() {
        System.out.println("\nBike is in gear " + this.gear
                + " with a cadence of " + this.cadence +
                " and travelling at a speed of " + this.speed + ".");
    }
}

 

 

 

 

예제2 - 자식 클래스 (MountainBike) 

public class MountainBike extends Bicycle {
    private String suspension;

    public MountainBike(int startCadence, int startSpeed, int startGear, String suspensionType) {
        super(startCadence, startSpeed, startGear);
        this.setSuspension(suspensionType);
    }

    public String getSuspension(){
      return this.suspension;
    }

    public void setSuspension(String suspensionType) {
        this.suspension = suspensionType;
    }

	@Override
    public void printDescription() {
        super.printDescription(); // 부모 클래스의 메서드 호출
        System.out.println("The MountainBike has a " + getSuspension() + " suspension.");
    }
}

 

✅ MountainBike 클래스 생성자에 this.setSuspension(suspensionType); 를 추가해서 클래스가 생성될 때 사용자가 입력한 값이 private 변수인 suspension 에 바로 적용되도록 함. 

✅ 오버라이딩 내용: 부모 클래스의 printDescription()을 MountainBike의 printDescription() 안에서 '호출', 즉 자식 클래스의 printDescription 안에서 부모 클래스의 printDescription 를 '실행'

✅ 오버라이딩 목적: 기본 자전거(Bicycle)와 동일한 기능을 가지면서도, "MountainBike에는 어떤 서스펜션이 있는지"를 추가로 출력하도록 printDescription()을 오버라이딩

💡알아둘 것은 !!! 부모 클래스와 메서드 이름, 매개변수, 반환 타입이 같음 → 오버라이딩 성립된다 !!!!

 

 

 

예제3 - 자식 클래스 (RoadBike) 

public class RoadBike extends Bicycle {
    private int tireWidth; // 타이어 너비 (mm 단위)

    public RoadBike(int startCadence, int startSpeed, int startGear, int newTireWidth) {
        super(startCadence, startSpeed, startGear);
        this.setTireWidth(newTireWidth);
    }

    public int getTireWidth() {
        return this.tireWidth;
    }

    public void setTireWidth(int newTireWidth) {
        this.tireWidth = newTireWidth;
    }

    @Override
    public void printDescription() { // 오버라이딩된 메서드
        super.printDescription(); // 부모의 printDescription() 실행
        System.out.println("The RoadBike has " + getTireWidth() + " MM tires.");
    }
}

 

✅ 위 내용과 동일 !! 

✅ tireWidrh 타이어 넓이를 나타내는 변수를 추가적으로 생성해 printDescription 메서드를 오버라이딩한 뒤 출력한다. ! 

 

이제 정의한 클래스들을 출력해보자 !! 

 

예제4 - 메인클래스 

public class TestBikes {
    public static void main(String[] args) {
        Bicycle bike01, bike02, bike03;

        bike01 = new Bicycle(20, 10, 1);         // 일반 자전거 객체
        bike02 = new MountainBike(20, 10, 5, "Dual"); // 산악 자전거 객체
        bike03 = new RoadBike(40, 20, 8, 23);    // 도로용 자전거 객체

        bike01.printDescription();
        bike02.printDescription();
        bike03.printDescription();
    }
}

 

 

출력 결과 

Bike is in gear 1 with a cadence of 20 and travelling at a speed of 10.

Bike is in gear 5 with a cadence of 20 and travelling at a speed of 10.
The MountainBike has a Dual suspension.

Bike is in gear 8 with a cadence of 40 and travelling at a speed of 20.
The RoadBike has 23 MM tires.

 

✅ 부모 클래스(Bicycle) 타입의 변수에 여러 자식 클래스(MountainBike, RoadBike)의 객체를 할당할 수 있다.

✅ 각각 객체 타입에 맞는 printDescription 메서드가 실행된다. 

 

JVM은 실제 객체의 타입을 기준으로 메서드를 호출한다

• 변수의 타입이 Bicycle이지만, 실제 객체가 MountainBike 또는 RoadBike라면 해당 클래스의 오버라이딩된 메서드가 실행된다.
• 이런 동작을 "가상 메서드 호출(Virtual Method Invocation)"이라고 한다.
• 즉, JVM은 변수의 선언된 타입(Bicycle)이 아니라, 실제 객체의 타입(MountainBike, RoadBike)을 기준으로 메서드를 실행한다.

 

다음에 추가할 것 

업캐스팅(Upcasting)과 다운캐스팅(Downcasting) 개념 

• Bicycle myBike = new MountainBike(); (업캐스팅)
• MountainBike realBike = (MountainBike) myBike; (다운캐스팅)

 

오버라이딩과 오버로딩 차이점 

• 오버라이딩(Overriding) ≠ 오버로딩(Overloading)
• 오버로딩은 같은 이름이지만 매개변수가 다름, 오버라이딩은 부모 메서드를 재정의하는 것

 

 

 

캡슐화(Encapsulation)

 

📝공식 문서 내용 정리 

캡슐화(Encapsulation)란?

데이터를 보호하고, 직접 접근을 차단하여 잘못된 데이터 변경을 방지하는 기법

private 멤버 변수 + public 메서드(getter, setter)를 통해 접근

직접 변수 값을 수정하지 못하게 하고, 메서드를 통해서만 변경 가능하도록 제한

 

 

먼저, 

자바에서 변수를 선언하는 방법에는 여러 가지가 있다!

다음은 변수의 종류이다

1️⃣ 멤버 변수 (fields) → 클래스 내부에서 선언된 변수
2️⃣ 지역 변수 (local variables) → 메서드나 코드 블록 안에서 선언된 변수
3️⃣ 매개변수 (parameters) → 메서드 선언에서 전달받는 변수

 

자바에서는 접근 제한자(public, private 등)를 사용하여 클래스 외부에서 특정 변수(필드)나 메서드에 접근할 수 있는 범위를 제어할 수 있다.
일반적으로 캡슐화(Encapsulation)의 원칙을 지키기 위해 멤버 변수는 private으로 선언하고, public 메서드를 통해 접근하는 것이 일반적이다.

 

예제1 - private 접근 제한자 사용하여 클래스 멤버 변수 선언 

public class Bicycle {
        
    private int cadence;
    private int gear;
    private int speed;
}

 

✅ 멤버 변수를 private으로 설정하면 외부 클래스에서 직접 접근할 수 없음
✅ 하지만 private 변수에 접근하기 위한 getter와 setter 메서드를 추가하면 값을 조작할 수 있음

 

getter & setter 사용 이유

• 직접 변수 접근을 막고, 안전한 방법으로 값을 읽거나 변경하기 위해 사용
• get변수명(), set변수명(값) 형식으로 사용

 

 

예제2- 캡슐화를 적용한 Bicycle 클래스 

public class Bicycle {
        
    private int cadence;
    private int gear;
    private int speed;
        
    public Bicycle(int startCadence, int startSpeed, int startGear) {
        gear = startGear;
        cadence = startCadence;
        speed = startSpeed;
    }
        
    // Getter & Setter 메서드 (캡슐화)
    public int getCadence() {
        return cadence;
    }
        
    public void setCadence(int newValue) {
        cadence = newValue;
    }
        
    public int getGear() {
        return gear;
    }
        
    public void setGear(int newValue) {
        gear = newValue;
    }
        
    public int getSpeed() {
        return speed;
    }
        
    public void applyBrake(int decrement) {
        speed -= decrement;
    }
        
    public void speedUp(int increment) {
        speed += increment;
    }
}

 

 

 + 변수 타입(자료형)

• 자바의 모든 변수는 자료형(type)을 가져야 한다.
• 기본 타입(Primitive Type): int, float, boolean 등
• 참조 타입(Reference Type): String, 배열(Array), 객체(Object) 등

 

+  네이밍 규칙 

✅ 모든 변수명, 필드명, 메서드명은 자바의 네이밍 규칙을 따라야 한다.
✅ 클래스명: PascalCase (대문자로 시작, 단어 연결 시 대문자로 구분)
✅ 변수명, 메서드명: camelCase (소문자로 시작, 단어 연결 시 대문자로 구분)

 

 

 

다음에 추가할 것 

- "왜 캡슐화를 해야 하는가?"에 대한 실용적인 예제

(ex. setSpeed() 메서드에 값 검증(Validation) 로직을 추가해서, 잘못된 값이 들어가는 걸 막는 예제 )

 

---

 

 

Oracle Java 튜토리얼 문서 좌표 

1. 다형성(Polymorphism)

https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html 

Polymorphism (The Java™ Tutorials > Learning the Java Language > Interfaces and Inheritance)

 

2. 캡슐화(Encapsulation) 

https://docs.oracle.com/javase/tutorial/java/javaOO/variables.html 

Declaring Member Variables (The Java™ Tutorials > Learning the Java Language > Classes and Objects)

(공식 문서에 있는 내용은 워낙 내용이 방대하고 많다보니 이게 다가 아닐 것이다? )

 

 

Oracle Java 튜토리얼에서는 다형성(Polymorphism)과 캡슐화(Encapsulation) 가 다른 카테고리로 분류되어 있다. 

 

둘 다 객체지향프로그래밍(OOP) 의 주요 개념이지만 

위에서 본 것처럼 다형성은  상속(Inheritance)과 인터페이스(Interfaces) 개념과 밀접하게 연결되어 있고 

캡슐화(Encapsulation)는 객체 내부 데이터를 보호하는 개념이므로 클래스와 객체 개념을 설명하는 부분에서 다뤄진다.