val/var 變量名稱:變量類型 = 初始值

lazy val 變量名 = 表達(dá)式

  def main(args: Array[String]): Unit = {
     val x:Int=2
     if (x>10) println(x)
     else println(x+x)
}

  def main(args: Array[String]): Unit = {

    val x = 0
    val result = {
      val y = x + 10
      val z = y + "-hello"
      val m = z + "-kaikeba"
      "over"
    }
    println(result)
}

over

Process finished with exit code 0

  def main(args: Array[String]): Unit = {
    val x = 0
    val result = {
      val y = x + 10
      val z = y + "-hello"
      val m = z + "-kaikeba"
      m
    }
    println(result)
}

10-hello-kaikeba

for (i <- 表達(dá)式/數(shù)組/集合){
    //表達(dá)式
}

def main(args: Array[String]): Unit = {
    var nums=1 to 10
    //for循環(huán)
    for(i <- nums) println(i)
}

  def main(args: Array[String]): Unit = {

    //雙層for循環(huán)
    for (i <- 1 to 3; j <- 1 to 3)
      println(i * 10 + j)
}

11
12
13
21
22
23
31
32
33

 def main(args: Array[String]): Unit = {
//    守衛(wèi)
    var nums = 1 to 10
    for (i <- nums if i>5 ) println(i)
}

6
7
8
9
10

def main(args: Array[String]): Unit = {

    // for推導(dǎo)式：for表達(dá)式中以yield開始，該for表達(dá)式會(huì)構(gòu)建出一個(gè)集合
    val v = for(i <- 1 to 5) yield i * 10
    //打印集合v的第一個(gè)元素
    println(v(0))
}

10

while(返回值為布爾類型的表達(dá)式){
    //表達(dá)式
}

def methodName (參數(shù)名:參數(shù)類型, 參數(shù)名:參數(shù)類型) : [return type] = {
    // 方法體：一系列的代碼
}

  //方法一
  def yy(i: Int = 10, u: Int = 8): Int = {
    return i + u;
  }

  //方法二
  def tt(i: Int) = i * i


  /**
   * 遞歸必須添加返回值參數(shù)
   *
   * @param x
   * @return
   */
  //方法三
  def m1(x: Int): Int = {
    if (x == 1) 1
    else x * m1(x - 1)
  }

  /**
   * 參數(shù)值加*，可以傳遞多個(gè)參數(shù)
   *
   * @param num
   * @return
   */
  //    方法四
  def add(num: Int*) = num.sum

  def main(args: Array[String]): Unit = {
    
        println(yy(1))
        println(tt(8))
        println(m1(10))
        println(add(1,2,3))
}

9
64
3628800
6

val 函數(shù)變量名 = (參數(shù)名:參數(shù)類型, 參數(shù)名:參數(shù)類型....) => 函數(shù)體

 val add2 = (x: Int, y: Int) => x * y
  def main(args: Array[String]): Unit = {
        println(add2(2,4))
}

8

def main(args: Array[String]): Unit = {
    val a = new Array[Int](10)
    println(a)
    a(0)=98
    println(a(0))
    println(a(1))
    println(a.length)
  }

[I@ea4a92b
98
0
10

import scala.collection.mutable.ArrayBuffer

  def main(args: Array[String]): Unit = {
    //變長(zhǎng)數(shù)組
    val a = ArrayBuffer[String]();
    a+=("test")
    a+=("張三")
    a++=Array("妞兒","所以算是")
    println(a(3))
    println(a.size)
  }
}

所以算是
4

for(i <- a) println(i)

/0 to n    ——包含0，也包含n
for(i <- 0 to a.length -1 ) println(a(i))

//0 until n ——生成一系列的數(shù)字，包含0，不包含n
for(i <- 0 until a.length) println(a(i))

 def main(args: Array[String]): Unit = {

    val array = Array(1,3,4,2,5)
    println("求和："+array.sum)
    println("最大值："+array.max)
    println("最小值："+array.min)
    println("排序(獲取一個(gè)新數(shù)組，并翻轉(zhuǎn))："+array.sorted.reverse(0))

  }

求和：15
最大值：5
最小值：1
排序(獲取一個(gè)新數(shù)組，并翻轉(zhuǎn))：5

val/var 元組變量名稱 = (元素1, 元素2, 元素3....)

val/var 元組 = 元素1 -> 元素2

  def main(args: Array[String]): Unit = {
    val a = (1, "張三", 20, "北京市")
    val b = 1 -> 2
    println(a._1)
    println(a._4)
    println(b._1)
  }

1
北京市
1

val/var map = Map(鍵->值, 鍵->值, 鍵->值...)    // 推薦這種寫法，可讀性更好 
val/var map = Map((鍵, 值), (鍵, 值), (鍵, 值), (鍵, 值)...)

