課程大綱

課程內容

學習效果

掌握目標

Scala編程數據結構

Scala類、對象

掌握

熟練掌握類的定義，創建對象

熟練掌握繼承和特質

熟練掌握樣例類、模式匹配

?

Scala繼承

掌握

Scala特質

掌握

Scala樣例類

掌握

Scala模式匹配

掌握

//在Scala中，類的定義可以通過class關鍵字實現，類并不用聲明為public。

//Scala源文件中可以包含多個類，所有這些類都具有公有可見性。

class Dog {

??//屬性必須有初始值，如果不想有初始值初始化為_下劃線，賦值為_是必須指定數據類型

??private var?leg = 4

??def shout(content: String) {

????println(content)

??}

??def currentLeg = leg

}

//在Scala中，類并不用聲明為public。默認就是public

val dog = new Dog

//調用方法，通過對象.方法 對象+空格+方法

dog shout "汪汪汪"

dog.shout("汪汪汪")

println(dog currentLeg)

println(dog.currentLeg)

//訪問屬性，通過對象.屬性 對象+空格+屬性

dog.leg = 4

println(“leg = “+dog.leg)

dog leg = 4

println(dog leg)

//在Scala中，類并不用聲明為public。

//Scala源文件中可以包含多個類，所有這些類都具有公有可見性。

class Person {

??//用val修飾的變量是只讀屬性，有getter但沒有setter

??//（字面量，相當與Java中用final修飾的變量）

??val id?= "9527"

??//用var修飾的變量既有getter又有setter

??var age: Int = 18

// _代表初始值,使用時屬性必須指定類型

var color:Strng =?_

??//類私有字段,只能在伴生對象和類的內部使用

??private var name: String = "唐伯虎"

??//對象私有字段,訪問權限更加嚴格的，當前對象的字段只能被Person類的方法訪問到

//對象私有字段,只能在類的內部使用
??private[this] val pet = "小強"

}

//getter

println(dog leg)

//setter

//對象.屬性_=(值)

dog.leg_=(10)

println(dog currentLeg)

class Dog2 {

??private var _leg = 4

??def leg = _leg

??def leg_=(newLeg: Int) {

????_leg = newLeg

??}

}

val dog2 = new Dog2

dog2.leg_=(10)

println(dog2.leg)

import scala.beans.BeanProperty

class Person {

??@BeanProperty var name: String = _

}

val person = new Person

person.setName("Nick")

person.getName

println(person.name)

/**

??*每個類都有主構造器，主構造器的參數直接放置類名后面，與類交織在一起

??*/

class Student(val name: String, val age: Int){

??//主構造器會執行類定義中的所有語句

??println("執行主構造器")

?

??private var gender = "male"

??//用this關鍵字定義輔助構造器
??def this(name: String, age: Int, gender: String){
????//每個輔助構造器必須以主構造器或其他的輔助構造器的調用開始

this(name, age)
????println("執行輔助構造器")
????this.gender = gender
??}

}

?

//主構造器中name屬性沒有初始值，age屬性有初始值，那么在調用主構造創建對象是，可以不傳age這個參數的值

class?Teacher(var name:String,var age:Int=30) {

}

//如果在主構造器中屬性有初始值，那么在調用主構造創建對象是，可以不傳這個參數的值

val?t01 = new Teacher("xiaoming")
println(" t01 name "+t01.name)
println("t01 age = "+t01.age)

?

?

object Constants{
??val path = "aaaaa"
}
object StringUtil{
??def concat(a:String, b:String)= a+b
}

//類A后面加了private，那么主構造器就變為私有了，外部不能new實例
class A private{
??println("我是類")
}
object A{
??//但是伴生對象可以調用私有的主構造器
??println("我是伴生對象"+new A())
}

?

//以下代碼實現單例
class SingleTon private{
??println("我是類")
}
object SingleTon{
??private val _instance = new SingleTon
??def instance = _instance
}

package cn.bigdata.scala

class Dog {
??val id = 1
??private var name = "bigdata"

??def printName(): Unit ={
????//在Dog類中可以訪問伴生對象Dog的私有屬性
????println(Dog.CONSTANT + name )
??}
}

/**
??* 伴生對象
??*/
object Dog {

??//伴生對象中的私有屬性
??private val CONSTANT = "汪汪汪 : "

??def main(args: Array[String]) {
????val p = new Dog
????//訪問私有的字段name
????p.name = "123"
????p.printName()
??}
}

?

object Teacher {
??println("我是對象Teacher")
??//調用Teacher()時，apply()方法會被調用
??def apply() = {println("我是apply()")}
}

?

package cn.bigdata.scala

object ApplyDemo {

??def main(args: Array[String]) {

//調用了Array伴生對象的apply方法

//def apply(x: Int, xs: Int*): Array[Int]

//arr1中只有一個元素5
????val arr1 = Array(5)
????println(arr1.toBuffer)

????//new了一個長度為5的array，數組里面包含5個null
????var arr2 = new Array(5)
??}
}

