类（class）
类是对象的模板，主要由方法和属性构成。
声明定义
语法：
class 类名{
//属性
//方法
}
class User{
//属性
var id;Int = 10
var name:String = "xiaohei"
//方法（等同于函数）
def sayHi(name:String):String - {
"Hello" + name
}
}
创建类
语法： new 类名
var user = new User()
user.id = 20
println(user,id + "\t" + user.name)
注意：
- 在scala中的类中所有属性都是私有的，不能通过属性名完成操作
- 属性的操作最终都会变成属性的Getter和Setter方法的操作
总结
- Scala中的属性都是私有的成员
var修饰的变量，属性私有并且提供公开的Getter(属性名 ())/Setter(属性名 _$eq)方法val修饰的变量，属性私有并且提供公开的Getter方法而没有Setter方法。private var私有的变量，属性私有并且提供私有的Getter和Setter方法。private val私有的产量，属性私有并且提供私有的Getter方法而没有Setter方法。
@BeanProperty
注解主要作用：自动产生Java和Scala风格的Getter/Setter方法，用于java和scala类库兼容。
class Cat{
@BeanProperty
var id : Int =_
@BeanProperty
var name : String =_
}
object CatTest{
def main(args: Array[String]): Unit = {
//java style
val cat = new Cat()
cat.setId(1)
cat.setName("小黑")
println(cat.getId + "\t" + cat.getName)
//scala style
val cat2 = new Cat()
cat2.id=2
cat2.name="小白"
println(cat2.id + "\t" + cat2.name)
}
}
方法
重载
同一个类中方法名相同参数列表不同（个数，类型，顺序）的乙烯类方法成为重载方法。
class Student {
def m1(): Unit ={
}
def m1(x:Int):Unit = {
}
def m1(x:Int,y:String): Unit ={
}
def m1(y:String,x:Int): Unit ={
}
}
成员变量和局部变量
class Student {
// 成员变量
var name: String = _
def m1(): Unit = {
// 局部变量（优先）
val name: String = "zs"
println(name) // zs
// 如何获取成员变量
println(this.name) // null
}
}
构造方法
辅助构造器
类似于java重载的构造方法，在Scala类中有一个主构造器（Primary Constructor）和若干个辅助构造器。
- 辅助构造器必须为this。
- 辅助构造器必须以调用一个主构造器或者其他辅助构造器作为开始。
class Car{
var name: String =_
var color: String =_
//构造方法重载（辅助构造器）
def this(name : String){
this()
this.name = name
}
def this(name:String,color:String){
this(name)
this.color =color
}
}
主构造器
默认提供一个无参主构造器，也允许用户自定义主构造器。主构造器得定义和类的定义交织在一起。
// 有一个参数的主构造器
// 属性私有 提供公开getter/setter方法 遵循属性结论
class Bus(var name: String){
var color : String =_
def this(name :String,color: String){
this(name)
this.color=color
}
}
作用范围
主构造器的作用范围是整个类体，属性和方法仅仅只是生命并不会理解执行，而对于其他内容，在每一次创建对象时都会执行。
class Bus(var name: String){
println("----start----")
var color: String =_
def this(name: String,color:String){
this(name)
this.color = color
}
println("----end----")
}
单例对象（object）
Scala中没有static关键字，可以试用object实现等同效果目的。
object IdFactory{
//单例对象：JVM只会有一个实例
//静态属性
private var id: Int = 0
//静态方法
def getId():Int ={
this.id += 1
this.id
}
}
注意：
- 声明单例对象只需要将类声明为object即可。
- object单例对象中的成员都是静态的。
伴生对象和伴生类
在一个Scala的源文件中，类名和单例类的名字相同，则将类成为伴生类，单例类成为伴生对象。
//伴生类中 可以调用伴生对象的私有，公开 成员
class Cat {
var age: Int = _
def this(age: Int) {
this()
println(Cat.id)
println(Cat.color)
this.age = age
}
}
// 伴生对象
object Cat {
private var id: Int = 10
var color: String = "white"
}
注意：类加载的顺序，现有静态成员的加载初始化，再有普通成员的加载初始化。
apply和unapply方法
伴生对象中的apply方法，实际上是一个工厂方法，用以构建伴生类。
特点：通过伴生独享的apply方法 通过值创建一个伴生类
class Snake {
var length: Double = _
var color: String = _
def this(length: Double, color: String) {
this()
this.length = length
this.color = color
}
}
object Snake {
/**
* apply 工厂方法 创建伴生类
*
* 接受参数 ---> new 伴生类
*/
def apply(length: Double, color: String): Snake = new Snake(length, color)
def main(args: Array[String]): Unit = {
val snake = new Snake(10.0, "black")
val snake2 = Snake.apply(20.0, "white")
// 简化,自动调用伴生对象中的apply方法
val snake3 = Snake(30.0, "gray")
val snake4 = Snake(30.0, "gray")
println(snake3 == snake4) // false
// 数组
val arr = Array(1,2,3,4,5)
}
}
unapply是apply方法逆向操作，主要作用传递一个伴生类，从伴生类中提取值。
特点：通过伴生对象的unapply方法，从伴生类中提取值。
class Snake {
var length: Double = _
var color: String = _
def this(length: Double, color: String) {
this()
this.length = length
this.color = color
}
}
object Snake {
/**
* apply 工厂方法 创建伴生类
*
* 接受参数 ---> new 伴生类
*/
def apply(length: Double, color: String): Snake = new Snake(length, color)
/**
* unapply方法(模式匹配中)
* 伴生类 ---> 提取值
*/
def unapply(snake: Snake): Option[(Double, String)] = {
// option(有值或者无值父类对象)
if (snake == null) {
// 没有提取到任何的值
None
} else {
val length = snake.length
val color = snake.color
Some((length, color))
}
}
def main(args: Array[String]): Unit = {
val snake = new Snake(10.0, "black")
val snake2 = Snake.apply(20.0, "white")
// 简化,自动调用伴生对象中的apply方法
val snake3 = Snake(30.0, "gray")
val snake4 = Snake(30.0, "gray")
println(snake3 == snake4) // false
// 数组
val arr = Array(1, 2, 3, 4, 5)
val list = List(1, 2, 3, 4, 5)
//----------------------------------------------
// 传统写法
val option = Snake.unapply(snake3)
val value = option.get
println(value)
// 其它写法 自动将snake3应用unapply方法 并且会将提取到值赋值给a和b变量
val Snake(a, b) = snake3
println(a)
println(b)
}
}