标签：语句 语法 hang -- repo 值类型 字母 equal 参数化
Scala用一种简洁的高级语言将面向对象和函数式编程结合在一起。Scala的静态类型有助于避免复杂应用程序中的错误，它的JVM和JavaScript运行时使您可以轻松访问庞大的库生态系统来构建高性能系统。
Scala在JVM上运行，因此Java和Scala堆栈可以自由混合以实现完全无缝的集成。
根据变量自动推断变量类型。
对集合使用数据并行操作，对并发和分发使用参与者，对异步编程使用期货。
将Java风格接口的灵活性和类的功能结合在一起。提供了多重继承。
类似于Java的swatch...case...，但可以同时匹配类型和类型值。
可以将函数作为参数进行传递。
Scala是由 Martin Odersky 发起，下面是有关他的一些简介。
Martin是EPFL（瑞士领先的技术大学）编程研究组的教授。他在整个职业生涯中一直不断追求着一个目标：让写程序这样一个基础工作变得高效、简单、且令人愉悦。他可能比世界上任何一个人写过更多的Java和Scala代码。他编写了javac，这是大部分Java程序员所使用的编译器。他也编写了Scala编译器scalac，可谓是Scala社区飞速发展的基石。他著有《Programming in Scala》一书，是最畅销的Scala书籍。他曾经就职于IBM研究院、耶鲁大学、卡尔斯鲁厄大学以及南澳大利亚大学。在此之前，他在瑞士苏黎世联邦理工学院追随Pascal创始人Niklaus Wirth学习，并于1989年获得博士学位。
javac -version在命令行上运行，并确保您看到 javac 1.8.___创建项目时，我们将安装最新版本的Scala。注意：如果要打开现有的Scala项目，则可以 在启动IntelliJ时单击“ 打开”。
主方法是一个程序的入口点。JVM要求一个名为main的主方法，接受一个字符串数组的参数。
通过使用对象，你可以如下所示来定义一个主方法。
def main(args: Array[String]): Unit = {
}表达式是可计算的语句。
println(2 + 5) //7你可以组合几个表达式，并且用{}包围起来。我们称之为代码块（block）。
代码块中最后一个表达式的结果，也正是整个块的结果。
println({
val y = 2 * 4
y + 1
})//9函数是带有参数的表达式。
你可以定义一个匿名函数（即没有名字），来返回一个给定整数加一的结果
(x: Int) =>x * 2=>左边代表参数，右边是一个包含参数的表达式。
var double= (x: Int) =>x * 2 //注意位置
println(double(1))//2函数可带有多个参数。
val add=(x:Int,y:Int)=>x+y
println(add(1,2))//3或者不带参数。
var getTheAnswer = () => 11
println(getTheAnswer())//11方法的行为和函数非常类似，但是它们之间还是有一些关键差别。
方法由def进行定义，后面跟方法名，参数，返回值类型，等号和方法体。
def addOne(x: Int) = x + 1
println(addOne(11))方法可以接受多个参数列表。
def addThenMultiple(x: Int, y: Int)(multiplier: Int) = (x + y) * multiplier
println(addThenMultiple(3, 4)(4))还可以不带参数。
def getAnswer()="hello"
println(getAnswer())可以用class定义一个类，后面跟它的名字和构造参数。
class Person(addRess: String, name: String) {
def say(word: String) = {
println(s"${addRess}的${name}说:${word}")
}
}调用
val person=new Person("地球","刘星雨")
person.say("我是火星派过来拯救你们的~") //地球的刘星雨说:我是火星派过来拯救你们的~对象是它们自己定义的单实例，你可以看作类的单例。
你可以使用object关键字来定义对象。
object IdFactory {
private var counter = 0
def create() = {
counter += 1
counter
}
}调用
println(IdFactory.create()) //1特质包含某些字段和方法类型。可以组合多个特质。
你可以使用trait关键字来定义特质。
class CustomizableGreeter(prefix: String, postfix: String) extends Greeter {
override def greet(name: String): Unit = {
println(prefix + name + postfix)
}
}调用
val customGreeter=new CustomizableGreeter("How are you, ", "?")
customGreeter.greet("Scala developer")也可以不带默认实现
class CustomizableGreeter(prefix: String, postfix: String) extends Greeter {
override def greet(name: String): Unit
}Any是所有类型的超类型，也称为顶级类 型。它定义了一些通用的方法如equals、hashCode和toString。Any有两个直接子类：AnyVal和AnyRef。
AnyVal代表值类型。有9个预定义的非空的值类型分别是：Double、Float、Long、Int、Short、Byte、Char、Unit和Boolean。Unit是不带任何意义的值类型，它仅有一个实例可以像这样声明：()。所有的函数必须有返回，所以说有时候Unit也是有用的返回类型。
AnyRef代表引用类型。所有非值类型都被定义为引用类型。在Scala中，每个用户自定义的类型都是AnyRef的子类型。如果Scala被应用在Java的运行环境中，AnyRef相当于java.lang.Object。
val list: List[Any] = List(
"hello",
123,
12.11f,
true,
() => "What's happen"
)类型转换可以按照下面的方向进行转换:
Nothing是所有类型的子类型，没有一个值是 Nothing类型的，它的用途之一是非正常终结信号，如抛异常，程序退出或者无限循环。
Null是所有引用类型的子类型，它有一个单例由null所定义。Null主要使得Scala满足和其它JVM语言的 互操作性的。
一个最简单的类定义是class+标识符，类名首字母应大写。
class User但是通常里面都定义方法。
class User{
def say(name:String)={
println("我叫"+name)
}
}构造器可以通过一个默认值来拥有可选参数。
class Point(x: Int = 0, y: Int = 0) {
def defaultPoint = {
println("x=" + x + ",y=" + y)
}
}调用
val point1=new Point(1,2)
val point2=new Point
point1.defaultPoint //x=1,y=2
point2.defaultPoint //x=0,y=0成员默认是公有的public。使用private访问修饰符可以在类外部隐藏它们。
class Number(val y: Int) {
private var _x = 0
def x = _x
def x_=(newValue: Int) = {
_x = newValue
}
def getNumber = {
println(_x)
}
}调用
val number = new Number(2)
number.x = 10
number.getNumber特质（Traits）用于在类之间共享接口（Interface）和字段（Fields）。它们类似于Java 8的接口。类和对象（Ojbects）可以扩展特质，但是特质不能被实例化，因为特质没有参数。
最简单的特质就是trait关键字+标识符
trait Color
特质也可以定义泛型
trait Color[C] {
def defaultColor(): C
def getColor: C = {
defaultColor()
}
}class MyColor extends Color[String] {
override def defaultColor: String = "红色"
override def getColor: String = {
defaultColor
}
}调用
val color = new MyColor();
println(color.getColor) //红色 凡是需要特质的地方，都可以用子类型来替换。
trait Person {
def name: String
}
class ZhangSan extends Person {
override def name: String = "张三"
}
class LiSi extends Person {
override def name: String = "李四"
}调用
val zhangSan = new ZhangSan
val liSi = new LiSi
var person = ArrayBuffer.empty[Person]
person.append(zhangSan)
person.append(liSi)
person.foreach(p => println(p.name))在Scala中元组是一个可以容纳不同类型元素的类。元组是不可变的。
当我们从函数返回多个值时，元组会派上用场。
元组可以创建如下:
val ingredient=(12,"hello",1.1):Tuple3[Int,String,Double]这将创建一个包含Int元素，一个String元素和一个Double元素的元组。
Scala包含一系列元素：Tuple1，Tuple10等，直到Tuple22。因此我们创建一个n个 元素(n位于1~22之间)的元组时，Scala基本上从上述一组实例中实例化一个类，使用组成元素进行参数化。
使用下划线来访问元组中的元素。‘tuple._n‘取出了第n个元素。
调用上面的实例
println(ingredient._2) //hello val ingredient=(12,"hello",1.1)
val(age,word,num)=ingredient
println(age) //12
println(word) //hello元素数组也可以用于模式匹配。
val personList = List(("张三", 22), ("李四", 24), ("王五", 20)) personList.foreach(p => {
p match {
case ("张三", distance1) => println("我是张三") //我是张三
case p if (p._1 == "李四") => println("我是李四") //我是李四
case _ => println("我是无名氏") //我是无名氏
}
})或者，在‘for‘表达式中。
for (x <- personList) {
println(x._1 + "," + x._2)
}输出：
张三,22
李四,24
王五,20
当某个特质被用于组合类时，被称为混入。
abstract class A {
val message: String
}
class B extends A {
val message = "hello"
}
trait C extends A {
def upperMessage = message.toUpperCase()
}
class D extends B with C调用
val d = new D
println(d.message)
println(d.upperMessage)高阶函数是指使用其它函数作为参数、或者返回一个函数作为结果的函数。
最常见的一个例子是scala集合类（collections）的高阶函数map。
val listNum = Seq(1, 2, 3)
val addOne = (x: Int) => x + 1
val result=listNum.map(addOne)
result.foreach(println) //2 3 4你同样可以传入一个方法作为高阶函数的参数，这是因为Scala编译器会将方法强制转换成一个函数。
val listNum = Seq(1, 2, 3)
def addTwo(x:Int)=x+2
val addTwoResult=listNum.map(addTwo)
addTwoResult.foreach(println)有的时候你需要将函数作为参数减少代码冗余。
//定义一个处理方法
private def add(listNum: List[Int], addFunction: Int => Int) = listNum.map(addFunction)
//定义加1计算
def addOne(listNum: List[Int]) = {
add(listNum, x => x + 1)
}
//定义加2计算
def addTwo(listNum: List[Int]) = {
add(listNum, x => x + 2)
}调用
val listNum = List(1, 2, 3, 4)
val addOneResult = addOne(listNum)
val addTwoResult = addTwo(listNum)
addOneResult.foreach(println) //2 3 4 5
addTwoResult.foreach(println) //3 4 5 6有的时候方法需要返回一个函数
//定义一个方法让x和y相加，然后返回一个带z参数的函数。
def add(x: Int, y: Int) = (z: Int) => x + y + z调用
var addResult = add(1, 2)
var result = addResult(3)
println(result)//6在Scala中可以嵌套定义方法，例如下面对象提供了一个factorial方法计算给定的阶乘:
def factorial(x: Int): Int = {
def fact(x: Int, accumulator: Int): Int = {
if (x <= 1) accumulator
else fact(x - 1, x * accumulator)
}
fact(x, 1)
}调用
println("Factorial of 3: " + factorial(3))//6方法可以定义多个参数， 当使用较少的参数列表调用多参数列表的方法时，会产生一个新的函数，该函数接收剩余的参数列表作为其参数。这被称为柯里化。
下面是一个例子，在Scala集合 trait TraversableOnce 定义了 foldLeft
def foldLeft[B](z: B)(op: (B, A) => B): B调用
val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val res = numbers.foldLeft(1)((m,n)=>m*n)
println(res) //3628800在某些情况下存在单一的函数参数时，例如上述例子foldLeft中的op，多参数列表可以使得传递匿名函数作为参数的语法更为简洁。如果不使用多参数列表，代码可能像这样：
numbers.foldLeft(0,{(m:Int,n:Int)=>m+n})如果要指定参数列表中的某些参数为隐式（implicit），应该使用多参数列表。例如：
def execute(arg: Int)(implicit ec: ExecutionContext) = ???案例类（Case Class）和普通类差不多，但是案例类非常适合不可变的数据。
一个最简单的案例类由关键字case class
case class Test()调用
val test1 = Test//直接调用
val test2 = new Test//使用new调用可以看到方法是可以直接不通过new进行调用的，这是因为case类默认有个apply方法来负责创建对象。
case class Test1(x: Int, y: Int) //定义一个case类
class Test2(x: Int, y: Int) //定义一个普通类调用
val test1_1 = Test1(2, 4)
val test1_2 = Test1(2, 4)
if (test1_1 == test1_2) println("两个类数据相同") else println("两个类是数据不相同")//两个类数据相同
val test2_1 = new Test2(2, 4)
val test2_2 = new Test2(2, 4)
if (test2_1 == test2_2) println("两个类数据相同") else println("两个类是数据不相同")//两个类是数据不相同通过演示可以看到，case 类比较的是具体的值，而普通类比较的是引用。
case class Test(name: String, age: Int)调用
val test = Test("张三", 18)
val test2 = test.copy(name = "李四")//将test值copy给test2，并覆盖name
println(test2.name)//李四
println(test2.age)//18模式匹配是校验某个值（value）是否匹配一个模式的机制，一个成功的匹配同时会将值解构成其组成成分。它是Java中switch的升级版，同时会代替一系列if/else语句。
一个模式匹配包含特定的值，match关键字，以及至少一个case。
var x: Int =11
def matchTest = x match {
case 1 => "one"
case 2 => "two"
case 3 => "three"
case _=>"no"
}
println(matchTest)//no,如果不定义_=>则匹配不到11会报异常。案例类非常适用于模式匹配。
abstract class Person
case class ZhangSan(msg: String) extends Person //继承Person
case class LiSi(msg: String) extends Person //继承Person调用
def talk(person: Person) = person match { //
case ZhangSan(msg) => "张三说" + msg
case LiSi(message) => "李四说" + message
}
val zhangSan = new ZhangSan("我吃饭了")
val lisi = new LiSi("一起去打羽毛球")
println(talk(zhangSan))
println(talk(lisi))为了让匹配更具体，可以加上模式守卫，也就是在case 后面加上if。例如还是上面案例经过简单改造:
def talk(person: Person) = person match { //
case ZhangSan(msg,isShow) if isShow => "张三说" + msg //加了个控制是否显示的参数
case LiSi(message,isShow) if isShow => "李四说" + message//加了个控制是否显示的参数
case other=>"我什么也没说"
} val zhangSan = new ZhangSan("我吃饭了",false)
val lisi = new LiSi("一起去打羽毛球",true)
println(talk(zhangSan))//我什么也没说
println(talk(lisi))//李四说一起去打羽毛球上面的匹配的实例，也可以仅仅匹配类型。
case class ZhangSan(msg: String) extends Person //继承Person
case class LiSi(msg: String) extends Person //继承Person def talk(person: Person) = person match { //
case p: ZhangSan => "张三说" + p.msg //仅匹配ZhangSan类型
case p: LiSi => "李四说" + p.msg //仅匹配LiSi类型
}
val zhangSan = new ZhangSan("我吃饭了")
val lisi = new LiSi("一起去打羽毛球")
println(talk(zhangSan))//张三说我吃饭了
println(talk(lisi))//李四说一起去打羽毛球特质(trait)和类(class)都可以用sealed标记为密封的，这意味着所有子类必须和定义类在相同文件中，从而保证所有子类都是已知的。
sealed abstract class Person单例对象是一种特殊的类，有且只有一个实例。和惰性变量一样，单例对象是延迟创建的，它第一次使用时创建。
单利对象使用关键字object定义
object Test {
def googleEmial(userName: String): String = s"${userName}@Google.com"
}object Test2 {
def main(args: Array[String]): Unit = {
println(googleEmial("zhangsan"))//zhangsan@Google.com
}
}当一个单利对象和某个类共享一个名称时，这个单利对象称为 伴生对象。同理，这个类被称为这个对象的伴生类。类和伴生对象可以互相访问其私有成员。使用伴生对象来定义那些不依赖实例化而存在的成员变量或者方法。
object Person {
private def say(userName: String) = println(userName)
}
case class Person() {
import Person._ //注意这里要引入一下
var userName = "张三 "
val result=say(userName)//这里就可以调用私有方法打印了
}调用
val person=new Person
person.result正则表达式是找出数据中指定的字符串。.r方法可使任意字符串变成一个正则表达式。
val numberPartten = "[0-9]".r
def numP(str: String) = numberPartten.findFirstMatchIn(str) match {
case Some(_) => println("ok")
case None => println("no")
}
numP("12d") //ok ,因为带有数字中的0~9
numP(str = "d") //no，因为提取器是一个包含unapply方法的单利对象，apply方法就像一个构造器，接收参数并返回方法，反之unapply方法接收一个实例对象然后返回最初创建它所用的参数。提取器常用在模式匹配和偏函数中。
import scala.util.Random
object CustomerID {
def apply(name: String) = s"$name--${Random.nextLong}"
def unapply(customerID: String): Option[String] = {
val stringArray: Array[String] = customerID.split("--")
if (stringArray.tail.nonEmpty) Some(stringArray.head) else None
}
}
val customer1ID = CustomerID("Sukyoung") // Sukyoung--23098234908
customer1ID match {
case CustomerID(name) => println(name) // prints Sukyoung
case _ => println("Could not extract a CustomerID")
}Scala是一个轻量级的标记方式用来表示列的推导。推导使用形势为for(enumerator) yield e的for表达式。此处` enumerators 指一组以分号分割的枚举器。一个enumerator要么是 一个产生新变量的枚举器，要么是一个过略器。for表达式在枚举器每一次绑定中都会计算e`值，并在循环结束后返回这些组成的序列。
case class Person(name: String, age: Int)调用
val personList = List(Person("张三", 11),
Person("李四", 20),
Person("赵六", 66)
)
val filterPerson = for (p <- personList if (p.age > 18))
yield p
filterPerson.foreach(x=>println("name:"+x.name+",age:"+x.age))// name:李四,age:20 name:赵六,age:66泛型类是可以使用类型参数的类。
class Person[T] {
def get(t: T) = t
} val person1 = new Person[String]
val result1 = person1.get("hello")
println(result1)//hello
val person2=new Person[Int]
val result2=person2.get(2)
println(result2)//2型变是复杂类型的子类型关系与其组件类型的子类型关系的相关性。 Scala支持泛型类的类型参数的型变注释，允许它们是协变的，逆变的，或在没有使用注释的情况下是不变的。 在类型系统中使用型变允许我们在复杂类型之间建立直观的连接，而缺乏型变则会限制类抽象的重用性。
子类型转换成父类型就叫协变。
使用注释 +A，可以使一个泛型类的类型参数 A 成为协变。 对于某些类 class List[+A]，使 A 成为协变意味着对于两种类型 A 和 B，如果 A 是 B 的子类型，那么 List[A] 就是 List[B] 的子类型。 这允许我们使用泛型来创建非常有用和直观的子类型关系。
考虑以下简单的类结构：
abstract class Animal {
def name: String
}
case class Cat(name: String) extends Animal
case class Dog(name: String) extends Animalobject CovarianceTest extends App {
def printAnimalNames(animals: List[Animal]): Unit = {
animals.foreach { animal =>
println(animal.name)
}
}
val cats: List[Cat] = List(Cat("Whiskers"), Cat("Tom"))
val dogs: List[Dog] = List(Dog("Fido"), Dog("Rex"))
printAnimalNames(cats)
// Whiskers
// Tom
printAnimalNames(dogs)
// Fido
// Rex
}父类型转换成子类型就叫逆变。
通过使用注释 -A，可以使一个泛型类的类型参数 A 成为逆变。 与协变类似，这会在类及其类型参数之间创建一个子类型关系，但其作用与协变完全相反。 也就是说，对于某个类 class Writer[-A] ，使 A 逆变意味着对于两种类型 A 和 B，如果 A 是 B 的子类型，那么 Writer[B] 是 Writer[A] 的子类型。
考虑在下例中使用上面定义的类 Cat，Dog 和 Animal ：
abstract class Printer[-A] {
def print(value: A): Unit
}class AnimalPrinter extends Printer[Animal] {
def print(animal: Animal): Unit =
println("The animal's name is: " + animal.name)
}
class CatPrinter extends Printer[Cat] {
def print(cat: Cat): Unit =
println("The cat's name is: " + cat.name)
}
object ContravarianceTest extends App {
val myCat: Cat = Cat("Boots")
def printMyCat(printer: Printer[Cat]): Unit = {
printer.print(myCat)
}
val catPrinter: Printer[Cat] = new CatPrinter
val animalPrinter: Printer[Animal] = new AnimalPrinter
printMyCat(catPrinter)
printMyCat(animalPrinter)
}这个程序的输出如下：
The cat's name is: Boots
The animal's name is: Boots子类型和父类型不能互相转换叫不变。
class Container[A](value: A) {
private var _value: A = value
def getValue: A = _value
def setValue(value: A): Unit = {
_value = value
}
}val catContainer: Container[Cat] = new Container(Cat("Felix"))
val animalContainer: Container[Animal] = catContainer
animalContainer.setValue(Dog("Spot"))
val cat: Cat = catContainer.getValue // 糟糕，我们最终会将一只狗作为值分配给一只猫在Scala中，类型参数和抽象类型都可以有个类型约束。这种类型边界在限制取值的同时，还能展露更多信息，比如T<:A,这样声明的类型上界T应该是A的子类。
abstract class Person {//定义父类
def name: String
}
abstract class On extends Person {}
class ZhangSan extends On {
override def name: String = "张三"
}
class LiSi extends On {
override def name: String = "李四"
}
class WangWu extends Person {//这个继承的是Person，注意和以上继承的区别
override def name: String = "王五"
}
class OnContainer[oc <: On](o: On) {//限制参数范围只能是On的子类
}调用
val zhangSan = new OnContainer[ZhangSan](new ZhangSan)
val liSi = new OnContainer[LiSi](new LiSi)
var wangWu = new OnContainer[WangWu](new WangWu) //超出限定，所以会报错类型上界 将类型限制为另一种类型的子类型，而 类型下界 将类型声明为另一种类型的超类型。 术语 B >: A 表示类型参数 B 或抽象类型 B 是类型 A 的超类型。 在大多数情况下，A 将是类的类型参数，而 B 将是方法的类型参数。
在Scala中一个类可以作为另一个类的内部成员。
class Person() {
class LiSi() {
def name: String = "我是李四"
}
class WangWu() {
def name = "我是王五"
}
}调用
val person = new Person
val liSi: person.LiSi = new person.LiSi
val wangWu: person.WangWu = new person.WangWu
println(liSi.name)
println(wangWu.name)特质（trait）和抽象类（abstract class）可以包含一个抽象类成员，意味着实际类型可由具体实现来确定。
trait Person {
type T
val elements: T
}
class ZhangSan extends Person {
override type T = Int
override val elements: Int = 11
}调用
val zhangSan = new ZhangSan
println(zhangSan.elements)//11有时要表名一个类型是其它类型的子类型。这Scala中，这也可以表示成复合类型，及多个类型的交集。
假设我们有两个特质 Cloneable 和 Resetable：
trait Cloneable extends java.lang.Cloneable {
override def clone(): Cloneable = {
super.clone().asInstanceOf[Cloneable]
}
}
trait Resetable {
def reset: Unit
}现在假设我们要编写一个方法 cloneAndReset，此方法接受一个对象，克隆它并重置原始对象：
def cloneAndReset(obj: ?): Cloneable = {
val cloned = obj.clone()
obj.reset
cloned
}这里出现一个问题，参数 obj 的类型是什么。 如果类型是 Cloneable 那么参数对象可以被克隆 clone，但不能重置 reset; 如果类型是 Resetable 我们可以重置 reset 它，但却没有克隆 clone 操作。 为了避免在这种情况下进行类型转换，我们可以将 obj 的类型同时指定为 Cloneable 和 Resetable。 这种复合类型在 Scala 中写成：Cloneable with Resetable。
以下是更新后的方法：
def cloneAndReset(obj: Cloneable with Resetable): Cloneable = { //这里就同时拥有clone和reset了。
//...
}自类型用于声明一个特质必须混入其它特质。
trait Person {
def userName: String
}
trait Cls {
this: Person =>
def say = println(userName)
}
class ZhangSan extends Person with Cls {
override def userName: String = "张三"调用
val zhangSan = new ZhangSan
zhangSan.say //张三自动匹配隐式类型进行传递。
abstract class Monoid[A] {
def add(x: A, y: A): A
def unit: A
}
object ImplicitTest {
implicit val stringMonoid: Monoid[String] = new Monoid[String] {
def add(x: String, y: String): String = x concat y
def unit: String = ""
}
implicit val intMonoid: Monoid[Int] = new Monoid[Int] {
def add(x: Int, y: Int): Int = x + y
def unit: Int = 0
}
def sum[A](xs: List[A])(implicit m: Monoid[A]): A =
if (xs.isEmpty) m.unit
else m.add(xs.head, sum(xs.tail))
def main(args: Array[String]): Unit = {
println(sum(List(1, 2, 3))) // uses IntMonoid implicitly
println(sum(List("a", "b", "c"))) // uses StringMonoid implicitly
}
}一个从类型 S 到类型 T 的隐式转换由一个函数类型 S => T 的隐式值来定义，或者由一个可转换成所需值的隐式方法来定义。
隐式转换在两种情况下会用到：
e 的类型为 S， 并且类型 S 不符合表达式的期望类型 T。S 的实例对象 e 中调用 e.m， 如果被调用的 m 并没有在类型 S 中声明。例如，当调用一个接受 java.lang.Integer 作为参数的 Java 方法时，你完全可以传入一个 scala.Int。那是因为 Predef 包含了以下的隐式转换：
import scala.language.implicitConversions
implicit def int2Integer(x: Int) =
java.lang.Integer.valueOf(x)Scala可以按值和类型进行参数化。语法和泛型类似。类型参数括在方括号中，而值参数在圆括号中。
def listOfDuplicates[A](x: A, length: Int): List[A] = {
if (length < 1)
Nil
else
x :: listOfDuplicates(x, length - 1)
}
println(listOfDuplicates[Int](3, 4)) // List(3, 3, 3, 3)
println(listOfDuplicates("La", 8)) // List(La, La, La, La, La, La, La, La)Scala编译器通常可以推断出表达式的类型，因此你不必显示声明它。
val name1="张三"//省略类型,编译器会根据"张三"自动推断出是String类型
val name2:String="张三"//不省略类型Seq(1,2,3).map(x=>x*2) var test = "hello"
test = 1//会报错在Scala中运算符即是方法。任何具有单个参数的方法都可以用 中缀运算符（我们平时用的最多的那种。）
println(10 + 1)//11* / %
+ -
:
= !
< >
&
^
|传名参数仅在被使用时触发实际参数的求值运算。它们与传值参数正好相反。要将一个参数变为传名参数，只需在它的类型前加上=>。
def whileLoop(condition: => Boolean)(body: => Unit): Unit =
if (condition) {
body
whileLoop(condition)(body)
}
var i = 2
whileLoop (i > 0) {
println(i)
i -= 1
} // prints 2 1方法 whileLoop 使用多个参数列表来分别获取循环条件和循环体。 如果 condition 为 true，则执行 body，然后对 whileLoop 进行递归调用。 如果 condition 为 false，则永远不会计算 body，因为我们在 body 的类型前加上了 =>。
现在当我们传递 i > 0 作为我们的 condition 并且 println(i); i-= 1 作为 body 时，它表现得像许多语言中的标准 while 循环。
如果参数是计算密集型或长时间运行的代码块，如获取 URL，这种延迟计算参数直到它被使用时才计算的能力可以帮助提高性能。
注解将元信息与定义进行关连。例如，方法之前的注解 @deprecated 会导致编译器在该方法被使用时打印警告信息。
object DeprecationDemo extends App {
@deprecated("deprecation message", "release # which deprecates method")
def hello = "hola"
hello
}如果不满足条件，某些注解实际上会导致编译失败。
import scala.annotation.tailrec
def factorial(x: Int): Int = {
@tailrec
def factorialHelper(x: Int, accumulator: Int): Int = {
if (x == 1) accumulator else factorialHelper(x - 1, accumulator * x)
}
factorialHelper(x, 1)
}方法 factorialHelper 使用注解 @tailrec 确保方法确实是尾递归的。 如果我们将方法 factorialHelper 的实现改为以下内容，它将编译失败：
import scala.annotation.tailrec
def factorial(x: Int): Int = {
@tailrec
def factorialHelper(x: Int): Int = {
if (x == 1) 1 else x * factorialHelper(x - 1)
}
factorialHelper(x)
}我们将得到一个错误信息 “Recursive call not in tail position”.
像 @inline 这样的注解会影响生成的代码 。
scala可以定义默认参数值，这样调用者就可以忽略这些默认值的参数。
def person(name: String = "", age: Int = 18): Unit = {
println(name + "" + age + "岁了")
}调用
person("张三")//张三18岁了
person("李四", 11)//李四11岁了当调用方法时，实际名称可以通过其对应形式的参数的名称来标记。
def person(name: String = "", age: Int = 18): Unit = {
println(name + "" + age + "岁了")
}调用
person(name="王五")//王五18岁了Scala使用包资源来创建命名空间，从而允许你创建模块化程序。
package users {
package administrators {
class NormalUser
}
package normalusers {
class NormalUser
}
}import endTest._ //导入endTest包下所有成员
import endTest.Test //导入类TestScala 提供包对象作为在整个包中方便的共享使用的容器。
包对象中可以定义任何内容，而不仅仅是变量和方法。 例如，包对象经常用于保存包级作用域的类型别名和隐式转换。 包对象甚至可以继承 Scala 的类和特质。
按照惯例，包对象的代码通常放在名为 package.scala 的源文件中。
每个包都允许有一个包对象。 在包对象中的任何定义都被认为是包自身的成员。
看下例。 假设有一个类 Fruit 和三个 Fruit 对象在包 gardening.fruits 中；
// in file gardening/fruits/Fruit.scala
package gardening.fruits
case class Fruit(name: String, color: String)
object Apple extends Fruit("Apple", "green")
object Plum extends Fruit("Plum", "blue")
object Banana extends Fruit("Banana", "yellow")包对象与其他对象类似，这意味着你可以使用继承来构建它们。 例如，一个包对象可能会混入多个特质：
package object fruits extends FruitAliases with FruitHelpers {
// helpers and variables follows here
}标签：语句 语法 hang -- repo 值类型 字母 equal 参数化
原文地址：https://www.cnblogs.com/shun7man/p/12508320.html
