kotlin programming langauage - 반복제어문

while loop

자바와 거의 동일하다

[while문]

    while (x > 0) {
        x--
    }

[do..while 문]

do{
    print(x)
}while(x>0)

}

for loop :http://kotlinlang.org/docs/reference/grammar.html#for

자바의 iterator를 이용한 for문과 비슷하다.

for (item in collection)
    print(item)

물론 {}를 사용해도 되고 타입을 지정해도 된다.

for (item:String in collection){
    print(item)
}

인덱스 기반으로 사용할 경우 indices함수를 사용한다. 해당 함수는 컬렉션의 int range를 리턴해준다.

for (item in collection.indices)
    print(item)

그리고 이터레이터를 이용한 for문 사용시 문제가 되었던 인덱스 사용도 withIndex()함수를 사용한다면 별도의 구현이 필요 없다.

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

ranges and in

label and return

kotlin에도 반복문을 제어하기위해  label과 continue, break, return이 있다.기본은 자바와 같다. 

 return : 실행중인 함수가 종료된다.

continue :가장 가까운 반복문의 다음 단계로 이동

break:가장 가까운 반복문을 종료 시킨다.

먼저 라벨을 설명하기 위해 자바와 비교하자면

자바의 Label  반복문 앞에 라벨명:<반복문>의 형식으로 사용한다

public static void main (String[] args){
    firstLabel:for(int i=0;i<10;i++){
        for(int j=0;j<10;j++){
            if(j%2 >0) continue ;           
            if(j==4) continue firstLabel;          
            System.out.println(i + "-"+j);
        }
    }
}

kotlin에서는 

fun main(args:Array<String>){
    val x =arrayOf("a","b","c")
    firstLabel@ for(i in 1..10) {
        for (j in 1..10) {
            if (j % 2 > 0) continue
            if (j > 5) continue@firstLabel 
           println("$i - $j")
        }
        println("after foreach")
    }
}

람다식 foreach에서의 라벨 사용

fun main(args:Array<String>){
    val x =arrayOf("a","b","c")
    x.forEach {
        if(it == "b") return
        println("$it")
    }
    println("after foreach")
}

if 조건에 맞아 return이 실행되면 함수가 종료되고 결과는 a만 출력된다.

fun main(args:Array<String>){
    val x =arrayOf("a","b","c")
    x.forEach loop@{
        if(it == "b") return@loop
        println("$it")
    } 
   println("after foreach")
}

라벨을 사용하면 함수전체가 종료되는 것이 아니라 해당 조건만 종료되고 계속진행된다.

결과는 a c after foreach가 출력된다.

람다식에서는 함수와 같은 이름의 라벨을 사용 한다면 라벨선언을 생략할 수 있다.

fun main(args:Array<String>){
    val x =arrayOf("a","b","c")
    x.forEach {
         if(it == "b") return@forEach
        print(it)
    }}

햇갈린다면 익명 함수를 람다 표현식 안에 선언하여 사용할 수 있다.

fun main(args:Array<String>){
    val x =arrayOf("a","b","c")
    x.forEach(fun(value:String){
        if(value == "b") return
        print(value)
    })

}

kotlin programming language - 조건 제어문

kotlin에는 if, when 두가지 조건 제어문이 있습니다.

if 조건문

//1.전통적인 사용법

var max = a 

if (a < b)
  max = b
 

// 2.if .. else

var max: Int

if (a > b) 

  max = a
else
  max = b
 

kotlin에서는 if문으로 3항연산자를 표현할 수 있습니다.

val max = if (a > b) a else b

오른쪽 조건문의 값이 왼쪽 변수에 대입될 수 있습니다. 만약 if문에 {}블록이 있다면 마지막 항목이 해당 블록의 리턴값이 됩니다.

val max = if (a > b) {
    print("Choose a")
    a
  }
  else {
    print("Choose b")
    b 

  }

a가 1 b가 2라고 한다면 max = 2가 됩니다.

when 

when은 기존의 switch문을 대신합니다. 

when (x) {

  1 -> print("x == 1") //x가 1일 때 

  2 -> print("x == 2") //x가 2일 때

  else -> { // 나머지 경우
    print("x is neither 1 nor 2")

  }}

변수가 다르지만 같은 결과를 출력 때는 ','로 구분하여 사용할 수 있습니다.

when (x) {
  0, 1 -> print("x == 0 or x == 1")

  else -> print("otherwise")}

또 in 을 range나 컬렉션과 함께 사용할 수 있습니다.

