[Kotlin] Class

* 기본 클래스

 
class ClassName { 
 
}
 

* 생성자

   - constructor로 생성자 만듬(생략가능)

 
// Java 생성자
class ClassName { 
    public ClassName(String name) { 
 
    }
}
 
// Kotlin 생성자
class ClassName constructor(name: String) {
 
}
// Kotlin 생성자 변형
class ClassName(name: String) {
 
}
 

 
// Java 생성자 초기화
class ClassName {
 
  private int[] age;
 
  public ClassName() {
    age = new int[10];
  }
}
 
// Kotlin 생성자 초기화
class ClassName(name: String) {
  init {
    println("Initialized with value ${name}")
  }
}
// Kotlin 생성자 초기화 변형
class ClassName(name: String) {
  val upperName = name.toUpperCase()
}
 
// Java 다중 생성자 정의
class Person {
  public Person(String name) {
    // name 정의
  }
  public Person(String name, int age) {
    this(name);
    // age 정의
  }
}
 
// Kotlin 다중 생성자 정의
class Person(val name: String) {
  constructor(name: String, age: Int) : this(name) {
    // ...
  }
}
 

* 클래스 사용

 
// Java 클래스 선언
ClassName className = new ClassName();
 
// Kotlin 클래스 선언
val className = ClassName()
 

* 상속(extends, implements)

 
// Java 상속
public abstract class Base {
  public Base(int age) {
 
  }
}
 
public class UseBase extends Base {
  public UseBase(int age) {
    super(age);
  }
}
 
// Kotlin 상속(open으로 생성한 추상 클래스를 다음과 같이 사용)
open class Base(age: Int)
 
class UseBase(age: Int) : Base(age)
 
// Kotlin View 상속
class MyView : View {
    constructor(ctx: Context) : super(ctx) {
      // 정의
    }
 
    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs) {
      // 정의
    }
}
 

* 함수 Overriding

 
// Java 함수 overriding
abstract class AbstractBase {
  abstract void onCreate();
  final void onResume() {} // 상속에서 재 구현 금지
}
 
interface Base {
  void onStart();
}
 
public Use extends AbstractBase implements Base {
 
  // Abstract 상속에 대한 구현
  @Override
  void onCreate() {}
 
  // interface에 대한 구현
  @Override
  void onStart() {}
}
 
 
 
// Kotlin 함수 overriding(open으로 생성한 추상 클래스를 다음과 같이 사용)
interface BaseItem {
    fun onStart()
}
 
open class Base {
    open fun v() {}
    fun nv() {}
}
 
class AbstractBase() : Base(), BaseItem {
    // Base의 open 키워드를 통해 상속을 구현
    override fun v() {}
    // Interface에서 구현한 상속
    override fun onStart() {}
}
 

* Open

  - 상속의 재정의(overriding)를 허용하기 위해 사용됨

 
// Kotlin Code
open class Base {
    open fun v() { //함수 재정의하여 사용가능
        print("ABC")
    }
    fun nv() {}     //함수 재정의하여 사용불가
}
 
// 변수도 open 사용가능
open class Foo {
  open val x: Int get { ... } 
}
 
class Bar(override val x: Int) : Foo() { 
 
}
 

* 다중상속

 
// Kotlin Code
open class A {
  open fun f() { print("A") }
  fun a() { print("a") }
}
 
interface B {
  fun f() { print("B") } // interface members are 'open' by default
  fun b() { print("b") }
}
 
class C() : A(), B {
  // The compiler requires f() to be overridden:
  override fun f() {
    super<A>.f() // call to A.f()
    super<B>.f() // call to B.f()
  }
}
 

* 추상클래스(abstract)

 
// Java Code
public abstract class Base {
 
  public Base(String name) {
    updateName(name);
  }
 
  protected abstract void updateName(String name);
}
 
// Base를 상속 받는 클래스
public class UseName extends Base {
  public UseName(String name) {
    super(name);
  }
 
  @Override
  protected void updateName(String name) {
    // 정의
  }
}
 
// Kotlin Code
abstract class BaseUse(name: String) {
 
    init {
        updateName(name)
    }
 
    protected abstract fun updateName(name: String)
}
 
 
// Base를 상속 받는 클래스
class UseName(name: String) : BaseUse(name) {
 
    override fun updateName(name: String) {
        // 정의
    }
}
 

* static

 
// Java Code
public class ClassName {
 
  // getInstance() 구현을 위하여 private
  private ClassName() {
 
  }
 
  public static ClassName getInstance() {
    return new ClassName();
  }
}
 
// Use...
ClassName className = ClassName.getInstance();
 
// Kotlin Code
// 생성자 private 처리
class ClassName private constructor() {
 
  // 외부에서 static 형태로 접근 가능
  companion object {
    fun getInstance() = ClassName()
  }
}
 
// Use kotlin
val className = ClassName().getInstance()
 

* 열거형

 
// Kotlin Code
fun main(args: Array<String>) {
    print(eval(Expr.Sum(Expr.Const(12.44), Expr.Const(12.33))))
}
 
sealed class Expr {
    class Const(val number: Double) : Expr()
    class Sum(val e1: Expr, val e2: Expr) : Expr()
    object NotANumber : Expr()
}
 
fun eval(expr: Expr): Double = when(expr) {
    is Expr.Const -> expr.number
    is Expr.Sum -> eval(expr.e1) + eval(expr.e2)
    Expr.NotANumber -> Double.NaN
    // the `else` clause is not required because we've covered all the cases
}