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

最新推荐文章于 2022-09-17 16:47:29 发布
最新推荐文章于 2022-09-17 16:47:29 发布
阅读量1.5k 收藏 3
点赞数 2
分类专栏： Scala/Spark应用剖析与开发优化 文章标签： scala 特质trait使用 scala抽象的使用 scala匿名内部类 大数据
本文为博主原创文章，属博主老婆资产，故未经博主老婆允许不得转载。
本文链接：https://blog.csdn.net/qq_26442553/article/details/108410979
版权

目录

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类，观察输出。

参考代码

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.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:你好
  */

 

涤生大数据
关注
专栏目录
Scala--类，匿名内部类，匿名子类，triait特质，继承体系，重写字段方法，protected[]
ITgagaga的博客
03-06 543
文章目录1. 类的基本操作1.1. 类的定义1.2. 类的构造1.3. 内部类1.4. object对象1.4.1. object对象1.4.2. 单例1.4.3. 伴生对象2. 类的继承体系2.1. 类的扩展2.2. 类型检查和转换2.3. 受保护字段和方法2.4. 超类的构造2.5. 重写字段和方法重写2.6. 匿名子类2.7. 抽象类2.8. trait特质 1. 类的基本操作 1.1. 类...
Scala 抽象类
残缺的孤独
12-07 4015
Scala抽象类不能被实例化，包含若干定义不完全的方法，具体的实现由子类去实现。
0013.scala的抽象类、抽象字段、抽象方法
njiang的专栏
10-11 1743
scala的抽象类、抽象字段、抽象方法
Scala中的抽象(abstract)
zqm_super_man的博客
12-03 463
** 抽象 ** 先明确Scala中的抽象有哪些？ 抽象类、抽象方法、抽象属性 1.Scala中将一个不完整的类叫做抽象类： —>抽象类不能被实例化； —>如果一个类继承了抽象类，那么这个类必须必须实现抽象类中的所有抽象属性和抽象方法；如果这个类本身也是一个抽象类，那么可以不去实现； —>抽象类本身可以没有抽象方法，但是这个类如果存在抽象属性或抽象方法，那么这个类就必须是抽象类； —>抽象类中可以有实现的方法 abstract class Person { //抽象类 }
Scala中的抽象类
hzp666的博客
04-23 846
1.先看下 类的层次结构： 类层次结构，也称为类分类法，是一组相关的类，它们通过继承连接起来做类似的事情。 层次结构的顶部可以是一个基类，它下面的所有其他类都是从中派生出来的，或者层次结构可以有多个基类，这些基类的功能稍后会在一个或多个派生类中合并在一起。 1.Scala中的类层次结构 2.Scala中抽象类的概念 简单讲在Scala中 一个被abstract 修饰的类， 类中包含没有实现的成员，即对象没有初始值，定义的方法没有方法体，则该类就是抽象类。 ...
Scala 样例类
最慢的步伐不是跬步，而是徘徊；最快的脚步不是冲刺，而是坚持
04-22 8781
目录 1、创建一个demo1的单例，在demo1中创建一个样例类名字为student1，成员变量为name:String, age:Int创建主方法实例化student，并传参数（“xiaoming”,20）,打印输出student1对象到控制台 2、创建一个demo2的单例，在demo2中创建一个样例类名字为student2，成员变量为name:String, age:Int创建主方法实例化...
Scala编程详解 第13讲-Scala编程详解：面向对象编程之对象 共9页.pptx
最新发布
11-25
在本系列讲解中，我们将深入探讨Scala的面向对象编程，特别是关于对象的概念。 在Scala中，`object`是一种特殊的类，它只能有一个实例，因此它常被用来实现单例模式。当你首次调用`object`的方法或访问它的字段时，...
Scala-简易详解文章
06-28
抽象类和特质提供代码复用，其中特质可以多继承。匿名类可以快速创建临时类实例。 10. **包**：Scala的包系统用于组织代码，避免命名冲突。`import`语句用于引入所需包中的成员。 11. **样例类（Case Classes）**...
lua-compiler-in-scala:用Scala和LLVM后端编写的Lua编译器
05-15
1. **Scala编程语言**：Scala具有面向对象和函数式编程的特性，它的类、对象、特质、模式匹配等概念提供了强大的抽象能力，同时它的类型系统可以避免运行时错误，提高代码的可靠性。 2. **LLVM后端**：LLVM是一个...
Scala编程语言详解（从入门到精通）spark
03-30
- **面向对象**：Scala 支持面向对象编程的所有主要特性，包括类、继承、抽象类、接口等，并引入了特性（Trait）来改进 Java 的对象模型。 - **函数式编程**：Scala 完全支持函数式编程，提供了不可变数据结构、一等...
Scala案例详解
Dream_aju的博客
10-12 468
1.编写一个方法，getValues(arrLArray[Int],v:Int)返回数组中 小于v，等于v，大于v的元素个数，要求三个值一起返回 object _01WorkGetValues { def main(args: Array[String]): Unit = { //定义一个数组 val arr:Array[Int] = Array(1,3,4,6,7,4,7,8,9,3) //v=6 计算大于6 小于6 等于6 val temp = getCount.
Scala样本类
知其然，知其所以然
12-30 247
样本类 scala> class Student(id:Int){} defined class Student scala> case class Student1(id:Int){} defined class Student1 作用：支持模式匹配 在spark SQL 创建schema package day1230 /** *author: Jackso...
Scala控制抽象入门详解
热门推荐
楚生辉的博客
09-17 1万+
大家好，我是楚生辉，在未来的日子里我们一起来学习大数据相关的技术，一起努力奋斗，遇见更好的自己！大家好，我是楚生辉，在未来的日子里我们一起来学习大数据相关的技术，一起努力奋斗，遇见更好的自己！本文详细的介绍了`scala的控制抽象`，有需要的小伙伴可以学习~
Scala——（继承，特质，模式匹配和样例类）
qq_43408367的博客
03-12 439
如果继承的父类是抽象类（假设抽象类为AbstractClass，子类为SubClass），在SubClass类中，AbstractClass对应的抽象方法如果没有实现的话，那SubClass也必须定义为抽象类，否则的话必须要有方法的实现。方法重写指的是当子类继承父类的时候，从父类继承过来的方法不能满足子类的需要，子类希望有自己的实现，这时需要对父类的方法进行重写，方法重写是实现多态的关键。在Scala中，trait特质也可以继承class类，此时这个class类就会成为所有继承此trait的类的父类。
scala 抽象方法_Scala抽象类型
从零开始的教程世界
07-18 757
scala 抽象方法The type whose identity is not known precisely can be termed as abstract type. 身份未知的类型可以称为抽象类型 。 Scala抽象成员 (Scala Abstract Members) A member is said to be abstract if the member does not h...
Scala抽象类型
weixin_33962621的博客
01-07 116
1 package big.data.analyse.scala 2 3 import scala.io.{BufferedSource, Source} 4 5 /** 6 * 抽象类型 7 * Created by zhen on 2019/1/6. 8 */ 9 trait Reader{ 10 type url <: jav...
Scala学习回顾（七）---- 抽象类、抽象字段、抽象方法
刘利民的博客
08-01 953
注：本文学习源自：DT大数据梦工厂（微信公众号:DT_Spark） 与java相似，scala中abstract声明的类是抽象类，抽象类不可以被实例化。在scala中，抽象类和物质中的方法、字段和类型都可以是抽象的。          抽象方法：抽象方法不需要（也不充许）有abstract修饰符，一个方法只要是没有实现（没有等号或没有方法体），它就是抽象的。          抽象类型：sc
scala学习之路：10. Abstract抽象类抽象字段抽象方法
matiji66
03-13 1957
/** * 抽象类抽象字段抽象方法 必须用abstract修饰 */ class AbstractClassOps { var id : Int = _ // 此处 变量必须初始化（或者赋值）或者是使用占位符 不然的话就只能使用abstract 进行修饰 // val id : Int = _ 此处就会直接报错 （var才可以使用占位符，因为val定义之后不可变） } /**
scala模板方法模式
m0_58535137的博客
02-19 210
object 模板方法模式 { abstract class Template { // 用于执行不确定的代码 def code() def getRuntime(): Long = { val start = System.currentTimeMillis() code() val end = System.currentTimeMillis() end - start } } class Fo
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

涤生大数据

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值