Scala基础语法小结(三)

1.类型判断

有时候,我们设计的程序,要根据变量的类型来执行对应的逻辑 在scala中,有两种方式来进行类型判断

isInstanceOfgetClass/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中…

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

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

在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实现调用链模式

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

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

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

责任链模式

4.8 trait调用链

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

示例: 实现一个模拟支付过程的调用链 步骤:

定义一个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 } }