1.類型層次結(jié)構(gòu)

<- 用在for循環(huán)
=> 用在函數(shù)
-> 用在二元元組

image.png

2.條件表達(dá)式

2.1 表達(dá)式

   if ( ){ }else if(){ }.....else{  }
   塊表達(dá)式 { } 
    #有默認(rèn)返回值,有值得就是最后一行就是值
    for(i <- 表達(dá)式/數(shù)組/集合){ } #一般循環(huán)
    for(i <- 1 to 3; j<- 1 to 5){ } #嵌套循環(huán)
    for(i <- 1 to10 if(i%3)==0){ print(i)}#守衛(wèi)式
    val new_list  = for(i <- 1 to10 ) yield { i * 10}#推導(dǎo)式
    while(i <= 10){println(i)i=i+1}

2.2 break和continue

break()跳出breakable()的生命周期范圍

#break功能的實現(xiàn)
breakable{
    for(i<-1 to 10) {
        println(i)
        //for表達(dá)式中需要退出循環(huán)的地方君躺，添加break()方法調(diào)用
        if(i>=5) break()
    }
}
#continue功能的實現(xiàn)
for(i<- 1 to 10){
    breakable{
        if(i%3==0){break()}
        println(i) 
    }
}

3.方法

#def 定義, Unit 返回值類似void
def methodName (name:String , age:String) Unit= {
}
#簡寫
def methodName(name:String,age:String)={println(name)}
#變長參數(shù)
def methodName(name:String*)={println(name)}
#點調(diào)用
a.b
#中綴調(diào)用
Math abs -1
#花括號調(diào)用 
#方法只有一個參數(shù)衫冻，才能使用花括號調(diào)用法
Math.abs{-1}
#省略括號調(diào)用
def printHello()={println("hello")}
printHello

4.函數(shù)

#函數(shù)可以被傳遞.可以賦值給變量
#def 定義, Unit 返回值類似void
var func =(name:String , age:String) =>{
name + age}
func("張三","王五")
###1)方法是加載到JVM方法區(qū). 函數(shù)在堆中
###2)方法可以轉(zhuǎn)換為一個函數(shù)賦值給變量

5.數(shù)組

#定長數(shù)組
val a =new Array[Int](100)
Array("java","scala","python")

#變長數(shù)組
val a = ArrayBuffer[Int]()
val a = ArrayBuffer("hadoop", "storm", "spark")

#常用方法
sum,  max,  min,  sorted , reverse反轉(zhuǎn)

6.元組

val stu=(1,"zhangsan",20,"beijing")
val stu = "zhangsan"->20#或者箭頭
#訪問 
stu._1  stu._2
#元組不可變不能重新賦值

7.列表

#有先后順序
####不可變列表
//創(chuàng)建一個不可變列表，存放以下幾個元素（1,2,3,4）
val a = List(1,2,3,4)
//使用Nil創(chuàng)建一個不可變的空列表
val a =Nil
//使用::方法創(chuàng)建列表，包含-2刃跛、-1兩個元素
val a = -2 :: -1 :: Nil

####可變列表
val a = ListBuffer[Int]()
//創(chuàng)建一個可變列表，包含以下元素：1,2,3,4
val a = ListBuffer(1,2,3,4)

#常用方法
a.toList #轉(zhuǎn)換為List
a.toArray#轉(zhuǎn)換為Array

#常用操作
     · 扁平化（flaten）***
· 判斷列表是否為空（isEmpty）
· 拼接兩個列表（++）
· 獲取列表的首個元素（head）和剩余部分(tail)
· 反轉(zhuǎn)列表（reverse）
· 獲取前綴（take）、獲取后綴（drop）
· 拉鏈（zip）和拉開（unzip）
· 轉(zhuǎn)換字符串（toString）
· 生成字符串（mkString）
· 并集（union）
· 交集（intersect）
· 差集（diff）

8.集(Set)

