类和对象

scala是支持面向对象的，也有类和对象的概念。我们依然可以基于scala语言来开发面向对象的应用程序。

创建类和对象

语法

使用class来定义一个类
使用new来创建对象

示例说明

创建一个Person类，并创建它的对象

步骤

创建一个scala项目，并创建一个Object
添加main方法
创建类和对象

实现

在IDEA中创建项目，并创建一个Object（main方法必须放在Object中）
添加main方法
创建一个Person类
在main方法中创建Person类对象

object _01ClassDemo {
  // 创建类
  class Person{}

  def main(args: Array[String]): Unit = {
    // 创建对象
    val p = new Person()
    println(p)
  }
}

简写方法

如果类是空的，没有任何成员，可以省略{}
如果构造器的参数为空，可以省略()

object _02ClassDemo {

  // 创建类，省略花括号
  class Person

  def main(args: Array[String]): Unit = {
    // 创建对象，省略括号
    val person = new Person
  }
}

定义和访问成员变量

一个类会有自己的属性，例如：人这样一个类，有自己的姓名和年龄。我们接下来学习在类中定义、和访问成员变量。

语法：

在类中使用var/val来定义成员变量
对象直接使用成员变量名称来访问成员变量

示例说明

定义一个Person类，包含一个姓名和年龄字段
创建一个名为"张三"、年龄为20岁的对象
打印对象的名字和年龄

步骤

创建一个Object，添加main方法
创建Person类，添加姓名字段和年龄字段，并对字段进行初始化，让scala自动进行类型推断
在main方法中创建Person类对象，设置成员变量为"张三"、20
打印对象的名字和年龄

object _03ClassDemo {
  class Person {
    // 定义成员变量
    var name = ""
    var age = 0
  }

  def main(args: Array[String]): Unit = {
    // 创建Person对象
    val person = new Person
    person.name = "zhangsan"
    person.age = 20

    // 获取变量值
    println(person.name)
    println(person.age)
  }
}

使用下划线初始化成员变量

语法

在定义var类型的成员变量时，可以使用_来初始化成员变量
- String => null
- Int => 0
- Boolean => false
- Double => 0.0
- ...
val类型的成员变量，必须要自己手动初始化

示例说明

定义一个Person类，包含一个姓名和年龄字段
创建一个名为"张三"、年龄为20岁的对象
打印对象的名字和年龄

步骤

创建一个Object，添加main方法
创建Person类，添加姓名字段和年龄字段，指定数据类型，使用下划线初始化
在main方法中创建Person类对象，设置成员变量为"张三"、20
打印对象的名字和年龄

object _04ClassDemo {

  class Person{
    // 使用下划线进行初始化
    var name:String = _
    var age:Int = _
  }

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

定义成员方法

语法

在scala的类中，也是使用def来定义成员方法

示例说明

创建一个Customer类
创建一个该类的对象，并调用printHello方法

步骤

创建一个Object，添加main方法
创建Customer类，添加成员变量、成员方法
在main方法中创建Customer类对象，设置成员变量值(张三、男)
调用成员方法

object _05ClassDemo {

  class Customer {
    var name:String = _
    var sex:String = _

    // 定义成员方法
    def sayHi(msg:String) = {
      println(msg)
    }
  }

  def main(args: Array[String]): Unit = {
    val customer = new Customer
    customer.name = "张三"
    customer.sex = "男"
    customer.sayHi("你好")
  }
}

访问修饰符

和Java一样，scala也可以通过访问修饰符，来控制成员变量和成员方法是否可以被访问。

语法

Java中的访问控制，同样适用于scala，可以在成员前面添加private/protected关键字来控制成员的可见性。但在scala中，没有public关键字，任何没有被标为private或protected的成员都是公共的

示例说明*

定义一个Person类
在main方法中创建该类的对象，测试是否能够访问到私有成员

object _02AccessDemo {

  class Person {
    // 定义私有成员变量
    private var name:String = _
    private var age:Int = _

    def getName() = name
    def setName(name:String) = this.name = name
    def getAge() = age
    def setAge(age:Int) = this.age = age