def main(args: Array[String]): Unit = {
    val map1 = Map("zhangsan"->30, "lisi"->40)
    val map2 = Map(("zhangsan", 30), ("lisi", 30))
    println(map1("lisi"))
    println(map2("zhangsan"))
  }

40
30

import scala.collection.mutable.Map

  def main(args: Array[String]): Unit = {

    val map3 = Map("zhangsan" -> 30, "lisi" -> 40)
    //修改一個(gè)
    map3("zhangsan") = 50
    println("修改的" + map3)
    //添加一個(gè)
    map3 += ("yy" -> 22)
    println("添加的" + map3)
    //刪去一個(gè)
    map3 -= "yy"
    println("刪除的" + map3)
    //拿取到map所有key
    println("拿取到map所有key:" + map3.keys)
    println("拿取到map所有key:" + map3.keySet)
    //獲取所有的value
    println("獲取所有的value:" + map3.values)
  }

修改的Map(lisi -> 40, zhangsan -> 50)
添加的Map(yy -> 22, lisi -> 40, zhangsan -> 50)
刪除的Map(lisi -> 40, zhangsan -> 50)
拿取到map所有key:Set(lisi, zhangsan)
拿取到map所有key:Set(lisi, zhangsan)
獲取所有的value:HashMap(40, 50)

     val map3 = Map("zhangsan" -> 30, "lisi" -> 40)
    //方法一。通過遍歷key拿取到值
    for (i <- map3.keys) println(i + "->" + map3(i))
    //方法二，通過元組的方法拿取到值
    for (i <- map3) println(i._1 + "->" + i._2)
    //方法三
    for((k, v) <- map3) println(k + " -> " + v)

lisi->40
zhangsan->30
lisi->40
zhangsan->30
lisi -> 40
zhangsan -> 30

//創(chuàng)建一個(gè)空的不可變集
val/var 變量名 = Set[類型]()

//給定元素來創(chuàng)建一個(gè)不可變集
val/var 變量名 = Set[類型](元素1, 元素2, 元素3...)

 def main(args: Array[String]): Unit = {
    val a = Set(1, 1, 2, 3, 4, 5)
    println("a的長(zhǎng)度大小"+a.size)
    for(i<-a)println(i)
    println("添加一個(gè)元素的新set:",a + 6)
    println("刪除一個(gè)元素的新set:",a -1)
    println("刪除多個(gè)元素的新set:",a -- Set(2,3) )
    println("添加多個(gè)元素的新set:",a ++ Set(6,7,8)  )
    println("多個(gè)Set集合交集的新set:",a & Set(3,4,5,6))
    println(a)
  }

a的長(zhǎng)度大小5
5
1
2
3
4
(添加一個(gè)元素的新set:,Set(5, 1, 6, 2, 3, 4))
(刪除一個(gè)元素的新set:,Set(5, 2, 3, 4))
(刪除多個(gè)元素的新set:,Set(5, 1, 4))
(添加多個(gè)元素的新set:,Set(5, 1, 6, 2, 7, 3, 8, 4))
(多個(gè)Set集合交集的新set:,Set(5, 3, 4))
Set(5, 1, 2, 3, 4)

import scala.collection.mutable.Set

val/var 變量名 = List(元素1, 元素2, 元素3...)

//使用 Nil 創(chuàng)建一個(gè)不可變的空列表
val/var 變量名 = Nil

//使用 :: 方法創(chuàng)建一個(gè)不可變列表
val/var 變量名 = 元素1 :: 元素2 :: Nil

 def main(args: Array[String]): Unit = {
    val list1 = List(1, 2, 3, 4)
    val list2 = Nil
    val list3= 1::2::3::Nil
    println(list1(0))
    println(list3)
  }

1
List(1, 2, 3)

val/var 變量名 = ListBuffer[Int]()

val/var 變量名 = ListBuffer(元素1，元素2，元素3...)

    val a = ListBuffer[Int]()
    val b = ListBuffer(1, 2, 3, 4)
    println(b(0))
    println("list數(shù)組首部:", b.head)
    println("獲取除了第一個(gè)元素外其他元素組成的列表", b.tail)
    b += 5
    println("添加應(yīng)元素", b)
    b ++= List(6, 7)
    println("添加一個(gè)不可變列表", b)
    b ++= ListBuffer(8, 9)
    println("添加一個(gè)可變列表", b)
    b -= 9
    println("刪除單個(gè)元素", b)
    b --= List(7,8)
    println("刪除一個(gè)不可變的列表存在的元素", b)
    b --= ListBuffer(5,6)
    println("刪除一個(gè)可變的列表存在的元素", b)
    println("toList根據(jù)可變的列表生成一個(gè)不可變列表",b.toList)
    println("toList根據(jù)可變的列表生成一個(gè)不可變列表，原列表不變",b)

    println("toArray根據(jù)可變的列表生成一個(gè)新的不可變數(shù)組",b.toArray)
    println("toArray根據(jù)可變的列表生成一個(gè)新的不可變數(shù)組，原列表不變",b)

