Kotlin ) intelliJ IDE 설치, Kotlin 기초

1. IntelliJ다운로드 및 설치

2. 프로젝트 생성

다운로드가 완료되면

3. 코틀린 기초

3.1. 출력문

3.2. 리터럴

3.2.1. 리터럴의 종류

리터럴 : 코드 작성시에 값을 작성하는 문법

정수(Int, Long) : 100, 100L, 1_000_000
- 정수 자료에 L이 붙으면 Long 형 자료를 의미한다.
- 큰 값의 정수를 구분하기 편하게 하기위해 천 단위 구분기호(,)와 같은 기능으로 '_'를 중간에 넣을 수 있다.
실수(Double, Float) : 11.11, 22.22F
- 'F'가 사용되면 Float형 자료이다.
문자(Char) : 'A', 'B'
문자열(String) : "문자열"
진위 논리 리터럴 : println(false)

//정수 리터럴
println(100)                // Int
println(1000000000000000)   // Long
println(1000000000000000L)
println(938_545_245_245);   
//실수 리터럴
println(11.11)
println(22.22F)
// 문자 리터럴
println('A')
println('가')
// 문자열 리터럴
println("문자열")      // String
//진위 논리 리터럴
println(true)
println(false)
// 참고로 '자료형은 모두 첫글자 대문자로 시작'한다.

// 복수행 String
println("동해물과 백두산이\n마르고 닳도록\n하느님이 보우하사\n우리나라 만세\n")
println("""동해물과 백두산이
    |마르고 닳도록
    |하느님이 보우하사
    |우리나라 만세""".trimMargin())
// .trimMargin() : 호출객체가 되는 문자열에 각행의 앞뒤공백 및 행의 시작문자 ('|')를 제거해주는 함수.
// 큰 따옴표 세개를 이용하여 복수행의 문자열을 하나의 데이터로 다룰 수 있다.

3.2.2. 변수와 자료형

자료형의 이름 첫 글자는 대문자로 쓰여진다.

정수 : Long(8), Int(4), Short(2), Byte(1)
부호가 없는 정수형 : ULong(8), UInt(4), UShort(2), UByte(1)
- U가 붙은 자료형은 'Unsigned를 의미'하며, '음수가 없는 자료형'을 칭한다.
- Int가 -21억 ~ 21억의 표현범위라면, UInt는 0~42억까지의 표현범위를 갖는다
실수 : Double(8), Float(4)
논리 : Boolean(1)
문자 : Char(2)
문자열 : String

3.2.3. 변수의 선언

var : 변수 선언 후 다시 값을 담을 수 있다.
val : 변수 선언 후 다시 값을 담을 수 없다.

변수 선언 방식 -> var/val 변수명:타입 = 값
타입을 생략 시 저장하는 값에 따라 자료형이 자동으로 결정된다.

// Int a = 100;     // - 자바의 선언 방식
val a:Int = 100; // - 코틀린의 선언 방식

val a1:Int = 100        // 변수명 뒤에 ':'를 쓰고 자료형을 이어서 씀으로써 변수를 선언한다
println("a1 = ${a1}")   // ${}안에 변수명을 넣어 변수의 값을 출력문구와 함께 출력한다
println("a1 = $a1")     // 리터럴 출력이 아닌 '변수 출력'인 경우 ${}에서 {}를 생략할 수 있다.
val a2:Int = 100        // 변수 선언시 자바스크립트처럼 자료형을 생략하면 저장하는 값에 따라 자동으로 자료형이 결정된다.
println("a2 = $a2")

var a3:Int = 100
val a4:Int = 100

// var변수는 값을 바꿀 수 있고, val은 초기화된 값을 변경할 수 없다.
a3 = 200
println("var a3 : $a3")

// val변수는 값을 다시 저장하지 못한다.
// a4 = 200 //에러발생
println("val a4 : $a4")

3.2.4. 변수의 null check

코틀린은 변수 선언 시 '그 변수가 null값을 가질 수 있는 변수인지, 아닌지 결정이 가능'하다.
일반적인 변수 선언은 null값을 허용하지 않는다.
이것은 프로그래밍시 null값이 저장되어 발생하는 오류를 방지하기 위함.
변수 선언 시, '자료형 뒤에 '?' 를 붙여 null을 허용'하게 할 수 있다.

var/val 변수명:자료형 = 값  // -> null 허용하지 않는 변수
var/val 변수명:자료형? = 값 // -> null 허용 변수

// var a5:Int=null  //에러발생
var a5:Int=100
println("a5 : $a5")

var a6:Int? = null
println("a6 : $a6")

var a7:Int? = a5
println("a7 : $a7")

// var a8:Int =a6  //에러
// a8은 null을 허용하는 변수가 아니므로 아래 명령은 에러

// * 코틀린은 모든 기본 타임 변수 및 값을 객체로 변환하여 사용합니다. *

3.3. Function

fun 함수이름(매개변수) : 리턴타입 {
	코드들..
}

3.3.1. 기본 함수(전달인수x, 반환x)

fun main(){
    test1();
}

// 기본함수 (전달인수 없고 반환값이 없는 함수)
fun test1(){
    println("test1함수 호출")
    println("-------------")
}

3.3.2. 전달인수가 있는 함수

fun main(){
     val a3:Int=200
     test2(50, 12.23);   // test2()함수 호출
     // 매개변수가 있는 함수를 호출할 때, 전달인수를 넣는 동작이 하나하나 끝날 때 마다 '매개변수명 : '을 인텔리제이가 전달인수 앞에 붙여준다.
     // 자동으로 입력되는 사항이니, 수동으로 입력ㄴㄴ

     test2(a3, 12.23);   // test2()함수 호출
     // 변수가 전달인수로 전달될 때는 앞에 매개변수명이 붙지 않는다.

     test2(a2=123.12, a1=300);
     // 다른 프로그래밍 언어와 마찬가지로, 전달인수의 순서는 매개변수의 기술된 순서에 맞춰 작성해야한다.
     // 다만 위와 같이 매개변수의 순서를 바꾸고자 한다면, '매개변수명='을 작성하여, 전달인수와 매개변수의 짝을 맞춰주면 가능하다.
}

fun test2(a1:Int, a2:Double ){
    println("test2함수 호출")
    println("a1:$a1")
    println("a2:$a2")
    println("-------------")
}

3.3.3. 매개변수에 기본값(defaultr값)이 지정된 함수

fun main(){
     test3(100, 11.11);
     test3(200);
     // a2에 전달할 값이 생략되어 기본값 0.0이 a2변수에 대입된다.
     test3(a2 = 30.123)
     // a1에 전달할 값을 생략하려면 매개변수 이름을 써서 전달값만 전달한다.
     test3()
     // 모두 생략도 가능하다(default값이 있기 때문!)
}

// 매개변수에 기본값(디폴트)가 지정된 함수 : 해당 매개변수에 전달된 값이 없으면, 기본값이 변수에 대입된다.
fun test3(a1:Int = 0, a2:Double=0.0 ){
    println("test3함수 호출")
    println("a1:$a1")
    println("a2:$a2")
    println("-------------")
}

3.3.4. return(반환값)이 있는 함수

toInt() : 변수 또는 리터럴의 형변환(toInt -> Int로 변환)

fun main(){
     val r1:Int = test4(100,200.12)
     println("r1 : $r1")
     val r2:Int = test4(1000, 2000.123)
     println("r2 : $r2")
}

// 리턴(반환값)이 있는 함수
// fun 함수 이름(매개변수):리턴값의 자료형 { }
fun test4(a1:Int, a2:Double ) : Int {
    println("test4 호출")
    val result:Int = a1 + a2.toInt()
    return result
}   // 변수 또는 리터럴 .toInt() -> 변수 또는 자료형의 형변환(정수로 변환)

3.3.5. 반환값이 없는 함수 (Unit)

fun main(){
     test5()
     test6()
}

// Unit : void의 의미로 사용되며, 대부분은 생략된 채로 사용된다.
fun test5():Unit{
    println("test5 호출")
    println("--------------------")
}

fun test6(){
    println("test6 호출")
    println("----------------------------")
}

3.3.6. 오버로딩(Overloading)

fun main(){
     test7()
     test7(100)
}

// 함수의 오버로딩 - 매개변수의 형태와 갯수를 달리한 같은 이름의 함수들을 정의하여 사용한다.
fun test7(){
    println("test7 호출 - 매개변수 x")
    println("------------------------------")
}
fun test7(a1:Int=200){
    println("test7 호출 - 매개변수 한 개(Int:$a1)")
    println("----------------------------")
}

3.3.7. 함수 내부의 함수

