Spark大数据处理笔记1.7掌握Scala类、对象、抽象类与特质

最新推荐文章于 2024-06-14 09:46:55 发布

qq_62847100

最新推荐文章于 2024-06-14 09:46:55 发布

阅读量197

点赞数

文章标签： scala java 开发语言

本文链接：https://blog.csdn.net/qq_62847100/article/details/129787965

版权

一、类

（一）类的定义

对象是类的具体实例，类是抽象的，不占用内存，而对象是具体的，占用存储空间。
面向对象三大特性之一：封装（encapsulation） - 封装数据和操作
Scala中一个简单的类定义是使用关键字class，类名首字母必须大写。类中的方法用关键字def定义
创建net.zhj.day04包，在包里创建User类，包含三个私有属性和一个公共方法

package net.zhj.day04

class User {
  private var name = "张三"
  private var gender =  "男"
  private var age = 20

  def speak(): Unit = println("我叫" + name + "," + gender + age + "岁")
  
  
}

（二）类的实例化

关键字new用于创建类的实例
实例化User类，调用其speak()方法
在net.zhj.day04包里创建TestUser对象

package net.zhj.day04

object TestUser {
  def main(args: Array[String]): Unit = {
    val user = new User()
    user.speak()
  }
}

运行程序，查看结果

二、单例对象

（一）单例对象概念

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

（二）案例演示

在net.zhj.day04里创建Person单例对象，包含三个私有属性和一个公共方法

package net.zhj.day04

object Person {
  private var name = "李华"
  private var gender = "女"
  private var age = 19

  def speak(): Unit = println("我叫" + name + "," + gender + age + "岁")
}

在net.zhj.day04包里创建TestPerson对象

package net.zhj.day04

object TestPerson {
  def main(args: Array[String]): Unit = {
    Person.speak()
  }
}

运行程序，查看结果

三、伴生对象

（一）伴生对象概念

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

（二）案例演示

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

package net.zhj.day04

//伴生类
class Student {
  private var name = "刘华强"

  def speak():Unit = {
    println("我叫" + name + Student.age +"岁")
  }
}

//伴生对象
object Student{
  private var age = 18

  def main(args: Array[String]): Unit = {
    val student = new Student()
    println("姓名: " + student.name)
    println("年龄:" + age)
    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.zhj.day04包里创建Dog类

package net.zhj.day04

class Dog {
  val Id: Int= 1
  var name: String = "小黑"
  private var gender: String = "公"
  private[this] var age: Int = 4

}

（2）编译成字节码文件

将Dog.scala编译成Dog.class
任务2、用户自己编写私有属性的Scala风格的get和set方法
注意：set方法的写法 —— 方法名_=
在net.zhj.day04包里创建Cat类

package net.zhj.day04

class Cat {
  private var catName: String = "大黑"

  //get方法
  def name: String = catName

  //set方法
  def name_=(name:String):Unit = {
    catName = 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()
在net.zhj.day04包里创建Bird类

package net.zhj.day04

class Bird {
  private var name = "熊大"

  def getName:String = name

  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.name)
  }
}

运行程序，查看结果

五、构造器

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

（一）主构造器

1、构造器参数带val或var

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

package net.zhj.day05

class Person (val name: String,var age:Int = 18) {
  def speak():Unit = println("myname is"+name+",今年:"+age+"岁")
}


object Person{
  def main(args: Array[String]): Unit = {
    val person = new Person("小李子",20)

    println("姓名:"+person.name)
    println("年龄:"+person.age)

    person.speak()

    person.age_=(18)

    person.speak()
  }
}

运行程序，查看结果

因为主构造器第二个参数是有初始值，所以创建对象时可以不再初始化第二个参数，采用主构造器参数的初始值

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

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

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

系统会为name属性添加一个公共的get方法
系统会为age属性添加一个私有的get和set方法

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.zhj.day05包里创建Dog类

package net.zhj.day05

class Dog (var name:String,var age:Int) {
  name = "大熊"
  age = 2
  println("主构造器被调用了")

  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成了2，于是调用对象的speak()方法，会输出我叫大熊，今年2岁~。

5、私有化构造器

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

package net.zhj.day05

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("牛牛",1)
    cat.speak()
  }
}

运行程序，查看结果

6、无参构造器

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

package net.zhj.day05

class Bird {
  var name = "小黑"
  var age = 1

  def speak():Unit={
    println("我叫"+name+"今年"+age+"岁")
  }
}

object Bird{
  def main(args: Array[String]): Unit = {
    val bird = new Bird
    bird.speak()
  }
}

运行程序，查看结果

（二）辅助构造器

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

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

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

2、案例演示

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

在net.zhj.day05包里创建Student类

package net.zhj.day05

class Student {
  private var name = "熊大"
  private var age = 17

  def this(name:String)={
    this()
    this.name = name
  }

  def this(name:String,age:Int)={
    this(name)
    this.age = age
  }


  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("小八嘎",16)
    println(student3)
  }
}

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

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

package net.zhj.day05

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
  }

  override def toString :String = "我叫"+name+age+"岁" + "性别"+gender


}

object Teacher{
  def main(args: Array[String]): Unit = {
    val teacher = new Teacher("草原三剑客",20,"男")
    println(teacher)
  }
}

