Java 기초 정리 - 객체지향의 4가지 특징

Zyoon·2025년 5월 2일
Java객체지향다형성상속추상화캡슐화

Java 기초정리

목록 보기
24/24
post-thumbnail

💡 캡슐화, 상속, 추상화, 다형성


캡슐화 (접근제어자)

📘 데이터의 보호

  1. 캡슐화의 특징

    • 객체의 정보를 외부로부터 보호
    • 접근제어자를 통해서 구현 가능

  2. 접근제어자

    • 클래스, 변수, 메서드, 생성자의 접근 범위를 제한하는 키워드

    • 접근 영역 : public > protected > default > private

      한정자클래스 내부동일 패키지하위 클래스그 외의 영역
      publicOOOO
      protectedOOOX
      defaultOOXX
      privateOXXX

  3. Getter / Setter

    • 캡슐화가 적용된 클래스의 내부 데이터에 안전하게 접근하는 메서드
    public class Person { 
    private String secret;
    
    //Getter 메서드
    public String getSecret() {
		    return this.secret; // ✅ 객체의 secret 속성 반환
    }
    //Setter 메서드
    public void setSecret(String secret) {
		    this.secret = secret; // ✅ secret 속성 설정 및 변경
    }
}

public class Main {
    public static void main(String[] args) {
		    //생성자 생성
		    Person p1 = new Person();
		    
		    //Getter 활용해 데이터 Get
		    p1.secret; // ❌ 직접 접근 불가능
		    String newSecret = p1.getSecret(); // ✅ 게터를 활용해 접근가능

				//Setter 사용해 데이터 Set
		    p1.secret = "password"; // ❌ 직접접근, 변경 불가능
		    p1.setSecret("newPassword"); // ✅ 세터를 활용해 접근, 변경가능
    }
}

상속

📘 재사용성과 확장

  1. 상속의 특징

    • 클래스간의 관계를 부모(상위), 자식(하위) 으로 바라보는 개념
    • 부모 클래스에 있던 메소드를 자식 클래스에서 재사용 및 확장 가능
    • 부모는 리턴타입으로 자식을 쓸 수 있음
    • extends 키워드를 사용해서 상속관계를 구현
    • super 키워드로 부모클래스에 접근
    // 부모 클래스
class Animal {
    String name;

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

    void sound() {
        System.out.println("동물이 소리를 냅니다.");
    }

    void showName() {
        System.out.println("이 동물의 이름은 " + name + "입니다.");
    }
}

// 자식 클래스
class Dog extends Animal {
    String breed;

    Dog(String name, String breed) {
        super(name); // 부모 클래스의 생성자 호출
        this.breed = breed;
    }

    @Override //상속 관계 표시
    void sound() {
        super.sound(); // super 키워드로 부모생성자 메서드 접근
        System.out.println("강아지가 멍멍 짖습니다.");
    }

		//자식클래스에서 기능 확장
    void showBreed() {
        System.out.println("견종: " + breed);
    }
}

// 실행 클래스
public class TestInheritance {
    public static void main(String[] args) {
        Dog dog = new Dog("바둑이", "진돗개");

        dog.showName();   // 부모의 메서드 재사용
        dog.sound();      // 자식에서 오버라이드 + super로 부모 호출
        dog.showBreed();  // 자식만의 메서드(확장)
    }
}
//출력

//이 동물의 이름은 바둑이입니다.
//동물이 소리를 냅니다. -> super 로 부모 호출
//강아지가 멍멍 짖습니다.
//견종: 진돗개

추상화

📘 데이터의 계층적 표현

  1. 추상화의 특징

    • 복잡한 것에서 핵심적인 부분만 뽑아서 단순화한 것
    • 구체적인 구현은 감추고, 필요한 기능이나 속성만 보여주는 것
    • 추상화의 계층적 특징을 활용해서 유지보수성 증가
    • 추상 클래스와 인터페이스를 사용

  2. 추상 클래스

    • 공통된 속성과 메서드 / 일부 미구현 메서드
    • abstract 키워드 사용
    • 공통 속성과 동작이 있을 때
    // 부모 클래스 (추상클래스) - 상속 전용
abstract class Animal {
    String name;

    Animal(String name) {
        this.name = name;
    }
		
		// 추상 메서드 (구현은 자식에게 맡김)
    abstract void sound();

		// 일반 메서드
    void showName() {
        System.out.println("이 동물의 이름은 " + name);
    }
}

//자식 클래스
class Dog extends Animal {
    Dog(String name) {
        super(name); //부모의 생성자 호출
    }

		// 자식 클래스에서 구현
    @Override
    void sound() {
        System.out.println("멍멍!");
    }
}

  1. 인터페이스

    • 기능 목록만 선언하고 구현은 각각 다르게 적용
    • 기능 규칙만 정하고 싶을 때, 여러 클래스에서 공통으로 강제하고 싶을 때 사용
    //인터페이스 선언
interface Movable {
    void move(); //반드시 구현해야 하는 메서드
}

//인터페이스로 각각의 기능 구현
class Car implements Movable {
    public void move() {
        System.out.println("자동차가 달립니다.");
    }
}

class Person implements Movable {
    public void move() {
        System.out.println("사람이 걷습니다.");
    }
}

다형성

📘 여러 형태를 가질 수 있는 특성

  1. 다형성의 특징

    • 하나의 타입으로 여러 객체를 다룰 수 있음
    • 추상계층을 활용해서 다형성 구현 - 인터페이스, 추상클래스
    • 부모, 자식 사이의 자동 형변환

  2. 업캐스팅

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

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

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        
        // 업캐스팅: 자식 클래스(Dog)의 객체를 부모 클래스(Animal) 타입으로 참조
        Animal animal = dog;  // 업캐스팅은 자동으로 이루어짐
        
        // 다형성: 부모 클래스 타입의 변수로 자식 클래스 메서드 호출
        animal.makeSound();  // "Bark" 출력
    }
}

  1. 다운캐스팅

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

// 자식 클래스
class Dog extends Animal {
    void bark() {
        System.out.println("Bark");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();  // 업캐스팅: Dog 객체를 Animal 타입으로 참조
        
        // 다운캐스팅: Animal 타입의 변수를 Dog 타입으로 변환
        Dog dog = (Dog) animal;  // 명시적으로 다운캐스팅
        
        // 자식 클래스에서만 사용할 수 있는 메서드 호출
        dog.bark();  // "Bark" 출력
    }
}
profile
Zyoon
기어 올라가는 개발
이전 포스트

Java 기초 정리 - 명명 규칙

0개의 댓글