python - Scala类是否具有像Python这样的“ self ”？

Question

例如，如果我有

object Solution {
    class myClass(A: Array[Int]){
        val something: Int = A.length;
        val another: Int = something/2;
        val someName = "blah"
 ...
 ...

这些变量是否只存在于MyC类的一个特定实例中，还是它们在所有对象之间共享的“类范围”变量？如果是后者，如何使这些变量仅成为对象？

Answer 1

是的，它被实现为this，就像在Java或C++中一样。您不必像在python中那样在方法调用时显式地传递它。
然后在示例中创建的是实例变量，也称为成员。它们属于类的实例，即它们不是在同一类的所有对象（类变量）上共享的。对于后者，您可能需要使用the companion scheme。
最后，您可能想更多地阅读scala，比如this tutorial here，或者@IanAuld提供的one for python devs，或者运行scala创建者提供的scala course on coursera。
顺便说一下，欢迎使用堆栈溢出！
编辑：
所以我在Scala中设置它的方式是实例变量，而如果我在Python中使用了相同的通用方法（在布局方面），它们就是类变量？或者你是说我必须在某个地方加上“this”使它们成为实例变量？
我知道你在哪里搞糊涂了。Python和Scala在面向对象编程的方法上非常不同。首先让我们谈谈python：
蟒蛇
Python的设计理念是类（和模块，btw）是dict，在Python的早期版本中，您甚至可以通过myclass.__dict__成员访问类的成员，而今天，即使dict被实现“隐藏”，它仍然可以通过getattr和setattr访问。
这个想法是python如何处理类的核心，因为所有事情都是通过monkey补丁完成的，即在运行时更改并实际定义类定义。

class Foo:
    pass
foo = Foo()
foo.bar = 1
print(foo.bar)

python的另一个基本特性是，一切都是显式的。这就是为什么在声明方法时，会将当前类的引用作为参数显式传递给该方法：

class Foo:
    def foobar(self):
        self.bar = 1
print(foo.bar)

但这实际上相当于：

class Foo:
    pass
def foobar(self):
    self.bar = 1
foo = Foo()
foobar(foo)
print(foo.bar)

以下行为很好地说明了猴子修补的意义：

class Foo:
    def foobar(self):
        print(self.bar)
foo = Foo()
foo.bar = 1
foo.foobar() # prints 1

所以当你在python中定义成员的时候，你真正要做的是用新的成员修补当前的实例。
现在，当你做类实例时，如果我们使用我告诉过你的dict表示，你所做的实际上如下：

Foo = dict(a=1, b=[2]) # class definition with class variables
foo = Foo.copy()       # create instance
foo['b'].append(3)     # use a class variable's instance
print(Foo['b']) # prints: [2,3]

总而言之，python对OOP有一种非常特殊的方法，这完全基于这样一种思想：类的行为有点像dict，它们应该被猴补丁来定义（这就是为什么在创建类时，约定是在构造函数中声明所有成员）。这就是为什么python不被认为是一种“纯”面向对象的语言（它只是该语言的一个属性，而不是一个限定条件）。
斯卡拉
Scala被定义为一种纯函数和纯面向对象的语言。语言的这两个特性使得它与python有很大的不同。我不打算深入解释函数式编程，但我强烈建议你遵循一门课程，阅读有关它和Scala的书籍，以便更好地掌握它。
因此，在Scala中定义类时，可以执行以下操作（示例由我链接的教程提供）：

class Square {
    var x: Double = 0
    var y: Double = 0
    var width: Double = 0
    var height: Double = 0
    def area(): Double = width * height
}

在这里，您定义了实例变量，并给它们一个“默认”值，这就是您在python中在 __init__()构造函数中定义的值。然后定义一个方法。
但由于scala是功能性的，因此可以在类定义中进行另一次读取：

class Square(
    private var x: Double,
    private var y: Double,
    private var width: Double,
    private var height: Double
  ) {
    def area(): Double = width * height
  }

Square是一个函数，它接受参数并返回一个实例，该实例具有在该函数范围内定义的方法。那么，外部的“函数”实际上是一个构造函数，而内部的函数是方法。
现在，Scala中没有实际的类变量，要这样做，您可能更喜欢使用同伴设计模式（CF关于它的答案链接）。
但顺便提一下，因为您在示例中使用的someName变量的属性：

class myClass(A: Array[Int]){
    val something: Int = A.length;
    val another: Int = something/2;
    val someName = "blah"

您的 someName变量是不可变的。这意味着不能在实例中修改它，因此对于所有实例都是一样的。所以不知怎么的，它看起来像类变量，即使不是，它们实际上是实例变量。
就像我在python中的dict示例一样，这并不完全准确，因为对这些机制还有很多需要了解的地方——我在这里甚至没有触及表面，但它的工作目的是演示Scala（一种功能/对象语言）和python（一种修补/对象语言）之间的巨大差异。
现在从一种程序型语言到一种功能型语言迈出了相当大的一步，感觉像是要重新学习来发展，但这绝对是值得的，因为它将教会你一种不同的思维方式来思考你的程序，而不仅仅是你学习一种新的语言和一种新的模式，但它也会通过更好的实践和更多地关注打字，使你在已经掌握的语言中得到更好的发展。