Kotlin 자세히 알아보기 - Inheritance, Abstract, Interface

1. Inheritance (상속)

1-1. open class

Kotlin 클래스는 기본적으로 java의 final 이 붙어있다. 
그래서 상속 가능한 클래스를 만드려면 open 키워드를 붙여야 한다. 
(참고로 final 클래스는 상속받을 수 없음을 의미한다.)

open class Empty(a: Int)
class Sample(a: Int) : Empty(a)

1-2 primary, secondary constructer

java코드의 생성자 오버로딩 호환성을 지닌 kotlin constructor 선언

방법 1>

class CustomConstraintLayout(
	context: Context,
    attrs: AttributeSet?,
    defStyleAttr: Int)
    : ConstraintLayout(contect, attrs, efStyleAttr) {
    
    constructor(contect: Context, attrs: AttributeSet?) : this(contect, attrs, 0)
    
    constructor(context: Context) : this(context, null)
}    
	

방법 2>
default 생성자 정의로 secondary constructor 제거 (코드가 간결해짐)

class CustomConstraintLayout(
	context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0)
: ConstraintLayout(context, attrs, defStyleAttr) {
}

But!! 위에 코드를 자바에서 사용할 시에는 아래와 같은 문제점이 있다. 

CustomConstraintLayout customConstraintLayout = new CustomConstraintLayout(this); // 컴파일 에러

자바에서는 default 생성자의 개념이 없으니, 모든 매개변수를 입력해야 한다. 

해결책
@JvmOverloads annotation을 추가한다. 

class CustomConstraintLayout @JvmOverloads constructor(
	context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0)
: ConstraintLayout(contect, attrs, efStyleAttr) {
}    
	

정리하자면
자바 호환 생성자는 secondary constructor를 사용하는 방법도 있지만,
default생성자와 @JvmOverloads annotation을 사용하여 더 간결한 코드를 만들 수 있다. 

2. Abstract 클래스

abstract class Base(val a: Int) {
	fun printBase() {
    	println("value a : $a")
	}
    
    abstract fun equals(): Boolean
}

class Sample(a: Int, val b: Int) : Base(a) {
	override fun equals() = a == b
}    

 

3. Interface

- java

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의 값을 변경할 수 없음
    }
}    

- java 8

java8에서는 interface에서 method 정의가 가능해졌는데, 바로 default, static을 이용하면 된다. 

public interface Base {
	/*public static final*/ int type = 0;
    default void newDefaultMethod() {
    	System.out.println(type);
    }
    static boolean isTypeZero() {
    	return type == 0;
	}
    void existingMethod();
}

class Sample implements Base {
	
    @override
    public void existingMethod() { }
    
    @override
    public void newDefaultMethod() {
    	// super() 가 존재하지 않는다. 따라서 인터페이스의 함수는 호출되지 않는다.
	}        
}    

- kotlin

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() {
    	super.newDefaultMethod()
        print("Sample")
	}        
}    

위의 kotlin 코드에서 눈여겨 봐야할 부분은 super.newDefaultMethod() 이다.
java의 interface default 메서드와 다르게 kotlin은 super 사용이 가능하다. 

- kotlin interface 변수

interface Base {
	val a: Int
}

class SampleTwo : Base {
	
 	override var a: Int = 0            // 방법 1
   
   	override val a: Int                      // 방법 2
    	get() = 0
}        

class SampleOne(override val a: Int) : Base  // 방법 3

- 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() {
    	super<A>.f() // call to A.f()
        super<B>.f() // call to B.f()
	}
}

 

[참고]
https://thdev.tech/kotlin/2017/03/09/Kotlin-Constructor-Init/