?

class?Dog(name:String) {
??var age:Int = 0
??def this(name:String,age:Int){
????this(name)
????this.age = age
??}
}
object Dog{
??def apply(name: String): Dog ={
????println("一個參數的apply");
????new Dog(name)
??}
??def apply(name: String,age:Int):Dog={
????println("兩個參數的apply");
????new Dog(name,age)
??}

??def main(args: Array[String]): Unit = {
????var a1 = Dog

//通過一個參數的apply創建對象,Dog會變成斜體
????var a2= ?Dog("lisi")

//通過兩個參數的apply創建對象
????var a3 = Dog("lisi",23)
??}
}

?

class Cat(var name:String, var age:Int) {
???var sex:Char = 'c'
???def this(name:String,age:Int,sex:Char){
????this(name,age)
????this.sex = sex
??}
}

object Cat{
??def apply(name:String,age:Int) = {
????println("這是伴生對象的兩個參數apply方法")
????new Cat(name,age)
??}
??def apply(name:String,age:Int,sex:Char)={
????println("這是伴生對象的三個參數apply方法")
????new Cat(name,age,sex)
??}
??def main(args: Array[String]): Unit = {
????var cat01 = new Cat("bosimao",1)
????var cat02 = Cat("bosimao",1)
????var cat03 = new Cat("bosimao",2,'1')
????var cat04 = Cat("bosimao",2,'1')
??}
}

package cn.bigdata.scala

object AppObjectDemo extends App{
??//不用寫main方法
??println("I love you Scala")
}

?

?

class?Person ?{

??var?name = ""

}

?

class?Employee extends?Person{

??var?salary = 0.0

??def?description = "員工姓名：" + name + " 薪水：" + salary

}

Scala

Java

含義

obj.isInstanceOf[C]

obj instanceof C

判斷obj是不是C類型，返回boolean的值

obj.asInstanceOf[C]

(C)obj

將obj強制轉換成C類型，返回類實例

classOf[C]

C.class

返回class

?val a1 = new A1
?//返回true
?println(a1.isInstanceOf[A1])
?//返回false
println(a1.isInstanceOf[List[Int]])
?//返回class day031$A1
?println(a1.asInstanceOf[A].getClass)
?//報錯java.lang.ClassCastException: day031$A1 cannot be cast to scala.collection.immutable.List
?println(a1.asInstanceOf[List[Int]].size)

?

//返回class day031$A1
println(classOf[A1])
//返回class day031$A1
println(a1.getClass)

class?Person {
??var name = ""
??override def toString = getClass.getName + "[name=" + name + "]"
}

class Employee extends Person {
??var salary = 0.0
??override def toString = super.toString + "[salary=" + salary + "]"
}

class?Person(val name: String, val age: Int) {
??override def toString = getClass.getName + "[name=" + name +
????",age=" + age + "]"
}
class Employee(name: String, age: Int, val salary : Double) extends Person(name, age) {
??override def toString = super.toString + "[salary=" + salary + "]"
}

??class A{
????val name:String = "張三"
????def sleep() = "8 hours" ??//這是無參的方法
??}
??class A1 extends A{
????override val name="歷史"

????override val sleep: String = {"9 hours"} ?//這里理解為屬性
??}

??val a = new A()
??println(a.name)
??println(a.sleep)
??val a1 = new A1()
??println(a1.name)
??println(a1.sleep)
// ?println(a1.sleep()) //編譯錯誤

abstract class A{
??var name:String //抽象屬性
??def desc:String //抽象方法
}

class A1 extends A{
??//實現屬性，可以不加override，也可以加
??override var name: String = "zhangsan"
??//實現方法，可以不加override，也可以加
??override def desc: String = "aaaaaaaa"
}

val a1 = new A1()
println(a1.name)
println(a1.desc)

?

trait?Logger {
??def log(msg: String)
}

class ConsoleLogger extends Logger with Cloneable with Serializable {
??def log(msg: String) {
????println(msg)
??}
}

trait?ConsoleLogger {
??def log(msg: String) {
????println(msg)
??}
}

class Account {
??protected var balance = 0.0
}

class SavingsAccount extends Account with ConsoleLogger {
??def withdraw(amount: Double) {
????if (amount > balance) log("余額不足")
????else balance -= amount
??}
}

//這是一個接口

trait?Animal {

//定義一個抽象方法
??def sleep

//定義一個實現的方法，普通方法
??def eat(): Unit ={
????println("這是接口中的一個方法，已經實現")
??}
}

?

//定義一個類去繼承接口，使用關鍵字extends

class?Emp extends Animal{

??//實現它的抽象方法，關鍵字override 可有可無
??override def sleep: Unit = {
????println("繼承接口，并實現抽象方法")
??}

??//重寫已經實現的方法，關鍵字override 必須有

??override def eat(): Unit = {
????println("繼承接口，并重寫已經實現的方法")
??}
}

?

