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.scalaimport 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 Herolvbu.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 Persondef main(args: Array[String]): Unit = {// 2创建一个Student类对象实例，并设置name为“张三”val s = new Students.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 Persondef 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 = Students.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 Studentprintln(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 Persondef 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 Persondef 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_Iabstract 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_Idef main(args: Array[String]): Unit = {val s = new Studentval p = new Policemanprintln(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方法，通过创建匿名内部类的方式来实现Persondef 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 ConsoleLoggerc.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 MessageWorkerw.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.scalaimport 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 PaymentServicep.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 Personp.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=23println(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 == bprintln(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 Sexcase 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)}
}

scala相关操作（三）相关推荐

1. rabbitmq 持久化_RabbitMQ原理与相关操作(三)消息持久化

   现在聊一下RabbitMQ消息持久化: 问题及方案描述 1.当有多个消费者同时收取消息,且每个消费者在接收消息的同时,还要处理其它的事情,且会消耗很长的时间.在此过程中可能会出现一些意外,比如消息接收 ...

2. 快学Scala习题解答—第三章 数组相关操作

   原文链接:http://blog.csdn.net/ivan_pig/article/details/8257365 ----------------------------------------- ...

3. Git入门与使用 (三) 使用GitHub进行代码托管的相关操作

   文章目录 一.前言 二.使用GitHub进行代码托管的相关操作 1.推送本地仓库内容至远程仓库 2.克隆远程仓库内容至本地仓库 3.邀请他人加入项目团队 4.拉取远程仓库修改的内容 5.解决协同开发时 ...

4. Hbase table DDL操作及scala API操作

   Hbase shell操作table 建表 直接创建 ns3 是namespace,emp是表,base_info是列簇 hbase(main):037:0> create 'ns3:emp', ...

5. 2021年大数据HBase（五）：HBase的相关操作JavaAPI方式

   全网最详细的大数据HBase文章系列,强烈建议收藏加关注! 新文章都已经列出历史文章目录,帮助大家回顾前面的知识重点. 目录 系列历史文章 前言 HBase的相关操作-JavaAPI方式 一.需求说明 ...

6. 2021年大数据HBase（四）：HBase的相关操作-客户端命令式！【建议收藏】

   全网最详细的大数据HBase文章系列,强烈建议收藏加关注! 新文章都已经列出历史文章目录,帮助大家回顾前面的知识重点. 目录 系列历史文章 前言 HBase的相关操作-客户端命令式 1.进入HBase ...

7. 2021年大数据Spark（二十五）：SparkSQL的RDD、DF、DS相关操作

     目录 RDD.DF.DS相关操作 SparkSQL初体验 SparkSession 应用入口 获取DataFrame/DataSet 使用样例类 指定类型+列名 自定义Schema ​​​​​​​ ...

8. Linux之用户相关操作

   Linux之用户相关操作 1. 创建用户  [创建后会立即让设置密码] 命令 说明 useradd 创建(添加)用户 useradd命令选项: 选项 说明 -m 自动创建用户主目录,主目录的名字就是用 ...

9. java导入包大全_eclipse快速导入jar包的相关操作步骤

   eclipse怎样快速导入jar包呢?熟悉这款软件是非常简单的,今天小编就分享了关于eclipse快速导入jar包,有需要的朋友一起来看看吧! eclipse快速导入jar包的相关操作步骤 方法1·最 ...

最新文章

1. Visual C++ 确定要使用的链接方法
2. Day6 Pyhton基础之文件操作（五）
3. P1119 灾后重建(经典floyd)
4. 【学习排序】 Learning to Rank 中Listwise关于ListNet算法讲解及实现
5. JSP、ASP、PHP Web应用程序怎么这么多P！
6. package 和 install的区别
7. 开发者的 Big Day！亚马逊 re:Invent 2020 参会学习攻略来啦～
8. PCL之点云分割算法概述
9. python是什么 自学-python自学需要什么软件？
10. oracle行号排序问题
11. Ubuntu下PDF编辑软件pdfedit
12. ps把图片无损放大的方法
13. qq邮箱foxmail imap服务器,开通IMAP服务 用Foxmail远程遥控QQ邮箱
14. 支付宝沙箱版app登入失败账户不存在问题
15. 文件MD5/SHA等校验码校验
16. 一个免费识别验证码的接口
17. python发朋友圈突破朋友圈限制_突破限制！原来朋友圈可以发长达5分钟的视频，后悔没早点知道...
18. 《响应式Web图形设计》一1.4　布置页面内容
19. OFFICE中的VBA库的定义
20. 虎从风跃，龙借云行--神行者Wi10无线移动硬盘开启WIFI无线存储共享新时代_MID论坛_太平洋电脑网产品论坛...

热门文章

1. 双态运维：如何让CMDB配置维护更贴近人性
2. 长风破浪正其时，Python天堑变通途（1）（print和if）
3. M701-R USB 驱动
4. 华为T8951一键root（附教程）
5. Python+selenium 实现自动化163邮箱登录并发送邮件
6. IT行业项目解决方案编写策略
7. TVB举行台庆亮灯仪式 帝后大热门黎耀祥邓萃雯抢眼
8. 败给深蓝20年后，棋王卡斯帕罗夫说：智能机器不是人类的威胁
9. 常用开发语言及相应框架
10. hmm 求隐藏序列_隐马尔可夫模型HMM