Scala語言基礎第2章目

錄01Scala語言概述02Scala基礎知識03面向對象編程基礎04函數式編程基礎Scala語言概述2.1.1計算機的緣起人類社會超級計算裝置?阿隆佐?邱奇設計了λ演算用于研究函數定義、函數應用、遞歸的形式系統(tǒng)2.1.1計算機的緣起可計算的函數表達求值λ

演算2.1.1計算機的緣起一個形式系統(tǒng)計算機不能真正實現λ

演算2.1.1計算機的緣起英國數學家阿蘭·圖靈圖靈機2.1.1計算機的緣起λ演算圖靈機λ

演算計算能力2.1.1計算機的緣起阿隆佐?邱奇阿蘭·圖靈學習編程語言和計算機2.1.1計算機的緣起將圖靈的理論物化成為實際的物理實體，成為了計算機體系結構的奠基者。1945年6月，馮·諾依曼提出了在數字計算機內部的存儲器中存放程序的概念，這是所有現代計算機的范式，被稱為“馮·諾依曼結構”計算機體系結構的奠基者

馮·諾依曼輸入設備存儲器輸出設備控制器運算器CPU數據流指令流控制流“馮·諾依曼結構”保存數據與程序發(fā)生運算統(tǒng)一調度2.1.1計算機的緣起函數式編程命令式編程編程范式編程的基本風格2.1.2

編程范式命令式語言馮·諾依曼體系命令馮?諾依曼機器的指令序列命令式程序程序執(zhí)行2.1.2

編程范式λ

演算泛函編程函數式編程2.1.2

編程范式近些年函數式編程會迅速升溫呢？命令式編程函數式編程2.1.2

編程范式涉及多線程之間的狀態(tài)共享命令式編程保證數據的一致性鎖機制函數式編程鎖機制不會在多個線程之間并發(fā)處理2.1.2

編程范式2.1.3Scala簡介面對象編程風格函數式編程風格2.1.3Scala簡介Java虛擬機(JVM)Scala特點兼容現有的Java程序2.1.3Scala簡介面向對象的語言一門函數式語言2.1.3Scala簡介MartinOdersky（Scala之父）詹姆斯·高斯林（Java之父）詹姆斯·高斯林（Java之父）“IfIweretopickalanguagetousetodayotherthanJava,itwouldbeScala.”

—JamesGosling

2.1.3Scala簡介2.1.4Scala的安裝2.1.4Scala的安裝/blog/929-2/2.1.4Scala的安裝2.1.4Scala的安裝支持多種操作系統(tǒng)WindowLinuxMacOS2.1.4Scala的安裝Linux系統(tǒng)的安裝方法/blog/1257-2/2.1.4Scala的安裝直接通過命令安裝OpenJDK7配置JAVA_HOME環(huán)境變量，用下面的命令打開配置文件$sudoapt-getinstallopenjdk-8-jreopenjdk-8-jdk$vim~/.bashrc在文件開頭增加如下語句exportJAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-amd64在Linux系統(tǒng)中安裝Java2.1.4Scala的安裝退出文件編輯，并運行如下命令使配置立即生效配置JAVA_HOME環(huán)境變量，用下面的命令打開配置文件$source~/.bashrc#使變量設置生效$java-versionopenjdkversion“11.0.15”2022-04-19#輸出當前版本號和編譯時間在Linux系統(tǒng)中安裝Java2.1.4Scala的安裝安裝Scala2.12.15版本3.2.0版本2.1.4Scala的安裝登錄Scala官網，下載scala-2.12.15.tgz$source~/.bashrc$sudotar-zxf~/下載/scala-2.12.15.tgz-C/usr/local#解壓到/usr/local中$cd/usr/local/$sudomv./scala-2.12.15/./scala#將文件夾名改為scala$sudochown-Rhadoop./scala#使hadoop用戶擁有對scala目錄的權限安裝Scala

對應的Scala版本是2.12.152.1.4Scala的安裝修改配置文件，把scala命令路徑添加到path環(huán)境變量中檢驗一下是否設置正確$vim~/.bashrc$scala–versionScalacoderunnerversion2.12.15...#省略了部分輸出安裝Scala

對應的Scala版本是2.12.15exportPATH=$PATH:/usr/local/scala/bin2.1.5HelloWorld可以使用命令“:quit”退出Scala解釋器在Shell命令提示符界面中輸入“scala”命令后，會進入scala命令行提示符狀態(tài)scala>//可以在命令提示符后面輸入命令通過HelloWorld程序了解Scala解釋器的使用方法scala>:quit2.1.4Scala的安裝在

Scala

解釋器中運行腳本文件用“:load”命令導入腳本，一次運行多行程序：使用文本編輯器（比如vim）創(chuàng)建一個代碼文件Test.scala在ScalaREPL中執(zhí)行如下命令運行該代碼文件：//代碼文件為/usr/local/scala/mycode/Test.scalaprintln("Thisisthefirstline")println("Thisisthesecondline")println("Thisisthethirdline")scala>:load/usr/local/scala/mycode/Test.scalaLoading/usr/local/scala/mycode/Test.scala…ThisisthefirstlineThisisthesecondlineThisisthethirdline2.1.4Scala的安裝通過編譯打包的方式運行Scala程序使用scalac命令進行編譯（編譯的結果為Java字節(jié)碼）使用scala或者java命令運行字節(jié)碼文件//代碼文件為/usr/local/scala/mycode/HelloWorld.scalaobjectHelloWorld{defmain(args:Array[String]){println("Hello,world!");}}$cd/usr/local/scala/mycode$scalacHelloWorld.scala$scala-classpath.HelloWorld$java-classpath.:/usr/local/scala/lib/scala-library.jarHelloWorldScala基礎知識2.2Scala基礎知識提綱2輸入輸出3控制結構1基本數據類型和變量4數據結構2.2.1

基本數據類型和變量基本數據類型基本操作變量2.2.1

基本數據類型和變量基本數據類型BooleanByteCharShortIntLongFloatDouble2.2.1

基本數據類型和變量Int類型scala.Int類2.2.1

基本數據類型和變量java.lang.String2.2.1

基本數據類型和變量數據類型取值范圍Byte8位有符號補碼整數（-27~27-1）short16位有符號補碼整數（-215~215-1）Int32位有符號補碼整數（-231~231-1）Long64位有符號補碼整數（-263~263-1）Char16位無符號補碼整數（0~216-1）String字符序列Float32位IEEE754單精度浮點數Double64位IEEE754單精度浮點數Booleantrue或false2.2.1

基本數據類型和變量vali=123//123就是整數字面量vali=3.14//3.14就是浮點數字面量vali=true//true就是布爾型字面量vali='A'//'A'就是字符字面量vali=“Hello”//“Hello”就是字符串字面量

字面量（literal）2.2.1

基本數據類型和變量操作符類型操作符算術運算符加(+)、減(-)、乘(*)、除(/)、余數(%)關系運算符大于(>)、小于(<)、等于(==)、不等于(!=)、大于等于(>=)、小于等于(<=)邏輯運算符邏輯與(&&)、邏輯或(||)、邏輯非(!)位運算符按位與(&)、按位或(|)、按位異或(^)、按位取反(~)等賦值運算符=及其與其它運算符結合的擴展賦值運算符，例如+=、%=2.2.1

基本數據類型和變量

操作符優(yōu)先級算術運算符>>>關系運算符邏輯運算符賦值運算符2.2.1

基本數據類型和變量

scala>valsum1=5+3//實際上調用了(5).+(3)sum1:Int=8scala>valsum2=(5).+(3)

//可以發(fā)現，寫成方法調用的形式，和上面得到相同

的結果sum2:Int=8a.方法(b)a方法b

操作符定義成方法2.2.1

基本數據類型和變量富包裝類RichInt類RichStringIntStringmaxscala.runtime2.2.1

基本數據類型和變量富包裝類35maxInt類型Int類型對象不屬于這個Int類型的方法Scala會自動通過隱式轉換將該對象轉換為對應的富包裝類型，然后再調用相應的方法2.2.1

基本數據類型和變量變量不可變可變函數式編程面向對象編程2.2.1

基本數據類型和變量val不可變聲明時必須初始化不能再賦值var可變的聲明時需要初始化可以再賦值valvar不同類型變量2.2.1

基本數據類型和變量val變量名:數據類型=初始值

var

變量名:數據類型=初始值valvar規(guī)范格式2.2.1

基本數據類型和變量類型推斷機制：根據初始值自動推斷變量的類型scala>valmyStr="HelloWorld!"myStr:String=HelloWorld!當然，我們也可以顯式聲明變量的類型scala>valmyStr2:String="HelloWorld!"myStr2:String=HelloWorld!scala>myStr="HelloScala!"<console>:27:error:reassignmenttovalmyStr="HelloScala!"^myStr是val變量，因此，一旦初始化以后，就不能再次賦值2.2.1

基本數據類型和變量scala>varmyPrice:Double=9.9myPrice:Double=9.9scala>myPrice=10.6myPrice:Double=10.6var變量初始化以后，可以再次賦值注意：在REPL環(huán)境下，可以重復使用同一個變量名來定義變量，而且變量前的修飾符和其類型都可以不一致，REPL會以最新的一個定義為準scala>vala="XiamenUniversity"a:String=XiamenUniversityscala>vara=50a:Int=50類型推斷機制：根據初始值自動推斷變量的類型2.2.2輸入輸出控制臺輸入輸出語句讀寫文件輸入輸出（scala.io.StdIn）readIntreadShortreadCharreadDoublereadFloatreadBooleanreadBytereadLongreadLine從控制臺讀入數據的方法2.2.2輸入輸出使用前，必須導入直接用全稱進行調用scala.io.StdIn從控制臺讀入數據的方法2.2.2輸入輸出2.2.2輸入輸出控制臺輸入輸出語句：從控制臺讀入數據方法scala>importio.StdIn._importio.StdIn._scala>vari=readInt()54i:Int=54scala>varf=readFloat1.618f:Float=1.618scala>varb=readBooleantrueb:Boolean=truescala>varstr=readLine("pleaseinputyourname:")pleaseinputyourname:LiLeistr:String=LiLei2.2.2輸入輸出scala>vali=345i:Int=345scala>print("i=");print(i)//兩條語句位于同一行，不能省略中間的分號i=345scala>println("hello");println("world")helloworld控制臺輸入輸出語句：C語言風格格式化字符串的printf()函數print()和println()，可直接輸出字符串或者其它數據類型，println在末尾自動換行2.2.2輸入輸出C語言printf%C語言風格的格式化字符串Scala繼承了C語言格式化字符串的風格加各種各樣的格式化字符串2.2.2輸入輸出控制臺輸入輸出語句：C語言風格格式化字符串的printf()函數print()、println()和printf()都在對象Predef中定義，該對象默認情況下被所有的Scala程序引用，可直接使用Predef對象提供的方法，無需使用scala.Predef.的形式scala>vali=34i:Int=34scala>valf=56.5f:Double=56.5scala>printf("Iam%dyearsoldandweight%.1fKg.","LiLie",i,f)Iam34yearsoldandweight56.5Kg.2.2.2輸入輸出控制臺輸入輸出語句字符串插值機制s字符串f字符串2.2.2輸入輸出控制臺輸入輸出語句：s字符串和f字符串基本語法：s"…$變量名…"或f"…$變量名%格式化字符…"scala>vali=10i:Int=10scala>valf=3.5f:Double=3.5452scala>vals="hello"s:String=helloscala>println(s"$s:i=$i,f=$f")//s插值字符串hello:i=10,f=3.5452scala>println(f"$s:i=$i%-4d,f=$f%.1f")//f插值字符串hello:i=10,f=3.52.2.2輸入輸出控制臺輸入輸出語句讀寫文件輸入輸出2.2.2輸入輸出寫入文件java.io.PrintWriterprintlnprint2.2.2輸入輸出讀寫文件：Scala需要使用java.io.PrintWriter實現把數據寫入到文件PrintWriter類提供了print和println兩個寫方法scala>importjava.io.PrintWriterscala>valoutputFile=newPrintWriter("test.txt")scala>outputFile.println("HelloWorld")scala>outputFile.print("Sparkisgood")scala>outputFile.close()2.2.2輸入輸出讀取文件：用scala.io.Source的getLines方法實現對文件中所有行的讀取2.2.3控制結構if條件表達式while循環(huán)for循環(huán)異常處理對循環(huán)的控制2.2.3控制結構控制結構：if條件表達式if(表達式){

語句塊1}else{

語句塊2}valx=6if(x>0){println(“Thisisapositivenumber”)}else{println(“Thisisnotapositivenumber”)}2.2.3控制結構控制結構：if

條件表達式valx=3if(x>0){println(“Thisisapositivenumber”)}elseif(x==0){println(Thisisazero”)}else{println(“Thisisanegativenumber”)}2.2.3控制結構if

表達式可以再次賦值給變量2.2.3控制結構控制結構：if條件表達式valx=6vala=if(x>0)1else-12.2.3控制結構while(表達式){

循環(huán)體}do{

循環(huán)體}while(表達式)控制結構：while循環(huán)2.2.3控制結構vari=9while(i>0){i-=1printf(“iis%d\n”,i)}vari=0do{i+=1printf(i)}while(i<5)可變類型的變量i不小于5它就退出循環(huán)i等于0以后它就停止執(zhí)行控制結構：while循環(huán)2.2.3控制結構生成器（generator）for

(變量

<-表達式){語句塊}for循環(huán)2.2.3控制結構for(i<-1to5)println(i)for(i<-1to5by2)println(i)12345135控制結構：for循環(huán)2.2.3控制結構for(i<-1to5ifi%2==0)println(i)24for(變量<-表達式if

條件表達式)語句塊控制結構：for循環(huán)—“守衛(wèi)(guard)”的表達式2.2.3控制結構12324636for(i<-1to5;j<-1to3)println(i*j)9481251015支持“多個生成器”的情形，用分號隔開2.2.3控制結構生成器for推導式for(變量<-表達式)yield{語句塊}scala>valr=for(i<-Array(1,2,3,4,5)ifi%2==0)yield{println(i);i}24r:Array[Int]=Array(2,4)2.2.3控制結構異常處理

受檢異常(checkedexception)