fun main(){
     fun test10(){
         println("test10 호출")
     }
     test8()
     // test9()     // 에러 (불가능)
     test10()
}

// 함수 내부의 함수
fun test8(){
    println("test8 호출")
    fun test9(){
        println("test9 호출")
    }
    test9()
}

4. 예제

국어, 영어, 수학 점수를 입력 받아서 총점 평균 성적표 양식에 맞춰 출력하세요

package days01

import java.text.DecimalFormat

fun main(){
    // 코틀린의 화면 입력
    // 국어, 영어, 수학 점수를 입력 받아서 총점 평균 성적표 양식에 맞춰 출력하세요
    print("국어점수 입력 : ")
    val kor:Int = readLine()!!.toInt()
    print("영어점수 입력 : ")
    val eng:Int = readLine()!!.toInt()
    print("수학점수 입력 : ")
    val mat:Int = readLine()!!.toInt()

    val tot:Int = sum(kor,eng,mat)
    val avg:Double = average(tot)
    prn(kor, eng, mat, tot, avg)

}

fun sum(kor:Int, eng:Int, mat:Int) : Int{
    return kor + eng + mat
}

fun average(tot:Int) : Double {
    return tot/3.0
}

fun prn(kor:Int, eng:Int, mat:Int, tot:Int, avg:Double):Unit{
    val df1 = DecimalFormat("#,##0.0")
    println("\t\t===성적표===")
    println("-----------------------------------")
    println("국어\t영어\t수학\t총점\t평균")
    println("-----------------------------------")
    println("$kor\t\t$eng\t\t$mat\t\t$tot\t\t${df1.format(avg)}\t")
    println("-----------------------------------")

}

5. 연산자

5.1. 단항 연산자

항이 하나인 연산자

5.1.1. + : +양수 -> 양수 / +음수 -> 음수

val a1 : Int = 10;  val a2:Int = -10;

// + : +양수 -> 양수, +음수 -> 음수
val r1 : Int = +a1; val r2:Int = +a2;
println("a1:$a1, r1:$r1");
println("a2:$a2, r2:$r2");

5.1.2. - : -양수 -> 음수 / -음수 -> 양수

val a1 : Int = 10;  val a2:Int = -10;

// - : -양수 -> 음수, -음수 -> 양수
val r3:Int = -a1;   val r4:Int = -a2;
println("a1:$a1, r3:$r3");
println("a2:$a2, r4:$r4");

5.1.3. ! : !true -> false / !false -> true

val a3:Boolean = true;  val a4:Boolean = false;

// ! : !true -> false , !false ->true
val r5:Boolean = !a3;   val r6:Boolean = !a4;
println("a3:$a3, r5:$r5");  println("a4:$a4, r6:$r6");

5.2. 이항 연산자

val r11:Int = 10 + 3
val r12:Int = 10 - 3
val r13:Int = 10 * 3
val r14:Int = 10 / 3
val r15:Int = 10 % 3

println("$r11, $r12, $r13, $r14, $r15")

5.3. 비교 연산자

    val a14:Int = 10
    val r17:Boolean = a14 == 10;    val r18:Boolean = a14 != 10;
    println("$r17, $r18")
    val r19:Boolean = a14 == 20;    val r20:Boolean = a14 != 20;
    println("$r19, $r20")

    println("-------------------------------------")

    val a15:Int = 10
    val r21:Boolean = a15 < 20;     val r22:Boolean = a15>20
    val r23:Boolean = a15 <= 10;     val r24:Boolean = a15>=10
    println("$r21, $r22, $r23, $r24")

5.4. IntRange

데이터의 범위를 나타내는 관리데이터

val r16:IntRange = 10..20 // 10부터 20까지의 영역데이터(관리데이터)
println("r16 : $r16")   // 출력 : 10..20 내부숫자 11개를 모두 출력하려면 반복실행이 필요

val r25:IntRange = 20..30
var r26:IntRange = 50..60
println("r25 : $r25, r26 : $r26")

println("-------------------------------------")

print("r16 : ")
for(item in r16){
    print("$item ")
}

println()

print("r25 : ")
for(item in r25){
    print("$item ")
}

println()

print("r26 : ")
for(item in r26){
    print("$item ")
}

6. if문

6.1. 기본 if문

val a1:Int = 10

// 기본 if문
if(a1==10) println("a1은 10이다")

if(a1!=10){
    println("a1은 10이 아니다")
}

6.2. else문

val a1:Int = 10

// else문 : 조건식이 만족하지 않을 경우 수행
if(a1==10)println("a1은 10이다")
else{
    println("a1은 10이 아니다")
}

if(a1==20)println("a1은 20이다")
else{
    println("a1은 20이 아니다")
}

6.3. else-if문

val a1:Int = 10

// else if
if(a1==5){
    println("a1은 5이다")
}else if(a1==10){
    println("a1은 10이다")
}else if(a1==20){
    println("a1은 20이다")
}else{
    println("a1은 5, 10, 20이 아니다")
}

6.4. 코틀린에서의 if문의 변형 사용

// 코틀린에서만 사용할 수 있는 if문의 변형 사용

// 예제1
val a6:String = if(a5==10) "10이다" else "10이 아니다"
println("a6:$a6")

println("----------------------------------")

// 예제2
val a7:String = if(a5==10){
    println("블록1 수행")
    "10입니다"     // 변수에 입력될 값은 각 경우에 해당하는 영역 맨 마지막에 작성된다.
}else{
    println("블록2수행")
    "10이 아니다"
}
println("a7:$a7")

7. when문

자바에는 switch문이 있다면, 코틀린에는 when문이 있다.
구조적으로는 비슷하지만 몇가지 차이점이 있으니 비교하며 학습해보자.

val a1 = 10

// switch-case문법과 비슷하다. 각 case를 '->'로 표시하고, break를 작성하지 않아도 된다.
when(a1){
    1 -> println("a1은1이다")
    2 -> {
        println("수행되는 코드")
        println("a1은 2이다")
    }
    3-> println("a1은 3이다")
    else -> println("a1은 1,2,3이 아니다. a1:$a1")
}

val a2 = 3

when(a2){
    1, 2 -> println("a2는 1 또는 2")
    3, 4 -> println("a2는 3 또는 4")
    5, 6 -> println("a2는 5 또는 6")
    else -> println("a2는 1 ~ 6이 아닙니다")
}   // (,)로 구분하여 두 가지의 경우를 하나의 case로 처리 가능

val a5 = 5

when(a5){
    in 1..3 -> println("a5는 1~3 사이의 숫자")
    in 4..6 -> println("a5는 4~6 사이의 숫자")
    in 1..6 -> println("a5는 1~6 사이의 숫자")
    else -> println("a5는 1~6사이의 숫자가 아닙니다")
}   // in 키워드와 .. 연산자를 이용하여 범위를 골라내는 case를 작성할 수 있다.

val a6 = 20

val str:String = when(a6){
    10 -> "a6는 10이다"
    20 -> {
        println("두 번째 경우의 수")
        "a6는 20이다"
    }
    30 -> "a6는 30이다"
    else -> "a6는 10~30이 아닙니다."
}   // 각 케이스에서 선택된 값을 결과로 반환하여 변수의 값으로 활용할 수 있다.
println("str : $str");

fun main(){

    // setValue()메서드 활용
    val str1 = setValue(10)
    val str2 = setValue(20)
    val str3 = setValue(30)
    val str4 = setValue(40)
    
    println("str1:$str1")
    println("str2:$str2")
    println("str3:$str3")
    println("str4:$str4")

} 

// when이 내장되어있는 setValue()메서드 생성
fun setValue(a1:Int)= when(a1){
        10->"a1는 10이다"
        20->"a1는 20이다"
        30->"a1는 30이다"
        else->"a6는 10~30이 아닙니다."
}

8. 특별한 함수식

8.1. 자료형의 생략

코틀린에서 변수를 선언하면 보통 변수명 옆에 콜론( : )과 함께 자료형을 기술한다.
하지만, 변수를 선언할 때 초기화 되는 값의 자료형이 명확하다면 변수선언의 자료형은 생략이 가능하다.

함수의 리턴값을 담는 변수에도 마찬가지

fun main(){

    // 함수의 리턴값의 자료형이 Int자료형으로 명확하기 때문에 따로 변수의 자료형을 쓰지 않는다.

    val r3 = testFun1(100, 200)
    println("r3(testFun1()의 결과): $r3")	// r3(testFun1()의 결과): 300

    val r4 = testFun2(100, 200)
    println("r4(testFun2()의 결과): $r4")	// r4(testFun2()의 결과): 300

    val r5 = testFun3(100, 200)
    println("r5(testFun3()의 결과): $r5")	// r5(testFun3()의 결과): 300
}

