多范式
命令式（imperative）和 函数式（functional）编程风格
Object-Oriented Meets Functional

一切都是对象 一切都是函数 一切都是表达式

SCALA六大特性

1.SEAMLESS JAVA INTEROP
与java无缝整合运行在JVM上的，可互相调用 

2.TYPE INFERENCE 类型自动推断
var 定义变量
val 定义常量

3.CONCURRENCY& DISTRIBUTION 并行和分布式
底层有一个actor通信模型，解决死锁的问题 

4、TRAITS特质和特性
将java中个接口、抽象类等进行整合

5.PATTERN MATCHING 模式匹配
类似java中的switch case 
scala关键字 match 

6.HIGHER-ORDER FUNCTIOINS 高阶函数
一切皆函数


建议类名首字母大写 ，方法首字母小写，驼峰命名法
object 单例对象，相当于工具类
在同一个文件中，object对象和class类的名称相同，则这个对象就是这个类的伴生对象，这个类就是这个对象的伴生类,可以互相访问私有变量
静态的与非静态的相剥离




export SCALA_HOME=/home/dugang/scala-2.12.10
export PATH=$SCALA_HOME/bin:$PATH
source /etc/profile

scala -version

直接输入scala， 进入scala shell 

scala> println("hello")
hello

scala> 1+3.0
res1: Double = 4.0

var和val  
val 不可变

scala> val str = "hello"
str: String = hello

自动类型推导

def hello = { 
    println("hello") 
}  
return 可选 
最后一个表达式作为返回指

def hello(name : String = "Scala") : String = { 
    return "Hello," + name 
}  
hello()
hello("java")

函数参数 val类型 ,不可变

def add = (x : Int, y : Int) => x + y
add(1, 2)
def add2(x : Int)(y : Int) = x + y
add2(1)(2)

不支持i++和++i，使用i+=1

while循环

var i=0 
while (i < args.length) { 
  println (args(i)) 
  i+=1 
}  

for循环 

for (arg <-args) 
  println(arg)  
  
for (i <- 1 to 10 if i % 2 == 0)  
  println(i)  
  
args.foreach(arg => println(arg))  

参数只有一个，可简写
args.foreach(println)  

Array与List 


val args = new Array[String](2)  
args(0) = "hello" 
args(1) = "scala"  

val args = Array("hello", "scala")  

获取数组第一个元素 args(0) 
注意不是 args[0] ！！！

Array长度不可变，但是元素值可变
args(1)="java"

List长度与值都不可变

val list1 = List(1, 2) 
val list2 = List(3, 4) 
// (1,2,3,4) 
val list3 = list1 ::: list2  
// (0,1,2,3,4) 
val list4 = 0 :: list3       

::: 连接两个List

::  将一个新元素放到List 头部



类与对象 

class Person { 
  // var变量 生成getter和setter
  var email = "dyyx@qq.com"  
  // 
  var name : String = _  
  // 常变量 val 只生成getter  
  val age = 9;        
  // 只能在类内部使用 
  private val gender = "male" 
} 

缺省访问级别 public
一个源文件中可以有多个class 

主构造器

class Student(var name : String, val number : String) { 
  println("主构造器！") 
}  
主构造器的参数 会编译成字段
参数声明 不加val或者var 相当于private 

从构造器定义在类内部，方法名为this
从构造器必须先调用已经存在的构造器


继承而来的字段不需要加var或者val
class UniversityStudent(name : String, number : String, val major : String) extends Student(name, number) { 
  ...... 
}  
重写父类的字段或方法 加 override 关键字


抽象类（abstract class）与特质（trait）
抽象方法不需要加关键字，只有声明，没有具体实现
可以声明抽象字段，没有初始值
子类重写父类的抽象方法或者抽象字段，不需要加override

trait特质 有具体实现方法的接口
类可以通过with关键字混入（mix-in）特质，它的对象也可以混入特质


apply方法 
类名+括号，调用对象的apply方法  


val arr = Array(1, 2, 3) 
实际调用的是 
val arr = Array.apply(1, 2, 3)

单例
用object替换class 
当单例对象与类共享同一个名字时，该对象称作类的伴生对象

var arr=for(i<- 1 until 10;if(i>5)) yield  i
arr: scala.collection.immutable.IndexedSeq[Int] = Vector(6, 7, 8, 9)


def hello(name:String): Unit ={
  println(s"hello,${name}")
}

可变参数 
def sum(nums:Int*)={
  var sum=0
  for(n<-nums){
    sum+=n
  }
  println(sum)
}



高阶函数
函数的参数或返回值是函数 



 
柯里化
高阶函数的简化


def fun(a:Int,b:Int)(c:Int,d:Int)={
  a+b+c+d
}
println(fun(1,2)(3,4))