    // 定义私有成员方法
    private def getNameAndAge = {
      name -> age
    }
  }

  def main(args: Array[String]): Unit = {
    val person = new Person
    person.setName("张三")
    person.setAge(10)

    println(person.getName())
    println(person.getAge())
  }
}

类的构造器

当创建类对象的时候，会自动调用类的构造器。之前使用的都是默认构造器，我们接下来要学习如何自定义构造器。

语法

class 类名(var/val 参数名:类型 = 默认值, var/val 参数名:类型 = 默认值){
    // 构造代码块
}

示例说明

定义一个Person类，通过主构造器参数列表定义姓名和年龄字段，并且设置它们的默认值
在主构造器中输出"调用主构造器"
创建"张三"对象（姓名为张三，年龄为20），打印对象的姓名和年龄
创建"空"对象，不给构造器传入任何的参数，打印对象的姓名和年龄
创建"man40"对象，不传入姓名参数，指定年龄为40，打印对象的姓名和年龄

object _06ConstructorDemo {

  // 定义类的主构造器
  // 指定默认值
  class Person(var name:String = "", var age:Int = 0) {
    println("调用主构造器")
  }

  def main(args: Array[String]): Unit = {
    // 给构造器传入参数
    val zhangsan = new Person("张三", 20)
    println(zhangsan.name)
    println(zhangsan.age)

    println("---")

    // 不传入任何参数
    val empty = new Person
    println(empty.name)
    println(empty.age)

    println("---")

    // 指定字段进行初始化
    val man40 = new Person(age = 40)
    println(man40.name)
    println(man40.age)
  }
}

辅助构造器

在scala中，除了定义主构造器外，还可以根据需要来定义辅助构造器。例如：允许通过多种方式，来创建对象，这时候就可以定义其他更多的构造器。我们把除了主构造器之外的构造器称为辅助构造器。

定义辅助构造器与定义方法一样，也使用def关键字来定义
这个方法的名字为this

def this(参数名:类型, 参数名:类型) {
    // 第一行需要调用主构造器或者其他构造器
    // 构造器代码
}

示例说明

定义一个Customer类，包含一个姓名和地址字段
定义Customer类的主构造器（初始化姓名和地址）
定义Customer类的辅助构造器，该辅助构造器接收一个数组参数，使用数组参数来初始化成员变量
使用Person类的辅助构造器来创建一个"zhangsan"对象
- 姓名为张三
- 地址为北京
打印对象的姓名、地址

object _07ConstructorDemo {

  class Customer(var name:String = "", var address:String = "") {
    // 定义辅助构造器
    def this(arr:Array[String]) = {
      // 辅助构造器必须要调用主构造器或者其他辅助构造器
      this(arr(0), arr(1))
    }
  }

  def main(args: Array[String]): Unit = {
    val zhangsan = new Customer(Array("张三", "北京"))

    println(zhangsan.name)
    println(zhangsan.address)
  }
}

辅助构造器相当于扩展主构造器的属性，比如说我们还需要将customer中添加一个sex属性，那么我们则可以在Customer中再去写一个扩展类。

def this(var name:String="",var address:String="",var sex:String=""){
    def this(var name:String,var address:String,var sex:String){
        this.sex = sex
    }
}

单例对象

scala中没有Java中的静态成员，我们想要定义类似于Java的static变量、static方法，就要使用到scala中的单例对象——object.

单例对象表示全局仅有一个对象（类似于Java static概念）

定义单例对象和定义类很像，就是把class换成object
在object中定义的成员变量类似于Java的静态变量
可以使用object直接引用成员变量

示例说明

定义一个Dog单例对象，保存狗有几条腿
在main方法中打印狗腿的数量

object _08ObjectDemo {

  // 定义一个单例对象
  object Dog {
    // 定义腿的数量
    val LEG_NUM = 4
  }

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

在单例对象中定义成员方法

示例说明

设计一个单例对象，定义一个能够打印分割线（15个减号）的方法
在main方法调用该方法，打印分割线

object _09ObjectDemo {

