Kotlin_상속 / 객체 / 인터페이스와 추상 클래스

 

---

상속

 

public : 코틀린에서 속성과 함수가 기본적으로 갖는 가시성

private : 속성과 함수가 정의된 클래스 내부에서만 사용될 수 있다.

protected : 이 가시성이 지정된 속성과 함수는 자신이 정의된 클래스 내부 또는 이 클래스의 어떤 서브 클래스에서도 사용 가능

 

is 연산자 : 현재 객체가 특정 타입인지 검사한다.

 

 

상속

open class Room(val name: String){

    protected open val dangerLevel : Int = (1..10).shuffled().last()

    fun description() = "Room: ${name}\n" + "위험 수준 : ${dangerLevel}"

    open fun load() = "아무도 여기에 오지 않았습니다.."

    // any 타입의 toString을 오버라이드
    override fun toString(): String {
        return this.name
    }
}

// 상속 받을 땐, : 뒤에 슈퍼 클래스인 Room과 생성자 호출을 지정해야 한다.
// 서브 클래스의 오버라이딩 함수나 속성은 기본적으로 open이 되어서 서브 클래스의 서브 클래스에서는 언제든 오버라이딩 할 수 있다.
open class TownSquare : Room("Town Square")
{
    override val dangerLevel = super.dangerLevel -3
    private val bellSound = "댕댕"

    // Room의 서브 클래스인 TownSquare로 부터 또 다시 서브 클래스를 생성할수 있게 하되, TownSquare의 load 함수를 오버라이딩 되지 않게 하려면, final!
    final override fun load() = "여기는 TownSquare"


    private fun ringBell() = "당신의 도착을 종탑에서 알립니다. $bellSound"
}

// is 연산자 - 타입 어떤 건지
// any 타입 - 모든 null 불가능 타입의 최상의 슈퍼 클래스
//fun printIsSourceOfBlessing(any : Any){
//    val isSourceOfBlessiongs = if(any is Player){
//        any.isBlessed
//    }else{
//        (any as Room).name == "Fount of Blessings"
//    }
//}




fun main() {
    var currentRoom = Room("Foyer")
    println(currentRoom.description())
    println(currentRoom.load())

    var currentTownSquare = TownSquare()
    println(currentTownSquare.description())
    println(currentTownSquare.load())

}

 

 

코틀린 타입의 상속 계층

- 코틀린의 모든 Null 불가능 클래스는 자동으로 Any라는 최상위 슈퍼 클래스로 부터 상속 받는다.

코틀린의 모든 객체는 Any의 서브 클래스 인스턴스 → 어떤 타입의 인자도 printIsSourceOfBlessings 함수에 전달할 수 있다. 

Any

- equals, hashCode,toString 정의하고 있음 (추가로 확장된 속성과 함수도 갖고 있다.)

✲ 지금까지 처럼, Any는 null 불가능 타입이고, Any?는 null 가능 타입니다.

타입 변환

 

>> 코틀린을 사용하면 서로 다른 플랫폼 어플리케이션을 만들 수 있다. 

      여러 운영체제 JVM에서 실행되는 애플리케이션 / JVM 없이 실행되는 애플리케이션 / 웹 브라우저에서 실행되는 자바스크립트/ 서버에 서 실행되는 자바스크립트 / 서버에서 실행되는 Http 서블릿 / 구글 안드로이드 애플리케이션.

>> Any 클래스는 그런 다양한 플랫폼에 독립적인 애플리케이션을 생성할 수 있게 해준다.

---

객체 Object

https://www.youtube.com/watch?v=QPqzmKu0Y_k

 

- 해체 선언

- 데이터 클래스 (data class)

- enum 클래스 

- 연산자 오버로딩

 

/**
 *
 * Object 키워드
 *
 * 프로그램이 실행되는 내내 수시로 변하는 상태 정보를 지속적으로 유지 관리할 필요가 있다면 싱글톤 사용을 고려하자 (예를 들면 Game 클래스 같은)
 * 싱글톤은 하나의 인스턴스(객체)만 생성되는 것을 말한다.
 * 코틀린에서는 object 키워드를 사용하여, 싱극톤 객체를 정의할 수 있다.
 *
 * 싱글톤 객체는 최초 사용시점에 하나만 생성되어, 프로그램이 실행되는 동안 계속 유지된다.
 * ★ 싱글톤은 시스템의 자원 사용과 부담을 줄기오 객체를 공유할 수 있다는 장점 있음
 * ★ 다중 스레드로 실행될 때는 반드시 하나의 객체만 생성되도록 동기화 처리를 해주어야 함
 *
 * Object 키워드 사용하는 방법 3가지
 * 1. 객체 선언 2. 객체 표현식 3. 동반 객체
 *
 * Observer
 * 함수로 직접 요청 안했지만 시스템 혹은 루틴에 의해 동작하는 것을 이벤트라고 부르며 이 이벤트 발생시마다
 * 즉각적으로 처리하도록 만드는 패턴을 의미한다.
 * > 이벤트를 수신하는 클래스
 * > 이벤트의 발생 및 전달 클래스
 * > 콜백 - 이벤트를 넘겨 주는 것을 의미한다.
 *
 *
 * 데이터 클래스
 * : 데이터를 저장하기 위해 특별히 설계된 클래스
 * : 강력한 데이터 처리 기능을 가짐!
 * 데이터 클래스는 class 키워드 앞에 data 키워드를 추가하여 정의.
 *
 *
 * 연산자 오버로딩
 *
 *
 * */