#獲取集的大小 
a.size
#不可變集合
//定義一個空的不可變集
val a = Set[Int]()
//定義一個不可變集婆瓜，保存以下元素：1,1,3,2,4,8
val a = Set(1,1,3,2,4,8)
#可變集合
//1.定義一個可變集，包含以下元素: 1,2,3, 4
import scala.collection.mutable.Set
val a = Set(1,2,3,4)
#常用方法
· 添加一個元素际度，生成一個Set（+）
· 拼接兩個集葵袭，生成一個Set（++）
· 拼接集和列表，生成一個Set（++）

9.映射(類似HashMap)

#不可變映射
val a = Map("zhangsan"->30,"lisi"->40)
//2.獲取zhangsan的年齡
a("zhangsan")
#可變映射
import scala.collection.mutable.Map
val a = Map("zhangsan"->30,"lisi"->40)

#基本操作
· 獲取值(map(key))
· 獲取所有key（map.keys）
· 獲取所有value（map.values）
· 遍歷map集合
· getOrElse判斷在不在不在返回-1
 a += "wangwu"->35

//2.使用while循環(huán)和迭代器乖菱，遍歷打印該列表
val ite = a.iterator
while(ite.hasNext){println(ite.next)}

//3.使用for 表達(dá)式和迭代器坡锡，遍歷打印該列表
val ite = a.iterator
for(i <- ite)println(i)

10.函數(shù)式編程

#遍歷的功能跟for表達(dá)式是一樣的蓬网，都是對集合的每個元素進(jìn)行迭代
List(1,2,3,4).foreach( println) #遍歷（foreach）

val b = a.map(_+1) #映射（map）

val list3 = List("hadoop hive spark flink flume", 
"kudu hbase sqoop storm").flatMap((x)=>{x.split(" ")})#映射扁平化flatmap

val b = a.filter( _%2==0 ) #過濾（filter）

val b = List(3,1,2,9,7).sorted #排序（sorted、sortBy鹉勒、sortWith）
List("01 hadoop", "02 flume", "03 hive", "04 spark")
.sortBy( x=>{x.split(" ")(1)}) #sortBy按照特性排序,不能降序

List(2,3,1,6,4,5).sortWith( _>_ )#使用sortWith對列表進(jìn)行降序排序

val i = (1 to 10).toList.reduce(_ + _) #聚合計算（reduce）

val i = (1  to 10).toList.foldLeft(10)(_+_) #折疊（fold)

#定義一個元組列表來保存學(xué)生姓名和性別
//"張三", "男"
//"李四", "女"
//"王五", "男"
val a = List(("張三", "男"),("李四", "女"),("王五", "男"))
//2.按照性別進(jìn)行分組
val b = a.groupBy((x)=>{x._2})

//3.將分組后的Map轉(zhuǎn)換為列表：List(("男" -> 2), ("女" -> 1))
val c = b.map(x=> { x._1->x._2.length }  )
 c.toList

11.類跟對象

 class Person #簡寫方法

11.1成員變量

 class Person{ var name="" var age=0} #類型推斷
 class Person{var name:String=_var age :Int=_}# 萬能下劃線

11.2.成員方法

 def printHello(msg:String)={println(s"${msg},我叫${name}")}

11.3.修飾符關(guān)鍵字

• protected帆锋，提供給子類訪問
• private，只能在本類中進(jìn)行訪問禽额。子類繼承不了锯厢。
• private[this]:修飾的變量，任何對象都不能訪問
• scala沒有public關(guān)鍵字脯倒，除開protected实辑，private以外，都是公共的藻丢。

11.4.主構(gòu)造器 (除了關(guān)鍵字外都是構(gòu)造)

 //整個class中除了字段定義和方法定義的代碼都是構(gòu)造代碼
 class Person(var name:String="",var age:Int=0){
    //在主構(gòu)造器中輸出"調(diào)用主構(gòu)造器"
    println("調(diào)用主構(gòu)造器")
  }

