scala相关操作（三）

最新推荐文章于 2022-08-10 22:02:18 发布
最新推荐文章于 2022-08-10 22:02:18 发布
阅读量318 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Autumn_tears/article/details/108738476
版权
  1. 单例对象
    24.1 定义单例对象
package com.ithe.scala

/**
*24.1 定义单例对象
* 示例
* 示例说明
* 1定义一个Dog单例对象，保存狗有几条腿
* 2在main方法中打印狗腿的数量
*/
object Demo24_1 {
 // 1定义一个Dog单例对象，保存狗有几条腿
 object Dog{
   val LEG_NUM=4
 }
 // 2在main方法中打印狗腿的数量
 def main(args: Array[String]): Unit = {
   println(Dog.LEG_NUM)
 }
}

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

package com.ithe.scala

/**
*24.2 在单例对象中定义成员方法
* 示例
* 示例说明
* 1设计一个单例对象，定义一个能够打印分割线（15个减号）的方法
* 2在main方法调用该方法，打印分割线
*/
object Demo24_2 {
 // 1设计一个单例对象，定义一个能够打印分割线（15个减号）的方法
 object PrintUtil{
   def printSpliter()=println("-"*15)
 }
 // 2在main方法调用该方法，打印分割线
 def main(args: Array[String]): Unit = {
   PrintUtil.printSpliter()
 }
}

24.3 工具类案例

package com.ithe.scala

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

/**
* 24.3 工具类案例
* 需求
* 1编写一个DateUtil工具类专门用来格式化日期时间
* 2定义一个方法，用于将日期（Date）转换为年月日字符串，例如：2030-10-05
* 步骤
* 1定义一个DateUtil单例对象，定义日期格式化方法format
* 2在format中，使用SimpleDateFormat将日期转换为字符串，并返回。
* 3在main方法中调用format方法。
*/
object Demo24_3 {
 // 1定义一个DateUtil单例对象，定义日期格式化方法（format）
 object DateUtil{
   val SDF=new SimpleDateFormat("yyyy-MM-dd")
   // 2在format中，使用SimpleDateFormat将日期转换为字符串，并返回。
   def format(date:Date)=SDF.format(date)
 }
 //3在main方法中调用format方法。
 def main(args: Array[String]): Unit = {
   val date = DateUtil.format(new Date())
   println(date)
 }

}
  1. main方法
    25.1 定义main方法
package com.ithe.scala

/**
* 25.1 定义main方法
* 示例
* 示例说明
* 创建一个单例对象，在该单例对象中打印"hello, scala"
*/
//本身就是单例对象
object Demo25_1 {
 def main(args: Array[String]): Unit = {
   println("hello,scala")
 }
}

25.2 实现App Trait来定义入口

package com.ithe.scala

/**
* 25.2 实现App Trait来定义入口
* 示例说明
* 继承App特质，来实现一个入口。同样输出"hello, scala"
*/
//跟刚才的Demo8_1效果是一样的
object Demo25_2 extends App{
 println("hello,scala")
}
  1. 伴生对象
    26.1 定义伴生对象
package com.ithe.scala

/**
* 26.1 定义伴生对象
* 示例
* 示例说明
* 1编写一个英雄Hero类，打印
* 2编写一个Hero伴生对象，定义一个私有变量，用于保存作战武器的名称，比如方天画戟
* 3有一个作战方法，打印  "我要用【xxx】作战了"
* 4在main方法中创建Hero类的对象吕布，调用fight方法
*/
object Demo26_1 {

 // 1编写一个英雄Hero类，打印
 class Hero {
   // 3有一个作战方法，打印  "我要用【xxx】作战了"
   def fight() = println(s"我要用${Hero.weapon}作战了")
 }
 // 2编写一个Hero伴生对象，定义一个私有变量，用于保存作战武器的名称，比如方天画戟
 object Hero{
   private val weapon="方天画戟"
 }
 // 4在main方法中创建Hero类的对象吕布，调用fight方法
 def main(args: Array[String]): Unit = {
   val lvbu = new Hero
   lvbu.fight()
 }
}

26.2 private[this]访问权限

package com.ithe.scala

/**
* 26.2 private[this]访问权限
* 示例
* 示例说明
* 1定义一个Person类，包含一个name字段
* 2定义Person类的伴生对象，定义printPerson方法
* 3测试伴生对象是否能访问private[this]权限的成员
* 步骤
* 1定义一个Person类，包含一个name字段，仅用private修饰（不带[this]）
* 2定义Person类的伴生对象，定义printPerson方法，访问Person类实例的name，是允许访问的
* 3在main方法中，创建Person类的对象，传入printPerson方法，看运行结果。
* 4另外将Person类的name字段，用private[this]修饰，此时printPerson方法无法访问name，编译报错。
*
*/
object Demo26_2 {
 // 1定义一个Person类，包含一个name字段，仅用private修饰（不带[this]）
 class Person(private/*[this]*/ var name:String="")
 // 2定义Person类的伴生对象，定义printPerson方法，访问Person类实例的name，是允许访问的
 object Person{
   def printPerson(p:Person)={
     println(p.name)
   }
 }

 def main(args: Array[String]): Unit = {
 // 3在main方法中，创建Person类的对象，传入printPerson方法，看运行结果。
   val p = new Person("张三")
   Person.printPerson(p)
 // 4另外将Person类的name字段，用private[this]修饰，此时printPerson方法无法访问name，编译报错。

 }

}

26.3 apply方法

package com.ithe.scala

