一、Scala包
1、基本语法
package 包名
2、Scala 包的三大作用（和 Java 一样）
（1）区分相同名字的类
（2）当类很多时，可以很好的管理类
（3）控制访问范围
二、包说明
1、说明
Scala 有两种包的管理风格，一种方式和 Java 的包管理风格相同，每个源文件一个包（包名和源文件所在路径不要求必须一致），包名用“.”进行分隔以表示包的层级关系
2、案例实操：
// 定义父包
package com {
// 父包中的对象
object Parent {
val parentValue: String = "I'm from parent package"
}
// 定义子包
package child {
// 子包中的对象
object Child {
def main(args: Array[String]): Unit = {
// 子包访问父包内容，无需导包
println(Parent.parentValue)
}
}
}
}
// 另一个包，尝试访问 com 包下的内容
package other {
// 这里访问 com 包下子包内容，需要导包
object TryAccess {
def main(args: Array[String]): Unit = {
// 先导入 com.child.Child
import com.Parent
println(Parent.parentValue)
}
}
}
三、导包说明
1、和 Java 一样，可以在顶部使用 import 导入，在这个文件中的所有类都可以使用。
2、局部导入：什么时候使用，什么时候导入。在其作用范围内可以用
3、通配符导入：import java.util._
4、给类起名：import java.util.{ArrayList=>JL}
5、导入相同包的多个类：import java.util.{HashSet, ArrayList}
6、屏蔽类：import java.util.{ArrayList =>_,_}
7、导入包的绝对路径：new _root_.java.util.HashMap
四、属性
案例实操：
package com.example.demo
import scala.beans.BeanProperty
// 定义一个员工类
class Employee {
// 可变属性，员工姓名
var name: String = "Alice"
// 未初始化的可变属性，员工年龄，后续可赋值
var age: Int = 0
// 使用@BeanProperty注解，会自动生成setter和getter方法
@BeanProperty var department: String = "Engineering"
}
object Employee {
def main(args: Array[String]): Unit = {
val employee = new Employee()
println(employee.name)
// 设置年龄
employee.age = 30
println(employee.age)
// 使用自动生成的setter方法修改部门
employee.setDepartment("Marketing")
// 使用自动生成的getter方法获取部门
println(employee.getDepartment())
}
}
五、权限访问
1、说明
在 Java 中，访问权限分为：public，private，protected 和默认。在 Scala 中，你可以通过类似的修饰符达到同样的效果。但是使用上有区别。
（1）Scala 中属性和方法的默认访问权限为 public，但 Scala 中无 public 关键字。
（2）private 为私有权限，只在类的内部和伴生对象中可用。
（3）protected 为受保护权限，Scala 中受保护权限比 Java 中更严格，同类、子类可以访问，同包无法访问。
（4）private[包名]增加包访问权限，包名下的其他类也可以使用
2、案例实操：
// 定义动物类
class Animal {
private var species: String= "Dog" // 私有属性，动物种类
protected var age: Int = 3 // 受保护属性，年龄
def speak(): Unit = {
println(s"I'm a $species")
}
}
object Animal {
def main(args: Array[String]): Unit = {
val animal = new Animal()
animal.speak()
// 以下直接访问私有属性会报错
// println(animal.species)
// 以下直接访问受保护属性会报错
// println(animal.age)
}
}
// 定义狗类，继承自动物类
class Dog extends Animal {
def checkAge(): Unit = {
// 子类可访问父类受保护属性
println(s"My age is $age")
// 子类不能直接访问父类私有属性
// println(this.species)
}
}
六、构建器
和 Java 一样，Scala 构造对象也需要调用构造方法，并且可以有任意多个构造方法。Scala 类的构造器包括：主构造器和辅助构造器
1、说明
（1）辅助构造器，函数的名称 this，可以有多个，编译器通过参数的个数及类型来区分。
（2）辅助构造方法不能直接构建对象，必须直接或者间接调用主构造方法。
（3）构造器调用其他另外的构造器，要求被调用构造器必须提前声明。
2、案例实操
// 定义一个书籍类
class Book {
// 定义书籍的属性
var title: String = _
var author: String = _
var pages: Int = _
// 主构造器，无参数时小括号可省略
println("主构造器被调用")
}
// 第一个辅助构造器，接受页数参数
def this(pages: Int) {
this()
this.pages = pages
println(s"辅助构造器（传入页数：$pages）被调用")
}
// 第二个辅助构造器，接受标题和作者参数
def this(title: String, author: String) {
this()
this.title = title
this.author = author
println(s"辅助构造器（传入标题：$title，作者：$author）被调用")
}
// 第三个辅助构造器，接受标题、作者和页数参数
def this(title: String, author: String, pages: Int) {
this(title, author)
this.pages = pages
println(s"辅助构造器（传入标题：$title，作者：$author，页数：$pages）被调用")
}
}
object Book {
def main(args: Array[String]): Unit = {
// 使用不同构造器创建对象
val book1 = new Book(200)
val book2 = new Book("Scala Programming", "Martin Odersky")
val book3 = new Book("Effective Scala", "Josh Suereth", 300)
}
}
七、继承和多态
1、基本语法
（1）子类继承父类的属性和方法
（2）scala 是单继承
2、案例实操
// 定义一个形状类，作为父类
class Shape(color: String) {
var shapeColor: String = color
var area: Double = _
def this(color: String, sideLength: Double) {
this(color)
this.area = calculateArea(sideLength)
println("父类辅助构造器")
}
private def calculateArea(sideLength: Double): Double = {
sideLength * sideLength
}
println("父类主构造器")
}
// 定义一个正方形类，继承自形状类，作为子类
class Square(color: String, sideLength: Double) extends Shape(color, sideLength) {
var side: Double = sideLength
def this(color: String, sideLength: Double, additionalInfo: String) {
this(color, sideLength)
println(s"子类辅助构造器，额外信息：$additionalInfo")
}
println("子类主构造器")
}
object ShapeExample {
def main(args: Array[String]): Unit = {
val square = new Square("Red", 5.0, "This is a square")
}
}