面向对象
Scala的面向对象思想和Java的面向思想和概念是一致的。
Scala中语法和Java不同，补充了更多的功能。
Scala包
package 包名
三大作用：
- 区分相同名字的类
- 当类很多的时候，可以很好的管理类
- 控制访问范围
包的命名
只能包含数字、字母、下划线、小圆点，但不能用数字开头，也不要使用关键字。
一般是小写字母 + 小圆点
com.公司名.项目名.业务模块名
包说明
包对象
在Scala中可以为每个包定义一个同名的包对象，定义在包对象的中的成员，作为其对应包下所有class 和 object 的共享变量，可以被直接访问。
package object com {
val shareValue= "share"
def shareMethod() = {}
}
导包说明
- 和Java一样，可以在顶部使用import导入，在这个文件中的所有类都可以使用
- 局部导入，什么时候使用，什么时候导入。在其作用范围内都可以使用
- 通配符导入
import java.util._ - 给类起名
import java.util.{ArrayList => JL} - 导入相同包的多个类
import java.util.{HashSet, ArrayList} - 屏蔽类
import java.util.{ArrayList => _,_} - 导入包的绝对路径
import new_root_.java.util.ArrayListi
类和对象
类：可以看成一个模板
对象：表示具体的事物
定义类
Scala中没有public，一个Scala中可以写多个类
Scala语法中，类并不声明为public，所有这些类都具有公共可见性，即默认就是public
一个Scala源文件可以包含多个类
package chapter06
import scala.beans.BeanProperty
object Test03_Class {
def main(args: Array[String]): Unit = {
// 创建一个对象
val student = new Student()
// 不能通过以下的方式访问name属性，因为它是private
println(student.age)
println(student.sex)
student.setSex("male")
println(student.sex)
student.age = 20
println(student.getAge)
}
}
// 定义一个类
class Student{
// 定义属性
// 属性默认为public
// 增加注解添加getter和setter
private var name: String = "zihoo"
// @BeanProperty
// val age: Int = 18
//
// val sex: String = "male"
// var nullValue: String = _
@BeanProperty
var age: Int = _
@BeanProperty
var sex: String = _
}
封装
封装就是把抽象出的数据和数据的操作封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作（成员方法），才能对数据进行操作。
Scala中的public属性，底层实际为private，并通过get方法和set方法对其进行操作。所以Scala并不推荐将其属性设为private，再为其设置public的get和set方法的做法。
但由于很多Java框架都利用反射调用get和set的方法，有时候为了和这些框架兼容，也会通过@BeanProperty注解为类实现get和set的方法。
访问权限
Scala中属性和方法的默认访问权限为public，但是Scala中无public关键字。
private为私有权限，只有类的内部和伴生对象中可用。
protected为受保护权限，Scala中受保护权限比Java中更严格，同类、子类可以访问，同包无法访问。
private[包名] 增加包的访问权限，包名下的其它类也可以使用
package chapter06
object Test04_Access {
def main(args: Array[String]): Unit = {
// 创建对象
val person: Person = new Person()
// protected只能在子类或本类中可以访问
// person.name
println(person.age)
println(person.sex)
person.printInfo()
val worker: Worker = new Worker()
worker.printInfo()
}
}
class Worker extends Person {
override def printInfo(): Unit = {
name = "Worker"
age = 25
sex = "female"
println(s"Worker => {姓名：${name}, 性别：${sex}，年龄：${age}}")
}
}
方法
就是定义在类中的函数
def 方法名(参数列表) [: 返回值类型] = {
方法体
}
创建对象
和Java类似
val person: Person = new Person()
当使用修饰符 val 后，表示常量，也就是不可更改的。所有当使用person = new Person() 是不被允许的。但是可以修改person的属性值 person.age = 12 ，这样是被允许的。
构造器
和 Java一样，Scala构造对象也需要调用构造方法，并且可以有任意多个构造方法。
Scala的构造器包括：主构造器和辅助构造器
class 类名(形参列表) { // 主构造器
// 类体
def this(形参列表) { // 辅助构造器
}
def this(形参列表) { // 辅助构造器
}
}
辅助构造器，函数的名称this，可以有多个，编译器通过参数的个数及类型来区分
辅助构造方法不能直接构造对象，必须直接或者间接调用主构造方法
构造器调用其他另外的构造器，要求被调用的构造器必须提前声明
package chapter06
object Test05_Constructor {
def main(args: Array[String]): Unit = {
}
}
// 定义一个类
class Animal() {
// 定义属性
var name: String = _
var age: Int = _
println("1. 主构造方法调用")
def this(name: String, age: Int){
// 直接调用著构造器
this()
println("2. 辅助构造方法1被调用")
this.name = name
this.age = age
println(s"name: ${name}, age:${age}")
}
def this(name: String) {
this(name, 20)
println("3. 辅助构造方法2被调用")
}
}
构造器参数
Scala类的主构造器函数的形参包括三种类型：未用任何修饰符、var修饰符、val修饰符
- 未用任何修饰符，这个参数就是一个局部变量
- var修饰符，作为类的成员属性使用，可修改
- val修饰符，作为类的只读属性使用，不可修改
package chapter06
object Test06_ConstructorParams {
def main(args: Array[String]): Unit = {
val model = new ConstructorModel("zihoo", 21, 'M')
model.age = 20
// model.sex = 'W' 常量不可以修改
println(s"model => {age: ${model.age}, sex: ${model.sex}")
}
}
// 定义一个类
class ConstructorModel(name: String, var age: Int, val sex:Char)
继承和多态
class 子类名 extends 父类名 {
类体
}
子类继承父类的属性和方法
scala是单继承
package chapter06
object Test07_Inherit {
def main(args: Array[String]): Unit = {
val student = new Test07Student("zihoo", 21)
val student2 = new Test07Student("gazikel", 21, "20194077")
}
}
// 定义一个父类
class Test07Person {
var name: String = _
var age: Int = _
println("1. 父类的主构造器调用")
def this(name: String, age:Int) {
this()
println("2. 父类的辅助构造器调用")
this.name = name
this.age = age
}
def printInfo( ): Unit = {
println(s"Person => {${name}, ${age}")
}
}
// 定义子类
class Test07Student(name: String, age: Int) extends Test07Person {
var stuNo: String = _
println("3. 子类的主构造器调用")
def this(name: String, age:Int, stuNo:String) {
this(name, age)
println("4. 子类的辅助构造器调用")
this.stuNo = stuNo
}
override def printInfo(): Unit = {
println(s"Student => {${name}, ${age}, ${stuNo}")
}
}
在Java中，属性是静态绑定的。
而在Scala中，属性和方法都是动态绑定的。
package chapter06
object Test08_DynamicBind {
def main(args: Array[String]): Unit = {
val student: Test08Person = new Test08Student()
println(student.name)
student.hello()
}
}
class Test08Person() {
val name:String = "Person"
def hello(): Unit = {
println("Hello Person")
}
}
class Test08Student extends Test08Person {
override val name:String = "Student"
override def hello(): Unit = {
print("Hello Student")
}
}
抽象类
抽象属性和抽象方法
- 定义抽象类
abstract class Person {}，通过abstract关键字标记抽象类 - 定义抽象属性
val | var name: String，一个属性没有初始化，就是抽象属性 - 定义抽象方法
def hello(): String，只声明而没有实现的方法，就是抽象方法
只要存在了抽象属性或抽象方法，那么这个类一定是抽象类。
package chapter06
object Test09_AbstractClass {
def main(args: Array[String]): Unit = {
}
}
// 定义一个抽象类
abstract class Test09Person{
// 非抽象
val name: String = "Person"
def eat(): Unit = {
println("eat")
}
// 抽象
var age: Int
def sleep(): Unit
}
class Test09Student extends Test09Person {
// 实现抽象类和方法
var age: Int = 21
def sleep(): Unit = {
println("Student Sleep")
}
}
匿名子类
和Java一样，可以通过包含带有定义或重写代码块的方式创建一个匿名的子类
package chapter06
// 匿名子类
object Test10_AnnoymousClass {
def main(args: Array[String]): Unit = {
val person: Test10Person = new Test10Person {
override var name: String = "zihoo"
override def eat(): Unit = println("person eat")
}
println(person.name)
person.eat()
}
}
// 定义一个抽象类
abstract class Test10Person{
var name: String
def eat(): Unit
}
单例对象
Scala语言是完全面向对象的语言，所以并没有静态的操作(即在Scala中没有静态的概念)。但是为了能够和Java语言交互(因为Java中有静态概念)，就产生了一种特殊的对象来模拟类对象，该对象为单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明。
单例对象语法
object Person {
val country: String = "China"
}
单例对象采用object关键字声明
单例对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。
单例对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问。
package chapter06
object Test11_Object {
def main(args: Array[String]): Unit = {
val person: Test11Person = Test11Person.newPerson("zihoo", 21)
// 使用apply
val person2: Test11Person = Test11Person.apply("gazikel", 22)
// 在Scala的底层，如果使用apply方法创建对象的实例，那么我们可以省区aplly调用方法名，如下。
val person3: Test11Person = Test11Person("gazikel_apply", 23)
person3.printInfo()
}
}
// 构造方法私有化
class Test11Person private(var name: String, var age: Int) {
def printInfo(): Unit = {
println(s"Person => {${name}, ${age}, ${Test11Person.school}}")
}
}
object Test11Person {
val school: String = "atguigu"
// 定义一个创建类对象实例的方法
def newPerson(name: String, age: Int): Test11Person = new Test11Person(name, age)
def apply(name: String, age: Int): Test11Person = new Test11Person(name, age)
}
特质
Scala语言中，采用特质trait来代替接口的概念，也就是说，多个类具有相同的特质时，就可以将这个特质独立出来，采用关键字trait声明。
Scala中的trait中 既可以有抽象属性和方法，也可以有具体的属性和方法，一个类可以混入多个特质。这种感觉类似于Java中的抽象类。
Scala引入trait特质，第一可以替代Java的接口，第二个也是对单继承机制的一种补充。
特质声明
trait 特质名 {
trait主体
}
特质基本语法
一个类具有某种性质，就意味着这个类满足了这个特质的所有要素，所以在使用时，也采用了extends关键字，如果有多个特质或存在父类，那么采用with关键字进行连接。
# 没有父类
class 类名 extends 特质1 with 特质2 with 特质3
# 有父类
class 类名 extends 父类 with 特质1 with 特质2 with 特质3
package chapter06
object Test13_Trait {
def main(args: Array[String]): Unit = {
val student: Test13Student = new Test13Student()
student.study()
student.dating()
}
}
class Test13Person{
val name: String = "person"
var age: Int = 21
def sayHello(): Unit = {
println("Hello" + name)
}
}
// 定义一个特质
trait Young {
// 可以声明抽象或非抽象属性
var age: Int
val name: String = "young"
def play(): Unit = {
println("Young people is playing.")
}
def dating(): Unit
}
class Test13Student extends Test13Person with Young {
// 重写冲突的属性
override val name: String = "Student"
override def dating(): Unit = {
println(s"Student ${name} is dating.")
}
def study(): Unit = println(s"Student ${name} is studying")
override def sayHello(): Unit = {
super.sayHello()
println(s"Hello from Student ${name}")
}
}
特质的覆盖
父类和叠加的特征是平等的。当有相同的方法或属性时，后面的特征会覆盖前面的特征。
叠加顺序是从右到左。
如果遇到两个特征继承自同一个特征，则父特征在最右边。
super指的是此特征的叠加顺序的上一级。
如果想让super为父类，则需要写为 super[类名]
特征和抽象类的区别
1.优先使用特质。一个类扩展多个特质是很方便的，但却只能扩展一个抽象类。
2.如果你需要构造函数参数，使用抽象类。因为抽象类可以定义带参数的构造函数，而特质不行。
自身类型
自身类型可实现依赖注入功能
package chapter06
object Test16_TraitSelfType {
def main(args: Array[String]): Unit = {
val register: RegisterUesr = new RegisterUesr("zihoo", "123456")
register.insert()
}
}
// 定义一个用户类
class User(val name: String, val password: String)
trait UserDao {
// 自身属性
_: User =>
def insert(): Unit = {
println(s"insert into db values(${name}, ${password})")
}
}
class RegisterUesr(name: String, password: String) extends User(name, password) with UserDao {
}
扩展
类型检查和转换
obj.isInstanceOf[T]: 判断obj是不是T类型
obj.asInstanceOf[T]: 判断obj强转成T类型
classOf: 获取对象的类名
枚举类和应用类
枚举类：需要继承Enumeration
应用类：需要继承App
Type定义新类型
使用type关键字可以定义新的数据类型名称，本质上就是类型的一个别名。
object Test{
def main(args: Array[String]): Unit = {
type S = String
var v: S = "abc"
def test(): S = "xyz"
}
}