11.5.輔助構(gòu)造器

  def this(arr:Array[String]){
      //第一行需要調(diào)用主構(gòu)造器或者其他構(gòu)造器
      //使用數(shù)組參數(shù)來初始化成員變量
      this(arr(0),arr(1))
    }

12.單例對象(類似Static)

#定義單例對象和定義類很像剪撬，就是把class換成object
#單例對象也就是伴生類
#單例對象只有一個實例, 不能被重復(fù)NEW
#單例對象所有屬性方法都是靜態(tài)的
#訪問它的屬性或方法不用new直接類型.成員
#單例對象成員方法
object PrintUtil{def printSpliter()= println("-"*15)}
#object類

13.定義main方法

object 單例對象名 extends App {
    // 方法體繼承App特質(zhì)，來實現(xiàn)一個入口悠反。同樣輸出"hello, scala"
}

14.伴生對象

#伴生對象必須要和伴生類一樣的名字
#伴生對象和伴生類在同一個scala源文件中
#伴生對象和伴生類可以互相訪問private屬性
  class Hero{def fight()= println(s"本類")}
  object Hero{private val WEAPON:String="伴生類"}

private[this]#添加訪問權(quán)限半生類也無法訪問

#使用伴生對象 免NEW方式定義類
  class Person(var name:String,var age:Int)
  //定義伴生對象残黑，重寫apply方法，使用Person類名就可以創(chuàng)建對象
  object Person{
    def apply(name:String,age:Int)=new Person(name,age)
  }
#apply方法

15.繼承

15.1 類繼承 跟java一樣

子類(class 或 object) extends 父類{ 
}

15.2 單例對象繼承 跟java一樣

15.3 override和super

- override：重寫父類的屬性或方法斋否。
- overload：一個類可以有多個同名的方法梨水，但是他們的參數(shù)列
表內(nèi)容不同。方法的重載如叼。

15.4 isInstanceOf/asInstanceOf

 if(stu.isInstanceOf[Student]){  #判斷obj是否是類型
      # 將obj1轉(zhuǎn)換成類型A冰木，類似于java的強制轉(zhuǎn)換。
      val stu2: Student = stu.asInstanceOf[Student]
      println(stu2)
    }

15.5 getClass和classOf

obj.getClass  獲取obj的精確類型的模板
classOf[obj]  獲取已知的泛型A類的模板

16 . 抽象類

16.1 抽象方法

跟java一樣
 abstract class Person{
    def sayHello()
  }

17 .匿名內(nèi)部類

跟java一樣
object Demo24Anonymous {
  //1.創(chuàng)建一個Person抽象類笼恰，并添加一個sayHello抽象方法
  abstract class Person{
    def sayHello()
  }
  //2.添加main方法踊沸，通過創(chuàng)建匿名內(nèi)部類的方式來實現(xiàn)Person
  def main(args: Array[String]): Unit = {
    val p = new Person {
      override def sayHello(): Unit = println("你好")
    }
    //3.調(diào)用匿名內(nèi)部類對象的sayHello方法
    p.sayHello()
  }
}

18 .特質(zhì)(trait)類似接口

class 類 extends 特質(zhì)1 with 特質(zhì)2 {}

//在方法中混入接口類調(diào)用方法
val service = new UserService with Logger

//在類定義上
1. 執(zhí)行父類A的構(gòu)造器
2. 從左到右依次執(zhí)行trait的構(gòu)造器
3. 如果trait有父trait，先構(gòu)造父trait社证，如果多個trait有同樣的父trait逼龟，則只初始化一次
4. 執(zhí)行子類構(gòu)造器
 trait Student extends Logger with Mylogger
  {println("執(zhí)行Student構(gòu)造器!")}

特質(zhì)trait=包含抽象類的所有功能（既有抽象屬性和方法，又有具體屬性和方法）
+被子類繼承多個trait 追葡。