코틀린에서 오버로딩은 자주 사용하지는 않음

파라미터에 default값을 할당 할 수 있음

overloading - 함수이름은 같고, 파라미터를 다르게

overriding - 상위 클래스의 함수를 하위 클래스에서 재정

overloading

• 이름이 같은 함수에 파라미터 개수 또는 타입을 다르게 적용해 함수
  를 사용하는 기법
• return type도 같아야 한다

fun paycheck() = (5000000 * 12).toLong()
fun paycheck(annualSalary: Long, tax: Float) = (annualSalary.div(12) - (annualSalary.div(12)).times(tax)).toLong()
fun paycheck(annualSalary: Long, tax: Float, bonus: Int) = ((annualSalary.div(12) + bonus) - (annualSalary.div(12) + bonus).times(tax)).toLong()
fun main(){
var salary = paycheck()
println("이번달 기본 월급은 ${salary/12} 입니다")
val monthlySalary = paycheck(90_000_000, 0.07f)
println("이번달 월급은 $monthlySalary 입니다")
salary = paycheck(90_000_000, 0.07f,3_000_000)
println("보너스를 포함한 이번 달 월급은 $salary 입니다")
}

defalut 주기

함수 호출 시 인자 값을 전달하지 않고 함수를 호출하면 파라미터에 할
당된 기본 인자 값이 적용

• 파라미터(parameter) => annualSalary:Long, tax:Float 를 의미
• 인자(argument) => 90_000_000, 0.033f 를 의미

함수 호출 시 기본값을 적용하지 않고 다른 값을 할당하여 호출하려면
기본적으로 첫번째 파라미터 부터 명시해야 한다

호출 할 함수의 파라미터 이름을 명시하면 다양하게 호출가능

val decimalFormat = DecimalFormat("###,###,###,###") 
val currency: String? = Currency.getInstance(Locale.getDefault()).symbol
val currentMonth = Calendar.getInstance().get(Calendar.MONTH) + 1
const val MONTHS_OF_YEAR = 12

fun paycheck(annualSalary:Long = 50_000_000,tax:Float = 0.033f):Long{
var salary = annualSalary.div(MONTHS_OF_YEAR)
salary -= (salary.times(tax)).toLong()
return salary
}

fun main(){
var salary = paycheck(36_000_000) - - - -> 두번째 tax는 0.033 적용
println("${currentMonth}월 급여는 $currency${decimalFormat.format(salary)} 입니다")

salary = paycheck() - - - - -> 기본 인자 값 적용
println("${currentMonth}월 급여는 $currency${decimalFormat.format(salary)} 입니다")

salary = paycheck(90_000_000, 0.025f) - - - -> 현재 인자 값 적용
println("${currentMonth}월 급여는 $currency${decimalFormat.format(salary)} 입니다")
//salary = paycheck(0.045f) - - - > error 기본적으로 첫번째 파라미터 부터 적용된다
salary = paycheck(tax = 0.045f) - - - > 함수의 파라미터 변수이름을 이용하며 적용할 수 있다
println("${currentMonth}월 급여는 $currency${decimalFormat.format(salary)} 입니다")
}

overriding

1. 메소드 오버라이딩 (함수)

• 오버라이딩 될 메소드 : open 어노테이션
• 오버라이딩 된 메소드 : override 어노테이션

open class A(x:Int) {
	open fun test() {}
}
class B(x:Int) : A(x) {
	override fun test() {}
}

fun main(){
    var t = Tiger()
    t.intro()
}
open class animal(){
    open fun intro(){ //수퍼클래스에서 open이 붙은 함수는 서브클래스 오버라이드 해서 제구현가능
        println("저는 입니다")
    }
}
class Tiger : animal(){
    override fun intro() {      //오버라이딩
        println("오버라이드 됐지롱")
    }
}

1. 프로퍼티 오버라이딩

• 메소드 오버라이딩과 유사한 방식

open class A(x:Int) {
	open val x:Int  ...
}
class B(x:Int) : A(x) {
	override val x: Int ...
}

1. 오버라이딩 규칙

• 같은 멤버에 대한 중복된 구현을 상속받은 경우, 상속받은 클래스는 해당 멤버를 오버라이딩하고 자체 구현을 제공해야함
  • 위에 말이 어려운데, 이름이 같은 함수를 상속받으면 특정한 표기법으로 구분한다는 뜻임. 그 표기법은 밑에 있음
• super + <클래스명>을 통해서 상위 클래스를 호출 할 수 있음

fun main(){
    val a = C()
    a.f()
}

open class A{
    open fun f() {println("af")}
    fun a() {println("a")}
}
interface B {
    fun f() {
        println("bf")
    }

    fun b() {
        println("b")
    }
}

class C : A(), B {
    override fun f() {
            super<A>.f()
            super<B>.f()
    }
}
//af
//bf