/**
* 26.3 apply方法
* 示例
* 示例说明
* 1定义一个Person类，它包含两个字段：姓名和年龄
* 2定义伴生对象，重写apply方法，使用Person类名就可以创建对象
* 3在main方法中创建该类的对象，并打印姓名和年龄
*/
object Demo26_3 {
 // 1定义一个Person类，它包含两个字段：姓名和年龄
 class Person(var name:String,var age:Int)
 object Person{
   // 2 定义伴生对象，重写apply方法，使用Person类名就可以创建对象
   def apply(name: String, age: Int): Person = new Person(name, age)
 }

 // 3在main方法中创建该类的对象，并打印姓名和年龄
 def main(args: Array[String]): Unit = {
   val p = Person("张三",30)
   println(p.name,p.age)
 }
}
  1. 继承
    27.1 定义语法
package com.ithe.scala

/**
* 27. 继承
* 27.1 定义语法
* 1定义一个Person类包含name属性，再定义一个Student类，继承自Person类
* 2创建一个Student类对象实例，并设置name为“张三”
* 3打印姓名
*/
object Demo27_1 {
 // 1定义一个Person类，再定义一个Student类，继承自Person类
 class Person(var name:String="")
 class Student extends Person
 def main(args: Array[String]): Unit = {
   // 2创建一个Student类对象实例，并设置name为“张三”
   val s = new Student
   s.name="张三"
   // 3打印姓名
   println(s.name)
 }

}

27.2 类继承

package com.ithe.scala

/**
*27.2 类继承
* 1 定义一个Person类包含name属性,getName()方法，再定义一个Student类，继承自Person类
* |--------------------|
* |      <<class>>     |
* |        Person      |
* |--------------------|
* | +var name:String   |
* | +getName():String  |
* |--------------------|
*           ▲
*           |
*           |
* |--------------------|
* |       <<class>>    |
* |       Student      |
* |--------------------|
* 2创建一个Student类对象实例，并设置name为“张三”
* 3打印姓名
*/
object Demo27_2 {

 //1定义一个Person类，再定义一个Student类，继承自Person类
 class Person() {
   var name: String = ""
   def getName() = name
 }

 //2再定义一个Student类，继承自Person类
 class Student extends Person

 def main(args: Array[String]): Unit = {
   //3创建一个Student类对象实例，并设置name为“张三”
   val s = new Student()
   s.name = "张三"
   //4打印姓名
   println(s.getName())
 }
}

27.3 单例对象继承

package com.ithe.scala

/**
* 27.3 单例对象继承
* 示例说明
* 1 创建一个Student单例对象，让单例对象继承示例1中的Person类包括name和getName()
* 2 设置单例对象的名字为"张三"，调用Student单例对象的getName方法
*/
object Demo27_3 {
 // 1 创建一个Student单例对象，让单例对象继承示例1中的Person类包括name和getName()
 class Person{
   var name:String="super"
   def getName()=name
 }
 object Student extends Person
 // 2 设置单例对象的名字为"张三"，调用Student单例对象的getName方法
 def main(args: Array[String]): Unit = {
   val s = Student
   s.name="张三"
   println(s.getName())
 }

}

27.4 override和super

package com.ithe.scala

/**
* 27.4 override和super
* 示例
* 示例说明
* 1定义一个Person类，包含
*  姓名字段（不可重新赋值）
*  获取姓名方法
* 2定义一个Student类，继承Person类
*  重写姓名字段
*  重写获取姓名方法，返回"hello, " + 姓名
* 3在main方法中创建Student类的对象示例，调用它的getName方法
*/
object Demo27_4 {
 // 1定义一个Person类，包含
 //  姓名字段（不可重新赋值）
 //  获取姓名方法
 class Person{
   val name:String="super"
   def getName()=name
 }
 // 2定义一个Student类，继承Person类
 //  重写姓名字段
 //  重写获取姓名方法，返回"hello, " + 姓名
 class Student extends Person{
   override val name: String = "stu"

   override def getName(): String = "hello,"+super.getName()
 }
 // 3在main方法中创建Student类的对象示例，调用它的getName方法
 def main(args: Array[String]): Unit = {
   val a = new Student
   println(a.getName())
 }
}
  1. 类型判断
    28.1 isInstanceOf/asInstanceOf
package com.ithe.scala

/**
* 28. 类型判断
* 28.1 isInstanceOf/asInstanceOf
* 示例
* 示例说明
* 1定义一个Person类
* 2定义一个Student类继承自Person类
* 3创建一个Student类对象
* 4判断该对象是否为Student类型，如果是，将其转换为Student类型并打印该对象
*/
object Demo28_1 {
 //1定义一个Person类
 class Person
 //2定义一个Student类继承自Person类
 class Student extends Person
 def main(args: Array[String]): Unit = {
   //3创建一个Student类对象
   val s = new Student
   //4判断该对象是否为Student类型，如果是，将其转换为Student类型并打印该对象
   if(s.isInstanceOf[Student]){
     s.asInstanceOf[Student]
     println(s)
   }
 }
}

28.2 getClass和classOf

package com.ithe.scala

/**
* 28.2 getClass和classOf
* 示例
* 示例说明
* 1定义一个Person类
* 2定义一个Student类继承自Person类
* 3创建一个Student类对象，并指定它的类型为Person类型
* 4测试使用isInstanceOf判断该对象是否为Person类型
* 5测试使用getClass/classOf判断该对象是否为Person类型
* 6测试使用getClass/classOf判断该对象是否为Student类型
*/
object Demo28_2 {
// * 示例
 //示例说明
 //1定义一个Person类
 class Person
 //2定义一个Student类继承自Person类
 class Student extends Person

