๐กcompanion, data class, ์ค์ฒฉ ํด๋์ค, enum, sealed๐ก
โช๏ธcompanion
· ๊ฐ์ฒด๋ฅผ ์์ฑํ์ง ์๊ณ ์ฌ์ฉํ ์ ์๋ค.
· ๊ณตํต๋ ๊ฐ์ด ๋ง๋ค๋ฉด companion์ ์ฌ์ฉํ๋ฉด ๋๋ค.
fun main() {
// ๊ฐ์ฒด๋ฅผ ์์ฑํด์ผ ๊ทธ ์์ ๋ด์ฉ๋ค์ ์ธ ์ ์์
val obj = ComClass()
println("obj.num1 : ${obj.num1}")
obj.comFunction1()
// companion์ ๊ฐ์ฒด๋ฅผ ์์ฑํ์ง ์๊ณ ๋ฐ๋ก ์ฌ์ฉ ๊ฐ๋ฅ
println("obj.num2 : ${ComClass.num2}")
ComClass.comFunction2()
}
class ComClass {
var num1 = 100
fun comFunction1() {
println("comFunction1 ํธ์ถ")
}
companion object {
var num2 = 200
fun comFunction2() {
println("comFunction2 ํธ์ถ")
}
}
}
โช๏ธdata class
· ๋งค๊ฐ์ฒด์ ๋ฐ์ดํฐ๋ฅผ ๊ด๋ฆฌํ๋ ์ฉ๋๋ก ์ฌ์ฉํ๋ ํด๋์ค์ด๋ค.
· ๋ฐ๋์ ์ฃผ ์์ฑ์๋ฅผ ๊ฐ์ง๊ณ ์์ด์ผ ํ๋ค.
fun main() {
val obj1 = DatClass("์งฑ๊ตฌ", 10)
val obj2 = DatClass("์ฒ ์", 20)
val obj3 = DatClass("๋งน๊ตฌ", 30)
println("obj1 : ${obj1.name}, ${obj1.age}")
println("obj2 : ${obj2.name}, ${obj2.age}")
println("obj3 : ${obj3.name}, ${obj3.age}")
}
data class DatClass(
val name : String,
val age : Int
)
โช๏ธGeneric
· ์ ๋ค๋ฆญ์ ์ฌ์ฉํ๋ฉด ๊ฐ์ฒด ์์ฑ ์์ ๋ณ์์ ํ์ ์ ๊ฒฐ์ ํ ์ ์๋ค.
fun main() {
val obj1 = GenClass1<Int>()
obj1.genClass1function(100)
val obj2 = GenClass2<Double>(100.0)
obj2.genClass2function(200.0)
val obj3 = GenClass3<Int, Double>()
obj3.genClass3function(100, 100.0)
val obj4 = GenClass4<Int, Double, String, Boolean>(100,100.0)
obj4.genClass4function("๊ฐ๋๋ค", false)
}
// ๊ฐ์ฒด๋ฅผ ๋ง๋ค ๋ <>์์ ํ์
์ ๋ฃ์ด์ค๋ค๋ฉด ํด๋น ํ์
๋ง ๋ฃ์ ์ ์์
class GenClass1<T> {
fun genClass1function(what : T) {
println("genClass1function what : $what")
}
}
class GenClass2<T>(var what1 : T) {
fun genClass2function(what2 : T) {
println("GenClass2 what : $what1")
println("genClass2function what : $what2")
}
}
// ํ ๊ฐ ์ด์์ ํ์
์ ๋ฃ์ ์ ์์
class GenClass3<A, B> {
fun genClass3function(what1 : A, what2 : B) {
println("genClass3function what1 : $what1")
println("genClass3function what2 : $what2")
}
}
class GenClass4<A, B, C, D>(var what1 : A, var what2 : B) {
fun genClass4function(what3 : C, what4 : D) {
println("GenClass4 what1 : $what1")
println("GenClass4 what2 : $what2")
println("genClass4function what3 : $what3")
println("genClass4function what4 : $what4")
}
}
โช๏ธ์ค์ฒฉ ํด๋์ค
· ํด๋์ค ์์ ๋ง๋๋ ํด๋์ค๋ฅผ ์ค์ฒฉ ํด๋์ค๋ผ๊ณ ๋ถ๋ฅธ๋ค.
· class ์์ inner ํค์๋๋ฅผ ์์ฑํ๋ฉด ๋๋ค.
fun main() {
// inner class์ ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ ค๋ฉด ์์ ํด๋์ค์ ๊ฐ์ฒด๋ฅผ ๋จผ์ ์์ฑํด์ผ ํ๋ค.
val obj1 = InnClass1()
val obj2 = obj1.InnClass2()
obj2.innClass2Function()
}
class InnClass1 {
inner class InnClass2 {
fun innClass2Function() {
println("innClass2Function ํธ์ถ")
}
}
}
์ต๋ช ์ค์ฒฉ ํด๋์ค
· ์ด๋ฆ์ด ์๋ ํด๋์ค๋ฅผ ์ต๋ช ์ค์ฒฉ ํด๋์ค๋ผ๊ณ ๋ถ๋ฅธ๋ค.
· ์ธํฐํ์ด์ค๋ ์ถ์ํด๋์ค๋ฅผ ์ฌ์ฉํ ๋ ์ด์ฉ๋๋ค.
· ์ด๋ฆ์ด ์์ผ๋ฏ๋ก ๊ฐ์ฒด๋ฅผ ์์ฑํ ์ ์๋ค.
fun main() {
val obj1 = InnClass1()
obj1.innAbsFunction()
val obj2 = InnClass2()
obj2.innIntFunction()
// ์ต๋ช
์ค์ฒฉ ํด๋์ค
val obj3 = object : InnClass1() {
override fun innAbsFunction() {
println("์ต๋ช
์ค์ฒฉ ํด๋์ค์ innAbsFunction ํธ์ถ")
}
}
obj3.innAbsFunction()
val obj4 = object : InnClass2() {
override fun innIntFunction() {
println("์ต๋ช
์ค์ฒฉ ํด๋์ค์ innIntFunction ํธ์ถ")
}
}
obj4.innIntFunction()
}
abstract class InnAbsClass {
abstract fun innAbsFunction()
}
interface InnIntClass {
fun innIntFunction()
}
// ์ถ์ ํด๋์ค๋ฅผ ์์๋ฐ์ ํด๋์ค
open class InnClass1 : InnAbsClass() {
override fun innAbsFunction() {
println("innAbsFunction ํธ์ถ")
}
}
// ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ํด๋์ค
open class InnClass2 : InnIntClass {
override fun innIntFunction() {
println("innIntFunction ํธ์ถ")
}
}
โช๏ธenum
· ์ด๊ฑฐํ์ ์ ์ํ ๋จ์ด ์์ฒด๊ฐ ํ๋ก๊ทธ๋จ์์ ์ฌ์ฉํ๋ ๊ฐ์ด ๋๋ค.
fun main() {
enuFunction1(EnuClass1.SOUTH)
enuFunction2(EnuClass2.TWO)
}
enum class EnuClass1 {
NORTH, SOUTH, WEST, EAST
}
enum class EnuClass2(val num : Int, val str : String) {
ONE(1,"ํ๋"), TWO(2,"๋"), THREE(3,"์
")
}
fun enuFunction1(what : EnuClass1) {
when(what) {
EnuClass1.NORTH -> println("๋ถ์ชฝ์
๋๋ค.")
EnuClass1.SOUTH -> println("๋จ์ชฝ์
๋๋ค.")
EnuClass1.WEST -> println("์์ชฝ์
๋๋ค.")
EnuClass1.EAST -> println("๋์ชฝ์
๋๋ค.")
}
}
fun enuFunction2(what : EnuClass2) {
when(what) {
EnuClass2.ONE -> println("ONE์
๋๋ค.")
EnuClass2.TWO -> println("TWO์
๋๋ค.")
EnuClass2.THREE -> println("THREE์
๋๋ค.")
}
// ๋ถ๊ธฐ๊ฐ ๊ฐ๋ฅ
when(what.num) {
1 -> println("1์
๋๋ค.")
2 -> println("2์
๋๋ค.")
3 -> println("3์
๋๋ค.")
}
when(what.str) {
"ํ๋" -> println("ํ๋์
๋๋ค.")
"๋" -> println("๋์
๋๋ค.")
"์
" -> println("์
์
๋๋ค.")
}
}
โช๏ธsealed
· sealed class๋ ๊ฐ์ฒด๋ฅผ ๋ชจ์ ๊ด๋ฆฌํ๋ ํด๋์ค์ด๋ค.
fun main() {
val n1 = SeaClass.SealedTwo(1)
checkNumber(n1)
val n2= SeaClass.SealedTwo(2)
checkNumber(n2)
val n3= SeaClass.SealedThree(3, 3.0)
checkNumber(n3)
}
sealed class SeaClass {
class SealedOne(val num : Int) : SeaClass()
// ๋ฉ์๋๋ ์์ฑํ ์ ์์
class SealedTwo(val num : Int) : SeaClass() {
fun seaFunction() {
println("seaFunction ํธ์ถ")
}
}
class SealedThree(val num : Int, val num2 : Double) : SeaClass()
}
fun checkNumber(number : SeaClass) {
when(number) {
// ํด๋์คํ์
๊ฒ์ฌ๋ is๋ฅผ ์ฐ๋ฉด ๋จ
is SeaClass.SealedOne -> {
println("SealedOne")
println(number.num)
}
is SeaClass.SealedTwo -> {
println("SealedTwo")
println(number.num)
when(number.num) {
1 -> println("1์
๋๋ค.")
2 -> println("2์
๋๋ค.")
3 -> println("3์
๋๋ค.")
}
number.seaFunction()
}
is SeaClass.SealedThree -> {
println("SealedThree")
println(number.num)
when(number.num) {
3 -> println("3์
๋๋ค.")
}
when(number.num2) {
3.0 -> println("3.0์
๋๋ค.")
}
}
}
}
![](https://t1.daumcdn.net/keditor/emoticon/niniz/large/019.gif)
'๐ฑ > ๐Kotlin' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Kotlin] ์ปฌ๋ ์ (1) | 2022.12.26 |
---|---|
[Kotlin] ํจ์ํ ํ๋ก๊ทธ๋๋ฐ (0) | 2022.12.26 |
[Kotlin] ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ (0) | 2022.12.20 |
[Kotlin] ์ ์ด๋ฌธ๊ณผ ๋ฐ๋ณต๋ฌธ (0) | 2022.12.20 |
[Kotlin] ๊ธฐ๋ณธ ๋ฌธ๋ฒ (0) | 2022.12.20 |