fun main() {
    Game.play()
}

// 1. 객체 선언 - 상태 관리에 유용함. 프로그램이 실행되는 동안 지속적으로 어떤 상태 정보를 유지 관리할 필요 있을 때 특히
// 초기화 블록이 포함 될수 있다. - 최초로 사용되는 시점에 하나의 객체가 자동 생성되어 초기화 되기 때문. >> 객체 생성시 실행 필요 있는 코드 포함해야함
// 생성자는 가질 수 없다.
// 객체 선언에도 일반 클래스 처럼 속성과 함수가 포함될 수 있다.
// 게임 로직 처리 코드 , 게임 루프, player, room 인스턴스 생성하하는 것을 Game 객체 안에 두어야 한다.
// ↓ 모든 게임 로직이 포함될 것이다.

object Game{

    private val player = Player("Carrie")
    private var currentRoom: Room = TownSquare()


    // 중첩 클래스 - Game 객체에서만 필요하고 다른 코드에서는 사용하지 않기 때문에 중첩 시킴
      private class GameInput(arg: String?){
            private val input  =arg ?:""
            val command = input.split(" ")[0]
            val argument = input.split(" ").getOrElse(1,{ "" })

            fun  processCommand() = when(command.toLowerCase()){
                else -> commandNotFound()
            }
            private fun commandNotFound() = "적합하지 않은 명령입니다 !"
        }

        init{
            println("방문을 환영합니다.")
            player.castFireball(10)
        }

        fun play()
        {
            while(true){
                // 게임 시작
                println(currentRoom.description())
                println(currentRoom.load())

                printPlayerStatus(player)

                print("> 명령을 입력하세요 : ")
                println("최근 명령 : ${readLine()}")
            }
        }

        private fun printPlayerStatus(player: Player){
            println("player's name is ${player.nick}")
        }
}

// 2. object 키워드로 정의된 것이 객체 표현식이며,
// {} 안에 정의된 코드가 익명 클래스의 몸체를 정의한 것.
// 이 익명 클래스의 인스턴스는 위의 코드가 실행될 때 생성과 초기화된다.
val abandondedTownSquare = object : Room("room name") {
    override fun load() = "오잉?"
}

// 3. 동반객체
// 객체 선언과 유사 하나, 최상의 수준에서 사용 X, 클래스 내부에 정의하여 사용
//


// data class
// * 데이터 클래스
// * : 데이터를 저장하기 위해 특별히 설계된 클래스
// * : 강력한 데이터 처리 기능을 가짐!
// * 데이터 클래스는 class 키워드 앞에 data 키워드를 추가하여 정의.

// 데이터 클래스를 정의하면, 이 클래스의 속성에 맞게 처리되는 toString, equals, hashCode 함수들을 코틀린 컴파일러가 자동으로 생성해줌.
// 자동 생성되는 함수들이 데이터 클래스의 모든 속성을 처리할 수 있게 하려면 반드시 기본 생성자에 속성들을 지정해야 함.
data class Coordinate(val x:Int, val y: Int){
    val isInBounds = x>=0 && y>=0

    operator fun plus(other: Coordinate) = Coordinate(x + other.x , y + other.y)
}


// 해체 선언

// enum Class
// 코틀린에서는 enum 클래스가 각 항목에 대해
// 내부적으로 name(항목 이름, string 타입) 과 ordinal(항목 위치, Int 타입) 속성을 갖는다.
//
enum class Direction(private val coordinate: Coordinate){
    NORTH(Coordinate(0,-1)),
    EAST(Coordinate(1,0)),
    SOUTH(Coordinate(0,1)),
    WEST(Coordinate(-1,0)) ; // 제일 끝에 세미 콜론!

    fun updateCoordinate(playerCoordinate: Coordinate) =
//        Coordinate(playerCoordinate.x +coordinate.x,
//        playerCoordinate.y +coordinate.y)
        coordinate + playerCoordinate

}

