[Day63] 2022-04-27(수) Kotlin 기본2 - Scanner클래스, 연산자, 제어문, Null - 김서연 강사님

[1] Kotlin 기본

  1. Scanner 클래스

scannerTest.kt

// scannerTest.kt
package com.example.kotlinwork.basic

import java.util.*

/*
python -> thread = Thread()
JS -> Thread thread = new Thread()
*/

// 키보드로 입력하면 입력받은 내용으로 Scanner 객체를 메모리에 사용할 수 있는 상태로 생성

fun main(args: Array<String>) {
    val sc: Scanner = Scanner(System.`in`)
    print("문장을 입력하세요: ")
    val line = sc.nextLine()    // 엔터를 만나기 전까지 읽음
    print("성명: ")
    val name = sc.next()    // 띄어쓰기 전까지 읽음(한 단어)
    print("나이: ")
    val age = sc.nextInt()

    println(line)
    println("name:$name, age:$age")
}

  2. 연산자

oprTest.kt

// oprTest.kt
package com.example.kotlinwork.basic

fun main(args: Array<String>) {
    // 1. 단항 연산자
    // +(양수), -(음수)
    val a1:Int = +10
    val a2:Int = -10

    val r1:Int = +a1
    val r2:Int = -a2
    println("a1:$a1, a2:$a2")
    println("r1:$r1, r2:$r2")

    // ! : true->false, false->true
    val a3:Boolean = true
    val a4:Boolean = false
    println("a3:$a3, a4:$a4")
    println("a3:${!a3}, a4:${!a4}")

    // ++, --
    var a5:Int = 100
    var a6:Int = 100
    a5++    // a5 = a5 + 1
    a6--    // a6 = a6 - 1
    println("a5:$a5, a6:$a6")
    // ++, -- 전위/후위 차이
    var y:Int = 0
    var x:Int = 0
    y = 0
    x = 5
    y = x++
    println("x=$x, y=$y")
    y = 0
    x = 5
    y = ++x
    println("x=$x, y=$y")
    y = 0
    x = 5
    y = x--
    println("x=$x, y=$y")
    y = 0
    x = 5
    y = --x
    println("x=$x, y=$y")

    // 2. 산술 연산자
    val a7:Int = 10 + 3
    val a8:Int = 10 - 3
    val a9:Int = 10 * 3
    val a10:Int = 10 / 3 // int/int -> int
    val a11:Int = 10 % 3
    println("$a7, $a8, $a9, $a10, $a11")

    // 3. 숫자의 범위를 관리하는 객체
    val numlist:IntRange = 10..20   // 10부터 20까지의 값을 관리하는 객체
    println("numlist: $numlist")

    // 4. 비교연산자 ==, !=, >, >=, <, <=
    val num1:Int = 10
    val data1:Boolean = num1==10
    val data2:Boolean = num1!=10
    println("data1:$data1, data2:$data2")
}

  3. 제어문

    1) 조건문

      - if문

ifTest1.kt

// ifTest1.kt
package com.example.kotlinwork.statement

import java.util.*

fun main(args: Array<String>) {
    /*
    if(조건){
        조건을 만족하는 경우 실행할 문장
    }

    if(조건){
        조건을 만족하는 경우 실행할 문장
    }else{
        조건을 만족하지 않는 경우 실행할 문장
    }

    if(조건1){
        조건1을 만족하는 경우 실행할 문장
    }else if(조건2){
        조건2을 만족하는 경우 실행할 문장
    }else if(조건3){
        조건3을 만족하는 경우 실행할 문장
    }else{
        조건을 만족하지 않는 경우 실행할 문장
    }
    */
    var sc:Scanner = Scanner(System.`in`)
    print("숫자입력: ")
    val num1:Int = sc.nextInt()
    if(num1 == 100){
        println("같다")
    }
    if(num1 != 100){
        println("다르다")
    }

    if(num1 >= 90){
        println("성공")
    }else{
        println("실패")
    }
    
    // &&, ||
    if(num1>100 || num1<0){
        println("잘못입력")
    }else{
        if(num1>=90){
            println("A")
        }else if(num1>=80){
            println("B")
        }else if(num1>=70){
            println("C")
        }else if(num1>=60){
            println("D")
        }else{
            println("F")
        }
    }
}

    2) 선택문

      - when문

 

      ① 기본적인 사용법

whenTest.kt

// whenTest.kt
package com.example.kotlinwork.statement

