**1. 定义类的基础语法：** ``` // 主构造器 class ClassName(参数列表) { 辅助构造器 成员变量 成员方法 } ``` <br/> **2. 定义类** （1）写法1 ```scala // 主构造器 // Point1(xc:Int, yc:Int)是该类的主构造器 class Point1(xc:Int, yc:Int) { // 字段 var x:Int = xc; var y:Int = yc; // 辅助构造器，相当于Java中构造器的重载 def this() = { this(0, 0) // 辅助构造器的第一句必须调用该类已存在的构造器，不一定是主构造器 } // 成员方法 def move(dx:Int, dy:Int):Unit={ x = x + dx; y = y + dy; } } ``` （2）写法2 ```scala class Point1(var x:Int, var y:Int) { // 自动生成为类的字段 // 字段。可以写，也可以不写了，因为会隐式地自动生成 // var x:Int = xc; // var y:Int = yc; def this() = { this(0, 0) } def move(dx:Int, dy:Int):Unit={ xc = xc + dx; yc = yc + dy; } } ``` **3. 调用** 对于类先要`new`才能调用它的字段和方法。 ```scala import org.example.oop.Point1 object App{ def main(args: Array[String]): Unit = { // 实例化对象 val point1 = new Point1(10, 10) println(point1.x) // 10 println(point1.y) // 10 point1.move(20, 20) println(point1.x) // 30 } } ``` **4. 关于类的细节** Scala代码由Java编译器进行编译，查看编译后的Java代码如下（无论是写法1还是写法2都基本一样的）。 ```java package org.example.oop; import scala.reflect.ScalaSignature; @ScalaSignature(bytes="\002\0") // 1. 定义的类的访问权限默认为public public class Point1 { // 2. 成员变量默认访问权限是private private int x; private int y; // 3. 自动为成员变量提供类似于Java中的Getter方法，并且访问权限是public // 在上面我们point1.x，调用的其实是这个方法，而不是字段 public int x(){ return this.x; } // 4. 自动为成员变量提供类似于Java中的Setter方法，并且访问权限是public // x_$eq，与 x_= 是同一个方法名 public void x_$eq(int x$1) { this.x = x$1; } public int y() { return this.y; } public void y_$eq(int x$1) { this.y = x$1; } // 5. 成员方法的默认访问权限为public public void move(int dx, int dy) { x_$eq(x() + dx); y_$eq(y() + dy); } // 6. 根据成员变量自动提供了两个参数的构造器，并且默认访问权限默认为public public Point1(int x, int y) { } // 7. 根据辅助构造器自动提供了无参构造器，默认访问权限为public public Point1() { this(0, 0); } } ``` 1. **`this`：** 在Scala 中，`this`是关键字，用于引用当前对象。可以使用 this 调用实例变量、方法、构造器。 2. 如果不指定访问修饰符，除了字段是`private`外，其它都是`public`，当然你也可以指定为`private`或`protected`。 3. Scala 类中无法定义静态成员和方法，因为没有 `static` 关键字。 4. 在Scala中，无论是字段或者成员方法，统一称为成员变量。 5. 在Scala中，方法使用`def`关键字定义，任何方法的参数列表的关键字都是`val`，所以你不能对该参数赋值，如下： ```scala def method(x:Int, y:Int){ // 不能对参数进行赋值 x = 10 y = 10 } // 方法的参数列表不能使用var或val修饰 def method(var x:Int, val y:Int) {} ``` 6. 统一访问原则： 当方法无参时与字段的调用是一样的，比如方法`def method():Unit = println("")`是无参的，它可以`obj.method()`调用或者`obj.method`调用，如果调用字段一样。 7. 对于无参构造器，可以`new Point()`，也可以`new Point`实例化。 8. 对于无参成员方法，其实可以将关键字`def`转换为`val`或者`var`，如下： ```scala def method():Unit = { println(1000) } var method = { println(1000) } val method = { println(1000) } ``` 区别在于，方法每次调用都会重新计算，而字段只在初始化时被计算，所以字段的运行效率比方法效率高。 9. 对于`val`定义的字段，Scala自动创建该字段的Getter方法，但是没有Setter方法；对于`var`定义的字段，则两者都会自动创建。 10. 如果字段使用`val`修饰则不能对其赋值，如下： ```scala class Point1(val x:Int, var y:Int) {} val point1 = new Point1 point1.x = 1000 // 编译报错 point1.y = 1000 // 编译通过 ```