Fonctions

Définition de la méthode

	def Nom de la méthode(Paramètres: Type de paramètre): Type de valeur de retour = {
		//Corps de la méthode

		//La dernière ligne comme valeur de retour(Pas besoin d'utiliserreturn)
	}

	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())
    // Pas besoin d'écrire quand il n'y a pas de paramètre 
    println(three)
  }




  def three()=1+2
}

Aucune valeur de retour Auto plusUnit

Paramètres par défaut

Paramètres par défaut： Lors de la définition de la fonction , Permet de spécifier les valeurs par défaut des paramètres

  //Paramètres
  def sayName(name: String ) = {
    println(name)
  }

  //Paramètres par défaut
  def sayName1(name: String ="Jack") = {
    println(name)
  }


//mainAppelez

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

jaja
Jack
Ma

Sources pertinentes：SparkContextUtilisé dans

Paramètres nommés

Vous pouvez modifier l'entrée des paramètres Ordre

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

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

Paramètres variables

Paramètres variables ( Vous pouvez passer n'importe quel nombre de paramètres du même type ) javaMoyenne int… numbers
JDK5+：Paramètres variables

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

Sources pertinentes：org.apache.spark.sql.DatasetDansselectMéthodes

Déclaration conditionnelle

Déclaration circulaire

• to 1 to 10 ( Gauche fermée droite fermée ) 1.to(10)
• range Range(1,10) ( Fermeture à gauche et ouverture à droite ) Range(1,10,2) (2Par étapes)
• until 1 until 10 (Fermeture à gauche et ouverture à droite)

to、until Tous les appels de bas niveau sont 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)
	}

	//xEn fait, c'estcoursesChaque élément à l'intérieur
	// => 	  C'est à gauche x En agissant sur une fonction , En un autre résultat 


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

• while

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

Orienté objet

Généralités

• Java/Scala OO(Object Oriented)
  • Encapsulation：Propriétés、 Méthode encapsulée dans la classe , Niveau d'accès réglable
  • Succession： La relation entre les parents et les enfants Réécriture
  • Polymorphisme：La référence de la classe mère pointe vers l'objet de la classe Enfant La pierre angulaire du cadre de développement

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

Définition et utilisation des classes

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()
    //Compilation infructueuse private Modification
    //    println(person.gender)
  }

}



class People{
  //var(Variables) Type généré automatiquement getter/setter
  // Cette écriture est un substituant 
  var name: String = _
  //val(Constante) Type généré automatiquement 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

### Hériter et réécrire

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

• Réécriture

	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)
  }

}
// Constructeur principal 
class Person(val name: String, val age: Int){
  println("Person constructor enter...")

  val school = "ustc"
   // Le substituant doit spécifier le type à l'avance 
  var gender: String = _

  // Constructeur auxiliaire 
  def this(name: String , age: Int, gender: String){
    // Vous devez appeler le constructeur principal ou un autre constructeur secondaire 
    this(name, age)
    this.gender = gender
  }

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

}

//Succession
//name: String, age: Int, var major: String  Celui qui hérite de la classe mère peut ne pas écrire directement var  Sinon, une nouvelle déclaration est nécessaire 
class Student(name: String, age: Int, var major: String) extends Person(name, age) {

  //Réécriture
  override val school = "pku"
  println("Person Student enter...")

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

Classe abstraite

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
}

Classes d'accompagnement et objets d'accompagnement

S'il y en a unclass,Il y a aussi un lien avecclassHomonymeobject L'un pour l'autre. Classes d'accompagnement et objets d'accompagnement

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

Nom de la classe() ==> Object.apply
Objet() ==> Class.apply
Meilleures pratiques：InObjectDeapply De la méthode newUnClass

package org.example


object ApplyApp {
  def main(args: Array[String]): Unit = {
//    for(i<-1 to 10){
//      ApplyTest.incr
//    }
//    //object  Est un objet Singleton 
//    println(ApplyTest.count)

    var b=ApplyTest()
    // Par défaut, c'est 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...")

    //InobjectDansapplyMoyennenew class
    new ApplyTest
  }
  println("Object end...")
}

caseEttrait

case class ：Non, non.new

case class Dog(name: String)
Peut être appelé directement Dog("wangcai")

Trait： Similaireimplements

xxx entends ATrait 
xxx extends Cloneable with Logging with Serializable

Dans le code sourcePartitionCatégorie