Spark基础学习笔记15：Scala类和对象

Posted 2022-03-10 howard2005

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spark基础学习笔记15：Scala类和对象相关的知识，希望对你有一定的参考价值。

文章目录

零、本讲学习目标
一、类
- （一）类的定义
- （二）类的实例化
二、单例对象
- （一）单例对象概念
- （二）案例演示
三、伴生对象
- （一）伴生对象概念
- （二）案例演示
四、get和set方法
五、构造器
六、抽象类
七、特质
八、课后作业
- 任务：学生喂养三种宠物

零、本讲学习目标

掌握类的定义
理解单例对象和伴生对象
掌握构造器和辅助构造器
掌握抽象类和特质

一、类

（一）类的定义

对象是类的具体实例，类是抽象的，不占用内存，而对象是具体的，占用存储空间。
Scala中一个简单的类定义是使用关键字class，类名必须大写。类中的方法用关键字def定义
创建User类，包含三个私有属性和一个公共方法
说明：如果一个类不写访问修饰符，那么默认访问级别为public，这与Java是不一样的。

（二）类的实例化

关键字new用于创建类的实例
实例化User类，调用其speak()方法
访问私有属性name，系统会报错

二、单例对象

（一）单例对象概念

Scala中没有静态方法或静态字段，但是可以使用关键字object定义一个单例对象，单例对象中的方法相当于Java中的静态方法，可以直接使用“单例对象名.方法名”方式进行调用。单例对象除了没有构造器参数外，可以拥有类的所有特性。

（二）案例演示

创建Person单例对象，包含三个私有属性和一个公共方法
直接通过单例对象名调用其speak()方法

三、伴生对象

（一）伴生对象概念

当单例对象的名称与某个类的名称一样时，该对象被称为这个类的伴生对象。类被称为该对象的伴生类。类和它的伴生对象必须定义在同一个文件中，且两者可以互相访问其私有成员。

（二）案例演示

在net.hw.obj包里，创建Scala类Student，在文件里创建其伴生对象

package net.hw.obj

/**
  * 功能：演示伴生对象
  * 作者：华卫
  * 日期：2022年03月07日
  */
class Student 
  private var name = "李明文"

  def speak(): Unit = 
    // 访问伴生对象的私有成员
    println("年龄：" + Student.age)
  


object Student 
  private var age = 18

  def main(args: Array[String]): Unit = 
    var student = new Student()
    // 访问伴生类的私有成员
    println("姓名：" + student.name)
    // 调用半生类实例的方法
    student.speak()

运行程序，查看结果

四、get和set方法

（一）生成原则

Scala默认会根据类的属性的修饰符生成不同的get和set方法

1、val修饰的属性

系统会自动生成一个私有常量属性和一个公有get方法。

2、var修饰的属性

系统会自动生成一个私有变量属性和一对公有get/set方法。

3、private var修饰的属性

系统会自动生成一对私有get/set方法，相当于类的私有属性，只能在类的内部和伴生对象中使用。

4、private[this]修饰的属性

系统不会生成get/set方法，即只能在类的内部使用该属性。

（二）案例演示

任务1、利用系统自动生成的get和set方法

（1）创建Dog类

在net.hw.obj包里创建Dog类

（2）编译成字节码文件

将Dog.scala编译成Dog.class
在项目的out目录里，逐层点开，找到Dog，那就是生成字节码文件

（3）将字节码文件反编译为Java代码

使用Java反编译工具将字节码文件反编译为Java代码

package net.hw.obj;

import scala.reflect.ScalaSignature;

public class Dog 
  private final int id = 1;
  
  public int id() 
    return this.id;
  
  
  private String name = ";
  
  public String name() 
    return this.name;
  
  
  public void name_$eq(String x$1) 
    this.name = x$1;
  
  
  private String gender = ";
  
  private String gender() 
    return this.gender;
  
  
  private void gender_$eq(String x$1) 
    this.gender = x$1;
  
  
  private int age = 5;

（4）说明反编译生成的Java代码

使用name属性举例，在Scala中，get和set方法并非被命名为getName和setName，而是被命名为name和name_=，由于JVM不允许在方法名中出现=，因此=被翻译成$eq。
从上述代码可以看出，由于属性id使用val修饰，因此不可修改，只生成了与get方法对应的id()；属性name使用var修饰，因此生成了与get和set方法对应的name()和name_$eq()方法，且都为public；属性gender由于使用private var修饰，因此生成了private修饰的get和set方法 - gender()和gender_$eq()；属性age由于使用private[this]修饰，因此没有生成get和set方法，只能在类的内部使用。

（5）创建单例对象用来测试Dog类

创建TestDog单例对象

package net.hw.obj

/**
  * 功能：测试狗类
  * 作者：华卫
  * 日期：2022年03月08日
  */
object TestDog 
  def main(args: Array[String]): Unit = 
    // 创建Dog对象
    var dog: Dog = new Dog()
    // 访问id属性
    println("id: " + dog.id)
    // 设置name属性
    dog.name = "欢欢"
    // 访问name属性
    println("name: " + dog.name)

