[JAVA] 상속,구체화

---

 

1.Subclassing (is-a관계)

클래스를 확장하여 새로운 클래스를 만든다.
상속을 통해 구현한다.

class Animal { // 상위 클래스
    void eat() {
        System.out.println("Eating");
    }
}

class Dog extends Animal { // 서브클래스
    void bark() {
        System.out.println("Barking");
    }
}

 

 

2.Subtyping(can be used as)

서로 다른 타입 간의 관계를 나타낸다.
인터페이스 및 구현 클래스를 통해 구현한다.

class Animal { // 상위 타입
    void makeSound() {
        System.out.println("Animal sound");
    }
}

class Cat extends Animal { // 서브타입
    @Override
    void makeSound() {
        System.out.println("Meow");
    }
}

 

 

 

3.객체 관계

3-1.사용(use-a)

한 객체가 행위를 수행하기 위해 다른 종류의 객체를 사용

class Engine {
    public void start() {
        System.out.println("Engine starting...");
    }
}

class Car {
    private Engine engine; // Car는 Engine을 사용

    // 생성자
    public Car(Engine engine) {
        this.engine = engine; // Engine 객체를 Car에 주입
    }

    public void startCar() {
        engine.start(); // Car가 Engine의 메서드 사용
        System.out.println("Car is ready to go!");
    }
}

 

3-2.포함(has-a)

다른 클래스의 객체를 멤버 변수로 유지

class Address {
    private String city;
    private String zipCode;

    // 생성자
    public Address(String city, String zipCode) {
        this.city = city;
        this.zipCode = zipCode;
    }

    public String getAddressInfo() {
        return city + ", " + zipCode;
    }
}

class Person {
    private String name;
    private Address address; // Person은 Address를 포함

    // 생성자
    public Person(String name, Address address) {
        this.name = name;
        this.address = address; // Address 객체를 Person에 포함
    }

    public void printInfo() {
        System.out.println("Name: " + name);
        System.out.println("Address: " + address.getAddressInfo());
    }
}

 

 

 

4.Object 클래스

어떤 클래스를 정의할 때 그것의 부모 클래스를 지정하지 않으면 Object가 부모클래스임
(모든 클래스의 조상은 Object 클래스)

 

 

 

 

5.상속 vs 인터페이스

상속은 멤버변수와 메소드 구현을 공유하고
인터페이스는 메소드 이름만 공유한다.

상속은 한부모에게만가능하고
인터페이스는 한클래스에 여러개 구현가능
인터페이스의 메소드들은 모두 구현해야한다.( defalut 키워드로 작성된것 제외)

 

 

 

6.추상클래스 (abstract class)

객체를 생성하지 못하는 클래스이다.

// 추상 클래스 정의
abstract class Animal {
    // 추상 메서드 (구현 없음)
    abstract void sound();

    // 일반 메서드 (구현 있음)
    void sleep() {
        System.out.println("Sleeping...");
    }
}

 

6-1.추상 메소드(abstract method)

메소드의 정의는 필요하지만 공유할 코드가 없을때 사용함
이 메소드는 상속받으면 무조건 구현해야함

(추상 메소드를 가지는 클래스는 반드시 추상 클래스가 되어야 함)

//X
//추상메소드가 있으면 무조건 추상 클래스여야함
public class A {
	public abstract void foo();
}


//X
//추상메소드는 반드시 구현해야함
public abstract class A {
	public abstract void foo();
}

public classB extends A {
};

//X
//인터페이스의 메소드는 추상메소드이므로 반드시 구현해야함
public interface L {
	void foo(); 
}
public class B implements L {
}

 

 

 

 

7.super

super()을 이용하면 부모의 생성자를 호출할수있고
super에 . 연산을 통하여 부모의 맴버변수와 메소드에 접근을 할수있다.

(this, super를 이용한 호출은 항상 생성자의 첫 문장으로 사용해야 함)

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

    void showInfo() {
        super.makeSound(); // 부모 클래스의 메서드 호출
        System.out.println(name + " is a dog.");
    }
}

 

 

 

8.instanceof

object instanceof ClassName형태로 사용된다.

animal instanceof Dog은 Dog는 animal 인가? 정도로 해석할수있다.
(animal은 Dog의 인스턴스)

class Animal {
}

class Dog extends Animal {
}

class Cat extends Animal {
}