fun main(args: Array<String>) {
    // when구문 -> 다중분기(if ~ else if, switch 와 유사)
    // 범위를 비교하는 경우는 if~else if
    // 정확하게 일치하는 값을 비교하고 비교할 값들이 적은 경우
    /*
    when(변수 or 연산식 or 메소드호출문){
        -----------------------------
                └ 결과가 값으로 리턴
       값1 -> 결과가 값1이면 실행할 명령문
       값2 -> 결과가 값2이면 실행할 명령문
       값3 -> {
                실행할 문장이 여러 개인 경우 중괄호 안에 입력
       }
       값4,값5 -> 결과가 값4 혹은 값5인 경우 실행할 명령문
            .....
       else -> 해당되는 것이 없는 경우 실행할 명령문
    }
    */
    val num1:Int = 5

    when(num1){
        1 -> println("num1은 1")
        2 -> {
            println("num1은 2")
            println("여러 줄 명령문")
        }
        3 -> println("num1은 3")
        4, 5 -> println("num1은 4 또는 5")
        else -> println("해당사항없음")
    }

    val num2 = 13
    when(num2){
        in 1..3, in 11..15 -> println("num2는 1부터 3, 11부터 15 사이")
        in 4..7 -> println("num2는 4부터 7 사이")
        in 8..10 -> println("num2는 8부터 10 사이")
    }
    
}

      ② 함수의 리턴값으로 사용

whenTest2.kt

// whenTest2.kt
package com.example.kotlinwork.statement

fun main(args: Array<String>) {
    println(setValue(1))
    println(setValue(2))
    println(setValue(3))
    println(setValue(4))
}

// when을 함수의 리턴값으로 사용 - else문 반드시 사용해서 리턴값이 없는 경우를 만들지 않는다.
fun setValue(num:Int) = when(num){
    1 -> "문자열1"
    2 -> {
        println("실행할 문장")
        "문자열2"              // 여러 줄 쓰는 경우 리턴값을 마지막 줄에 입력
    }
    3 -> "문자열3"
    else -> "그 외의 값"
}

    3) 반복문

      - for문, while문, do~while문

loopTest.kt

// loopTest.kt
package com.example.kotlinwork.statement

fun main(args: Array<String>) {
    // 반복문
    // for, while, do~while
    // 코드의 반복, 배열과 같은 값을 관리...
    // 1. for문
    /*
        for(변수 in 컬렉션){
                    -----
                      └ 배열과 같이 값을 여러 개 저장할 수 있는 변수
            반복해서 실행할 명령문
        }
    */
    val numlist1 = 1..10
    for(i in numlist1){
        println("i:$i")
    }
    println("============================")
    val numlist2 = 1..10 step 2
    for(i in numlist2){
        println("i:$i")
    }
    println("============================")
    val numlist3 = 10 downTo 1
    for(i in numlist3){
        println("i:$i")
    }
    println("============================")
    val numlist4 = 10 downTo 1 step 2
    for(i in numlist4){
        println("i:$i")
    }

    // arrayOf 를 이용해서 배열을 생성
    val myarr1 = arrayOf(10, 20, 30, 40, 50)
    println("============================")
    test(myarr1)

    // 2. while문
    /*
    while(조건식){
        반복해서 실행할 명령문
    }
    */
    println("============================")
    var num1 = 10
    while(num1<10){
        println("num1:$num1")
        num1++
    }
    // 조건을 만족하지 않아도 do ~ while은 {}안의 명령문을 한 번은 실행한다.
    do{
        println("num1:$num1")
        num1++
    }while(num1<10)
}

// Array 객체로 배열을 관리 - Array에 담을 데이터의 타입을 <>안에 명시
fun test(myarr:Array<Int>){
    for(i in myarr){
        println("값:$i")
    }
}

  4. Null 관련 문법

    1) null 참조 시 기본값 설정

nullTest.kt

// nullTest.kt
package com.example.kotlinwork.etc

// 코틀린에서 Null 관리
fun main(args: Array<String>) {
    // num1이 null이 아닌 경우 상관 없지만, null인 경우 에러
//    var num1:Int? = 10
//    var num2:Int = num1!!
    testnull1("문자열")
    // testnull1(null)     // 에러
    testnull2(null)
}

fun testnull1(str:String?){
    val value1:String = str!! // 문법적 오류는 해결, !!는 null에 대한 안정성을 보장받을 수 없다.
    println("value1:$value1")
}

fun testnull2(str:String?){
    // str매개변수가 null이면 "기본값"이 str에 할당되고 null이 아니면 전달된 값이 적용
    val value2:String = str?:"기본값" // 변수가 null이면 전달된 값을 할당하고, null이 아니면 기본값을 할당
    println("value2:$value2")
}

    2) 참조변수로 null 값이 전달되는 경우 처리

