Scala系列15：抽象，匿名内部类，特质，模板等使用详解与演示

系统管理员 2022-12-04 01:19 107阅读 0赞

**目录**

0. 抽象类

0.1 定义

0.2代码演示

1.抽象字段

2.匿名内部类

2.1定义

2.2示例

3.特质的使用

3.1特质的定义

3.1.1定义特质

3.1.2 特质继承

3.1.3特质使用演示

3.2特质 | 定义具体的方法

3.3 trait中定义具体的字段和抽象的字段

3.3.1 定义

3.3.2 示例说明

3.3 使用trait实现模板模式

3.3.1示例

3.4 对象混入trait

3.4.1定义

3.4.2示例

3.5 trait的构造机制

3.51 定义

3.5.2 示例说明

3.6 trait继承class

3.6.1示例

--------------------

# 0. 抽象类 #

和Java语言一样，scala中也可以定义抽象类

## 0.1 定义 ##

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

不完整定义有两种情况：

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

**定义抽象类和Java一样，在类前面加上abstract关键字**

// 定义抽象类
    abstract class 抽象类名 {
      // 定义抽象字段
      val 抽象字段名:类型
      // 定义抽象方法
      def 方法名(参数:参数类型,参数:参数类型...):返回类型
    }

## 0.2代码演示 ##

package com.robot.scalademo1
    class Person3
    class Student3 extends Person3
    object _08ObjectDemo {
      // 创建形状抽象类
      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
      }
    
    
        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)
        }
    }
    
    /**
      * 4.0
        6.0
        12.566370614359172
      */

# 1.抽象字段 #

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

**语法**

abstract class 抽象类 {
        val/var 抽象字段:类型
    }

**示例说明**

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

// 定义一个人的抽象类
    package com.robot.scalademo1
    
    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 _08ObjectDemo {
      
        def main(args: Array[String]): Unit = {
          val p1 = new Student6
          val p2 = new Policeman6
    
          println(p1.WHO_AM_I)  //学生
          println(p2.WHO_AM_I)  //警察
    
      }
    }

# 2.匿名内部类 #

1.  **匿名内部类是没有名称的子类，直接用来创建实例对象。Spark的源代码中有大量使用到匿名内部类。**
2.  **scala中的匿名内部类使用与Java一致。**

## 2.1定义 ##

val/var 变量名 = new 类/抽象类 {
        // 重写方法
    }
    Copy

## 2.2示例 ##

**示例说明**

1.  创建一个Person抽象类，并添加一个sayHello抽象方法
2.  添加main方法，通过创建匿名内部类的方式来实现Person
3.  调用匿名内部类对象的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
      }
    }

# 3.特质的使用 #

scala中没有Java中的接口（interface），替代的概念是——特质。用法跟Java中几乎一样。

### 3.1特质的定义 ###

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

### 3.1.1定义特质 ###

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

### **3.1.2 特质继承** ###

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

*  **使用`extends`来继承trait（scala不论是类还是特质，都是使用extends关键字）**
 *  **如果要继承多个trait，则使用`with`关键字**
 *  **注意不仅类可以继承trait，单例object也可以继承trait，trait也可以继承trait.**

### 3.1.3特质使用演示 ###

**1.类单继承特质的使用**

/**
    创建一个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("这是一条日志")
      }

**2.类多继承特质的使用**

/**
    创建一个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())
    }

**3.单例objectg继承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("程序退出!")
    }

**4.特质trait继承trait的使用**

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构造器

## 3.2特质 | 定义具体的方法 ##

**和类一样，trait中还可以定义具体的方法**

**示例说明**

1.  定义一个Logger特质，添加log实现方法
2.  定义一个UserService类，实现Logger特质
    
     *  添加add方法，打印"添加用户"
3.  添加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()
      }
    }

## 3.3 trait中定义具体的字段和抽象的字段 ##

### 3.3.1 定义 ###

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

### 3.3.2 示例**说明** ###

通过trait来实现一个日志输出工具，该日志工具可以自动添加日志的日期

**步骤**

1.  创建Logger特质
    
     *  定义一个SimpleDateFormat字段，用来格式化日期（显示到时间）
     *  定义一个TYPE抽象字段，用于定义输出的信息
     *  创建一个log抽象方法，用于输出日志
2.  创建ConsoleLogger类，实现TYPE抽象字段和log方法
3.  添加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")
      }

## 3.3 使用trait实现模板模式 ##

在scala中，trait是可以定义抽象方法，也可以定义具体方法的

*  **trait中定义了一个抽象方法**
 *  **trait中定义了其他的几个具体方法，会调用抽象方法**
 *  **其他实现类可以来实现抽象方法**
 *  **真正调用trait中具体方法的时候，其实会调用实现类的抽象方法实现**

### 3.3.1示例 ###

**示例说明**

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

**实现步骤**

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

**参考代码**

package com.robot.scalademo1
    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)
      }
    }
    
    object _08ObjectDemo {
    
      def main(args: Array[String]): Unit = {
        val logger = new ConsoleLogger
        logger.info("信息日志")
        logger.warn("警告日志")
        logger.error("错误日志")
      }
    }/**
    INFO:信息日志
    WARN:警告日志
    ERROR:错误日志
      
      */

## 3.4 对象混入trait ##

**scala中可以将trait混入到对象中，就是将trait中定义的方法、字段添加到一个对象中**

### 3.4.1定义 ###

val/var 对象名 = new 类 with 特质

### 3.4.2示例 ###

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

**步骤**

1.  创建一个Logger特质
    
     *  添加一个log实现方法，打印参数
2.  创建一个UserService类
3.  添加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("混入的方法")
      }

## 3.5 trait的构造机制 ##

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

### 3.51 定义 ###

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

### 3.5.2 示例**说明** ###

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

**步骤**

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

**参考代码**

## 3.6 trait继承class ##

**trait也可以继承class的。特质会将class中的成员都继承下来。注意这一点很特别。**

### 3.6.1示例 ###

**示例说明**

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

**步骤**

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

**参考代码**

package com.robot.scalademo1
    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("你好")
    }
    
    object _08ObjectDemo {
    
      def main(args: Array[String]): Unit = {
        val person = new Person
        person.sayHello()
      }
    
    }/**
    Logger:你好
      */