when (x) {
  in 1..10 -> print("x is in the range")
  in validNumbers -> print("x is valid")
  !in 10..20 -> print("x is outside the range")

  else -> print("none of the above")}

타입 체크시에는 'is'를 사용합니다.

val hasPrefix = when(x) {
  is String -> x.startsWith("prefix")
  else -> false}

kotlin programming language - 클래스 생성

클래스의 생성

코틀린에서는 new 선언자가 없다. 클래스명()으로 선언한다.

class Example(){} -> Example()

생성자

primary constructor와 한개 또는 그 이상의 secondary constructor를 갖는다.

primary constructor : 클래스 헤더에 선언

class constructor Example(title:String){}

단, 다른 annotation이나 visible modifier가 없다면 생략 가능

코클린의 모든 클래스는 공통 클래스 Any를 갖는다. 이것은 기본 선언없이 사용되며 java.lang.Object는 아니다.

클래스를 상속하기 위해서는 'open' annotaion을 붙여준다. 이는 final과 반대되는 성격의 지시자 이다. 다음과 같이 사용한다.

open class Base(p: Int){}


class Derived(p: Int) : Base(p){}

method overrinde

java와 동일하게 사용된다. super class에 동일한 메소드가 있다면 override annotation을 앞에 붙인다.

super class의 멤버에 open으로 선언되어 있어야 한다.

open class Base {
  open fun v() {}
  fun nv() {}}class Derived() : Base() {

  override fun v() {}}

gettter&setter

-작성중-

Kotlin Programming Language 시작하기 - 기초문법

1. 기초 문법

 - 패키지 선언 : 자바와 같이 최상단에서 선언한다.

package foo.bar

fun baz() {}

class Goo {}

자바와 다르게 클래스와 메소드가 한 파일에 같은 레벨로 존재할 수 있다.

따라서 import시 사용할 메소드와 클래스의 패키지명은 같다

메소드 baz()의 풀패키지명은 foo.bar.baz

클래스 Goo의 풀 패키지명은 foo.bar.goo

패키지명이 특정되지 않았다면 default 패키지에 속하고 아무런 이름이 없다.

Imports

import foo.Bar // Bar만 접근가능 

import foo.* // foo의 모든 컨텐츠(패키지,클래스, 오브젝트 등등)에 접근가능

패키지명이 충돌할 수도 있다. 이때에는 'as'키워드를 사용한다

import foo.Bar // Bar is accessible

import bar.Bar as bBar // bBar stands for 'bar.Bar'

자바와는 다른점 import static이 없다. 패키지명이 디렉토리 구조와 달라도 상관없다

 메소드 선언하기

 fun 지시자(?)를 통해 선언하며  자바와 리턴타입과 파라미터 표현 방식이 조금 다르다. 형식은 다음과 같다. 

  fun <function 명>(<파라미터명>:<파라미터타입>):리턴 타입 

 예제로 제시된건 4가지 방법 있다. 

가. 자바와 비슷하게 return 타입을 선언하고 body에 return문 기술

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

나. return 타입을 생략하고 = 우측에 return 문 기술

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

다. void 타입(return 타입 Unit은 void와 같다.)

fun printSum(a: Int, b: Int): Unit {
    print(a + b)
}

라. 3의 unit은 생략될 수 있다

fun printSum(a: Int, b: Int) {
    print(a + b)
}

변수 선언
변수를 선언할 때에는 크게 val과 var 두가지 타입으로 선언할 수 있다. val은 자바의  final과 비슷하며 선언하고 값을 초기화한 뒤에는 더이상 수정되지 않는다. var는 계속 수정 가능하다. 아래와 같이 선언 할 수 있다.

val a: Int = 1 //int 타입으로 선언하고 정수 1로 초기화
val b = 1   // 초기화 값이 있다면 타입 생략 가능

 val c: Int  // 선언과 동시에 초기화 하지 않는다면 타입선언 필요

c = 1       // 초기화

c=2       //다시 값을 변경하려 한다면 Kotlin: Val cannot be reassigned 오류발생

var x = 5 // `Int` type is inferredx += 1

null타입 변수 선언
null타입의 변수를 선언하기 위해서는 변수선언시 타입뒤에 ?를 붙여준다.

val canNull:String? = null //null로 변수를 초기화할 수 있다. 다만 val타입 변수는 다시 값을 변경할 수 없다 
val notNull:String = null  //null은 non-null type 변수의 값이 될 수 없다.