 def main(args: Array[String]): Unit = {
   //3创建一个Student类对象，并指定它的类型为Person类型
   val a:Person = new Student
   //4测试使用isInstanceOf判断该对象是否为Person类型
   println(a.isInstanceOf[Person])
   //5测试使用getClass/classOf判断该对象是否为Person类型
   println(a.getClass==classOf[Person])
   //6测试使用getClass/classOf判断该对象是否为Student类型
   println(a.getClass==classOf[Student])
 }
}
  1. 抽象类
    29.1 定义
/**

**/

29.2 抽象方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6cGfRtyl-1600772035320)(06-scala代码大纲.assets/1598844789964.png)]

package com.ithe.scala

/**
* 29. 抽象类
* 29.2 抽象方法
* 1设计4个类，表示上述图中的继承关系
* 2每一个形状都有自己求面积的方法，但是不同的形状计算面积的方法不同
* 步骤
* 1.	创建一个Shape抽象类，添加一个area抽象方法，用于计算面积
* 2.	创建一个Square正方形类，继承自Shape，它有一个边长的主构造器，并实现计算面积方法
* 3.	创建一个长方形类，继承自Shape，它有一个长、宽的主构造器，实现计算面积方法
* 4.	创建一个圆形类，继承自Shape，它有一个半径的主构造器，并实现计算面积方法
* 5.	编写main方法，分别创建正方形、长方形、圆形对象，并打印它们的面积
*/
object Demo29_2 {
 //1.	创建一个Shape抽象类，添加一个area抽象方法，用于计算面积
 abstract class Shape{
   //计算面积
   def area():Double
 }
 //2.	创建一个Square正方形类，继承自Shape，它有一个边长的主构造器，并实现计算面积方法
 class Square(edge:Double/*边长*/) extends Shape{
   override def area(): Double = edge*edge
 }

 //3.	创建一个长方形类，继承自Shape，它有一个长、宽的主构造器，实现计算面积方法
 class Rectangle(length:Double/*长*/,width:Double/*宽*/) extends Shape{
   override def area(): Double = length*width
 }
 //4.	创建一个圆形类，继承自Shape，它有一个半径的主构造器，并实现计算面积方法
 class Circle(radius:Double/*半径*/) extends Shape {
   override def area(): Double = Math.PI*radius*radius
 }
 //5.	编写main方法，分别创建正方形、长方形、圆形对象，并打印它们的面积
 def main(args: Array[String]): Unit = {
   val a:Shape=new Square(4)
   println(a.area())

   val b:Shape=new Rectangle(3,4)
   println(b.area())

   val c:Shape=new Circle(4)
   println(c.area())
 }
}

29.3 抽象字段

package com.ithe.scala

/**
* 29.3 抽象字段
* 示例
* 示例说明
* 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
*/
object Demo29_3 {
 //1.	创建一个Person抽象类，它有一个String抽象字段WHO_AM_I
 abstract class Person{
   var WHO_AM_I:String
 }
 //2.	创建一个Student类，继承自Person类，重写WHO_AM_I字段，初始化为学生
 class Student extends Person{
   override var WHO_AM_I: String = "学生"
 }
 //3.	创建一个Policeman类，继承自Person类，重写WHO_AM_I字段，初始化警察
 class Policeman extends Person{
   override var WHO_AM_I: String = "警察"
 }
 //4.	添加main方法，分别创建Student/Policeman的实例，然后分别打印WHO_AM_I
 def main(args: Array[String]): Unit = {
   val s = new Student
   val p = new Policeman

   println(s.WHO_AM_I)
   println(p.WHO_AM_I)
 }
}
  1. 匿名内部类
package com.ithe.scala

/**
* 30. 匿名内部类
* 示例
* 示例说明
* 1.	创建一个Person抽象类，并添加一个sayHello抽象方法
* 2.	添加main方法，通过创建匿名内部类的方式来实现Person
* 3.	调用匿名内部类对象的sayHello方法
*/
object Demo30 {
 // 1.	创建一个Person抽象类，并添加一个sayHello抽象方法
 abstract class Person{
   def sayHello()
 }

 // 2.	添加main方法，通过创建匿名内部类的方式来实现Person
 def main(args: Array[String]): Unit = {
   val person = new Person {
     override def sayHello(): Unit = println("我是一个匿名内部类")
   }
   // 3.	调用匿名内部类对象的sayHello方法
   person.sayHello()
 }

}
  1. 特质(trait)

31.1 定义

/**

**/

31.2 trait作为接口使用

package com.ithe.scala

/**
* 31.2 trait作为接口使用
* 示例一 继承单个trait
* 示例说明
* 1.	创建一个Logger特质，添加一个接受一个String类型参数的log抽象方法
* 2.	创建一个ConsoleLogger类，继承Logger特质，实现log方法，打印消息
* 3.	添加main方法，创建ConsoleLogger对象，调用log方法
*/
object Demo31_2_1 {
 //1.	创建一个Logger特质，添加一个接受一个String类型参数的log抽象方法
 trait Logger{
   def log(msg:String)
 }
 //2.	创建一个ConsoleLogger类，继承Logger特质，实现log方法，打印消息
 class ConsoleLogger extends Logger{
   override def log(msg: String): Unit = println("来自控制台的日志："+msg)
 }
 //3.	添加main方法，创建ConsoleLogger对象，调用log方法
 def main(args: Array[String]): Unit = {
   val c = new ConsoleLogger
   c.log("这是一条日志")
 }
}


