[Kotlin] 코틀린 문법 6 (open, 상속, 인터페이스)

Kotlin에서는 객체 지향 프로그래밍(OOP)의 핵심 개념인 상속(Inheritance)과 인터페이스(Interface) 를 지원하지만,

Java와는 몇 가지 차이점이 있음. 특히 open 키워드는 Java와 Kotlin의 클래스 설계 철학의 차이를 보여주는 중요한 요소임.

 

🛠️ 1. open 키워드 (Java의 extends와 비교)

✅ Java: 클래스와 메서드는 기본적으로 상속 가능 (final을 붙이면 금지)

class Parent {
    void show() {
        System.out.println("부모 클래스");
    }
}

class Child extends Parent {
    @Override
    void show() {
        System.out.println("자식 클래스");
    }
}

Child child = new Child();
child.show(); // "자식 클래스"

🔹 특징:

• Java에서는 클래스와 메서드가 기본적으로 open(상속 가능) 상태이며, 제한하려면 final을 사용해야 함.

• @Override 어노테이션을 사용하여 명시적으로 오버라이딩을 표시함.

 

✅ Kotlin: 클래스는 기본적으로 final이므로 open을 사용해야 상속 가능

open class Parent {
    open fun show() {
        println("부모 클래스")
    }
}

class Child : Parent() {
    override fun show() {
        println("자식 클래스")
    }
}

val child = Child()
child.show() // "자식 클래스"

🔹 특징:

• Kotlin에서는 클래스와 메서드가 기본적으로 final이므로 상속하려면 open 키워드를 붙여야 함.

• override 키워드를 사용해야 부모 메서드를 오버라이딩할 수 있음.

 

🔥 open 키워드 비교 (Kotlin vs Java)

기능	Kotlin	Java
기본 상속 여부	❌ (final이 기본)	✅ (open이 기본)
상속 가능하게 하는 방법	open 키워드 추가	기본적으로 가능 (final 추가 시 제한)
오버라이딩 가능 여부	❌ (final이 기본)	✅ (open이 기본)
오버라이딩 허용 방법	open 키워드 추가	기본적으로 가능 (final 추가 시 제한)
오버라이딩할 때 필요한 키워드	override	@Override (선택적)

 

🛠️ 2. 상속 (Inheritance)

Kotlin과 Java 모두 단일 상속(Single Inheritance) 만 지원하며, 다중 상속(Multiple Inheritance) 은 인터페이스를 통해 해결함.

 

✅ Java 코드 (클래스 상속)

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

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("멍멍!");
    }
}

Dog dog = new Dog();
dog.makeSound(); // "멍멍!"

→ Dog 클래스는 Animal 클래스를 extends 키워드로 상속받고, @Override 어노테이션을 붙여 오버라이딩함.

 

✅ Kotlin 코드 (클래스 상속)

open class Animal {
    open fun makeSound() {
        println("동물이 소리를 냅니다.")
    }
}

class Dog : Animal() {
    override fun makeSound() {
        println("멍멍!")
    }
}

val dog = Dog()
dog.makeSound() // "멍멍!"

→ Dog 클래스는 Animal 클래스를 상속받으며, override 키워드로 메서드를 오버라이딩함.

 

🔥 Kotlin vs Java 상속 비교

기능	Kotlin	Java
상속 키워드	: 사용 (class Child : Parent())	extends 사용 (class Child extends Parent)
기본 상속 가능 여부	❌ (open 필요)	✅ (final 없으면 가능)
오버라이딩 필수 키워드	override	@Override (선택적)

 

🛠️ 3. 인터페이스 (Interface)

Kotlin과 Java 모두 인터페이스를 지원하지만, Kotlin은 인터페이스에 default 메서드 없이도 구현을 포함할 수 있음.

 

✅ Java 코드 (인터페이스)

interface Animal {
    void makeSound(); // 추상 메서드

    default void walk() { // Java 8부터 기본 구현 가능
        System.out.println("동물이 걷습니다.");
    }
}

class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("멍멍!");
    }
}

Dog dog = new Dog();
dog.makeSound(); // "멍멍!"
dog.walk(); // "동물이 걷습니다."

🔹 특징:

• interface 키워드를 사용하여 정의.

• Java 8부터 default 메서드를 사용하여 기본 구현 제공 가능.

• 모든 메서드는 기본적으로 public abstract.

 

✅ Kotlin 코드 (인터페이스)

interface Animal {
    fun makeSound() // 추상 메서드
    fun walk() { // 기본 구현 제공 가능
        println("동물이 걷습니다.")
    }
}

class Dog : Animal {
    override fun makeSound() {
        println("멍멍!")
    }
}

val dog = Dog()
dog.makeSound() // "멍멍!"
dog.walk() // "동물이 걷습니다."

🔹 특징:

• interface 키워드를 사용하여 정의.

• 추상 메서드는 abstract 없이 선언 가능.

• 기본 구현 제공 가능.

 

🔥 Kotlin vs Java 인터페이스 비교

기능	Kotlin	Java
인터페이스 선언	interface 키워드 사용	interface 키워드 사용
메서드 기본 구현	✅ (fun walk() {} 가능)	✅ (default 키워드 필요)
다중 구현 가능 여부	✅	✅
다중 상속 시 충돌 해결	명시적으로 super<T>.method() 호출	Interface.super.method() 호출

 

🛠️ 4. 다중 상속 (인터페이스 활용)

Kotlin과 Java는 클래스 다중 상속을 지원하지 않지만, 인터페이스는 다중 구현 가능함.

 

✅ Java 코드 (다중 인터페이스)

interface Animal {
    void makeSound();
}

interface Pet {
    void play();
}

class Dog implements Animal, Pet {
    @Override
    public void makeSound() {
        System.out.println("멍멍!");
    }

    @Override
    public void play() {
        System.out.println("강아지가 놀고 있습니다!");
    }
}

Dog dog = new Dog();
dog.makeSound(); // "멍멍!"
dog.play(); // "강아지가 놀고 있습니다!"

 

✅ Kotlin 코드 (다중 인터페이스)

interface Animal {
    fun makeSound()
}

interface Pet {
    fun play()
}

class Dog : Animal, Pet {
    override fun makeSound() {
        println("멍멍!")
    }

    override fun play() {
        println("강아지가 놀고 있습니다!")
    }
}

val dog = Dog()
dog.makeSound() // "멍멍!"
dog.play() // "강아지가 놀고 있습니다!"

 

비교	코틀린	자바
클래스 상속	: 사용 (open 필요)	extends
인터페이스 구현	: 사용	implements
다중 인터페이스	✅ 지원	✅ 지원
기본 메서드	인터페이스 내 메서드 구현 가능	default
같은 이름 메서드 충돌 해결	super<Interface>.method()	Interface.super.method()
부모 생성자 호출	: 부모클래스()	super()
abstract	abstract 필요	abstract 필요

 

🎯 결론

• Kotlin은 기본적으로 클래스와 메서드가 final이며, 상속하려면 open을 사용해야 함.

• Kotlin과 Java 모두 단일 상속만 지원하며, 다중 상속은 인터페이스로 해결 가능.

• Kotlin은 인터페이스에서 기본 구현을 제공할 때 default 없이도 가능.

• Kotlin에서는 :을 사용해 상속과 인터페이스 구현을 동시에 처리 가능.

 

 

 

 

출처 : ChatGPT