1
(list數(shù)組首部:,1)
(獲取除了第一個(gè)元素外其他元素組成的列表,ListBuffer(2, 3, 4))
(添加應(yīng)元素,ListBuffer(1, 2, 3, 4, 5))
(添加一個(gè)不可變列表,ListBuffer(1, 2, 3, 4, 5, 6, 7))
(添加一個(gè)可變列表,ListBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9))
(刪除單個(gè)元素,ListBuffer(1, 2, 3, 4, 5, 6, 7, 8))
(刪除一個(gè)不可變的列表存在的元素,ListBuffer(1, 2, 3, 4, 5, 6))
(刪除一個(gè)可變的列表存在的元素,ListBuffer(1, 2, 3, 4))
(toList根據(jù)可變的列表生成一個(gè)不可變列表,List(1, 2, 3, 4))
(toList根據(jù)可變的列表生成一個(gè)不可變列表，原列表不變,ListBuffer(1, 2, 3, 4))
(toArray根據(jù)可變的列表生成一個(gè)新的不可變數(shù)組,[I@3567135c)
(toArray根據(jù)可變的列表生成一個(gè)新的不可變數(shù)組，原列表不變,ListBuffer(1, 2, 3, 4))

foreach(f: (A) ? Unit): Unit

  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3, 4)
    //定義一個(gè)匿名函數(shù)傳入到foreach方法中
    list.foreach((u: Int) => println(u))
    //匿名函數(shù)的輸入?yún)?shù)類型可以省略，由編譯器自動(dòng)推斷
    list.foreach(u => println(u))
    //  當(dāng)函數(shù)參數(shù)，只在函數(shù)體中出現(xiàn)一次，而且函數(shù)體沒有嵌套調(diào)用時(shí)，可以使用下劃線來簡(jiǎn)化函數(shù)定義
    list.foreach(println(_))
    //最簡(jiǎn)單直接
    list.foreach(println)
  }

def map[B](f: (A) ? B): TraversableOnce[B]

    val list = List(1, 2, 3, 4)
    //定義一個(gè)匿名函數(shù)
    val b=list.map((i:Int)=>i*10)
    println(b)
    //省略匿名函數(shù)參數(shù)類型
    val c=list.map(i=>i*10)
    println(c)
    //最簡(jiǎn)單用下劃線的方法
    val d=  list.map(_ * 10)
    println(d)

List(10, 20, 30, 40)
List(10, 20, 30, 40)
List(10, 20, 30, 40)

def flatMap[B](f: (A) ? GenTraversableOnce[B]): TraversableOnce[B]

def main(args: Array[String]): Unit = {
    val list = List("hadoop hive spark flink", "hbase spark")
    val tt = list.flatMap(x => x.split(" "));
    println(tt)
    //簡(jiǎn)寫
    val t2 = list.flatMap(_.split(" "))
    println(t2)
    //flatMap該方法其本質(zhì)是先進(jìn)行了map 然后又調(diào)用了flatten
    val t3 = list.map(_.split(" ")).flatten
    println(t3)
  }

List(hadoop, hive, spark, flink, hbase, spark)
List(hadoop, hive, spark, flink, hbase, spark)
List(hadoop, hive, spark, flink, hbase, spark)

def filter(p: (A) ? Boolean): TraversableOnce[A]

def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    ///過濾出集合中大于5的元素
    val tt=list.filter(x=>x>5)
    println(tt)
    //把集合中大于5的元素取出來乘以10生成一個(gè)新的list集合
    val t3=list.filter(x=>x>5).map(u=>u*10)
    println(t3)
  }

List(6, 7, 8, 9, 10)
List(60, 70, 80, 90, 100)

 def main(args: Array[String]): Unit = {
    val list = List(5, 1, 2, 4, 3)
    println(list.sorted)
  }

List(1, 2, 3, 4, 5)

def sortBy[B](f: (A) ? B): List[A]

 val list2 = List("1 hadoop", "2 spark", "3 flink")
    println(list2.sortBy(x=>x.split(" ")(0)))

List(1 hadoop, 2 spark, 3 flink)

def sortWith(lt: (A, A) ? Boolean): List[A]

   val list3 = List(2, 3, 1, 6, 4, 5)
    //降序
    var tt = list3.sortWith((x, y) => x > y)
    println(tt)
    //升序
    var tt2 = list3.sortWith((x, y) => x < y)
    println(tt2)
    //簡(jiǎn)寫
    var tt3 =list3.sortWith(_ > _)
    println(tt3)