package com.ithe.scala

/**
* 示例二、 继承多个trait
* 示例说明
* 1.	创建一个MessageSender特质，添加send方法
* 2.	创建一个MessageReceiver特质，添加receive方法
* 3.	创建一个MessageWorker实现这两个特质
* 4.	在main中调用，分别调用send方法、receive方法
*/
object Demo31_2_2 {
 // 1.	创建一个MessageSender特质，添加send方法
 trait MessageSender{
   def send(msg:String)
 }
 // 2.	创建一个MessageReceiver特质，添加receive方法
 trait MessageReceiver{
   def receive():String
 }
 // 3.	创建一个MessageWorker实现这两个特质
 class MessageWorker extends MessageSender with MessageReceiver{
   override def send(msg: String): Unit = println("发送一条消息："+msg)

   override def receive()  = "你好，我是一个好人"
 }
 // 4.	在main中调用，分别调用send方法、receive方法
 def main(args: Array[String]): Unit = {
   val w = new MessageWorker
   w.send("你好鸭")
   println(w.receive())
 }
}


package com.ithe.scala

/**
* 示例三、 object继承trait
* 示例说明
* 1.	创建一个Logger特质，添加一个log抽象方法
* 2.	创建一个ConsoleLogger的object，继承Logger特质，实现log方法，打印消息
* 3.	编写main方法，调用ConsoleLogger的log方法
*/
object Demo31_2_3 {
 // 1.	创建一个Logger特质，添加一个log抽象方法
 trait Logger{
   def log(msg:String)
 }
 // 2.	创建一个ConsoleLogger的object，继承Logger特质，实现log方法，打印消息
 object ConsoleLogger extends Logger{
   override def log(msg: String): Unit = println("控制台消息："+msg)
 }
 // 3.	编写main方法，调用ConsoleLogger的log方法
 def main(args: Array[String]): Unit = {
   ConsoleLogger.log("这是一条日志")
 }
}

31.3 定义具体的方法

package com.ithe.scala

/**
* 31.3 定义具体的方法
* 示例
* 示例说明
* 1.	定义一个Logger特质，添加具体的log方法
* 2.	定义一个UserService类，继承Logger特质
* 添加add方法，在add方法中调用log方法，打印"添加用户"
* 3.	添加main方法
* 创建UserService对象实例
* 调用add方法
*/
object Demo31_3 {
 //  1.	定义一个Logger特质，添加具体的log方法
 trait Logger{
   def log(msg:String)
 }
 //  2.	定义一个UserService类，继承Logger特质
 class UserService extends Logger{
   override def log(msg: String): Unit = println(msg)
   //    添加一个具体方法，名叫add，在add方法中调用log方法，打印"添加用户"
   def add()=log("打印用户")
 }
 //  3.	添加main方法
 def main(args: Array[String]): Unit = {
   //    创建UserService对象实例
   val u = new UserService
   //    调用add方法
   u.add()
 }
}

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

package com.ithe.scala

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

/**
* 31.4 trait中定义具体的字段和抽象的字段
* 示例
* 示例说明
* 通过trait来实现一个日志输出工具，该日志工具可以自动添加日志的日期
* 步骤
* 1.	创建Logger特质
* 定义一个具体的SimpleDateFormat字段，用来格式化日期（显示到时间）
* 定义一个抽象字段TYPE，用于表示日志的级别
* 创建一个log抽象方法，用于输出日志
* 2.	创建ConsoleLogger类，
*   重写TYPE抽象字段
*   重写log方法，输出日志格式为： 日志级别 时间 日志内容
* 3.	添加main方法
* 创建ConsoleLogger类对象
* 调用log方法，打印“用户A登录了系统”
*/
object Demo31_4 {
 // 1.	创建Logger特质
 trait Logger{
   //  定义一个具体的SimpleDateFormat字段，用来格式化日期（显示到时间）
   val sdf=new SimpleDateFormat("yyyy-DD-mm HH-mm-ss")
   //  定义一个抽象字段TYPE，用于表示日志的级别
   val TYPE :String
   //  创建一个log抽象方法，用于输出日志
   def log(msg:String)
 }

 // 2.	创建ConsoleLogger类
 class ConsoleLogger extends Logger{
   //   重写TYPE抽象字段
   override val TYPE: String = "info"

   //   重写log方法，输出日志格式为： 日志级别 时间 日志内容
   override def log(msg: String): Unit = {
     val info = s"$TYPE ${sdf.format(new Date())}:$msg"
     println(info)
   }
 }
 // 3.	添加main方法
 def main(args: Array[String]): Unit = {
   //  创建ConsoleLogger类对象
   val c = new ConsoleLogger
   //  调用log方法
   c.log("用户A登录了系统")
 }

}

31.5 使用trait实现模板模式

package com.ithe.scala

