출처: https://www.boostcourse.org/mo234/lecture/154292?isDesc=false
데이터 클래스와 기타 클래스
data class
데이터 전달을 위한 객체를 DTO (Data Transfer Object)라고 부른다. 자바에서는 POJO (Plain Old Java Object)라고 부르기도 한다.
- 구현 로직 없이 순수한 데이터 객체 표현
- 데이터에 접근하는 게터, 세터 포함
- toString(), equals() 등과 같은 데이터 표현 및 비교 메서드 포함
자바로 DTO를 표현하면, 데이터 필드와 게터/세터, 데이터 표현 및 비교 메서드를 모두 작성해줘야 한다. 하지만, 코틀린으로 DTO를 표현하면 프로퍼티만 신경써서 작성하면 되고, 나머지는 내부적으로 자동 생성해주기 때문에 매우 편리하다!
cf) 데이터 클래스에도 간단한 로직을 포함하고 싶으면, 부 생성자나 init 블록을 사용하면 된다.
data class Customer(var name: String, var email: String) {
var job: String = "Unknown"
constructor(name: String, email: String, _job: String): this(name, email) {
job = _job
}
init {
// 간단한 로직은 여기에
}
}데이터 클래스의 조건
- 주 생성자는 최소한 하나의 매개변수를 가져야 한다.
- 주 생성자의 모든 매개변수는 val, var로 지정된 프로퍼티여야 한다.
- 데이터 클래스는 abstract, open, sealed, inner 키워드를 사용할 수 없다.
데이터 클래스에서 자동 생성되는 메서드들
package chap03.section3
data class Customer(var name: String, var email: String)
fun main() {
val cus1 = Customer("Sean", "sean@mail.com")
val cus2 = Customer("Sean", "sean@mail.com")
println(cus1 == cus2) // true (값을 비교)
println(cus1 === cus2) // false (참조 주소를 비교)
println(cus1.equals(cus2)) // true (값을 비교)
println("${cus1.hashCode()}, ${cus2.hashCode()}") // equal
val cus3 = cus1.copy(name = "Alice")
println(cus1.toString())
println(cus3.toString())
} true
false
true
-1521025108, -1521025108
Customer(name=Sean, email=sean@mail.com)
Customer(name=Alice, email=sean@mail.com)
destructuring (분해)
데이터 클래스의 객체가 갖고 있는 프로퍼티를 개별 변수들로 분해하는 것
val (name, email) = cus1
println("name = $name, email = $email")
// 특정 프로퍼티를 가져올 필요가 없을 때
//val (_, email) = cus1 val name2 = cus1.component1()
val email2 = cus1.component2()
println("name = $name2, email = $email2")
val cus1 = Customer("Sean", "sean@mail.com")
val cus2 = Customer("Sean", "sean@mail.com")
val bob = Customer("Bob", "bob@mail.com")
val erica = Customer("Erica", "erica@mail.com")
val customers = listOf(cus1, cus2, bob, erica)
for((name, email) in customers){
println("name = $name, email = $email")
}data class Customer(var name: String, var email: String)
fun myFunc(): Customer {
return Customer("Mickey", "mic@mail.com")
}
fun main() {
// 함수로부터 객체가 반환되는 경우
val (myName, myEmail) = myFunc()
println("$myName $myEmail")
// 람다식에서 사용하는 경우
val myLambda = {
// destructuring
(nameLa, emailLa): Customer ->
println(nameLa)
println(emailLa)
}
val cus1 = Customer("Sean", "sean@mail.com")
myLambda(cus1) // 인자로 객체를 전달
}inner class, nested class
자바의 내부 클래스 종류
| 종류 | 역할 |
|---|---|
| 정적 클래스 (static class) | static 키워드를 가지며, 외부 클래스를 인스턴스화 하지 않고 바로 사용 가능한 클래스 (주로 빌더 클래스에 이용) |
| 멤버 클래스 (member class) | 인스턴스 클래스로도 불리며 외부 클래스의 필드나 메서드와 연동하는 내부 클래스 |
| 지역 클래스 (local class) | 초기화 블록이나 메서드 내의 블록에서만 유효한 클래스 |
| 익명 클래스 (anonymous class) | 이름이 없고, 주로 일회용 객체를 인스턴스화 하면서 오버라이드 메서드를 구현하는 내부 클래스. 가독성이 떨어지는 단점이 있다. |
자바와 코틀린의 내부 클래스 비교
| 자바 | 코틀린 |
|---|---|
| 정적 클래스 | 중첩 클래스: 객체 생성 없이 사용 가능 |
| 멤버 클래스 | 이너 클래스: 필드나 메서드와 연동하는 내부 클래스로 inner 키워드가 필요하다. |
| 지역 클래스 | 지역 클래스: 클래스의 선언이 블록 내에 있다면 지역 클래스이다. |
| 익명 클래스 | 익명 객체: 이름이 없고, 주로 일회용 객체를 사용하기 위해 object 키워드로 선언된다. |
nested class
코틀린에서 중첩 클래스는 기본적으로 static 클래스처럼 다뤄진다.
package chap03.section3
class Outer {
val ov = 5
// Nested -> Outer (X)
class Nested {
val nv = 10
fun greeting() = "[Nested] Hello! $nv" // 외부의 ov는 접근 불가
}
// Outer -> Nested (O)
fun outside(){
// 중첩 클래스의 메서드 및 프로퍼티 접근
val msg = Nested().greeting()
println("[Outer] $msg, ${Nested().nv}")
}
}
fun main() {
// static처럼 Outer 객체 생성 없이, Nested 객체 생성하여 사용 가능함.
val output = Outer.Nested().greeting()
println(output)
val outer = Outer()
outer.outside()
//Outer.outside() // error
}중첩 클래스에서 외부 클래스에 접근하는 방법
class Outer {
val ov = 5
// Nested -> Outer (X)
class Nested {
val nv = 10
fun greeting() = "[Nested] Hello! $nv" // 외부의 ov는 접근 불가
fun accessOuter(){ // 컴페니언 객체에 접근 가능
println(country)
getSomething()
}
}
// Outer -> Nested (O)
fun outside(){
// 중첩 클래스의 메서드 및 프로퍼티 접근
val msg = Nested().greeting()
println("[Outer] $msg, ${Nested().nv}")
}
companion object { // 컴페니언 객체는 static처럼 접근 가능
const val country = "Korea"
fun getSomething() = println("Get something...")
}
}inner class
inner 키워드로 선언된 이너 클래스는 바깥 클래스의 멤버에 접근 가능하다. (private 멤버 포함)
package chap03.section3
class Smartphone(val model: String){
private val cpu = "Exynos"
inner class ExternalStorage(val size: Int){
// 외부 클래스의 프로퍼티에 접근
fun getInfo() = "${model}: Installed on $cpu with ${size}GB"
}
}
fun main() {
// 이너 클래스의 객체 생성
val mySdcard = Smartphone("S7").ExternalStorage(32)
println(mySdcard.getInfo())
}local class
- 특정 메서드의 블록이나 init 블록과 같이 블록 범위에서만 유효한 클래스
- 블록 범위를 벗어나면 더 이상 사용되지 않음.
package chap03.section3
class Smartphone(val model: String){
private val cpu = "Exynos"
// 이너 클래스
inner class ExternalStorage(val size: Int){
// 외부 클래스의 프로퍼티 접근 가능
fun getInfo() = "${model}: Installed on $cpu with ${size}GB"
}
fun powerOn(): String {
// 지역 클래스
class LED(val color: String){
// 외부 클래스의 프로퍼티 접근 가능
fun blink(): String = "Blinking $color on $model"
}
val powerStatus = LED("Red")
return powerStatus.blink()
}
}
fun main() {
// 이너 클래스의 객체 생성
val mySdcard = Smartphone("S7").ExternalStorage(32)
println(mySdcard.getInfo())
val myPhone = Smartphone("Note9")
println(myPhone.powerOn()) // 지역 클래스의 사용
}익명 객체
- 자바에서는 익명 내부 클래스로 일회성 객체를 생성하여 사용한다.
- 코틀린에서는 object 키워드로 같은 기능을 수행할 수 있다.
package chap03.section3
interface Switcher {
fun on(): String
}
class Smartphone(val model: String){
private val cpu = "Exynos"
// 이너 클래스
inner class ExternalStorage(val size: Int){
// 외부 클래스의 프로퍼티 접근 가능
fun getInfo() = "${model}: Installed on $cpu with ${size}GB"
}
fun powerOn(): String {
// 지역 클래스
class LED(val color: String){
// 외부 클래스의 프로퍼티 접근 가능
fun blink(): String = "Blinking $color on $model"
}
val powerStatus = LED("Red")
// 익명 객체 생성하여 인터페이스의 추상 메서드 구현
// 하위 클래스를 따로 만들 필요 없음.
val powerSwitch = object: Switcher {
override fun on(): String {
return powerStatus.blink()
}
}
return powerSwitch.on()
}
}
fun main() {
// 이너 클래스의 객체 생성
val mySdcard = Smartphone("S7").ExternalStorage(32)
println(mySdcard.getInfo())
// 지역 클래스와 익명 객체의 사용
val myPhone = Smartphone("Note9")
println(myPhone.powerOn())
}sealed class, enum class
sealed class
- Sealed는 '봉인된'이라는 뜻으로 무언가 안전하게 보관하기 위해서 묶어두는 것
- 실드 클래스 자체로는 추상 클래스와 같기 때문에 객체를 생성할 수는 없다.
- 생성자도 기본적으로 private이며, private이 아닌 생성자는 허용하지 않는다.
- 실드 클래스는 같은 파일 안에서는 상속이 가능하다. (다른 파일에서는 상속 불가)
- 블록 안에 선언된 클래스는 상속이 필요한 경우 open 키워드로 선언해야 한다.
package chap03.section3
// 상태를 정의하고 관리하는 데 사용되는 실드 클래스
sealed class Result{
open class Success(val message: String): Result()
class Error(val code: Int, val message: String): Result()
}
class Status: Result() // 실드 클래스의 상속은 같은 파일 내에서만 가능
class Inside: Result.Success("status") // open 되어있는 내부 클래스 상속
// 상태를 검사하기 위한 함수
fun eval(result: Result): String = when(result){
is Status -> "in progress"
is Result.Success -> result.message
is Result.Error -> result.message
// Result 클래스의 모든 상태를 처리하므로 else 필요 없음. (실드 클래스의 장점)
}
fun main() {
val result = Result.Success("good")
println(eval(result))
val result2 = Result.Error(10, "No disk")
println(eval(result2))
}enum class
열거형 클래스는
- 여러 개의 상수를 선언하고 열거된 값을 조건에 따라 선택할 수 있는 특수한 클래스
- 자료형이 동일한 상수를 나열할 수 있다. (실드 클래스처럼 다양한 자료형을 다루지 못한다.)
// 각 상수는 Direction 클래스의 객체로 취급됨.
enum class Direction {
NORTH, SOUTH, WEST, EAST
}
enum class DayOfWeek(val num: Int) {
MONDAY(1), TUESDAY(2), WEDNESDAY(3), THURSDAY(4),
FRIDAY(5), SATURDAY(6), SUNDAY(7)
}
val day = DayOfWeek.SATURDAY
when(day.num) {
1, 2, 3, 4, 5 -> println("Weekday")
6, 7 -> println("Weekend")
}package chap03.section3
enum class Color(val r: Int, val g: Int, val b: Int){
RED(255, 0, 0), ORANGE(255, 165, 0),
YELLOW(255, 255, 0), GREEN(0, 255, 0),
BLUE(0, 0, 255), INDIGO(75, 0, 130),
VIOLET(238, 130, 238); // 세미콜론 필수
fun rgb() = (r * 256 + g) * 256 + b // 메서드 포함
}
fun main() {
println(Color.BLUE.rgb())
}package chap03.section3
interface Score {
fun getScore(): Int
}
// 인터페이스를 구현하는 열거형 클래스
enum class MemberType(var prio: String): Score {
NORMAL("Third"){
override fun getScore(): Int = 100
},
SILVER("Second"){
override fun getScore(): Int = 500
},
GOLD("First"){
override fun getScore(): Int = 1500
}
}
fun main() {
println(MemberType.NORMAL.getScore())
println(MemberType.GOLD)
println(MemberType.valueOf("SILVER"))
println(MemberType.SILVER.prio)
for(grade in MemberType.values()){
println("name = ${grade.name}, priority = ${grade.prio}")
}
}어노테이션 클래스
어노테이션 (annotation) 이란?
- 코드에 부가 정보를 추가하는 표기법
- @ 기호와 함께 사용하며 주로 컴파일러나 프로그램 실행 시간에 사전 처리를 하기 위해 사용함.
- @Test (유닛 테스트 코드 작성)
- @JvmStatic (자바 코드에서 컴페니언 객체에 접근)
어노테이션의 속성
- @Target: 어노테이션이 지정되어 사용할 종류 (클래스, 함수, 프로퍼티 등)을 정의
- @Retention: 어노테이션을 컴파일 된 클래스 파일에 저장할 것인지 실행 시간에 반영할 것인지 결정
- @Repeatable: 어노테이션을 같은 요소에 여러 번 사용 가능하게 할지 결정
- @MustBeDocumented: 어노테이션이 API의 일부분으로 문서화 하기 위해 사용
연산자 오버로딩
- 연산자에 여러가지 다른 의미의 작동을 부여
- 코틀린에서는 특정 연산자의 역할을 함수로 정의
- operator 키워드를 사용해 정의
연산자의 작동 방식
예시
package chap03.section4
class Point(var x: Int = 0, var y: Int = 10){
operator fun plus(p: Point): Point {
return Point(x + p.x, y + p.y)
}
operator fun dec() = Point(--x, --y)
}
fun main() {
val p1 = Point(3, -8)
val p2 = Point(2, 9)
var point = p1 + p2 // 연산자 오버로딩 (객체의 프로퍼티끼리 더함)
println("point = (${point.x}, ${point.y})")
--point // 연산자 오버로딩
println("point = (${point.x}, ${point.y})")
}
꾸준히!