List(6, 5, 4, 3, 2, 1)
List(1, 2, 3, 4, 5, 6)
List(6, 5, 4, 3, 2, 1)

def reduce[A1 >: A](op: (A1, A1) ? A1): A1

def main(args: Array[String]): Unit = {
    val a = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    //基礎(chǔ)的寫法
    var b = a.reduce((x, y) => x + y)
    println("基礎(chǔ)的寫法"+b)
    //簡(jiǎn)單的寫法
    var c = a.reduce(_ + _)
    println("簡(jiǎn)單的寫法"+c)
    //從左往右計(jì)算
    var d = a.reduceLeft(_ + _)
    println("從左往右計(jì)算"+d)
     //從右往左計(jì)算
    var f = a.reduceRight(_ + _)
    println("從右往左計(jì)算"+f)
  }

基礎(chǔ)的寫法55
簡(jiǎn)單的寫法55
從左往右計(jì)算55
從右往左計(jì)算55

def fold[A1 >: A](z: A1)(op: (A1, A1) ? A1): A1

def main(args: Array[String]): Unit = {
    val a = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    var e = a.fold(0)(_ + _)
    println("簡(jiǎn)單折疊:",e)
    var g = a.fold(5)(_ + _)
    println("給定一個(gè)初始值，，折疊求和:"+g)
    var h=  a.foldLeft(10)(_ + _)
    println("從左往右折疊:",h)

  }

(簡(jiǎn)單折疊:,55)
給定一個(gè)初始值，，折疊求和:60
(從左往右折疊:,65)

  def main(args: Array[String]): Unit = {
    //定義一個(gè)數(shù)組
    val array = Array(1, 2, 3, 4, 5)
    //定義一個(gè)函數(shù)
    val func = (x: Int) => x * 10
    //函數(shù)作為參數(shù)傳遞到方法中
    val tt=  array.map(func)
    println("通過map轉(zhuǎn)化的新數(shù)組:",tt)
    println("通過map轉(zhuǎn)化的新數(shù)組最大:",tt.max)
  }