// 1. 함수의 리턴값이 호출된 곳에서 리턴값을 받는 변수의 자료형을 결정한다.
fun testFun1(a1: Int, a2: Int): Int{
    return a1 + a2
}

// 2. 함수의 리턴값이 간단한 수식으로 해결된다면 '='와 함께 연결하여 return명령을 대신한다.
// testFun1과 testFun2는 같은 동작을 수행.
fun testFun2(a1: Int, a2: Int): Int = a1 + a2

// 3. 리턴값의 자료형이 아래와 같이 정수와 정수의 연산이어서 그 결과도 정수라면,
//  그리고 그 정수가 리턴될 것이라면 함수의 리턴자료형도 생략이 가능하다.
fun testFun3(a1: Int, a2: Int) = a1 + a2

testFun1()
- 함수의 리턴값이 호출된 곳에서 리턴값을 받는 변수의 자료형을 결정
testFun2()
- '='로 return명령을 대신한다.
testFun3()
- 함수의 리턴자료형도 생략이 가능

8.2. 람다식 선언

함수의 간략형 표현으로 함수의 몸체를 변수에 담아 사용하도록 변형한 형태.

val lambda1 : (Int, Int) -> Int = {a1:Int, a2:Int -> a1 + a2 }  // 람다식의 풀버전

val r6 = lambda1(100, 200)
    println("r6(lambda1()의 결과): $r6")	// r6(lambda1()의 결과): 300

{ a1:Int, a2:Int -> a1 + a2 } 앞에 정의된 자료형에 맞춰 사용되는 실제 매개변수와 연산식 & 리턴값

(Int, Int) : 매개변수의 갯수와 자료형
Int = { , -> a1 + a2 } : 리턴값의 자료형과 리턴값
lambda1 : 함수명

8.2.1. 함수의 원형(헤더)을 생략한 형태

val lambda2 = {a1:Int, a2:Int -> a1 + a2 }  // 매개변수, 리턴값의 자료형이 명확하다면 ':'이후부터 '='이전 까지 생략이 가능ㅎ다.
// (Int, Int) -> Int : '함수의 원형(헤더)을 생략'한 형태

val r7 = lambda2(100, 200)
println("r7 : $r7")	// r7 : 300

8.2.2. 함수 바디의 자료형을 생략한 형태

val lambda3 : (Int, Int) -> Int = {a1, a2 -> a1 + a2}
// 헤더를 생략하지 않고, 함수 바디 쪽 자료형을 생략한 형태

val r8 = lambda3(100, 200)
println("r8 : $r8") // r8 : 300

8.2.3. 함수 바디가 다중라인인 형태

// 함수의 몸체에 여러라인의 명령이 필요한 경우 원래 함수 형태 호출
val lambda4 = { a1:Int, a2:Int ->
    var r1 = a1 + a2
    var r2 = a1 + a2
    r1 * r2     // 맨 마지막에 리턴값을 쓰면, 람다함수의 리턴값으로 인식된다.
}

val r9 = lambda4(100, 200)
println("r9 : $r9") // r9 : 90000

9. Anonymous Function ( 익명함수 )

두 개의 매개변수를 곱하여 리턴하는 익명함수를 생성한다.

// 익명함수 생성
val t1 = fun(x1:Int, x2:Int):Int{
    return x1 * x2
}

9.1. '익명함수가 전달인수'인 형태

fun main(){

    // 익명함수 생성
    val t1 = fun( x1:Int, x2:Int ): Int{
        return x1 * x2
    }

    // 익명함수를 전달인수로 전달
    testFunc1( t1, 100, 200 ) // a3 : 20000

}

// 매개변수 중 하나는 함수를 저장할 수 있는 매개변수이다.
// 함수의 '매개변수에 람다함수 헤더부분을 전달된 함수에 맞게 매개변수명 함께 작성'한다
fun testFunc1( funcName:(Int, Int) -> Int, a1:Int, a2:Int) : Unit {
    // var a3 = funcName(100,200)
    var a3 = funcName(a1, a2)
    println("a3 : $a3")
}

9.2. '전달인수에 익명함수를 기술'한 형태

fun main(){

    // 전달인수로 직접 익명함수를 기술
    testFunc1( fun( x1:Int, x2:Int ):Int{ return x1-x2 }, 300, 400 ) // a3 : -100

}

// 매개변수 중 하나는 함수를 저장할 수 있는 매개변수이다.
// 함수의 '매개변수에 람다함수 헤더부분을 전달된 함수에 맞게 매개변수명 함께 작성'한다
fun testFunc1( funcName:(Int, Int) -> Int, a1:Int, a2:Int) : Unit {
    // var a3 = funcName(100,200)
    var a3 = funcName(a1, a2)
    println("a3 : $a3")
}

9.3. '전달인수로 람다함수'를 보내는 형태

fun main(){

    // 전달인수로 람다함수를 보내는 경우 : testFunc1의 매개변수가 람다함수의 헤더이므로, 전달인수는 바디만 보내면 된다.
    testFunc1( { x1:Int, x2:Int -> x1 + x2 }, 500, 600 )      // a3 : 1100
    // 전달인수와 매개변수의 조합은 'funcName:(Int, Int) -> Int = {x1:Int, x2:Int -> x1+x2}'와 같다.
    
}

// 매개변수 중 하나는 함수를 저장할 수 있는 매개변수이다.
// 함수의 '매개변수에 람다함수 헤더부분을 전달된 함수에 맞게 매개변수명 함께 작성'한다
fun testFunc1( funcName:(Int, Int) -> Int, a1:Int, a2:Int) : Unit {
    // var a3 = funcName(100,200)
    var a3 = funcName(a1, a2)
    println("a3 : $a3")
}

9.4. '리턴값이 함수인 함수'

함수의 '자료형은 리턴되는 람다함수의 헤더( (Int, Int) -> Int )를 작성'한다
실제 리턴되는 함수의 내용은 'return 키워드와 함께 익명함수 또는 람다함수를 작성'한다.

fun main(){

    // '함수가' 리턴값으로 '리턴되어 변수에 저장'된다.
    var t2 = testFunc2()
    var r2 = t2(600, 700)   // 정수형 매개변수 두 개, 정수 리턴으로 된 함수가 리턴되어 t2에 저장되고 실행되는 형태
    println("testFunc2()가 실행되고, \n익명함수가 리턴되어 사용된 결과 : $r2")

}

// 리턴값이 함수인 함수의 정의
// 함수의 리턴자료형은 리턴되는 람다함수의 헤더( (Int, Int) -> Int )를 작성한다
// 실제 리턴되는 함수의 내용은 'return 키워드와 함께 익명함수 또는 람다함수를 작성'한다.
fun testFunc2():(Int, Int) -> Int{
    // return fun(x1:Int, x2:Int):Int{return x1*x2}    // 익명함수가 리턴값으로 사용
    return { x1:Int, x2:Int -> x1 * x2 }   // 람다함수가 리턴값으로 사용
}

10. Loop 반복문

10.1. for문

코틀린의 for문은 자바의 for(시작, 끝, 증감량){ }이 아닌, 범위데이터만 사용한다.

//  코틀린의 for문은 자바처럼 시작값 끝값 증감량 등을 사용하지 않고, 범위 데이터만 사용한다.
val a1 = 1..10
for(item in a1){
    print("$item\t")
}

println("\n-----------------------")

//  범위 데이터로 사용되는 대상은 배열, 리스트, Map, ..을 이용한 범위데이터 등이 사용된ㄷ.
val a2 = 1..10 step 2    // 2씩 증가하는 범위 데이터
for(item in a2){
    print("$item\t")
}

println("\n-----------------------")

//  10부터 1까지 줄어드는 범위데이터 사용
// val a3 = 10..1   <- 잘 못된 사용 방법
val a3 = 10 downTo 1
for(item in a3){
    print("$item\t")
}

println("\n-----------------------")

val a4 = 10 downTo 1 step 2
for(item in a4){
    print("$item\t")
}

10.2. while문 ( + do-while문 )

var a5 = 0
while(a5<10){
    print("$a5\t")
    a5++
}

println("\n-----------------------")

var a6 = 0
do{
    print("$a6\t")
    a6++
}while(a6<10)

println("\n-----------------------")

var a7 = 100
while(a7<10){
    print("$a7\t")
    a7++
}

println("\n-----------------------")

var a8 = 100
do{
    print("$a8\t")
    a8++
}
while(a8<10)

11. Array 배열

11.1. arrayOf( )

코틀린에서의 배열생성은 arrayOf( )메서드를 주로 사용한다.

