1、类的定义
直接定义{}内部就是scala的构造方法
重载构造方法使用this函数
属性变量等前面 加了_需要使用{}括起来使用
//{
}就是scala中类的默认构造函数，可以直接传入参数
class Students(id: String, name: String, age: Int) {
println("默认的构造方法")
//定义属性
val _id: String = id
val _name: String = name
val _age: Int = age
//使用_先不传入
var _clazz: String = _
//重载构造方法，使用函数this
//方法中第一行为默认的构造方法
def this(id: String, name: String, age: Int, clazz: String) {
this(id, name, age)
_clazz = clazz
println("重载构造方法")
}
//重写toString方法
override def toString(): String = {
return s"Students(${_id}, ${_name}, ${_age})"
}
def printName(): Unit = {
println(this._name)
}
}
object Demo02scala {
def main(args: Array[String]): Unit = {
val stu: Students = new Students("1001", "zs", 178)
println(stu._id)
println(stu._name)
println(stu._age)
println(stu)
stu.printName()
val stu2 = new Students("1002","ls",26,"文科一班")
println(stu2)
}
}
2、类的继承
object Demo03ScalaExtend {
def main(args: Array[String]): Unit = {
val s1: A = new B("1001", "zs", 18)
println(s1.toString)
}
}
class A(id: String, name: String) {
println("A中的构造方法")
val _id: String = id
val _name: String = name
override def toString = s"A(${_id}, ${_name})"
}
//B继承A，会调用父类A的构造方法
//A（）中传入具体的值，值从前面定义的B来
class B(id: String, name: String, age: Int) extends A(id, name) {
println("B中的构造方法")
val _age: Int = age
override def toString = s"B(${_id}, ${_name},${_age})"
}
3、样例类case
创建样例列对象时new可以省略
object Demo04CaseClass {
def main(args: Array[String]): Unit = {
val stu = new Stu("1002","dfg",15)
println(stu.name)
println(stu.age)
//也可以直接修改
//样例类中的参数就是类的属性
//样例类会给每一个属性在编译的时候加上"get\set"方法
//还会实现序列化接口
stu.id = "555"
println(stu.id)
}
}
//默认是使用val修饰的
case class Stu(var id: String, name: String,age:Int)
4、封装
Scala 中的 public 属性，底层实际为 private，并通过 get 方法（obj.field()）和 set 方法
（obj.field_=(value)）对其进行操作。所以 Scala 并不推荐将属性设为 private，再为其设置
public 的 get 和 set 方法的做法。但由于很多 Java 框架都利用反射调用 getXXX 和 setXXX 方
法，有时候为了和这些框架兼容，也会为 Scala 的属性设置 getXXX 和 setXXX 方法（通过
@BeanProperty 注解实现）。
5、动态绑定
Scala 中属性和方法都是动态绑定，而 Java 中只有方法为动态绑定
6、单例对象（伴生对象）
Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象来模拟类对象，该对象为单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明。
7、特质（Trait） （通过查看字节码，可以看到特质=抽象类+接口）
Scala 语言中，采用特质 trait（特征）来代替接口的概念，也就是说，多个类具有相同的特质（特征）时，就可以将这个特质（特征）独立出来，采用关键字 trait 声明。Scala 中的 trait 中即可以有抽象属性和方法，也可以有具体的属性和方法，一个类可以混入（mixin）多个特质。这种感觉类似于 Java 中的抽象类。
Scala 引入 trait 特征，第一可以替代 Java 的接口，第二个也是对单继承机制的一种
补充。
trait 特质名 {
trait 主体
}
8、 特质和抽象类的区别
1）优先使用特质。一个类扩展多个特质是很方便的，但却只能扩展一个抽象类。
2）如果你需要构造函数参数，使用抽象类。因为抽象类可以定义带参数的构造函数，
而特质不行（有无参构造）。