/**
* 31.5 使用trait实现模板模式
* 示例说明
* 编写一个日志输出工具，分别有info、warn、error三个级别的日志输出
* 日志输出的方式要求设计为可扩展的，例如：可以输出到控制台、将来也可以扩展输出到文件、数据库等
* 实现步骤
* 1.	添加一个Logger特质
* 添加一个log抽象方法
* 添加三个info、warn、error具体方法，他们都调用log抽象方法。就像信用卡提前透支，此处提前使用log方法，log()的具体内容留给以后再去实现。
* 2.	创建ConsoleLogger类，继承Logger特质，实现log方法，打印入参即可
* 3.	添加main方法
* 创建ConsoleLogger类对象
* 分别调用info、warn、error方法输出日志
*/
object Demo31_5 {
 // 1.	添加一个Logger特质
 trait Logger {
   //   添加一个log抽象方法
   def log(msg: String)
   //   添加三个info、warn、error具体方法，他们都调用log抽象方法。就像信用卡提前透支，此处提前使用log方法，log()的具体内容留给以后再去实现。
   def info(msg:String)=log("INFO:"+msg)
   def warn(msg:String)=log("WARN:"+msg)
   def error(msg:String)=log("ERROR:"+msg)
 }

 // 2.	创建ConsoleLogger类，继承Logger特质，实现log方法，打印入参即可
 class ConsoleLogger extends Logger{
   override def log(msg: String): Unit = println(msg)
 }
 // 3.	添加main方法
 def main(args: Array[String]): Unit = {
   //  创建ConsoleLogger类对象
   val c = new ConsoleLogger
   //  分别调用info、warn、error方法输出日志
   c.info("信息日志")
   c.warn("警告日志")
   c.error("错误日志")
 }
}

31.6 对象混入trait

package com.ithe.scala

/**
* 31.6 对象混入trait
* 示例
* 给一个对象添加一些额外的行为
* 步骤
* 1.	创建一个Logger特质
* 添加一个log实现方法，打印参数
* 2.	定义一个UserService类
* 3.	添加main方法
* 创建UserService对象，混入Logger特质
* 调用log方法
*/
object Demo31_6 {
 // 1.	创建一个Logger特质
 trait Logger{
   //   添加一个log实现方法，打印参数
   def log(msg:String)=println(msg)
 }

 // 2.	定义一个UserService类
 class UserService

 // 3.	添加main方法
 def main(args: Array[String]): Unit = {
   //   创建UserService对象，混入Logger特质
   val u = new UserService with Logger
   //   调用log方法
   u.log("混入的方法")
 }


}

31.7 trait实现调用链模式
31.8 trait调用链

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xxmOE4az-1600772035324)(06-scala代码大纲.assets/1598845223710.png)]

package com.ithe.scala

/**
* 31.8 trait调用链
* 步骤
* 1.	定义一个HandlerTrait特质
* 	定义一个具体的handler方法，打印"处理数据..."
* 2.	定义一个DataValidHandlerTrait，继承HandlerTrait特质
* 	重写handler方法，打印"验证数据"
* 	调用父特质的handler方法
* 3.	定义一个SignatureValidHandlerTrait，继承HandlerTrait特质
* 	重写Handler方法
* 	打印"检查签名"
* 	调用父特质的handler方法
* 4.	创建一个PaymentService类
* 	继承DataValidHandlerTrait
* 	继承SignatureValidHandlerTrait
* 	定义pay方法
* 	打印"准备支付"
* 	调用父特质的handler方法
* 5.	添加main方法
* 	创建PaymentService对象实例
* 	调用pay方法
*/
object Demo31_8 {

 //1.	定义一个HandlerTrait特质
 trait HandlerTrait {
   //	定义一个具体的handler方法，打印"处理数据..."
   def handler(data: String) = println("处理数据")
 }

 //2.	定义一个DataValidHandlerTrait，继承HandlerTrait特质
 trait DataValideHandlerTrait extends HandlerTrait {
   //	重写handler方法，打印"验证数据"
   override def handler(data: String): Unit = {
     println("校验数据")
     //	调用父特质的handler方法
     super.handler(data)
   }
 }

 //3.	定义一个SignatureValidHandlerTrait，继承HandlerTrait特质
 //	重写Handler方法
 //	打印"检查签名"
 //	调用父特质的handler方法
 trait SignatureValidHandlerTrait extends HandlerTrait {
   override def handler(data: String): Unit = {
     println("检查签名")
     super.handler(data)
   }
 }

 //4.	创建一个PaymentService类
 //	继承DataValidHandlerTrait
 //	继承SignatureValidHandlerTrait
 //	定义pay方法
 //	打印"准备支付"
 //	调用父特质的handler方法
 class PaymentService extends DataValideHandlerTrait with SignatureValidHandlerTrait {
   def pay() = {
     println("1准备支付")
     super.handler("支付参数")
   }

 }

 //5.	添加main方法
 //	创建PaymentService对象实例
 //	调用pay方法
 def main(args: Array[String]): Unit = {
   val p = new PaymentService
   p.pay()
 }
}

31.9 trait的构造机制

package com.ithe.scala