// 코틀린의 배열생성은 arrayOf를 자주 이용합니다.
val array1 = arrayOf(10, 20, 30, 40, 50)
println("array1:$array1")   //클래스 이름과 해시코드등이 출력된다.
// 배열의 요소들을 한 번에 출력하려면 contentToString 함수를 사용한다.
println("array1 : ${array1.contentToString()}")

11.2. 배열의 자료형

    // 코틀린의 배열은 자료형의 제약이 없어서, 자바의 리스트 등 처럼 여러 자료형 데이터를 하나의 배열에 넣어서 사용할 수 있다.
    // 다만, 그것이 권장할 만한 동작은 아니기 때문에 자료형을 제한하는 코드가 제공되어 사용된다.

    //자료형 제약 없이 사용
    val array2 = arrayOf(100, 11.11, "문자열", true)
    println("array2 : ${array2.contentToString()}")

    // 하나의 자료로 제한하여 사용
    val array3 = intArrayOf(10, 20, 30, 40, 50) // 기본 자료형은 ArrayOf앞에 자료형을 붙여 쓰고 ( intArrayOf() )
    println("array3 : ${array3.contentToString()}")
    
    val array4 = doubleArrayOf(11.11, 22.22, 33.33, 44.44, 55.55)   // doubleArrayOf()
    println("array4 : ${array4.contentToString()}")
    
    val array5 = arrayOf<String>("문자열1", "문자열2", "문자열3")    // 객체형 자료는 제네릭을 사용한다. ( ArrayOf<> )
    println("array5 : ${array5.contentToString()}")

    // int array6 = new Int[5];
    // String str = new String[5];

11.3. null 배열

코틀린은 null을 허용하지 않는 것이 default이므로 '?'로 허용해야 한다.

var array6 = Array(5,{0})   // 다섯개의 0이 채워진 배열 생성
var str = Array<String?>(5,{null})  // 다섯개의 null이 채워진 배열. 코틀린의 변수는 null을 허용하지 않는 것이 기본이므로 이와같이 '?'를 넣어 null을 허용한다.

println("array6 : ${array6.contentToString()}")
println("str : ${str.contentToString()}")

11.4. 배열 요소 꺼내기 ( for문 )

val array1 = arrayOf(10, 20, 30, 40, 50)

// 반복실행문으로 배열 요소 꺼내기
for(item in array1){
    print("$item\t")
}

11.5. 배열객체의 메서드

println("첫 번째 값 : ${array1.first()}")
println("마지막 값 : ${array1.last()}")
println("30의 위치 : ${array1.indexOf(30)}")
println("평균 : ${array1.average()}")
println("합 : ${array1.sum()}")
println("개수 : ${array1.count()}")
println("개수 : ${array1.size}")
println("30을 포함하는가 : ${array1.contains(30)}")
println("1000을 포함하는가 : ${array1.contains(1000)}")
println("30을 포함하는가 : ${30 in array1}")
println("1000을 포함하는가 : ${1000 in array1}")

val array12 = arrayOf(5,1,3,7,10,8)

val array13 = array12.sortedArray()
println("요소를 오름차순으로 : ${array13.contentToString()}")

val array14 = array12.sortedArrayDescending()
println("요소를 내림차순으로: ${array14.contentToString()}")

12. 달력 예제

package days02

fun main(){
    print("연도 입력 : ")
    val year:Int = readLine()!!.toInt()
    print("월 입력 : ")
    val month:Int = readLine()!!.toInt()
    print("일 입력 : ")
    val day:Int = readLine()!!.toInt()

    var days:Int = sumdays(year, month, day)    // 전달인수에 year, day도 추가할 것
    // sumdays 함수안에서 월에 해당하는 날짜 수 계산할 때 when을 이용하지 말고, 배열 생성 후 반복실행과 함께 계산할 것

    val temp:Int = days%7
    val weekday:String = selectWeekday2(temp)
    println(weekday)

}

fun sumdays(y:Int, m:Int, d:Int):Int{
    var days:Int = 0
    val mdays = arrayOf(0,31,28,31,30,31,30,31,31,30,31,30,31)    //배열 생성
    if(y%4==0 && y%100!=0 || y%400==0) mdays[2] = 29    // 입력한 년도가 윤년이면 2월을 29일로 변경

    days = 365*(y-1)

    val ys:IntRange = 1..(y-1)
    for(i in ys){
        if(y%4==0 && y%100!=0 || y%400==0)days++
    }   // 입력한 년도의 전년도까지 있었던 윤년만큼 +1 반복

    var i:Int = 0
    while(i<m){
        days+= mdays[i]
        i++
    }   // 입력한 월의 전월까지 날짜를 합산

    days += d   // 입력한 일만큼 날짜 합산
    return days
}

fun selectWeekday2(t:Int) = when(t){
    1->"월요일"
    2->"화요일"
    3->"수요일"
    4->"목요일"
    5->"금요일"
    6->"토요일"
    7->"일요일"
    else->"잘못된 연산"
}

13. Class ( 클래스 )

코틀린도 자바와 마찬가지로 '객체 지향 언어'이다.

13.1. 객체생성

fun main(){

    // 생성된 클래스 형태로 객체를 생성한다.
    // 자바문법 : TestClass1 obj1 = new TestClass1();
    // 코틀린 : val 참조변수명 : 클래스명 = 클래스명()
    val obj1:TestClass1 = TestClass1()
    // 'new'를 쓰지 않는다고 새로운 공간이 만들어지지 않는 것이 아니라 '생략되어 사용될 뿐'이다.
    println("obj1:$obj1")
    
    val obj2:TestClass1 = TestClass1()  // new를 쓰지 않아도 새 공간이 할당된다.
    println("obj2:$obj2")
    
    val obj3 = obj1
    println("obj3:$obj3")

    val obj4 = TestClass2()
    println("obj4:$obj4")

}

// 클래스 선언
class TestClass1{ }   // 비어있는 클래스

class TestClass2    // 비어있는 클래스를 생성 ( {}생략 )
// 비어있는 클래스를 생성한다면 {}를 생략할 수 있다.

13.2. 멤버변수 / 메서드에 접근

package days02

fun main(){

    val obj5 = TestClass3()
    // 멤버변수에 접근하는 순간 내부적으로 getter/setter가 실행되어 값을 이용하게 된다.
    println("obj5.a1 : ${obj5.a1}") // 0
    println("obj5.a2 : ${obj5.a2}") // 100

    //obj.a1 = 100 // 에러 : 'setter가 없는 a1변수(val)는 값을 변경할 수 없다.'
    obj5.a2 = 200
    println("obj5.a2 : ${obj5.a2}") // 200
    obj5.testMethod1()  // testMethod1
    obj5.testMethod2()  // testMethod2
    
}

// 클래스 선언
class TestClass3{

    // 멤버변수 : 멤버변수는 var 또는 val로 자유롭게 생성이 가능.
    // 자료형은 초기값에 따라 결정되도록 생략 가능하다.
    
    val a1:Int = 0      // getter만 있는 val변수는 밑줄이 없다.
    var a2:Int = 100    // getter와 setter가 모두 생성되는 var 변수는 밑줄이 표시된다.
    // 코틀린 클래스에서는 생성된 멤버변수는 기본적으로 private로 생성된다.

    //멤버 메서드
    fun testMethod1(){
        println("testMethod1")
    }

    fun testMethod2(){
        println("testMethod2")
    }
}

13. 클래스의 초기화 : init, constructor ( 생성자 )

13.1. initializer ( init{} )

코틀린은 클래스에 init블럭을 만들어주면 객체 생성시 자동으로 처리되는 코드를 만들 수 있다.
멤버변수에 값을 초기화하는 기능도 가능하다.
init블럭은 생성자와 비슷한 역할을 할 수 있는 역영이지만, 전달인수나 기타의 함수로서의 기능은 없는 단순블럭이다.
init블럭은 멤버변수 초기화, 생성자는 그외 객체 생성시 해야할 일들이 실행된다.

fun main(){

    val obj1 = TestClass11()
    println("obj1:$obj1")

}

// 코틀린은 클래스에 init블럭을 만들어주면 객체 생성시 자동으로 처리되는 코드를 만들 수 있다.
// 멤버변수에 값을 초기화하는 기능도 가능하다.
// init블럭은 생성자와 비슷한 역할을 할 수 있는 역영이지만, 전달인수나 기타의 함수로서의 기능은 없는 단순블럭이다.
// init블럭은 멤버변수 초기화, 생성자는 그외 객체 생성시 해야할 일들이 실행된다.

class TestClass11{
    init{
        println("init블럭 처리 : 객체가 생성되면 자동으로 동작되는 부분")
    }
}

