1.자바클래스의 상속은 단일상속이다.

2.상속은(특정 클래스가 가지는 일부 속성과 기능을 다른 클래스에 제공하기위해 맺는 클래스간의 관계이다. )

3.두 클래스를 부모와 자식관계로 맺어주는다.

4.자식은 부모의 요소를 전부 가져온다.(단, 생성자는 제외이다.)

5.조상은 자손에게 영향O , 자손클래스의 변경은 아무런 영향X.

6.상속받지 않은 클래스들은 모두 최상위 클래스 java.lang.Object클래스를 묵시적으로 상속받는다.

자식 클래스의 생성자에서 명시적으로 부모 클래스의 생성자가 호출되지 않으면 자동으로 부모 클래스의 default 생성자가 호출된다.

자식 클래스의 생성자에서 명시적으로 부모 클래스의 생성자를 호출할 수도 있다.

super 키워드를 사용하여 부모 클래스의 생성자를 호출할 수 있는데, 이때 super 키워드는 제일 처음에 호출되어야 한다. 그러지 않으면 'Constructor call must be the first statement in a constructor'라는 오류 문구가 뜬다.

또한 부모 클래스에 디폴트 생성자가 없는 경우도 있는데 그럴 때는 다른 생성자를 반드시 호출해야 한다.

package action.java.test;

class Vehicle {
    int speed;

    //삭제시 에러발생 -> superClass가 시그니처 생성자를 만들경우 더이상 default생성자가지고 있다.
    //따라서 default 클래스를 만들어 자동으로 호출하게 하거나
    //시그니처 생성자를 super()로 호출하게 해야한다.
    public Vehicle() {
        System.out.println("Vehicle()생성");
    }

    public Vehicle(int speed) {
        super();//상속받지 않은 클래스들은 모두 최상위 클래스 java.lang.Object클래스를 묵시적으로 상속기때문에 생략가능
        this.speed = speed;
        System.out.println("Vehicle(int) 생성 : speed = " + speed);
    }

}

class Car extends Vehicle {
    int oil;

    public Car() {
        //호출할 상위클래스의 생성자를 직접 명시할 수 있다.
        super(45);
        System.out.println("Car() 생성");
    }

    public Car(int oil) {
        super();
        this.oil = oil;
        super(); //super 키워드가 처음에 호출되지 않으면 오류 발생
        System.out.println("Car(int) 생성 : oil = " + oil);
    }

    public Car(int oil, int speed) {
        super();
        //상위클래스의 생성자를 호출하지 않으면 상위클래스의 기본 생성자가 호출 된다.
        this.oil = oil;
        System.out.println("Car(int) 생성 : oil = " + oil + " speed = " + speed);
    }

}

public class DefaultConstructor {
    public static void main(String[] args) {
        Vehicle v1 = new Vehicle();
        System.out.println();

        Vehicle v2 = new Vehicle(100);
        System.out.println();

        Car car1 = new Car(100, 60);
        System.out.println();

        Car car2 = new Car();
        System.out.println();

         //정답 유추 해보세요!
        Car car3 = new Car(100, 60);
        System.out.println();

    }

}

Vehicle()생성

Vehicle(int) 생성 : speed = 100

Vehicle()생성 Car(int) 생성 : oil = 100 speed = 60

Vehicle(int) 생성 : speed = 45 Car() 생성

Vehicle()생성 Car(int) 생성 : oil = 100 speed = 60

class HybridCar extends Car {
    int electricity;

    public HybridCar() {
        System.out.println("HybridCar() 생성");
    }

    public HybridCar(int electricity) {
        System.out.println("HybridCar(int) 생성 : electricity = " + electricity);
        this.electricity = electricity;
    }

    public HybridCar(int electricity, int oil) {
        this(electricity); //생성자 위임, 매개변수가 하나인 본인 클래스의 생성자를 호출함
        System.out.println("HybridCar(int, int) 생성 : oil = " + oil);
        this.oil = oil;
    }

}