  object PrintUtil {

    // 打印分割线
    def printSpliter() = {
      // 字符串乘法，表示返回多少个字符串
      println("-" * 10)
    }
  }

  def main(args: Array[String]): Unit = {
    PrintUtil.printSpliter()
  }
}

工具类案例

编写一个DateUtil工具类专门用来格式化日期时间
定义一个方法，用于将日期（Date）转换为年月日字符串，例如：2030-10-05

object _10ObjectDemo {

  object DateUtils {
    // 在object中定义的成员变量，相当于Java中定义一个静态变量
    // 定义一个SimpleDateFormat日期时间格式化对象
    val simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm")

    // 相当于Java中定义一个静态方法
    def format(date: Date) = simpleDateFormat.format(date)
  }

  // main是一个静态方法，所以必须要写在object中
  def main(args: Array[String]): Unit = {
    println(DateUtils.format(new Date()))
  }
}

伴生对象

在Java中，经常会有一些类，同时有实例成员又有静态成员。例如：

public class CustomerService {

    private static String SERVICE_NAME = "CustomerService";

    public void save() {
        // 保存客户
        System.out.println(SERVICE_NAME + ":保存客户");
    }

    public static void main(String[] args) {
        new CustomerService().save();
    }
}

一个class和object具有同样的名字。这个object称为伴生对象，这个class称为伴生类

伴生对象必须要和伴生类一样的名字
伴生对象和伴生类在同一个scala源文件中
伴生对象和伴生类可以互相访问private属性

示例说明

编写一个CustomerService类，有一个save方法，打印
```
服务类名称:保存客户
```
编写一个CustomerService伴生对象，定义一个私有变量，用于保存服务类名称
创建CustomerService对象，调用save方法

object _11ObjectDemo {

  class CustomerService {
    def save() = {
      println(s"${CustomerService.SERVICE_NAME}:保存客户")
    }
  }

  // CustomerService的伴生对象
  object CustomerService {
    private val SERVICE_NAME = "CustomerService"
  }

  def main(args: Array[String]): Unit = {
    val customerService = new CustomerService()
    customerService.save()
  }
}

伴生对象 | apply方法

我们之前使用过这种方式来创建一个Array对象。

// 创建一个Array对象
val a = Array(1,2,3,4)

这种写法非常简便，不需要再写一个new，然后敲一个空格，再写类名。我们可以通过伴生对象的apply方法来实现。

定义apply方法

object 伴生对象名 {
    def apply(参数名:参数类型, 参数名:参数类型...) = new 类(...)
}

示例

定义一个Person类，它包含两个字段：姓名和年龄
重写apply方法，使用Person类名就可以创建对象
在main方法中创建该类的对象，并打印姓名和年龄

object _12ApplyDemo {
  class Person(var name:String = "", var age:Int = 0)

  object Person {
    // 定义apply方法，接收两个参数
    def apply(name:String, age:Int) = new Person(name, age)
  }

  def main(args: Array[String]): Unit = {
    // 使用伴生对象名称来创建对象
    val zhangsan = Person("张三", 20)
    println(zhangsan.name)
    println(zhangsan.age)
  }
}

继承

scala语言是支持面向对象编程的，我们也可以使用scala来实现继承，通过继承来减少重复代码。

定义语法

scala和Java一样，使用extends关键字来实现继承
可以在子类中定义父类中没有的字段和方法，或者重写父类的方法
类和单例对象都可以从某个父类继承

class/object 子类 extends 父类 {
    ..
}

示例说明

定义一个Person类，再定义一个Student类，继承自Person类

创建一个Student类对象实例，并设置name为“张三”
打印姓名

class Person {
  var name = "super"

