Class
class Animal(val name:String)
class Person(val firstName: String, tmpLastName:String){
var lastName:String = tmpLastName
get () = field.uppercase()
set (value){
field = "[$value]"
}
}
fun main(){
val a = Animal("Dog")
println("Animal: ${a.name}")
val p = Person("Sukung","Kim")
// getter 호출됨
println("Name: ${p.firstName} ${p.lastName}")
// setter 호출됨 []이 붙여짐
p.lastName = "KIM"
println("Name: ${p.firstName} ${p.lastName}")
}
- 단순한 클래스 정의
- class 클래스_이름(생성자 인자 리스트)
- 생성자 인자들 중 val/var이 붙은 것은 클래스의 속성이 됨
- 자바와 다른점
- 코틀린은 기본적으로 public class임
- 객체를 생성할 때 new 키워드를 쓰지 않음
- 속성 접근 메소드를 자동으로 만들어주며, 커스텀 접근 메소드를 만들 수도 있음
Interface
interface ClickListener{
fun onClick()
fun onTouch() = println("touched")
}
class View(private val id:Int):ClickListener{
override fun onClick() {
println("clicked $id")
}
}
fun main(){
val v = View(10)
v.onClick()
v.onTouch()
}
- 자바의 인터페이스와 비슷함
- 구현이 있는 메소드 정의가 가능 하지만 자바처럼 default를 붙이진 않음
- 인터페이스 구현 클래스의 메소드 구현에서 override를 반드시 적어주어야 함
- 클래스 상속 받을 때 메소드 오버라이드 할 때에도 override를 반드시 명시해 주어야 함
기본적으로 상속, 오버라이드 금지
class NoInherit(val name:String)
// 컴파일 에러
//class Child2(val name:String):NoInherit(name)
open class Inherit(val name:String){
fun first() = println("first")
open fun second() = println("second")
}
open class child(name:String):Inherit(name){
final override fun second() {
println("override second")
}
open fun third() = println("third")
}
class GrandChild:child(""){
override fun third() {
println("override third")
}
}
- open 이라는 키워드가 붙어야 가능
- 단 interface, abstract class는 기본적으로 open 키워드가 디폴트로 들어가 있음
- class 는 기본적으로 상속, 메소드 오버라이드 금지
- 메소드 오버라이드 접근 변경
- final: 오버라이드 금지 기본적인 디폴트 설정임
- open: 오버라이드 가능
- abstract: 반드시 오버라이드 해야 함
- override: 오버라이드 한 것을 명시
기본적으로 공개(public)
- 코틀린은 클래스와 메소드 모두 기본적으로 public
- 접근 변경자
- public: 디폴트 옵션 자유롭게 접근 가능
- internal: 같은 모듈에서만 접근 가능
- protected: 상속 받은 클래스에서만 접근 가능
- private: 같은 클래스 에서만 접근 가능
중첩 클래스
class Outer(var m:Int=0){
// inner 키워드를 통해 내부 클래스 선언
inner class Inner{
fun doSomething(){
this@Outer.m++
println("Inner.doSomething ${this@Outer.m}")
}
}
// Outer 클래스의 속성에 접근이 불가능
// 기본적으로 정적(static) 중첩 클래스로 만들어짐
class NoInner{
fun doSomething(){
println("NoInner.doSomething")
}
}
}
fun main(){
// Outer클래스를 만들고 나서야 Inner 클래스를 만들 수 있음
// 대신 Outer 클래스의 속성에 접근이 가능함
val inner = Outer().Inner()
inner.doSomething()
// Outer클래스를 만들지 않고 바로 NoInner 클래스를 만들 수 있음
val noInner = Outer.NoInner()
noInner.doSomething()
}
- 코틀린에서 중첩 클래스는 자바에서 static 중첩 클래스와 같음
- 자바처럼 내부 클래스를 만들려면 중첩 클래스 앞에 inner 키워드 사용
봉인(sealed) 클래스
sealed class Expr{
class Num(val value:Int): Expr()
class Sum(val left: Expr, val right: Expr): Expr()
}
fun eval(e: Expr): Int =
when(e){
is Expr.Num -> e.value
is Expr.Sum -> eval(e.right)+eval(e.left)
}
fun main(){
val r = eval(Expr.Sum(Expr.Num(10),Expr.Num(10)))
println(r)
}
- 특정 클래스를 상속하는 클래스를 제한할 수 있다.
Constructor 생성자
class ConstEx1 constructor(tmp:Int){
val prop: Int
val prop2: Int
init {
prop = tmp
prop2= tmp
}
}
class ConstEx2 constructor(tmp:Int){
val prop = tmp
}
class ConstEx3 constructor(val prop:Int)
open class ConstEx4(val prop:Int,val prop2:Int=0){
constructor(_prop:Int,_prop2:Int,_prop3:Int): this(_prop+_prop3+_prop2){
}
}
class ConstEx5(_prop:Int) : ConstEx4(_prop)
fun main(){
ConstEx1(1)
ConstEx2(2)
ConstEx3(3)
ConstEx4(4)
ConstEx4(4,4)
ConstEx4(4,4,4)
ConstEx5(5)
}
- Primary constructor: 클래스 이름 옆에 정의하는 생성자
- Secondary constructor: 클래스 내부에 정의 하는 생성자
Property와 getter/setter
interface GetSetI{
var prop: String
}
class GetSet(tmp:String):GetSetI{
override var prop: String = tmp
set(value) {
field = value.substringBefore('@')
}
get() = field.uppercase()
var prop2:Int =0
private set
}
fun main(){
val getset = GetSet("test@removed")
println("getset.prop = ${getset.prop}")
getset.prop = "ok@remeved"
println("getset.prop = ${getset.prop}")
// 컴파일 오류 getset.prop2 = 10
}
- Property의 커스텀 setter와 getter를 정의할 수 있다.
- public 속성에 대해 setter를 private으로 하면 클래스 밖에서는 get만 가능함
- Interface에 property를 정의할 수 있으나, 이 property는 구현 클래스에서 반드시 오버라이드 해야 한다.
Data Class
data class MyClass(val a:Int,val b:String)
fun main(){
val str1 = "Hello, kotil"
val str2 = "Hello, kotil"
val class1 = MyClass(10,"class1")
val class2 = MyClass(10,"class1")
val class3 = MyClass(20,"class2")
println(str1 == str2)
println(class1==class2)
println(class1==class3)
println(class1==class2)
}
- class 정의 앞에 data 키워드 추가
- data class 는 equals/ hashCode/ toString / copy를 자동으로 만들어준다.
object 키워드
interface ClickListner{
fun onClick()
}
object ClickListenerImp : ClickListner{
override fun onClick() {
println("clicked")
}
}
fun setClickListner(listner: ClickListner) = listner.onClick()
class Touch(){
val objectNums : Int
get() = num
init{
num++
}
// Touch 클래스가 아무리 많이 만들어져도 해당 클래스는 한 개만 존재 싱글톤
companion object{
var num:Int = 0
}
}
fun main(){
setClickListner(ClickListenerImp)
setClickListner(object :ClickListner{
override fun onClick() {
println("click2")
}
})
Touch()
Touch()
println(Touch().objectNums)
}
- 클래스 정의 없이 바로 객체를 생성하는 방법
- 싱글톤을 만들거나
- companion object를 만들거나
- anonymous object를 만들때 사용 (한 번만 사용하는 객체를 만들경우)
- Companion object는 이 객체를 포함하는 클래스의 private 맴버에 접근 가능
Extension Method/Property
val String.lastChar:Char
get() = get(length-1)
fun main(){
println("Hello".lastChar)
}
fun<T> Collection<T>.join(separator:String = " "):String
{
val result = StringBuilder()
// this.withIndex (해당 컬렉션의 맴버)
for((index,element)in withIndex()){
if(index>0) result.append(separator)
result.append(element)
}
return result.toString()
}
fun main()
{
println(listOf("1","2","3").join())
println(arrayListOf(1,2,3).join(","))
}
- 이미 말들어진 클래스의 메소드와 속성을 클래스를 상속하거나 수정하지 않고도 추가 할 수 있음
- 이렇게 추가도니 메소드는 오버라이드 안됨
- 자바의 기존 Collection들에 다양한 유틸 함수들을 이 방법으로 추가
- String의 새로운 유틸 함수: substringBefore, substringAfter 등
연산자 오버로딩
data class Complex(val real:Double,val img:Double){
operator fun plus(other:Complex):Complex
= Complex(real + other.real,img+other.img)
override fun toString(): String = "$real+${img}i"
}
operator fun Complex.minus(other: Complex):Complex
= Complex(real-other.real,img-other.img)
fun main(){
val c1 = Complex(1.0,1.0)
val c2 = Complex(2.0,2.0)
val c3 = c1 + c2
println(c3)
println(c3==Complex(3.0,3.0))
}
- 이항 산술 연산자 +,-,*,/,% 오버로딩 가능
- 오버로딩할 때 연산자 이름 plus, minus, times, div, rem
- 단항연산자
- unaryPlus, unaryMinus, not, inc, dec
- 비교 연산자
위임(Delegation)
interface Base{
fun print()
fun printHello()
}
class BaseImpl(val x :Int):Base{
override fun print(){print(x)}
override fun printHello() {
println("Hello")
}
}
class Derived(val b:Base):Base by b{
override fun print() {
b.print()
println("ok")
}
}
fun main(){
val b = BaseImpl(10)
val d = Derived(b)
d.print()
d.printHello()
}
- 상속과 유사하지만 다른 개념
- 상속은 강한 결합, 위임은 약한 결합
- 상속 북가여도 위임은 가능
- 위임(상속)할 클래스와 동일한 인터페이스를 구현해야 함
- 위임 패턴은 위임(상속)할 객체를 맴버로 만들고 특정 메소드 호출시 위임 객체의 메소드로 포워드(호출)하는 방식으로 만듦
- 위임 객체의 메소드 각각에 대해 메소드를 새로 만들어서 포워드 해야 함
- 코틀린은 by 키워드로 위임을 쉽게 지원함
위임 속성(Delegated Property)
class User(val map:MutableMap<String, Any?>){
val lazyValue: String by lazy{
// 처음 실행시 출력됨
println("computed!")
"hello"
}
var name:String by map
var age: Int by map
var nameOb: String by Delegates.observable("<no name>"){
prop,old,new ->
println("$old -> $new")
}
}
fun main(){
val user = User(mutableMapOf(
"name" to "SuKung",
"age" to 25
))
println(user.lazyValue)
println(user.lazyValue)
println(user.name)
println(user.age)
user.age = 30
println(user.map)
user.nameOb = "fisrt"
user.nameOb = "second"
}
class MyClass{
var newName: Int = 0
@Deprecated("Use 'newNaem' instead",ReplaceWith("newName"))
var oldName: Int by this::newName
}
- by 키워드를 써서 속성의 get/set을 위임 객체의 getValue/setValue로 위임함
- 이를 이용하여 특별한 성질을 갖는 속성을 만듦
- Lazy 특성: 값을 처음 접근할 때 생성/계산함
- Observable 특성: 값이 변경될 때 알려주는 리스너를 지정
- Map을 이용하여 객체 속성 값을 저장
- 다른 속성으로 위임할 수도 있음
Generic
fun <T:Number> myPlus(op1:T,op2:T):String = "$op1$op2"
class MyGeneric<T:Number>(private val prop:T){
fun test(arg:T):String{
println(arg)
return myPlus(prop,arg)
}
}
fun main(){
println(myPlus(1,1))
println(myPlus(1.0,1.0))
println(MyGeneric(10).test(10))
}
