Kotlin透明属性解析器：组合替代继承时属性访问的优化方案咨询

Great question! I totally get your frustration here—Kotlin’s emphasis on composition over inheritance is fantastic in theory, but when you’re stuck typing dim2.x instead of just x in your Dim3 class, it feels like you’re trading elegance for design principles. And extracting every field into an interface to mimic inheritance? That’s way too much unnecessary boilerplate. Let’s break down some smarter alternatives that keep composition intact while making property access just as smooth as inheritance.

1. Use Kotlin’s Delegated Properties (For Small Property Sets) #

If Dim2 only has a handful of properties, delegated properties let you "forward" each property from your composed dim2 instance to Dim3 with minimal code—no interfaces required.

class Dim2(val x: Int, val y: Int)

class Dim3(private val dim2: Dim2, val z: Int) {
    // Delegate each Dim2 property to the composed instance
    val x: Int by dim2::x
    val y: Int by dim2::y
}

// Usage is identical to inheritance
val dim3 = Dim3(Dim2(1, 2), 3)
println(dim3.x) // Output: 1
println(dim3.y) // Output: 2

Pros: #

• No changes needed to your original Dim2 class
• Super concise syntax (shorter than writing custom getters like val x get() = dim2.x)
• Keeps dim2 private, maintaining encapsulation

Cons: #

• You have to declare each delegated property individually—this gets tedious if Dim2 has a lot of properties.

2. Interface Delegation (For Large Property Sets) #

If Dim2 has many properties, interface delegation is the sweet spot. It lets you forward an entire interface’s properties/methods to your composed instance in one line, avoiding boilerplate while keeping composition flexible.

First, define an interface for the properties you want to expose:

interface Dim2Properties {
    val x: Int
    val y: Int
}

Update Dim2 to implement this interface (a one-time change):

class Dim2(override val x: Int, override val y: Int) : Dim2Properties

Then use Kotlin’s by keyword to delegate the interface implementation to your composed dim2 instance in Dim3:

class Dim3(dim2: Dim2Properties, val z: Int) : Dim2Properties by dim2

// Usage is exactly like inheritance
val dim3 = Dim3(Dim2(1, 2), 3)
println(dim3.y) // Output: 2

Pros: #

• Zero boilerplate for property forwarding—add a property to Dim2Properties, update Dim2, and Dim3 automatically gains it
• Keeps composition flexibility (you can pass any implementation of Dim2Properties to Dim3, not just Dim2)
• Looks and behaves just like inheritance from the outside

Cons: #

• Requires creating an interface (but this is a lightweight change, not the "extract all fields" mess you mentioned)

3. Extension Properties (For No Class Modifications) #

If you can’t or don’t want to modify Dim2 or Dim3 at all, extension properties let you add "virtual" properties to Dim3 that forward to dim2.

class Dim2(val x: Int, val y: Int)
class Dim3(val dim2: Dim2, val z: Int) // Note: dim2 needs to be public (or internal if in the same module)

// Add extension properties to Dim3
val Dim3.x: Int get() = this.dim2.x
val Dim3.y: Int get() = this.dim2.y

// Usage
val dim3 = Dim3(Dim2(1, 2), 3)
println(dim3.x) // Output: 1

Pros: #

• No changes to existing classes whatsoever
• Clean external access

Cons: #

• dim2 has to be accessible (public/internal) from where you define the extension
• Extension properties can’t be used inside Dim3 itself (unless you define the extension in the same file as Dim3 and use internal visibility)
• Less encapsulated than the other options

Which One Should You Choose? #

• Go with delegated properties if Dim2 has a small number of properties and you want to keep dim2 private.
• Use interface delegation if Dim2 has many properties or you want flexibility to swap out the composed implementation later.
• Pick extension properties only if you can’t modify the original classes and don’t need internal access to the forwarded properties.

All of these options let you stick to composition over inheritance without sacrificing the elegance of direct property access.

内容的提问来源于stack exchange，提问作者smallufo