运行程序，查看结果
注意：本地私有属性age，不能访问
私有属性gender只有在伴生对象里可以访问，在非伴生对象TestDog里是无法访问的
创建Dog类的伴生对象，就可以访问Dog类的私有属性gender
运行程序，查看结果
即使伴生对象也无法访问伴生类的本地私有属性age

任务2、用户自己编写私有属性的Scala风格的get和set方法

注意：set方法的写法 —— 方法名_=
创建Cat类

package net.hw.obj

/**
  * 功能：猫类
  * 作者：华卫
  * 日期：2022年03月08日
  */
class Cat 
  private var privateName: String = "虎丸"

  // 定义get方法 - name
  def name: String = 
    privateName
  

  // 定义set方法 - name_=
  def name_=(name: String): Unit = 
    privateName = name
  


// 伴生对象
object Cat 
  def main(args: Array[String]): Unit = 
    val cat: Cat = new Cat()
    println("原来的名字：" + cat.name)
    cat.name_=("冰轮丸")
    println("现在的名字：" + cat.name)

运行程序，查看结果

任务3、用户自己编写私有属性的Java风格的get和set方法

注意：get方法 —— getXXX()，set方法——setXXX()
创建Bird类

package net.hw.obj

/**
  * 功能：鸟类
  * 作者：华卫
  * 日期：2022年03月08日
  */
class Bird 
  private var name = "玲玲"

  // get方法
  def getName: String = name

  // set方法
  def setName(name: String): Unit = 
    this.name = name
  


// 伴生对象
object Bird 
  def main(args: Array[String]): Unit = 
    val bird = new Bird()
    println("原来的名字：" + bird.getName)
    bird.setName("菲菲")
    println("现在的名字：" + bird.getName)

运行程序，查看结果

五、构造器

Scala中的构造器分为主构造器和辅助构造器。

（一）主构造器

1、构造器参数带val或var

主构造器的参数直接放在类名之后，且将被编译为类的成员变量，其值在初始化类时传入。注意，构造器参数必须指定类型
在net.hw.constructor包里创建Person类

package net.hw.constructor

/**
  * 功能：人类
  * 作者：华卫
  * 日期：2022年03月08日
  */
class Person (val name: String, var age: Int = 18) 
  def speak() :Unit = 
    println(name + "今年" + age + "岁了~")
  


// 伴生对象
object Person 
  def main(args: Array[String]): Unit = 
    // 调用主构造器初始化两个参数
    val person = new Person("李文华", 25)

    // 访问构造器参数，其实调用了name属性的get方法
    println("姓名：" + person.name)
    println("年龄：" + person.age)

    // 调用对象的方法
    person.speak()

运行程序，查看结果
注意：构造器两个参数，name是常量，不能再修改，age是变量，可以再修改

2、构造器参数带访问权限

可以通过对主构造器的参数添加访问修饰符来控制参数的访问权限
创建Person类，将参数age设置为私有的，参数name设置为不可修改（val）

class Person (val name: String, private var age: Int)

3、构造器参数不带var或val

构造参数也可以不带val或var，此时默认为private[this] val，这样会被编译成类的本地私有成员，不会生成get和set方法，只能在类的内部访问。

class Person (name: String, age: Int)

可以改写成带访问权限的参数

class Person (private[this] val name: String, private[this] val age: Int)

4、类的初始化语句

主构造器执行时，类中定义的语句作为初始化语句
在net.hw.constructor包里创建Dog类

package net.hw.constructor

/**
  * 功能：狗类
  * 作者：华卫
  * 日期：2022年03月08日
  */
class Dog (var name: String, var age: Int) 

  name = "瑞瑞"
  age = 5

  def speak(): Unit = 
    println(name + "今年" + age + "岁了~")
  


// 伴生对象
object Dog 
  def main(args: Array[String]): Unit = 
    val dog = new Dog("", 0)
    dog.speak()

运行程序，查看结果
说明：实例化Dog时，传入的参数是""与0，但是会执行类里的两个给成员变量赋值的语句，于是name成了瑞瑞，age成了5，于是调用对象的speak()方法，会输出瑞瑞今年5岁了~。

5、私有化构造器

如果需要将整个主构造器设置为私有的，那么只需要添加private关键字即可，注意，只有伴生对象里才能调用私有构造器来实例化，非伴生对象里就不能调用私有构造器来实例化
在net.hw.constructor包里创建Cat类

package net.hw.constructor

/**
  * 功能：猫类
  * 作者：华卫
  * 日期：2022年03月08日
  */
class Cat private (var name: String, var age: Int) 
  def speak(): Unit = 
    println(name + "今年" + age + "岁了~")
  


// 伴生对象
object Cat 
  def main(args: Array[String]): Unit = 
    val cat = new Cat("欢欢", 2)
    cat.speak()

运行程序，查看结果
如果改成非伴生对象TestCat，报错：私有构造器不能被非伴生对象TestCat访问

