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)

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) 
} 

함수란 ?
input값을 넣어주면 ouput이 나오는 것

예시)
y = x + 2
x에 1을 넣으면 y는 3이 된다.
x에 0.5를 넣으면 y는 2.5가 된다.

함수 선언방법

fun 함수명 (인자명: 타입, 인자명: 타입 ….): 반환형 
{ 
    함수 내용… 

    return 반환값 
}

(사용 예시)

fun plus(_first: Int, _second: Int): Int 
{ 
    var result: Int = _first + _second 
    result *= 2 

    return result 
} 

fun main(array: Array<String>) 
{ 
    val printNumber = plus(7, 11) 
    println(printNumber) 

    // 인자명을 명시하여 값을 넣을 경우 순서를 지키지 않아도 된다. 
    val number2 = plus(_second = 4, _first = 3) 
    println(number2) 
} 

디폴트(기본) 값을 갖는 인자

// _second 인자에 디폴트 값으로 5를 지정 
fun plusFive(_first: Int, _second: Int = 5): Int 
{ 
    val result: Int = _first + _second 
    
    return result 
} 

fun main(array: Array<String>) 
{ 
    // _second 두번째 인자의 값을 넣어주지 않아도 에러가 발생하지 않는다. 
    var result = plusFive(20) 
    println(result) 

    // 디폴트 값을 50으로 바꿔서 사용하도록 2번자에 값을 넣어줌 
    var result2 = plusFive(20, 50) 
    println(result2) 
} 

반환값이 없는 함수

// 반환값이 없는 함수는 반환 type으로 Unit을 적어준다 (Unit 은 생략 하여도 된다.) 
fun PrintPlus(_first: Int, _second: Int): Unit 
{ 
    val result: Int = _first + _second 
    println(result) 
} 

fun main(array: Array<String>) 
{ 
    // PrintPlus 내부에 println이 있으므로 함수 호출만으로 덧셈과 출력이 모두 실행된다. 
    PrintPlus(25, 66) 
} 

간단한 함수

// 간단한 함수 
fun simplePlus(_first: Int, _second: Int) = _first + _second 

fun main(array: Array<String>) 
{ 
    val simpleResult = simplePlus(24, 33) 
    println(simpleResult) 
} 

가변인자를 갖는 함수

// 가변인자를 갖는 함수 (인자를 vararg 형태로 만들어준다.) 
fun plusMany(vararg numbers: Int) 
{ 
    for(number in numbers) 
    { 
    	println("Numbers $number") 
    } 
} 

fun main(array: Array<String>) 
{ 
    plusMany(1, 2, 3, 4, 5) 
}