Scala(4) 面向对象
2023-08-09 14:53:19 # Big Data # Scala

6. 面向对象

6.1 Scala包

6.1.1 包的命名

命名规则

只能包含数字、字母、下划线、小圆点,但不能用数字开头,也不要使用关键字。

命名规范

com.公司.项目.模块

6.1.2 包说明(包语句)

基础说明

Scala有两种包的管理风格,一种和Java的包管理风格相同,每个源文件一个包(包名和源文件所在路径不要求必须一致),用”.”进行分割表示包的层级关系

另一种风格,通过嵌套的风格表示层级关系

1
2
3
4
5
6
7
package com {
package whale {
package scala {

}
}
}

有以下特点:

  • 一个源文件中可以声明多个package
  • 子包中的类可以直接访问父包中的内容,而无需导包

案例实操

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com {
// 父包访问子包需要导包
import com.whale.Inner

object Outer {
val out: String = "out"

def main(args: Array[String]): Unit = {
println(Inner.in)
}
}

package whale {

object Inner {
val in: String = "in"

def main(args: Array[String]): Unit = {
println(Outer.out) // 子包访问父包无需导包
}
}
}
}

package other {
}

6.1.3 包对象

在Scala中可以为每个包定义一个同名的包对象,定义在包对象中的成员,作为其对应包下所有class和object的共享变量,可以被直接访问。

定义

1
2
3
4
package object com {
val shareValue = "share"
def shareMethod() = {}
}

说明

  1. 若使用Java的包管理风格,则包对象一般定义在其对应包下的packageName.scala文件中,包对象名与包名保持一致

    image-20220925121142605

  2. 如采用嵌套方式管理包,则包对象可与包定义在同一文件,但是要保证包对象与包声明在同一作用域

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    package com {

    object Outer {
    val out: String = "out"

    def main(args: Array[String]): Unit = {
    println(name)
    }
    }
    }

    package object com {
    val name: String = "com"
    }

6.1.4 导包说明

  • 可以在顶部使用import导入,在这个文件中的所有类都可以使用
  • 局部导入:什么时候使用,什么时候导入。在作用范围内都可以使用

  • 通配符导入:import java.util._

  • 给类起名:import java.util.{ArrayList => JL}
  • 导入相同包的多个类:import java.util.{HashSet, ArrayList}
  • 屏蔽类:import java.util.{ArrayList => _, _}
  • 导入包的绝对路径:new _root_.java.util.HashMap

注意

Scala中的三个默认导入

  • import java.lang._
  • import scala._
  • import scala.Predef._

6.1.5 访问权限

  • Scala中属性和方法的默认访问权限为public,但Scala中无public关键字
  • private为私有权限,只有在类的内部和伴生对象中可用
  • protected为受保护权限,比Java中更严格,同类、子类可以访问,同包无法访问
  • private [包名]增加包访问权限,包名下的其他类也可以使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package com.whale.scalademo.chapter6

class Person {

private var name: String = "tony"
protected var age: Int = 18
private [chapter6] var sex: String = "男"

def say(): Unit = {
println(name)
}
}

object Person {
def main(args: Array[String]): Unit = {
val person = new Person
person.say()
println(person.name)
println(person.age)
println(person.sex)
}
}

class Teacher extends Person {
def test(): Unit = {
this.age
this.sex
}
}

class Animal {
def test(): Unit = {
new Person().sex
}
}

6.2 类和对象

6.2.1 定义类

回顾

Java中,public类的类名与文件名一致,且一个.java文件只有一个public类

Scala中没有public关键字,一个.scala文件可以写多个类

基本语法

[修饰符] class 类名 {

​ 类体

}

  • Scala语法中,类并不声明为public,所有这些类都具有公有可见性(即默认为public)
  • 一个Scala源文件可以包含多个类

6.2.2 属性

基本语法

[修饰符] val|var 属性名 [: 类型] = 属性值

注:Bean属性(@BeanProperty)可以自动生成规范的set/get方法

案例实操

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Person {

var name: String = "tony"
var age: Int = _ // _ 表示给属性一个默认值

// Bean属性
@BeanProperty var sex: String = "男"
// val 修饰的属性不能赋默认值,必须显式指定
}

object Person {
def main(args: Array[String]): Unit = {
var person = new Person
println(person.name)
person.setSex("女")
println(person.getSex)
}
}

6.2.3 方法

基本语法

def 方法名(参数列表)[: 返回值类型] = {

​ 方法体

}

6.2.4 创建对象

基本语法

val|var 对象名 [: 类型] = new 类型()

注意事项

  • val修饰对象,不能改变对象的引用(即内存地址),可以改变对象属性的值
  • var修饰对象,可以修改引用和属性值
  • 自动推导变量类型不能堕胎,所以多态需要显式声明

6.2.5 构造器

Scala类的构造器包括:主构造器和辅助构造器

基本语法

class 类名(形参列表) { // 主构造器

​ def this(形参列表){} // 辅助构造器

​ def this(形参列表){} // 辅助构造器可以有多个

}

  • 辅助构造器,函数名this,可以有多个,编译器通过参数的个数及类型来区分
  • 辅助构造方法不能直接构建对象,必须直接或者简介调用主构造方法
  • 构造器调用其他的构造器,要求被调用构造器必须提前声明
  • 如果主构造器无参数,小括号可以省略,构建对象时调用的构造方法的小括号也可以省略

案例实操

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// class Person() {
class Person {

var name: String = _
var age: Int = _

def this(age: Int) {
this()
this.age = age
println("辅助构造器")
}

def this(age: Int, name: String) {
this(age)
this.name = name
}

println("主构造器")
}

6.2.6 构造器参数

说明

Scala类的主构造器函数的形参包括三种类型:未用任何修饰、var修饰、val修饰

  • 未用任何修饰符修饰,这个参数就是一个局部变量
  • var修饰参数,作为类的成员属性使用,可以修改
  • val修饰参数,作为类只读属性使用,不能修改

案例实操

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Person(name: String, var age: Int, val sex: String) {

}

object Test {
def main(args: Array[String]): Unit = {
var person = new Person("bob", 18, "男")
// 未用任何修饰符修饰,这个参数就是一个局部变量
// println(person.name)

// var修饰参数,作为类的成员属性使用,可以修改
person.age = 19
println(person.age)
// val修饰参数,作为类只读属性使用,不能修改
// person.sex = "女"
println(person.sex)
}
}

6.3 封装

Scala中的public属性,底层实际为private,并通过get方法(obj.field())和set方法(obj.field_=(value))对其进行操作。所以Scala并不推荐将属性设为private,再设置public的get和set方法。

但由于很多Java框架都利用反射调用setXXX和getXXX方法,有时为了兼容,也会为Scala的属性设置get和set方法(通过@BeanProperty)

6.4 继承和多态

基本语法

  • entends
  • 子类继承父类的属性和方法
  • 单继承