scala instance scala instance doesnt

转载

mob64ca140f29e5 2023-08-14 11:11:53

文章标签 scala instance scala 字段抽象方法 文章分类 scala 后端开发

1.类型判断

有时候,我们设计的程序,要根据变量的类型来执行对应的逻辑

scala instance scala instance doesnt_scala

在scala中,有两种方式来进行类型判断

isInstanceOf
getClass/classOf

1.1 isInstanceOf/asInstanceOf

在Java中,可以使用instanceof关键字来进行类型判断,以及object来进行类转换,在scala中提供了isInstanceOf和asInstanceOf方法

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

用法

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

示例

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

参考代码

package scala.demo

object Demo17 {
  class Person
  class Student extends Person
  def main(args: Array[String]): Unit = {
    val s1: Person = new Student
    if(s1.isInstanceOf[Student]){
      val s2 = s1.asInstanceOf[Student]
      println(s2)
    }
  }
}

1.2 getClass和classOf

isInstanceOf只能判断对象是否为指定类及其子类的对象,而不能精确的判断出对象就是指定类的对象,如果要精确的判断出对象就是指定类的对象,只能使用getClass和classOf

用法:

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

示例:

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

参考代码

package scala.demo

object Demo18 {
  class Person
  class Student extends Person
  def main(args: Array[String]): Unit = {
    val p:Person = new Student    
    println(p.isInstanceOf[Student])//true
    println(p.getClass==classOf[Person])//false
    println(p.getClass==classOf[Student])//true
  }
}

2.抽象类

和Java一样,scala中也可以定义抽象类

2.1定义

如果类的某个成员在当前类中的定义是不完整的,就是一个抽象类
不完整定义的情况有两种

方法没有方法体(抽象方法)
变量没有初始化(抽象字段)

抽象类的定义和Java一样,需要在类前面加上abstarct关键字

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

2.2 抽象方法

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

步骤:

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

参考代码:

package scala.demo

object Demo19 {
  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 redius:Double/*半径*/) extends Shape {
    override def area:Double = redius*redius*Math.PI
  }

  def main(args: Array[String]): Unit = {
    val square = new Square(5)
    println(square.area)
    val rectangle = new Rectangle(2,3)
    println(rectangle.area)
    val cirle = new Cirle(2)
    println(cirle.area)
  }
}

2.3 抽象字段

scala中,也可以定义抽象字段,如果一个成员变量没有初始化值,就认为它是抽象类

语法:

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

示例:

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

参考代码

package scala.demo

object Demo20 {
  abstract class Person{
    var WHO_AM_I:String
  }
  class Student extends Person {
    override var WHO_AM_I: String = "学生"
  }
  class Policeman extends Person {
    override var WHO_AM_I: String = "警察"
  }
  def main(args: Array[String]): Unit = {
    val student = new Student
    println(student.WHO_AM_I)
    val policeman = new Policeman
    println(policeman.WHO_AM_I)
  }
}

3.匿名内部类

匿名内部类是没有名称的子类,直接用来创建实例对象,scala中的匿名内部类的使用和Java中的一致

语法:

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

示例:

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

参考代码

package scala.demo
object Demo21 {
  abstract class Person{
    def sayHello
  }
  def main(args: Array[String]): Unit = {
    new Person {
      override def sayHello: Unit = println("我是一个匿名内部类")
    }.sayHello
  }
}

4.特质

scala中没有Java中的接口(interface),替代的概念是–特质

4.1 定义

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

语法:

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

继承特质

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

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

4.2 trait作为接口使用

trait作为接口使用,与java的接口用法一样

示例

[继承单个trait]

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

package scala.demo

object Demo {
  trait Logger{
    def log(msg:String)
  }
  class ConsoleLogger extends Logger {
    override def log(msg: String): Unit = println(msg)
  }
  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLogger
    logger.log("控制台输出消息......")
  }
}

示例

[继承多个trait]

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

参考代码

package scala.demo

object Demo23 {
  trait MessageSender{
    def send(msg:String)
  }
  trait MessageReceiver{
    def receive():String
  }
  class MessageWorker extends MessageSender with MessageReceiver {
    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("晚上吃什么???")
    println(worker.receive())
  }
}

示例

[object继承trait]

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

参考代码

package scala.demo

object Demo24 {
  trait Logger{
    def log(message:String)
  }
  object ConsoleLogger extends Logger {
    override def log(message: String): Unit = println(s"控制台消息:${message}")
  }
  def main(args: Array[String]): Unit = {
    ConsoleLogger.log("程序出错了..............")
  }
}

4.3 定义具体的方法

trait也可以定义具体的方法

示例

定义一个Logger特质，添加log实现方法
定义一个UserService类，实现Logger特质

添加add方法，打印"添加用户"

添加main方法

创建UserService对象实例
调用add方法

参考代码

package scala.demo

object Demo25 {
  trait Logger{
    def log(message:String)=println(message)
  }
  class UserService extends Logger{
    def add()=log("添加用户")
  }
  def main(args: Array[String]): Unit = {
    val service = new UserService
    service.add()
  }
}

4.4 trait中定义具体的字段

定义:

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

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

步骤:

创建Logger特质

定义一个SimpleDateFormat字段，用来格式化日期（显示到时间）
定义一个TYPE抽象字段，用于定义输出的信息
创建一个log抽象方法，用于输出日志

创建ConsoleLogger类，实现TYPE抽象字段和log方法
添加main方法

创建ConsoleLogger类对象
调用log方法

