kotlin → 자바 마이그레이션

자바 코틀린 문법 차이1

클래스, 프로퍼티, 메소드 선언 방식 및 인스턴스 생성 방식
default visibility modifier(기본 접근 제한자)
- 자바: private
- 코틀린: public

상속 및 오버라이딩 가능 여부

자바: 가능, 불가능하게 하려면, final 필요(클래스, 메소드, 프로퍼티는 직접적인 override 없음)

public class Person { }
// Employee는 Person을 상속, Employee는 final이라서 다른 클래스에서 상속 불가
public final class Employee extends Person { }

코틀린: 불가능(가능하게 하려면, open 필요)

open class Person {
// 메소드도 상속가능하게 하려면 open 필요
open fun introduce() {
  println("I am a person.")
}
}
// Employee는 open 키워드가 없어서 다른 클래스에서 상속 불가
class Employee : Person() {
override fun introduce() {
  println("I am an employee.")
}
}

생성자

자바: 생성자 파라미터가 필요하면, 그에 대응되는 생성자를 정의해야함

public class Person {
private String name;
private int age;

// 파라미터가 두 개 있는 생성자를 새로 정의함, 기본 생성자는 없어짐
// new Person()으로 인스턴스 생성 불가, new Person("민수", 30)로만 생성 가능
public Person(String name, int age) {
  this.name = name;
  this.age = age;
}
}

코틀린: 생성자 정의 불필요

// 생성자 정의 불필요
class Person(val name: String, var age: Int) { }

코드 예시

자바

public class Person {
// 프로퍼티
private final String name; // final은 생성자 외에서는 할당 불가, kotlin의 val과 비슷
private int age;
private String location = "Korea";

// 생성자
public Person(String name, int age) {
  this.name = name;
  this.age = age;
}

// 메소드
public void introduceYourself() {
  System.out.println("Hi, I'm " + name + ", I'm " + age + " years old and I live in " + location + ".");
}

// 리턴형 존재하는 메소드
public int getAge() {
  return age;
}

// 파라미터 존재하는 메소드
public void setAge(int age) {
  this.age = age;
}

public void setLocation(String location) {
  this.location = location;
}

// static 메소드, 코틀린의 companion object와 비슷
// Person.main()로 호출 가능, 클래스에 종속된 함수
public static void main(String[] args) {
  Person person = new Person("Alice", 30); // 인스턴스 생성 시 new 키워드 필요
  person.setLocation("New York");
  person.introduceYourself();
}
}

코틀림

class Person(val name: String, var age: Int) {
var location: String = "Korea"

fun introduceYourself() {
    println("Hi, I'm $name, I'm $age years old and I live in $location.")
}

companion object {
    // Person.main()으로 호출 가능, 클레스에 종속된 함수
    fun main(args: Array<String>) {
        val person = Person("Alice", 30)
        person.location = "New York"
        person.introduceYourself()
    }
}
}

자바 코틀린 문법차이2

자바에는 없고 코틀린에만 있는 기능

null sfaty

자바

String name = null; // null 대입 가능
if (name == null) {
  System.out.println("Name is null");
}

코틀린

val name: String = null // String이여서 null 대입 못함, 컴파일 에러
val name: String? = null // Stinrg?여서 null 대입 가능

확장함수

코틀린에는 확장함수 존재

package com.example.extensions // 중요! 패키지+파일 이름을 통해 자바에서 사용할 수 있음, 파일 이름은 ListExtension.kt 

// 가지고 있는 원소들을 제곱하여 합한 수를 리턴하는 함수
fun List<Int>.sumOfSquares(): Int {
  return this.map { it * it }.reduce { acc, element -> acc + element }    // this는 없어도 됨
}

fun main() {
  val numbers = listOf(1, 2, 3, 4, 5)
  println("Sum of squares: ${numbers.sumOfSquares()}") // 55
}

자바에서 코틀린에 정의된 확장함수 사용하는 법

import com.example.extensions.ListExtensionKt; // 패지지+파일 이름으로 import

public static void main(String[] args) {
  List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

  // import한 파일이름으로 접근하여 그 파일에 정의된 확장함수를 사용할 수 있음
  // 인스턴스를 파라미터로 넘겨줘야함
  int sumOfSquares = ListExtensionKt.sumOfSquares(numbers);
  System.out.println("Sum of squares: " + sumOfSquares);
}

default 파라미터, named 파라미터

코틀린

class Greeter {
  // default 파라미터가 있는 함수
  fun greet(name: String = "Guest", greeting: String = "Hello") {
      println("$greeting, $name!")
  }
}

fun main() {
  val greeter = Greeter()
  greeter.greet()  // 출력: Hello, Guest!
  greeter.greet(name = "Alice") // 출력: Hello, Alice!
  greeter.greet(name = "Bob", greeting = "Welcome") // 출력: Welcome, Bob!
}

자바 - default 파라미터 없어서 함수 이름은 같지만, 파라미터가 다른 함수를 여러 개 만들어야 함(함수 오버로딩)

public class Greeter {
  // 파라미터 두 개 있는 함수
  public void greet(String name, String greeting) {
      System.out.println(greeting + ", " + name + "!");
  }

  // 파라미터 한 개 있는 함수
  public void greet(String name) {
      System.out.println("Hello, " + name + "!");
  }

  // 파라미터 없는 함수
  public void greet() {
      System.out.println("Hello, Guest!");
  }

  public static void main(String[] args) {
      Greeter greeter = new Greeter();
      greeter.greet(); // 출력: Hello, Guest!
      greeter.greet("Alice"); // 출력: Hello, Alice!
      greeter.greet("Bob", "Welcome"); // 출력: Welcome, Bob!
  }
}

data class - toString(), equals(), hashCode() 함수 오버라이딩 자동으로 해줌
만약 data class로 안 만들었다면 각각 함수는 아래 같이 리턴됨
- toString(): com.example.movietrailer.data.video.Video@3e1d347
- equals(): 두 인스턴스의 주소를 비교하여 true, false 리턴
- hasCode(): 61711536(메모리 주소 기반으로 생성됨, 인스턴스 생성 시마다 다른 값)
data class로 만들었을 떄
- toString(): Video(id=1034541, title=Terrifier 3, key=0 ...)
- equals(): 두 인스턴스의 프로퍼티 값들 비교
- hasCode(): -95314519(프로퍼티 기반으로 생성됨, 같은 프로퍼티를 가지고 있다면 같은 값)

코틀린

data class Person(val name: String, val age: Int)

자바
```
import java.util.Objects;
```

public class Person { private final String name; private final int age;

// 생성자(constructor)
public Person(String name, int age) {
    this.name = name;
    this.age = age;
}

// 게터(getter)
public String getName() {
    return name;
}

public int getAge() {
    return age;
}

// toString() 함수 오버라이딩 @Override public String toString() { return "Person{name='" + name + "', age=" + age + "}"; }

// equals() 함수 오버라이딩 @Override public boolean equals(Object o) { Person person = (Person) o; return age == person.age && name == person.name; }

// hashCode() 함수 오버라이딩
@Override
public int hashCode() {
    return Objects.hash(name, age);
}

}

lminsu / MovieTrailer

kotlin → 자바 마이그레이션 #22

자바 코틀린 문법 차이1

자바 코틀린 문법차이2