运行程序，查看结果

六、抽象类

（一）抽象类的定义

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

（二）抽象类的特征

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

（三）案例演示

1、创建抽象类 - Person

在net.zhj.day06包里创建Person抽象类

package net.zhj.day06

abstract class Person {
  var name:String
  var age:Int
  var address:String = "牛马潭区长起桥桥洞"

  def speak()

  def walk():Unit={
    println(name+"在捡瓶子")
  }
}

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

在net.zhj.day06包里创建Teacher普通类

package net.zhj.day06

abstract class Person {
  var name:String
  var age:Int
  var address:String = "牛马潭区长起桥桥洞"

  def speak()

  def walk():Unit={
    println(name+"在捡瓶子")
  }
}

3、创建测试对象 - TestTeacher

在net.zhj.day06包里创建TestTeacher对象

package net.zhj.day06

object TestTeacher {
  def main(args: Array[String]): Unit = {
    val teacher = new Teacher()
    teacher.speak()
    teacher.walk()
  }
}

运行程序，查看结果

5、简要说明

需要注意的是，上述Teacher类中speak()方法的地址字段（address）是从父类（抽象类Person）中继承而来的。由于该字段在Person中有初始化值，不是抽象字段，若需要在Teacher类中修改该字段的值，则可以在Teacher类的构造函数或其它方法中使用this.address对其重新赋值。例如，将地址改为“江阳区前进中路3号”，可以使用以下代码：this.address="高坝"。

运行程序，查看结果

七、特质

（一）特质的概念

Scala特质使用关键字trait定义，类似Java 8中使用interface定义的接口。特质除了有Java接口的功能外，还有一些特殊的功能。Scala特质中，字段和方法的定义与Scala抽象类一样，可以定义抽象字段和抽象方法、非抽象字段和非抽象方法。

（二）特质的定义

1、语法格式

trait 特质名 {
   // 抽象字段
   // 抽象方法
   // 普通字段
   // 普通方法
}

2、案例演示

任务1、创建宠物特质 - Pet

在net.zhj.day07包里创建Pet特质

package net.zhj.day07

trait Pet {
  var name:String
  var age:Int

  def speak

  def eat:Unit = {
    println(name + "在吃嘎嘎")
  }
}

任务2、创建奔跑特质 - Runnable

在net.zhj.day07包里创建Runnable特质

package net.huawei.day07

/**
 * 功能：奔跑特质
 * 作者：zhj
 * 日期：2023年03月16日
 */
trait Runnable {
  // 抽象方法
  def run
}

任务3、创建飞翔特质 - Flyable

在net.zhj.day07包里创建Flyable特质

package net.huawei.day07

/**
 * 功能：飞翔特质
 * 作者：zhj
 * 日期：2023年03月16日
 */
trait Flyable {
  // 抽象方法
  def fly
}

(三）特质的实现

类可以使用关键字extends实现特质，但必须实现特质中未实现的字段和方法（抽象字段和抽象方法），这一点与继承抽象类是一致的。

1、语法格式

（1）实现一个特质

class 类名 extends 特质名 {
// 实现抽象字段
// 实现抽象方法
}

（2）实现多个特质

如果需要实现的特质不止一个，那么可以通过with关键字添加额外特质，但位于最左侧的特质必须使用extends关键字。

class 类名 extends 特质名1 with 特质名2 with 特质名3 …… with 特质名n {
// 实现抽象字段
// 实现抽象方法
}

2、案例演示

任务1、实现一个特质

在net.zhj.day07包里创建Cat类，实现Pet特质

package net.zhj.day07

class Cat extends Pet {
  var name:String = "梅里猫"
  var age:Int = 1

  def speak:Unit = {
    println("我叫"+name+"今年"+age)
  }

  override def eat:Unit = {
    println(name+"在吃暴龙")
  }
}

object Cat{
  def main(args: Array[String]): Unit = {
    val cat = new Cat
    cat.speak
    cat.eat
  }
}

运行程序，查看结果

任务2、实现多个特质

在net.zhj.day07包里创建Bird类，实现Pet、Runnable、Flyable特质

package net.zhj.day07


class Bird extends Pet with Runnable with Flyable {
  var name: String = "玲玲"
  var age: Int = 2

  def speak: Unit = {
    println("我叫" + name + "，今年" + age + "岁了~")
  }

  def run: Unit = {
    println("鸟儿[" + name + "]在欢快地奔跑~")
  }

  def fly: Unit = {
    println("鸟儿[" + name + "]在自由地飞翔~")
  }
}

// 伴生对象
object Bird {
  def main(args: Array[String]): Unit = {
    // 创建鸟对象
    val bird = new Bird()
    // 调用对象方法
    bird.speak
    bird.run
    bird.fly
  }
}

qq_62847100

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
Spark大数据处理笔记1.7掌握Scala类、对象、抽象类与特质

辅助构造器的方法名称为this每一个辅助构造器的方法体中必须首先调用其他已定义的构造器辅助构造器的参数不能使用var或val进行修饰Scala的抽象类使用关键字abstract定义trait 特质名 {// 抽象字段// 抽象方法// 普通字段// 普通方法。
复制链接

扫一扫