// extends 繼承一個類/抽象類 ?with 實現接口
// 實現多個接口：with 接口1 with 接口2
class Student extends Human with Animal with Flyable{
??override def work: Unit = {
????println("繼承抽象類，并實現抽象方法")
??}
??override def sleep: Unit = {
????println("實現接口，并實現抽象方法")
??}
}

trait Logger{
??def log(msg:String)=println("日志 "+msg)
}
class A{}
class A1 extends A ?{
}

val a1 = new A1()
println(a1)
//實例a2混入特質，有log方法；a1沒有
val a2 = new A1() with Logger
a2.log("aaaaaaaaa")

trait Logger{
??def log(msg:String)=println("Logger日志 "+msg)
}
trait FileLogger extends Logger {
??override def log(msg: String): Unit = {
????println("FileLogger日志 "+msg)
????//必須調用super
????super.log(msg)
??}
}
trait HDFSLogger extends FileLogger {
??override def log(msg: String): Unit = {
????println("HDFSLogger日志 "+msg)
????//必須調用super
????super.log(msg)
??}
}

class A{}
val a2 = new A() with Logger with FileLogger with HDFSLogger
//從右向左，依次調用各個特質中的log方法
a2.log("aaaaaaaaa")

package cn.bigdata.cases
import scala.util.Random

object CaseDemo01 extends App{
??val arr = Array("a", "b", "c")
??val name = arr(Random.nextInt(arr.length))

??//匹配到case 后面的值，就執行=> 后面的內容
??//沒有匹配到就 匹配_， 執行 => 后面的內容

??name match {
????case "a" => println("aa...")
????case "b" => println("bb...")
????case _ => println("真不知道你們在說什么...")
??}
}

//模式匹配結果作為函數返回值
def patternShow(x : Any) = x match {
??case 5 => "五"
??case true => "真"
??case "test" => "字符串"
??case null => "null值"
??case Nil => "空列表"
??case _ => "其他常量"
}
println(patternShow(5))
println(patternShow(true))
println(patternShow(List()))

//模式匹配結果作為函數返回值
def patternShow(x : Any) = x match {
??case x if (x == 5) => x
??case x if (x == "Scala") => x
??case _ =>
}
println(patternShow(5))
println(patternShow("Scala"))

?

object TypePattern{

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

　　def typePattern(t : Any) = t match {{

　　　　case t : String => "String"

　　　　case t : Int => "Intger"

　　　　case t : Double => "Double"

　　　　case _ => "Other Type"

　　}

　　println(typePattern(5.0))

　　println(typePattern(5))

　　println(typePattern("5"))

　　println(typePattern(List()))

　　}

}

package cn.bigdata.cases

object CaseDemo03 extends App{

??val arr = Array(1, 3, 5)
??arr match {
????case Array(1, x, y) => println(x + " " + y)
????case Array(0) => println("only 0")
????case Array(0, _*) => println("0 ...")
????case _ => println("something else")
??}

//_ 表示一個元素的通配符

//_*?表示0個或者多個元素的通配符

??val lst = List(3, -1)
??lst match {
????case 0 :: Nil => println("only 0")

case?_ ::Nil => println("List 只有一個元素的List,這個元素是任意值")
????case x :: y :: Nil => println(s"x: $x?y: $y")
????case 0 :: tail => println("0 ...")
????case _ => println("something else")
??}

??val tup = (2, 3, 7)
??tup match {
????case (1, x, y) => println(s"1, $x?, $y")
????case (_, z, 5) => println(z)
????case ?_ => println("else")
??}

//元組只能匹配內容，固定長度的元組只能匹配對應長度的元組，只是配置內容，不能匹配長度
}

?

object?ExceptionSyllabus {

??def divider(x: Int, y: Int): Float= {
????if(y == 0) throw new Exception("0作為了除數")
????else x / y
??}

??def main(args: Array[String]): Unit = {
????try {
??????println(divider(10, 3))
????} catch {
??????case ex: Exception => println("捕獲了異常：" + ex)
????} finally {}
??}
}

case class A(id:Int, name:String, age:Int);
//使用伴生對象創建實例
val a = A(1,"張三", 23)
//輸出A(1,張三,23)
println(a)
//已經覆蓋copy方法
val b = a.copy()
//輸出A(1,張三,23)
println(b)
//輸出true
println(a==b)

//定義樣例類
case class Address(street: String, city: String, country: String)
case class Person(name: String, age: Int, address: Address)
//創建實例
val alice = Person("Alice", 12, Address("1 hello world", "2 hello world", "CN"))
val bob = Person("Bob", 12, Address("1 hello world", "2 hello world", "CN"))
val charlie = Person("Charlie", 12, Address("1 hello world", "2 hello world", "CN"))

for (person <- Seq(alice, bob, charlie)) {
??person match { ?//匹配實例值，使用==判斷
????case Person("Alice", 12, Address(_, "2 hello world", _)) => println("hi alice")
????case Person("Bob", 12, Address("1 hello world", "2 hello world", "CN")) => println("hi bob")
????case Person(name, age, _) => println("who are you?")
??}
}