fun getDirectionName(direction: Direction) =
    when(direction){
        Direction.NORTH -> "북"
        Direction.EAST -> "동"
        Direction.SOUTH -> "남"
        Direction.WEST -> "서"

    }

---

인터페이스와 추상 클래스

↓ 아래 유튜브 링크 이해하기 매우 쉽다!

https://mond-al.github.io/kotlin-visibility-internal.html

https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.text/trim-indent.html

https://www.youtube.com/watch?v=UpJ5r67oDfY&list=PLg3A12oL1JCNnsU2qTQGDJelJwu4pruji&index=3 

 

import javax.print.DocFlavor

/**
 *
 *
 * 인터페이스(abstract 보다 좀 더 추상) == 규칙 / 규약
 * >> 자바나 코틀린은 다중 상속 안되는데, 기능을 무한정으로 늘려갈 수 있음
 * >> 추상클래스는 생성자가 있지만, 인터페이스는 생성자가 없다.
 *  추상화 메소드임에도 , abstract, open 등이 모두 생략되어있음
 *  ★ 생성자 자체가 없으니까 생성자 호출이 없고, 인스터스 생성 자체가 안됨( 추상 클래스는 생성자는 있지만 추상 메서드를 하나라도 구체화 하지 않으면, 생성자가 불려지지는 않음 == 인스턴스화 되지 못함)
 *
 *
 * Abstract 추상클래스 - 추상 메소드 : 노바디
 * 추상 클래스의 인스턴스는 생성할 수 없음.
 *
 * 구체화/ 추상화
 * >> Red 에서 Flock 으로 가는 정도는 추상화 된 것
 * >> Flock 에서 Red로 가는 정도는 구체화 된 것
 * */

// 새총위에 올려진다. 고무줄을 당긴다. 발사되어 날아간다.
// 장애물에 부딪혀 충격을 주다. 비행을 마치다.

// 새 : 이름 , 공격력, 공격력 가중치 , 상태, 컬러
// >> RED 를 잘 설계 해서 다른 색의 새들을 파생 시킬 거임

enum class Color(val hexColor: String)
{
    RED("FF0000"), GREEN("00FF00"), BLUE("0000FF"),
    BLACK("000000"), YELLOW("FFFF00"), WHITE("FFFFFF")
}

enum class Status(val exp: String)
{
    NONE("비행 시작 전의"), READY("새총 위에 준비된"), SHOT("발사된"),
    FLYING("날아가는"),CRASHED("충돌한"), END("비행을 완료한")
}

// 고무줄 인자 LENGTH
private val LENGTH = 20

 /**
  * class Red 를 Flock(가금류) 로 바꿔야함 (공통적으로 쓰려고)
 2가지 함수는 새마다 달라져야 한다. "추상화 함수" abstract - 바디 없음
 abstract 아닌건, concrete 함수. 구체화 함수라고 말함.
 ★ 추상화 메소드(코딩이 완료 되지 않은)  갖는다면 해당 클래스가 추상화 클래스가 되어야 한다. → 나는 현재 추상화 메소드가 있기 때문에 인스턴스를 만들 수 없다~
  */
abstract class Flock {
    lateinit var name: String // 나중에 setter로 설정할 수 있게끔 lateinit 사용 되어 있다.
    open val color: Color = Color.RED // override 할 수 있게끔 open
    var power: Double = 10.0
    open val weight: Double = 1.1 // 가중치
    var status: Status = Status.NONE
    open val type: String = "Red" // 신규 추가 프러퍼티


    // 2차 생성자 - 자신의 이름 표시
//    constructor(name: String): this(){
//        this.name = name
//    }

    // Any 타입한테 물려 받은 걸 재 정의 toString
    override fun toString(): String {
        // exp : status enum의 프로퍼티
        return "${status.exp} ${name} ${type}새 (power = ${power}, weight = ${weight})"
    }

     // concrete 구체화 함수. 상속을 생각해서 private → protected 로 바꿔줘야 함.
     protected fun getRandom(max : Int = 10) = (Math.random()*max).toInt() + 1
     protected fun getDamage() = power * weight * getRandom()

    // 새총위에 올려지다.
    fun readyForShoot()
    {
        // 아래 this : 자기 자신, toString 자동 호출 되어 위의 return 값 나올 것임
        println("step1: ${this}가 새총 위에 올려지다.")
        // 상태 바꿔주기
        this.status = Status.READY
    }

    // 고무줄을 당기다.
    fun adjustAngleLength(){
        println("step1: ${this}가 고무줄이 당겨저 발사되다.")
        this.power += getRandom(LENGTH) *this.weight
        println("\t >> 결정된 power: ${power}")
        this.status = Status.SHOT
    }