/**
* 31.9 trait的构造机制
* 示例
* 示例说明
* 	定义多个特质，然后用一个类去实现它们
* 	测试trait的构造顺序
* 步骤
* 1.	创建一个Logger特质，在构造器中打印"执行Logger构造器!"
* 2.	创建一个MyLogger特质，继承自Logger特质，，在构造器中打印"执行MyLogger构造器!"
* 3.	创建一个TimeLogger特质，继承自Logger特质，在构造器中打印"执行TimeLogger构造器!"
* 4.	创建一个Person类，在构造器中打印"执行Person构造器!"
* 5.	创建一个Student类，继承自Person、MyLogger、TimeLogger特质，在构造器中打印"执行Student构造器!"
* 6.	添加main方法，实例化Student_One类，观察输出。
*/
object Demo31_9 {
 //步骤
 //1.	创建一个Logger特质，在构造器中打印"执行Logger构造器!"
 trait Logger{
   println("2执行Logger构造器！")
 }
 //2.	创建一个MyLogger特质，继承自Logger特质，，在构造器中打印"执行MyLogger构造器!"
 trait MyLogger extends Logger{
   println("3执行MyLogger构造器")
 }
 //3.	创建一个TimeLogger特质，继承自Logger特质，在构造器中打印"执行TimeLogger构造器!"
 trait TimeLogger extends Logger{
   println("4执行TimeLogger构造器")
 }
 //4.	创建一个Person类，在构造器中打印"执行Person构造器!"
 class Person {
   println("1执行Person构造器")
 }
 //5.	创建一个Student类，继承自Person、MyLogger、TimeLogger特质，在构造器中打印"执行Student构造器!"
 class Student extends Person with MyLogger with TimeLogger{
   println("5执行Student构造器")
 }
 //6.	添加main方法，实例化Student_One类，观察输出。
 def main(args: Array[String]): Unit = {
   val s = new Student
 }
}

31.10 trait继承class

package com.ithe.scala

/**
* 31.10 trait继承class
* 示例
* 示例说明
* 	定义一个特质，继承自一个class
* 步骤
* 1.	创建一个MyUtils类，定义printMsg方法，打印传入的信息
* 2.	创建一个Logger特质，继承自MyUtils，定义log方法,打印Logger:传入的信息
* 3.	创建一个Person类，添加name字段
* 	继承Logger特质
* 	定义  sayHello方法，调用log方法
* 4.	添加main方法，创建一个Person对象，调用sayHello方法
*/
object Demo31_10 {
 //步骤
 //1.	创建一个MyUtils类，定义printMsg方法，打印传入的信息
 class MyUtils{
   def printMsg(msg:String)=println(msg)
 }
 //2.	创建一个Logger特质，继承自MyUtils，定义log方法,打印Logger:传入的信息
 trait Logger extends MyUtils{
   def log(msg:String)=println("Logger:"+msg)
 }
 //3.	创建一个Person类，添加name字段
 //  继承Logger特质
 //  定义sayHello方法，调用log方法
 class Person extends Logger{
   var name:String=""
   def sayHello(msg:String)=log(msg)

 }
 //4.	添加main方法，创建一个Person对象，调用sayHello方法
 def main(args: Array[String]): Unit = {
   val p = new Person
   p.sayHello("hello")
 }
}
  1. 样例类
    32.1 定义样例类
/**

**/

32.2 定义一个样例类

package com.ithe.scala

/**
* 32. 样例类
* 32.2 定义一个样例类
* 需求
* 1	定义一个Person样例类，包含姓名和年龄成员变量
* 2	创建样例类的对象实例（"张三"、20），并打印它
*/
object Demo32_2 {
 // 1	定义一个Person样例类，包含姓名和年龄成员变量
 case class Person(name:String,age:Int)
 // 2	创建样例类的对象实例（"张三"、20），并打印它
 def main(args: Array[String]): Unit = {
   val a = Person("张三",20)
   println(a)
 }
}

32.3 可变成员变量

package com.ithe.scala

/**
* 32.3 可变成员变量
* 需求
* 1	定义一个Person样例类，包含姓名和年龄(可变)成员变量
* 2	创建样例类的对象实例（"张三"、20）
* 3	修改张三的年龄为23岁，并打印
*/
object Demo32_3 {
 //  1	定义一个Person样例类，包含姓名和年龄成员变量
 case class Person(name:String,var age:Int)
 //  2	创建样例类的对象实例（"张三"、20）
 //  3	修改张三的年龄为23岁，并打印
 def main(args: Array[String]): Unit = {
   val p = Person("张三",20)
   p.age=23
   println(p)
 }
}

32.4 样例类的方法

32.4.1 apply方法

package com.ithe.scala

/**
* 32.4 样例类的方法
* 32.4.1 apply方法
* apply方法可以让我们快速地使用类名来创建对象。
* 案例
* 	定义一个样例类CasePerson，属性包括姓名name，年龄age。
* 	用免new的方式直接创建一个对象
*/
object Demo32_4_1 {
 //  定义一个样例类CasePerson，属性包括姓名name，年龄age。
 case class CasePerson(name:String,age:Int)
 //  免new的方式创建一个对象
 def main(args: Array[String]): Unit = {
   val a=CasePerson("李四",30)  //说明重写了apply()方法
   println(a)                   //说明重写了toString()方法
 }
}

32.4.2 toString方法

package com.ithe.scala

/**
*32.4.2 toString方法
* 案例
* 调用上面的对象的toString方法试试。
*/
object Demo32_4_2 {

 case class CasePerson(name: String, age: Int)

 def main(args: Array[String]): Unit = {
   val a = CasePerson("李四", 30)
   //打印a等价于调用对象a的toString方法
   println(a.toString)
 }
}

32.4.3 equals方法

package com.ithe.scala

/**
* 32.4.3 equals方法
* 示例
* 1	创建一个样例类Person，包含姓名、年龄
* 2	创建名字年龄分别为"李四", 21的两个对象
* 3	比较它们是否相等
*/
object Demo32_4_3 {
 // 1	创建一个样例类Person，包含姓名、年龄
 case class Person(name:String,age:Int)
 // 2	创建名字年龄分别为"李四", 21的两个对象
 // 3	比较它们是否相等
 def main(args: Array[String]): Unit = {
   val a = Person("李四",21)
   val b = Person("李四",21)
   println(a == b)       //true, 因为比较的是属性值
   println(a.equals(b))  //true, 因为底层自动帮我们重写了equals()方法, 等价于 a == b
   println(a.eq(b))      //false,因为比较的是地址值
 }
}