  def getName = this.name
}

class Student extends Person

object Main13 {
  def main(args: Array[String]): Unit = {
    val p1 = new Person()
    val p2 = new Student()

    p2.name = "张三"

    println(p2.getName)
  }
}

override和super

类似于Java语言，我们在子类中使用override需要来重写父类的成员，可以使用super来引用父类

子类要覆盖父类中的一个方法，必须要使用override关键字
使用override来重写一个val字段
使用super关键字来访问父类的成员方法

示例说明
- 定义一个Person类，包含
  - 姓名字段（不可重新赋值）
  - 获取姓名方法
- 定义一个Student类
  - 重写姓名字段
  - 重写获取姓名方法，返回"hello, " + 姓名
- 创建Student对象示例，调用它的getName方法

class Person {
  val name = "super"

  def getName = name
}

class Student extends Person {
  // 重写val字段
  override val name: String = "child"

  // 重写getName方法
  override def getName: String = "hello, " + super.getName
}

object Main13 {
  def main(args: Array[String]): Unit = {
    println(new Student().getName)
  }
}

类型判断

1557152463629

scala中对象提供isInstanceOf和asInstanceOf方法。

isInstanceOf判断对象是否为指定类的对象
asInstanceOf将对象转换为指定类型

// 判断对象是否为指定类型
val trueOrFalse:Boolean = 对象.isInstanceOf[类型]
// 将对象转换为指定类型
val 变量 = 对象.asInstanceOf[类型]

示例说明

定义一个Person类
定义一个Student类继承自Person类
创建一个Student类对象
判断该对象是否为Student类型，如果是，将其转换为Student类型并打印该对象

class Person3
class Student3 extends Person3

object Main3 {
  def main(args: Array[String]): Unit = {
    val s1:Person3 = new Student3

    // 判断s1是否为Student3类型
    if(s1.isInstanceOf[Student3]) {
      // 将s1转换为Student3类型
      val s2 =  s1.asInstanceOf[Student3]
      println(s2)
    }
  }
}

getClass和classOf

isInstanceOf 只能判断对象是否为指定类以及其子类的对象，而不能精确的判断出，对象就是指定类的对象。如果要求精确地判断出对象就是指定类的对象，那么就只能使用 getClass 和 classOf 。

p.getClass可以精确获取对象的类型
classOf[x]可以精确获取类型
使用==操作符可以直接比较类型

示例说明

定义一个Person类
定义一个Student类继承自Person类
创建一个Student类对象，并指定它的类型为Person类型
测试使用isInstance判断该对象是否为Person类型
测试使用getClass/classOf判断该对象是否为Person类型
测试使用getClass/classOf判断该对象是否为Student类型

class Person4
class Student4 extends Person4

object Student4{
  def main(args: Array[String]) {
    val p:Person4=new Student4
    //判断p是否为Person4类的实例
    println(p.isInstanceOf[Person4])//true

    //判断p的类型是否为Person4类
    println(p.getClass == classOf[Person4])//false

    //判断p的类型是否为Student4类
    println(p.getClass == classOf[Student4])//true
  }
}

抽象类

如果类的某个成员在当前类中的定义是不包含完整的，它就是一个抽象类

不完整定义有两种情况：

方法没有方法体（抽象方法）
变量没有初始化（抽象字段）

示例

1552449400240

设计4个类，表示上述图中的继承关系
每一个形状都有自己求面积的方法，但是不同的形状计算面积的方法不同

步骤

创建一个Shape抽象类，添加一个area抽象方法，用于计算面积
创建一个Square正方形类，继承自Shape，它有一个边长的主构造器，并实现计算面积方法
创建一个长方形类，继承自Shape，它有一个长、宽的主构造器，实现计算面积方法
创建一个圆形类，继承自Shape，它有一个半径的主构造器，并实现计算面积方法
编写main方法，分别创建正方形、长方形、圆形对象，并打印它们的面积

// 创建形状抽象类
abstract class Shape {
  def area:Double
}

// 创建正方形类
class Square(var edge:Double /*边长*/) extends Shape {
  // 实现父类计算面积的方法
  override def area: Double = edge * edge
}

// 创建长方形类
class Rectangle(var length:Double /*长*/, var width:Double /*宽*/) extends Shape {
  override def area: Double = length * width
}

// 创建圆形类
class Cirle(var radius:Double /*半径*/) extends Shape {
  override def area: Double = Math.PI * radius * radius
}

object Main6 {
  def main(args: Array[String]): Unit = {
    val s1:Shape = new Square(2)
    val s2:Shape = new Rectangle(2,3)
    val s3:Shape = new Cirle(2)

    println(s1.area)
    println(s2.area)
    println(s3.area)
  }
}

抽象字段

在scala中，也可以定义抽象的字段。如果一个成员变量是没有初始化，我们就认为它是抽象的。

示例说明

创建一个Person抽象类，它有一个String抽象字段WHO_AM_I
创建一个Student类，继承自Person类，重写WHO_AM_I字段，初始化为学生
创建一个Policeman类，继承自Person类，重写WHO_AM_I字段，初始化警察
添加main方法，分别创建Student/Policeman的实例，然后分别打印WHO_AM_I

// 定义一个人的抽象类
abstract class Person6 {
  // 没有初始化的val字段就是抽象字段
  val WHO_AM_I:String
}

class Student6 extends Person6 {
  override val WHO_AM_I: String = "学生"
}

class Policeman6 extends Person6 {
  override val WHO_AM_I: String = "警察"
}

object Main6 {
  def main(args: Array[String]): Unit = {
    val p1 = new Student6
    val p2 = new Policeman6

    println(p1.WHO_AM_I)
    println(p2.WHO_AM_I)
  }
}

匿名内部类

匿名内部类是没有名称的子类，直接用来创建实例对象。Spark的源代码中有大量使用到匿名内部类。

示例说明

创建一个Person抽象类，并添加一个sayHello抽象方法
添加main方法，通过创建匿名内部类的方式来实现Person
调用匿名内部类对象的sayHello方法

abstract class Person7 {
  def sayHello:Unit
}

object Main7 {
  def main(args: Array[String]): Unit = {
    // 直接用new来创建一个匿名内部类对象
    val p1 = new Person7 {
      override def sayHello: Unit = println("我是一个匿名内部类")
    }
    p1.sayHello
  }
}

特质(trait)

scala中没有Java中的接口（interface），替代的概念是——特质

特质是scala中代码复用的基础单元
它可以将方法和字段定义封装起来，然后添加到类中
与类继承不一样的是，类继承要求每个类都只能继承一个超类，而一个类可以添加任意数量的特质。
特质的定义和抽象类的定义很像，但它是使用trait关键字

定义特质

trait 名称 {
    // 抽象字段
    // 抽象方法
}

继承特质

class 类 extends 特质1 with 特质2 {
    // 字段实现
    // 方法实现
}

使用extends来继承trait（scala不论是类还是特质，都是使用extends关键字）
如果要继承多个trait，则使用with关键字

示例 | 继承单个trait

示例说明

创建一个Logger特质，添加一个接受一个String类型参数的log抽象方法
创建一个ConsoleLogger类，继承Logger特质，实现log方法，打印消息
添加main方法，创建ConsoleLogger对象，调用log方法

trait Logger {
    // 抽象方法
    def log(message:String)
  }

