Code__

선언 예시

class Car(var engine: String, var body: String) 
{ 
} 

사용 예시

class SuperCar 
{ 
    var engine: String 
    var body: String 
    var door: String 

    // 객체 생성시 호출되는 초기화 (호출 순서 1) 
    init 
    { 
      	println("초기화") 
    } 

    // 생성자 (호출 순서 2) 
    constructor(_engine: String, _body: String, _door: String) 
    { 
        println("생성자") 
        this.engine = _engine 
        this.body = _body 
        this.door = _door 
    } 

    fun ride() 
    { 
        println("탑승") 
    } 

    // overload: 이름이 같지만 인자의 타입 또는 갯수가 다르면 이름을 중복하여 사용할 수 있다. 
    fun ride(WithDog: String) 
    { 
      	println("강아지 $WithDog" + "와 함께 탑승") 
    } 

    fun drive() 
    { 
      	println("운전") 
    } 

    fun navi() 
    { 
      	println("목적지는 워싱턴") 
    } 
} 

fun main(args: Array<String>) 
{ 
    val SteelCar = Car("v8", "Steel") 
    val Car1: Car = Car("x9", "Wood") 

    val CarS: SuperCar = SuperCar("x9", "Wood", "2way") 
} 

val numList = mutableListOf<Int>(1,2,3,4)

1. for문

반복하여 List의 원소 값을 출력

for(item in numList)
{
    println(item)
}
/*
출력값
1
2
3
4
*/

1-1. 인덱스와 원소 값을 함께 출력

for( (index, item) in numList.withIndex())
{
    println("index: $index, value: $item")
}

/*
출력값
index: 0, value: 1
index: 1, value: 2
index: 2, value: 3
index: 3, value: 4
*/

1-2. 반복 횟수를 지정

until은 크기 - 1만큼을 뜻한다.

for(i in 0 until numList.size) // 0 부터 numList의 크기 - 1 만큼 반복
{
    println( "until: $i" )
}

step: 증가 값을 지정

0부터 2씩 증가하여 i에 대입한다.

numList의 인덱스를 0, 2, 4, 6 ... 이런식으로 접근하여 사용한다.

for(i in 0 until numList.size step (2))
{
    println( "step: $i" )
}

downTo 값을 감소시키면서 반복

for ( i in numList.size - 1 downTo (0) )
{
    println( "downTo: $i" )
}

downTo, step: step값 만큼 감소 시켜서 반복

for ( i in numList.size - 1 downTo (0) step (2))
{
    println( "downTo step: $i" )
}

배열.size 마지막을 포함한다

for(i in 0..numList.size)
{
    println("..: $i")
}

2. foreach

numList.forEach {
    println(it)
}

numList.forEach { item ->
    println(item)
}

2-1. index를 포함한 forEach

numList.forEachIndexed { index, item ->
    println("index: $index, value: $item")
}

3. While문

반복문 내부에 조건을 거짓으로 만드는 탈출 문장이 있어야 끝나게 된다.

var W1: Int = 0
var W2: Int = 6

while (W1 < W2)
{
    ++W1
    println("$W1: W1")
}

3-1. Do While문

최소 1번의 실행을 보장하는 반복문

var W3: Int = 0
var W4: Int = 6

do 
{
    println("$W3: W4")
    ++W3
}while(W3 < W4)

Immutable Collections : 값을 추가, 삭제, 변경이 불가능 한 콜렉션 
listOf<T>, setOf<T>, mapOf<TKey, TValue> 

// 1. List -> 중복 허용 
val numberList = listOf<Int>(1, 2, 3, 3, 3) 
// 출력 값: [1, 2, 3] 

// 1-1. 원소단위로 출력 
println(numberList[0]) 
println(numberList[1]) 

// 2. Set (집합) 
// 집합의 특징: 중복을 허용하지 않는다, 순서가 없다 
val numberSet = setOf<Int>(4, 5, 6, 6, 6) 
// 출력 값: [4, 5, 6] 

// 2-1. 출력 
// 순서가 없기 때문에 Index가 없다. 
numberSet.forEach { println(it) } 
// 출력 값: 4 5 6 

// 3. Map -> 원소가 쌍을 이루는 Key와 value를 가진다 
// mapOf<Key, Value> 
val numberMap = mapOf<String, Int>("A" to 11, "B" to 22, "C" to 33) 
// 출력 값: {1=A, 2=b, 3=C} 

// 3-1. 출력: Key값을 인덱스로 사용한다. 
println(numberMap["A"]) 
println(numberMap["B"]) 
println(numberMap["C"]) 

Mutable Collection : 추가, 삭제, 변경이 가능한 콜렉션

mutableListOf<T>, mutableSetOf<T>, mutableMapOf<TKey, TValue>