public class DefaultConstructor {
    public static void main(String[] args) {

        //정답 유추 해보세요!
        HybridCar hybridCar1 = new HybridCar();
        System.out.println();

        //정답 유추 해보세요!
        HybridCar hybridCar2 = new HybridCar(120, 800);
    }

}

Vehicle(int) 생성 : speed = 45 Car() 생성 HybridCar() 생성

Vehicle(int) 생성 : speed = 45 Car() 생성 HybridCar(int) 생성 : electricity = 120 HybridCar(int, int) 생성 : oil = 800

참고

https://jojelly.tistory.com/39

https://mimah.tistory.com/entry/Java-%EC%83%81%EC%86%8D-%EA%B4%80%EA%B3%84%EC%97%90%EC%84%9C-%EC%83%9D%EC%84%B1%EC%9E%90-%ED%98%B8%EC%B6%9C-%EC%88%9C%EC%84%9C

https://stackoverflow.com/questions/48392818/when-do-superclasses-not-have-a-default-constructor

Util.kt

@file:JvmName("MyUtil")
package common // package 선언이 있어야 외부에서 import를 통해 접근가능하다


class TopClass {

}
fun topFunction(){
    print("top_function")
}

const val topValue = "topValue"

Kotlin

package action.kotlin.test

import common.TopClass
import common.topFunction
import common.topValue

fun test() {
    TopClass()
    topFunction() //java와 달리 클래스 명(최상의 함수 정의한 파일 명).메소드로 접근 안해도 됨
    topValue

}

Java

package action.java.test;
import common.MyUtil;
import common.TopClass;

public class TestTop {
    public static void main(String[] args) {
        MyUtil.topFunction();
        System.out.println(MyUtil.topValue);
        TopClass topClass = new TopClass();

    }

}

https://june0122.tistory.com/9 https://kotlinworld.com/69

자바의 @Override 애노테이션과 비슷한 override 변경자는 상위 클래스나 상위 인터페이스 안에 있는 프로퍼티나 메소드를 오버라이드한다는 표시다. 하지만 자바와 달리 코틀린에서는 override 변경자를 꼭 사용해야 한다. override 변경자는 실수로 상위 클래스의 메소드를 오버라이드하는 경우를 방지해준다.

kotlin

internal open class Animal {
    open fun getType(animal: Animal?): String {
        return "animal"
    }
}

internal class Person(private val name: String, private val age: Int) : Animal() {
    fun getType(animal: Animal?): String { // 에러 발생
        return if (animal is Person) {
            "person"
        } else {
            "NA"
        }
    }
}

internal object TestOverride {
    @JvmStatic
    fun main(args: Array<String>) {
        val animal: Animal = Person("lily", 26)
        println(animal.getType(animal))
    }
}

컴파일시 아래와 같은 에러가 발생한다.

Kotlin: 'getType' hides member of supertype 'Animal' and needs 'override' modifier

override 키워드 명시한 후 빌드한 결과

person

*참고 java에서 class 기본 접근제어자는 default이고 kotlin의 internal과 비슷하다.

Java

class Animal {
    public String getType(Animal animal) {
        return "animal";
    }
}

class Person extends Animal {
    private String name;
    private int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //@Override
    public String getType(Animal animal) {
        if (animal instanceof Person) {
            return "person";
        } else {
            return "NA";
        }
    }
}

class TestOverride {
    public static void main(String[] args) {
        Animal animal = new Person("lily", 26);
        System.out.println(animal.getType(animal));
    }
}

person

자바에서 오버라이드 키워드는 일종의 개발자를 위한 명시일뿐 시그니처(매개변수 Type&개수, 반환Type, 함수이름)이 같은 메소드에대해 실제로 오버라이드를 하지만 @Override 애노테이션이 없어도 컴파일 에러를 발생하지 않는다.

참고

코틀린 인 액션 4장

목적

• Executing a lambda on non-null objects: let

• Introducing an expression as a variable in local scope: let