(通過map轉(zhuǎn)化的新數(shù)組:,[I@17550481)
(通過map轉(zhuǎn)化的新數(shù)組:,50)

 def main(args: Array[String]): Unit = {
    val array = Array(1, 2, 3, 4, 5)
    var a = array.map(x => x * 10)
    println(a.max)
  }

50

 def main(args: Array[String]): Unit = {
    def getAddress(a: String): (String, String) => String = {
      (b: String,c: String) => a + "-" + b + "-" + c
    }
    var b=getAddress("china");
    var c=b("beijing","tianAnMen")
    println(c)
  }

china-beijing-tianAnMen

  def main(args: Array[String]): Unit = {
    var factor = 1
    val f1 = (x: Int) => x * factor
    println(f1(8))
    factor=2
    println(f1(8))
  }

8
16

 def main(args: Array[String]): Unit = {
   
    def multiply(x: Double) = (y: Double) => x * y

    //先進(jìn)行科爾化
    val doubleFunc = multiply(2)
    val tripleFunc = multiply(3)
    //    再對(duì)閉包進(jìn)行計(jì)算
    var u = doubleFunc(10)
    var u2 = tripleFunc(10)
    println(u)
    println(u2)
  }

20.0
30.0

import java.util.Date

class Customer {
  var name: String = _
  var sex: String = _
  val registerDate: Date = new Date

  def sayHi(msg: String) = {
    println(msg)
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    val customer = new Customer
    //給對(duì)象的成員變量賦值
    customer.name = "張三"
    customer.sex = "男"

    println(s"姓名: ${customer.name}, 性別：${customer.sex}, 注冊(cè)時(shí)間: ${customer.registerDate}")
    //對(duì)象調(diào)用方法
    customer.sayHi("你好!")
  }
}

姓名: 張三, 性別：男, 注冊(cè)時(shí)間: Fri Apr 22 16:23:21 CST 2022
你好!

class 類名(var/val 參數(shù)名: 類型 = 默認(rèn)值, var/val 參數(shù)名: 類型 = 默認(rèn)值){
    // 構(gòu)造代碼塊
}

object DateUtils {
//  / 在object中定義的成員變量，相當(dāng)于Java中定義一個(gè)靜態(tài)變量
  // 定義一個(gè)SimpleDateFormat日期時(shí)間格式化對(duì)象
  val simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm")

  // 構(gòu)造代碼
  println("構(gòu)造代碼")

  // 相當(dāng)于Java中定義一個(gè)靜態(tài)方法
  def format(date: Date) = simpleDateFormat.format(date)

  // main是一個(gè)靜態(tài)方法，所以必須要寫在object中
  def main(args: Array[String]): Unit = {

    println { DateUtils.format(new Date()) };
  }
}

package com.testScala.E_duixiang

class Dog {
  val id = 1
  private var name = "kkb"
  def printName(): Unit = {
    //在Dog類中可以訪問伴生對(duì)象Dog的私有屬性
    println(Dog.CONSTANT + name )
  }
}

object Dog{
  //伴生對(duì)象中的私有屬性
  private val CONSTANT = "汪汪汪 : "
  def main(args: Array[String]) {
    val dog = new Dog
    //訪問私有的字段name
    dog.name = "123"
    dog.printName()
  }
}

汪汪汪 : 123

package com.testScala.E_duixiang

class Person(var name: String, var age: Int) {

  override def toString = s"Person($name, $age)"
}

object Person {
  // 實(shí)現(xiàn)apply方法
  // 返回的是伴生類的對(duì)象
  def apply(name: String, age: Int): Person = new Person(name, age)

  // apply方法支持重載
  def apply(name: String): Person = new Person(name, 20)

  def apply(age: Int): Person = new Person("某某某", age)

  def apply(): Person = new Person("某某某", 20)
}

object Main2 {
  def main(args: Array[String]): Unit = {
    val p1 = Person("張三", 20)
    val p2 = Person("李四")
    val p3 = Person(100)
    val p4 = Person()

    println(p1)
    println(p2)
    println(p3)
    println(p4)
  }
}

Person(張三, 20)
Person(李四, 20)
Person(某某某, 100)
Person(某某某, 20)

object Main1{
  def main(args: Array[String]) = {
    println("hello, scala")
  }
}

class Person3 {
  val name = "super"

  def getName = name
}

class Student3 extends Person3 {
  // 重寫val字段
  override val name: String = "child"

  // 重寫getName方法
  override def getName: String = "hello, " + super.getName
}

object Main3 {
  def main(args: Array[String]): Unit = {
    val p = new Student3();
    println(p.name)
    println(p.getName)
  }
}

child
hello, child

class Person4
class Student4 extends Person4

object Main4 {
  def main(args: Array[String]): Unit = {
    val s1: Person4 = new Student4

    // 判斷s1是否為Student4類型
    if(s1.isInstanceOf[Student4]) {
      // 將s1轉(zhuǎn)換為Student3類型
      val s2 =  s1.asInstanceOf[Student4]
      println(s2)
    }
  }
}

com.testScala.F_jicheng.Student4@ea4a92b

class Person5
class Student5 extends Person5

object Student5{
  def main(args: Array[String]) {
    val p: Person5 = new Student5
    //判斷p是否為Person5類的實(shí)例
    println(p.isInstanceOf[Person5])//true

    //判斷p的類型是否為Person5類
    println(p.getClass == classOf[Person5])//false

    //判斷p的類型是否為Student5類
    println(p.getClass == classOf[Student5])//true
  }
}

package com.testScala.F_jicheng
class Person6 {
  // 只有在當(dāng)前對(duì)象中能夠訪問
  private[this] var name = "super"

  def getName = this.name	// 正確！

  def sayHelloTo(p: Person6) = {
    println("hello" + p.name)     // 報(bào)錯(cuò)!無法訪問
  }
}

object Person6 {
  def showName(p: Person6) = println(p.name)  // 報(bào)錯(cuò)!無法訪問
}

package com.testScala.F_jicheng

class Person7 {
  // 只有在當(dāng)前類以及繼承該類的當(dāng)前對(duì)象中能夠訪問
  protected[this] var name = "super"

  def getName = {
    // 正確！
    this.name
  }

  def sayHelloTo1(p: Person7) = {
    // 編譯錯(cuò)誤！無法訪問
//    println(p.name)
  }
}

object Person7 {
  def sayHelloTo3(p: Person7) = {
    // 編譯錯(cuò)誤！無法訪問
//    println(p.name)
  }
}

class Student7 extends Person7 {
  def showName = {
    // 正確！
    println(name)
  }

  def sayHelloTo2(p: Person7) = {
    // 編譯錯(cuò)誤！無法訪問
//    println(p.name)
  }
}
object  yy{
  def main(args: Array[String]): Unit = {
    var yu=    new Student7();
    yu.showName
//    println()
  }
}

package com.testScala.F_jicheng

class Person8(var name: String){
  println("name:"+name)
}

// 直接在子類的類名后面調(diào)用父類構(gòu)造器
class Student8(name: String, var clazz: String) extends Person8(name)

object Main8 {
  def main(args: Array[String]): Unit = {
    val s1 = new Student8("張三", "三年二班")
    println(s"${s1.name} - ${s1.clazz}")
  }
}

name:張三
張三 - 三年二班

package com.testScala.F_jicheng

abstract class Person9(val name: String) {
  //抽象方法
  def sayHello: String
  def sayBye: String
  //抽象字段
  val address: String
}
class Student9(name: String) extends Person9(name){
  //重寫抽象方法或字段，def前不必加override關(guān)鍵字
  def sayHello: String = "Hello," + name
  def sayBye: String ="Bye," + name
  //重寫抽象字段
   val address: String = "beijing "
}
object Main9{
  def main(args: Array[String]) {
    val s = new Student9("tom")
    println(s.sayHello)
    println(s.sayBye)
    println(s.address)
  }
}

Hello,tom
Bye,tom
beijing 

trait Logger1 {
  // 抽象方法
  def log(msg: String)
}

class ConsoleLogger1 extends Logger1 {
  override def log(msg: String): Unit = println(msg)
}

object LoggerTrait1 {
  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLogger1
    logger.log("控制臺(tái)日志: 這是一條Log")
  }
}

