八、Scala类和对象

类

（一）类的定义

对象是类的具体实例，类是抽象的，不占用内存，而对象是具体的，占用存储空间。
面向对象三大特性之一：封装（encapsulation） - 封装数据和操作
Scala中一个简单的类定义是使用关键字class，类名必须大写。类中的方法用关键字def定义
创建User类，包含三个私有属性和一个公共方法

class User {
private var name = “张三丰”
private var gender = “男”
private var age = 25

def speak(): Unit = println(name + ", " + gender + ", 今年" + age + "岁了~")

单例对象

（一）单例对象概念

Scala中没有静态方法或静态字段，但是可以使用关键字object定义一个单例对象，单例对象中的方法相当于Java中的静态方法，可以直接使用“单例对象名.方法名”方式进行调用。单例对象除了没有构造器参数外，可以拥有类的所有特性。

（二）案例演示

创建Person单例对象，包含三个私有属性和一个公共方法

object Person {
private var name = “陈燕文”
private var gender = “女”
private var age = 18

def speak(): Unit = println(name + ", " + gender + ", 今年" + age + "岁了~")

}
直接通过单例对象名调用其speak()方法

伴生对象

（一）伴生对象概念

当单例对象的名称与某个类的名称一样时，该对象被称为这个类的伴生对象。类被称为该对象的伴生类。类和它的伴生对象必须定义在同一个文件中，且两者可以互相访问其私有成员。

（二）案例演示

package net.hw.obj

class Student {
private var name = “李明文”

def speak(): Unit = {
// 访问伴生对象的私有成员
println(name + “今年” + Student.age + “岁了。”)
}
}

object Student {
private var age = 18

def main(args: Array[String]): Unit = {
// 基于伴生类创建学生对象
val student = new Student()
// 访问伴生类对象的私有成员
println(“姓名：” + student.name)
// 调用伴生类对象的方法
student.speak()
}
}

get和set方法

（一）生成原则

Scala默认会根据类的属性的修饰符生成不同的get和set方法
1、val修饰的属性
系统会自动生成一个私有常量属性和一个公有get方法。
2、var修饰的属性
系统会自动生成一个私有变量属性和一对公有get/set方法。
3、private var修饰的属性
系统会自动生成一对私有get/set方法，相当于类的私有属性，只能在类的内部和伴生对象中使用。
4、private[this]修饰的属性
系统不会生成get/set方法，即只能在类的内部使用该属性。

（二）案例演示

任务1、利用系统自动生成的get和set方法
（1）创建Dog类
package net.hw.obj
class Dog {
val id: Int = 1 // 系统会自动生成公共的get方法
var name: String = “瑞瑞” // 系统会自动生成公共的get和set方法
private var gender: String = “公” // 系统会自动生成私有的get和set方法，只有伴生对象可以访问
private[this] var age: Int = 5 // 系统不会生成get和set方法，即使伴生对象也无法访问
}

构造器

Scala中的构造器分为主构造器和辅助构造器

（一）主构造器

1、构造器参数带val或var
主构造器的参数直接放在类名之后，且将被编译为类的成员变量，其值在初始化类时传入。注意，构造器参数必须指定类型
package net.hw.collection

class Person (val name: String, var age: Int = 18) {
def speak(): Unit = println(name + “今年” + age + “岁了~”)
}

/**

• 伴生对象
  */
  object Person {
  def main(args: Array[String]): Unit = {
  // 基于主构造器创建对象，传入两个参数值
  val person = new Person(“李文华”, 25)

  // 访问构造器参数，其实是访问成员属性
  println(“姓名：” + person.name)
  println(“年龄：” + person.age)

  // 调用对象的方法
  person.speak()

  // 修改对象属性（name属性不能改，age属性可以改）
  person.age_=(26)

  // 再次调用对象的方法
  person.speak()
  }
  }

抽象类

（一）抽象类的定义

Scala的抽象类使用关键字abstract定义
abstract class 类名 {

}

（二）抽象类的特征

抽象类不能被实例化。
抽象类中可以定义抽象字段（没有初始化的字段）和抽象方法（没有被实现的方法），也可以定义被初始化的字段和被实现的方法。
若某个子类继承了一个抽象类，则必须实现抽象类中的抽象字段和抽象方法，且实现的过程中可以添加override关键字，也可以省略。若重写了抽象类中已经实现的方法，则必须添加override关键字。

（三）案例演示

1、创建抽象类 - Person

package net.hw.absclass

abstract class Person {
var name: String // 抽象字段
var age: Int // 抽象字段
var address: String = “龙马潭区长桥路2号” // 普通字段

// 抽象方法
def speak()

// 普通方法
def walk(): Unit = {
print(name + “在散步~”)
}
}

2、继承抽象类，创建普通类 - Teacher

package net.hw.absclass

class Teacher extends Person {
// 实现抽象字段（可以不加override）
var name: String = “无心剑”
var age: Int = 50

// 实现抽象方法，不用加override
def speak(): Unit = {
println(name + “，今年” + age + “岁，家住” + address + “，擅长讲课与翻译。” )
}

// 重写普通方法，必须加override
override def walk(): Unit = {
println(name + “喜欢雨中漫步~”)
}
}

3、创建测试单例对象 - TestTeache

package net.hw.absclass

object TestTeacher {
def main(args: Array[String]): Unit = {
// 创建教师对象
val teacher = new Teacher()
// 调用对象方法
teacher.speak()
teacher.walk()
}
}

特质

1、创建宠物特质 - Pet

package net.hw.mytrait

trait Pet {
// 抽象字段
var name: String
var age: Int
// 抽象方法
def speak
// 普通方法
def eat: Unit = {
print(name + “在吃东西~”)
}
}

2、创建奔跑特质 - Runnable

package net.hw.mytrait

trait Runnable {
// 抽象方法
def run
}

3、创建飞翔特质 - Flyable

package net.hw.mytrait

trait Flyable {
// 抽象方法
def fly
}