• Object configuration: apply

• Object configuration and computing the result: run

• Running statements where an expression is required: non-extension run

• Additional effects: also

• Grouping function calls on an object: with

코틀린 스코프 함수는 객체의 context내에서 코드를 실행하는 유일한 목적을 갖고 있습니다 람다식을 갖고있는 객체에대해 이런한 함수를 call할 때, 임시적인 스코프로 형성합니다.스코프 안에서 객체를 객체를 표현하는 이름 없이 접근 할 수 있습니다. 이런 함수를 스코프 함수라 부르고 종류는 5개입니다.

let, run, with, apply, also

기본적으로 함수는 같은 역할을 수행합니다. : 객체위에 코드 블락을 실행함

다른 점은 이 객체가 블록 내부에서 어떻게 사용 가능하게 되는지와 전체 표현식의 결과가 무엇인지입니다.

Person("Alice", 20, "Amsterdam").let {
    println(it)
    it.moveTo("London")
    it.incrementAge()
    println(it)
}

Person(name=Alice, age=20, city=Amsterdam) Person(name=Alice, age=21, city=London)

만약 같은 기능을 let없이 사용한다면 새로운 변수를 만들고 사용 할때 마다 그 이름을 반복해야합니다.

val alice = Person("Alice", 20, "Amsterdam")
println(alice)
alice.moveTo("London")
alice.incrementAge()
println(alice)

Person(name=Alice, age=20, city=Amsterdam) Person(name=Alice, age=21, city=London)

스코프 함수의 유사한 특성때문에 이들 사이의 주요 차이점을 아는 것이 중요합니다 주요 차이점은 두가지가 있습니다.

1. context 객체를 참조하는 방법
2. 리턴 값

Context Object: this or it

람다 스코프 함수안에 contex 객체는 그것의 실제 이름을 사용하는 대신에 짧은 참조를 이용될 수 있습니다. 각 스코프 함수는 context object에 접근하는 방법인 두개 중 하나를 사용합니다. this: 람다 수신자 it : 람다 변수

각각 같은 기능을 제공합니다. 이제 각각 상황에 대한 장 단점을 설명하고, 그것들을 추천사용법을 알려드리겠습니다.

fun main() {
    val str = "Hello"
    // this
    str.run {
        println("The string's length: $length")
        //println("The string's length: ${this.length}") // does the same
    }

    // it
    str.let {
        println("The string's length is ${it.length}")
    }
}

The string's length: 5 The string's length is 5

this

run, with 그리고 apply는 context this 키워드로 부터 객체를 lamda 수신자로 참조 합니다. 그러므로 람다안에서 객체는 일반 클래스 함수안에서 사용 할 수 있습니다. 대부분의 경우 수신객체의 멤버에 접근할때 this를 제거할 수 있습니다. 그러나 this는 수신객체와 외부 객체 또는 함수를 구별 하기 어렵습니다. 그래서 context object를 수신객체인 this로 갖는 것은 주로 객체의 멤버를 계산하는 람다식(객체의 함수의 호출, 또는 프로퍼티에 값 할당)에 추천합니다.

val adam = Person("Adam").apply { 
    age = 20                       // same as this.age = 20 or adam.age = 20
    city = "London"
}
println(adam)

Person(name=Adam, age=20, city=London)

    data class Apple(var weight: Int)
        class AppleTree(val appleTree: List<Apple>) {
            fun pick(): Apple {
                return appleTree[0]
            }
        }
//여기서 apply를 사용하는 경우 this는 가려지게 되고 this.weight은 fruteBasket이 아닌 apple을 참조한다.
        class FruitBasket {
            private var weight = 0

            fun addFrom(appleTree: AppleTree) {
                val apple = appleTree.pick().let { it ->
                    this.weight += it.weight
                    add(it)
                }

            }

            fun add(apple: Apple) {

            }
        }

it