13.2. constructor ( 생성자 )

생성자를 만들지 않으면 내부에 존재하는 디폴트 생성자가 사용되지만, 인위적으로 꺼내어 따로 기술할 수 있다.
코틀린 클래스의 생성자 이름은 클래스이름을 따르지 않고, 'constructor'로 사용된다.
constructor'라는 이름의 생성자는 오버로딩이 가능하다.

13.2.1. 보조 생성자 ( 클래스 지역변수 내 선언 )

fun main(){

    val obj2 = TestClass12()    // 매개변수가 없는 생성자 호출
    println("obj2:$obj2")
    println("obj2.v1:${obj2.v1}")
    println("obj2.v2:${obj2.v2}")
    val obj3 = TestClass12(100,200) // 매개변수가 있는 생성자 호출
    println("obj3:$obj3")
    println("obj3.v1:${obj3.v1}")
    println("obj3.v2:${obj3.v2}")

}

class TestClass12{
    var v1:Int = 0
    var v2:Int = 0
    // 생성자(constructor)를 만든다.
    // 생성자를 만들지 않으면 내부에 존재하는 디폴트 생성자가 사용되지만, 인위적으로 꺼내어 따로 기술할 수 있다.
    // 코틀린 클래스의 생성자 이름은 클래스이름을 따르지 않고, 'constructor'로 사용된다.
    constructor(){
        println("매개변수가 없는 생성자 동작")
    }
    // 'constructor'라는 이름의 생성자는 오버로딩이 가능하다.
    constructor(a1:Int, a2:Int){
        println("매개변수가 두 개인 생성자 동작")
        v1 = a1
        v2 = a2
    }
}

13.2.2. 주 생성자 ( 클래스 선언부에 선언 )

클래스명 옆에 기술하는 생성자
'주(대표)생성자'라고 부른다.
그 외 클래스 내부에 만들어지는 다른 오버로딩된 생성자들은 '보조생성자'라고 부른다.
주생성자에서 매개변수들은 var, val 등을 붙여 선언한다.
이들은 생성자의 매개변수이기도 하지만, 클래스의 멤버변수가 되기도 한다.
클래스 TestClass13의 이름 옆의 생성자는 매개변수가 없는 디폴트생성자를 대체하는 생성자로서, 매개변수 없는 생성자는 현재 클래스에서 없다고 생각해야 한다.
디폴트 생성자를 추가해야한다면 보조생성자로 오버로딩 되도록 생성해야 한다.

fun main(){

    val obj4 = TestClass13(100,200)
    println("obj4.a1:${obj4.a1}")   // obj4.a1:100
    println("obj4.a2:${obj4.a2}")   // obj4.a2:200
    // val obj5 = TestClass13() // 에러 : 매개변수 두개 있는 생성자가 디폴트 생성자를 대체하고
    // 별도로 디폴트 생성자를 오버로딩 하지 않았으므로 이것은 에러가 발생한다.

}

// 클래스명 옆에 기술하는 생성자
// 자바에는 없는 생성자이며 '주(대표)생성자'라고 부른다.
// 그 외 클래스 내부에 만들어지는 다른 오버로딩된 생성자들은 '보조생성자'라고 부른다.
// 주생성자에서 매개변수들은 var, val 등을 붙여 선언한다.
// 이들은 생성자의 매개변수이기도 하지만, 클래스의 멤버변수가 되기도 한다.
// 클래스 TestClass13의 이름 옆의 생성자는 매개변수가 없는 디폴트생성자를 대체하는 생성자로서, 매개변수 없는 생성자는
// 현재 클래스에서 없다고 생각해야 한다. 디폴트 생성자를 추가해야한다면 보조생성자로 오버로딩 되도록 생성해야 한다.

class TestClass13 constructor(var a1:Int, val a2:Int){
}

// class TestClass13 constructor(){}
// 클래스 생성시 매개변수가 없는 생성자는 이미 존재하기 떄문에 위와같은 표현은 따로 쓰지 않는다.
// class Test13{}

// 위 생성자의 모습은 이렇게도 바뀌어 사용할 수 있다. (클래스에 더 이상 쓸 내용이 없어서 중괄호 생략)
class TestClass14 (var a1:Int, val a2:Int)

13.2.3. 주 생성자 + 보조 생성자의 오버로딩

※ 클래스의 이름옆에 있는 대표생성자는 객체생성시에 반드시 한번은 호출되어야 하는 강제규칙이 있다.
이는 보조생성자가 있고 보조생성자가 호출되더라도 마찬가지이다.
만약 객체 생성시에 보조생성자가 호출되었다면, 해당 보조생성자에서 대표생성자를 재호출해야 에러가 없다.
보조생성자에서 디폴트 생성자를 재호출하는 방법은 constructor()옆에 :this(디폴트생성자에 맞는 전달인수)형태로 호출한다.
클래스 이름 옆에 대표 생성자는 "멤버변수를 포함하고 있기 때문에" 그를 호출하지 않으면 객체 생성시 멤버변수가 만들어지지 않는다는 말과 같다. 따라서 반드시 this 호출이 필요하다.

fun main(){

    // val obj5:TestClass15 = TestClass15(10,20)
    val obj6:TestClass15 = TestClass15()        // 매개변수가 없는 보조생성자 호출
    val obj7:TestClass15 = TestClass15(10)  // 매개변수가 하나인 보조생성자 호출


}

// 클래스 이름 옆에 생성자를 만들고 나서 오버로딩된 다른 보조생성자를 사용하고 싶을 때
class TestClass15(var a1:Int, val a2:Int){
    // ※ 클래스의 이름옆에 있는 대표생성자는 객체생성시에 반드시 한번은 호출되어야 하는 강제규칙이 있다.
    // 이는 보조생성자가 있고 보조생성자가 호출되더라도 마찬가지이다.

    // 만약 객체 생성시에 보조생성자가 호출되었다면, 해당 보조생성자에서 대표생성자를 재호출해야 에러가 없다.
    // 보조생성자에서 디폴트 생성자를 재호출하는 방법은 constructor()옆에 :this(디폴트생성자에 맞는 전달인수)형태로 호출한다.
    // 클래스 이름 옆에 대표 생성자는 "멤버변수를 포함하고 있기 때문에" 그를 호출하지 않으면 객체 생성시 멤버변수가 만들어지지 않는다는 말과 같다.
    // 따라서 반드시 this 호출이 필요하다.

    constructor() :this(10,20){
        println("매개변수가 없는 보조생성자 호출")
    }
    constructor(a1:Int) :this(10,a1){
        println("매개변수가 하나인 보조생성자 호출")
    }
}

14. extends ( 상속 )

14.1. 부모 클래스를 상속하는 자식 클래스의 객체 생성

fun main(){
    
    val s1 = SubClass1() //자식클래스 객체 생성

    println("s1.subMember1:${s1.subMember1}")      // s1.subMember1:200
    s1.subMethod1()                                 // SubClass1의 메서드 실행

    println("s1.superMember1:${s1.superMember1}")  // s1.superMember1:100
    s1.superMethod1()                               // SuperClass1의 메서드 실행

}

// 상속이 될 클래스들이 final로 만들어진다. 이는 상속이 불가능하므로, 'open 키워드'를 앞에 붙인다
open class SuperClass1{
    var superMember1 = 100
    fun superMethod1(){
        println("SuperClass1의 메서드 실행")
    }
}

// 상속은 extends키워드 없이 부모클래스 이름을 ':', '()'와 함께 클래스 옆에 써준다.
class SubClass1 : SuperClass1(){
    var subMember1 = 200
    fun subMethod1(){
        println("SubClass1의 메서드 실행")
    }
}

14.2. 부모 클래스에 생성자가 있는 경우

fun main(){

    val s2 = SubClass2()
    s2.superMethod2()

    println(" ------------------------- ")

    val s3 = SubClass3()
    s3.superMethod2()

    println(" ------------------------- ")

    val s4 = SubClass4(400)
    s4.superMethod2()
    
}

// 만일 부모 클래스에 대표생성자가 있다면?
open class SuperClass2(val a1:Int){
    fun superMethod2(){
        println("superMethod2 실행 a1 = $a1")
    }
}

// 상속을 위해 부모클래스 이름을 쓰고 괄호를 연결했다면, 괄호안에 부모클래스의 대표생성자 매개변수에 맞게 전달인수를 전달해야 한다.
// 그렇지 않으면 부모클래스의 멤버변수가 생성되지 않고, 상속도 안되는 에러가 발생한다.
class SubClass2 : SuperClass2(200){

}

