Kotlin

📢 문법 - 작성중

---

📚함수

구문식 (Statement)

fun sum(a: Int, b: Int): Int {

    return a + b

}

표현식 (Expresstion)

fun sum(a: Int, b: Int) = a + b

fun max(a: Int, b: Int) = if (a>b) a else b

📌자바와의 차이점

1. 메소드 표시로 메소드명 앞에 fun을 입력
2. parameter 표기 기존 데이터타입 객체명 에서 인자: 데이터 타입로 변경
3. 리턴형 표기가 기존 메소드명 앞 ' 리턴형 ' 에서 (파라메터) 우측 옆 ' : 리턴형 '으로 변경

• 자료형 표기가 int에서 Int로 변경
• void의 경우 void(Unit)생략 가능.
• 기본 접근제한자가 기존 defalut에서 public로 변경

---

📚 Value, Variable(변수)와 데이터 형식

📙Value, Variable(변수)

var d: String = "처음이자 마지막 초기화"

val b = 2L //  L -> short타입과 구분 짓기
val c = 3.14f //  f -> Double과 구분 짓기

val d: String // 선언
d = "null값이 안되도록 초기화 진행"
val a: Int = 1 // 생성

val e: String? // ? -> null값 존재 가능

var ary = ArrayList<Int>(1)
ary!!.add(99)

val boolNull: boolean? = null

📌자바와의 차이점

• final(고정값)을 val로 표시하고 final이 아닌경우 var로 표시
• 타입추론이 가능하므로 자료형 생략가능
• 기본적으로 null값이 들어가는 것이 불가능
• null값을 넣고싶을 경우 자료형 우측에 '?'를 붙이기
• ' ? '이 널값 존재표기라면 반대로 널값 불가능표기는 변수명우측에' !! '로 표기
• ' ? '이 붙으면 null값이 들어왔을때 skip가능

📙데이터 형식 (기본형 변수)

분류	키워드	크기	최소 ~ 최대
논리형	Boolean	1 bit	true,false
문자형	Char	2 byte	0 ~ 65,535
정수형	Long	8 byte	-2^63 ~ 2^63 -1
	Int	4 byte	-2^31 ~ 2^31 -1
	Short	2 byte	-2^15 ~ 2^15 -1 (-32,768 ~ 32,767)
	Byte	1 byte	-2^7 ~ 2^7-1 (-128 ~ 127)
실수형	Float	4 byte	약 1.4E-45 - 3.4E+38
	Double	8 byte	약 4.9E-324 - 1.7E+308

---

📚 Template

var name = "hyo-sang"
var lastName = "Seong"
println("my name is ${name}lastName")

println("my name is ${name + lastName}.")

println("my name is ${name}\${lastName}.")

println("my name is ${name}\\lastName")

📌자바와의 차이점

• ' + '가 아닌 ' ${내용} ' 을 사용 '{ }'는 띄어쓰기 구분 용도
• 변수 두개가 이어질 경우 ' ${ } '안에서 + 사용 가능
• ' $변수명 '뒤에 ' \ '를 붙이면 변수명뒤로는 문자취급
• ' $변수명 '뒤에 ' \ '를 문자로 넣고 싶을시, ' 역슬래쉬 두번 '입력

---

📚 반복문

📙for, while문

for (변수 in 시작..끝 step 증가량) {

}

for (변수 in 시작 until 끝){ // 끝 미포함  

}

for (변수 in 끝 down 시작 ) {

}

for (변수 in 배열명.indices) { //배열요소 한번에 출력

}

for (변수 in 배열명) { //배열요소 하나씩 출력

}

for ((index : index, name : String) in name.indeces.withIndex()) {

}

📌자바와의 차이점

• 표기변경 ' .길이 ' 에서 ' .indices ' 또는 생략

📙when문

구문식 (Expresstion)

var jumsu : Int = (count / 10) * 10
when(jumsu) {

100 -> print("1순위")

90, 80, 70 -> print("2순위") //일부 항목지정

in 69..60 -> print("3순위") //범위지정

!in 10..0 -> print("통과")

!is Int -> print("정수가 아님")

}

표현식 (Statement)

var b : Int = when(scope) {
1 -> 1
2 -> 2

else -> 3
}

📌자바와의 차이점

• 표기변경 switch 에서 when 으로
• 표기변경 : 에서 -> 로
• break 생략
• ,를 이용해서 일부 항목을 지정 가능
• in 시작숫자. .마지막 숫자 // 범위지정 가능
• !in // 위 항목의 부정
• !is // 논리판별
• 표현식 사용 가능
• 표현식의 경우, 예외가 발생하지 않도록 else 입력 필수
• 표기변경 default 에서 else 로

---

📚 Array(배열) and List

📙Array(배열)

1차원 배열

var one = Array<Int>(4,{0})

val array = arrayOf(1,2,3)

val arrayOf = arrayOf(1, "d", 3.14f)

one[0] = 10
one[1] = 20

