• 2023_Spark_实验五：Scala面向对象部分演示（一）（IDEA开发）

    1、面向对象的基本概念

    把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象，面向

    对象的三大特征：

    •  封装

    •  继承

    •  多态

    2、类的定义

    简单类和无参方法

    1.  
    2. class Counter{
    3.  
    4. private var value =0;
    5.  
    6. def increment() { value+=1};
    7.  
    8. def current() =value;
    9.  
    10. }
    11.  
    12.  
    13.  
    14. //注意：class 前面没有public 关键字修饰

    如果要开发main方法，需要将main方法定义在该类的伴生对象中，即：object对

    象中，（后续做详细的讨论）：

    1.  
    2. class Counter{
    3.  
    4. private var value =0;
    5.  
    6. def increment() { value+=1};
    7.  
    8. def current() =value;
    9.  
    10. }
    11.  
    12.  
    13.  
    14. //Scala 中类的定义
    15.  
    16. class Student1{
    17.  
    18. //定义属性
    19.  
    20. private var stuName:String = "Tom"
    21.  
    22. private var stuAge:Int =20
    23.  
    24.  
    25.  
    26. //成员方法
    27.  
    28. def getStuName():String = stuName
    29.  
    30. def setStuName(newName:String) =this.stuName=newName
    31.  
    32.  
    33.  
    34. def getStuAge():Int = stuAge
    35.  
    36. def setStuAge(newAge:Int) = this.stuAge=newAge
    37.  
    38. }
    39.  
    40.  
    41.  
    42. object student {
    43.  
    44. def main(args: Array[String]): Unit = {
    45.  
    46. //测试student1
    47.  
    48. var s1 = new Student1
    49.  
    50.  
    51.  
    52. //第一次输出
    53.  
    54. println(s1.getStuName() + "\t" + s1.getStuAge())
    55.  
    56.  
    57.  
    58. //调用set方法
    59.  
    60. s1.setStuName("Mary")
    61.  
    62. s1.setStuAge(25)
    63.  
    64.  
    65.  
    66. //第二次输出
    67.  
    68. println(s1.getStuName() + "\t" + s1.getStuAge())
    69.  
    70.  
    71.  
    72. //第三次输出
    73.  
    74. // println(s1.stuName + "\t" + s1.stuAge)
    75.  
    76.  
    77.  
    78. }
    79.  
    80. }

    3、属性的getter和setter方法

    当定义属性是private时候，scala会自动为其生成对应的get和set方法，如下所

    示：

    private var stuName:String = "Tom"

    get方法: stuName ----> s2.stuName() 由于stuName是方法的名字，所

    以可以加上一个括号

    set方法: stuName_= ----> stuName_= 是方法的名字

    定义属性：private var money:Int = 1000 希望money只有get方法，没有

    set方法？？

    办法：将其定义为常量private val money:Int = 1000

    private[this]的用法：该属性只属于该对象私有，就不会生成对应的set和

    get方法。如果这样，就不能直接调用，例如：s1.stuName ---> 错误

    1.  
    2. //属性的get 和 set 方法
    3.  
    4. /*
    6. 1.当定义属性是private 时候，scala会自动为其生成对应的get 和set方法
    8. private var stuName:String = "Tom"
    10. (1) get 方法：stuName ----> s2.stuName()
    12. (2) set 方法：stuName_=
    16. 2.定义属性：private var money:Int = 1000 希望money只有get方法，没有set方法？
    18. 方法：将其定义为常量private val money:Int = 1000
    22. 3.private[this]
    24. 3.private[this]的方法：该属性只属于该对象私有，就不会生成对应的set和get方法
    26. */
    27.  
    28.  
    29.  
    30. class Student2 {
    31.  
    32. //定义属性
    33.  
    34. private var stuName:String = "Tom"
    35.  
    36. //private [this] var stuAge:Int =20
    37.  
    38. private var stuAge:Int = 20
    39.  
    40. private val money:Int = 1000
    41.  
    42.  
    43.  
    44. }
    45.  
    46.  
    47.  
    48. //测试
    49.  
    50. object Student2 {
    51.  
    52.  
    53.  
    54. def main(args: Array[String]): Unit = {
    55.  
    56. var s2 = new Student2
    57.  
    58. println(s2.stuName + "\t" + s2.stuAge)
    59.  
    60. println(s2.stuName + "\t" +s2.stuAge + "\t" + s2.money)
    61.  
    62.  
    63.  
    64. //修改money的值 --》 error
    65.  
    66. //s2.money = 2000
    67.  
    68.  
    69.  
    70. }
    71.  
    72. }

    4、内部类（嵌套类）

    我们可以在一个类的内部在定义一个类，如下：我们在Student类中，再定义了

    一个Course类用于保存学生选修的课程：

    1.  
    2. import scala.collection.mutable.ArrayBuffer
    3.  
    4.  
    5.  
    6. //嵌套类：内部类
    7.  
    8. class Student3 {
    9.  
    10. //定义一个内部类：记录学生选修的课程信息
    11.  
    12. class Course(val courseName:String,val credit:Int){
    13.  
    14. //定义其他方法
    15.  
    16. }
    17.  
    18. private var stuName:String = "Tom"
    19.  
    20. private var stuAge:Int = 20
    21.  
    22. //定义一个ArrayBuffer记录学生选修的所有课程
    23.  
    24. private var courseList = new ArrayBuffer[Course]()
    25.  
    26. //定义方法往学生信息中添加新的课程
    27.  
    28. def addNameCourse(cname:String,credit:Int): Unit ={
    29.  
    30. //创建新的课程
    31.  
    32. var c = new Course(cname,credit)
    33.  
    34. //将课程加入list
    35.  
    36. courseList += c
    37.  
    38. }
    39.  
    40. }
    41.  
    42.  
    43.  
    44. //测试
    45.  
    46. object Student3 {
    47.  
    48. def main(args: Array[String]): Unit = {
    49.  
    50. //创建学生对象
    51.  
    52. var s3 = new Student3
    53.  
    54. //给该学生添加新的课程
    55.  
    56. s3.addNameCourse("Chinese",2)
    57.  
    58. s3.addNameCourse("English",3)
    59.  
    60. s3.addNameCourse("Math",4)
    61.  
    62. //输出
    63.  
    64. println(s3.stuName + "\t" + s3.stuAge)
    65.  
    66. println("*********选修课程***********")
    67.  
    68. for (s <-s3.courseList) println(s.courseName + "\t" + s.credit)
    69.  
    70. }
    71.  
    72.  
    73.  
    74. }

    5、类的构造器

    类的构造器分为：主构造器、辅助构造器

    主构造器：和类的声明结合在一起，只能有一个主构造器

    Student4(val stuName:String,val stuAge:Int)

    (1) 定义类的主构造器：两个参数

    (2) 声明了两个属性：stuName和stuAge 和对应的get和set方法

    辅助构造器：可以有多个辅助构造器，通过关键字this来实现

    1.  
    2. /*
    4. 类的构造器
    6. 1.主构造器：和类的声明结合在一起；只能有一个主构造器
    8. Student4(val stuName:String,var stuAge:Int)
    10. (1)定义类的主构造器：两个参数
    12. (2)声明了两个属性：stuName和stuAge 和 对应的get 和 set 方法
    14. 2.辅助构造器：可以有多个辅助构造器
    16. 通过关键字this 来实现
    18. */
    19.  
    20.  
    21.  
    22. class Student4 (val stuName:String,val stuAge:Int) {
    23.  
    24. //定义辅助构造器
    25.  
    26. def this(age:Int){
    27.  
    28. //调用主构造器
    29.  
    30. this("no name",age)
    31.  
    32. }
    33.  
    34. }
    35.  
    36.  
    37.  
    38. object Student4 {
    39.  
    40. def main(args: Array[String]): Unit = {
    41.  
    42. //创建Student4的一个对象
    43.  
    44. var s4 = new Student4("Tom",20)
    45.  
    46. println(s4.stuName + "\t" +s4.stuAge)
    47.  
    48.  
    49.  
    50. //创建一个新的Student4 的对象
    51.  
    52. var s42 = new Student4(25)
    53.  
    54. println(s42.stuName + "\t" + s42.stuAge)
    55.  
    56. }
    57.  
    58.  
    59.  
    60. }

    6、Scala中的Object对象

    Scala没有静态的修饰符，但Object对象下的成员都是静态的 ，若有同名的

    class，这其作为它的伴生类。在Object中一般可以为伴生类做一些初始化等操

    作。下面是Java中的静态块的例子。在这个例子中，我们对JDBC进行了初始化：

    而Scala中的Object就相当于Java中静态块。

    在 Scala 中，是没有 static 这个东西的，但是它也为我们提供了单例模式的

    实现方法，那就是使用关键字 object。

    Scala 中使用单例模式时，除了定义的类之外，还要定义一个同名的 object 对

    象，它和类的区别是，object对象不能带参数。

    当单例对象与某个类共享同一个名称时，他被称作是这个类的伴生对象：

    companion object。你必须在同一个源文件里定义类和它的伴生对象。类被称为

    是这个单例对象的伴生类：companion class。类和它的伴生对象可以互相访问

    其私有成员。

    Object对象的应用

    单例对象

    1.  
    2. //利用object 对象实现单例模式
    3.  
    4. object CreditCard {
    5.  
    6. //变量保存信用卡号，这里比较好的做法，是定义成private[this],即：该属性只属于该对象,这个方法由于定义在object中，所以是静态的，即：单例的
    7.  
    8.  
    9.  
    10. private[this] var creditCardNumber:Long = 0
    11.  
    12.  
    13.  
    14. //产生新的卡号
    15.  
    16. def generateNewCCNumber():Long = {
    17.  
    18. creditCardNumber += 1
    19.  
    20. creditCardNumber
    21.  
    22. }
    23.  
    24. //测试程序
    25.  
    26. def main(args: Array[String]): Unit = {
    27.  
    28. //产生新的卡号
    29.  
    30. println(CreditCard.generateNewCCNumber())
    31.  
    32. println(CreditCard.generateNewCCNumber())
    33.  
    34. println(CreditCard.generateNewCCNumber())
    35.  
    36. println(CreditCard.generateNewCCNumber())
    37.  
    38. }
    39.  
    40. }

    使用应用程序对象：可以省略main方法；需要从父类App继承。

    1.  
    2. //使用应用程序对象，可以省略main方法
    3.  
    4. object HelloWorld extends App{
    5.  
    6.  
    7.  
    8. /*
    10. def main(args: Array[String]): Unit = {
    12. //这里的main就可以不写。相当于下面的代码是在main方法中执行的。
    14. }
    16. */
    17.  
    18. println("Hello World")
    19.  
    20. ///如何取得命令行的参数
    21.  
    22. if(args.length > 0) {
    23.  
    24. println(args(0))
    25.  
    26. }else{
    27.  
    28. println("no arguents")
    29.  
    30. }
    31.  
    32. }

  • 相关阅读:
    国产化之虚拟ARM64-CPU安装银河麒麟操作系统
    自学（黑客技术）方法——网络安全
    成功转行软件测试感受，一个从业3年的过来人告诉你
    Android开发：Camera2+MediaRecorder录制视频后上传到阿里云VOD
    网站入门：Flask用法讲解
    【MAPBOX基础功能】08、mapbox绘制点图层并进行添加、删除、更新、显隐等操作
    双连通与网络可靠性
    kubelet证书延期
    Vue 路由使用
    Netty02 - 回显服务器实例
  • 原文地址：https://blog.csdn.net/pblh123/article/details/132624431