코틀린1 - 코틀린 기초

fun main(args: Array<String>){
  println("Hello, world!")
}

fun max(a:Int, b:Int): Int{
  return if(a > b) a else b
}

boolean a = false;
if (a = false){
  // 자바) 자바의 if는 값을 가지지 않은 문장이다. a == false라고 써야하는데 대입식으로 잘못 사용한 경우
  // 에러가 나지 않고 예상과 다른 결과를 내보낼 수 있다.
  System.out.println(a); //런타임 에러
}

// 코틀린) 앞선 함수의 식이 하나라면 중괄호와 return을 제거해서 식이 본문인 함수로 만들 수 있다.
fun max(a:Int, b:Int) = if(a > b) a else b

val question = "이것은 타입을 명시하지 않아도 스트링"
val question2:String = "이것은 타입을 명시한 스트링"
val answer = 42
val answer2:Int = 42
val answer3: Int //선언을 먼저하고
answer3 = 42 //나중에 할당할 수도 있다.
// 이 경우 변수타입을 반드시 명시해야한다.

val value = "변경 불가능한 변수"

value = "변경" //에러

var variable = "변경 가능한 변수"

variable = "변경" //OK

val languages = arrayListOf("Java")
languages.add("Kotlin")

var answer = 42
answer = "no answer" // 컴파일 오류 type mismatch

fun template(name: String){
  println("Hello, $name")
}
template("Jonny")
//출력 - Hello, Jonny

fun printArray(arr: Array<String>){
  println("arr.size = ${arr.size}")
}

// 자바
public class Person{
  private final String name; //필드
  public Person(String name){ //생성자
    this.name = name;
  }
  public String getName(){ //게터
    return name;
  }
}

// 코틀린
class Person(val name: String)

class Person(
  val name:String, // 읽기 전용 프로퍼티 private필드와 getter생성
  var isMarried: Boolean // 읽고 쓸 수 있는 프로퍼티 private필드와 getter, setter생성
)

val person = Person("Bob", true)
println(person.name) //프로퍼티 이름을 사용하면 코틀린이 getter를 호출
println(person.isMarried)
person.isMarrie = false //setter를 호출하여 값을 주입. 필드는 private임에 주의

class Rectangle(val height: Int, val width: Int){
  val isSquare: Boolean get() = height == width // 커스텀 게터 선언
}

val rect = Rectangle(30, 30)
println(rect.isSquare) //true

val rect = Rectangle(30, 29)
println(rect.isSquare) //false

package geometry.shapes // 패키지 선언
import java.util.Random // 표준 자바 라이브러리 클래스 임포트
class Rectangle(val height: Int, val width: Int){
  val isSqure: Boolean get() = height == width
}
fun createRandomRectangle() : Rectangle {
  val random = Random()
  return Rectangle(random.nextInt(), random.nextInt())
}

package geometry.example
import geometry.shapes.createRandomRectangle // 다른 패키지의 함수 임포트
fun main(args: Array<String>){
  println(createRandomRectangle().isSquare)
}

//자바 패키지 구조
geometry
  ㄴexample
  ㄴㄴMain
  ㄴshapes
  ㄴㄴRectangle
  ㄴㄴRectangleUtil

//코틀린 구조
geometry
  ㄴexample.kt
  ㄴshapes.kt

enum class Color {
  RED, ORANGE, YELLOW, GREEN, BLUE, INDIGO, VIOLET
}

enum class Color(
  val r:Int, val g:Int, val b:Int // 상수의 프로퍼티 정의
) {
  RED(255, 0, 0), // 각 상수를 생성할 때 그에 대한 프로퍼티 값을 지정한다.
  ORANGE(255, 165, 0),
  YELLOW(255, 255, 0),
  GREEN(0, 255, 0),
  BLUE(0, 0, 255),
  INDIGO(75, 0, 130),
  VIOLET(238, 130, 238); // 여기서는 반드시 세미콜론을 사용해야 한다.
  fun rgb() = (r * 256 + g) * 256 + b //enum 클래스 안에서 메소드를 정의한다.
}

fun getMnemonic(color: Color) =
  when (color) {
  // when도 값을 만들어내는 식이다. -> 여러 줄 식을 본문으로 하는 함수
    Color.RED -> "Richard"
    Color.ORANGE -> "Of"
    Color.YELLOW -> "York"
    Color.GREEN -> "Gave"
    Color.BLUE -> "Battle"
    Color.INDIGO -> "In"
    Color.VIOLET -> "Vain"
  }

//println(getMnemonic(Color.BLUE))

import ch02.colors.Color // 다른 패키지에서 정의한 Color 클래스 임포트
import ch02.colors.Color.* // 짧은 이름으로 사용하기 위해 enum 상수를 모두 임포트

fun getWarmth(color: Color) =
  when (color) {
    RED, ORANGE, YELLOW -> "warm" // 임포트한 enum 상수를 이름만으로 사용
    GREEN -> "netural"
    BLUE, INDIGO, VIOLET -> "cold"
  }

fun mix(c1: Color, c2: Color) =
  when (setOf(c1, c2)){ // when 식의 인자로 아무 객체나 사용할 수 있다.
    setOf(RED, YELLOW) -> ORANGE
    setOf(YELLOW, BLUE) -> GREEN
    setOf(BLUE, VIOLET) -> INDIGO
    else -> throw Exception("Dirty color")
  }

