[ Kotlin ] 클래스

기본

• 속성 + 함수
• 인스턴스를 만드는 틀

class ClassName (params) {
    ...
    fun FunctionName (params) { ... }
    ...
}

fun main(){
    var InstanceName = ClassName(params 초기화)

    InstanceName.FunctionName(params)
}

 

• 클래스의 params는 속성 + 생성자

 

생성자

• 인스턴스의 속성 초기화 + 생성 시 구문 수행

class ClassName(params){
    init { ... } // 생성 시 바로 수행되는 함수
}

• ※보조 생성자

class ClassName(params){
    init { ... } // 생성 시 바로 수행되는 함수
    constructor (params) : this (params, 고정 값) { ... }
}

• constructor에서의 this에 의해 init이 가장 먼저 수행됨

 

상속

• 기존의 클래스의 멤버를 확장하기 위한 목적으로 상, 하 구조를 가지도록 구성하는 것

• 슈퍼 클래스

open class ...

• 서브 클래스

class SubClassName (params) : SuperClassName ( ... ) { ... }

• 예시

fun main() {
    var SUPER = Super()
    println(SUPER.a)

    println()

    var SUB = Sub()
    println(SUB.a)
    println(SUB.b)
}
//1
//
//1
//11

open class Super {
    val a = 1
}

class Sub : Super() {
    val b = 11
}

 

오버라이딩

• 슈퍼 클래스에 open을 붙이고
• 서브 클래스에서 override를 붙여 이름과 형태가 같은 함수 재정의 가능

fun main() {
    var SUPER = Super()
    println(SUPER.a)
    SUPER.superfunc()

    println()

    var SUB = Sub()
    println(SUB.a)
    println(SUB.b)
    SUB.superfunc()
    SUB.subfunc()
}

//1
//super fun
//
//1
//11
//override super fun
//sub fun

open class Super {
    val a = 1
    open fun superfunc(){
        println("super fun")
    }
}

class Sub : Super() {
    val b = 11
    override fun superfunc() {
        println("override super fun")
    }
    fun subfunc(){
        println("sub fun")
    }
}

 

추상화

• 형식만 선언하고 실제 구현을 서브 클래스에 일임

fun main() {
    var b = B()
    b.a()
    b.b()
}

abstract class A() {
    abstract fun a()
    fun b() {
        println("fun b")
    }
}

class B : A() {
    override fun a() {
        println("override fun a")
    }
}

//override fun a
//fun b

• 추상 클래스, 함수에는 반드시 ‘abstract’ 키워드를 붙여야 함
• 상속 받은 클래스에서 재정의 가능

 

인터페이스

• abstract 와 달리 생성자가 없음
• Java와 달리 구현된 일반 함수도 구현 가능, 속성도 선언 가능
• → abstract 와 open 키워드가 필요 없음
  → 서브 클래스에서 override를 이용해 모두 구현, 재정의 가능
• ※ 여러 인터페이스를 하나의 서브 클래스에 상속 받는 것이 가능해
  유연한 코딩(구현) 가능

fun main() {
    var c = C()
    c.a()
    c.b()
    c.c()
}

interface A {
    fun a()
}

interface B {
    fun b()
    fun c() {
        println("fun c")
    }
}

class C : A, B {
    override fun a() {
        println("override fun a")
    }

    override fun b() {
        println("override fun b")
    }
}

• 인터페이스 A, B를 한 번에 C로 상속 가능
• 클래스 C를 인스턴스로 생성하여 함수 a, b, c 사용 가능

 

다형성

fun main() {
    var varName: ClassName1 = ClassName2()
    varName.FunctionName1()
//    varName.FunctionName2()

    println()

    var variable2 = ClassName2()
    variable2.FunctionName1()
    variable2.FunctionName2()

    println()

    if (varName is ClassName1) {
        var variable3 = varName as ClassName2
        variable3.FunctionName1()
        variable3.FunctionName2()
    } else {
        println("...")
    }
}

open class ClassName1 {
    open fun FunctionName1() {
        println("구문1")
    }
}

class ClassName2 : ClassName1() {
    override fun FunctionName1() {
        println("구문1 재정의")
    }

    fun FunctionName2() {
        println("구문2")
    }
}

//구문1 재정의
//
//구문1 재정의
//구문2
//
//구문1 재정의
//구문2

• up-casting : 하위 클래스가 상위 클래스화 되는 것
  down-casting : 상위 클래스화 된 인스턴스를 지정한 하위 클래스화 하는 것
• up-casting
  var 인스턴스: 상위 클래스 = 하위 클래스()
  상위 클래스화 하기 위해서 인스턴스의 클래스 타입 지정
  ※ 인스턴스의 클래스 타입을 지정하지 않으면
  자동으로 하위 클래스로 추론됨
• down-casting
  is와 as 키워드 사용
• if (인스턴스 is 클래스) → 인스턴스의 클래스 확인용 조건에 사용
• var 인스턴스 = 존재하는 인스턴스 as 하위 클래스
  up-casting 된 인스턴스를 하위 클래스로 캐스팅
• is 로 조건을 걸어서 as 로 down-casting 하는 방법이 일반적