2차원 배열

var arr1 = Array(2){Array(3){i->(5)}} //2행 3열 초기화값 5

var arr2 = arrayOf( arrayOf(5,5,5), arrayOf(5,5,5) ) //위와 동일

val arr3 = Array(2){ i -> Array(3){ j ->(i*3) + (j+1)}} // [{1,2,3},{4,5,6}]

var count2 = 0
    for((count1, i) in arr1.indices.withIndex()){
        for(j in arr1[i]){
            println("${count1}행 ${count2}열의 값은 $j 입니다.")
            count2++
        }
        if(count2 == arr1[i].size){
            count2 = 0;
        }
    }

📌자바와의 차이점

• val를 쓰는 이유는 주소값을 참조하므로

• 1차원 배열

  • var 배열명 = Array<데이터 타입>(갯수, {초기화값})
  • var 배열명 : IntArray = intArrayOf(1,2,3) //값을 바로 입력
  • 데이터 타입 혼용 가능
  • 배열명[인덱스] = 값 입력

• 2차원 배열

  • var 배열명 = Array(행 갯수){ Array(열 갯수), { _->(초기확 값)} }
  • 1차원 배열의 "초기화값"자리에 " 1행에 대한 arrayOf(값), 2행에 대한 arrayOf(값) "를 넣음
  • 자바코드로 바꿔서 이해 할 예정
  • java의 확장형 for문으로 값을 출력하는 것과 같음

📙List

List

val list1 = listOf(1,"d",11L) 

MutableList(수정가능)

val arraList1 = arrayListOf(1,"d",3)

📌List와 mutableList의 차이점

• mutableList인터페이스를 상속받은 ArrayList는 mutableList의 set메소드에 의해

  읽기만 가능한 List와 다르게 쓰기도 가능

---

📚 Nullable / NonNull

var nullName : String? = null

val nullNameInUC = nullName.?toUpperCase()

val name = "joyce"
val lastName : String? = null
var fullName = name + (lastName ?: "Hong")

val email: String? = "tjdgytkd!naver.com"
email?.let{
        println("my email is $email")
    }
}

fun igonoreNulls(str: String?){
    val mNotNull: String = str!!

📌자바와의 차이점

• 자료형뒤에 ' ? '이 붙지 않을 경우, null 입력이 불가능
• 메소드 사용시에는 객체명뒤에 ' ? '을 붙이면 null값일시, Skip
• " 객체명?: "는 null값일떄 실행
• " 객체명?.let "는 null값이 아닐떄 실행
• ' !! '는 NonNull로 선언

---

📚 Class

📙생성자

class Human (var name : String){

    init {
        println("create Human class")
    }
}

fun main() {
    val human1 = Human( "name1" )
    val human2 = Human( "name2")
}

📌자바와의 차이점

• 클래스를 생성할떄 생성자도 같이 생성가능
• 주 생성자와 부 생성자로 분류
• 부 생성자는 ' constructor '로 생성
• 주 생성자의 코드블럭은 ' init{ 내용 } ' 로 작성
• 인스턴스 생성시 Expression로 생성자가 바로 실행

📙오버로딩

class Human(){

    constructor(name: String, age: Int ): this()  {
        println("my name: $name \nmy age: $age")
    }

    constructor(name2: Int): this(){

    }
}

fun main() {
    val human3 = Human(29)
}

📌자바와의 차이점

1. 오버로딩을 위해서는 클래스명 옆에 빈생성자 넣기
2. 오버로딩한 생성자 옆에 : this()를 붙여서 부모생성자 호출이 필수

📙오버라이딩

open class Human(){

    open fun song(){
        println("lalala")
    }
}

class Korean : Human(){

    override fun song(){
        println("라라라")
    }

}

📌자바와의 차이점

• Kotlin에서의 class는 final이므로 오버라이딩을 위해서는

  모티브 대상의 앞에 open을 기입

📙Lamda

기본형

val lamdaName = {argumentList -> codeBody}

val calculater  = {number : Int -> number*number}

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

fun main(){
   println(calculater(12))
    println(nameAge("hyosang", 29))
}

확장형

fun main(){
   val a = "joyce said"

   println(a.pizzaGreat())

   println(extnedsString(hyo-sang, 29))
   println(caculater(97))
}

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

val extendsString(name : String, age : Int) {
    val introduceMyself : String.(Int) -> String = { "I am $this and $it years old" }

    return name.introduceMyself(age)
}
val calculater((Int) -> String){
    when(it){
        in 0..59 : "fail"
        in 60..89 : "pass"
        in 90..100 : "bonus point"
        else : "Error"
    }
}

람다식 parameter로 넣기

fun main(){
    val lamda1 = {number : Double -> number == 4.3213}
    println(invokeLamda(lamda1)) // true

    println(invokeLamda { it > 3.22 }) // false

}

fun invokeLamda(lamda : (Double) -> Boolean) : Boolean {
    return lamda(5.2343)
}

📌특징

• 메소드로 사용가능
• 인자가 하나인 경우 it으로 표기 가능
• return으로 사용 가능
• 메소드 인자로 사용가능

---

📚 DataClass

data class Ticket(val companyName: String, val name: String, var date: String, var seatNumber : Int)
// toString(), hashCode(), equals(), copy()

class TicketNormal(val companyName: String, val name: String, var date: String, var seatNumber : Int)

fun main(){
    val ticketA = Ticket("koreanAir", "hyosang", "2020-02-16", 14)
    val ticketB = TicketNormal("koreanAir", "hyosang", "2020-02-16", 14)

    println(ticketA) // Ticket(companyName=koreanAir, name=hyosang, date=2020-02-16, seatNumber=14)
    println(ticketB) // com.example.myapplication.TicketNormal@6fadae5d
}

📌class와 data Class 차이점

• toString(), hashCode(), equals(), copy() 메소드를 자동생성
• 클래스명을 print할 경우, haskCode가 아닌 인자값을 그대로 출력
• 내부class에 여러 data class를 넣으면 관리가 용이함

---

📚 Companion object

interface IdProvider {
    fun getId(): Int
}

class Book private constructor(val id: Int, val name: String) {

    companion object BookFactory : IdProvider {

        override fun getId(): Int {
            return 444
        }

        var myBook = "new book"
        fun create() = Book(getId(), myBook)

    }

}

fun main() {

    val bookId = Book.getId()
    val book = Book.create()

    println("${bookId}${book.name}") // 444new book

}

📌특징

• java의 static과 비슷한 존재
• 모든 인스턴스와 공유하는 객체를 만들고 싶을때 사용
• 클래스당 하나만 사용

---

📚 Object

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)
    var car2 = CarFactory.makeCar(200)

    println(car) // Car(horsePower=10)
    println(car2) // Car(horsePower=200)
    println(CarFactory.cars.size.toString()) // 2
}

