Question

我正在尝试像Java一样在其他类中调用一个类的静态函数，但是在kotlin中，我无法创建静态函数，而必须创建一个必须在其中定义函数的伴侣对象，但是在执行此操作时我无法访问父类变量，有什么方法可以在kotlin中实现。

class One {

    val abcList = ArrayList<String>()

    companion object {

        fun returnString() {
            println(abcList[0]) // not able to access abcList here
        }
    }
}

class Two {

    fun tryPrint() {
        One.returnString()
    }
}

// In Java we can do it like this

class One {

    private static ArrayList<String> abcList = new ArrayList<>();

    public void tryPrint() {
        // assume list is not empty 
        for(String ab : abcList) {
            System.out.println(ab);
        }
    }

    public static void printOnDemand() {
        System.out.println(abcList.get(0));
    }
}

class Two {

    public void tryPrint(){
        One.printOnDemand();
    }
}

我想像我们在Java中那样访问有趣的returnString（），就像一类的静态函数一样，如果任何一个实现了这一点，请帮忙。

Answer 1

在您的情况下，abcList是该类的成员变量。类的每个实例都有其成员变量的各自版本，这意味着静态方法无法访问它们。如果要从同伴对象访问它，它也必须是静态的。

class One {
    companion object {
        val abcList = ArrayList<String>()

        fun returnString() {
            println(abcList[0])
        }
    }
}

class Two {
    fun tryPrint() {
        One.returnString()
    }
}

此代码将起作用，但是请记住，在这种情况下，abcList仅会有一个实例。无法从静态函数访问成员变量（即使在Java中也是如此）。

这是您的Java示例的Kotlin版本：

class One {
    companion object {
        val abcList = ArrayList<String>()

        fun printOnDemand() {
            println(abcList[0])
        }
    }

    fun tryPrint() {
        for (ab in abcList) {
            println(ab)
        }
    }
}

class Two {
    fun tryPrint() {
        One.printOnDemand()
    }
}

Answer 2

规则：您不能访问静态属性，也不能以静态成员的形式访问类的成员，也不能访问静态属性，即作为伙伴对象类的静态成员的类的成员。 Java和Kotlin中都使用此规则。如果要访问类的非静态成员在静态成员内部，您必须在伴侣对象类中声明它。

Answer 3

为您的情况使用以下代码。

object One {
    val abcList: MutableList<String> = mutableListOf()

    fun returnString() {
       println(abcList[0])
    }

    fun printOnDemand() {
       println(abcList[0]);
    }
}

class Two {
    fun tryPrint() {
        One.printOnDemand()
    }
}

在Kotlin中访问伴随对象中的父类变量

3 个答案: