2. 程式人生 > >Scala - 06 - 面向物件

Scala - 06 - 面向物件

阿新 • • 發佈：2018-11-30

1- 類

1.1- 簡介：類、方法及物件

類是用來建立物件的藍圖。 Scala檔案中包含的多個類之間，都是彼此可見的，不需要宣告為public。 建立物件 定義好類以後，就可以使用new關鍵字來建立物件。
  • 欄位預設為public，在類外部和內部都可以訪問該欄位。
  • 私有欄位使用private關鍵字修飾，外界無法訪問，只有在類內部可以訪問該欄位。
方法
  • 通過def關鍵字實現方法的定義
  • 方法的返回值：方法裡面的最後一個表示式的值就是方法的返回值，不需要靠return語句。
  • 如果方法不返回任何值，返回值的型別就為Unit。
  • 如果包含方法具體操作語句的大括號裡面只有一行語句，可以省略大括號。
package testscala

object TestScala {
  def main(args: Array[String]) {
    println("Testing, Scala!")

    val myTest1 = new myCounter
    myTest1.increment()
    // myTest1.increment  // 呼叫無參方法時，可以省略方法名後面的圓括號
    println(myTest1.current)

    val myTest2 = new myCounter2
    myTest2.increment(5)
    println(myTest2.current)
  }

}

class myCounter {
  private var value = 0
  def increment(): Unit = { value += 1 }
  // def increment(): Unit = value += 1  // 大括號裡面只有一行語句，可以省略大括號
  def current(): Int = { value }
}

class myCounter2 {
  private var value = 0
  def increment(step: Int): Unit = { value += step }
  def current(): Int = { value }
}

1.2- 定義類似getter和setter的方法

Scala沒有提供getter和setter方法，但可以通過定義類似getter和setter的方法，來訪問私有value欄位。 
package testscala

object TestScala {
  def main(args: Array[String]) {
    println("Testing, Scala!")

    val myTest3 = new myCounter3
    println(myTest3.value)
    myTest3.value = 3
    println(myTest3.value)
    myTest3.increment(1)
    println(myTest3.current)

    val myTest4 = new myCounter4
    println(myTest4.value)
    myTest4.value = 3
    println(myTest4.value)
    myTest4.increment(1)
    println(myTest4.current)
  }
}

class myCounter3 {
  var value = 0 // 變數預設為public，對外部可見
  def increment(step: Int): Unit = { value += step }
  def current(): Int = { value }
}

class myCounter4 {
  private var privateValue = 0 // 變數為private，私有欄位
  def value = privateValue
  def value_=(newValue: Int) {
    if (newValue > 0) privateValue = newValue // 新值為正數才可以修改
  }
  def increment(step: Int): Unit = { value += step }
  def current(): Int = { value }
}

1.3- 構造器

Scala構造器包含1個主構造器和若干個（0個或多個）輔助構造器。 主構造器 Scala的每個類都有主構造器。 Scala的主構造器是整個類體，需要在類名稱後面羅列出構造器所需的所有引數，這些引數被編譯成欄位，欄位的值就是建立物件時傳入的引數的值。 
package helloscala

object helloscala {
  def main(args: Array[String]) {
    println("Testing, Scala!")

    val myTest5 = new myCounter5("Timer", 2)
    myTest5.info
    myTest5.increment(1)
    printf("Current Value is: %d\n", myTest5.current)
  }
}

class myCounter5(val name: String, val mode: Int) {
  private var value = 0
  def increment(step: Int): Unit = { value += step }
  def current(): Int = { value }
  def info(): Unit = { printf("Name:%s and mode is %d \n", name, mode) }
}
輔助構造器 輔助構造器的名稱為this。 每個輔助構造器都必須呼叫一個此前已經定義的輔助構造器或主構造器。 
package helloscala

object helloscala {
  def main(args: Array[String]) {
    println("Testing, Scala!")

    val myTest6 = new myCounter6
    myTest6.info
    myTest6.increment(1)
    printf("Current Value is: %d\n", myTest6.current)

    val myTest62 = new myCounter6("Runner")
    myTest62.info
    myTest62.increment(2)
    printf("Current Value is: %d\n", myTest62.current)

    val myTest63 = new myCounter6("Timer", 2)
    myTest63.info
    myTest63.increment(3)
    printf("Current Value is: %d\n", myTest63.current)
  }
}

class myCounter6 {
  private var value = 0
  private var name = ""
  private var mode = 1
  def this(name: String) {
    this()
    this.name = name
  }
  def this(name: String, mode: Int) {
    this(name)
    this.mode = mode
  }
  def increment(step: Int): Unit = { value += step }
  def current(): Int = { value }
  def info(): Unit = { printf("Name:%s and mode is %d \n", name, mode) }
}

2- 面向物件-物件

2.1- 單例物件

Scala並沒有提供Java那樣的靜態方法或靜態欄位。 但可以用object關鍵字定義單例物件，具備和Java靜態方法同樣的功能。 
package helloscala

object helloscala {
  def main(args: Array[String]) {
    println("Testing, Scala!")
    printf("The first person id is %d.\n", Person.newPersonId())
    printf("The second person id is %d.\n", Person.newPersonId())
    printf("The third person id is %d.\n", Person.newPersonId())
  }
}

object Person {
  private var lastId = 0
  def newPersonId() = {
    lastId += 1
    lastId
  }
}

2.2- 伴生物件

在Scala中通過伴生物件來實現同時包含例項方法和靜態方法的類。 當單例物件與某個類具有相同的名稱時，它被稱為這個類的“伴生物件”。 類和它的伴生物件必須存在於同一個檔案中，而且可以相互訪問私有成員（欄位和方法）。 Scala原始碼經過編譯後都會變成JVM位元組碼，class和object在Java層面都會被合二為一。class裡面的成員成了例項成員，object成員成了static成員。 伴生類中的成員和伴生物件中的成員都被合併到一起，並且伴生物件中的方法成為靜態方法。 
package testscala

object TestScala { // 單例物件與某個類具有相同的名稱，稱為這個類的伴生物件

  private var lastId = 0
  private def newPersonId() = {
    lastId += 1
    lastId
  }

  def main(args: Array[String]) {
    println("Testing, Scala!")
    val person1 = new TestScala("AAA")
    val person2 = new TestScala("BBB")
    person1.info()
    person2.info()
  }
}

class TestScala {
  private val id = TestScala.newPersonId() //呼叫伴生物件中的方法
  private var name = ""

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

  def info() { printf("The id of %s is %d.\n", name, id) }
}
 注意： 可以通過javap命令對.class檔案進行反編譯，來確認伴生類中的成員和伴生物件中的成員都被合併到一起，並且，伴生物件中的方法成為靜態方法。 另外，進行反編譯時，要把伴生物件中方法的private修飾符去掉。如果不去掉，作為伴生物件的私有方法，在javap反編譯後，在執行結果中是看不到這個方法的。

2.3- 應用程式物件

每個Scala應用程式都必須從一個物件的main方法開始。 第一種方法：直接使用scala命令執行得到結果。 程式碼中沒有定義類，就是一個單例物件，因此，可以不用編譯，直接使用scala命令執行得到結果。 
[email protected] MINGW64 /d/Anliven-Running/Zen/ScalaProjets/temptest
$ ls -l
total 1
-rw-r--r-- 1 guowli 1049089 88 Nov 21 11:31 test.scala

[email protected] MINGW64 /d/Anliven-Running/Zen/ScalaProjets/temptest
$ cat test.scala
object HelloWorld {
  def main(args: Array[String]){
    println("Hello, World!")
  }
}

[email protected] MINGW64 /d/Anliven-Running/Zen/ScalaProjets/temptest
$ scala test.scala
Hello, World!

[email protected] MINGW64 /d/Anliven-Running/Zen/ScalaProjets/temptest
$ ls -l
total 1
-rw-r--r-- 1 guowli 1049089 88 Nov 21 11:31 test.scala

[email protected] MINGW64 /d/Anliven-Running/Zen/ScalaProjets/temptest
$

第二種方法：先編譯再執行

首先使用scalac編譯命令對.scala檔案進行編譯，然後使用scala命令執行。 
[email protected] MINGW64 /d/Anliven-Running/Zen/ScalaProjets/temptest
$ scalac test.scala

[email protected] MINGW64 /d/Anliven-Running/Zen/ScalaProjets/temptest
$ ls -l
total 3
-rw-r--r-- 1 guowli 1049089 665 Nov 21 11:33 'HelloWorld$.class'
-rw-r--r-- 1 guowli 1049089 602 Nov 21 11:33 HelloWorld.class
-rw-r--r-- 1 guowli 1049089  88 Nov 21 11:31 test.scala

[email protected] MINGW64 /d/Anliven-Running/Zen/ScalaProjets/temptest
$ scala -classpath . HelloWorld
Hello, World!

[email protected] MINGW64 /d/Anliven-Running/Zen/ScalaProjets/temptest
$

2.4- apply方法和update方法

apply方法 用括號傳遞給變數(物件)一個或多個引數時，Scala 會把它轉換成對 apply方法的呼叫 類中定義apply方法： 
package testscala

object TestScala {
  def main(args: Array[String]) {
    println("Testing, Scala!")
    val myObject = new TestApplyClass
    println(myObject("param1")) // 執行myObject("param1")時呼叫了apply方法
  }
}

class TestApplyClass {
  def apply(param: String): String = {
    println("apply method called, parameter is: " + param)
    "Hello World!" // apply方法的返回值
  }
}

單例物件中定義apply方法：

package testscala

object TestScala {

  def main(args: Array[String]) {
    println("Testing, Scala!")
    val group = TestScala("AAA", "BBB")  // 呼叫了apply方法，獲得返回值並賦值給變數
    println(group)
  }

  def apply(param1: String, param2: String): String = {
    println("apply method called")
    param1 + " and " + param2  // 方法的返回值
  }

}

伴生類和伴生物件中的apply方法：

package testscala

object TestScala {
  def main(args: Array[String]) {
    val a = ApplyTest() // 呼叫伴生物件中的apply方法並返回該方法呼叫的值      
    a.greetingOfClass
    a() // 呼叫伴生類中的apply方法         
  }
}

object ApplyTest {
  def apply() = {
    println("apply method in object is called")
    new ApplyTest()  // 返回ApplyTest類的例項化物件
  }
}

class TestScala {
}

class ApplyTest {
  def apply() = println("apply method in class is called!")
  def greetingOfClass: Unit = {
    println("Greeting method in class is called.")
  }
}

示例：apply方法

 val myStrArr = Array("AAA", "BBB", "CCC")       //> myStrArr  : Array[String] = Array(AAA, BBB, CCC)
利用Scala中Array物件已定義的apply方法可以直接給物件傳遞引數。 也就是呼叫Array類的伴生物件Array的apply方法，完成陣列的初始化。 理解：將伴生物件作為工廠使用，就使用關鍵字new建立例項化物件 
package testscala

object TestScala {
  def main(args: Array[String]) {
    val mycar = Car("BMW") // 呼叫伴生物件中的apply方法建立一個Car類的例項化物件
    mycar.info()
  }
}

class Car(name: String) {
  def info() { println("Car name is " + name) }
}

object Car {
  def apply(name: String) = new Car(name) // 呼叫伴生類Car的構造方法建立一個Car類的例項化物件
}
update方法 當對帶有括號幷包括一到若干引數的物件進行賦值時，編譯器將 呼叫物件的update方法，把括號裡的引數和等號右邊的物件一起作為update方法的輸入引數來執行呼叫。 
  val myStrArr = new Array[String](3)             //> myStrArr  : Array[String] = Array(null, null, null)
  myStrArr(0) = "AAA" //實際呼叫了伴生類Array中的update方法，執行myStrArr.update(0,"AAA")
  myStrArr(1) = "BBB" //實際呼叫了伴生類Array中的update方法，執行myStrArr.update(1,"BBB")
  myStrArr.update(2, "CCC") // 執行myStrArr.update(2,"CCC")
  for (x <- myStrArr) println(x)                  //> AAA
                                                  //| BBB
                                                  //| CCC

注意：在進行元組賦值的時候，之所以沒有采用Java中的方括號myStrArr[0]，而是採用圓括號的形式，myStrArr(0)，是因為存在上述的update方法的機制。

3- 面向物件-繼承

Scala和Java一樣，不允許類從多個超類繼承。 Scala中的繼承與Java有著顯著的不同：
  1. 重寫一個非抽象方法必須使用override修飾符。
  2. 只有主構造器可以呼叫超類的主構造器。
  3. 在子類中重寫超類的抽象方法時，不需要使用override關鍵字。
  4. 可以重寫超類中的欄位。
抽象類
  • 使用關鍵字abstract定義抽象類
  • 抽象類不能直接被例項化，可以被其他類繼承
  • 定義抽象類中的抽象方法不需要使用abstract關鍵字，方法體為空
  • 抽象類中定義的欄位必須宣告型別，否則編譯會報錯；如果欄位沒有初始化值，就表示是一個抽象欄位
擴充套件類   擴充套件類可以直接被例項化。 
package testscala

object TestScala {
  def main(args: Array[String]) {
    val myCar1 = new BMWCar()
    val myCar2 = new BenzCar()
    myCar1.greeting()
    myCar1.info()
    myCar2.greeting()
    myCar2.info()
  }
}

abstract class Car { //抽象類
  val carBrand: String //抽象欄位沒有初始化值
  def info() //抽象方法，不需要使用abstract關鍵字，方法體為空
  def greeting() { println("Welcome to my car!") }  //非抽象方法，方法體內容非空
}

class BMWCar extends Car {  //擴充套件類
  override val carBrand = "BMW" //重寫超類欄位，需要使用override關鍵字，否則編譯會報錯
  def info() { printf("This is a %s car.\n", carBrand) } //重寫超類的抽象方法時，可以不使用override關鍵字
  override def greeting() { println("Welcome to my BMW car!") } //重寫超類的非抽象方法，必須使用override關鍵字
}

class BenzCar extends Car { //擴充套件類
  override val carBrand = "Benz"
  def info() { printf("This is a %s car.\n", carBrand) }
  override def greeting() { println("Welcome to my Benz car!") }
}

4- 面向物件-特質

Scala中沒有介面的概念，而是提供了“特質(trait)”，不僅實現了介面的功能，還具備了很多其他的特性。 Scala中一個類只能繼承自一個超類，卻可以實現多個特質，通過重用特質中的方法和欄位可以實現多重繼承。
  • 使用關鍵字trait定義特質
  • 特質中沒有方法體的方法，預設為抽象方法。抽象方法不需要使用abstract關鍵字。
  • 特質定義完成後，可以使用extends或with關鍵字把特質混入類中。
  • 特質可以包含具體實現，特質中的欄位和方法不一定要是抽象的。
  • 如果特質只包含了抽象欄位和抽象方法，相當於實現了類似Java介面的功能。
package helloscala

object helloscala {
  def main(args: Array[String]) {
    println("Testing, Scala!")
    val myCarId1 = new BenzCarId()
    val myCarId2 = new BMWCarId()
    printf("My first CarId is %d.\n", myCarId1.currentId)
    myCarId2.greeting("Welcome my second car.")
    printf("My second CarId is %d.\n", myCarId2.currentId)
  }
}

trait CarId { //使用關鍵字trait定義特質
  var id: Int //定義抽象欄位
  def currentId(): Int //定義抽象方法，不需要使用abstract關鍵字
}

trait CarGreeting { //使用關鍵字trait定義特質 
  def greeting(msg: String) { println(msg) } //定義非抽象方法，
}

class BenzCarId extends CarId { //使用extends關鍵字把特質混入類中
  override var id = 10000 //BYD汽車編號從10000開始
  def currentId(): Int = { id += 1; id } //返回汽車編號
}

class BMWCarId extends CarId with CarGreeting { //使用extends關鍵字混入第1個特質，後面可以反覆使用with關鍵字混入更多特質
  override var id = 20000
  def currentId(): Int = { id += 1; id }
}

 

相關推薦

Scala - 06 - 面向物件

1- 類 1.1- 簡介：類、方法及物件 類是用來建立物件的藍圖。 Scala檔案中包含的多個類之間，都是彼此可見的，不需要宣告為public。 建立物件 定義好類以後，就可以使用new關鍵字來建立物件。 欄位預設為public，在類外部和內部都可以訪問該欄位

scala筆記-面向物件程式設計（10）

定義一個簡單的類 // 定義類，包含field以及方法 class HelloWorld { private var name = "leo" def sayHello() { print("Hello, " + name) } def getName = name

[筆記遷移][Spark開發語言][Scala][10]面向物件——型別引數

Scala型別引數與Java的泛型引數的概念一致 泛型類 (1) 定義：在類名的後面跟上型別引數列表，用[]包裹 (2) 案例 (3) Scala可以根據第一欄位型別自動推斷泛型型別 泛型引數 (1) 定義：在方法名後跟上型別引數列表，用[]包裹 (2)

Scala中面向物件程式設計之trait

1.1將trait作為介面使用 Scala中的trait是一種特殊的概念； 首先先將trait作為介面使用，此時的trait就與Java中的介面 (interface)非常類似； 在trait中可以定義抽象方法，就像抽象類中的抽象方法一樣，只要不給出方法的方法體即可； 類可以使用ex

[筆記遷移][Spark開發語言][Scala][6]面向物件

一、 類 方法與函式的定義一樣，需要使用"="，對於“不需要返回”的方法，可以直接省略"="(隱式返回Unit的過程)。 沒有引數且只有一條語句的方法可以省略引數列表定界()和方法體定界{}。

scala的面向物件

面向物件 1.物件:用object修飾的語法結構 2.類：用class修飾的 3.類的例項：new 類() 類的例項 4.面向物件的三大特徵 (1)封裝 (2)繼承 (3)多型 5.抽象類 6.Trait（介面） 物件 Object 1.單例的，靜態的，scal