    // 발사되어 날아가다. → abstract : 바디 없게 - 다른 Red 나 Blue 에서 오버라이드해서 쓰게끔 유도 하고 있다.
    abstract fun flyAtterShoot()
//    {
//        println("step3: ${this}가 공중으로 날아가다.")
//        this.status = Status.FLYING
//    }

    // 장애물에 부딪혀 충격을 주다. → abstract : 바디 없게
    abstract fun crashWithDamage()
//    {
//        println("step 4: ${this}가 장애물에 부딪혀 충격을 주다.")
//        println("\t >> 입힌 총 대미지 : ${java.lang.String.format("%.2f", getDamage())} 점")
//        this.status = Status.CRASHED
//    }

    // 비행을 마치다.
    fun landingForEnd()
    {
        println("step5: ${this}가 비행을 마치다.")
        println("-".repeat(80)+"\n")
        this.status = Status.END
    }
}


// 추상화 메소드임에도 , abstract, open 등이 모두 생략되어있음
// 사용할 떄에는 override 를 통해 사용 하면 됨.
interface Spliter {

    fun splitBirds()
    fun splitDamage(vararg birds: String)


}

// 안에 3마리로 분리되는 고유한 기능을 담고 있다.
class Blues(_name:String): Flock(),Spliter
{

    init {
        super.name = _name
        super.power = 8.0
        status  = Status.NONE

//        color = Color.BLUE  // err - val 이니까 변경 안되지만, Flock 클래스에서 상속 가능하게 해두었기 떄문에
//        weight = 1.3 // err
    }

    override val color: Color = Color.BLUE

    override val type: String = "Blues"

    override val weight: Double = 1.3

    // 자신만의 기능이 있음 - 3마리로 split 됨.
    // 재정의 Spliiter 인터페이스 통해서 옴
    override fun splitBirds()
    {
        println("\t>> 짐, 제이크, 제이 세마리 새들로 분리 되어 날아간다.")
    }

    override fun splitDamage(vararg birds: String)
    {
        for (bird in birds){
            println("\t>> '${bird}'기 장애물에 부딪혀 충격을 주다.")
            println("\t>> 입힌 총 대미지: ${java.lang.String.format("%.2f",getDamage())}' 점")

        }
    }


    // Flock 클래스로 부터 오버라이드
    override fun flyAtterShoot() {
        println("step3 : ${this}가 공중으로 날아가다.")
        splitBirds()
        this.status = Status.FLYING
    }

    override fun crashWithDamage() {
        println("step4: ${this}가 장애물에 부딪혀 충격을 주다.")
        splitDamage("Jim Blue새", "Jake Blue새", "Jay Blue새")
        println("\t>> 입힌 총 대미지: ${java.lang.String.format("%.2f",getDamage())}' 점")
        this.status = Status.CRASHED
    }

}


/** 상속 받자!
상속 받은 클래스에 있는 것은 없애자~
 */
 class Red(_name: String): Flock() {

    init {
        super.name = _name
    }

    /** 재정의! 해야함 - 반드시!! implement ovveride */
    override fun flyAtterShoot()
    {
        println("step3: ${this}가 공중으로 날아가다.")
        this.status = Status.FLYING
    }

    // 장애물에 부딪혀 충격을 주다. → abstract : 바디 없게
    override fun crashWithDamage()
    {
        println("step 4: ${this}가 장애물에 부딪혀 충격을 주다.")
        println("\t >> 입힌 총 대미지 : ${java.lang.String.format("%.2f", getDamage())} 점")
        this.status = Status.CRASHED
    }


}
fun main() {
//    val bird1 = Red()
//    bird1.name = "레드1" // lateinit을 사용해서

//    val bird1 = Red("지영")
//    println("bird1 = ${bird1}")
//    bird1.readyForShoot()
//    bird1.adjustAngleLength()
//    bird1.flyAtterShoot()
//    bird1.crashWithDamage()
//    bird1.landingForEnd()
//
//    println()
//    listOf<Red> (Red("길동"),Red("영희"),Red("꺽정")).forEach {
//        it.readyForShoot()
//        it.adjustAngleLength()
//        it.flyAtterShoot()
//        it.crashWithDamage()
//        it.landingForEnd()
//    }

    println()
    listOf<Blues> (Blues("철수"),Blues("안나"),Blues("대산"))
        .forEach {
            with(it) {
                // with 함수에 it을 받아서 객체가 this 문맥에 들어 온다.this 문맥에 깔려 있기 때문에 아래 it. 을 생략한다.
                readyForShoot()
                adjustAngleLength()
                flyAtterShoot()
                crashWithDamage()
                landingForEnd()
            }
    }
}

 

exitProcess : 코틀린 표준 라이브러리 함수. 현재 실행 중인 JVM 인스턴스(우리 프로그램)을 중단 시킴.

import kotlin.system.exitProcess