scala基础函数格式：def 函数名(参数列表) : [返回类型] = { 函数体; }示例：def sum(value1:Int, value2:Int):Int={ value1+value2; } println(sum(2,3)) // --> 5;注意：scala的函数返回参数时，只要确保函数体的最后一条命令返回的值与函数定义的返回值相同即可正常返回。匿名函数格式：(参数)=>函数体;示例：val add=(x:Int)=>x+1; println(add(10)); // --> 11条件语句格式：if (布尔表达式){ 代码块 }if (布尔表达式){ 代码块 }else{ 代码块 } // 三if (布尔表达式1){ 代码块 }else if(布尔表达式2){ 代码块 }else if(布尔表达式3){ 代码块 }else{ 代码块 }示例：var a:Int=10; if(a==10){ println("a等于10"); } // --> a等于10var a:Int=10; if(a<10){ println("a小于10"); }else{ println("a不小于10"); } // --> a不小于10var a:Int=10; if(a<10){ println("a小于10"); }else if(a==10){ println("a等于10"); }else{ println("a不小于10"); } // --> a等于10循环while格式：while(条件表达式){ 循环体 }示例：var num:Int=0; while(num<=10){ num=num+1; } println(num); // --> 11;for格式：for(变量<-集合;过滤条件){ 循环体; }示例：for(num:Int<-1 to 10;if num%2!=1){ println(num); } // --> 2 4 6 8 10注意：n to m 表示从n到m的数组（包含n和m）示例：1 to 4就是(1, 2, 3, 4)for循环的过滤条件要用if做操作，不能直接写个布尔表达式for循环的多重循环嵌套不同于其他语言，只需要在过滤条件里再写一个循环条件，示例：for(num:Int<-1 to 10;js:Int<-1 to 10)do…while格式：do{ 循环体; }while(布尔表达式)示例：var num:Int = 10; do{ num+=1; }while(num<=10); println(num) // --> 11跳出/中断循环scala本身是没有跳出循环或者中断循环的方法的。因此如果要跳出或者中断循环只能先导入一个包，即:scala.util.control._格式：import scala.util.control._; var loop = new Breaks; for(变量<-集合;过滤条件){ 循环体; loop.break; }示例：import scala.util.controll._; var loop = new Breaks; for(num:Int<-1 to 10){ println(num); loop.break; } // --> 1数组(Array)创建格式：var 变量名:Array[数组类型] = new Array[数组类型](数组长度)var 变量名=Array(元素列表)示例：var age:Array[Int] = new Array[Int](3)var age = Array(1,2,3)设置值格式：数组名(下标参数)=元素示例：var age:Array[Int] = new Array[Int](3) age(0)=1; age(1)=2; age(2)=3;获取值格式：数组名(下标参数);示例：var age = Array(1,2,3) println(age(1)) // --> 2常用方法方法名描述arr.length返回数组长度arr.head返回数组第一个元素arr.tail返回数组除了第一个元素以外的元素arr.isEmpty判断数组是否为空arr.contains(x)判断数组是否包含元素xarr1++arr1将两个数组合并为一个数组concat(arr1，arr2)将两个数组合并为一个数组(需要导包)注意：concat()方法的使用需要导入包Array._注意scala默认创建的是不可变数组，创建可变数组需要导入包scala.collection.mutable.ArrayBuffer列表(List)创建scala构造列表还可以使用::加上Nil两个符号进行操作。符号描述Nil代表空列表::中缀操作符，表示从前端扩展，遵循右结合格式：val 常量名:List[列表类型] = List(元素列表)val 常量名:List[列表类型] = 元素1::元素2::Nil示例：val age:List[Int] = List(1, 2, 3, 4)获取值格式：数组名(下标参数);示例：val age = 1::2::3::Nil println(age(1)) // --> 2常用方法方法名描述list.head返回列表第一个元素list.last返回列表最后一个元素list.tail返回列表除了第一个元素外的所有元素list.init返回列表除了最后一个元素外的所有元素list.take(n)返回包含列表前n个元素的新列表list.contains(x)判断列表是否包含某个元素xlist1:::list2合并两个列表list1.:::list2合并两个列表，并且顺序为list2, list1List.concat(list1, list2)合并两个列表注意列表只能赋值给常量。列表构造以后就无法修改元素和元素的顺序。即，无法增删改。想给列表添加新元素可以通过合并列表的方法创建新列表。集合(Set)集合的元素是唯一且不可变的。创建格式：val 常量名:Set[集合类型]=Set(元素列表)示例：val age:Set[Int] = Set(1,2,3,4,5)添加值注意：添加值只能使用可变型map，即导入包scala.collection.mutable.Set格式：集合名+=元素集合名+=(元素列表)集合名++=集合示例：val age:Set[Int] = Set(1,2,3,4,5) age+=10val age:Set[Int] = Set(1,2,3,4,5) age+=(11,12,13,14)va:Set[Int] = Set(1,2,3,4,5) val value:Set[Int] = Set(11,12,13,14,15) age++=value获取值格式：集合名(下标参数)示例：val age:Set[Int] = Set(1,2,3,4,5) println(age(2)) 常用方法方法名描述set.head返回集合的第一个元素set.last返回集合的第二个元素set.tail返回集合除第一个元素的所有元素set.init返回集合除了最后一个元素的所有元素set.take(x)返回含有集合前x个元素的新集合set.contains(x)判断集合是否含有某个元素set1++set2合并两个集合注意scala默认创建的是不可变集合，若是创建可变集合，需要导入包scala.collection.mutable.Set映射(Map)映射是一种可迭代的键值对结构，所有的值都要通过键来获取，并且在map中键是唯一的。创建格式：val 常量名:Map[键类型, 值类型]=Map(键->值)示例：val actor:Map[String,Int] = Map("kirito"->16,"asina"->15,"alen"->14)修改值注意：修改值只能使用可变型map，即导入包scala.collection.mutable.Map格式：映射名(键)=值示例：val actor:Map[String,Int] = Map("kirito"->16,"asina"->15,"alen"->14) actor("asina")=10添加键值对注意：添加值只能使用可变型map，即导入包scala.collection.mutable.Map格式：映射名+=(键->值)示例：val actor:Map[String,Int] = Map("kirito"->16,"asina"->15,"alen"->14) actor+=("sitate"->20)注意scala默认创建的是不可变映射，若是创建可变映射，需要导入包scala.collection.mutable.Map元祖用()括号括起来的，和列表类似的结构。元祖可以包含不同类型的数据。创建格式：val 常量名=new Tuplen(元素列表)其中Tuplen的n这个地方表示的是改元祖的长度，只能为数值val 常量名=(元素列表)示例：val actor = new Tuple4(1, 2, 3, "kirito")val actor = (1, 2, 3, "kirito")获取值注意：元祖取值的下标是从1开始的格式：元祖名._下标参数示例：val actor = new Tuple4(1, 2, 3, "kirito") println(actor._2) // --> 2scala的类(class)创建格式：class 类名(父类参数列表, 参数列表) extends 父类名(父类参数列表){ 类属性列表 def 方法名(方法参数列表):返回类型={ 方法体 } }示例：class character(hpx:Int, spx:Int){ var hp:Int = hpx; var sp:Int = spx; } class Actor(hpx:Int, spx:Int, atkx:Int) extends character(hpx, spx){ var atk:Int = atkx; def Attatk(ehp:Int):Int={ ehp - this.atk } }继承在scala中只允许继承一个父类在scala中使用extends这个关键字来进行继承子类继承父类已经实现的方法使用关键字override子类继承父类中没有实现的方法则不需要使用关键字override格式：class 父类名(父类参数列表, 参数列表){ 类属性列表 def 方法名1(方法参数列表):返回类型={ 方法体 } def 方法名2:返回类型 } class 类名(父类参数列表, 参数列表) extends 父类名(父类参数列表){ 类属性列表 override def 方法名1(方法参数列表):返回类型={ 方法体 } def 方法名2(方法参数列表):返回类型={ 方法体 } }示例：abstract class character(hpx:Int, spx:Int){ var hp:Int = hpx; var sp:Int = spx; def hunger(num:Int):Int ={ this.hp-num } def Attatk(ehp:Int):Int } class Actor(hpx:Int, spx:Int, atkx:Int) extends character(hpx, spx){ var atk:Int = atkx; override def hunger(num:Int):Int ={ this.hp-num-10 } def Attatk(ehp:Int):Int={ ehp - this.atk } }单例模式(object)在scala中没有static关键字，因此scala中不存在静态成员。但是在scala中可以使用object来实现单例模式。是单例的不需要通过new来创建对象，直接通过类名创建没有有参的主构造器，但是有主构造代码块（不包含在任何方法中的代码，就是object的主构造代码块）通常用于封装一些常量、工具类、枚举和隐式转换函数主构造代码块只会执行一次，因为是单例的格式：object 类名{ 类属性列表 def 类方法名(参数列表):返回类型={} }示例：object Enemy{ var atk =10 def Attatk(ehp:Int):Int = { ehp-this.atk } println(Enemy.Attatk(1100)) } Enemy // --> 1090匹配模式变量匹配格式：变量名 match{ case 选项 => 返回值 }示例：val a =List(true,false) for(b:Boolean<- a){ b match{ case true =>println("好") case false =>println("废物") case _ =>println("差") } }列表匹配在match中”_“表示占一位，”_*“表示占任意位。格式：列表名 match{ case 列表类型(参数,_,*) => 返回值 }示例：val a = List(1,2,3,4,5) a match{ case List(1,_,_) => println("yi") case List(_,2,_) => println("er") case List(1,_,_,_,_) => println("san") case List(_,2,_,_*) => println("si") case _ => println("tc") } // --> san样例类case关键值定义的类被称为样例类。样例类是一个特殊的类，经过优化用于模式匹配。格式：case class 类名(参数列表:参数类型)示例：case class Actor(name:String, age:Int) var a = new Actor("kirito",12) var b = new Actor("asina",15) var c = new Actor("alen",19) for(actor:Actor<-List(a,b,c)){ actor match{ case Actor("kirito",12) => println("I'am kirito") case Actor("asina",15) => println("I'am asina") case _ => println("I'am actor") } } // --> I'am kirito // --> I'am asina // --> I'am actor读写文件读取用户可以通过scala的Source类来读取文件内容。即导入包scala.io.Source示例：import scala.io.Source Source.fromFile("文件地址").foreach(print)格式：import scala.io.Source Source.fromFile("C:/Users/honor/Desktop/cs.txt").foreach(print)写入scala不提供任何特殊文件写入能力，进行文件的写操作的时候使用java的I/O类的PrintWriter方法。使用前要导入包java.io._格式：import java.io._ val 常量名 = new PrintWriter(new File("文件路径")) 常量名.write("写入内容") 常量名.close示例：import java.io._ val a = new PrintWriter(new File("C:/Users/honor/Desktop/cs.txt")) a.write("写入内容") a.close键入数据用户可以使用Console.readLine来接收用户键盘输入的指令。格式：val 常量名=Console.readLine示例：val line = Console.readLine // <-- wsys println(line) // --> wsys