函式

方法定義

	def 方法名(引數: 引數型別): 回傳值型別 = {
		//方法體

		//最后一行作為回傳值(不需要使用return)
	}

	def max(x: Int, y: Int): Int = {
		if(x > y)
			x
		else 
			y
	}

package org.example

object App {

  def main(args: Array[String]): Unit = {
    println(add(2,5))
  }


  def add(x:Int,y:Int):Int={
  x+y
  }
}

7

package org.example

object App {

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

    println(three())
    //沒有入參的時候可以不用寫
    println(three)
  }




  def three()=1+2
}

無回傳值 自動加Unit

默認引數

默認引數： 在函式定義時，允許指定引數的默認值

  //引數
  def sayName(name: String ) = {
    println(name)
  }

  //默認引數
  def sayName1(name: String ="Jack") = {
    println(name)
  }


//main呼叫

    sayName("jaja")
    sayName1()
    sayName1("Ma")

jaja
Jack
Ma

相關原始碼：SparkContext中使用

命名引數

可以修改引數的傳入順序

  	def speed(destination: Float, time: Float): Float {
  		destination / time
  	}

  	println(speed(100, 10))
  	println(speed(time = 10, destination = 100))

可變引數

變引數(可傳入任意多個相同型別的引數) java中 int… numbers
JDK5+：可變引數

	def sum(number: Int*) =  {
		var result = 0
		for(num <- number) {
			result += num
		}
		result
	}

相關原始碼：org.apache.spark.sql.Dataset中的select方法

條件陳述句

回圈陳述句

• to 1 to 10 (左閉右閉) 1.to(10)
• range Range(1,10) (左閉右開的) Range(1,10,2) (2為步長)
• until 1 until 10 (左閉右開)

to、until的底層呼叫都是Range

scala> 1 to 10
res1: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> Range(1,10)
res2: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> 1.to(10)
res3: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> Range(1,10,2)
res4: scala.collection.immutable.Range = Range(1, 3, 5, 7, 9)

scala> Range(1,10,5)
res5: scala.collection.immutable.Range = Range(1, 6)

scala> Range(10,1,-1)
res8: scala.collection.immutable.Range = Range(10, 9, 8, 7, 6, 5, 4, 3, 2)

scala> 1 until 10
res9: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)

• for

	for(i <- 1.to(10)) {
		println(i)
	}
	for(i <- 1.until(10, 2)) {
		println(i)
	}
	for(i <- 1 to 10 if i % 2 == 0) {
		println(i)
	}

	val courses = Array("Hadoop", "Spark SQL", "Spark Streaming", "Storm", "Scala")
	for(x<- courses) {
		println(x)
	}

	//x其實就是courses里面的每個元素
	// => 	 就是將左邊的x作用上一個函式，變成另外一個結果


	courses.foreach(x=> println(x))

• while

	var (num, sum) = (100, 0)
	while(num > 0){
		sum = sum + num
		num = num - 1
	}
	println(sum)

面向物件

概述

• Java/Scala OO(Object Oriented)
  • 封裝：屬性、方法封裝到類中，可設定訪問級別
  • 繼承：父類和子類之間的關系 重寫
  • 多型：父類參考指向子類物件 開發框架基石

Person person = new Person();
User user = new User();
Person person =new User();

類的定義和使用

package org.example

object ObjectApp {
  def main(args: Array[String]): Unit = {
    val person = new People()
    person.name = "Messi"
    //    println(person.name + ".." + person.age)
    println("invoke eat method: " + person.eat)
    person.watchFootball("Barcelona")

    person.printInfo()
    //編譯不通過 private 修飾
    //    println(person.gender)
  }

}



class People{
  //var(變數)型別自動生成getter/setter
  //這種寫法就是一個占位符
  var name: String = _
  //val(常量)型別自動生成getter
  val age: Int = 10

  private [this] var gender = "male"

  def printInfo() : Unit = {
    print("gender: " + gender)
  }

  def eat(): String = {
    name + " eat..."
  }

  def watchFootball(teamName: String): Unit = {
    println(name + " is watching match of " + teamName)
  }
}

invoke eat method: Messi eat…
Messi is watching match of Barcelona
gender: male

###繼承和重寫

• 繼承
  class Student(name: String, age: Int, var major: String) extends Person(name, age) {}

• 重寫

	override def acquireUnrollMemory()
	override def toString = "test override"

package org.example

object ConstructorApp {
  def main(args: Array[String]): Unit = {
    var person =new Person("zhangsan",99)
    println(person.age+":"+person.name)
    var person2 =new Person("zhangsan",99,"Man")
    println(person2.age+":"+person2.name+";"+person2.gender)
  }

}
//主構造器
class Person(val name: String, val age: Int){
  println("Person constructor enter...")

  val school = "ustc"
   //占位符肯定要預先指定型別
  var gender: String = _

  //附屬構造器
  def this(name: String , age: Int, gender: String){
    //必須要呼叫主構造器或者其他附屬構造器
    this(name, age)
    this.gender = gender
  }

  override def toString = "test override"
  println("Person Constructor leave...")

}

//繼承
//name: String, age: Int, var major: String 繼承父類的可以不用直接寫var 否則需要重新申明
class Student(name: String, age: Int, var major: String) extends Person(name, age) {

  //重寫
  override val school = "pku"
  println("Person Student enter...")

  println("Person Student leave...")
}

抽象類

package org.example

object AbstractApp {
  def main(args: Array[String]): Unit = {
    var stu =new Student1();
    println(stu.age)
    println(stu.name)
    stu.speak;
  }
}
abstract class Person3{
  def speak

  val name: String
  val age: Int
}

class Student1 extends Person3{
  override def speak: Unit = {
    println("speak")
  }
  override val name: String = "Messi"
  override val age: Int = 32
}

伴生類和伴生物件

如果有一個class，還有一個與class同名的object 互為 伴生類和伴生物件

	class ApplyTest{
		def apply(){
			println(...)
		}
	} 
	object ApplyTest{
		def apply(){
			println("Object ApplyTest apply...")
			new ApplyTest
		}
	} 

類名() ==> Object.apply
物件() ==> Class.apply
最佳實踐：在Object的apply方法中去new一個Class

package org.example


object ApplyApp {
  def main(args: Array[String]): Unit = {
//    for(i<-1 to 10){
//      ApplyTest.incr
//    }
//    //object 是一個單例物件
//    println(ApplyTest.count)

    var b=ApplyTest()
    //默認走的是object=》apply
    //Object ApplyTest apply...

    println("-----------------------")
    var c= new ApplyTest()
    c()
    //Class ApplyTest apply...
  }

}
class ApplyTest {
  def apply() = {
    println("Class ApplyTest apply...")

  }

}
object ApplyTest {
  println("Object start...")
  var count = 0
  def incr={
    count=count+1
  }
  def apply() = {
    println("Object ApplyTest apply...")

    //在object中的apply中new class
    new ApplyTest
  }
  println("Object end...")
}

case和trait

case class ：不用new

case class Dog(name: String)
直接可以呼叫Dog("wangcai")

Trait： 類似implements

xxx entends ATrait 
xxx extends Cloneable with Logging with Serializable

原始碼中Partition類