Tag Archives: Class

https://www.journaldev.com/18688/kotlin-enum-class

가장 좋은 설명

Enumerations in Kotlin are data types that hold a set of constants. Enums are defined by adding the modifier enum in front of a class as shown below. Yes, in Kotlin, Enums are classes.

enum class Months{
    January,
    February,
    March
}

Here are some important points about enum classes in kotlin.

• Each enum constant is an object. Enum constants are separated by commas.
• Each of the enum constants acts as separate instances of the class.
• Enums are useful in enhancing the readability of your code since it assigns pre-defined names to constants.
• Unlike classes, an instance of enum classes cannot be created using constructors.
• Hence, we can assert that enum classes are abstract.

Let’s see how the enum class is initialized in the main function of our class.

fun main(args: Array<String>) {

    println(Months.January) //prints January
    println(Months.values().size) //prints 3
    println(Months.valueOf("March")) //prints March

    for (enum in Months.values()) {
        println(enum.name)
    }

    println(Months.valueOf("Mar")) //throws java.lang.IllegalArgumentException: No enum constant Months.Mar
}

Few inferences from the above code:

Let’s see how to tackle this scenario.

fun enumContains(name: String): Boolean {
    return enumValues<Months>().any { it.name == name }
}

fun main(args: Array<String>) {

    if (enumContains("")) {
        println(Months.valueOf(""))
    } else {
        println("The string value does not match with any of the enum constants.") //this gets printed.
    }

}

enumContains is a function that calls the lambda function any which iterates over the enum constants to check if any of them matches the string and returns a boolean.

Enum Properties

Every enum constant has properties: name, ordinal to retrieve the name and position of the constant.

fun main(args: Array<String>) {
    
    println(Months.January.name) //prints January
    println(Months.March.ordinal) // prints 2
    for (enum in Months.values()) {
        println(enum.name)
    }
}

Enum toString()

We can override the toString() function in the enum class as shown below.

enum class Months {
    January,
    February,
    March;

    override fun toString(): String {
        return super.toString().toUpperCase()
    }
}

fun main(args: Array<String>) {
    println(Months.January) //prints JANUARY
    println(Months.January.name) //prints January
     println(Months.valueOf("March")) //prints MARCH
}

Enums are classes. So besides defining the constants we can define other things as well that can be present in a class. To do so we need to first end the enum part with a semi colon.
Note: Month.January invokes the toString() method of the class whereas Month.January.name directly prints the enum constant’s name.

Enum Initialisation

Enum constants can be initialized using primary constructors as shown below.

enum class Months(var shorthand: String) {
    January("JAN"),
    February("FEB"),
    March("MAR");
}

fun main(args: Array<String>) {

    var x = Months.January
    println(x.shorthand) //prints JAN
    x.shorthand = "Shorthand changed to J."
    println(Months.January.shorthand) //prints Shorthand changed to J.
}

Enums as Anonymous classes

Enum constants can behave as anonymous classes be implementing their own functions along with overriding base functions from the class as shown below.

enum class Months(var shorthand: String) {
    January("JAN"){
        override fun printSomething() {
            println("First month of the year.")
        }
    },
    February("FEB"){
        override fun printSomething() {
            println("Second month of the year.")
        }
    },
    March("MAR"){
        override fun printSomething() {
            println("Third month of the year.")
        }
    };
    var a: String = "Hello, Kotlin Enums"
    abstract fun printSomething()
}

fun main(args: Array<String>) {
    Months.February.printSomething() //prints Second month of the year.
    println(Months.February.a) //prints Hello, Kotlin Enums
}

Each of the enum constants must override

Enum inside an Enum

It’s possible to define another enum class in the current enum class as shown below.

enum class Months {
    January,
    February,
    March;

    enum class Day{
        Monday,
        Tuesday,
        Wednesday
    }
}

fun main(args: Array<String>) {
    println(Months.Day.Tuesday) //prints Tuesday
}

Only an enum class can invoke another one. The inner class Day cannot be invoked from the enum constants.

Enums and when

when is Kotlin equivalent of switch in Java. We’ve covered the workings of it in the Control Flow tutorial.
An example showing how when statements are used with enums is given below.

enum class Months {
    January,
    February,
    March;
}

fun main(args: Array<String>) {

    var m = Months.February

    when (m) {
        Months.January  -> print("Matches with Jan")
        Months.February -> print("Matches with Feb") //prints this.
        Months.March -> print("Matches with Mar")
    }
}

This brings an end to kotlin enum tutorial.

References: Kotlin Docs

.

.

.

.

https://youtu.be/or_HJ6NGLxc
kotlin enum basic 설명

.

.

.

.

https://youtu.be/jc9AZfZs7kY

enum class

.

.

.

.

.

.

https://www.baeldung.com/kotlin-enum
Working with Enums in Kotlin

.

.

.

.

내가 정리한 enum class

• child class는 parent constructor 를 그대로 구현해야 한다. 
• parent constructor가 없으면 child에도 constructor는 없다.
• parent class안에 abstract로 정의된 func은 모든 child 가 구현해야 한다.
• parent class안에 abstract로 정의되지 않은 함수를 child안에 새로 만들수 있다.
• child class는 각각 , 로 구분한다. child class정의 마지막은 ;를 사용한다. 
• parent class는 abstract method, abstract property를 가질수 있다. (sealed class도 같다)

sealed class의 경우 parent constructor가 정의되어있지 않더라도 child class 는 constructor를 가질수 있다. 각 class 정의 사이에 구분자는 없다. (정의부분 뒤에 enum의 경우 , 가 붙는데 sealed class의 경우는 없다는 이야기)

sealed class BasicGarment2(){
    class CLEAN_PRESS(var name:String, var price:BigDecimal): BasicGarment2()
    class CLEAN_ONLY(): BasicGarment2()
}

enum class BasicGarment(val na: String, val price:BigDecimal){
    CLEAN_PRESS("a",10.toBigDecimal()){
        override fun calculatePrice(): BigDecimal {
            return 10.toBigDecimal()
        }

        fun foo(){
            println("test func")
        }

        override var testVar: String
            get() = TODO("Not yet implemented")
            set(value) {}
    },
    CLEAN_ONLY("nam", 10.toBigDecimal()){
        override fun calculatePrice(): BigDecimal {
            return 10.toBigDecimal()
        }

        override var testVar: String
            get() = TODO("Not yet implemented")
            set(value) {}
    };
    abstract fun calculatePrice():BigDecimal
    abstract var testVar :String
}

.

.

.

.

https://www.geeksforgeeks.org/enum-classes-in-kotlin/