  class ConsoleLogger extends Logger {
    override def log(message: String): Unit = println("控制台日志:" + message)
  }

  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLogger
    logger.log("这是一条日志")
  }

示例 | 继承多个trait

示例说明

创建一个MessageSender特质，添加send方法
创建一个MessageReceiver特质，添加receive方法
创建一个MessageWorker实现这两个特质
在main中调用，分别调用send方法、receive方法

trait MessageSender {
    def send(msg:String)
}

trait MessageReceive {
    def receive():String
}

class MessageWorker extends MessageSender with MessageReceive {
    override def send(msg: String): Unit = println(s"发送消息:${msg}")

    override def receive(): String = "你好！我叫一个好人！"
}

def main(args: Array[String]): Unit = {
    val worker = new MessageWorker
    worker.send("hello")
    println(worker.receive())
}

示例 | object继承trait

示例说明

创建一个Logger特质，添加一个log抽象方法
创建一个ConsoleLogger的object，实现LoggerForObject特质，实现log方法，打印消息
编写main方法，调用ConsoleLogger的log方法

trait Logger {
    def log(message:String)
}

object ConsoleLogger extends Logger {
    override def log(message: String): Unit = println("控制台消息:" + message)
}

def main(args: Array[String]): Unit = {
    ConsoleLogger.log("程序退出!")
}

特质 | 定义具体的方法

示例说明

定义一个Logger特质，添加log实现方法
定义一个UserService类，实现Logger特质
添加add方法，打印"添加用户"
添加main方法
创建UserService对象实例
调用add方法

trait LoggerDetail {
  // 在trait中定义具体方法
  def log(msg:String) = println(msg)
}

class UserService extends LoggerDetail {
  def add() = log("添加用户")
}

object MethodInTrait {
  def main(args: Array[String]): Unit = {
    val userService = new UserService
    userService.add()
  }
}

在trait中可以定义具体字段和抽象字段
继承trait的子类自动拥有trait中定义的字段
字段直接被添加到子类中

步骤

创建Logger特质
- 定义一个SimpleDateFormat字段，用来格式化日期（显示到时间）
- 定义一个TYPE抽象字段，用于定义输出的信息
- 创建一个log抽象方法，用于输出日志
创建ConsoleLogger类，实现TYPE抽象字段和log方法
添加main方法

创建ConsoleLogger类对象
调用log方法

