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)如果你需要构造函数参数,使用抽象类。因为抽象类可以定义带参数的构造函数,
而特质不行(有无参构造)。