คำศัพท์ Kotlin - คลาสปิดผนึก

บ่อยครั้งที่เราต้องแสดงความเป็นไปได้ที่ จำกัด คำขอทางเว็บจะประสบความสำเร็จหรือล้มเหลวUserสามารถเป็นได้เฉพาะผู้ใช้มืออาชีพหรือผู้ใช้มาตรฐาน

ในการสร้างแบบจำลองนี้เราสามารถใช้ an enumได้ แต่สิ่งนี้มีข้อ จำกัด หลายประการ คลาส Enum อนุญาตเพียงอินสแตนซ์เดียวของแต่ละค่าและไม่สามารถเข้ารหัสข้อมูลเพิ่มเติมเกี่ยวกับแต่ละประเภทเช่นErrorกรณีที่มีExceptionคุณสมบัติที่เกี่ยวข้อง

คุณสามารถใช้คลาสนามธรรมและส่วนขยายจำนวนมากได้ แต่สิ่งนี้จะสูญเสียชุดข้อได้เปรียบที่ จำกัด ซึ่งมาจาก enums คลาสที่ปิดผนึกมอบสิ่งที่ดีที่สุดให้กับทั้งสองโลก: เสรีภาพในการเป็นตัวแทนของคลาสนามธรรมและกลุ่มประเภทของ enums ที่ จำกัด อ่านต่อเพื่อเรียนรู้เพิ่มเติมเกี่ยวกับคลาสที่ปิดผนึกหรือหากคุณต้องการวิดีโอโปรดดูที่นี่:

พื้นฐานของคลาสปิดผนึก

เช่นเดียวกับคลาสนามธรรมคลาสปิดผนึกช่วยให้คุณสามารถแสดงลำดับชั้นได้ คลาสย่อยสามารถเป็นคลาสประเภทใดก็ได้: คลาสข้อมูลอ็อบเจ็กต์คลาสปกติหรือคลาสอื่นที่ปิดผนึก ซึ่งแตกต่างจากคลาสนามธรรมคุณต้องกำหนดลำดับชั้นเหล่านี้ในไฟล์เดียวกันหรือเป็นคลาสที่ซ้อนกัน

// Result.kt
sealed class Result<out T : Any> {
    data class Success<out T : Any>(val data: T) : Result<T>()
    data class Error(val exception: Exception) : Result<Nothing>()
}

Cannot access ‘<init>’: it is private in Result

บ่อยครั้งที่เราต้องการจัดการทุกประเภทที่เป็นไปได้:

when(result) {
    is Result.Success -> { }
    is Result.Error -> { }
}

sealed class Result<out T : Any> {
    data class Success<out T : Any>(val data: T) : Result<T>()
    data class Error(val exception: Exception) : Result<Nothing>()
    object InProgress : Result<Nothing>()
}

val action = when(result) {
    is Result.Success -> { }
    is Result.Error -> { }
}

เพื่อให้ได้รับประโยชน์ที่ดีนี้แม้ว่าเราจะใช้เมื่อเป็นคำสั่งก็ตามให้เพิ่มคุณสมบัติส่วนขยายตัวช่วยนี้:

val <T> T.exhaustive: T
    get() = this

when(result){
    is Result.Success -> { }
    is Result.Error -> { }
}.exhaustive

เนื่องจากทราบประเภทย่อยทั้งหมดของคลาสที่ปิดผนึก IDE สามารถเติมเต็มสาขาที่เป็นไปได้ทั้งหมดของคำสั่งเมื่อให้เรา:

คุณลักษณะนี้โดดเด่นด้วยลำดับชั้นของคลาสที่ปิดผนึกที่ซับซ้อนมากขึ้นเนื่องจาก IDE สามารถจดจำสาขาทั้งหมดได้:

sealed class Result<out T : Any> {
  data class Success<out T : Any>(val data: T) : Result<T>()
  sealed class Error(val exception: Exception) : Result<Nothing>() {
     class RecoverableError(exception: Exception) : Error(exception)
     class NonRecoverableError(exception: Exception) : 
                                               Error(exception)
  }
  object InProgress : Result<Nothing>()
}

      

ใต้ฝากระโปรง

แล้วอะไรที่ทำให้ชั้นเรียนที่ปิดผนึกมีพฤติกรรมเหมือนพวกเขา มาดูกันว่าเกิดอะไรขึ้นในโค้ด Java ที่ถอดรหัส:

sealed class Result
data class Success(val data: Any) : Result()
data class Error(val exception: Exception) : Result()
@Metadata(
…
d2 = {“Lio/testapp/Result;”, “T”, “”, “()V”, “Error”, “Success”, “Lio/testapp/Result$Success;”, “Lio/testapp/Result$Error;” …}
)
public abstract class Result {
    private Result() {}
    // $FF: synthetic method
    public Result(DefaultConstructorMarker $constructor_marker) {
        this();
    }
}

Resultจะดำเนินการเป็นระดับนามธรรมที่มีสองก่อสร้าง:

• ตัวสร้างเริ่มต้นส่วนตัว
• ตัวสร้างสังเคราะห์ที่คอมไพเลอร์ Kotlin ใช้ได้เท่านั้น

public final class Success extends Result {
    @NotNull
    private final Object data
    
    public Success(@NotNull Object data) {
      
       super((DefaultConstructorMarker)null);
       this.data = data;
    }