#Kotlin 수업 정리 2

import java.lang.reflect.Constructor
import java.security.MessageDigest
import java.util.Collections

//클래스

class MyClass /* 주 생성자 */ constructor(
    var memberConstructorVariable: String,
    parameterConstructorVariable: String
) {

    //멤버 속성 -> 필드
    var variable: String = ""
    val constant: String = ""

    init {
        variable = parameterConstructorVariable + "Variable"
        println("초기화 함수")
    }

    //부생성자
    constructor(
        parameterConstructorVariable: String
    ) : this("", parameterConstructorVariable) {
        //코틀린의 클래스에서 사용되는 생성자 함수에서는 몸체를 가지지 않을 수 있다.
        println("부생성자")
    }

    private var mVarVar: Int = 0

    //변수 : 값 변경가능 -> read/write 동시 가능 -> getter, setter 둘 다 가능
    var varVar: Int
        //getVarVar()
        get() {
            return mVarVar
        } //감춰진 필드(Backing Field)
        //setVarVar(newValue: Int)
        set(newValue) {
            mVarVar = newValue
        }

    //상수 : 값 변경불가 -> read-only -> setter 불 가능 getter 만 가능
    //별도로 get 만 적을 경우 get 만 사용 가능 .
    //val 이라고 적을 시 set 을 넣는 순간 ide 에서 빨간줄로 알려줌 !
    val constVar: Int = 0
        //요거는 backing field 임.
        //get 을 선언할 경우 초기화 불가
        get() {
            return field
        }

    // 멤버 기능 -> 함수
    fun func(param1: Int) {
        println("func(param1: Int)")
    }

    //함수 오버로딩
    fun func() {
        println("func()")
    }

    fun func(param1: Int = 0, param2: Int) {
        println("func(params1: Int = 0 => ${param1}, params2: Int => ${param2})")
        println(this)
        println(this::class)
        println(MyClass::class)
    }


    companion object {
        //클래스 변수 선언
        const val classConstVal: Int = 1 //우리가 코드를 작성할 때 입력한 리터럴만 가능
        val classVal: Int = 2
        var classVar: Int = 3

        //클래스 함수 선언
        fun classFunc() {
            println("classFunc")
        }
    }
}

//싱글톤 객체
object MySingleTon {
    var varVar: Int = 10
    fun objectFunc() {

    }
}

//열거형
//이넘에다가 함수도 넣을 수 있음
enum class MyEnum constructor(
    var value: String
) {
    A("97"),
    B("96"),
    C("95"),
    D("94");

    fun myEnumFunc() {
        println(this::myEnumFunc)
    }

    companion object {
        fun companionMyEnumFunc() {
            println(this::companionMyEnumFunc)
        }
    }
}


//데이터 클래스 => 자체만 객체화 하고 싶을 때 사용한다.
// equals, hashCode 등의 함수를 자동으로 생성해준다. => 값 비교 등 알아서 만들어준다.
data class MyData(
    var index: Int,
    var value1: Int,
    var value2: String
)

fun test() {
    listOf(
        MyData(1,0, "String"),
        MyData(2,0, "String"),
        MyData(3,0, "String"),
        MyData(4,0, "String")
    ).filter {
        it.index == 0
    }
}

//sealed 클래스 추상 클래스이며, 상속받는 자식 클래스의 종류를 제한.
//봉인 클래스
sealed class Color constructor(
    val r: Int,
    val g: Int,
    val b: Int
) {
    object Red : Color(255, 0, 0)
    object Green : Color(0, 255, 0)
    object Blue : Color(0, 0, 255)
}

//abstract : 속성 또는 함수를 상속 후 자신 클래스 수준에서 구현하도록 강제하는 클래스(추상화)

//interface : 속성 또는 함수를 상속 후 자신 클래스 수준에서 구현하도록 강제하는 클래스(추상화) 강제성

//상속:


fun main(args: Array<String>) {

    //싱클톤 호출
    var m1 = MySingleTon
    MySingleTon.varVar = 20
    println(MySingleTon.varVar)

    //instance -> Heap 메모리 영역에 저장 + 사용
    var myClass = MyClass("Parameter")
    //Getter 호출
    println(myClass.memberConstructorVariable)
    //Getter 호출
    println(myClass.variable)

    myClass.func()
    myClass.func(0)
    myClass.func(1, 2)

    //Class -> Code 메모리 영역에 저장 + 사용
    println(MyClass.classConstVal)
    println(MyClass.classVal)
    println(MyClass.classVar)

    var myClass2 = MyClass("SingleTonPattern")

    println("Program arguments: ${args.joinToString()}")
}