fun mixOptimized(c1: Colir, c2: Color) =
  when {
    (c1 == RED && c2 == YELLO) ||
    (c1 == YELLO && c2 == RED) -> ORANGE
    (c1 == YELLOW && c2 == BLUE) ||
    (c1 == BLUE && c2 == YELLOW) -> GREEN
    (c1 == BLUE && c2 == VIOLET) ||
    (c1 == VIOLET && c2 == BLUE) -> INDIGO
    else -> throw Exception("Dirty color")
  }

interface Expr
class Num(val value: Int) : Expr // Int형의 인자만 올 수 있는 Expr 인터페이스 구현 클래스이다.
class Sum(val left: Expr, val right: Expr) : Expr // Sum의 인자는 Expr인터페이스를 구현한 누구든 올 수 있다. 즉 Sum의 인자로 다른 Sum이나 Num모두 올 수 있다.

// 작은 클래스, 인터페이스들을 한 파일에 모으는 것을 주저하지 말자.

println(eval(Sum(Sum(Num(1), Num(2)), Num(4)))) //eval구현하기 전임
// 7

//코틀린언어지만 자바스타일 코드
fun eval(e: Expr): Int {
  if (e is Num) { // 변수 타입 검사 -> 자바의 instanceof와 비슷
    val n = e as Num // 명시적 캐스팅
    return n.value
  }
  if (e is Sum) {
    val n = e as Sum
    return eval(n.left) + eval(n.right)
  }
  throw IllegalArgumentException("Unknown expression")
}

//명시적 캐스팅은 필요없음
fun eval(e: Expr): Int {
  if (e is Num) { // 변수 타입 검사 + 캐스팅
    return e.value
  }
  if (e is Sum) {
    return eval(e.left) + eval(e.right)
  }
  throw IllegalArgumentException("Unknown expression")
}

println(eval(Sum(Sum(Num(1), Num(2)), Num(4))))
// 7

fun eval(e: Expr): Int =
  if(e is Num) {
    e.value
  } else if (e is Sum) {
    eval(e.left) + eval(e.left)
  } else {
    throw IllegalArgumentException("Unknown expression")
  }

println(eval(Sum(Sum(Num(1), Num(2)), Num(4))))
// 7

fun eval(e: Expr): Int =
  when(e){
    is Num -> e.value
    is Sum -> eval(e.left) + eval(e.right)
    else -> throw IllegalArgumentException("Unknown expression")
  }

fun evalWithLogging(e: Expr): Int =
  when(e){
    is Num -> {
      println("num: ${e.value})
      e.value //블록의 마지막 식 반환
    }
    is Sum -> {
      val left = evalWithLogging(e.left)
      val right = evalWithLogging(e.right)
      println("sum: $left + $right")
      left + right //블록의 마지막 식 반환
    }
    else -> throw IllegalArgumentException("Unknown expression")
  }

println(evalWithLogging(Sum(Sum(Num(1), Num(2)), Num(4))))
// num: 1
// num: 2
// sum: 1 + 2
// num: 4
// sum: 3 + 4
// 7

val oneToTen = 1..10

fun fizzBuzz(i: Int) = when {
  i % 15 -> "FizzBuzz"
  i % 5 -> "Buzz"
  i % 3 -> "Fizz"
  else -> "$i"
}

for (i in 1..100){
  print(fizzBuzz(i))
}

// 1 2 Fizz 4 Buzz Fizz 7 ...

// 100부터 거꾸로 세되 짝수만
for (i in 100 downTo 1 step 2){
  print(fizzBuzz(i))
}

// 1부터 99까지만 세고 싶지만 100을 명시하는 게 더 편할 때
val size = 100
for (i in 1 until size){
  print(fizzBuzz(i))
}

val binaryReps = TreeMap<SChar, String>()
for (c in 'A'..'F'){ // 문자 범위
  val binary = Integer.toBinaryString(c.toInt())
  binaryReps[c] = binary // 자바 - binaryReps.put(c, binary) 값 설정
}

for((letter, binary) in binaryReps){ // 맵에 대한 이터레이션 (구조 분해 구문)
  println("$letter = $binary")
}

val list = arrayListOf("10", "11", "1001")
for((index, element) in list.withIndex()){ // withIndex는 3장에서
  println("$index: $element")
}

fun isLetter(c: Char) = c in 'a'..'z' || c in 'A'..'Z'
fun isNotDigit(c: Char) = c !in '0'..'9'

println(isLetter('q')) // true
println(isNotDigit('x')) // true

println("Kotlin" in "Java".."Scala")

println("Kotlin" in setOf("Java", "Scala"))

val percentage =
  if(number in 0..100) number
  else throw IllegalArgumentException("A percentage value must be between 0 and 100: $number")

fun readNumber(reader: BufferedReader):Int?{
  // 함수가 던질 수 있는 예외를 명시할 필요가 없다.
  try {
    val line = reader.readLine()
    return Integer.parseInt(line)
  } catch (e:NumberFormatException){
    return null
  } finally {
    reader.close()
  }
}

fun readNumber(reader: BufferedReader){
  val nuber = try{
    Integer.parseInt(reader.readLine())
  } catch(e: NumberFormatException){
    return
  }
  println(number)
}