【天天新视野】Scala进阶之路-面向对象编程之类的成员详解

来源：CSDN 时间：2023-02-01 14:19:14

Scala进阶之路-面向对象编程之类的成员详解

(资料图)

作者：尹正杰

一.Scala中的object对象及apply方法

1>.scala 单例对象

在Scala中，是没有static这个东西的，但是它也为我们提供了单例模式的实现方法，那就是使用关键字object。注意：object 对象是不能带参数的。

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass 7 8 /** 9 * 1>.在scala中的object是一个单例对象，没办法new，因为它的构造方法被私有化了10 * 2>.Object中定义的成员变量和方法都是静态的11 * 3>.可以通过"类名.方法"或者 "对象名.成员变量"12 *13 */14 object ScalaStatic {15 val name:String = "尹正杰"16 var age:Int = 1817 18 def sayHello(): Unit ={19 println("Hi,I"m yinzhengjie !")20 }21 22 //注意:如果调用者没有指定方法，默认会调用apply方法哟！23 def apply(habby:String) = {24 println(s"我的爱好是:${habby}")25 }26 }

2>.接下来我们一起测试如何访问一个Object的成员变量和方法，具体代码如下：

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass 7 8 object Demo { 9 def main(args: Array[String]): Unit = {10 //直接“类名.成员变量”就可以访问非私有的变量11 var res1 = ScalaStatic.age12 print(s"res1=====> ${res1}\n")13 //对单例模式的类中的非私有成员变量进行修改操作，但前提是这个变量需要用关键字var来声明14 ScalaStatic.age = 2615 print(s"res1=====> ${res1}\n")16 17 ScalaStatic.sayHello()18 19 //如果没有指定方法，默认会调用apply方法哟！20 ScalaStatic.apply("篮球")21 ScalaStatic("乒乓球")22 }23 }

3>.验证Object编译后文件内容

二.Scala中类的定义及构造器的使用

1>.子定义Scala的Teacher类

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass; 7 8 /** 9 * 关于构造器的注意事项:10 *11 * 1>.在Scala中定义类用class关键字修饰，这个类名称后面的构造器叫主构造器。类的主构造器中的属性会定义成类的成员变量。一个类12 * 只能有一个主构造器，但是可以有多个辅助构造器；13 * 2>.如果住构造器中成员属性没有val或者var修饰的话，该属性不能被访问，相当于对外没有提供get方法；14 * 3>.如果成员属性使用var修饰的话，相当于对外提供了getter和setter方法；15 * 4>.如果成员属性使用val修饰的话，相当于对外只提供了getter方法，因为val用于修饰不可变数据类型，类似与Java中定义常量的关键字“final”；16 * 5>.辅助构造器是完成赋值操作的，辅助构造器是内部需要调用主构造器或者其它辅助构造器；17 */18 class Teacher(var name:String,val age:Int) {19 20 //定义sex和blog成员变量，让其默认值为null，我们可以用"_"表示为null。21 var sex:String = _22 var blog:String = _23 24 //定义辅助构造器一，辅助构造器需要调用主构造器25 def this(name:String,age :Int,sex:String)={26 //在辅助构造器中必须先调用主构造器27 this(name,age)28 this.sex = sex29 }30 31 //定义辅助构造器二，辅助构造器如果不调用主构造器那么必须得调用其它的辅助构造器32 def this(name:String,age:Int,sex:String,blog:String)={33 //调用其它辅助构造器，在上面的一个辅助构造器中调用了主构造器34 this(name,age,sex)35 this.blog = blog36 }37 38 }

2>.使用Scala的单列类调用自定义Teacher类

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass 7 8 object Demo { 9 10 def main(args: Array[String]): Unit = {11 //调用带有两个参数的主构造器12 val t1 = new Teacher("尹正杰",18)13 println(s"姓名:${t1.name},年龄:${t1.age}")14 15 //调用带有3个参数的辅助构造器16 val t2 = new Teacher("尹正杰",20,"男")17 println(s"姓名:${t2.name},年龄:${t2.age},性别:${t2.sex}")18 19 //调用带有4个参数的辅助构造器20 val t3 = new Teacher("尹正杰",26,"男","https://www.cnblogs.com/yinzhengjie")21 println(s"姓名:${t3.name},年龄:${t3.age},性别:${t3.sex},博客:${t3.blog}")22 }23 }24 25 26 27 /*28 以上代码输出几个如下:29 姓名:尹正杰,年龄:1830 姓名:尹正杰,年龄:20,性别:男31 姓名:尹正杰,年龄:26,性别:男,博客:https://www.cnblogs.com/yinzhengjie32 */

三.Scala类的访问权限

1>.Scala类的构造器访问权限

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass; 7 8 /** 9 * 关于构造器的访问权限：10 * 在构造器前加修饰权限就可以设置相应的相应的访问权限，如果你想让主构造器私有化，只需要在主构造器前加private修饰即可。当然这种方法也适用于辅助构造器11 */12 class Teacher private (var name:String,val age:Int) {13 14 //定义sex和blog成员变量，让其默认值为null，我们可以用"_"表示为null。15 var sex:String = _16 var blog:String = _17 18 //定义辅助构造器一，辅助构造器需要调用主构造器,我们想要将这个辅助构造器私有化，只需要在def前面加一个private修饰符即可。19 private def this(name:String,age :Int,sex:String)={20 //在辅助构造器中必须先调用主构造器21 this(name,age)22 this.sex = sex23 }24 25 //定义辅助构造器二，辅助构造器如果不调用主构造器那么必须得调用其它的辅助构造器26 def this(name:String,age:Int,sex:String,blog:String)={27 //调用其它辅助构造器，在上面的一个辅助构造器中调用了主构造器28 this(name,age,sex)29 this.blog = blog30 }31 }

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass 7 8 object Demo { 9 10 def main(args: Array[String]): Unit = {11 //调用带有4个参数的辅助构造器12 val t3 = new Teacher("尹正杰",26,"男","https://www.cnblogs.com/yinzhengjie")13 println(s"姓名:${t3.name},年龄:${t3.age},性别:${t3.sex},博客:${t3.blog}")14 }15 }16 17 18 19 /*20 以上代码输出几个如下:21 姓名:尹正杰,年龄:26,性别:男,博客:https://www.cnblogs.com/yinzhengjie22 */

Demo.scala 文件内容（调用辅助构造方法案例展示）

2>.Scala类的成员属性访问权限

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass; 7 8 /** 9 * 关于类的成员属性访问权限 :10 * 如果类的主构造器中成员变量是private修饰的，它的setter和getter方法都是私有的，外部不能访问11 */12 class Teacher(var name:String,private val age:Int) {13 14 }

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass 7 8 object Demo { 9 10 def main(args: Array[String]): Unit = {11 //调用带有4个参数的辅助构造器12 val t1 = new Teacher("尹正杰",26)13 //由于主构造方法的age字段被私有化了，因此就没法通过getter或者setter方法访问啦！因此我们只可以访问name字段！14 println(s"姓名:${t1.name}")15 }16 }17 18 19 20 /*21 以上代码输出几个如下:22 姓名:尹正杰23 */

Demo.scala 文件内容（调用主构造方法案例展示）

3>.Scala中的类的访问权限（可见性）

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass; 7 8 /** 9 *10 * 类的访问权限11 * 类的前面加上private[this] 标识这个类在当前包下都可见，当前包下的子包不可见12 * 类的前面加上private[包名] 表示这个类在当前包及其子包下都可见13 */14 private[scalaClass] class Teacher(var name:String,val age:Int) {15 16 //定义sex和blog成员变量，让其默认值为null，我们可以用"_"表示为null。17 var sex:String = _18 var blog:String = _19 20 //定义辅助构造器一，辅助构造器需要调用主构造器,我们想要将这个辅助构造器私有化，只需要在def前面加一个private修饰符即可。21 private def this(name:String,age :Int,sex:String)={22 //在辅助构造器中必须先调用主构造器23 this(name,age)24 this.sex = sex25 }26 27 //定义辅助构造器二，辅助构造器如果不调用主构造器那么必须得调用其它的辅助构造器28 def this(name:String,age:Int,sex:String,blog:String)={29 //调用其它辅助构造器，在上面的一个辅助构造器中调用了主构造器30 this(name,age,sex)31 this.blog = blog32 }33 }

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass.scala 7 8 import cn.org.yinzhengjie.scalaClass.Teacher 9 10 object Demo {11 12 def main(args: Array[String]): Unit = {13 //调用带有4个参数的辅助构造器14 val t1 = new Teacher("尹正杰",26,"男","https://www.cnblogs.com/yinzhengjie")15 println(s"姓名:${t1.name},年龄:${t1.age},性别:${t1.sex},博客:${t1.blog}")16 }17 }18 19 20 21 /*22 以上代码输出几个如下:23 姓名:尹正杰,年龄:26,性别:男,博客:https://www.cnblogs.com/yinzhengjie24 */

Demo.scala 文件内容（调用辅助构造方法案例展示）

四.Scala中的伴生对象

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass; 7 8 /** 9 * 关于构造器的注意事项:10 * 1>.在Scala中定义类用class关键字修饰，这个类名称后面的构造器叫主构造器。类的主构造器中的属性会定义成类的成员变量。一个类11 * 只能有一个主构造器，但是可以有多个辅助构造器；12 * 2>.如果住构造器中成员属性没有val或者var修饰的话，该属性不能被访问，相当于对外没有提供get方法；13 * 3>.如果成员属性使用var修饰的话，相当于对外提供了getter和setter方法；14 * 4>.如果成员属性使用val修饰的话，相当于对外只提供了getter方法，因为val用于修饰不可变数据类型，类似与Java中定义常量的关键字“final”；15 * 5>.辅助构造器是完成赋值操作的，辅助构造器是内部需要调用主构造器或者其它辅助构造器；16 *17 * 类的成员属性访问权限：18 * 如果类的主构造器中成员属性是private修饰的，它的set 和 get方法都是私有的，外部不能访问19 *20 *21 * 类的构造器访问权限22 * 在构造器前加修饰权限23 * private 在主构造器之前，这说明该类的主构造器是私有的，外部类或者外部对象不能访问24 * 也适用于辅助构造器25 *26 * 类的访问权限27 * 类的前面加上private[this] 标识这个类在当前包下都可见，当前包下的子包不可见28 * 类的前面加上private[包名] 表示这个类在当前包及其子包下都可见29 */30 private[scalaClass] class Teacher(var name:String,val age:Int) {31 //定义sex和blog成员变量，让其默认值为null，我们可以用"_"表示为null。32 var sex:String = _33 var blog:String = _34 //定义辅助构造器一，辅助构造器需要调用主构造器,我们想要将这个辅助构造器私有化，只需要在def前面加一个private修饰符即可。35 private def this(name:String,age :Int,sex:String)={36 //在辅助构造器中必须先调用主构造器37 this(name,age)38 this.sex = sex39 }40 //定义辅助构造器二，辅助构造器如果不调用主构造器那么必须得调用其它的辅助构造器41 def this(name:String,age:Int,sex:String,blog:String)={42 //调用其它辅助构造器，在上面的一个辅助构造器中调用了主构造器43 this(name,age,sex)44 this.blog = blog45 }46 }47 48 /**49 * 注意：“object Teacher”是“class Teacher”的伴生对象50 */51 object Teacher{52 53 /**54 * 定义apply方法帮我们创建出“class Teacher”的实例，如果调用者在没有指明具体方法时，默认就会调用该方法。55 */56 def apply(name: String, age: Int): Teacher = {57 // 初始化工作58 new Teacher(name, age, "男", "http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/")59 }60 61 62 def main(args: Array[String]): Unit = {63 //我们直接调用伴生对象的apply方法，当然apply方法我们可以省略不写。64 val t1 = Teacher("尹正杰",18)65 println(s"姓名:${t1.name},年龄:${t1.age},性别:${t1.sex},博客:${t1.blog}")66 67 //调用带有4个参数的辅助构造器68 val t2 = new Teacher("尹正杰",26,"男","https://www.cnblogs.com/yinzhengjie")69 println(s"姓名:${t2.name},年龄:${t2.age},性别:${t2.sex},博客:${t2.blog}")70 }71 }72 73 74 /*75 以上代码执行结果如下 :76 姓名:尹正杰,年龄:26,性别:男,博客:https://www.cnblogs.com/yinzhengjie77 */

五.Scala特质Trait使用

1>.Scala特质Trait定义使用

特质（Trait)相当于Java中的Interface，只不过特质（Trait)要比Java中的interface要强大的多，因为特质（Trait)可以定义已经实现的方法，也可以定义没有实现的方法。

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass 7 8 9 /**10 * Scala的中的接口叫做特质，关键字为trait。11 * 在Scala中也没有“implements”关键字，只有“extends”关键字12 * 在Scala特质中可以定义有实现的方法，也可以定义没有实现的方法13 */14 trait ScalaTrait {15 /**16 * 定义有实现的方法17 */18 def sayHello()={19 println("I"m Yinzhengjie!")20 }21 /**22 * 定义没有实现的方法23 */24 def playGame(name:String)25 }

ScalaTrait.scala 文件内容

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass 7 8 class ScalaTraitImpl extends ScalaTrait { 9 10 /**11 * 如果特质中playGame方法没有实现的话，子类在实现的时候可以不加override关键字也可以加12 */13 def playGame(name: String): Unit = {14 println(s"${name} 正在玩游戏！")15 }16 17 /**18 * 如果特质中某个方法有具体的实现，在子类继承重写的时候，必须使用override关键字19 */20 override def sayHello(): Unit = {21 //我们的重写过程需要其实就是调用父类的方法22 super.sayHello()23 }24 25 }26 27 /**28 * 注意：“object ScalaTraitImpl”是“class ScalaTraitImpl”的伴生对象29 */30 object ScalaTraitImpl{31 def main(args: Array[String]): Unit = {32 val s1 = new ScalaTraitImpl()33 s1.sayHello()34 s1.playGame("尹正杰")35 }36 }37 38 39 /*40 以上代码执行结果如下:41 I"m Yinzhengjie!42 尹正杰正在玩游戏！43 */

2>.Scala中混入特质的两种方式

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass 7 8 9 /**10 * Scala的中的接口叫做特质，关键字为trait。11 * 在Scala中也没有“implements”关键字，只有“extends”关键字12 * 在Scala特质中可以定义有实现的方法，也可以定义没有实现的方法13 */14 trait ScalaTrait {15 /**16 * 定义有实现的方法17 */18 def sayHello()={19 println("I"m Yinzhengjie!")20 }21 /**22 * 定义没有实现的方法23 */24 def playGame(name:String)25 }

ScalaTrait.scala 文件内容

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass 7 8 trait Bird { 9 /**10 * 定义有实现的方法11 */12 def fly(name:String): Unit ={13 println(s"${name} 正在天上飞......")14 }15 /**16 * 定义没有实现的方法17 */18 def sing()19 }

Bird.scala 文件内容

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass 7 8 /** 9 * 在定义类时，我们可以用将多个特质混在一起，第一个特质使用extends连接，后续的特质依次使用with连接即可。10 */11 class ScalaTraitImpl extends ScalaTrait with Bird {12 13 /**14 * 如果特质中playGame方法没有实现的话，子类在实现的时候可以不加override关键字也可以加15 */16 def playGame(name: String): Unit = {17 println(s"${name} 正在玩游戏！")18 }19 20 /**21 * 如果特质中某个方法有具体的实现，在子类继承重写的时候，必须使用override关键字22 */23 override def sayHello(): Unit = {24 //我们的重写过程需要其实就是调用父类的方法25 super.sayHello()26 }27 28 /**29 * 定义有实现的方法30 */31 override def fly(name: String): Unit = super.fly(name)32 33 def sing(): Unit = {34 println("Sing a song!")35 }36 }37 38 39 /**40 * 注意：“object ScalaTraitImpl”是“class ScalaTraitImpl”的伴生对象41 */42 object ScalaTraitImpl{43 def main(args: Array[String]): Unit = {44 /**45 * 在Scala中可以动态混入N个特质，各个特质之间使用关键字with连接即可46 */47 val s1 = new ScalaTraitImpl with Bird with ScalaTrait48 s1.sayHello()49 s1.playGame("尹正杰")50 s1.sing()51 s1.fly("猫头鹰")52 }53 }54 55 56 /*57 以上代码执行结果如下:58 I"m Yinzhengjie!59 尹正杰正在玩游戏！60 Sing a song!61 猫头鹰正在天上飞......62 */

六.Scala中得抽象类abstract

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass 7 8 /** 9 * 1>.使用关键字abstract定义一个抽象类10 * 2>.抽象类可以具体实现方法11 * 3>.也可以有具体实现的方法12 */13 abstract class AbstractClass {14 def eat(food:String):String15 16 def sayHello() = {17 println("I"m yinzhengjie!")18 }19 }

AbstractClass.scala 文件内容

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass 7 8 trait Teacher { 9 def palyGame(name:String):String10 11 def teaching(name:String): Unit ={12 println(s"${name} 正在教学生！")13 }14 }

Teacher.scala 文件内容

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass 7 8 9 /**10 * 1>.在Scala中第一个继承抽象类或者特质，只能使用关键字extends11 * 2>.如果想继承多个独特的话，可以在extends之后使用with关键字。12 */13 object AbstractClassImpl extends AbstractClass with Teacher {14 override def sayHello(): Unit = {15 super.sayHello()16 }17 18 def eat(food: String): String = {19 "炒着吃" + food20 }21 22 override def palyGame(name: String): String = {23 s"$name 正在打王者荣耀哟......."24 }25 26 def main(args: Array[String]): Unit = {27 AbstractClassImpl.sayHello()28 val res1 = AbstractClassImpl.eat("腊肉")29 println(s"res1 =====> ${res1}")30 }31 }

七.Scala中得final和type

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass 7 8 trait Teacher { 9 10 /**11 * 使用type关键字定义一个自定义类型Yinzhengjie，这个类型并没有被确定，而是让继承者自己去指定。12 */13 type Yinzhengjie14 15 final def Bodybuilding(s:Yinzhengjie)={16 println(s"${s} 正在健身....")17 }18 19 20 def palyGame(name:String):String21 22 /**23 * 由于teaching方法被我加了关键字final，因此这个方法没法重写（override）！24 */25 final def teaching(name:String): Unit ={26 println(s"${name} 正在教学生！")27 }28 }

Teacher.scala 文件内容

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass 7 8 /** 9 * 1>.使用关键字abstract定义一个抽象类10 * 2>.抽象类可以具体实现方法11 * 3>.也可以有具体实现的方法12 */13 abstract class AbstractClass {14 def eat(food:String):String15 16 /**17 * 由于sayHello方法被我加了关键字final，因此这个方法没法重写（override）！18 */19 final def sayHello() = {20 println("I"m yinzhengjie!")21 }22 }

AbstractClass.scala 文件内容

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass 7 8 9 /**10 * final关键字:11 * 1>.在Scala中，final修饰的类或者方法或者成员变量，不能被重写12 * 2>.如果使用final关键字修饰类，则该类不能被继承13 * 3>.如果使用final关键字修饰方法，则该方法不能被重写（override）14 * 4>.如果使用final关键字修饰成员变量，则该成员变量不能被重新修改（无法再次赋值）15 * type关键字:16 * 我们可以理解type的功能就是一个别名。17 */18 final object AbstractClassImpl extends AbstractClass with Teacher {19 20 /**21 * 我们在继承的时候，需要指定“Yinzhengjie”的类型，比如我们此处指定其类型为String。22 */23 type Yinzhengjie = String24 25 def eat(food: String): String = {26 "炒着吃" + food27 }28 29 override def palyGame(name: String): String = {30 s"$name 正在打王者荣耀哟......."31 }32 33 def main(args: Array[String]): Unit = {34 AbstractClassImpl.sayHello()35 val res1 = AbstractClassImpl.eat("腊肉")36 println(s"res1 =====> ${res1}")37 AbstractClassImpl.Bodybuilding("尹正杰")38 39 }40 }41 42 43 /*44 以上代码执行结果如下:45 I"m yinzhengjie!46 res1 =====> 炒着吃腊肉47 尹正杰正在健身....48 */

八.Scala中样例类和样例对象

样例类是特殊类，经过了优化处理，经常用于模式匹配。好处是内置实现了众多scala常用的功能，比如serializable、compare、apply、unapply

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.scalaClass 7 8 /** 9 * 样例类:10 * 1>.在类前加关键字case就是一个样例类11 * 2>.它支持模式匹配，默认实现了Serializable接口12 * 3>.具体格式为:case class Message(属性......)13 *14 * 定义变量规则:15 * 1>.类名的定义首字母大写推荐使用驼峰式；16 * 2>.属性名称第一个字母小写；17 * 一个标准的命名规则是一个资深开发的基础。18 */19 case class Message(name:String,countent:String) {20 21 }22 23 24 /**25 * 样例对象:26 * 1>.用于模式匹配27 * 2>.样例对象不能封装数据28 * 3>.样例对象格式:case opject 对象名29 */30 case object MonitorServer31 32 object CaseDemo{33 def main(args: Array[String]): Unit = {34 val message = new Message("杨幂","今天晚上要拍戏......")35 println(message.name)36 println(message.countent)37 }38 }39 40 /*41 以上代码输出结果如下 :42 杨幂43 今天晚上要拍戏......44 */

九.Scala中得模式匹配---match case

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.function 7 8 object People { 9 10 val (name,age) = ("尹正杰",26)11 12 def sayHello(): Unit ={13 println("I"m yinzhengjie!")14 }15 16 def init(): String ={17 s"姓名:$name,年龄:${age}"18 }19 }

People.scala 文件内容（自定义类）

1 /* 2 @author :yinzhengjie 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/ 4 EMAIL:y1053419035@qq.com 5 */ 6 package cn.org.yinzhengjie.function 7 8 import java.awt.Color 9 10 11 /** 12 * 模式匹配 match case 13 * 一旦一个case 匹配上了，就不会再往下匹配了 14 */ 15 object PatternMatching { 16 def main(args: Array[String]): Unit={ 17 matchingConstant(Color.orange) 18 contentMatch("yinzhengjie") 19 typeMatch(2018) 20 typeMatch(true) 21 arrayMatch(Array(8)) 22 listMatch(1::2::3::Nil) 23 tupleMatch((0, 1)) 24 objMatch(1,2) 25 objMatch(People) 26 } 27 /** 28 * 匹配对象 29 */ 30 def objMatch(obj: Any) = { 31 val res = obj match { 32 case (x, y) =>s"$x $y" 33 case Int => "int" 34 case People => People.init() 35 case _ => "匹配失败!" 36 } 37 println(res) 38 } 39 /** 40 * 匹配元组 41 */ 42 def tupleMatch(tuple: Any) = { 43 val res = tuple match{ 44 case (0, _) => "元组的第一个元素为0，第二个元素为任意类型的数据，且只有2个元素" 45 case (a, b, c) => "拥有三个元素的元组" 46 case (_, "98K + 八倍镜") => "[98K + 八倍镜] 套装" 47 case _ => "匹配失败!" 48 } 49 println(res) 50 } 51 /** 52 * 匹配List 53 */ 54 def listMatch(list: Any) = { 55 val res = list match{ 56 case 0::Nil => "只有一个0元素的List" 57 case 7::9::Nil => "只有7和9元素的List" 58 case x::y::z::Nil => "只有三个元素的List" 59 case m::n if n.length > 0 => "------" // 拥有head，和 tail的数组， “if n.length > 0” 是守卫条件 60 case _ => "匹配失败!" 61 } 62 println(res) 63 } 64 /** 65 * 匹配Array 66 */ 67 def arrayMatch(arr: Any) = { 68 val res = arr match { 69 case Array(0) => "只有一个0元素的数组" 70 case Array(0, _) => "以0开头的，拥有2个元素的数组" 71 case Array(1, _, 3) => "已1开头，3结尾，中间为任意元素的三个元素的数组" 72 case Array(8, _*) => "已8开头，N个元素的数组" // _*标识0个或者多个任意类型的数据 73 case _ => "匹配失败!" 74 } 75 println(res) 76 } 77 /** 78 * 匹配数据类型 79 */ 80 def typeMatch(tp: Any) = { 81 val res = tp match{ 82 case x: Int => s"Int $x" 83 case y: Long => s"Long $y" 84 case z: Boolean => s"boolean $z" 85 case _ => "匹配失败!" 86 } 87 println(res) 88 } 89 /** 90 * 匹配字符串内容 91 */ 92 def contentMatch(str: String) = { 93 val res = str match{ 94 case "yinzhengjie" => "尹正杰" 95 case "Python" => "Python" 96 case "Golang" => "Golang" 97 case "Java" => "Java" 98 case "2018" => "2018" 99 case _ => "匹配失败!" // "_"用于任意内容100 }101 println(res)102 }103 /**104 * 匹配常量 + 守卫条件105 * 扩展常量问题:大写会识别成常量，小写是变量，如果让小写也是常量，使用``标出106 */107 def matchingConstant(color: Color)={108 val res = color match {109 case Color.RED => "红色" //case Color.RED 匹配结果为 "红色"，下面两行代码类似。110 case Color.GREEN => "绿色"111 case Color.yellow => "黄色"112 case _ if color == Color.orange => "恭喜你，中奖了！" //这里定义的就是守卫条件。113 case _ => "匹配失败!" //case _ 表示匹配任意类型。换句话说，这里定义的是默认匹配情况，即上面的3中匹配均无效。114 }115 println(res)116 }117 }118 119 120 121 /*122 以上代码执行结果如下 :123 恭喜你，中奖了！124 尹正杰125 Int 2018126 boolean true127 已8开头，N个元素的数组128 只有三个元素的List129 元组的第一个元素为0，第二个元素为任意类型的数据，且只有2个元素130 1 2131 姓名:尹正杰,年龄:26132 */

十.密封样例类

必须将样例子类和父类定义在一个scala文件中。

//必须将样例子类和父类定义在一个scala文件中。sealed abstract class Dogcase class Jing8(var name:String) extends Dogcase class HaShiQi(var name:String) extends Dog

标签：

上一篇：react项目中最新组件不能完成热更新的原因是什么？
下一篇：最后一页