// 자식 클래스의 생성자가 따로 기술되어야 한다면 아래와 같이 표현한다.
class SubClass3 : SuperClass2{
    constructor() : super(300){
    }
}

// 자식 클래스에도 대표생성자가 있다면
class SubClass4 (var a4:Int) : SuperClass2(a4){

}

15. Override

15.1. 일반적인 상속

fun main(){

    // 상속이 구현된 자식 클래스를 이용하여 객체를 만들고 자식클래스가 새로 만든 변수를 출력하고 메서드를 실행해본다.
    var obj1:SubClass1 = SubClass1()
    println("obj1.subA1 : ${obj1.subA1}")  // obj1.subA1 : 200
    obj1.subMethod()                        // SubClass1의 subMethod1입니다

    // 상속받은 부모 클래스의 변수를 출력하고, 부모클래스에 있는 메서드를 실행
    println("obj1.superA1 : ${obj1.superA1}")   // obj1.superA1 : 100
    obj1.superMethod()                           // SuperClass1의 superMethod1입니다

}

// 일반적인 상속
open class SuperClass1{ // 상속을 하기위해 클래스를 open을 사용하여 생성
    var superA1 = 100
    fun superMethod(){
        println("SuperClass1의 superMethod1입니다")
    }
}

// SuperClass1 클래스를 상속받는 SubClass1을 생성
class SubClass1 : SuperClass1(){
    var subA1 = 200
    fun subMethod(){
        println("SubClass1의 subMethod1입니다")
    }
}

15.2. 오버라이딩을 위한 상속

fun main(){

    val obj2:SubClass2 = SubClass2()
    // 오버라이딩 된 메서드를 실행
    obj2.superMethod2()     // SubClass2의 오버라이딩 된 superMethod2

    // 부모클래스의 레퍼런스 변수에 자식클래스의 인스턴스를 저장
    val obj3:SuperClass2 = SubClass2()
    // 부모클래스의 레퍼런스 변수로 실행한 메서드는 ... 자식 클래스에서 재정의된 메서드가 우선 실행된다.
    obj3.superMethod2()     // SubClass2의 오버라이딩 된 superMethod2

    println(" ----------------------------------------- " )

    // 전달인수로 부모 인스턴스 주소 전달
    Test1(obj2);    // SubClass2의 오버라이딩 된 superMethod2
    
    val obj4:SuperClass2 = SuperClass2()
    Test1(obj3)     // SubClass2의 오버라이딩 된 superMethod2
    Test1(obj4)     // SuperClass2의 superMethod2입니다

}

// 메서드 오버라이딩을 위한 상속
open class SuperClass2{
    // 오버라이드가 될 부모클래스의 메서드는 반드시 앞에 open을 붙여 쓴다.
    open fun superMethod2(){
        println("SuperClass2의 superMethod2입니다")
    }
}

class SubClass2 : SuperClass2(){
    override fun superMethod2(){
        // super.superMethod2() // 부모 클래스의 오버라이딩 되기 전 메서드 호출 : super키워드 사용
        println("SubClass2의 오버라이딩 된 superMethod2")
    }
}

fun Test1(obj:SuperClass2){
    obj.superMethod2()
}

16. Any

자바의 'Object 클래스와 같은 것'
모든 클래스의 부모 클래스 (최상위 클래스)
이미 만들어져 있거나, 앞으로 생성될 클래스에 따로 명시하지 않아도, 다른 클래스를 상속받지 않아도, 그 클래스는 Any클래스를 상속받고 있다.
다만 다른 클래스를 상속받고 있는 클래스는 그 부모 클래스가 Any클래스를 상속받고 있기 때문에 결과적으로 자기 자신도 Any클래스의 자식(손자) 클래스가 된다고 볼 수 있다.

fun main(){

    val obj1 = TestClass11()
    println("obj1 : $obj1") // obj1 : days03.TestClass11@330bedb4
    // 참조변수를 println에 넣으면 Any클래스에서 상속받은 toString() 메서드가 실행되어 
    // 클래스 이름과 해시코드가 출력된다. obj1 : days03.TestClass11@해시코드

    // Any클래스에서 상속받은 toString메서드를 오버라이드 클래스는 재정의된 메서드가 실행된다.
    val obj2 = TestClass12()
    println("obj2 : $obj2") // obj2 : TestClass12 객체입니다.

    testFun(obj1)   // a:days03.TestClass11@330bedb4
    testFun(obj2)   // a:TestClass12 객체입니다.

}

// toString이 재정의되지 않은 클래스
class TestClass11{ }

class TestClass12{
    // Any클래스에서 상속받은 toString을 오버라이딩하여 사용할 수 있다.
    override fun toString() : String{
        return "TestClass12 객체입니다."
    }
}

// 매개변수의 자료형이 Any라는 것은 모든 클래스의 객체가 전달인수로 전달될 수 있다는 뜻
fun testFun(a:Any){
    println("a:$a")
}

17. this / super

17.1. this의 용도

멤버변수와 매개변수(또는 지역변수)의 이름이 같을 때, 그들을 구분하기 위해 사용한다.
대표생성자가 있는 경우 보조생성자에서 기본생성자의 매개변수 개수와 자료형에 맞춰서 반드시 호출해야하는데, 이때 this 키워드를 사용한다.
메서드 내부에 다른 메서드(이름하야 지역메서드:지역변수와 같은 의미)를 만들어 쓸 수 있는데 멤버메서드와 구분하기 위해 사용한다.

fun main(){

    var obj1 = TestClass21()
    obj1.testMethod1()

}

// ** this의 용도 **
// 멤버변수와 매개변수(또는 지역변수)의 이름이 같을 때 그들을 구분하기 위해 사용한다.
// 대표 생성자가 있는 경우 보조 생성자에서 기본 생성자의 매개변수 개수와 자료형에 맞춰서 반드시 호출해야하는데, 이때 this 키워드를 사용한다.
// 메서드 내부에 다른 메서드 (이름하야 지역메서드:지역변수와 같은 의미)를 만들어 쓸 수 있는데 멤버메서드와 구분하기 위해 사용한다.

class TestClass21 (var a2:Int){
    var a1:Int = 200
    constructor():this(300){
        // 보조생성자는 반드시 대표생성자를 this키워드를 이용하여 호출해야한다. 대표생성자의 매개변수가 멤버변수로 생성되어야 하는데,
        // 호출되지 않으면 생성되지 않기 떄문이다.
    }
    fun testMethod1(){
        var a1 = 100
        println("메서드의 지역변수 a1 : $a1")
        println("TestClass21의 멤버변수 a1 : ${this.a1}")
        // $this.a1이라고 쓰면, 클래스명@해시코드.a1으로 출력된다.
        // 멤버변수의 값을 출력하고 싶다면, 위와같이 ${this.a1}라고 작성한다.
        fun testMethod2(){
            println("testMethod1() 내부의 testMethod2() 메서드")
        }
        testMethod2()   // 지역메서드 우선 실행
        this.testMethod2()  // 멤버메서드 실행
    }
    fun testMethod2(){
        println("멤버메서드 testMethod2()")
    }
}

17.2. super의 용도

상속관계의 자식 생성자에서, 부모클래스의 생성자를 호출할 때, 자식 클래스의 이름 옆에 부모 클래스의 이름을 사용하지만, 보조 생성자에서는 super라는 키워드를 쓴다.
자식 클래스에서 오버라이드된 메서드 그리고 변수를 사용할 때, 인위적으로 부모의 메서드를 호추하거나 변수값을 취할 때 사용한다.

fun main(){

    var obj2 = SubClass11()
    obj2.superMethod1()
    //SuperClass의 superMethod1()
    //super.a1 : 100
    //SubClass의 superMethod1

    println(" ------------- ")

    var obj3 = SubClass12(600)
    obj2.superMethod1()
    //SuperClass의 superMethod1()
    //super.a1 : 100
    //SubClass의 superMethod1

}

// ** super의 용도 **
// 상속관계의 자식 생성자에서, 부모클래스의 생성자를 호출할 때, 자식 클래스의 이름 옆에 부모 클래스의 이름을 사용하지만, 보조 생성자에서는 super라는 키워드를 쓴다.
// 자식 클래스에서 오버라이드된 메서드 그리고 변수를 사용할 때, 인위적으로 부모의 메서드를 호추하거나 변수값을 취할 때 사용한다.

open class SuperClass(var a2:Int){  //대표생성자
    open var a1 = 100
    constructor():this(200){ }  // 보조생성자
    open fun superMethod1(){
        println("SuperClass의 superMethod1()")
    }
}

