简介
Scala 语言源自于Java，它天生就是面向对象的语言。
Scala 是纯粹的面向对象的语言，即在 Scala 中，一切皆为对象。
类的定义
类定义语法
语法规则：
[修饰符] class 类名 {
类体
}
注意：
- scala中的类不能声明为 public，因为所有类默认就是 public的
- 一个 Scala 源文件可以包含多个类，而且默认都是 public的
示例：
class Person {
//用val修饰的变量是只读属性，相当与Java中用final修饰的变量，有getter但没有setter
val id = "9527"
//用var修饰的变量既有getter又有setter
var age: Int = 18
//类私有字段，只能在类的内部使用
private var name: String = "唐伯虎"
//对象私有字段，访问权限更加严格的，Person类的方法只能访问到当前对象的字段
private[this] val pet = "小强"
}
属性
定义语法：
[访问修饰符] var 属性名称 [：类型] = 属性值
说明：
- 声明属性时，属性类型可以省略但必须显示初始化，系统会根据初始化数据的类型自动推断
- 如果赋值为 null，则一定要加类型，因为不加类型，那么该属性的类型就是Null类型
- 如果在定义属性时，暂时不赋值，可以使用符号_(下划线)，让系统分配默认值
示例：
class A {
var var1 :String = _ // null
var var2 :Byte = _ // 0
var var3 :Double = _ //0.0
var var4 :Boolean = _ //false
}
转换成的A.class的代码如下：
public class A {
private String var1;
private byte var2;
private double var3;
private boolean var4;
public String var1() {
return this.var1;
}
public void var1_$eq(String x$1) {
this.var1 = x$1;
}
public byte var2() {
return this.var2;
}
public void var2_$eq(byte x$1) {
this.var2 = x$1;
}
public double var3() {
return this.var3;
}
public void var3_$eq(double x$1) {
this.var3 = x$1;
}
public boolean var4() {
return this.var4;
}
public void var4_$eq(boolean x$1) {
this.var4 = x$1;
}
}
Bean 属性
将 Scala字段加上@BeanProperty 时，会自动生成规范的 setXxx/getXxx 方法。这时可以使用对象.setXxx() 和对象.getXxx() 来调用属性，从而和Java一致了。
注意：给某个属性加入@BeanPropetry 注解后，会生成 getXXX 和 setXXX 方法，对原来底层自动生成类似 xxx(),xxx_$eq()方法没有冲突，二者可以共存。
示例：
class Car {
@BeanProperty var name: String = null
}
生成的Car.class代码如下：
public class Car {
private String name = null;
public String name() {
return this.name;
}
public void name_$eq(String x$1) {
this.name = x$1;
}
public void setName(String x$1) {
this.name = x$1;
}
public String getName() {
return name();
}
}
对象的创建
创建对象的语法规则：
val|var 对象名 [:类型] = new 类型()
说明：
- 如果不希望改变对象的引用(即：内存地址)，应该声明为 val 性质的，否则声明为 var。推荐使用val。
- 在声明对象变量时，类型声明可以省略。但是当所要声明的对象的类型 和 new关键字后面对象的类型有继承关系时，就必须写了
示例：
class Person {
}
class Emp extends Person {
}
object ScalaDemo {
def main(args: Array[String]): Unit = {
val emp = new Emp // emp 类型就是 Emp
//如果我们希望将子类对象赋值给父类的引用时就必须写上类型
val emp2: Person = new Emp
}
}
构造方法
Scala 构造对象时需要调用构造方法，它可以有任意多个构造方法。Scala 类的构造方法包括主构造方法(一个)和辅助构造方法(多个)，语法规则如下：
class 类名(形参列表) { // 主构造方法
def this(形参列表) { // 辅助构造方法
}
def this(形参列表) { //辅助构造方法可以有多个…
}
}
说明：
- 辅助构造方法函数的名称为this，它可以有多个，编译器通过不同参数来区分
- 每个类都有主构造方法，主构造方法的声明直接放置于类名之后
- 主构造方法会执行类定义中的所有语句
- 如果主构造方法没有参数时小括号可省略，创建对象时调用的构造方法的小括号也可以省略
- 如果想让主构造方法变成私有的，可以在()之前加上 private，这样用户只能通过辅助构造方法来构造对象了。比如：class Person private() {}
- 辅助构造方法必须在第一行显式调用主构造方法
示例：
class Student(val name: String, val age: Int){
println("执行主构造方法")
private var gender = "male"
def this(name: String, age: Int, gender: String){ //用this关键字定义辅助构造方法
//每个辅助构造方法必须以主构造方法或其他的辅助构造方法的调用开始
this(name, age)
println("执行辅助构造方法")
this.gender = gender
}
}
构造方法参数：
- 如果主构造方法的形参未用任何修饰符修饰，那么这个参数是局部变量
- 如果主构造方法的形数使用val关键字声明，那么Scala会将参数作为类的私有的只读属性使用
- 如果主构造方法的形数使用var关键字声明，那么 Scala 会将参数作为类的成员属性使用,并会提供属性对应的getter/setter方法，即这时的成员属性是私有的，但是可读写。
示例：
class Worker(inName: String) { //inName是局部变量
var name = inName
}
class Worker2(val inName: String) { //inName 是 private 的只读属性
var name = inName
}
class Worker3(var inName: String) {//inName是private 可以读写属性
var name = inName
}
object ScalaDemo {
def main(args: Array[String]): Unit = {
val worker = new Worker("zhangsan")
println(worker.name)
// println(worker.inName) //不能访问 inName
val worker2 = new Worker2("lisi")
println(worker2.inName)
val worker3 = new Worker3("wanger")
worker3.inName = "mazi"
println(worker3.inName)
}
}