결국 let, also는 context 객체를 lamda 변수로 갖습니다. 만약 변수이름이 명시되지 않았다면, 객체는 암시적 기본 이름인 it으로 접근할 수 있습니다. it은 this보다 더 짧고 it을 갖을 표현은 읽기 편합니다. 하지만 객체의 함수나 프로퍼티들을 호출할 때 this처럼 암시적으로 이용할 수 있는 객체가 없습니다. 그러나 context 객체를 it으로 갖는 것은 객체가 함수 호출 안에서 변수로 사용될때 더 좋 습니다. it은 또한 코드 블록의 다양한 변수를 사용할때 더 좋습니다.

fun getRandomInt(): Int {
    return Random.nextInt(100).also {
        writeToLog("getRandomInt() generated value $it")
    }
}

val i = getRandomInt()
println(i)

INFO: getRandomInt() generated value 99 99

추가적으로 context obejct를 변수로 전달할때 스코프 안에서 context object의 custom name을 전달 할 수 있습니다.

fun getRandomInt(): Int {
    return Random.nextInt(100).also { value ->
        writeToLog("getRandomInt() generated value $value")
    }
}

val i = getRandomInt()
println(i)

return value

스코프 함수는 리턴되는 값에 따라 다릅니다

1. apply, also는 context 객체를 리턴
2. let, run, 그리고 with은 lamda의 결과를 리턴

Context Obejct

apply와 also는 자기자신의 context 객체를 리턴합니다. 그러므로 그것은 call chain에 사이드 스텝으로써 포함될 수 있습니다: 함수 호출 후 동일한 개체에 대한 함수 호출을 계속할 수 있습니다.

val numberList = mutableListOf<Double>()
numberList.also { println("Populating the list") }
    .apply {
        add(2.71)
        add(3.14)
        add(1.0)
    }
    .also { println("Sorting the list") }
    .sort()

또한 context 객체를 리턴하는 함수의 문으로 사용될 수 있습니다.

fun getRandomInt(): Int {
    return Random.nextInt(100).also {
        writeToLog("getRandomInt() generated value $it")
    }
}

val i = getRandomInt()

INFO: getRandomInt() generated value 55

Lamda result

let, run, and with은 람다 결과를 반환합니다. 따라서 변수에 결과를 할당하거나 결과에 대한 연산을 연결하는 등의 작업을 수행할 때 사용할 수 있습니다.

val numbers = mutableListOf("one", "two", "three")
val countEndsWithE = numbers.run { 
    add("four")
    add("five")
    count { it.endsWith("e") }
}
println("There are $countEndsWithE elements that end with e.")

There are 3 elements that end with e.

추가적으로 리턴 값을 무시하거나 변수에대한 임시적인 스코프를 갖는 스코프 함수를 사용할때 사용합니다.

val numbers = mutableListOf("one", "two", "three")
with(numbers) {
    val firstItem = first()
    val lastItem = last()        
    println("First item: $firstItem, last item: $lastItem")
}

First item: one, last item: three

Funtion

일반적이 사용 스타일을 정의하는 규칙을 아래 예제에서 확인 가능 합니다

let

호출 체인의 결과에 대해 하나 이상의 함수를 호출할 수 있습니다. 예를 들어, 다음 코드는 컬렉션에 대한 두 가지 작업의 결과를 출력 합니다.

val numbers = mutableListOf("one", "two", "three", "four", "five")
val resultList = numbers.map { it.length }.filter { it > 3 }
println(resultList)

[5, 4, 4]

let 사용 시

val numbers = mutableListOf("one", "two", "three", "four", "five")
numbers.map { it.length }.filter { it > 3 }.let { 
    println(it)
    // and more function calls if needed
} 

[5, 4, 4]

null 검사에도 사용합니다

val str: String? = "Hello"   
//processNonNullString(str)       // compilation error: str can be null
val length = str?.let { 
    println("let() called on $it")        
    processNonNullString(it)      // OK: 'it' is not null inside '?.let { }'
    it.length
}

let() called on Hello