参考代码

package scala.demo

import java.text.SimpleDateFormat
import java.util.Date

object Demo26 {
  trait Logger{
    val sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E")
    val TYPE:String
    def log(msg:String)
  }
  class ConsoleLogger extends Logger {
    override val TYPE: String = "控制台消息:"
    override def log(msg: String): Unit =println(s"${TYPE}${sdf.format(new Date)},${msg}")
  }
  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLogger
    logger.log("我是一条日志信息.........")
  }
}

4.5 使用trait实现模板模式

需求如下:

实现一个输出日志的功能
目前要求输出到控制台
将来可能会输出到文件,输出到Redis中…

如果在不修改之前的代码,应怎么实现?

scala instance scala instance doesnt_scala instance_02

定义:

在一个特质中,具体方法依赖于抽象方法,而抽象方法可以放到继承trait的子类中实现,这种设计方式也叫做模板设计模式

scala instance scala instance doesnt_scala_03

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

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

示例:

编写一个日志输出工具,分别有info,warn,error三个级别的日志输出

步骤:

添加一个Logger特质

添加一个log抽象方法
添加一个info、warn、error具体方法，这几个方法调用log抽象方法

创建ConsoleLogger类，实现Logger特质
添加main方法

创建ConsoleLogger类对象
分别调用info、warn、error方法输出日志

参考代码:

package scala.demo

object Demo27 {
  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("错误日志")
  }
}

4.6 对象混入trait

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

语法:

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

示例:

创建一个Logger特质

添加一个log实现方法，打印参数

创建一个UserService类
添加main方法

创建UserService对象，混入Logger特质
调用log方法

参考代码

package scala.demo

object Demo28 {
  trait Logger{
    def log(msg:String)=println(msg)
  }
  class UserServie
  def main(args: Array[String]): Unit = {
    val servie = new UserServie with Logger
    println(servie.log("混入的方法........"))
  }
}

4.7 trait实现调用链模式

如果我们要开发一个支付功能,往往需要进行一系列的验证才能完成支付,例如:

进行支付签名验证
数据合法性校验
…

如果将来第三方接口调整,需要增加更多的校验规则,如果不修改代码的前提来进行扩展?

责任链模式

scala instance scala instance doesnt_scala_04

4.8 trait调用链

scala instance scala instance doesnt_字段_05

类继承了多个trait后,可以一次调用多个trait中的同一个方法,只要让多个trait中的同一个方法在最后都一次执行super关键字就行,类中调用多个trait中都有这个方法时,首先会从右边的trait进行执行,然后依次往左执行,形成一个链条示例:

实现一个模拟支付过程的调用链

scala instance scala instance doesnt_抽象方法_06

步骤:

定义一个HandlerTrait特质

定义一个具体的handler方法，打印"处理数据…"

定义一个DataValidHandlerTrait，继承HandlerTrait特质

重写handler方法，打印"验证数据"
调用父特质的handler方法

定义一个SignatureValidHandlerTrait，继承HandlerTrait特质

重写Handler方法
打印"检查签名"
调用父特质的handler方法

创建一个PaymentService类

继承DataValidHandlerTrait
继承SignatureValidHandlerTrait
重写handler

打印"准备支付"

添加main方法

创建PaymentService对象实例
调用handler方法

参考代码

package scala.demo

object Demo29 {
  trait HandlerTrait{
    def handler(date:String)=println("4.处理数据......")
  }
  trait DataValidHandlerTrait extends HandlerTrait{
    override def handler(date: String): Unit = {
      println("3.验证数据....")
      super.handler(date)
    }
  }
  trait SignatureValidHandlerTrait extends HandlerTrait{
    override def handler(date: String): Unit = {
      println("2.检查签名....")
      super.handler(date)
    }
  }
  class  PaymentService extends DataValidHandlerTrait with SignatureValidHandlerTrait{
    override def handler(date: String): Unit = {
      println("1.准备支付....")
      super.handler(date)
    }
  }
  def main(args: Array[String]): Unit = {
    val service = new PaymentService
    service.handler("支付参数......")
  }
}

4.9 trait的构造机制

定义:

trait也有构造代码,但是和类不一样,特质不能有构造器参数
每个特质也只有一个无参数的构造器
一个类继承另一个类,以及多个trait,构造顺序如下

执行父类的构造器
从左往右执依次执行trait的构造器
如果父类有trait,先使用父trait,如果多个trait有相同的父trait,则只初始化一次
执行子类构造器

示例:

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

参考代码

package scala.demo

object Demo30 {
  trait Logger{
    println("2.执行Logger构造器!")
  }
  trait MyLogger extends Logger{
    println("3.执行MyLogger构造器!")
  }
  trait TimeLogger extends Logger{
    println("4.执行TimeLogger构造器!")
  }
  class Person{
    println("1.执行Person构造器!")
  }
  class Student extends Person with MyLogger with TimeLogger{
    println("5.执行Student构造器!")
  }
  def main(args: Array[String]): Unit = {
    val student = new Student
  }
}

4.10 trait继承class

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

示例:

创建一个MyUtils类，定义printMsg方法
创建一个Logger特质，继承自MyUtils，定义log方法
创建一个Person类，添加name字段

继承Logger特质
实现sayHello方法，调用log方法

添加main方法，创建一个Person对象，调用sayHello方法

参考代码

package scala.demo

object Demo31 {
  class  MyUtils{
    def printMsg(msg:String)=println(msg)
  }
  trait Logger extends MyUtils{
    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
  }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。