// 대표생성자와 보조생성자가 모두 있는 부모클래스는 둘 중 어떤 형태로도 상속(부모클래스 생성자호출)이 가능하다.
class SubClass11 : SuperClass(/*200*/) {
    override fun superMethod1() {
        super.superMethod1()    // 부모클래스의 메서드
        println("super.a1 : ${super.a1}")   // 부모클래스의 멤버변수
        println("SubClass의 superMethod1")
    }
}

class SubClass12 : SuperClass {
    // constructor키워드로 생성된 생성자 이름 옆에 super키워드를 이용하여 부모클래스의 대표생성자를 직접 호출할 수 있다.
    // 그 경우 Extends로 연결되는 부모클래스 이름 옆의 괄호는 지워진다.
    // class SubClass12 : SuperClass() -> class SubClass12 : SuperClass
    constructor(a1:Int) : super(a1){ }
}

18. Abstract 추상클래스

fun main(){

    val obj1 = Sub1()
    obj1.method1()  // Super1의 method1이다.
    obj1.method2()  // 재정의된 Super1의 method2이다.

    println(" ----------------------------- ")

    val obj2 = Sub2()
    testFun1(obj2)
    // Super1의 method1이다.
    // 재정의된 Super1의 method2이다.

    testFun1(obj1)
    // Super1의 method1이다.
    // 재정의된 Super1의 method2이다.

}

// 부모클래스의 참조변수가 멤버변수로 있기때문에, 그 자식클래스의 객체를 전달인수로 전달할 수 있다.
fun testFun1(obj1:Super1){
    obj1.method1()
    obj1.method2()
}



// 추상클래스 : 상속을 위한 클래스, 멤버메서드의 override에 강제성을 부여하기 위해 사용한다.
open abstract class Super1{

    // 재정의(override)의 강제성이 있는 메서드와 없는 메서드를 동시에 사용이 가능하다.
    fun method1(){
        println("Super1의 method1이다.")
    }
    open abstract fun method2() // 재정의(override) 강제성이 부여된 추상메서드
}


class Sub1:Super1(){
    override fun method2() {
        println("재정의된 Super1의 method2이다.")
    }
}

class Sub2:Super1(){
    override fun method2() {
        println("재정의된 Super1의 method2이다.")
    }
}

19. Interface

인터페이스 : 추상클래스가 할 수 없던, '다중상속'이 가능하다.
자바의 버전이 업그레이드 되면서,
'자바의 인터페이스에도 override의 강제성이 부여되지 않는 일반변수와 메서드 선언이 가능'해졌다.

fun main(){

    var obj31 = TestClass31()    // Inter1을 상속(구현)받은 자식클래스
    obj31.inter1_Method1()  // Inter1의 Method1이다.
    obj31.inter1_Method2()  // TestClass31의 Inter1에서 오버라이딩된 Method2이다.

    println(" ------------------ ")

    var obj32 = TestClass32()    // Inter2를 상속(구현)받은 자식클래스
    obj32.inter2_Method1()  // Inter2의 Method1이다.
    obj32.inter2_Method2()  // TestClass32의 Inter2에서 오버라이딩된 Method2이다.

}


// 인터페이스 : 추상클래스가 할 수 없던, '다중상속'이 가능하다.
// 자바의 버전이 업그레이드 되면서, '인터페이스에도 override의 강제성이 부여되지 않는 일반변수와 메서드 선언이 가능'해졌다.

interface Inter1{
    fun inter1_Method1(){
        println("Inter1의 Method1이다.")
    }   // override의 강제성이 부여되지 않는 메서드
    
    fun inter1_Method2() // override의 강제성이 부여된 메서드
}

interface Inter2 {
    fun inter2_Method1() {
        println("Inter2의 Method1이다.")
    }
    
    fun inter2_Method2()
}


// 인터페이스의 구현은 자식클래스명 옆에 ":"와 함께 인터페이스명만 기술한다.
class TestClass31:Inter1{
    override fun inter1_Method2() {
        println("TestClass31의 Inter1에서 오버라이딩된 Method2이다.")
    }
}

class TestClass32 : Inter2{
    override fun inter2_Method2() {
        println("TestClass32의 Inter2에서 오버라이딩된 Method2이다.")
    }
}

19.1. 다중 상속

fun main(){

    // 다중상속
    var obj33 = TestClass33()    // Inter1과 Inter2를 상속(구현)받은 자식클래스
    obj33.inter1_Method1()  // Inter1의 Method1이다.
    obj33.inter1_Method2()  // TestClass33의 Inter1에서 오버라이딩된 Method2이다.
    obj33.inter2_Method1()  // Inter2의 Method1이다.
    obj33.inter2_Method2()  // TestClass33의 Inter2에서 오버라이딩된 Method2이다.

    println(" ------------------ ")

    // 부모중 해당 인터페이스가 구현되어있는 객체만 전달인수로 사용이 가능합니다.
    
    // obj32는 test1에 전달이 불가능하다.
    // testFun1(obj32)

    // obj31는 전달이 불가능하다.
    // testFun2(obj31)

    // obj33(TestClass33)은 Inter1이 구현되어있어서 인수로 전달이 가능하다.
    testFun1(obj33)
    // Inter1의 Method1이다.
    // TestClass33의 Inter1에서 오버라이딩된 Method2이다.

    // obj33(TestClass33)은 Inter2가 구현되어있어서 인수로 전달이 가능하다.
    testFun2(obj33)
    // Inter2의 Method1이다.
    // TestClass33의 Inter2에서 오버라이딩된 Method2이다.


}


interface Inter1{
    fun inter1_Method1(){
        println("Inter1의 Method1이다.")
    }   // override의 강제성이 부여되지 않는 메서드

    fun inter1_Method2() // override의 강제성이 부여된 메서드
}

interface Inter2 {
    fun inter2_Method1() {
        println("Inter2의 Method1이다.")
    }

    fun inter2_Method2()
}


// 다중상속 클래스
// 두 개 이상의 인터페이스를 구현하려면 인터페이스명을 ','로 구분하여 기술한다.
class TestClass33 : Inter1, Inter2{
    override fun inter1_Method2() {
        println("TestClass33의 Inter1에서 오버라이딩된 Method2이다.")
    }
    override fun inter2_Method2() {
        println("TestClass33의 Inter2에서 오버라이딩된 Method2이다.")
    }
}


fun testFun1(obj:Inter1){
    obj.inter1_Method1()
    obj.inter1_Method2()
}

fun testFun2(obj:Inter2){
    obj.inter2_Method1()
    obj.inter2_Method2()
}

20. Companion

자바에서 'static'으로 사용되던 키워드가 'companion'이라는 키워드로 바뀌어 사용된다.
다만, 'static'은 각 변수나 메서드에 각각 붙여 사용하지만,
'companion'은 영역을 만들고 그 안에 정적멤버로 사용할 변수나 메서드를 다 때려 넣는다.
companion 영역에 선언된 멤버들은 객체 생성없이, 클래스 이름과 함께 바로 사용이 가능하다.
인스턴스 멤버는 companion(static)메서드에 접근할 수 없다.
정적 멤버 메서드에서는 정적멤버변수의 접근이 가능

fun main(){

    var obj1 = TestClass()
    println("obj1.a1 : ${obj1.a1}") // obj1.a1 : 100

    obj1.testFun1()
    // 인스턴스 메서드 testFun1 실행!
    // a1:100
    // a2:200
    // companion메서드 testFun2 실행!
    // a2:200

    obj1.a1 = 200
    println("obj1.a1 : ${obj1.a1}") // obj1.a1 : 200

    println(" -------------------- ")

    // companion 영역에 선언된 멤버들은 객체 생성없이, 클래스 이름과 함께 바로 사용이 가능하다.
    println("TestClass.a2 : ${TestClass.a2}")   // TestClass.a2 : 200
    TestClass.testFun2()
    // companion메서드 testFun2 실행!
    // a2:200

}

class TestClass{
    var a1 = 100    // 인스턴스 멤버 변수

    companion object{
        var a2 = 200
        fun testFun2(){
            println("companion메서드 testFun2 실행!")
            //println("a1:$a1") // 에러발생 - 인스턴스 멤버는 companion(static)메서드에 접근할 수 없다.
            println("a2:$a2")   // 정적 멤버 메서드에서는 정적멤버변수의 접근이 가능
        }
    }

    fun testFun1(){ // 인스턴스 멤버 메서드
        println("인스턴스 메서드 testFun1 실행!")
        println("a1:$a1")
        println("a2:$a2")   // 인스턴스 메서드는 companion변수(a2)를 언제든 사용이 가능하다.
        testFun2()
    }
}

21. 형변환 ( type casting )

21.1. 자료형변환

var a1:Int = 100
// var a2:Double = a1
var a2:Double = a1.toDouble()

