联系我们 - 广告服务 - 联系电话:
您的当前位置: > 综合 > > 正文

环球快消息!Scala进阶之路-面向对象编程之类的成员详解

来源:CSDN 时间:2023-01-31 14:03:01

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

责任编辑:

标签:

相关推荐:

精彩放送:

新闻聚焦
Top