Scala面向对象的特性

尘埃要变大佬

已于 2022-03-21 00:33:41 修改

阅读量935

点赞数 7

分类专栏： Spark Scala 文章标签： scala java 开发语言 spark 大数据

于 2022-03-20 22:30:57 首次发布

本文链接：https://blog.csdn.net/qq_53276543/article/details/123623388

版权

Spark 同时被 2 个专栏收录

4 篇文章 1 订阅

订阅专栏

Scala

4 篇文章 0 订阅

订阅专栏

继承

Scala只允许继承一个父类，且子类可以继承父类中的所有属性和方法，但是子类不可以直接访问父类中的私有属性和方法

在Scala子类继承父类的时候，需注意以下几点：

如果子类需重写一个父类中的非抽象方法，必须使用override关键字，否则会出现语法错误。
如果子类要重写父类中的抽象方法，则不需要使用override关键字。

示例：【创建一个Point类和一个Location类，并且Location类继承Point类，演示子类Location重写父类Point中的字段】

class Point(val xc:Int,val yc:Int){
  var x:Int = xc
  var y:Int = yc
  def move(dx:Int,dy:Int): Unit ={
    x = x+dy
    y = y+dy
    println("x的坐标点："+x);
    println("y的坐标点："+y);
  }
}
class  Location(override val xc:Int, override val yc:Int,val zc:Int)extends Point(xc,yc){
  var z:Int = zc
  def move(dx:Int,dy:Int,dz:Int): Unit ={
    x = x+dx
    y = y+dy
    z = z+dz
    println("x的坐标点："+x)
    println("y的坐标点："+y)
    println("z的坐标点："+z)
  }
}
object ExtendsTest {
  def main(args: Array[String]): Unit = {
    val loc = new Location(10,20,15);
    //移到一个新的位置
    loc.move(10,10,5);
  }

}

代码理解：先创建一个Point类，并在类中定义了两个字段x,y以及一个方法move()；再创建一个Location类，继承Point类并重写Point类的字段，在Location类中定义三个字段x,y,z以及一个方法move()，接着在主方法main()中创建Location的实例对象loc，并使用该对象访问子类中的move()方法

1.1 单例对象和伴生对象

在Scala中没有静态方法或静态字段，所以不能直接用类名访问类中的方法和字段，而是通过创建类的实例对象去访问类中的方法和字段，但是Scala中提供了object这个关键字用来实现单例模式，使用关键字object创建的对象为单例对象。【注：单例对象模拟为Java的静态成员】

创建单例对象的语法格式：

语法格式理解：关键字object主要用于创建单例对象；objectName为单例对象的名称

示例：【创建一个单例对象SingletonObject】

object SingletonObject{
  def hello(): Unit ={
    println("Hello,This is Sinleton Object")
  }
}

object Singleton {
  def main(args: Array[String]): Unit = {
    SingletonObject.hello()
  }
}

代码理解：先创建一个单例对象SingletonObject，并在该对象中定义了一个方法hello()，再在主方法main()中使用单例对象访问自己的方法hello()

在Scala中，在一个源文件中有一个类和一个单例对象，若单例对象名与类名相同，则把这个单例对象称作伴生对象；这个类则称为是单例对象的伴生类。类和伴生对象之间可以相互访问私有的方法和字段。

示例：【定义一个伴生对象Dog并演示如何操作类中的私有方法和字段】

import java.util.jar.Attributes.Name

class Dog{
  val id=666
  private var name = "二哈"
  def printName():Unit=(
    println(Dog.CONSTANT+name)
  )
}

object Dog {
  private var CONSTANT = "汪汪汪。。。"
  def main(args: Array[String]): Unit = {
   val dog = new Dog
    dog.name = "二哈666"
    dog.printName()
  }
}

代码理解：先创建一个类Dog，并在类中定义了两个字段id、name以及一个方法printName()；再创建一个伴生对象Dog，并在该对象中定义一个字段CONSTANT，在主方法main中创建Dog类的示例对象，再使用实例对象访问类中的字段和方法。

1.2 特质

在Scala中，Trait（特质）的功能类似Java中的接口，但Trait的功能比Java中的接口强大。Eg：Trait可以对定义字段和方法进行实现，而接口却不能。Scala中的Trait可以被类和对象（Object）使用关键字extends来继承

创建特质的语法格式：

语法格式理解：关键字trait用于创建特质；traitName为特质的名称

示例：【创建一个特质Animal，演示类继承特质并访问特质中方法的操作】

//定义特质
trait Animal{
  //定义一个抽象方法方法（没有实现的方法）
  def speak()
  def listen():Unit={
  }
  def run():Unit={
    println("I am running")
  }
}
//定义类，继承特质
class People extends Animal{
  override def speak(): Unit = {
    println("I am speaking English")
  }
}
object People {
  def main(args: Array[String]): Unit = {
    var people = new People
    people.speak()
    people.listen()
    people.run()
  }
}

代码理解：先创建一个特质Animal，并在该特质中定义了3个方法speak()、listen()、run()；再创建一个类People并继承特质Animal，重写特质中的方法Speak()，再在主方法main()中创建People类的实例对象people，再使用实例对象访问特质Animal中的方法。

Scala的模式匹配与样例类

Scala提供了强大的模式匹配机制，最常见的模式匹配就是match语句，主要应用于从多个分支中进行选择的场景。Scala还提供了样例类，它可以对末是匹配进行优化，提高匹配的速率。

2.1 模式匹配

Scala中的模式匹配是由match case组成，它类似于Java中的switch case，即对一个值进行条件判断，针对不同的条件，进行不同的处理。

模式匹配的语法格式：

语法格式理解：match关键字主要用来描述一个表达式，位于表达式位置的后面；case关键字主要用来描述和表达式结果进行比较后的模式，若发现有一个模式可以与表达式结果进行匹配，则执行所匹配模式对应的语句，而剩下的模式就不会继续进行匹配。

示例：【定义一个matchTest()，方法的参数是一个整型字段，而方法的调用则是对参数进行模式匹配，若参数匹配的是1，则打印输出one；若参数匹配的是2，则打印输出two；若参数匹配的是_，则打印输出many。】

object PatternMatch {
  def main(args: Array[String]): Unit = {
    println(matchTest(3))
  }
  def matchTest(x:Int):String = x match {
    case 1=>"one"
    case 2=>"two"
    case 3=>"many"
  }
}

代码理解：先调用match()方法，传入的参数是3，此时与case_进行匹配，由于case_对应的执行语句是打印输出many，所以结果会输出many。

2.2 样例类

在Scala中，使用case关键字来定义的类被称为样例类。样例类是一种特殊的类，经过优化可以被用于模式匹配。

注：样例类在定义完之后Scala会自动生成很多的方法；同时会给样例类自动生成伴生对象；还有在定义类的对象的时候不用使用new

示例：【使用case定义样例类Person，并将样例类应用到模式匹配中】

object CaseClass {
  case class Person(name:String,age:Int)

  def main(args: Array[String]): Unit = {
    val alice = new Person("Alice", 25)
    val bob = new Person("Bob",32)
    val charlie = new Person("Charlie", 32)
    for (person<-List(alice,bob,charlie)){
      person match {
        case Person("Alice",25) =>println("Hi Alice!")
        case Person("Bob",32)=>println("Hi Bob!")
        case Person(name,age)=>
          println("Name:"+name+"\t"+"Age:"+age)
      }
    }
  }
}