[JAVA]클래스, 상속, 캡슐화, 다형성 등

클래스와 객체

 

- 클래스는 객체의 설계도이며, 객체는 그 설계도를 바탕으로 메모리에 실제로 생성된 인스턴스입니다.

클래스는 변수(속성)와 메서드(기능)를 정의한 틀로, 실제 데이터와 동작을 정의합니다. 객체는 클래스를 바탕으로 생성된 실체이며, 그 클래스에서 정의한 속성과 메서드를 가집니다. 클래스를 정의하고 객체를 생성하는 과정에서 인스턴스화가 일어납니다.

 

class Car { // 'Car' 클래스 정의
    String color; // 'color' 속성, 객체의 색상
    void drive() { // 'drive' 메서드, 자동차를 운전하는 기능
        System.out.println("The car is driving."); // 자동차가 운전 중임을 출력
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car(); // 'Car' 클래스의 객체 'myCar' 생성
        myCar.color = "Red"; // 'myCar' 객체의 color 속성에 'Red' 값 할당
        myCar.drive(); // 'myCar' 객체의 'drive' 메서드 호출
    }
}

 

 

JVM 메모리 영역

JVM 메모리는 크게 4가지 영역으로 나뉩니다: 메서드 영역, 힙 영역, 스택 영역, 프로그램 카운터(PC) 레지스터.

 

• 메서드 영역: 클래스와 메서드 정보, 정적 변수들이 저장됩니다.
• 힙 영역: 객체가 동적으로 할당되는 곳입니다.
• 스택 영역: 메서드 호출 시 생성되는 로컬 변수, 메서드 반환 값 등이 저장됩니다.
• PC 레지스터: 현재 실행 중인 JVM 명령어의 주소를 저장합니다.

https://cscircles.cemc.uwaterloo.ca/java_visualize/

Java Visualizer

 

위 사이트에서 아래 코드를 넣고 흐름을 읽어봅시다.

public class Main {
    static class Person {

        // 1. 속성
        String name;
        int age;
        String address;

        // 2. 생성자
        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        // 3-1. 소개 기능(이름 나이 출력 기능)
        void introduce() {
            System.out.println("나의 이름은");
            System.out.println(this.name + "입니다.");
            System.out.println("나의 나이는");
            System.out.println(this.age + "입니다.");
        }

        // 3-2. 더하기 기능(소개를 하고 더하기 연산 수행)
        int sum(int value1, int value2) {
            introduce();
            int result = value1 + value2;
            return result;
        }
    }

    public static void main(String[] args) {
        String name = "Steve";
        int age = 20;
        Person personA = new Person(name, age);
        personA.introduce();

        int value1 = 1;
        int value2 = 2;

        int ret = personA.sum(value1, value2);
        System.out.println(ret);
    }
}

 

 

 

레퍼클래스 (기본형 참조형)

자바에서 기본형 데이터 타입은 값이 저장되는 방식과 참조형 데이터 타입은 메모리 주소를 참조하는 방식이 다릅니다.

본형 타입(int, char 등)은 실제 값을 저장하며, 레퍼클래스(Integer, Character 등)는 값을 객체로 감싸고 해당 객체가 메모리 상에 존재합니다. 이로 인해 null 값을 가질 수 있는 특성을 가지고 있습니다.

 

int num = 10; // 기본형 변수, 값이 10
Integer numObj = 10; // 레퍼클래스, 'Integer' 클래스의 객체에 기본형 값을 저장

// 기본형과 레퍼클래스의 차이점은 'numObj'가 객체로 저장된다는 점

 

 

 

 

static - 클래스가 공유하는 공간

static은 클래스 자체에 속하는 변수나 메서드를 정의하는 키워드로, 객체의 인스턴스와는 독립적으로 클래스에서 공유됩니다.

static으로 선언된 변수나 메서드는 모든 객체에서 동일한 값을 참조하며, 인스턴스가 아닌 클래스 레벨에서 사용됩니다.

class Counter {
    static int count = 0; // static 변수, 모든 인스턴스가 공유하는 변수

    void increment() {
        count++; // count를 증가시키는 메서드
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter1 = new Counter(); // 'counter1' 객체 생성
        counter1.increment(); // 'counter1'의 'increment' 메서드 호출 (count=1)
        
        Counter counter2 = new Counter(); // 'counter2' 객체 생성
        counter2.increment(); // 'counter2'의 'increment' 메서드 호출 (count=2)
        
        System.out.println(Counter.count); // 두 객체가 공유하는 'count' 값 출력
    }
}

 

 

final - 변하지 않는 값