또한 코드 가독성을 높이기 위해서 제한된 범위의 로컬변수로도 사용합니다. 이를 위해서는 it대신 lambda 변수 이름으로 제공해야 합니다.

val numbers = listOf("one", "two", "three", "four")
val modifiedFirstItem = numbers.first().let { firstItem ->
    println("The first item of the list is '$firstItem'")
    if (firstItem.length >= 5) firstItem else "!" + firstItem + "!"
}.uppercase()
println("First item after modifications: '$modifiedFirstItem'")

The first item of the list is 'one' First item after modifications: '!ONE!'

with

비확장 함수 : context 객체는 인수로 전달되지만 lambda 내부에 수신기로 사용할 수있습니다. 반환 값은 lambda 결과 입니다. 람다 결과를 제공하지 않고 컨텍스트 객체의 함수, 프로퍼티를 호출하려면 사용하는 것이 좋습니다. 코드에서는 "이 개체를 사용하여 다음을 수행합니다"로 읽습니다.

val numbers = mutableListOf("one", "two", "three")
with(numbers) {
    println("'with' is called with argument $this")
    println("It contains $size elements")
}

'with' is called with argument [one, two, three] It contains 3 elements

또 다른 사용 사례는 값을 계산하는 데 사용할 프로퍼티 또는 함수를 사용하는 도우미 개체를 도입하는 것입니다.

val numbers = mutableListOf("one", "two", "three")
val firstAndLast = with(numbers) {
    "The first element is ${first()}," +
    " the last element is ${last()}"
}
println(firstAndLast)

The first element is one, the last element is three

run

컨텍스트 객체를 lambda 수신기로 사용할 수 있습니다. 반환 값은 람다 결과입니다. 실행은 let과 동일한 기능을 수행하지만 컨텍스트 개체의 확장 함수로 let을 호출합니다.(추가적인 연산을 진행하고 그값을 반환하는..) run은 람다에 객체 초기화 및 반환값 계산이 모두 포함되어 있는 경우에 유용합니다.

val service = MultiportService("https://example.kotlinlang.org", 80)

val result = service.run {
    port = 8080
    query(prepareRequest() + " to port $port")
}

// the same code written with let() function:
val letResult = service.let {
    it.port = 8080
    it.query(it.prepareRequest() + " to port ${it.port}")
}

Result for query 'Default request to port 8080' Result for query 'Default request to port 8080'

확장자가 아닌 함수로 사용할 수 있습니다. 비확장 실행을 사용하면 식이 필요한 경우 여러 문의 블록을 실행할 수 있습니다.

val hexNumberRegex = run {
    val digits = "0-9"
    val hexDigits = "A-Fa-f"
    val sign = "+-"

    Regex("[$sign]?[$digits$hexDigits]+")
}

for (match in hexNumberRegex.findAll("+123 -FFFF !%*& 88 XYZ")) {
    println(match.value)
}

+123 -FFFF 88

apply

값을 반환하지 않고 주로 수신기 객체의 멤버에서 작동하는 코드 블록에 대해 apply를 사용합니다. 일반적인 경우는 객체 구성입니다. 이러한 호출은 "객체에 다음 할당을 적용"으로 읽을 수 있습니다. 또한 chaing도 적용할 수 있습니다.

val adam = Person("Adam").apply {
    age = 32
    city = "London"        
}
println(adam)

Person(name=Adam, age=32, city=London)

also

객체를 인수로 사용하고 객체를 반환 합니다. 객체의 속성 및 기능 대신 참조 객체의 참조가 필요한 작업이나 외부 범위에서 this에 의해 가려지지 않을려면 사용합니다. 코드에서도 "객체에 대해 다음 작업을 수행할 수도 있습니다."라고 읽을 수 있습니다.

l numbers = mutableListOf("one", "two", "three")
numbers
    .also { println("The list elements before adding new one: $it") }
    .add("four")

The list elements before adding new one: [one, two, three]

참고

https://kotlinlang.org/docs/scope-functions.html#function-selection