// 1. List
val mNumberList = mutableListOf<Int>(0, 1)

// 1-1. 마지막 Index 뒤에 순서대로 원소를 수가
mNumberList.add(3)
mNumberList.add(4)
println(mNumberList)
// 출력 값: [0, 1, 3, 4]

// 1-2. 위치를 지정하여 원소소를 추가
mNumberList.add(0, 10)
println(mNumberList)
// 출력 값: [10, 0, 1, 3, 4]

// 1-3. 지정한 index에 원소 추가
mNumberList.set(0, 100)
// 출력 값: [100, 0, 1, 3, 4] 해당 위치에 값이 들어가고 기존값 부터 우측 index로 이동된다.

// 1-4. 지정한 index의 원소 제거
mNumberList.removeAt(0)
// 출력 값: [0, 1, 3, 4]

// 2. Set
val mNumberSet = mutableSetOf<Int>(1, 2, 3, 3, 3)

// 2-1. 원소 추가
mNumberSet.add(10)
println(mNumberSet)
// 출력 값: [1, 2, 3, 10]

// 2-2. 원소제거: 제거할 원소의 "값"을 입력한다
mNumberSet.remove(2)
// 출력 값: [1, 3, 10]

// 3. Map
val mNumberMap = mutableMapOf<String, Int>("one" to 1, "two" to 2)

// 3-1. 원소 추가
mNumberMap["three"] = 3
mNumberMap["a"] = 10
mNumberMap.put("kkk", 999)
println(mNumberMap)
// 출력 값: {one=1, two=2, three=3, a=10, kkk=999}

// 3-2. 값 변경
mNumberMap.replace("two", 222)
// 출력 값: {one=1, two=222, three=3, a=10, kkk=999}

// 3-3. key, value의 목록출력
println(mNumberMap.keys)
// 출력 값: [one, two, three, a, kkk]

println(mNumberMap.values)
// 출력 값: [1, 222, 3, 10, 999]

// 3-4. Map의 전체 내용지우기
mNumberMap.clear()

package com.rodunstudio.kotlinbasic.Example 

fun main(args: Array<String>) 
{ 
    // 1. 배열: 같은 Type을 가지는 연속되는 변수의 목록이다. 

    // 2. 배열의 생성 방법 
    // 2-1. Type을 명시하여 생성 (Int Type을 가지는 배열) 
    var group1 = arrayOf<Int>(1, 2, 3, 4, 5) 

    // 2-2. Type을 명시하지 않고 직접 원소를 넣으면 
    // 다양한 Type의 목록을 가지는 배열을 만들 수 있다. 
    var group2 = arrayOf(1, 2, 3.5, "Hello") 

    // 3. Index: 배열 원소의 번호 
    // 3-1. Index를 활용하여 배열의 원소를 가져오기 
    val element1 = group1[0] 
    val element2 = group1[4] 

    // 3-2. Index를 활용하여 배열 원소의 값을 바꾸기 
    group1[0] = 100 
    group1[4] = 222 

    // 4. Type이 지정되어 있는 배열선언 
    val arr = intArrayOf(1, 2, 3) 
    val arr2 = charArrayOf('a', 'b') 
    val arr3 = booleanArrayOf(true, true, false, false, true) 

    // 5. Array를 이용한 배열 선언 (람다식) 
    var Array1 = Array(20, { 0 }) 
    var Array2 = Array(5, { 1; 2; 3; 4 }) 

    var Ary = Array(5, { i -> ( i * i ) } ) 
    for ( emt in Ary ) 
    { 
    	println( emt ) 
    } 
    
    /*결과 
    0 
    1 
    4 
    9 
    16 
    */ 
    // 람다식에 의해서 i의 제곱을 생성하게 된다. 

} 

package com.rodunstudio.kotlinbasic.Example 

fun main(args: Array<String>) 
{ 
  // 1. When 사용법 
  var value: Int? = 3 
  when( value ) 
  { 
      1 -> println("value는 1이다.") 
      2 -> println("value는 2이다.") 
      3 -> println("value는 3이다.") 
      else -> 
      { 
          println("값을 알수없다.") 
          value = null 
      } 
  } 

  // 2. When의 반환값 
  val value2 = when(value) 
  { 
      1 -> 11 
      2 -> 22 
      3 -> 33 
      else -> null 
  } 

  // 2-1. 값을 return하는 when은 모든 경우의 수에도 값을 return하도록 구성해야 한다. 
  var BooleanCheck: Boolean? = null 
  val result1: Int = when(BooleanCheck) 
  { 
      true -> 2 
      false -> 3 
      null -> 0 // 위의 Boolean변수가 null을 포함하도록 선언 되었기 때문에 추가 
  } 

  // 3. 중복 조건(x, y, z)과 범위 설정 (in x..y) 
  val value3 = when(value) 
  { 
      1, 11, 21 -> 11 // 중복 조건은 ,(콤마)로 설정 가능 
      in 4..40 -> 44 // 범위 설정 ( 4 <= x <= 40 )을 뜻함 
      else -> null 
  } 

  // 4. Any Type: 어떤 Type으로도 변할 수 있는 Type 
  // 4-1. is 구문: 변수의 Type을 묻는 구문 
  val value4: Any? = null 
  when (value4) 
  { 
      is Int -> 20 
      is Float -> 5.5f 
      is Double -> 10.55 
      is Boolean -> true 
      else -> println("Type을 알수없다.") 
  } 
  println(value4) 

} 