不受檢異常(uncheckedexception)2.2.3控制結構受檢異常清晰地知道錯誤代碼的執(zhí)行過程寫代碼的時候2.2.3控制結構受檢異常錯誤處理方法代碼的執(zhí)行過程2.2.3控制結構不受檢異常錯誤代碼的運行過程2.2.3控制結構受檢異常優(yōu)點在編程之前運行過程中會產生的錯誤2.2.3控制結構受檢異常優(yōu)點寫代碼時錯誤1錯誤2錯誤3……處理方式1處理方式2處理方式3……2.2.3控制結構不受檢異常(uncheckedexception)異常處理受檢異常(checkedexception)2.2.3控制結構import

java.io.FileReader

import

java.io.FileNotFoundException

import

java.io.IOException

try

{

valf=new

FileReader("input.txt")

//文件操作}

catch

{

caseex:FileNotFoundException=>

//文件不存在時的操作

caseex:IOException=>

//發(fā)生I/O錯誤時的操作}finally

{

file.close()//確保關閉文件}

控制結構：for循環(huán)2.2.3控制結構對循環(huán)的控制breakcontinue2.2.3控制結構Breaks類（包scala.util.control）對循環(huán)的控制2.2.3控制結構Breaks類（包scala.util.control）breakbreakable2.2.3控制結構breakable{...if(...)break...}Breaks類（包scala.util.control）2.2.3控制結構控制結構：對循環(huán)的控制//代碼文件為/usr/local/scala/mycode/TestBreak.scalaimportutil.control.Breaks._//導入Breaks類的所有方法valarray=Array(1,3,10,5,4)breakable{for(i<-array){ if(i>5)break//跳出breakable，終止for循環(huán)，相當于Java中的breakprintln(i) }}//上面的for語句將輸出1，32.2.3控制結構控制結構：對循環(huán)的控制for(i<-array){ breakable{ if(i>5)break//跳出breakable，終止當次循環(huán)，相當于Java的continue println(i) }}//上面的for語句將輸出1，3，5，42.2.4數據結構數組Array元組Tuple容器Collection序列Sequence集合Set映射Map迭代器Iterator2.2.4數據結構數組（Array）可變的可索引的元素是相同類型2.2.4數據結構提供了參數化類型的通用數組類Array[T]2.2.4數據結構數組（Array）：對循環(huán)的控制—聲明一個整型數組valintValueArr=newArray[Int](3)//聲明一個長度為3的整型數組，每個數組元素初始化為0intValueArr(0)=12//給第1個數組元素賦值為12intValueArr(1)=45//給第2個數組元素賦值為45intValueArr(2)=33//給第3個數組元素賦值為332.2.4數據結構數組（Array）：聲明一個字符串數組valmyStrArr=newArray[String](3)//聲明一個長度為3的字符串數組，每個數組元素初始化為nullmyStrArr(0)="BigData"myStrArr(1)="Hadoop"myStrArr(2)="Spark"for(i<-0to2)println(myStrArr(i))2.2.4數據結構數組（Array）：可不給出數組類型，Scala會自動根據初始化數據來推斷數組類型valintValueArr=Array(12,45,33)valmyStrArr=Array("BigData","Hadoop","Spark")數組（Array）：多維數組的創(chuàng)建：調用Array的ofDim方法valmyMatrix=Array.ofDim[Int](3,4)//類型實際就是Array[Array[Int]]valmyCube=Array.ofDim[String](3,2,4)//類型實際是Array[Array[Array[String]]可以使用多級圓括號來訪問多維數組的元素，例如myMatrix(0)(1)返回第一行第二列的元素2.2.4數據結構對多個不同類型對象的一種簡單封裝元組（Tuple）2.2.4數據結構元組（Tuple）：定義元組是把多個元素用逗號分開并用圓括號包圍起來使用下劃線“_”加上從1開始的索引值，來訪問元組的元素2.2.4數據結構可返回多個不同類型對象元組（Tuple）tuple2.2.4數據結構（Collection）容器（Set）集合2.2.4數據結構容器庫

提供序列集合映射2.2.4數據結構容器類的三個包scala.collectionscala.collection.immutablescala.collection.mutable

容器（Collection）2.2.4數據結構scala.collection容器（Collection）可變容器不可變容器封裝了一些超類或特質2.2.4數據結構scala.collection定義了一些可變容器和不可變的一些通用操作scala.collection包中容器的宏觀層次結構2.2.4數據結構2.2.4數據結構序

列元素可以按照特定的順序訪問的容器

序列（Sequence）

2.2.4數據結構序列中元素都帶從0開始計數的固定索引位置

序列（Sequence）

2.2.4數據結構序列容器根collection.Seq2.2.4數據結構LinearSeq有高效的隨機存取操作IndexedSeqSeq取頭或取尾巴操作2.2.4數據結構LinearSeq列表隊列可變數組（ArrayBuffer）

向量（Vector）共享相同類型的不可變的對象序列列表（List）列表List容器類scala.collection.immutable2.2.4數據結構列表的值不可變列表（List）的特征2.2.4數據結構varstrList=List("BigData","Hadoop","Spark")列表（List）的初始化2.2.4數據結構List頭部尾部headtail列表（List）返回的是列表第一個元素的值返回的是除第一個元素外的其它值構成的新列表2.2.4數據結構varstrList=List("BigData","Hadoop","Spark")列表（List）的初始化strList.head2.2.4數據結構varstrList=List("BigData","Hadoop","Spark")列表（List）的初始化strList.tail2.2.4數據結構向已有列表

前端增加元素構造列表常用的方法2.2.4數據結構構造列表常用的方法valotherList="Apache"::strList操作符2.2.4數據結構otherListList("BigData","Hadoop","Spark")strListList("Apache","BigData","Hadoop","Spark")2.2.4數據結構01valintList=List(1,2,3)構造列表常用的方法02valintList=1::2::3::Nil2.2.4數據結構注意：除了head、tail操作是常數時間O(1)，其它按索引訪問的操作都需要從頭開始遍歷，因此是線性時間復雜度O(N)。2.2.4數據結構序列（Sequence）—向量（Vector）：Vetor可實現所有訪問操作都是常數時間scala>valvec1=Vector(1,2)vec1:scala.collection.immutable.Vector[Int]=Vector(1,2,3)scala>valvec2=3+:4+:vec1vec2:scala.collection.immutable.Vector[Int]=Vector(3,4,1,2)scala>valvec3=vec2:+5vec3:scala.collection.immutable.Vector[Int]=Vector(3,4,1,2,5)scala>vec3(3)res6:Int=22.2.4數據結構一種特殊的帶索引的不可變數字等差序列從給定起點按一定步長增長(減小)到指定終點的所有數值Range2.2.4數據結構RangeIntBigDecimalLongBigIntFloatDoubleChar2.2.4數據結構步長1to5by2起點終點Range2.2.4數據結構scala>valr=newRange(1,5,1)scala>1to5res0:scala.collection.immutable.Range.Inclusive=Range(1,2,3,4,5)scala>1.to(5)res1:scala.collection.immutable.Range.Inclusive=Range(1,2,3,4,5)序列（Sequence）：創(chuàng)建一個從1到5的數值序列，包含區(qū)間終點5，步長為12.2.4數據結構創(chuàng)建一個從1到5的數值序列，不包含區(qū)間終點5，步長為1創(chuàng)建一個從1到10的數值序列，包含區(qū)間終點10，步長為2創(chuàng)建一個Float類型的數值序列，從0.5f到5.9f，步長為0.3f2.2.4數據結構2.2.4數據結構集合（Set）不重復元素的容器（collection）2.2.4數據結構有些數據結構元素重復2.2.4數據結構集合（Set）集合元素重復2.2.4數據結構先后51234列表(List)2.2.4數據結構快速找到某個具體值集合哈希方法2.2.4數據結構從頭到尾遍歷列表查找某個元素2.2.4數據結構集合（Set）scala.collection.mutable包集合（Set）可變集不可變集scala.collection.immutable包2.2.4數據結構集合（Set）：可變類型的變量varmySet=Set("Hadoop","Spark")mySet+="Scala"生成不可變集的對象2.2.4數據結構集合（Set）：可變類型的變量，聲明一個可變集importscala.collection.mutable.SetvalmyMutableSet=Set("Database","BigData")myMutableSet+="CloudComputing"myMutableSetSet("Database","BigData")Set(“Database”,“BigData”,"CloudComputing")2.2.4數據結構一系列鍵值對的容器，鍵是唯一的，但值不一定唯一鍵1鍵2值1值2映射(Map)2.2.4數據結構映射(Map)不可變可變scala.collection.mutable包scala.collection.immutable包（默認）2.2.4數據結構映射(Map)可變scala.collection.mutable包不可變scala.collection.immutable包映射

(Map)

：具體實例valuniversity=Map("XMU"->"XiamenUniversity","THU"->"TsinghuaUniversity","PKU"->"PekingUniversity")如果要獲取映射中的值，可以通過鍵來獲取若給定鍵不存在，則會拋出異常，訪問前可先調用contains方法確定鍵是否存在println(university("XMU"))valxmu=if(university.contains("XMU"))university("XMU")else02.2.4數據結構2.2.4數據結構映射

(Map)

：可變的映射具體實例也可以使用+=操作來添加新的元素importscala.collection.mutable.Mapvaluniversity2=Map("XMU"->"XiamenUniversity","THU"->"TsinghuaUniversity","PKU"->"PekingUniversity")university2("XMU")="XimanUniversity"http://更新已有元素的值university2("FZU")="FuzhouUniversity"http://添加新元素university2+=("TJU"->"TianjinUniversity")//添加一個新元素university2+=("SDU"->"ShandongUniversity","WHU"->"WuhanUniversity")//同時添加兩個新元素2.2.4數據結構按順序訪問容器容

器數據結構迭代器(Iterator)2.2.4數據結構返回迭代器的下一個元素檢測是否還有下一個元素迭代器(Iterator)nexthasNext2.2.4數據結構迭代器(Iterator)：迭代器基本操作具體實例建議：除next和hasnext方法外在對一個迭代器調用了某個方法后，不要再次使用該迭代器val

iter=Iterator("Hadoop","Spark","Scala")while(iter.hasNext){

println(iter.next())}面向對象編程基礎2.3.1類目錄2.3.1類2.3.2對象2.3.3繼承2.3.4參數化類型2.3.5特質2.3.6模式匹配2.3.7包2.3.1類類的定義1類成員的可見性2方法的定義方式3構造器42.3.1類類的定義

：

具體實例classCounter{//這里定義類的字段和方法}修飾關鍵詞val定義可變的變量修飾關鍵詞var定義不可變的變量2.3.1類類的定義

：方法定義和具體實例def方法名(參數列表):返回結果類型={方法體}classCounter{varvalue=0defincrement(step:Int):Unit={value+=step}defcurrent():Int={value}}2.3.1類類的定義

：

具體實例使用new關鍵字創(chuàng)建一個類的實例classCounter{varvalue=0defincrement(step:Int):Unit={value+=step}defcurrent():Int={value}}valmyCounter=newCountermyCounter.value=5//訪問字段myCounter.increment(3)//調用方法println(myCounter.current)//調用無參數方法時，可以省略方法名后的括號2.3.1類類成員的可見性privateprotected決定類成員的可見范圍2.3.1類私

有Scala類privateprotected本類型可見嵌套類型可見本類型可見其它繼承類型可見標題文字不暴露內部字段2.3.1類設置getter方法設置setter方法封裝聲明私有2.3.1類標題文字public字段類成員的可見性設置成私有2.3.1類讀取變量值寫入新的值settergetter2.3.1類valuevalue_=讀取修改2.3.1類類成員的可見性

：

具體實例//代碼文件為/usr/local/scala/mycode/Counter.scalaclassCounter{privatevarprivateValue=0defvalue=privateValuedefvalue_=(newValue：Int){if(newValue＞0)privateValue=newValue}defincrement(step:Int):Unit={value+=step}defcurrent():Int={value}}2.3.1類類成員的可見性

：

具體實例scala>:load/usr/local/scala/mycode/Counter.scalaLoading/usr/local/scala/mycode/Counter.scala…definedclassCounterscala>valmyCounter=newCountermyCounter:Counter=Counter@f591271scala>myCounter.value_=(3)//為privateValue設置新的值scala>println(myCounter.value)//訪問privateValue的當前值3myCounter.value=3//等效于myCounter.value_=(3)2.3.1類方法定義：def方法名(參數列表):返回結果類型={方法體}參數不能用val和var作為前綴去修飾沒有參數的方法在定義的時候是可以圓括號省略掉的類成員的可見性

：

方法的定義方式2.3.1類類成員的可見性

：

方法的定義方式方法定義：def方法名(參數列表):返回結果類型={方法體}一個方法如果只有一個參數可以省略圓點而采用中綴操作符調用方法2.3.1類整數調用中綴操作符調用方法aa.+(b)對象a+b2.3.1類類成員的可見性

：

方法的定義方式//代碼文件為/usr/local/scala/mycode/Counter1.scalaclassCounter{varvalue=0defincrement(step:Int):Unit={value+=step}defcurrent:Int=valuedefgetValue():Int=value}2.3.1類類成員的可見性

：

方法的定義方式scala>:load/usr/local/scala/mycode/Counter1.scalaLoading/usr/local/scala/mycode/Counter1.scala…definedclassCounterscala>valc=newCounterc:Counter=Counter@30ab4b0escala>cincrement5//中綴調用法scala>c.getValue()//getValue定義中有括號，可以帶括號調用res0:Int=02.3.1類類成員的可見性

：

方法的定義方式scala>c.getValue//getValue定義中有括號，也可不帶括號調用res1:Int=0scala>c.current()//current定義中沒有括號，不可帶括號調用<console>:13:error:Intdoesnottakeparametersc.current()^scala>c.current//current定義中沒有括號，只能不帶括號調用res3:Int=02.3.1類80可以省略結果類型返回結果可推斷可以同時省略返回結果類型和等號，但不能省略大括號返回類型為UnitclassCounter{varvalue=0defincrement(step:Int){value+=step}//賦值表達式的值為Unit類型defcurrent()=value//根據value的類型自動推斷出返回類型為Int型}2.3.1類構造器類主構造器2.3.1類Scala構造器類名稱(參數列表)用圓括號2.3.1類val

var修飾在方法定義里面的參數列表參數2.3.1類主構造器關鍵字var關鍵字val2.3.1類放在主構造器參數列表里面的參數自動變成它的類內部的成員字段2.3.1類構造器:如果不希望構造器參數成為類的字段，只需省略關鍵字var或者valscala>classCounter(varname:String)//定義一個帶字符串參數的簡單類definedclassCounterscala>varmycounter=newCounter("Runner")mycounter:Counter=Counter@17fcc4f7scala>println()//調用讀方法Runnerscala>_=("Timer")//調用寫方法scala>="Timer"http://更直觀地調用寫方法，和上句等效:String=Timer2.3.1類主構造器輔助構造器2.3.1類類（參數）（參數）（參數）定義不同的構造器與輔助構造器，this的返回類型為UnitThis(參數列表)2.3.1類//代碼文件為/usr/local/scala/mycode/Counter2.scalaclassCounter{privatevarvalue=0privatevarname=""privatevarstep=1//計算器的默認遞進步長

println("themainconstructor")defthis(name:String){//第一個輔助構造器

this()//調用主構造器

=nameprintf("thefirstauxiliaryconstructor,name:%s\n",name)}defthis(name:String,step:Int){//第二個輔助構造器

this(name)//調用前一個輔助構造器

this.step=stepprintf("thesecondauxiliaryconstructor,name:%s,step:%d\n",name,step)}defincrement(step:Int):Unit={value+=step}defcurrent():Int={value}}2.3.1類scala>:load/usr/local/scala/mycode/Counter2.scalaLoading/usr/local/scala/mycode/Counter2.scala…definedclassCounterscala>valc1=newCounterthemainconstructorc1:Counter=Counter@319c6b2

scala>valc2=newCounter("the2ndCounter")themainconstructorthefirstauxiliaryconstructor,name:the2ndCounterc2:Counter=Counter@4ed6c602

scala>valc3=newCounter("the3rdCounter",2)themainconstructorthefirstauxiliaryconstructor,name:the3rdCounterthesecondauxiliaryconstructor,name:the3rdCounter,step:2c3:Counter=Counter@64fab83b2.3.1類2.3.2對象單例對象apply方法update方法unapply方法2.3.2對象同樣的功能Java靜態(tài)成員單例對象（singletonobject）2.3.2對象單例對象:使用object關鍵字定義單例對象//代碼文件為/usr/local/scala/mycode/Person.scalaobjectPerson{privatevarlastId=0//一個人的身份編號defnewPersonId()={lastId+=1lastId}}2.3.2對象單例對象:單例對象的使用與一個普通的類實例一樣//代碼文件為/usr/local/scala/mycode/Person.scalaobjectPerson{privatevarlastId=0//一個人的身份編號defnewPersonId()={lastId+=1lastId}}2.3.2對象單例對象:單例對象的使用與一個普通的類實例一樣scala>:load/usr/local/scala/mycode/Person.scalaLoading/usr/local/scala/mycode/Person.scala…definedobjectPersonscala>printf("Thefirstpersonid:%d.\n",Person.newPersonId())Thefirstpersonid:1.scala>printf("Thesecondpersonid：%d.\n",Person.newPersonId())Thesecondpersonid：2.scala>printf("Thethirdpersonid:%d.\n",Person.newPersonId())Thethirdpersonid:3.2.3.2對象伴生對象孤立對象單例對象2.3.2對象單例對象同名類的伴生對象同名類單例對象的伴生類互為伴生關系2.3.2對象類伴生對象互相訪問對方內部的成員變量和成員方法存在于同一個文件中2.3.2對象單例對象同名類訪問對方內部的成員2.3.2對象孤立對象（standaloneobject）沒有同名類的單例對象main方法2.3.2對象單例對象:伴生對象和孤立對象具體實例//代碼文件為/usr/local/scala/mycode/Person1.scalaclassPerson(valname:String){privatevalid=Person.newPersonId()//調用了伴生對象中的方法definfo(){printf("Theidof%sis%d.\n",name,id)}}objectPerson{privatevarlastId=0//一個人的身份編號defnewPersonId()={lastId+=1lastId}2.3.2對象單例對象:伴生對象和孤立對象具體實例defmain(args:Array[String]){valperson1=newPerson("Lilei")valperson2=newPerson("Hanmei")()()}}2.3.2對象單例對象:伴生對象和孤立對象具體實例$scalac/usr/local/scala/mycode/Person1.scala$scala–classpath.PersonTheidofLileiis1.TheidofHanmeiis2.2.3.2對象apply方法valmyStrArr=Array("BigData","Hadoop","Spark")創(chuàng)建一個Array對象myStrArrScala調用Array這個類的伴生對象的apply方法2.3.2對象apply方法調用約定用括號傳遞給類實例或單例對象名一個或多個參數時Scala會在相應的類或對象中查找方法名為apply且參數列表與傳入的參數一致的方法并用傳入的參數來調用該apply方法2.3.2對象apply方法:類中的apply方法具體實例//代碼文件為/usr/local/scala/mycode/TestApplyClass.scalaclassTestApplyClass{defapply(param:String){ println("applymethodcalled:"+param)}}2.3.2對象apply方法:類中的apply方法具體實例scala>:load/usr/local/scala/mycode/TestApplyClass.scalaLoading/usr/local/scala/mycode/TestApplyClass.scala…definedclassTestApplyClassscala>valmyObject=newTestApplyClassmyObject:TestApplyClass=TestApplyClass@11b352e9scala>myObject("HelloApply")//自動調用類中定義的apply方法，等同于下句applymethodcalled:HelloApplyscala>myObject.apply("HelloApply")//手動調用apply方法applymethodcalled:HelloApply2.3.2對象apply方法不斷生成對象對象對象對象對象對象工廠方法2.3.2對象apply方法:伴生對象中的apply方法具體實例//代碼文件為/usr/local/scala/mycode/MyTestApply.scalaclassCar(name:String){definfo(){println("Carnameis"+name)}}objectCar{defapply(name:String)=newCar(name)//調用伴生類Car的構造方法}objectMyTestApply{defmain(args:Array[String]){valmycar=Car("BMW")//調用伴生對象中的apply方法()//輸出結果為“CarnameisBMW”}}2.3.2對象對象函數apply方法2.3.2對象函數式面向對象對象.方法函數名稱(參數)2.3.2對象括號調用函數括號參數點號調用點方法2.3.2對象apply方法:類中的apply方法具體實例scala>defadd=(x:Int,y:Int)=>x+y//add是一個函數add:(Int,Int)=>Intscala>add(4,5)//采用數學語言的括號調用樣式res2:Int=9scala>add.apply(4,5)//add也是對象，采用點號形式調用apply方法res3:Int=92.3.2對象函數看作Scala對象2.3.2對象apply方法:伴生對象中的apply方法具體實例//代碼文件為/usr/local/scala/mycode/MyTestApply.scalaclassCar(name:String){definfo(){println("Carnameis"+name)}}objectCar{defapply(name:String)=newCar(name)//調用伴生類Car的構造方法}objectMyTestApply{defmain(args:Array[String]){valmycar=Car("BMW")//調用伴生對象中的apply方法()//輸出結果為“CarnameisBMW”}}2.3.2對象當對帶有括號并包括一到若干參數的對象進行賦值時編譯器將調用對象的update方法并將括號里的參數和等號右邊的值一起作為update方法的輸入參數來執(zhí)行調用Update方法遵循相應的調用約定2.3.2對象update方法:具體實例scala>valmyStrArr=newArray[String](3)//聲明一個長度為3的字符串數組，每個數組元素初始化為nullscala>myStrArr(0)="BigData"http://實際上，調用了伴生類Array中的update方法，執(zhí)行myStrArr.update(0,"BigData")scala>myStrArr(1)="Hadoop"http://實際上，調用了伴生類Array中的update方法，執(zhí)行myStrArr.update(1,"Hadoop")scala>myStrArr(2)="Spark"http://實際上，調用了伴生類Array中的update方法，執(zhí)行myStrArr.update(2,"Spark")2.3.2對象unapply方法apply方法會被自動調用接受構造參數變成對象會被自動調用是apply方法的反向操作接受一個對象，從中提取值unapply方法2.3.2對象unapply方法:具體實例//代碼文件為/usr/local/scala/mycode/TestUnapply.scalaclassCar(valbrand:String,valprice:Int){definfo(){println("Carbrandis"+brand+"andpriceis"+price)}}objectCar{ defapply(brand:String,price:Int)={println("Debug:callingapply...")newCar(brand,price)} defunapply(c:Car):Option[(String,Int)]={println("Debug:callingunapply...")Some((c.brand,c.price))}}2.3.2對象update方法:具體實例objectTestUnapply{defmain(args:Array[String]){varCar(carbrand,carprice)=Car("BMW",800000)println("brand:"+carbrand+"andcarprice:"+carprice)}}2.3.3繼承抽象類Scala的類層次結構擴展類Option類2.3.3繼承沒有實現的成員類抽象類abstract修飾抽象類2.3.3繼承抽象類:具體實例abstractclassCar(valname:String){valcarBrand:String//字段沒有初始化值，就是一個抽象字段definfo()//抽象方法defgreeting(){println("Welcometomycar!")}}2.3.3繼承說

明010203定義一個抽象類，需要使用關鍵字abstract定義一個抽象類的抽象方法，不需要關鍵字abstract，只要把方法體空著，不寫方法體就可以抽象類中定義的字段，只要沒有給出初始化值，就表示是一個抽象字段，但是，抽象字段必須要聲明類型，否則編譯會報錯2.3.3繼承擴展類類類繼承extends繼承關系2.3.3繼承重載父類的抽象成員關鍵字override0102重載父類的非抽象成員關鍵字override必須2.3.3繼承

成員成員成員父類被實現字段已經被賦值繼承以后的子類必須加override2.3.3繼承字段重載val類型字段√var類型字段x2.3.3繼承擴展類:具體實例abstractclassCar{