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
  • 子类继承父类的属性和方法
  • 单继承
Prev
2023-08-09 14:53:19 # Big Data # Scala
Next