var b1:Double = 123.12
// var b2:Int = b1
var b2:Int = b1.toInt()

var c1:String = "12345"
var c2:Int = c1.toInt()

var d1:String = "123.45"
var d2:Double = d1.toDouble()

// var d3:String = "안녕하세요"
// var number4:Int = d3.toInt() // 문자 -> 정수 : 형변환 불가능

21.2. 스마트 캐스트 ( 플로우 기반 형변환)

    // ** 객체 타입 검사 **
    // 위 두개의 경우는 형변환 전에 안전한 실행을 위해 형변환이 가능한지에 대한 점검이 필요하다.

    // 자바에서는
    // if(super1 instanceof subClass41){
    //      val sub1:subClass41 = (SubClass41)super1    //형변환 명령
    // }

    // 코틀린에서는
    // if(super1 is SubClass41){
    //      super1 as SubClass41    //코틀린 강제 형변환 명령
    // }

    val super2:SuperClass4 = SubClass41()
    val inter2:Inter4 = SubClass42()
    // 부모레퍼런스가 저장하고 있는 자식인스턴스를 자식레퍼런스에 옮길텐데,
    // 위에서 언급한 것처럼 코틀린은 옮기지 않고, 레퍼런스 변수 자체를 변경한다.
    // 그 전에 변경이 가능한지 검사
    if(super2 is SubClass41){
        super2 as SubClass41    // if문의 중괄호 밖에서도 형변환 결과를 활용할 수 있다.
    } else {
        println("형변환이 불가능하다.")
    }   // 검사결과가 참이면 변환, 거짓이면 변환하지 않음

    if(inter2 is SubClass42) {
        // is에 의해 열린 if문 안에서는 as를 쓰지 않아도
        // is연산자 값이 true라면 형변환이 가능한 상황이므로 스마트 캐스팅 실행
        // 현재위치 중괄호{}안에서는 이미 inter2는 SubClass42의 레퍼런스로 변경된 상태이며, 그 상태로 사용이 가능하다.
        // 다만 중괄호를 벗어나면 다시 Inter2(부모인터페이스)의 레퍼런스로 되돌아간다.
        // 중괄호가 끝나도 계속 변경상태를 유지하려면 inter4 as SubClass42를 사용한다.
    }
    
}

open class SuperClass4
interface Inter4
class SubClass41 : SuperClass4(){
    fun subMethod1(){
        println("SubClass41의 subMethod1입니다")
    }
}
class SubClass42 : Inter4{
    fun subMethod2(){
        println("SubClass41의 subMethod2입니다")
    }
}

22. List

배열과 동일하게 인덱스 번호를 통해 객체를 관리한다.
배열의 크기가 정해지면 변경할 수 없지만 List는 추가, 삭제 등이 가능하다.

<코틀린의 컬렉션>

List	순서를 통해 관리한다.
Map	이름을 통해 관리한다.
Set	집합 관리

22.1. 리스트 생성

List 생성 메서드
listOf( )	불변형 리스트 생성
mutableListOf( )	가변형 리스트 생성
emptyList( )	비어있는 불변형 리스트를 생성
lsitOfNotNull( )	null을 제외한 나머지만으로 리스트를 생성한다.

val list1 = listOf(10, 20, 30, 40, 50)
val list2 = listOf("문자열1", "문자열2", "문자열3")
println("list1:$list1") // list1:[10, 20, 30, 40, 50]
println("list2:$list2") // list2:[문자열1, 문자열2, 문자열3]

var list3 = mutableListOf<Int>()    // 가변형이기 때문에 더러는 비어있는 상태로 시작되고 요소들을 추가하여 변경한다.
var list4 = mutableListOf("문자열1", "문자열2", "문자열3")
println("list3:$list3") // list3:[]
println("list4:$list4") // list4:[문자열1, 문자열2, 문자열3]

val list5 = emptyList<Int>()
println("list5:$list5") // list5:[]

// null을 제외한 나머지들로 리스트를 구성
val list6 = listOfNotNull(10, 20, null, 30, null, 40, 50)
println("list6:$list6") // list6:[10, 20, 30, 40, 50]

for (item in list1) {
    print("$item ")
}   // 10 20 30 40 50
println("\nlist1 size : ${list1.size}") // list1 size : 5

22.2. 리스트 요소에 접근

get( )

0부터 시작하는 인덱스 번호를 통해 객체를 추출할 수 있다.

// 리스트 요소에 접근
// get : 0 부터 시작하는 인덱스 번호를 통해 객체를 추출할 수 있다.
// kotlin의 리스트는 배열과 동일하게 []를 사용할 수 있다.
println("list1 0 : ${list1.get(0)}")    // list1 0 : 10
println("list1 1 : ${list1.get(1)}")    // list1 1 : 20
println("list1 2 : ${list1[2]}")    // list1 2 : 30
println("list1 3 : ${list1[3]}")    // list1 3 : 40

22.3. 리스트 기타 메서드

indexOf( )	지정된 값의 인덱스 번호를 반환한다. 값이 없을 경우 -1을 반환
lastIndexOf( )	지정된 값이 마지막에 해당하는 값의 인덱스 번호를 반환한다. 값이 없을경우 -1을 반환
subList( )	지정된 범위의 값을 추출하여 새로운 리스트를 생성해 반환한다.

// 기타 메서드
// indexOf : 지정된 값의 인덱스 번호를 반환한다. 값이 없을 경우 -1을 반환
// lastIndexOf : 지정된 값이 마지막에 해당하는 값의 인덱스 번호를 반환한다. 값이 없을경우 -1을 반환
// subList : 지정된 범위의 값을 추출하여 새로운 리스트를 생성해 반환한다.
val list7 = listOf(10, 20, 30, 10, 20, 30)
val index1 = list7.indexOf(20)
println("index1 : $index1") // index1 : 1
val index2 = list7.lastIndexOf(20)
println("index2 : $index2") // index2 : 4
val list8 = list1.subList(1, 3)
println("list8 : $list8")   // list8 : [20, 30]

22.4. 가변형 리스트 메서드

add(객체)	객체를 추가한다.
add(인덱스, 객체)	주어진 인덱스 위치에 객체를 삽입한다.
remove(객체)	주어진 객체를 제거한다
removeAt(인덱스)	주어진 인덱스의 객체를 제거한다.
set(인덱스, 객체)	주어진 인덱스에 객체를 덮어씌운다.

// 가변형 리스트의 메서드

list3.add(10)
list3.add(20)
list3.add(30)   // 가변 리스트에 요소를 하나씩 추가한다.
list3.addAll(listOf(40, 50, 60))  // 가변 리스트에 요소를 한번에 여러개 추가한다.
println("list3 : $list3")   // list3 : [10, 20, 30, 40, 50, 60]

list3.add(1, 100)   // 특정인덱스에 데이터를 추가한다. 뒤에 요소를 한칸씩 밀린다.
println("list3 : $list3")   // list3 : [10, 100, 20, 30, 40, 50, 60]

// 특정 인덱스에 데이터를 여러개 한번에 추가한다. 뒤에 요소를 한칸씩 밀린다.
list3.addAll(2, listOf(200,300,400))
println("list3 : $list3")   // list3 : [10, 100, 200, 300, 400, 20, 30, 40, 50, 60]

// 리스트 요소중 해당값을 한개 또는 여러개 제거
list3.remove(100)
println("list3 : $list3")   // list3 : [10, 200, 300, 400, 20, 30, 40, 50, 60]

list3.removeAll(listOf(200,300))
println("list3 : $list3")   // list3 : [10, 400, 20, 30, 40, 50, 60]

list3.removeAt(1)   //지정한 인덱스의 요소를 삭제
println("list3 : $list3")   // list3 : [10, 20, 30, 40, 50, 60]

list3.set(1,200)    // 지정한 인덱스에 지정한 값으로 수정한다.
println("list3 : $list3")   // list3 : [10, 200, 30, 40, 50, 60]

list3[2] = 300  // 배열처럼 지정한 인덱스에 지정한 값으로 수정
println("list3 : $list3")   // list3 : [10, 200, 300, 40, 50, 60]

22.5. 불변형 리스트를 가변형으로 변환

// 불변형 리스트(list1)를 가변형으로 변환
// list1.add(1000)  // 불변형이기 떄문에 요소 추가는 에러
val list100 = list1.toMutableList()     // 불변형 -> 가변형 : 불변형의 변환결과를 다른 참조변수에 전달
list100.add(1000)
println("list100 : $list100")   // list100 : [10, 20, 30, 40, 50, 1000]

//val list200 = list100.to
//list200.add(300) // 에러

저작자표시 비영리 변경금지