32.4.4 hashCode方法

package com.ithe.scala

/**
* 32.4.4 hashCode方法
* 1	创建名字年龄分别为"李四", 21的对象
* 2	再创建一个名字年龄分别为"李四", 22的对象
* 3  分别打印这两个对象的哈希值
*/
object Demo32_4_4 {
 case class Person(name: String, age: Int)

 def main(args: Array[String]): Unit = {
   //1	创建名字年龄分别为"李四", 21的对象
   val a = Person("李四", 21)
   //2	再创建一个名字年龄分别为"李四", 22的对象
   val b = Person("李四", 22)
   //3  分别打印这两个对象的哈希值
   println(a.hashCode())
   println(b.hashCode())
   println("-"*15)
   //补充内容：内容不同，但是哈希值相同的特例：重地 和 通话，儿女 和 农丰
   println("重地".hashCode)
   println("通话".hashCode)
   println("-"*15)
   println("儿女".hashCode)
   println("农丰".hashCode)
 }
}

32.4.5 copy方法

package com.ithe.scala

/**
* 32.4.5 copy方法
* 示例
* 1	创建名字年龄分别为"李四", 21的对象
* 2	通过copy拷贝，名字为"王五"的对象
*/
object Demo32_4_5 {
 case class Person(name: String, age: Int)

 def main(args: Array[String]): Unit = {
   //1	创建名字年龄分别为"李四", 21的对象
   val a = Person("李四", 21)
   //2	通过copy拷贝，名字为"王五"的对象
   val b = a.copy(name = "王五")
   println(a)
   println(b)
 }
}
  1. 样例对象
    33.1 定义
/**

**/

33.2 定义枚举

package com.ithe.scala

/**
* 33.2 定义枚举
* 需求说明
* 1	创建一个Trait，表示性别Sex枚举，
* 2	定义它的两个实例，样例对象（男性——Male、女性——Female）
* 3	创建一个Person样例类，它有两个成员（姓名、性别）
* 4	创建两个Person对象（"张三"、男性）、（"李四"、"女"）
*/
object Demo33_2 {

 //1	创建一个Trait，表示性别Sex枚举，
 trait Sex

 //2	定义它的两个实例，样例对象（男性——Male、女性——Female）
 case object Male extends Sex

 case object Female extends Sex

 //3	创建一个Person样例类，它有两个成员（姓名、性别）
 case class Person(name: String, sex: Sex)