📌특징

• java의 SingleThon과 비슷한 존재
• 객체가 한번만 생성되어 불필요한 메모리 낭비가 없음
  
  

📚 Scope Function (apply, with, let, also, run)

📙 apply

Kotlin

val person = Person().apply{
    firstname = "Fast"
    lastName = "Campus"
}

Java

Person person = new Person();
   person.firstname = "fast"
   person.lastName = "Campus"

📌특징

• 인스턴스생성 후 초기화를 시킬떄 유용함
  
  

📙 Also

Kotlin

Random().nextInt(100).also{ //인수가 하나이므로 ' it '으로 표기하여 다이렉트로 사용 가능
    print("getRandomInt() generated value $it")
}
Random().nextInt(100).also{
    print(value -> "getRandomInt() generated value $value")
}

Java

int value = Random().nextInt(100);
System.out.print(value);

📌특징

• 반환값을 객채에 담아서 람다식으로 가공 후 다시 반환
• 사용처 : 유효성 확인 및 디버깅에 이용소지가 있음.
  
  

📙 let

Kotlin

val number: Int?

val sumNumber = number?.let {
    "${sum(10, it)}"
}.orEmpty()

Java

Integer number= null;
String sumNumberStr= null;

if (number != null){
    sumNumberStr = " " + sum(10, number);
}

📌특징

• null이 아닌 경우 람다식으로 가공할떄 사용
• null인 경우는 실행을 안하지만 .orEmty를 이용하면 빈값으로 처리가능
  
  

📙 with

Kotlin

val person = Person()

with (person) {
    work()
    sleep()
    println(age)
}

Java

Person person = new person();

person.work();
person.sleep();
System.out.print(person.age);

📌특징

• 클래스명을 with 인자값에 넣음으로써 메소드명만 기입하여 메소드를 실행가능
  
  

📙 run

Kotlin

val result = service.run{
    port = 8080
    query()
}

Java

service.prot = 8000
Result result = service.query()

📌특징

• 어떤값을 계산할 필요가 있거나 객체구성(초기화)과 계산결과를 한번에 처리할떄
• when과 다른점은 확장함수로 사용가능
  
  

---

📚 lateinit, lazy init

📙 lateinit

lateinit 미사용

var nullableNumber : Int? = null

nullableNumber?.add()

lateinit 사용

lateinit var lateinitNumber: Int

lateinitNumber = 10

lateinitNumber.add()

📌특징

• val는 고정값이라 예약 선언을 할 이유가 없으므로
  
  var에만 사용

• null허용객체를 미리 선언할때 null값을 입력하지 않으므로
  
  NullSafe한 코딩에 용이함

  
  
  

📙 lazy init

val lazyNumber : Int by lazy{
    100 // 사용하기전까지 메모리에 할당이 되지 않음

lazyNumber.add()
//100 할당됌
}

📌특징

• val객체선언을 대기시킬 수 있음
• 사용하기전까지 메모리에 할당이 안됌
• view속성들을 미리 걸어 놓을때 용이함