控制臺(tái)日志: 這是一條Log

trait Logger2 {
  // 抽象方法
  def log(msg: String)
}

trait MessageSender {
  def send(msg: String)
}

class ConsoleLogger2 extends Logger2 with MessageSender {

  override def log(msg: String): Unit = println(msg)

  override def send(msg: String): Unit = println(s"發(fā)送消息:${msg}")
}

object LoggerTrait2 {
  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLogger2
    logger.log("控制臺(tái)日志: 這是一條Log")
    logger.send("你好!")
  }
}

控制臺(tái)日志: 這是一條Log
發(fā)送消息:你好!

package com.testScala.G_trait

trait LoggerDetail {
  // 在trait中定義具體方法
  def log(msg: String) = println(msg)
}

class PersonService extends LoggerDetail {
  def add() = log("添加用戶")
}

object MethodInTrait {
  def main(args: Array[String]): Unit = {
    val personService = new PersonService
    personService.add()
  }
}

添加用戶

package com.testScala.G_trait

trait Logger3 {
  // 抽象方法
  def log(msg: String)
  // 具體方法（該方法依賴于抽象方法log
  def info(msg: String) = log("INFO:" + msg)
  def warn(msg: String) = log("WARN:" + msg)
  def error(msg: String) = log("ERROR:" + msg)
}

class ConsoleLogger3 extends Logger3 {
  override def log(msg: String): Unit = println(msg)
}

object LoggerTrait3 {
  def main(args: Array[String]): Unit = {
    val logger3 = new ConsoleLogger3

    logger3.log("這是一條日志信息")
    logger3.info("這是一條普通信息")
    logger3.warn("這是一條警告信息")
    logger3.error("這是一條錯(cuò)誤信息")
  }
}

這是一條日志信息
INFO:這是一條普通信息
WARN:這是一條警告信息
ERROR:這是一條錯(cuò)誤信息

package com.testScala.G_trait

import java.text.SimpleDateFormat
import java.util.Date

trait LoggerEx {
  // 具體字段
  val sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm")
  val INFO = "信息:" + sdf.format(new Date)
  // 抽象字段
  val TYPE: String

  // 抽象方法
  def log(msg: String)
}

class ConsoleLoggerEx extends LoggerEx {
  // 實(shí)現(xiàn)抽象字段
  override val TYPE: String = "控制臺(tái)"
  // 實(shí)現(xiàn)抽象方法
  override def log(msg: String): Unit = print(s"$TYPE$INFO $msg")
}

object FieldInTrait {
  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLoggerEx

    logger.log("這是一條消息")
  }
}

控制臺(tái)信息:2022-04-24 15:05 這是一條消息

package com.testScala.G_trait

trait LoggerMix {
  def log(msg: String) = println(msg)
}

class UserService

object FixedInClass {
  def main(args: Array[String]): Unit = {
    // 使用with關(guān)鍵字直接將特質(zhì)混入到對(duì)象中
    val userService = new UserService with LoggerMix
    userService.log("你好")
  }
}

你好

import scala.util.Random


//todo:匹配字符串
object CaseDemo01 extends App{
  //定義一個(gè)數(shù)組
  val arr = Array("hadoop", "zookeeper", "spark", "storm")

  //隨機(jī)取數(shù)組中的一位，使用Random.nextInt
  val name = arr(Random.nextInt(arr.length))
  println(name)

  name match {
    case "hadoop"     => println("大數(shù)據(jù)分布式存儲(chǔ)和計(jì)算框架...")
    case "zookeeper"  => println("大數(shù)據(jù)分布式協(xié)調(diào)服務(wù)框架...")
    case "spark"      => println("大數(shù)據(jù)分布式內(nèi)存計(jì)算框架...")
    //表示以上情況都不滿足才會(huì)走最后一個(gè)
    case _            => println("我不認(rèn)識(shí)你")
  }
}

hadoop
大數(shù)據(jù)分布式存儲(chǔ)和計(jì)算框架...

