val x:T val x:T=e 声明一个常量
var x:T var x:T=e 声明一个变量
def abc(x:T):T=e
def adder(m:T,n:T)=m+n
数值类型：
整型值：Int Long Short Byte
浮点型：Double，Float
布尔值：Boolean(true/false)
字符值：Char，String
除了String归Java.lang 其他均归于scala包
val one6='aaa' char类型是单引号
val one6="aaa" String类型是双引号
scala 没有任何操作符，所有的操作符运算都是对方法（函数）的调用
如1+2 实际是1调用了.+()这个方法 1.+(2)
for(i <- 1 to 4)
println("NO."+i)
1 to 4 (1=<i<=4);1 until 4 (1=< i <=4-1)
定长数组声明
val A=new Array[T](N) 即：val A=new Array[Int](10)
或
val B= Array("aa","bb")
变长数组声明
val C=new ArrayBuffer[T]()
C+=e
C+=(e1,e2)
C++=Array(e3,e4)
C.trimEnd(2) 从数组末尾移除2个元素
C.insert(2,e3,e4)在第二个元素后插入e3,e4
C.remove(3)移除第三个元素后的一个元素
C.remove(3,2)移除第三个元素后的两个元素
D=C.toArray 变长数组转换为定长数组D
D=A.toBuffer 定长数组转换为变长数组D
还可以val G=B+Array("cc","dd") val G=B-Array("aa")
通过for 语句枚举数组成员，把数组成员各加1并生成新数组
val new=for(i<- c) yield i+1
scala 映射
数组是包含一组元素的集合，映射是包含一组键值对元素的集合
对于不可变映射
val scores = Map("Alice" -> 10, "Bob" -> 33) //构造一个不可变的Map[String,Int]
val ss=scores +(a4->b4,a5->b5) //增加
val ss1=scores -(a4->b4,a5->b5)
构造可变映射：
val treasuremap=Map[Int,String]() //key是int类型，value是string类型
val scores2 = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 33) //构造一个可变的映射
scores2 +=(a4->b4,a5->b5)
scores2 -=a4
映射的枚举
for((i,j)<-Z) E（i,j）
获取映射的键或值
val e=Z.keySet
val f=Z.values
元祖是不同类型值的集合
val g=(1,1.2,"sss")
利用方法_1,_2,_3访问元祖的元素
val h=g._1或 val h=g _1 (空格)
类
class hello{
private val value1="hello"
var value2="world"
def add(){println(value1+value2)}
def plus(m:Char)=value2+m
}
类声明后利用new声明对象
val one=new hello
scala对每个类中的字段都提供getter和setter方法
var 声明的字段有getter和setter方法（读写）
val 声明的字段只有getter方法，没有setter方法
每个类都是有主构造器，且与类定义交织在一起
如
class hello(val va1:String,var va2:String){
println("ssssss")
val value3=val+va2
}
val two=new hello("wlllcome","home")
scala允许任何语法结构中嵌套任何语法结构
class a{ pointto => //pointto指向外部类a
var value2="sss"
class b{
val values3=a.this.value2
var value4=pointto.value2
}
通配符“_”表示任意，"_*"表示任意长度
}
scala对象
object语法定义了某个类的单个实例
伴生对象
当一个单例对象存在同名类的时候，称为伴生对象
scala特质
args.foreach(arg=>println(arg))等价于 for(arg<- args) println(arg)
package com.persia
object FuncReturnType {
//写法一，始终待返回值
def add(x:Int,y:Int):Int={
x+y
}
def returnUnit():Unit={
println("another way to return void")
}
//写法二，省略非Unit返回值；如果没有写返回值，则根据等号后面的东西进行类型推演
def test(x:Int)={
x
}
//写法三，省略等号，返回Unit
def returnVoid(){
println("return void")
}
//写法四：省略花括号，如果函数仅包含一条语句，那么连花括号都可以选择不写
def max2(x: Int, y: Int) = if (x > y) x else y
def greet() = println("Hello, world!")
def main(args:Array[String]):Unit ={
println(add(1,2))
println(test(1))
}
}