[Chap 4] 코틀린 객체지향 프로그래밍

클래스와 생성자

클래스 선언

- class 키워드 사용

- 클래스의 멤버는 생성자, 변수, 함수, 클래스로 구성

- 코틀린의 생성자 : constructor 키워드로 선언

- 클래스 안에 다른 클래스 선언 가능

- 클래스는 객체를 생성해 사용(new 키워드 사용하지 않음)

class User {
	val name = "kkang";
 	constructor(name: String){ this.name = name }
    	fun someFun() { println("name : $name") }
    	class SomeClass {}
}

val user = User("kim");

 

생성자(constructor 키워드)

한 클래스 안에 주 생성자 / 보조 생성자 / 둘 다 선언 가능

 

1. 주 생성자 :  클래스 선언부

- 필수는 아니며 한 클래스에 하나만 가능

- 주로 생성자의 공통된 코드를 작성

- constructor 키워드 생략 가능

- 주 생성자 선언하지 않으면, 컴파일러가 매개변수가 없는 주 생성자를 자동으로 추가

class User constructor() { } // constructor 키워드 사용
class User() { } // constructor 키워드 생략
class User { } // 매개변수가 없는 주 생성자 자동 선언

class User(name: String, count: Int) { }

 

본문 - init 영역

주 생성자는 클래스 선언부에 있기 때문에 실행 영역에 { }를 사용할 수 없다.

init 키워드로 주 생성자의 본문 구현

init으로 지정한 영역은 객체를 생성할 때 자동으로 실행(꼭 선언할 필요는 없음)

 

생성자의 매개변수를 클래스의 멤버 변수로 선언하는 방법

생성자의 매개변수는 기본적으로 생성자에서만 사용할 수 있는 지역 변수

-> 주 생성자에서 매개변수를 var이나 val 키워드로 선언하면 클래스의 멤버 변수가 된다. 

class User(val name: String, val count: Int){
	fun someFun() { println("name: $name, count: $count") }
}

fun main() {
	val user = User("kkang", 10)
    	user.someFun()
}

 

2. 보조 생성자 : 클래스 본문

- 여러 개 추가 가능

class User {
	constructor(name: String) { println("constructor(name: String) call..." )}
    constructor(name: String, count: Int) { printlnt("constructor2") }
}

 

보조 생성자에 주 생성자 연결

클래스를 선언할 때 주 생성자와 보조 생성자를 모두 생성한다면 반드시 생성자끼리 연결 필요

-> 보조 생성자는 객체를 생성할 때 호출되며, 이때 클래스 내에 주 생성자가 있다면 this( ) 구문을 이용해 주 생성자를 호출해야 한다.

// 주석 : 연결 순서
class User(name: String) { // 4번
	constructor(name: String, count: Int): this(name) { ... } // 3번
    constructor(name: String, count: Int, email: String): this(name, count) { ... } // 2번
}

fun main() {
	val user = User("kkang", 10, "a@a.com") // 1번
}

 

클래스를 재사용하는 상속

상속과 생성자

1) 상속 : 클래스를 선언할 때 다른 클래스를 참조해서 선언하는 것

- 선언부에 : 과 함께 상속받을 클래스 이름을 입력

- 코틀린의 클래스는 기본적으로 다른 클래스가 상속할 수 없음. 그러나 open 키워드를 사용하면 상속 가능

open class Super { } 
class Sub: Super() { }

- 상위 클래스를 상속받은 하위 클래스의 생성자에서는 상위 클래스의 생성자를 호출해야 한다.

open class Super(name: String) { }
class Sub(name: String): Super(name) { } // 매개변수가 있는 상위 클래스의 생성자 호출
class Sub: Super {
	constructor(name: String): super(name) // 하위 클래스에 보조 생성자만 있는 경우
}

 

오버라이딩

상위 클래스에 정의된 멤버(변수, 함수)를 같은 이름으로 하위 클래스에서 다시 선언하는 것

- 주로 함수를 재정의할 때 사용(같은 함수명으로 하위 클래스에서 새로운 로직 추가하고 싶을 때)

- open 키워드로 선언된 변수나 함수에 한해서 override 할 수 있음

open class Super { open var someData = 10 }
class Sub: Super() { override var someData = 20 }

 

접근 제한자

