ABOUT ME

-

Today
-
Yesterday
-
Total
-
  • kotlin) 코틀린에서 변수와 타입, 연산자를 다루는 방법
    kotlin 2024. 7. 4. 21:03

    코틀린에서 변수를 다루는 방법

    1. 변수 선언 키워드

    • var : 변경 가능한 변수
    //java
    long number1 = 10L;
    //kotlin
    var number1 = 10L
    • val : 변경 불가능한 변수
    //java
    final long number1 = 10L;
    //kotlin
    val number1 = 10L

    변수 추론

    • java 에서는 String,Long 같은 Type 을 지정해줘야하지만 kotlin 에서는 지정할 필요가 없다
      • 그것을 가능하게 만드는것이 “변수 추론”
    var number1 = 10L   //이미 "10L" 이라는 값을 통해서 number1 이 "Long" Type 인것을 알 수 있다.
    var number1: Long   //값이 없을 경우 : 를 통해 number1 의 Type 을 지정해 줄 수 있다.
    • 코틀린의 타입 추론은 다음과 같은 원리를 기반으로 작동합니다
      • 리터럴 값: 리터럴 값 자체가 타입을 명확히 정의합니다.
      • 표현식: 표현식의 결과 타입을 분석하여 추론합니다.
      • 함수 반환 타입: 함수의 반환 타입을 기반으로 추론합니다.
      • 컬렉션 타입: 컬렉션의 요소 타입을 통해 추론합니다.
      • 람다 표현식: 람다 표현식의 파라미터와 반환 타입을 분석하여 추론합니다.
    fun main() {
        // 리터럴 값을 통한 타입 추론
        val number = 42  // Int로 추론
        val pi = 3.14159  // Double로 추론
        val greeting = "Hello, World!"  // String으로 추론
    
        // 표현식을 통한 타입 추론
        val sum = 10 + 20  // Int로 추론
        val message = greeting + " How are you?"  // String으로 추론
    
        // 함수 호출을 통한 타입 추론
        fun add(a: Int, b: Int): Int {
            return a + b
        }
        val result = add(5, 10)  // Int로 추론
    
        // 컬렉션을 통한 타입 추론
        val numbers = listOf(1, 2, 3, 4, 5)  // List<Int>로 추론
        val names = setOf("Alice", "Bob", "Charlie")  // Set<String>으로 추론
    
        // 람다 표현식을 통한 타입 추론
        val isEven = { n: Int -> n % 2 == 0 }  // (Int) -> Boolean으로 추론
    }

    val 과 element

    • val 은 final 과 동일하게 사용됨으로써 val 로 선언하더라도 element 를 추가할 수 있다.
    // final list 선언
    List<String> names = new ArrayList<>();
    //element 에 값 추가
    names.add("JS");
    // val 리스트 선언
    val languages = mutableListOf<String>()
    // 리스트에 "JS" 값을 추가
    languages.add("JS")

    !!모든 변수는 우선 val 로 만들고 꼭 필요한 경우 var 로 변경한다.!!

    2. Kotlin 에서의 Primitive Type

    • Java 에서는 primitive type 인 “long” 과 reference type 인 “Long” 이 있다.
    • 그러나 kotlin 에서는 둘다 var, val 로 표현된다.
    //java
    long number1 = 10L;
    Long number3 = 1_000L;
    //kotlin
    var number1 = 10L
    val number3 = 1_000L
    • kotlin 에서는 프로그래머가 boxing / unboxing 을 고려하지 않아도 되도록 Kotlin 이 알아서 처리해준다.

    3. Kotlin 에서의 nullable 변수

    • Kotlin 에서 null 이 변수에 들어가 수 있다면 “타입?” 를 사용해야 한다.
    • “타입?” 을 선언하면 reference type 이 된다.
    var number3: Long? = 1_000L   //java 에서 Long
    var number1: Long = 1_000L    //java 에서 long

    4. Kotlin 에서의 객체 인스턴스화

    • Kotlin 에서 객체 인스턴스화를 할 때에는 new 를 부팅지 않아야 한다.
    //java
    Person person = new Person("JS");
    //kotlin
    val person = Person("JS")

    코틀린에서 null을 다루는 방법

    1. Kotlin 에서의 null 체크

    //java
    public boolean startsWithA1(String str) {
      if (str == null) {
        throw new IllegalArgumentException("null이 들어왔습니다");
      }
      return str.startsWith("A");
    }
    
    //kotlin
    fun startsWithA1(str: String?): Boolean {
        if(str == null){
            throw IllegalArgumentException("null 이 들어왔습니다")
        }
        return str.startsWith("A");
    }
    
    //java
    public Boolean startsWithA2(String str) {
      if (str == null) {
        return null;
      }
      return str.startsWith("A");
    }
    
    //kotlin
    fun startsWithA2(str: String?): Boolean? {
        if(str == null){
            return null
        }
        return str.startsWith("A");
    }
    
    //java
    public boolean startsWithA3(String str) {
      if (str == null) {
        return false;
      }
      return str.startsWith("A");
    }
    
    //kotlin
    fun startsWithA3(str: String?): Boolean {
        if(str == null){
            return false
        }
        return str.startsWith("A");
    }

    2. Safe Call 과 Elvis 연산자

    • Safe Call
      • null 이 아니면 실행하고, null이면 실행하지 않는다(그대로 null)
    val str: String? = "ABC"
    str.length				//불가능
    str?.length				//가능
    • Elvis 연산자
      • 앞의 연산 결과가 null이면 뒤에 값을 사용
    val str: String? = "ABC"
    str?.length ?: 0

     

    위 코드를 Safe Call, Elvis 를 이용해서 수정하면

    //java
    public boolean startsWithA1(String str) {
      if (str == null) {
        throw new IllegalArgumentException("null이 들어왔습니다");
      }
      return str.startsWith("A");
    }
    
    //kotlin
    fun startsWithA1(str: String?): Boolean {
      str?.startsWith("A") ?: throw IllegalArgumentException("null이 들어왔습니다")
    }
    
    //java
    public Boolean startsWithA2(String str) {
      if (str == null) {
        return null;
      }
      return str.startsWith("A");
    }
    
    //kotlin
    fun startsWithA2(str: String?): Boolean? {
      return str.startsWith("A");
    }
    
    //java
    public boolean startsWithA3(String str) {
      if (str == null) {
        return false;
      }
      return str.startsWith("A");
    }
    
    //kotlin
    fun startsWithA3(str: String?): Boolean {
      return str?.startsWith("A") ?: false;
    }

    3. 널 아님 단언!!

    • str 이 절대 널이 들어올 수 없다는 선언
      • 만약에 이곳에 null 이 들어온다면 Error
    fun startsWith(str: String?): Boolean{
      return str!!.startsWith("A")
    }

    4. 플랫폼 타입

    Kotlin 에서 Java 문을 사용한다면?

    Java 코드를 Kotlin 에서 이해하고 사용한다.

    public class Person {
    
      private final String name;
    
      public Person(String name) {
        this.name = name;
      }
      @Nullable				//Java 코드에서 null 허용 어노테이션 선언시
      public String getName() {
        return name;
      }
    }
    
    
    fun main(){
      var person = Person("JS")
      startsWithA(person.name)		//이곳에서 에러가 발생함
    }
    
    fun startsWithA(str: String): Boolean {
      return str.startsWith("A")
    }

     


    코틀린에서 Type 을 다루는 방법

    1. 기본 타입

    //java 
    int number1 = 4;
    long number2 = number1;		//int 타입의 값이 long 으로 암시적으로 변경됨
    
    System.out.println(number1 + number2);
    
    
    //kotlin
    var number1 = 4
    var number2: Long = number1	// type mismatch
    var number2: Long = number1.toLong()		//이렇게 명시적으로 변경해야함
    
    println(number1 + number2)

     

    2. 타입 캐스팅

    //Java
    public static void printAgeIfPerson(Object obj) {
      if (obj instanceof Person) {
        Person person = (Person) obj;
        System.out.println(person.getAge());
      }
    }
    
    //Kotlin
    fun printAgeIfPerson(obj : Any){
        if(obj is Person){					//java 의 instanceof 와 동일한 기능 !is (반대 가능)
            val person = obj as Person		//as Person 은 "Person 타입으로 인식한다"이고 생략 가능하다.
            println(person.age)
        }
    }
    fun main() {
        printAgeIfPerson(null)
    }
    
    //함수가 null 이 가능하다면
    fun printAgeIfPerson(obj : Any?){
        val person = obj as? Person		//as 뒤에 ? 를 붙여 null 이 가능하다고 표현해야함
        println(person?.age)
    }

    3. Kotlin 의 3가지 특이한 타입

    • Any
      • Java 의 Object 역할
      • 모든 Primitive Type 의 최상단 타입도 Any
      • Any 자체로는 null 을 포함할 수 없어, null 을 포함하고 싶다면 Any?로 표현
      • equels / hashCode / toString 존재.
    • Unit
      • Java 의 void 와 동일한 역할
      • void 와 다르게 Unit 은 그 자체로 타입 인자로 사용 가능하다.
        • 타입인자란? 
      • 함수혐 프로그래밍에서 Unit 은 단 하나의 인스턴스만 갖는 타입을 의미. 즉 코틀린의 Unit 은 실제 존재하는 타입이라는 것을 표현
    • Nothing
      • 함수가 정상적으로 끝나지 않았다는 사실을 표현하는 역할
      • 무조건 예외를 반환하는 함수 / 무한루프 함수 등...

    4. String Interpolation, String indexing

    fun main() {
        val person = Person("JS", 100)
        val log = "제 이름은 ${Person.name} 이고 나이는 ${Person.age}세 입니다."
    }
    
    
    //큰 따옴표 세 개(""") 를 쓰면 좀 더 편하게 작성 가능
    fun main() {
        val withoutIndent =
            """
                ABC
                123
                456
            """.trimIndent()
        println(withoutIndent)
    }

     

    문자를 가져오고 싶을떄

    //java
    String str = "ABCDE";
    char ch = str.charAt(1);
    
    //kotlin
    val str = "ABCDE"
    val ch = str[1]

    코틀린에서 연산자를 다루는 방법

    1. 단항 연산자 / 산술 연산자

    Java, Kotlin 동일

    • 단항 연산자 : ++ , --
    • 산술 연산자 : +, -, *, /, %
    • 산술대입 연산자

    2. 비교 연산자와 동등성, 동일성

    • 비교 연산자 : >, <, >=, <=
      • Java, Kotlin 사용법은 동일
      •  Kotlin 에서는 Java 와 다르게 자동으로 compareTo 호출
        • 객체에 compareTo 를 Override 해서 생성한 경우 자동으로 생성한 compareTo 호출
    • 동등성, 동일성
      • Java 에서는 == 이 주소가 같은지 === 는 값이 같은지
      • Kotlin 에서는 == 이 값이 같은지(equls) === 은 주소가 같은지

    3. 논리 연산자 / 코틀린에 있는 특이한 연산자

    • 논리 연산자 : &&, ||, !
    • in / !in
      • 컬렌션이나 범위에 포함되어 있다, 포함되어 있지 않다.
    • a..b
      • a 부터 b 까지의 범위 객체를 생성한다
    • a[i]
      • a 에서 특정 Index i 로 값을 가져온다
    • a[i] = b
      • a의 특정 index i 에 b를 넣는다

    4. 연산자 오버로딩

    +,- 등등... 연산자에 오버로딩을 할 수 있다.

     

     

    댓글

Designed by Tistory.