06 面向物件（中）

----------- android培訓、java培訓、java學習型技術部落格、期待與您交流！ ------------ 面向物件（中） 1 繼承（Inherit） 概述 多個類中存在相同屬性和行為時，將這些內容抽取到單獨一個

3.Java面向物件程式設計OOA/OOP/OOD/OOAD()/UML類圖、函數語言程式設計Scala(JVM)---類與物件、封裝繼承多型、構造方法、覆寫/重寫/override

一、緒論 1.面向物件程式設計正規化（C++、Java、Go）------能進行現實生活的抽象。             每個物件都是一個類。類中包含屬性與方法。 OOA：面向物件分析 OOP：面向物件程式設計

06.Java面向物件——static關鍵字

一、關於new 在定義一個類時，只是在描述某類事物的特徵和行為，並沒有產生具體的資料。只有通過new關鍵字建立該類的例項物件後，系統才會為每個物件分配空間，儲存各自的資料。 二、靜態變數 static只能修飾成員變數，不能修飾區域性變數 class Student { static

Scala中的面向物件

作者：林偉兵，叩丁狼高階講師。本文為原創文章，轉載請註明出處。     5. 面向物件 5.1 類的定義[屬性和方法] 可以用class來宣告一個類，並用new關鍵字來建立一個物件。 對於類中的全域性變數，必須在宣告的時候指定其預設值，否則就會報錯。

[Scala]學習筆記三——面向物件

一、面向物件的概 （Object Oriented——OO） 1.封裝： 將屬性、方法封裝到類中 2.繼承： 父類和子類之間的關係 3.多型： 父類引用指向子類物件 多型是面向物件程式設計的精髓所在，是開發框架的基礎 二、類的定義和使用 //main方法 def main(ar

scala學習筆記-面向物件程式設計之Trait

將trait作為介面使用 1 // Scala中的Triat是一種特殊的概念 2 // 首先我們可以將Trait作為介面來使用，此時的Triat就與Java中的介面非常類似 3 // 在triat中可以定義抽象方法，就與抽象類中的抽象方法一樣，只要不給出方法的具體實現即可 4

Day-19 面向物件06 多繼承 MRO C3演算法 super()

一、python多繼承 　　1.經典類的MRO class A: pass class B(A): pass class C(A): pass class D(B, C): pass class E: pass class F(D, E):

day 20 面向物件 06 繼承

一 . 多繼承           繼承：X 是 一種 Y的時候，可以使用繼承關係 ， “  is   a "           一個類同時繼承多個類（python ,C++) &n

scala面向物件

1、scala面向物件概述 oo 封裝：屬性、方法封裝到類中        User: int id,String name,Date birthday .....   getter/setter 繼承：父類和子類之間的關係

Scala面向物件程式設計

Scala面向物件程式設計 目錄： 1 類與物件初步 2 引用與值型別 3　價值類 4 父類 5 Scala的構造器 6 類的欄位 6.1 統一訪問原則 6.2 一元方法 7 驗證輸入 8　呼叫父類構造器與良好的面向物件設計 9　巢狀型別   Scala 是

Scala實戰高手****第7課：零基礎實戰Scala面向物件程式設計及Spark原始碼解析

/** * 如果有這些語法的支援，我們說這門語言是支援面向物件的語言 * 其實真正面向物件的精髓是不是封裝、繼承、多型呢？ * --->肯定不是，封裝、繼承、多型，只不過是支撐面向物件的 * 一些語言級別的語法和功能，真正的

C++面向物件程式設計50道程式設計題（第06題）

C++面向物件程式設計50道程式設計題（第06題） 摘要：C++程式設計實習是為學生提供了一個既動手又動腦，獨立實踐的機會，將課本上的理論知識和實際有機的結合起來，鍛鍊學生的分析問題和解決問題的能力，提高學生運用所學知識解決實際問題的能力。   本專輯為程式設計入門者、高校計算機軟體

scala基礎學習--面向物件

一.面向物件之類 1.構造器 主構造器：Scala中的每個類都有一個主構造器，主構造器的引數直接放置類名後面，與類交織在一起. 注意：主構造器會執行類中定義的所有語句 package com.legendlee.oop.constructor class Student(var n

Java SE面向物件--06.類與物件、封裝、構造方法

學習目標： 面向物件 類與物件 三大特徵——封裝 構造方法 一、面向物件 1.1 引入面向物件(瞭解) 在開發的過程中，我們經常會遇到在多個程式中使用到同一個功能的情況。如下需求： 需求：定義類，在類中有定義功能對陣列求和的需求 clas