클래스의 멤버를 외부의 어느 범위까지 이용하게 할 것인지를 결정하는 키워드

접근 제한자	최상위에서 이용	클래스 멤버에서 이용
public	모든 파일에서 가능	모든 클래스에서 가능
internal	같은 모듈 내에서 가능	같은 모듈 내에서 가능
protected	사용 불가	상속 관계의 하위 클래스에서만 가능
private	파일 내부에서만 이용	클래스 내부에서만 이용

- public : 디폴트 접근 제한자

- internal : 같은 모듈 내에서 접근(모듈 : gradle, maven 같은 빌드 도구에서 프로젝트 단위 또는 같은 세트 단위)

- protected : 클래스의 멤버에서만 선언. 최상위에 선언되는 변수나 함수는 protected로 선언할 수 없음.

- private : 해당 클래스 내부 / 최상위에서 private로 선언하면 해당 파일 내부에서만 접근 가능

 

코틀린의 클래스 종류

데이터 클래스

- data 키워드로 선언, 자주 사용하는 데이터를 객체로 묶어준다

- VO(value object) 클래스를 편리하게 이용할 수 있게 해 준다.

- 주로 주 생성자에 var, val 키워드로 매개변수를 선언해 클래스의 멤버 변수로 활용

 

1) equals() 함수 : 객체의 데이터를 비교

- 일반 클래스의 객체 비교 : 객체 자체를 비교

- 데이터 클래스의 객체 비교 : 객체의 데이터를 비교

- 주 생성자에 선언한 멤버 변수의 데이터만 비교(주 생성자의 멤버 변수가 같은지만 판단)

data class DataClass(val name: String, val email: String, val age: Int) {
	lateinit var address: String
    constructor (name: String, email: String, age: Int, address: String){
    	this(name, email, age)
        this.address = address
    }
} 

fun main() {
	val obj1 = DataClass("kang", "aaa@com", 10, "seoul")
    val obj2 = DataClass("kang", "aaa@com", 10, "busan")
    println("obj1.equals(obj2) : ${obj1.equals(obj2}}") // true - address 고려 X
}

 

2) toString() 함수 : 객체의 데이터를 반환

- 주 생성자의 매개변수에 선언된 데이터만 출력 대상

- 일반 클래스로 생성한 객체의 toString() : 의미 없는 값

- 데이터 클래스로 생성한 객체의 toString() : 객체가 포함하는 멤버 변수의 데이터를 출력

println("data class toString : ${data.toString()}")
// 출력
DataClass(name=kang, email=aaa@com, age=10)

 

오브젝트 클래스

익명 클래스를 만들 목적으로 사용

- 클래스 이름이 없으므로 클래스를 선언하면서 동시에 객체 생성

- 타입 명시하지 않을 경우 코틀린의 최상위 타입인 Any로 취급 -> 보통은 타입까지 함께 입력

var/val 변수 = object {클래스 내용}

open class Super() { open var data = 10 }
val obj = object: Super() { override var data = 20 } // Super 클래스 상속
fun main() { obj.data = 30 }

 

컴패니언 클래스

멤버 변수나 함수를 클래스 이름으로 접근하고자 할 때 사용

- 객체를 생성하지 않고서도 클래스 이름으로 특정 멤버를 이용할 수 있음

class MyClass {
	companion object {
    	var data = 10
        fun some() { println(data) }
    }
}

fun main() {
	val obj = MyClass()
    	obj.data = 20 // 성공
 	MyClass.data = 20 // 성공
    MyClass.some() // 성공
}

 

+ 코틀린은 static 키워드를 지원하지 않기 때문에 컴패니언 클래스는 결과적으로 static 역할을 한다. 

그렇다면 왜 static을 쓰지 않는가? 자바는 모든 것을 클래스 내부에 선언하므로 객체로 묶일 필요가 없는 멤버는 static으로 선언하지만, 코틀린은 최상위에 함수나 변수를 선언할 수 있어서 객체로 이용할 필요가 없는 멤버를 굳이 클래스에 선언하지 않아도 되기 때문. 

-> 클래스에 선언하는 멤버는 대부분 객체로 이용해야 하지만, 클래스에 선언한 멤버를 자바의 static처럼 이용할 때가 있으므로 companion 클래스를 지원하는 것