 //4	创建两个Person对象（"张三"、男性）、（"李四"、"女"）
 def main(args: Array[String]): Unit = {
   val a = Person("张三", Male)
   val b = Person("李四", Female)
   println(a)
   println(b)
 }
}
Autumn_tears
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
计算正方形长方形圆形的周长面积
djq896276232的博客
04-13 618
计算正方形长方形圆形的周长面积。
运用scala语句打印图形
wswddo的博客
08-13 1252
def main(args: Array[String]): Unit = { var t : String = " hello scala"; println("t="+t) println("scala语言中的for语句，输出1到30之内所有的偶数") for(i<- 30 until (0,-2) ){ print(i+ " ") } println() printl...
Scala基础语法学习
weixin_43288858的博客
04-24 894
一、变量 val/var 变量名称:变量类型 = 初始值 注意： val定义的是不可重新赋值的变量(值不可修改) var定义的是可重新赋值的变量(值可以修改) scala中声明变量是变量名称在前，变量类型在后，跟java是正好相反 scala的语句最后不需要添加分号、、 惰性变量 Scala中使用==关键字lazy==来定义惰性变量，实现延迟加载(懒加载)。 惰性变量只能是不可变变量，并且只有在调用惰性变量时，才会去实例化这个变量。 语.
Scala样例类练习.docx
04-03
1创建一个demo1的单例，在demo1中创建一个样例类名字为student1，成员变量为name:String, age:Int 创建主方法实例化student，并传参数（“xiaoming”,20）,打印输出student1对象到控制台 创建一个demo2的单例，在demo2中创建一个样例类名字为student2，成员变量为name:String, age:Int 创建主方法实例化student2，并传参数（“xiaoming”,20）,修改student2对象的age=25,打印输出student2对象到控制台等等
用for循环打印一个菱形的第二种方法
曹利荣的博客
11-23 8784
步骤一：输出正方形 public class Test000 { public static void main(String [] args) { int size=15;//边长 for(int i=1;i&lt;=size;i++) {//控制行数 for(int j=1;j&lt;=size;j++) {//控制每行长度 System.out.print("...
scala从入门到精通技术教学视频
05-30
第三章 运算符 001.导学 01.算术运算符 02.赋值运算符 03.关系运算符 04.逻辑运算符 05.进制和8421码 06.原反补码计算规则 07.位运算符 08.案例_交换变量值 第四章 流程控制结构 00.导学 01.流程控制结构之顺序结构...
computation-expressions:Scala中计算表达式的实现
05-16
Scala的理解有三个缺点： 他们只使用flatMap ，这可能是不必要的限制它们在if和match语句中的表现不佳不可能从理解中操纵上下文它们还具有一些优点： 更好地控制效果的顺序当您不关心效果的顺序时，只想对Context中...
scala-play-realworld-example-app:使用Scala 2.13＆Play构建的示例现实世界应用程序
05-14
创建该代码库的目的是演示使用Scala＆Play Framework构建的完整的全栈应用程序，其中包括CRUD操作，身份验证，路由，分页等。 有关如何与其他前端/后端一起使用的更多信息，请转至库。 入门 您需要安装： Java> = ...
Scala编程——第八章：面向对象编程（初级部分）
lightupworld的博客
08-06 264
面向对象编程（初级部分）一、预备知识二、类与对象1.类与对象的关系2.类的定义3.属性(成员变量)4. 对象 本章开始学习Scala面向对象编程内容，内容分成初级、中级、高级部分。 一、预备知识 Java是面向对象的编程语言，由于历史原因，Java中还存在着非面向对象的内容:基本类型 ，null，静态方法等。 Scala语言来自于Java，所以天生就是面向对象的语言，而且Scala是纯粹的面向对象的语言，即在Scala中，一切皆为对象。 二、类与对象 1.类与对象的关系 类是抽象的，概念的，代表一类事
Scala 中的几种打印方式
jose_M的博客
05-15 2724
本文主要总结Scala中的几种打印方式 println("type 2") // 不换行 print("type 2") val a = "type 2" println(s"$a") println(s"${a}") printf("%s", a) printf("%s".format(a)) 以上几种方式均可以成功打印字符串 "type 2"
scala之面象对象之中级
初学者
08-17 107
1、scala包 1.1、基本语法 package 包名 1.2、包的作用（和java一样） 区分相同名字的类 当类很多时,可以很好的管理类 控制访问范围 可以对类的功能进行扩展 1.3、命名规则 只能包含数字、字母、下划线、小圆点.,但不能用数字开头, 也不要使用关键字。 demo.class.exec1 //错误 , 因为class是关键字 demo.12a // 错误，因为不能...
Scala入门到精通(尚硅谷学习笔记)章节四——输入和输出
weixin_47726676的博客
08-10 1232
在输出时，普通字符将原样不动地复制到标准输出，转换说明并不直接输出而是用于控制 printf 中参数的转换和打印。每个转换说明都由一个百分号字符（%）开始，以转换说明结束，从而说明输出数据的类型、宽度、精度等。Source单例对象中, 提供了一些非常便捷的方法, 从而使开发者可以快速的从指定数据源(文本文件, URL地址等)中获取数据, 在使用 Source单例对象之前, 需要先导入source包, 即。%[标志][最小宽度][.精度][类型长度]说明符。print(s"$a")输出为变量的值。...
ScalaTraining topic
最慢的步伐不是跬步，而是徘徊；最快的脚步不是冲刺，而是坚持
03-31 7887
set集合(1-10) 1、定义一个不可变set集合a，保存以下元素：10,20,30,10,50,40 var a = Set(10,20,30,40) 2、获取a集合的大小 a.size 3、遍历a集合 for(i<- a)println(i) 4、a集合删除元素50 a -50 5、a集合拼接set集合Set(60,80,90) a++Set(60,80,90) ...
scala学习-类与对象
weixin_30521161的博客
09-22 108
类　　/　　对象 【《快学Scala》笔记】 一、类 1、Scala中的类是公有可见性的，且多个类可以包含在同一个源文件中； 1 class Counter{ 2 private var value = 0　　//类成员变量必须初始化，否则报错 3 4 def increment(){ //类中的方法默认是公有可见性 5 va...
Scala详解
weixin_33971977的博客
07-05 200
1       快速入门... 4 1.1             分号... 4 1.2             常变量声明... 4 1.2.1         val常量... 4 1.2.2         var变量... 4 1.2.3         类型推导... 5 1.2.4         函数编程风格... 5 1.3             Range. 5 1.4   ...
Scala中Array的方法详细汇总(类比汇总)
Hugh_Guan的博客
09-14 593
scala中Array方法，类比总结。
6、 声明类Student，包含3个成员变量：name、age、score，
热门推荐
cj657300124的专栏
07-05 1万+
/* 分析：1，需要3个成员变量，name，  age，   score。   2，可以通过set， get方法访问。 思路：  1，创建一个student类， 类里面包含 name，age， score，三个变量。    2，设置成私有， 对外提供set，get，方法。    3，在主函数中创建student("张三", 22, 95)类型的对象。 */ class  Demo6
定义一个有关学生的Student类,内包含成员变量:String name，String sex，int age,所有的变量必须为私有的(private).(Java)
spursping的博客
07-03 8047
package spurs_ping; import java.util.Scanner; /*定义一个有关学生的Student类,内包含成员变量:String name，String sex，int age,所有的变量必须为私有的(private). 1.编写有参的构造函数:能对name,sex,age赋值. 2.覆盖toString函数: 按照格式:类名[name=,sex=,age=]输出.使用idea自动生成,然后修改成该输出格式 3.对每个属性生成setter/getter方法
Scala练习题
wzc8961661的博客
04-05 3823
目录题目第一题第二题第三题第四题第五题第六题第七题第八题第九题第十题第十一题第十二题第十三题第十四题第十五题第十六题第十七题第十八题第十九题第二十题第二十一题第二十二题第二十三题第二十四题 题目 1、创建一个demo1的单例，在demo1中创建一个样例类名字为student1，成员变量为name:String, age:Int 创建主方法实例化student，并传参数（“xiaoming”,20）...
scala遍历json对象
最新发布
04-13
在Scala中，可以使用第三方库如`play-json`或`circe`来遍历JSON对象。以下是使用`play-json`库的示例代码： 首先，确保在项目的构建文件中添加了`play-json`库的依赖。 ```scala libraryDependencies += ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值