（数据科学学习手札46）Scala中的面向对象

一、简介

　　在Scala看来，一切皆是对象，对象是Scala的核心，Scala面向对象涉及到class、object、构造器等，本文就将对class中的重点内容进行介绍；

 

二、Scala中的类

2.1 普通类

　　在Scala中定义普通类的方式如下面的示例：

class Demo{
  val name:String="类"
  def introduce(): Unit ={
    println("这是一个"+name)
  }
}

　　即class+类名+{类中的内容，包括类自带的变量，自带的方法}，而在class的定义中，也有一些特殊的方法：

　　1、private定义私有属性和方法

　　在class中定义属性或方法时在开头加上private关键词，则会将对应的属性或方法私有化，即只允许class中的方法调用该属性或方法：

//调用class中的非私有化属性和方法
object main{
  def main(args: Array[String]): Unit = {
    val demo = new Demo
    demo.introduce()
    println(demo.name)
  }
}

class Demo{
  val name:String="类"
  def introduce(): Unit ={
    println("这是一个"+name)
  }
}

object main{
  def main(args: Array[String]): Unit = {
    val demo = new Demo
    //尝试调用class中的私用化属性和方法
    println(demo.B)
    println(demo.x)
  }
}

class Demo{
  private val x:Int=1
  def A: Int ={
    B + x
  }
  private def B: Int ={
    2
  }
}

而调用非私有化的方法，虽然该方法中调用了class中的私有化属性和私有化方法，但这时代码运行是没有问题的：

object main{
  def main(args: Array[String]): Unit = {
    val demo = new Demo
    //尝试调用class中的私用化属性和方法
    println(demo.A)

  }
}

class Demo{
  private val x:Int=1
  def A: Int ={
    B + x
  }
  private def B: Int ={
    2
  }
}

　　2、类的继承

　　在Scala中，继承的关键字是extends：

object main{
  def main(args: Array[String]): Unit = {
    //调用父类中的introduce方法
    val demoFather = new Father
    demoFather.introduce
    //调用子类1中继承自父类的introduce方法
    val demoChild1 = new Child1
    demoChild1.introduce
  }
}

//父类
class Father{
  val name:String="father"
  def introduce: Unit ={
    println(name)
  }
}

//子类1
class Child1 extends Father{

}

　　子类通过override关键字来重写父类中的方法，如果要定义子类独特的方法，直接在子类的定义中书写即可：

object main{
  def main(args: Array[String]): Unit = {
    //调用父类中的introduce方法
    val demoFather = new Father
    demoFather.introduce
    //调用子类1中继承自父类的introduce方法
    val demoChild1 = new Child1
    demoChild1.introduce
    //调用子类1中自主的新方法
    demoChild1.unique
  }
}

//父类
class Father{
  val name:String="father"
  def introduce: Unit ={
    println(name)
  }
}

//子类1
class Child1 extends Father{
  //复写父类中继承来的方法和属性
  override val name: String = "son"
  override def introduce: Unit = {
    println(name)
  }
  def unique: Unit ={
    println("I am unique!")
  }
}

　　在父类中，被关键词final修饰的属性和方法不能被子类重写会提示错误：

　　3、class的传入参数

　　Scala中的class可以像定义函数一样传入一些必要或非必要参数，如下例：

无缺省值的参数，必须在初始化class的实例时定义：

object main{
  def main(args: Array[String]): Unit = {
    //初始化类的实例时传入无缺省必要参数
    val demoFather = new Father(Firstname = "Zhang")
    //调用类中的introduce方法
    demoFather.introduce
  }
}

class Father(Firstname:String){
  val Lastname:String="feifei"
  def introduce: Unit ={
    println(this.Firstname+Lastname)
  }
}

有缺省值的参数：

object main{
  def main(args: Array[String]): Unit = {
    //调用类中的introduce方法，这里的参数有缺省值可以不传入
    val demoFather = new Father()
    demoFather.introduce
  }
}

class Father(Firstname:String="Wang"){
  val Lastname:String="feifei"
  def introduce: Unit ={
    println(this.Firstname+Lastname)
  }
}

 

2.2 特质与混入

　　Scala中的特质用trait关键字来定义，混入用extends的方式，通过with以混入多个特质，下面是一个简单的演示：

 

object main{
  def main(args: Array[String]): Unit = {
    //调用混入后的方法
    val vehicle = new Vehicle
    vehicle.brand
    vehicle.Amount
    vehicle.amount
  }
}

//特质1
trait Car{
  def brand: Unit ={
    println("本田")
  }
}

//特质2
trait Wheel{
  def amount: Unit ={
    println("4个轮子")
  }
}

//特质3
trait Glass{
  def Amount: Unit ={
    println("深灰色的玻璃")
  }
}

//混入三个特质
class Vehicle extends Car with Wheel with Glass

 

 　　以上就是本文的全部内容，若有笔误之处，望指出。