![[코틀린 완전정복] 추상 클래스와 인터페이스](https://img1.daumcdn.net/thumb/R750x0/?scode=mtistory2&fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2FbdxQFb%2FbtrAdcxBKWC%2FNaBExk0HGswwMvdIK7DkkK%2Fimg.png)
추상 클래스
추상 클래스 VS 인터페이스
추상 클래스 는 대략적인 설계의 명세와 공통의 기능을 구현한 클래스이다. 즉, 구체적이지 않은 것이다. 추상 클래스 를 상속하는 하위 클래스 는 추상 클래스의 내용을 더 구체화 해야 한다.
오잉? 그럼 추상 클래스랑 인터페이스는 같은 거 아냐? 🤔
엄밀히 말하면 다르다. 인터페이스 역시 대략적인 설계 명세를 구현하고 인터페이스 를 상속하는 하위 클래스 에서 이를 구체화하는 것은 동일하다. 하지만 인터페이스에서는 프로퍼티의 상태 정보를 저장할 수 없다.
다시 말하면 인터페이스 에서는 프로퍼티의 초기화 가 불가능하다는 것이다.
interface Vehicle {
val name : String
val color : String
val weight : Double
}
interface Pet {
val name : String = "puppy" // 불가능!
}Pet Interface 의 경우 정의와 동시에 초기화까지 해주고 있는데 인터페이스 에선 불가능하다.
추상 클래스 사용해보기
추상 클래스 는 위에서 말한 것처럼 구체화되지 않은 클래스이기 때문에 일반적인 객체를 생성하는 방법으로 인스턴스화될 수 없다. 일단 한번 정의해보자. 우선 추상 클래스 를 정의하기 위해선 abstract 라는 키워드를 사용해야 한다. 또한 클래스 내에서의 프로퍼티나 메소드도 abstract로 선언할 수 있다. 이를 상속받는 클래스에서 구체화하겠다는 의미가 된다. 하지만 이를 사용하기 위해선 해당 클래스가 추상 클래스가 되어야한다.
// abstract로 정의한 추상 클래스이다. 주생성자를 사용했다.
abstract class Vehicle(val name : String, val color : String, val weight : Double) {
// abstract로 정의한 추상 프로퍼티이므로 하위 클래스에서 반드시 재정의해야한다.
abstract var maxSpeed : Double
// 초기값을 갖는 일반 프로퍼티 (인터페이스에서는 불가능)
var year = "2021"
// abstract로 정의한 추상 메소드이므로 하위 클래스에서 반드시 재정의해야한다.
abstract fun start()
abstract fun stop()
fun displaySpecs() {
println("Name : $name, Color : $color, Weight : $weight, Year : $year, MaxSpeed : $maxSpeed")
}
}Vehicle 클래스 는 abstract로 정의한 추상 클래스이므로 기본적인 설계만 정의하고 있다. abstract 를 사용한 maxSpeed, start(), stop()은 반드시 하위 클래스에서 재정의 해줘야한다.
여기서 잠깐! 클래스를 상속하기 위해선 부모 클래스를 open 키워드로 정의해야 하는데 추상 클래스에서도 해줘야 하나요? 🤔
이미 코드를 통해 느꼈겠지만, 추상 클래스 에서는 open 키워드 를 사용하지 않아도 된다. 추상 프로퍼티 나 추상 메소드 도 마찬가지다!
위에서 정의한 Vehicle 클래스를 상속해보자.
class Car(name : String, color : String, weight : Double, override var maxSpeed : Double) : Vehicle(name, color, weight) {
override fun start() {
// 재정의
println("Car start")
}
override fun stop() {
// 재정의
println("Car Stop")
}
}
class Bicycle(name : String, color : String, weight : Double, override var maxSpeed : Double) : Vehicle(name, color, weight) {
override fun start() {
// 재정의
println("Bicycle start")
}
override fun stop() {
// 재정의
println("Bicycle Stop")
}
}
fun main() {
val car = Car("Matiz", "Yellow", 1000, 150)
val bicycle = Bicycle("Bike", "Red", 150, 100)
// 새로운 값 할당
car.year = "2020"
car.displaySpec()
car.start()
bicycle.displaySpec()
bicycle.start()displaySpec 은 추상 클래스 가 갖고 있던 일반 메소드 이다. start 와 stop 은 추상클래스 를 상속받은 자식 클래스 에서 오버라이딩한 메소드 이다. 추상 클래스에서 abstract로 정의한 프로퍼티나 메소드들은 자식 클래스에서 반드시 재정의되어야한다.
그렇다면 혹시, 추상 클래스를 상속받는 하위 클래스를 정의하지 않고도 추상 클래스를 사용할 수 있을까? 🤔
사용할 수 있다! object 키워드를 사용하면 된다. (object 이 친구 만능이네...?)
abstract class Printer {
abstract fun print()
}
val myPrinter = object : Printer() {
override fun print() {
println("print 메소드가 재정의되었습니다")
}
}
fun main() {
myPrinter.print()
}인터페이스
코틀린 에서는 다른 언어와 다르게 메소드 에 구현 내용을 포함할 수 있다.
interface Pet {
var category : String // 추상 프로퍼티
fun feeding() // 추상 메소드
fun patting() { // 구현부를 포함할 수 있다. 구현부를 포함하면 일반 메소드
println("Keep patting")
}
}추상클래스 와 다르게 abstract 키워드를 사용하지 않는다. 또한 앞서 말한 것처럼 상태를 저장할 수가 없으므로 프로퍼티에 기본 값을 가질 수가 없다.
인터페이스 사용하기
class Cat(override var category : String) : Pet { // 주생성자를 이용
override fun feeding() {
println("Feeding 메소드가 구현되었습니다.")
}
}
fun main() {
val obj = Cat("Small")
obj.feeding() // 구현된 메소드
obj.patting()// 일반 메소드
}인터페이스에서 값 저장하기
아니 선생님, 인터페이스에서는 프로퍼티에 값을 저장할 수 없다고 하셨잖아요 😥
하지만 예외가 있다. val 로 선언한 프로퍼티 는 게터 를 통해서 필요한 내용을 구현할 수 있다.
interface Pet {
var category : String // 추상 프로퍼티
val message : String // val로 선언하면 게터의 구현이 가능하다.
get() = "I'm cutty"
fun feeding() // 추상 메소드
fun patting() { // 구현부를 포함할 수 있다. 구현부를 포함하면 일반 메소드
println("Keep patting")
}
}게터 가 사용 가능하지만 그렇다고 보조필드 가 사용가능한 것은 아니다.
인터페이스의 이점
인퍼페이스를 사용하면 뭐가 좋을까? 일단 코드의 재사용성이 올라간다. 한마디로 간결해진다는 점이다. 또 인터페이스를 이용해서 클래스 간의 의존성을 제거할 수 있다. 뿐만 아니라 다중 상속도 가능하다. 코틀린에서는 자바와 다르게 클래스에서 부모 클래스를 상속할 때는 1개의 클래스만 가능하다. 하지만 인터페이스를 활용하면 다중 상속이 가능해진다!
아래는 두 개의 인터페이스를 통해 다중 상속을 구현한 코드이다.
interface Bird {
val wings : Int
fun fly()
fun jump() { // 구현된 일반 메소드
println("Bird jump")
}
}
interface Horse {
val maxSpeed : Int
fun run()
fun jump() { // 구현된 일반 메소드
println("jump!, max speed : $maxSpeed")
}
}
class Pegasus : Bird, Horse {
override val wings : Int = 2
override val maxSpeed : Int = 100
override fun fly() {
println("The Pegasus Fly!")
}
override fun run() {
println("The Pegasus Run!")
}
override fun jump() {
super<Horse>.jump() {
println("The Pegasus jump")
}
}
}구현부가 있는 메소드의 경우 필요에 따라 오버라이딩을 진행하면 된다. 만약 인터페이스에서 구현한 메소드의 이름이 같은 경우 super<인터페이스 이름>.메소드명 을 통해 구분할 수 있다.
'💻 개발 > Kotlin' 카테고리의 다른 글
| [코틀린 완전정복] 공변성, 반공변성, 무변성 (0) | 2022.05.02 |
|---|---|
| [코틀린 완전정복] 제네릭 (0) | 2022.04.25 |
| [코틀린 완전정복] 여러 종류의 클래스 (0) | 2022.04.23 |
| [코틀린 완전정복] 추상 클래스와 인터페이스 (0) | 2022.04.22 |
