gist 사용, Kotlin 문법

▪ gist

: 짧은 코드, 메모 등을 기록 또는 공유 목적으로 사용한다.

• 사용 방법

1. 먼저, github에 가입한다.
2. 가입된 아이디에서 gist로 들어가서 파일을 생성해 준다.
   (오른쪽 상단에 프로필을 클릭하여 Your gist를 눌러주어 본인의 gist 페이지를 찾아갈 수 있다.
   또한 파일을 생성 할때도 프로필 옆에 + 를 클릭하면 파일을 생성할 수 있다.)
   
3. 파일 생성 후에는 git clone 해서 본인의 로컬에서 작업할 수 도 있고 페이지에 직접 들어가서 수정할 수도 있다.
4. 로컬에서 작업하는 경우는 $git pull ➡ 작업 ➡ $git status (수정 내역확인) ➡ $git add {수정한 파일명) ➡ $git commit ➡ $git push 순으로 작업해 준다.

❗ 단, $git add 할 때 gist는 폴더는 저장할 수 없으므로 수정된 파일만 add 해주는 것이 좋다.( add . ➡ X)

▪ Naming Rule

• class : Pascal case (새로운 단어가 나올 때 앞 글자는 대문자를 사용하고 단어는 명사/명사구를 사용)

• method : camel (처음 단어의 앞 글자만 소문자로 사용하고 새로운 단어의 앞 글자는 대문자를 사용하고 단어는 동사/동사구를 사용)

❗ Class 명과 method 명, 변수 명 이름을 정하는 부분이 정말 중요한거 같다. 코드를 읽을때 이름만 잘 정해도 읽기 정말 편해진다 !!

▪ Kotlin

: kotlin 에 대해서 모를때는 Stack Overflow, Slack 등을 활용해서 질문할 수 있다. (Slack에서도 Kotlin 대한 채팅 방이 따로 있다 !)

Kotlin 문법

• 기본 문법 (함수, 조건문, 반복문 등)

	// 1. 함수 사용
// return -> Unit = void
fun helloWorld() : Unit {
    println("Hello, World !")
}

fun add (a : Int, b : Int) : Int{
    return a + b;
}

// 2. val vs var
// val = value 변할수 없는 값 상수
// var =

fun hi () {
    val a : Int = 10
    var b : Int = 10
    // a = 100; error;
    b = 100

    var c = 10 // Type 생략 가능
    var name : String = "jaehong"
}

// 4. 조건식

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

fun maxBy2(a : Int, b : Int) : Int = if(a>b) a else b
// Kotlin 에서는 삼항 연산자( (a>b) ? a : b ) 가 없으므로 위 처럼 표기

fun checkNum(score : Int ){
    when(score) {
        0 -> println("this is 0")
        1 -> println("this is 1")
        2,3 -> println("this is 2 or 3")
        //else -> print("I don't know")
    }
    // when을 return 형으로 사용할 때는 else를 반드시 표기 해야한다.
    var b : Int = when(score){
        1 -> 1
        2 -> 2
        else -> 3
    }

    // 사이 값
   when(score){
        in 90..100 -> println("You are genius")
        in 10..80 -> println("Not bed")
        else -> println("okey")
    }
}

// Expresstion VS Statement
// Expresstion : 실행을 해서 값을 return (반환)
// Statement : 어떤 실행을 할지 명령 return 값이 없음

// 5. Array vs List

// List : 1. List(수정 불가능) 2. MutableList(수정 가능)

fun array(){
    val array : Array<Int> = arrayOf(1,2,3)
    val list : List<Int> = listOf(1,2,3)

    val array2 : Array<Any> = arrayOf(1,"a", 3.14f)
    val list2  = listOf(1,"a",11L)

    array[0] = 3;
    // list[0] = 3; error 수정 불가
    var result = list.get(0)

    // MutableList
    val arrayList = arrayListOf<Int>()
    arrayList.add(10)
    arrayList.add(20)
    arrayList[0] = 20
}

// 6. for / while 반복문

fun forAndWhile(){

    val student = arrayListOf("a","b","c","d")

    for(name in student){
        println("${name}")
    }

    var sum = 0
    for(i in 1..10){
        sum += i
    }

    // 두칸씩 증가 시켜라 1,3,5,7,9
    var sum1 = 0
    for(i in 1..10 step 2){
        sum1 += i
    }

    // 10부터 1까지
    var sum2 = 0
    for(i in 10 downTo 1){
        sum2 += i
    }

    //1 부터 99까지 100은 포함하지 않음
    var sum3 = 0
    for(i in 1 until 100){
        sum3 += i
    }
    println(sum)
    println(sum1)
    println(sum2)
    println(sum3)

    var index = 0;
    while(index <= 10){
        println("current index : ${index}")
        index++
    }

    // 인덱스와 배열 함께 사용
    for((index,name) in student.withIndex()){
        println("${index+1}번째 학생의 이름은 ${name}")
    }
}

// 7. Nullable vs NonNull

fun nullcheck(){

    var name= "jaehong"
    // var Nullname : String = null error
    var Nullname : String? = null // Type 생략 불가 (String? : Nullable type)

    var nameInUpperCase = name.toUpperCase()
    // Nullname null이 아니면 함수를 적용하고 아니면 null값을 반환
    var NullnameInUpperCase = Nullname?.toUpperCase()

    // ? : default 값을 주고 싶을 떄 사용
    val lastname : String? = null
    // lastname이 null아니면 그냥 출력 null이면 (?:"default") default 값 출력
    val fullname = name + " " + (lastname?:"NO lastName")

    println(fullname)



}