final은 변수, 메서드, 클래스에 사용할 수 있는 키워드로, 해당 값이나 메서드, 클래스가 변경되지 않도록 합니다.

 

• 변수에 사용: 값을 한 번만 할당할 수 있습니다.
• 메서드에 사용: 메서드를 오버라이드할 수 없습니다.
• 클래스에 사용: 해당 클래스를 상속할 수 없습니다.

final int MAX_VALUE = 100; // final 변수, 한 번 값이 설정되면 변경할 수 없음
// MAX_VALUE = 200; // 컴파일 오류, 'final'로 선언된 변수는 재할당 불가

 

 

 

인터페이스 - 표준화의 시작

인터페이스는 메서드 선언만 하고, 구현은 하지 않는 참조형 타입으로, 다른 클래스들이 이 인터페이스를 구현하도록 강제합니다.

인터페이스는 클래스가 해야 할 일만 정의하고, 실제 실행 내용은 구현 클래스가 책임집니다. 이를 통해 다양한 클래스들이 공통된 메서드를 정의하여 상호작용할 수 있습니다.

 

interface Vehicle { // 'Vehicle' 인터페이스 정의
    void drive(); // 'drive' 메서드 선언, 인터페이스에서 구현을 강제하지 않음
}

class Car implements Vehicle { // 'Car' 클래스가 'Vehicle' 인터페이스를 구현
    public void drive() { // 'drive' 메서드 구현
        System.out.println("Driving a car."); // 자동차가 운전 중임을 출력
    }
}

 

 

객체지향 PART 1 - 캡슐화(접근제어자)

캡슐화는 객체의 속성과 메서드를 하나로 묶고, 외부에서 직접 접근하지 못하게 막는 원칙입니다. 이를 통해 데이터 보호와 코드 관리가 용이합니다.

클래스의 속성은 private으로 보호하고, 메서드를 통해 접근하게 합니다. public, private, protected 등의 접근제어자를 통해 접근 범위를 제한할 수 있습니다.

class Person {
    private String name; // private 변수, 외부에서 직접 접근할 수 없음

    // public 메서드를 통해 접근할 수 있게 설정
    public void setName(String name) {
        this.name = name; // 'name' 값을 'this.name'에 할당
    }

    public String getName() {
        return name; // 'name' 값을 반환
    }
}

 

객체지향 PART 2 - 상속

상속은 기존 클래스의 기능을 새로운 클래스가 물려받는 객체지향 개념입니다.

상속을 통해 코드 재사용을 할 수 있으며, 자식 클래스는 부모 클래스의 속성과 메서드를 상속받습니다. extends 키워드를 사용하여 상속을 구현합니다.

class Animal {
    void sound() {
        System.out.println("Animal makes a sound."); // 기본적인 소리 출력
    }
}

class Dog extends Animal { // 'Dog' 클래스가 'Animal' 클래스를 상속
    void sound() { // 'sound' 메서드를 오버라이딩
        System.out.println("Dog barks."); // 개의 소리 출력
    }
}

 

객체지향 PART 3 - 추상화

추상화는 복잡한 시스템을 단순화하기 위해 핵심적인 부분만을 정의하는 개념입니다.

추상 클래스와 인터페이스를 통해 구현 세부 사항을 숨기고, 필요한 기능만을 노출하여 사용합니다.

abstract class Animal { // 'Animal' 클래스는 추상 클래스
    abstract void sound(); // 추상 메서드, 실제 구현은 자식 클래스에서 해야 함
}

class Dog extends Animal { // 'Dog' 클래스가 'Animal'을 상속
    void sound() { // 추상 메서드 구현
        System.out.println("Woof"); // 개의 소리 출력
    }
}

 

객체지향 PART 4 - 다형성

 

다형성은 같은 메서드 이름이지만, 객체에 따라 다른 방식으로 동작하는 특성입니다.

메서드 오버로딩과 오버라이딩을 통해 다형성을 구현할 수 있습니다. 같은 이름의 메서드가 객체에 따라 다르게 동작할 수 있습니다.

class Animal {
    void sound() {
        System.out.println("Animal sound"); // 기본적인 동물 소리
    }
}

class Dog extends Animal { // 'Dog' 클래스가 'Animal' 클래스를 상속
    void sound() { // 'sound' 메서드 오버라이딩
        System.out.println("Woof"); // 개의 소리 출력
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog(); // Animal 타입의 myDog 객체, 실제로는 Dog 객체
        myDog.sound(); // 다형성: Animal 타입으로 Dog 객체를 다뤄도 Dog의 'sound' 메서드가 호출됨
    }
}