클래스

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

클래스의 파라미터는 속성 + 생성자

class 클래스명 (파라미터) {
    ...
    fun 함수명 (파라미터) { ... }
    ...
}

fun main(){
    var 인스턴스명 = 클래스명(파라미터 초기화)

    인스턴스명.함수명(인자)
}

생성자

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

class 클래스명(파라미터){
	init { ... } // 생성 시 바로 수행되는 함수
}

※ 보조 생성자

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

class 클래스명(파라미터){
	init { ... } // 생성 시 바로 수행되는 함수
	constructor (파라미터) : this (파라미터, 고정 값) { ... }
}

상속

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

슈퍼 클래스

open class ...

서브 클래스

class 서브 클래스명 (일부 파라미터) : 슈퍼 클래스명 ( ... ) { ... }

풀코드

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")
    }
}

추상화

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

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

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 와 달리 생성자가 없음
Java와 달리 구현된 일반 함수도 구현 가능, 속성도 선언 가능
→ abstract 와 open 키워드가 필요 없음
→ 서브 클래스에서 override를 이용해 모두 구현, 재정의 가능

※ 여러 인터페이스를 하나의 서브 클래스에 상속 받는 것이 가능해 유연한 코딩(구현) 가능

인터페이스 A, B를 한 번에 C로 상속 가능

클래스 C를 인스턴스로 생성하여
함수 a, b, c 사용 가능

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")
    }
}

다형성

fun main() {
    var 변수1: 클래스1 = 클래스2()
    변수1.함수1()
//    변수1.함수2()

    println()

    var 변수2 = 클래스2()
    변수2.함수1()
    변수2.함수2()

    println()

    if (변수1 is 클래스1) {
        var 변수3 = 변수1 as 클래스2
        변수3.함수1()
        변수3.함수2()
    } else {
        println("...")
    }
}

open class 클래스1 {
    open fun 함수1() {
        println("구문1")
    }
}

class 클래스2 : 클래스1() {
    override fun 함수1() {
        println("구문1 재정의")
    }

    fun 함수2() {
        println("구문2")
    }
}

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

up-casting

< 하위 클래스가 상위 클래스화 되는 것 >

var 인스턴스: 상위 클래스 = 하위 클래스()

상위 클래스화 하기 위해서 인스턴스의 클래스 타입 지정

※ 인스턴스의 클래스 타입을 지정하지 않으면
  자동으로 하위 클래스로 추론됨

down-casting

< 상위 클래스화 된 인스턴스를 지정한 하위 클래스화 하는 것 >

is와 as 키워드 사용

if (인스턴스 is 클래스) → 인스턴스의 클래스 확인용 조건에 사용

var 인스턴스 = 존재하는 인스턴스 as 하위 클래스
up-casting 된 인스턴스를 하위 클래스로 캐스팅

is 로 조건을 걸어서 as 로 down-casting 하는 방법이 일반적