// !! : Nullable type으로 지정 되어있지만 컴파일러에세 null이 아니라는 것을 명시해주고 그냥 실행 시키라고 명령해주는것
// (단, 정말 확실할때만 사용 -> 만일 null이 들어갔을경우 런타임 에러가 발생하기때문에 오류를 해결하기 어려울수 있음)
fun ignoreNulls(str : String?){
    val mNotNull: String = str!!
    // 한번 명시하고 그 이후로는 그냥 사용 가능
    val upper = mNotNull.toUpperCase()


    val email : String? = "prk4224@naver.com"
    // email이 null이 아닌 경우 let함수를 수행
    email?.let{
        println("My email is ${email}")
    }
}

• 람다(lamda) 사용법

package com.example.jhpractice

import java.io.BufferedInputStream
import java.io.InputStreamReader

// 1. Lamda
// 람다식은 우리가 마치 value 처럼 다룰수 있는 익명 함수
// 1) 메소드에 파라미터로 남겨줄수 있다 fun maxBy(a :Int)
// 2) return 값을 함수 사용할수 있다.

// 람다의 기본 정의
// val lamdaName : Type = {argumentList -> codebody}

// (Int) -> (Int) 이 부분 때문에 type 추론이 가능 ( (inputType) -> (outputType) )
val square : (Int) -> (Int) = { number -> number*number}
// 위나 아래 둘중에 한부분을 타입을 정의해 줘야함.
val square1  = { number : Int -> number*number}

val nameAge = {name : String, age : Int ->
    "My name is ${name} I'm ${age} "
}

fun main(){


    println(square(4))
    println(nameAge("jaehong", 27))
    val a = "jaehong said"
    val b = "minju said"

    println(a.pizzeIsGrear())
    println(b.pizzeIsGrear())

    println(extendString("hong" ,27))
    println(calculateGrade(97))


    val lamda = {number : Double ->
        number === 4.1321
    }
    // lamda식의 number 값과 같으면 true 아니면 false
    println(invokeLamda(lamda))
    // lamda 식을 정의하지 않고 바로 쓰는 것도 가능
    println(invokeLamda({it > 3}))

    // 마지막 parameter가 람다식일때 소괄호를 생략하고 사용 가능 위 식과 똑같은 의미
    println(invokeLamda { it > 3 })

}
// 확장 함수

val pizzeIsGrear : String.() -> String = {
    this + "Pizza is the best"
}

fun extendString(name : String , age : Int) : String {

    //it 명령어는 받아오는 파라미터가 1개일때만 사용 가능 / this는 함수에서 가르키는 object, it은 하나들어가는 parameter
    val IntroduceMySelf : String.(Int) -> String = {"I'm ${this} and ${it} years old"}

    return name.IntroduceMySelf(age)
}

// 람다의 return

// input parameter (Int)는 여러개가 올수 있기때문에 소괄호를 써줘야 하고 return하는 값은 1개이기 때문에 소괄호를 써주지 않아도 된다.
val calculateGrade : (Int) -> String = {
    // 여기서도 input parameter가 1개이기 때문에 it을 사용 가능
    when(it){
        in 0..40 -> "fail"
        in 41..70 -> "pass"
        in 71..100 -> "perfact"
        else -> "error"
    }
}

// 람다를 표현하는 2가지 방법

// invokeLamda 함수 boolean 값을 return 하는데 input parameter가 Double로 들어와 boolean값으로 리턴되는 값을 리턴하겠다 라는 의미
fun invokeLamda(lamda : (Double) -> Boolean) : Boolean{
    return lamda(5.2341)
}

// 익명 내부 함
// 1. Kotlin interface 가 아닌 java interface 일때만 사용 가능
// 2. 그 interface는 딱 하나의 메소드만 가져야 한다.

• Object 사용

// Object
// : 모든 앱을 실행할 때 딱 한번 만들어진다.(Singleton Pattern)
//   불필요한 메모리 사용을 막을수 있다.


object carFactory {
    val cars = mutableListOf<Car>()
    fun makeCar(horsePower: Int) : Car {
        val car = Car(horsePower)
        cars.add(car)
        return car
    }
}

data class Car(val horsePower : Int)

fun main(){
    val car = carFactory.makeCar(10)
    val car2 = carFactory.makeCar(200)

    println(car)
    println(car2)
    println(carFactory.cars.size.toString())

- Null Type 정리

• ? : null 이 될 수 있는 type을 명시적으로 표시
• !! : null 이 될 수 있는 type이지만 null이 아님을 주장. (null이 될 수 없는 변수 null이 될 수 있는 타입을 주입할 수 있다.)

• var a:Int = null -> error 
  var a:Int? = null
  var b:Int? = 10
  var c:Int = b  -> error
  var c:Int = b!!

• ?. : null 검사와 함수 호출을 동시에 한다. (null이면 호출 무시 결과값 -> null)
• ?: : null 대신에 사용할 default 값 지정
• as? : 연산자는 어떤 값을 지정한 타입으로 캐스트하고, 변환할 수 없으면 null을 반환

(참조 : https://hororolol.tistory.com/572)