Множественное наследование классов с разными свойствами

Question

Я не уверен, что то, что я пытаюсь сделать, просто невозможно, или я просто думаю об этом совершенно неправильно, но по сути это то, что я пытаюсь сделать. У меня есть запечатанный класс с несколькими классами внутри, как это:

sealed class MySealedClass(val thing: Thing) : MyPropertyInterface
{
    val name: String = thing.name

    /** Base Methods Here */

    /** Obj 1 Constructor */
    class ObjOne(thing: Thing) : MySealedClass(thing)
    {
        override val properties = PropertyTypeOne()
        override val otherProperties = PropertyTypeTwo()

        inner class PropertyTypeOne(){
            val one = 1
        }

        inner class PropertyTypeTwo(){
            val two = 2
        }
    }

    /** Obj 2 Constructor */
    class ObjTwo(thing: Thing) : MySealedClass(thing)
    {
        override val properties = PropertyTypeOne()
        override val otherProperties = PropertyTypeTwo()

        inner class PropertyTypeOne(){
            val one = 1
        }

        inner class PropertyTypeTwo(){
            val two = 2
        }
    }
}

По сути, я хочу, чтобы классы в моем запечатанном классе наследовали эти свойства области так, как интерфейс заставлял бы их инициализировать их, поскольку они будут содержать свойства одного типа, но разные значения. Причина, по которой я хочу, чтобы свойства были ограничены областью, заключается в том, что вместо того, чтобы обращаться к ним через список, я хочу получить к ним прямой доступ (просто для большей читабельности), и без области видимости может стать неясно, к чему вы обращаетесь. Я понимаю, что мог бы создать собственный интерфейс для каждого класса внутри запечатанного класса, содержащего указанные классы с указанными свойствами, но моя проблема заключается в том, что я хочу, в некотором смысле, принудительно применить это к классам в запечатанном классе, который они должны построить эти две структуры данных. Создавая собственный интерфейс для каждого класса, можно было бы предположить, что один из них больше не соответствует критериям из-за человеческой ошибки.

Answer 1

Это решение, к которому я пришел, чтобы получить желаемый результат:

sealed class MySealedClass(val p0: Int, val p1: Int) : MyProperties{

    /** Base properties and methods */

    class MyClassA(p0: Int, p1: Int) : MySealedClass(p0, p1){
        override val propertyListOne: MyProperties.PropertiesA = MyProperties.PropertiesA()
        override val propertyListTwo: MyProperties.PropertiesB = MyProperties.PropertiesB()
    }

    class MyClassB(p0: Int, p1: Int) : MySealedClass(p0, p1){
        override val propertyListOne: MyProperties.PropertiesC = MyProperties.PropertiesC()
        override val propertyListTwo: MyProperties.PropertiesD = MyProperties.PropertiesD()
    }
}

interface MyProperties{
    val propertyListOne: Any
    val propertyListTwo: Any

    class PropertiesA{
        val one = 1
    }

    class PropertiesB{
        val two = 2
    }

    class PropertiesC{
        val three = 3
    }

    class PropertiesD{
        val four = 4
    }
}

fun testMethod(){
    val newClassA = MyClassA(0, 0)
    newClassA.propertyListOne.one
    newClassA.propertyListTwo.two
    val newClassB = MyClassB(0, 0)
    newClassB.propertyListOne.three
    newClassB.propertyListTwo.four
}

Я понимаю, что все это можно сделать проще, просто создав списки, но я специально не собираюсь индексировать эти значения. Кроме того, эта структура значительно упрощает понимание и чтение иерархии объектных структур кода, над которым я работаю.