public class Example {
    public static void main(String[] args) {
        Animal animal = new Dog(); // Animal 타입의 Dog 객체 생성

        // instanceof 사용 예시
        if (animal instanceof Dog) {
            System.out.println("animal은 Dog의 인스턴스입니다.");
        }

        if (animal instanceof Animal) {
            System.out.println("animal은 Animal의 인스턴스입니다.");
        }

        if (animal instanceof Cat) {
            System.out.println("animal은 Cat의 인스턴스입니다."); // 이 조건은 false
        }
    }
}

 

 

 

 

 

9.메소드 바인딩

자바는 모든 메소드가 자동으로 늦은 바인딩을 제공함
실제로 호출할 메소드를 런타임단계에서 바인딩한다는거다.

이른바인딩은 컴파일때 메소드에 바인딩되고 , 늦은 바인딩은 런타임때 바인딩된다.

 

 

 

9-1.이른 바인딩(컴파일 시간)

자바에서 이른바인딩을 사용할려면 final 메소드를 붙여서 더이상 바뀌지않게 만들어서 사용할수있다.

class Animal {
    final void sound() { // final 메서드
        System.out.println("Animal makes a sound.");
    }
}

class Dog extends Animal {
    // sound() 메서드를 오버라이드 할 수 없음
    // void sound() { 
    //     System.out.println("Dog barks."); // 오류 발생
    // }
}

public class Example {
    public static void main(String[] args) {
        Animal animal = new Dog(); // Dog 객체 생성
        animal.sound(); // "Animal makes a sound." 출력
    }
}

 

 

9-2.늦은 바인딩(실행 시간 runtime)

final을 사용하지않은 자바의 메소드들은 기본적으로 늦은 바인딩이다.

class Animal {
    void sound() { // 일반 메서드 (final 없음)
        System.out.println("Animal makes a sound.");
    }
}

class Dog extends Animal {
    @Override
    void sound() { // 오버라이드된 메서드
        System.out.println("Dog barks.");
    }
}

public class Example {
    public static void main(String[] args) {
        Animal animal = new Dog(); // Dog 객체 생성
        animal.sound(); // "Dog barks." 출력 (늦은 바인딩)
    }
}

 

 

 

10.상속

10-1.부모 클래스의 메소드를 상속

접근 권한이 있는 모든 메소드는 자동으로 상속

 

 

10-2.부모 클래스의 메소드를 재정의

부모가 상속한 메소드를 재정의(오버라이딩)한다.

 

 

10-3.private

private는 자식에게 상속되지않음

 

 

10-4.super

부모의 맴버에 접근한다. super.super은 사용불가능

class Child extends Parent {
    String name = "Child";

    void display() {
        System.out.println("Child's name: " + name);        // 자식 클래스의 name
        System.out.println("Parent's name: " + super.name); // 부모 클래스의 name
        super.showName(); // 부모 클래스의 showName() 메서드 호출
    }
}

 

10-5.@Override

문법 검사를 더 엄격하게 할 수 있도록 컴파일러에 추가 정보를 주는 역할

class Dog extends Animal {
    @Override
    void sound() { // @Override 어노테이션
        System.out.println("Dog barks.");
    }
}

 

 

 

 

11.재정의 규칙

11-1.매개변수 타입일치

오버라이딩한 메소드의 매개변수 타입은 부모와 일치해야한다.

 

 

11-2.반환타입 더 특수한타입으로 가능

반환타입은 부모타입과 일치하거나 거기에서 더 특별한 타입으로 가능하다.

 

 

11-3. 메소드 접근권한 강화불가

메소드의 접근권한을 완화(protected -> public) 은 가능하지만 강화(public -> private)는 불가능하다.

 

 

 

 

 

12.인터페이스 (interface)

• 멤버 변수를 가질수없음
• 추상메소드만 정의가능(자동으로 abstarct 처리됨)
• 가본적으로 public 접근권한( public 수익안해도 자동으로 처리됨)
• 상수정의 가능(자동으로 public static final)
• default (구현 안해도 되는 메소드 수식) (인터페이스에서 구현할수있음)
• implements 키워드를 사용하여 상속한다.

 

12-1.인터페이스 끼리 상속

extends 키워드를 사용하고 여러 인터페이스를 상속받을 때는 , 를 통해 구분한다.
인터페이스도 인터페이스를 상속받을수있다.

// 첫 번째 인터페이스
interface Animal {
    void eat();
}

// 두 번째 인터페이스
interface Pet {
    void play();
}

// 세 번째 인터페이스: Animal과 Pet을 상속
interface Dog extends Animal, Pet {
    void bark(); // 추가 메서드
}