//todo:匹配類型
object CaseDemo02 extends App{
  //定義一個(gè)數(shù)組
  val arr = Array("hello", 1, -2.0, CaseDemo02)

  //隨機(jī)獲取數(shù)組中的元素
  val value = arr(Random.nextInt(arr.length))
  println(value)

  value match {
    case x: Int                => println("Int=>"+x)
    case y: Double if(y >= 0)    => println("Double=>"+y)
    case z: String             => println("String=>"+z)
    case _                     => throw new Exception("not match exception")
  }
}

hello
String=>hello

package com.testScala.H_pipei

//匹配數(shù)組
object CaseDemo03 extends App{

  //匹配數(shù)組
  val arr = Array(1, 3, 5)
  arr match {
    case Array(1, x, y) => println(x + "---" + y)
    case Array(1, _*)   => println("1...")
    case Array(0)       => println("only 0")
    case _              => println("something else")

  }
}

1...

//匹配集合
object CaseDemo04 extends App{

  val list = List(0, 3, 6)
  list match {
    case 0::Nil        => println("only 0")
    case 0::tail       => println("0....")
    case x::y::z::Nil  => println(s"x:$x y:$y z:$z")
    case _             => println("something else")
  }
}

0....

package com.testScala.H_pipei

//匹配元組
object CaseDemo05 extends App{

  val tuple = (1, 3, 5)
  tuple match {
    case (1, x, y)    => println(s"1,$x,$y")
    case (2, x, y)    => println(s"$x,$y")
    case _            => println("others...")
  }
}

1,3,5

package com.testScala.H_pipei

// 定義一個(gè)樣例類
// 樣例類有兩個(gè)成員name、age
case class CasePerson(name: String, age: Int)

// 使用var指定成員變量是可變的
case class CaseStudent(var name: String, var age: Int)

object CaseClassDemo {
  def main(args: Array[String]): Unit = {
    // 1. 使用new創(chuàng)建實(shí)例
    val zhagnsan = new CasePerson("張三", 20)
    println(zhagnsan)

    // 2. 使用類名直接創(chuàng)建實(shí)例
    val lisi = CasePerson("李四", 21)
    println(lisi)

    // 3. 樣例類默認(rèn)的成員變量都是val的，除非手動(dòng)指定變量為var類型
    //lisi.age = 22  // 編譯錯(cuò)誤！age默認(rèn)為val類型

    val xiaohong = CaseStudent("小紅", 23)
    xiaohong.age = 24
    println(xiaohong)
  }
}

CasePerson(張三,20)
CasePerson(李四,21)
CaseStudent(小紅,24)

case class SendMessage(text: String)

// 消息如果沒有任何參數(shù)，就可以定義為樣例對(duì)象
case object startTask
case object PauseTask
case object StopTask

case class SubmitTask(id: String, name: String)
case class HeartBeat(time: Long)
case object CheckTimeOutTask

object CaseDemo06 extends App{
  val arr = Array(CheckTimeOutTask,
    HeartBeat(10000),
    SubmitTask("0001", "task-0001"))

  arr(Random.nextInt(arr.length)) match {

    case SubmitTask(id, name) => println(s"id=$id, name=$name")
    case HeartBeat(time)      => println(s"time=$time")
    case CheckTimeOutTask     => println("檢查超時(shí)")
  }
}

檢查超時(shí)

object TestOption {
  def main(args: Array[String]) {
    val map = Map("a" -> 1, "b" -> 2)

    val value: Option[Int] = map.get("b")
    println(value)
    val v1 = value match {
      case Some(i) => i
      case None => 0
    }
    println(v1)

    //更好的方式
    val v2 = map.getOrElse("c", 0)
    println(v2)
  }
}

Some(2)
2
0

object TestPartialFunction {
  // func1是一個(gè)輸入?yún)?shù)為Int類型，返回值為String類型的偏函數(shù)
  val func1: PartialFunction[Int, String] = {
    case 1 => "一個(gè)"
    case 2 => "二個(gè)"
    case 3 => "三個(gè)"
    case _ => "其他"
  }

  def main(args: Array[String]): Unit = {
    println(func1(1))

    val list = List(1, 2, 3, 4, 5, 6)

    //使用偏函數(shù)操作
    val result = list.filter{
      case x if x >3 => true
      case _ => false
    }
    println(result)
  }

def main(args: Array[String]): Unit = {
   val i = 10 / 0
    
    println("你好！")
  }

Exception in thread "main" java.lang.ArithmeticException: / by zero
	at ForDemo$.main(ForDemo.scala:3)
	at ForDemo.main(ForDemo.scala)