6、无参构造器

主构造器也可以没有参数，一个类中如果没有显式地定义主构造器，就默认有一个无参构造器。
在net.hw.constructor包里创建Bird类

package net.hw.constructor

/**
  * 功能：鸟类
  * 作者：华卫
  * 日期：2022年03月08日
  */
class Bird ()  // 显式定义无参构造器
  var name = "玲玲"
  var age = 4

  def speak(): Unit = 
    println(name + "今年" + age + "岁了~")
  


// 伴生对象
object Bird 
  def main(args: Array[String]): Unit = 
    val bird = new Bird() // 调用无参构造器实例化
    bird.speak()

运行程序，查看结果
其实，去掉类名Bird后面的()，系统依然会提供一个无参构造器，程序运行不会报错

（二）辅助构造器

Scala类除了可以有主构造器外，还可以有任意多个辅助构造器。

1、定义辅助构造器的注意事项

辅助构造器的方法名称为this
每一个辅助构造器的方法体中必须首先调用其他已定义的构造器
辅助构造器的参数不能使用var或val进行修饰

2、案例演示

（1）无参主构造器与有参辅助构造器

在net.hw.constructor包里创建Student类

package net.hw.constructor

/**
  * 功能：演示辅助构造器
  * 作者：华卫
  * 日期：2022年03月08日
  */
class Student 
  private var name = "李林芮"
  private var age = 18

  // 定义单参辅助构造器
  def this(name: String) = 
    this() // 调用无参主构造器
    this.name = name
  

  // 定义双参辅助构造器
  def this(name:String, age: Int) = 
    this(name) // 调用单参辅助构造器
    this.age = age
  

  // 重写toString方法
  override def toString: String = name + "今年" + age + "岁了~"


// 伴生对象
object Student 
  def main(args: Array[String]): Unit = 
    // 调用无参构造器实例化
    val student1 = new Student()
    println(student1)
    // 调用单参辅助构造器实例化
    val student2 = new Student("王晓琳")
    println(student2)
    // 调用双参辅助构造器实例化
    val student3 = new Student("张智霖", 21)
    println(student3)

运行程序，查看结果

（2）有参主构造器与有参辅助构造器

主构造器还可以与辅助构造器同时使用，在这种情况下，一般辅助构造器的参数要多于主构造器
在net.hw.constructor包里创建Teacher类

package net.hw.constructor

/**
  * 功能：教师类
  * 作者：华卫
  * 日期：2022年03月08日
  */
class Teacher (private var name: String, private var age: Int) // 双参主构造器
  private var gender = ""

  // 三参辅助构造器
  def this(name: String, age: Int, gender: String) = 
    this(name, age) // 调用双参主构造器
    this.gender = gender
  

  // 重写toString方法
  override def toString: String = name + "，" + gender + "，今年" + age + "岁了~"


// 伴生对象
object Teacher 
  def main(args: Array[String]): Unit = 
    // 调用三参辅助构造器实例化
    val teacher = new Teacher("无心剑", 50, "男")
    println(teacher)

运行程序，查看结果

六、抽象类

（一）抽象类的定义

Scala的抽象类使用关键字abstract定义

abstract class 类名

（二）抽象类的特征

抽象类不能被实例化。
抽象类中可以定义抽象字段（没有初始化的字段）和抽象方法（没有被实现的方法），也可以定义被初始化的字段和被实现的方法。
若某个子类继承了一个抽象类，则必须实现抽象类中的抽象字段和抽象方法，且实现的过程中可以添加override关键字，也可以省略。若重写了抽象类中已经实现的方法，则必须添加override关键字。

（三）案例演示

1、创建抽象类 - Person

在net.hw.absclass包里创建Person抽象类

package net.hw.absclass

/**
  * 功能：抽象人类
  * 作者：华卫
  * 日期：2022年03月08日
  */
abstract class Person 
  var name: String // 抽象字段
  var age: Int // 抽象字段
  var address: String = "龙马潭区长桥路2号" // 普通字段

  // 抽象方法
  def speak()

  // 普通方法
  def walk(): Unit = 
    print(name + "在散步~")

2、继承抽象类，创建普通类 - Teacher

在net.hw.absclass包里创建Teacher普通类

package net.hw.absclass

/**
  * 功能：教师类
  * 作者：华卫
  * 日期：2022年03月08日
  */
class Teacher extends Person 
  // 实现抽象字段（可以不加override）
  var name: String = "无心剑"
  var age: Int = 50

  // 实现抽象方法，不用加override
  def speak(): Unit = 
    println(name + "，今年" + age + "岁，家住" + address + "，擅长讲课与翻译。" )
  

  // 重写普通方法，必须加override
  override def walkSpark基础学习笔记13：Scala函数
 Spark基础学习笔记04：Scala简介与安装
 Spark零基础入门：Scala 类和对象（下）
 Spark基础学习笔记08：Scala简介与安装
 学习进度12
 寒假学习进度十二