nullTest.kt

// nullTest2.kt
package com.example.kotlinwork.etc

fun main(args: Array<String>) {
    // 참조변수(생성된 객체를 접근하는 변수)를 통해 메소드를 호출하거나
    // ex) var sc:Scanner = Scanner(System.`in`) -> 여기서 sc가 참조변수
    testMethod1("안녕하세요")    // null이 아닌 값이 전달됐으므로 가능
    // testMethod1(null)
    println("======================")
    testMethod2("안녕하세요")
    testMethod2(null)
    println("======================")
    testMethod3("안녕하세요")
    testMethod3(null)
}

// !!를 사용하는 방법은 null이 전달되는 경우 Exception 발생
fun testMethod1(str:String?){
    println(str!!.length)
}

// ? 를 사용하고 메소드 사용할 경우, null이 아니면 전달된 값으로 길이를 계산하고, null이면 처리하지 않고 null로 값을 출력한다.
fun testMethod2(str:String?){
    println(str?.length)
}

fun testMethod3(str:String?){
    if(str!=null){
        println(str.length)
    }
    if(str is String){
        println(str.length)
    }
}

  5. 연습 예제1

functionExam2.kt

// functionExam2.kt
/*
1. 아래와 같은 결과가 실행될 수 있도록 조건을 만족하는 함수를 작성하세요.
[조건]
두 숫자와 연산자를 입력 받아 처리하는 calc함수를 작성하세요
연산자는 연산 기호나 숫자를 입력 받아 처리합니다.
연산 결과를 리턴합니다.
*/
package com.example.kotlinwork.exam
import java.util.*

fun main(args: Array<String>) {
    val sc: Scanner = Scanner(System.`in`)
    println("**************계산기**************")
    println("1. 더하기")
    println("2. 빼기")
    println("3. 곱하기")
    println("4. 나누기")
    print("원하는 작업을 선택하세요:")
    val opr:Int = sc.nextInt()
    print("숫자1:")
    val num1:Int = sc.nextInt()
    print("숫자2:")
    val num2:Int = sc.nextInt()
    println("결과:${calc(num1, num2, opr)}")
}

fun calc(num1:Int, num2:Int, opr:Int):Int{
    var result:Int = 0
    when(opr){
        1 -> result = num1 + num2
        2 -> result = num1 - num2
        3 -> result = num1 * num2
        4 -> result = num1 / num2
    }
    return result
}

  6. 연습 예제2

functionExam3.kt

// functionExam3.kt
package com.example.kotlinwork.exam
/*
2. 다음 조건에 만족할 수 있도록 함수를 작성하고 호출해서 실행해보세요
1) printSumArray
   - Int데이터가 저장된 배열데이터를 매개변수로 입력
   - 매개변수로 전달된 배열에 저장된 모든 숫자의 합과 평균을 출력하는 리턴값이 없는 함수 작성
2) display
    - 전달 받은 Char형 매개변수를 판단해서 결과를 리턴하는 함수
    - 값은 when을 이용하여 평가해서 리턴하도록 작성합니다.
   [결과]
   display('a') -> 문자입니다.
   display('9') -> 숫자입니다.
   display('#') -> 판단할 수 없습니다.
3) printdata
   -  입력받은 매개변수 중 3의 배수만 출력하기
    100,90,90,80,97숫자를 배열로 작성한 후 함수의 매개변수로 전달합니다.​
   - 리턴값이 없는 함수
*/
fun main(args: Array<String>) {
    var myArray1 = arrayOf(20, 20, 41, 50, 60)
    printSumArray(myArray1)
    println("=======================")
    println(display('A'))
    println(display('1'))
    println(display('#'))
    println("=======================")
    var myArray2 = arrayOf(100, 93, 90, 80, 97)
    printdata(myArray2)
}

fun printSumArray(intArray:Array<Int>){
    var sum:Int = 0
    for(i in intArray){
        sum += i
    }
    println("합계:$sum, 평균:${sum/intArray.size.toDouble()}") // 실수의 형태로 결과를 출력하고 싶은 경우 캐스팅( 두 값 중 하나를 toDouble() 써서 실수로 )
}

fun display(chr:Char) = when(chr){
    in 'a'..'z', in 'A'..'Z' -> "문자입니다."
    in '0'..'9' -> "숫자입니다."
    else -> "판단할 수 없습니다."
}

fun printdata(intArray:Array<Int>){
    for(i in intArray){
        if(i%3==0){
            print("$i ")
        }
    }
}

 

- 끝 -