  def main(args: Array[String]): Unit = {
    throw new Exception("這是一個(gè)異常")
  }

Exception in thread "main" java.lang.Exception: 這是一個(gè)異常
	at ForDemo$.main(ForDemo.scala:3)
	at ForDemo.main(ForDemo.scala)

package com.testScala.I_Extractor

class Student {
  var name: String = _   // 姓名
  var age: Int = _       // 年齡

  // 實(shí)現(xiàn)一個(gè)輔助構(gòu)造器
  def this(name: String, age: Int) = {
    this()

    this.name = name
    this.age = age
  }
}

object Student {
  def apply(name: String, age: Int): Student = new Student(name, age)

  // 實(shí)現(xiàn)一個(gè)解構(gòu)器
  def unapply(arg: Student): Option[(String, Int)] = Some(arg.name, arg.age)
}

object extractor_DEMO {
  def main(args: Array[String]): Unit = {
    val zhangsan = Student("張三", 20)

    zhangsan match {
      case Student(name, age) => println(s"姓名：$name 年齡：$age")
      case _ => println("未匹配")
    }
  }
}

姓名：張三 年齡：20

object learn01 {
  def getMiddle[A](arr: Array[A]) = arr(arr.length / 2)

  def main(args: Array[String]): Unit = {
    val arr1 = Array(1, 2, 3, 4, 5)
    val arr2 = Array("a", "b", "c", "d", "f")

    println(getMiddle[Int](arr1))
    println(getMiddle[String](arr2))

    // 簡(jiǎn)寫方式,scala自動(dòng)進(jìn)行類型推斷
    println(getMiddle(arr1))
    println(getMiddle(arr2))
  }
}

package com.testScala.J_fanxing


  // 類名后面的方括號(hào)，就表示這個(gè)類可以使用兩個(gè)類型、分別是T和S
  // 這個(gè)名字可以任意取
  class Pair[T, S](val first: T, val second: S)

  case class People(var name: String, val age: Int)

  object Pair {
    def main(args: Array[String]): Unit = {

      val p1 = new Pair[String, Int]("張三", 10)
      println(p1.first)
      val p2 = new Pair[String, String]("張三", "1988-02-19")
      println(p2.first)
      val p3 = new Pair[People, People](People("張三", 20), People("李四", 30))
      println(p3.first.age)
    }
  }

張三
張三
20

package com.testScala.J_fanxing

// 類名后面的指定泛型的范圍 ----上界
class Pair1[T <: Person, S <: Person](val first: T, val second: S) {
  def chat(msg: String) = println(s"${first.name}對(duì)${second.name}說: $msg")
}

class Person(var name: String, val age: Int)

object Pair1 {
  def main(args: Array[String]): Unit = {

    val p3 = new Pair1[Person, Person](new Person("張三", 20), new Person("李四", 30))
    p3.chat("你好啊！")
  }
}

張三對(duì)李四說: 你好??！

class Pair22[T <: Person, S >: Policeman <: Person](val first: T, val second: S) {
  def chat(msg: String) = println(s"${first.name}對(duì)${second.name}說: $msg")
}

class Person(var name: String, val age: Int)
class Policeman(name: String, age: Int) extends Person(name, age)
class Superman(name: String) extends Policeman(name, -1)

object Pai {
  def main(args: Array[String]): Unit = {
    // 編譯錯(cuò)誤：第二個(gè)類型參數(shù)必須是Person的子類（包括本身）、Policeman的父類（包括本身）
    val p3 = new Pair22[Person, Policeman](new Person("張三", 20), new Policeman("李四",20))
    p3.chat("你好啊！")
  }
}

張三對(duì)李四說: 你好啊！

class Pair[T](a: T)

object Pair {
  def main(args: Array[String]): Unit = {
    val p1 = new Pair("hello")
    // 編譯報(bào)錯(cuò)，無法將p1轉(zhuǎn)換為p2
    val p2: Pair[AnyRef] = p1

    println(p2)
  }
}

package com.testScala.K_xieBian

class Super
class Sub extends Super

//非變
class Temp1[A](title: String)
//協(xié)變
class Temp2[+A](title: String)
//逆變
class Temp3[-A](title: String)

object Covariance_demo {
  def main(args: Array[String]): Unit = {
    val a = new Sub()
    // 沒有問題，Sub是Super的子類
    val b: Super = a

    // 非變
    val t1: Temp1[Sub] = new Temp1[Sub]("測(cè)試")
    // 報(bào)錯(cuò)！默認(rèn)不允許轉(zhuǎn)換
    // val t2: Temp1[Super] = t1

    // 協(xié)變
    val t3: Temp2[Sub] = new Temp2[Sub]("測(cè)試")
    val t4: Temp2[Super] = t3

    // 逆變
    val t5: Temp3[Super] = new Temp3[Super]("測(cè)試")
    val t6: Temp3[Sub] = t5
  }
}