 trait Logger {
    val sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm")
    def log(msg:String)
  }

  class ConsoleLogger extends Logger {
    override def log(msg: String): Unit = {
      val info = s"${sdf.format(new Date())}:控制台消息:${msg}"
      println(info)
    }
  }

  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLogger()
    logger.log("NullPointerException")
  }

实现模板模式

示例说明

编写一个日志输出工具，分别有info、warn、error三个级别的日志输出
日志输出的方式要求设计为可扩展的，例如：可以输出到控制台、将来也可以扩展输出到文件、数据库等

实现步骤

添加一个Logger特质
- 添加一个log抽象方法
- 添加一个info、warn、error具体方法，这几个方法调用log抽象方法
创建ConsoleLogger类，实现Logger特质
添加main方法
- 创建ConsoleLogger类对象
- 分别调用info、warn、error方法输出日志

  trait Logger {
    def log(msg:String)
    def info(msg:String) = log("INFO:" + msg)
    def warn(msg:String) = log("WARN:" + msg)
    def error(msg:String) = log("ERROR:" + msg)
  }

  class ConsoleLogger extends Logger {
    override def log(msg: String): Unit = {
      println(msg)
    }
  }

  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLogger
    logger.info("信息日志")
    logger.warn("警告日志")
    logger.error("错误日志")
  }

对象混入trait

示例说明

给一个对象添加一些额外的行为

步骤

创建一个Logger特质
- 添加一个log实现方法，打印参数
创建一个UserService类
添加main方法
- 创建UserService对象，混入Logger特质
- 调用log方法

trait Logger {
    def log(msg:String) = println(msg)
  }

  class UserService

  def main(args: Array[String]): Unit = {
    val service = new UserService with Logger
    service.log("混入的方法")
  }

调用链

1552535850223

步骤

定义一个HandlerTrait特质
- 定义一个具体的handler方法，打印"处理数据..."
定义一个DataValidHandlerTrait，继承HandlerTrait特质
- 重写handler方法，打印"验证数据"
- 调用父特质的handler方法
定义一个SignatureValidHandlerTrait，继承HandlerTrait特质
- 重写Handler方法
- 打印"检查签名"
- 调用父特质的handler方法
创建一个PaymentService类
- 继承DataValidHandlerTrait
- 继承SignatureValidHandlerTrait
- 定义pay方法
  - 打印"准备支付"
  - 调用父特质的handler方法
添加main方法
- 创建PaymentService对象实例
- 调用pay方法

trait HandlerTrait {
    def handle(data:String) = println("处理数据...")
}

trait DataValidHanlderTrait extends HandlerTrait {
    override def handle(data:String): Unit = {
        println("验证数据...")
        super.handle(data)
    }
}

trait SignatureValidHandlerTrait extends HandlerTrait {
    override def handle(data: String): Unit = {
        println("校验签名...")
        super.handle(data)
    }
}

