[Kotlin] Class Inheritance

open class 상속

open class Empty

class Sample : Empty()

java View class 상속

/*open*/ class CustomConstraintLayout (

context : Context,

attrs : AttributeSet?,

defstyleAttr : Int)

: ConstraintLayout(context, attrs, defStyleAttr) {

constructor(context : Context, attrs : AttributeSet?) : this (context, attrs, 0)

constructor(context : Context) : this (context, null)

}

- default 값을 추가하여 secondary 생성자를 제거한다.

/*open*/ class CustomConstraintLayout (

context : Context,

attrs : AttributeSet? = null,

defstyleAttr : Int = 0)

: ConstraintLayout(context, attrs, defStyleAttr) {

}

-> kotlin 생성자 사용

CustomConstraintLayout ( this )                                               // context만 보내도 나머지는 디폴트 값으로 지정됨

-> java 생성자 사용

CustomConstraintLayout customConstraintLayout = new CustomConstraintLayout(this);

// context만 보내면 에러 뜸 ( 에러 안뜨기 위해 코틀린 생성자 함수 고쳐줘야됨!!!! )

-> kotlin 생성자

class CustomConstraintLayout @JvmOverloads constructor (

context : Context,

attrs : AttributeSet? = null,

defstyleAttr : Int = 0)

: ConstraintLayout(context, attrs, defStyleAttr) {

}

// java에서 사용해도 더이상 에러 뜨지 않음!!!

// java에서 CustomConstraintLayout 클래스를 상속받으면 secondary 상속자까지 모두 사용할 수 있음!!

// CustomConstraintLayout 클래스 앞에 open 선언해줘야됨!!!

abstract

abstract class Base(val a : Int)

class Sample(a : Int) : Base(a)

abstract class Base (val a : Int) {                        // abstract라서 open 안써줘도 됨!!!

open fun printBase() {                               // open이라고 쓰지 않으면 상속되지 않는다.

println("value a : $a")

}

abstract fun equals() : Boolean                   // abstract라서 open 안써줘도 됨!!!

}

class Sample(a : Int, val b : Int) : Base(a) {

override fun equals() = a == b

}

interface - 변수 추가하기

-> java

interface Base {

int BASE_VALUE = 0;

void printValue();

}

class Sample implements Base {

@Override

public void printValue() {

System.out.println(BASE_VALUE);

}

}

interface Base {

/*public static final - 생략 형태*/ int BASE_VALUE = 0;

void printValue();

}

class Sample implements Base {

@Override

public void printValue() {

BASE_VALUE = 10;                                    // final BASE_VALUE의 값을 변경할 수 없음

System.out.println(BASE_VALUE);

}

}

-> java 8 interface

public interface Base {

/*public static final*/ int type = 0;

default void newDefaultMethod() {                     // default 메소드를 자식 클래스에서 재정의 할 수 있지만 super로 호출못함!!

System.out.println(type);

}

static boolean isTypeZero() {                            // static 메소드 이기 때문에 재정의 불가능

return type == 0;

}

void existingMethod();

}

class Sample implements Base {

@Override

public void newDefaultMethod() { 

}

@Override

public void existingMethod() { 

}

}

-> java 8 사용하려면 build.gradle (Module : app) 에 추가 해줘야됨!!

compileOptions {

sourceCompatibility JavaVersion.VERSION_1_8

targetCompatibility JavaVersion.VERSION_1_8

}

- default : 기본 함수를 구현할 수 있다. 재정의 가능

- static : 기본 함수를 구현하고, static으로 접근할 수 있다. 재정의 불가능

 = Base.isTypeZero();

- 항상 상속받을 수 있는 형태

-> kotlin

interface Base

class Sample : Base

interface Base {

fun printValue ( a : Int )

}

class Sample : Base {

override fun printValue (a : Int) {

println("value a : $a")

}

}

interface Base {

val a : Int                                                        // java와 다르게 초깃값을 가질 수 없다.

fun existingMethod()

fun newDefaultMethod() {

println("value $a")

}

}

class Sample : Base {

override val a : Int

get() = 0

override fun existingMethod() {}

override fun newDefaultMethod() {                         // java와 다르게 슈퍼 클래스의 디폴트 함수를 재정의 하고 호출도 할 수 있다.

super.newDefaultMethod()

print("Sample")

}

}

interface - java 7 vs java 8 vs kotlin

- java

 - final 변수 선언 가능(상속시 값을 변경할 수 없음)

 - java7 : 정의 - java8 : default/static/정의

- kotlin

 - final 정의를 하지 못하고, 반드시 상속에서 구현해야 함

 - 별도의 키워드 없이 default 메서드와 정의 가능

  - open 정의 없이 모두 확장 가능

kotlin interface - 변수

interface Base {

val a : Int

}

class SampleOne(override val a : Int) : Base

class SampleTwo : Base {

override var a : Int = 0

// or

override val type : Int

get() = 0

}

Overriding Rules

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() {                                                   

// 상속받은 A 클래스와 B 인터페이스 에 모두 f 함수가 있기때문에 정의해줘야됨!! java는 안해줘도 됨!!

super<A>.f()                        // call to A.f()

super<B>.f()                        // call to B.f()

}

}

C().f()                                          // AB 출력 - C 클래스의 f()함수 모두 실행