fun main (args: Array<String>) 
{ 
    var a: Int = 5 
    var b: Int = 7 

    // 1. if문: 괄호안의 조건이 참(true)경우 중괄호안의 내용을 실행한다. 
    if(a < b) 
    { 
        println("a가 b보다 작을 경우 실행") 
    } 

    // 2. else 문: 괄호안의 조건이 거짓(false)일 경우 else문 중괄호안의 내용을 실행한다. 
    // else문 혼자서만 사용될수 없고 반드시 if문 하위에 존재 하여아 한다. 
    if( a > b ) 
    { 
        println("a가 b보다 클 경우 실행") 
    } 
    else 
    { 
        println("a가 b보다 작거나 같을 경우 실행") 
    } 

    // 3. else if문: 참인 조건을 검사하는 if문을 중첩한다. 
    if( a > b ) 
    { 
        println("a가 b보다 클 경우 실행") 
    } 
    else if( a == b ) 
    { 
        println("a와 b가 같을 경우 실행") 
    } 
    else 
    { 
        println("위의 두 조건이 모두 거짓(false)이면 실행") 
    } 

    // 4. Return 값을 가지는 if문 
    // 모든 경우의 수를 만족해야 하기때문에(null safe) else문으로 마무리를 해주어야 한다. 
    val result = if(a > b) 
    { 
        "a가 b보다 크다." 
    } 
    else 
    { 
        "a가 b보다 작거나 같다." 
    } 
    println(result) 

    // 4-1. 간단하게 표기 
    val result2 = if(a > b) a else b 
    println(result2) 

    // 5. 엘비스 연산자: 대입할 변수가 null일 경우를 대비하는 연산자 
    val number: Int? = null 
    val number2 = number ?: 10 // <- 변수 number가 null일 경우 10일 대입한다. 
    println(number2) 
  
} 

fun main(array: Array<String>) 
{ 
    var Number1: Int = 1 
    var Number2: Int = 2 
    var Result: Int? = null 

    /* 1. 대입 연산자: 우변의 값이 좌변으로 복사된다. */
    Result = 10 

    // 2. 산술 연산자 
    Result = Number1 + Number2 // 덧셈 
    Result = Result - Number1 // 뺄셈 
    Result = Result * 3 // 곱셈 
    Result = Result / 2 //<- 몫 
    Result = Result % 3 //<- 나머지 

    // 3. 복합 대입 연산자 
    Result += Number1 //Result = Result + Number1을 줄여서 기술한 것 
    // -=, *=, /=, %= 

    // 4. 증감 연산자 
    Result++ // Result += 1과 같이 1값을 증가 시킨다. 

    // ++를 변수 앞에 적어주게 되면 변수의 현재값에 1을 더한후 다른 연산을 진행하게 된다. 
    // 뒤에 붙이게 되면 연산이 끝난 후에 1값을 증가시킨다. 
    ++Result 
    // Result--, --Result 

    // 5. 비교 연산자 
    var ComParison: Boolean = true 
    ComParison = 4 > 3 
    ComParison = 4 < 3 
    ComParison = 5 >= 5 
    ComParison = 9 <= 7 
    ComParison = 2 == 2 
    ComParison = 2 != 2 

    // 6. 논리 연산자: &&(and), ||(or), !(not) 
    ComParison = true && true 
    ComParison = true || false 
    ComParison = !true 
    ComParison = !false 

    // 7. 엘비스 연산자: 대입할 변수가 null일 경우를 대비하는 연산자 
    val number: Int? = null 
    val number2 = number ?: 10 // <- 변수 number가 null일 경우 10일 대입한다. 
    println(number2) 
} 

내부 함수
함수 내부에 존재하는 함수

fun showMyPlus(_first: Int, _second: Int): Int 
{ 
    fun double(_number_: Int): Int 
    { 
	return _number_ * _number_ 
    } 

    return double(_first) + double(_second) 
}