class PayService extends DataValidHanlderTrait with SignatureValidHandlerTrait {
    override def handle(data: String): Unit = {
        println("准备支付...")
        super.handle(data)
    }
}

def main(args: Array[String]): Unit = {
    val service = new PayService
    service.handle("支付参数")
}

// 程序运行输出如下：
// 准备支付...
// 检查签名...
// 验证数据...
// 处理数据...

class PayService extends DataValidHanlderTrait with SignatureValidHandlerTrait

with后面的会先执行

trait的构造机制

如果一个类实现了多个trait，那这些trait是如何构造的呢？

trait也有构造代码，但和类不一样，特质不能有构造器参数
每个特质只有一个无参数的构造器。
一个类继承另一个类、以及多个trait，当创建该类的实例时，它的构造顺序如下：
1. 执行父类的构造器
2. 从左到右依次执行trait的构造器
3. 如果trait有父trait，先构造父trait，如果多个trait有同样的父trait，则只初始化一次
4. 执行子类构造器

示例说明

定义多个特质，然后用一个类去实现它们
测试trait的构造顺序

步骤

创建一个Logger特质，在构造器中打印"执行Logger构造器!"
创建一个MyLogger特质，继承自Logger特质，，在构造器中打印"执行MyLogger构造器!"
创建一个TimeLogger特质，继承自Logger特质，在构造器中打印"执行TimeLogger构造器!"
创建一个Person类，在构造器中打印"执行Person构造器!"
创建一个Student类，继承自Person、MyLogger、TimeLogge特质，在构造器中打印"执行Student构造器!"
添加main方法，实例化Student_One类，观察输出。

trait Logger {
    println("执行Logger构造器")
}

trait MyLogger extends Logger {
    println("执行MyLogger构造器")
}

trait TimeLogger extends Logger {
    println("执行TimeLogger构造器")
}

class Person{
    println("执行Person构造器")
}

class Student extends Person with TimeLogger with MyLogger {
    println("执行Student构造器")
}

def main(args: Array[String]): Unit = {
    new Student
}

// 程序运行输出如下：
// 执行Person构造器
// 执行Logger构造器
// 执行TimeLogger构造器
// 执行MyLogger构造器
// 执行Student构造器

trait继承class

trait也可以继承class的。特质会将class中的成员都继承下来。

示例说明

定义一个特质，继承自一个class

步骤

创建一个MyUtils类，定义printMsg方法
创建一个Logger特质，继承自MyUtils，定义log方法
创建一个Person类，添加name字段
- 继承Logger特质
- 实现sayHello方法，调用log方法
添加main方法，创建一个Person对象，调用sayHello方法

class MyUtil {
    def printMsg(msg:String) = println(msg)
}

trait Logger extends MyUtil {
    def log(msg:String) = printMsg("Logger:" + msg)
}

class Person extends Logger {
    def sayHello() = log("你好")
}

def main(args: Array[String]): Unit = {
    val person = new Person
    person.sayHello()
}

Scala语言学习四（类和对象）

Scala语言学习四（类和对象）

类和对象

创建类和对象

定义和访问成员变量

使用下划线初始化成员变量

定义成员方法

访问修饰符

类的构造器

辅助构造器

单例对象

伴生对象

伴生对象 | apply方法

继承

override和super

类型判断

getClass和classOf

抽象类

抽象字段

匿名内部类

特质(trait)

特质 | 定义具体的方法

实现模板模式

对象混入trait

调用链

trait的构造机制

trait继承class

Scala语言学习四 （类和对象）

类和对象

创建类和对象

定义和访问成员变量

使用下划线初始化成员变量

定义成员方法

访问修饰符

类的构造器

辅助构造器

单例对象

伴生对象

伴生对象 | apply方法

继承

override和super

类型判断

getClass和classOf

抽象类

抽象字段

匿名内部类

特质(trait)

特质 | 定义具体的方法

实现模板模式

对象混入trait

调用链

trait的构造机制

trait继承class

Scala语言学习四（类和对象）