第一章：简单讲解了一下Scala的优劣势
第二章：
val：常量(值) 会自动生成get方法
var: 变量 自动生成get/set方法
lazy属性是遇到Action操作才会执行
优点：大数据需要提前加载的时候不会占用整个系统很多资源
缺点：不判断程序或加载数据的对错，只有在Action运行时才发现
IDEA开发工具的使用：
1、windows下载maven，配置环境变量
2、plugins 可以手动添加Scala包，也可以idea下载
第三章：def 函数名
(可以无参数，也可以有参数): 返回类型(Unit无返回类型) {
//函数体
如果有返回类型，最后一行被当做是返回类型，不需要return
}
如果函数名(无参数) 调用时可以直接函数名
默认参数：可以写一个默认参数函数名(a:Int = 3)，如果没有赋予其它参数，默认a=3
命名参数：参数名对应好了，顺序可以错乱
循环：
1 to 10 （1,2,3,4,5,6,7,8,9,10） 1.to（10） 1 until 10 （1,2,3,4,5,6,7,8,9） 1.until（10） Range(1,10) （1,2,3,4,5,6,7,8,9） for(变量 <- 要遍历的数据) for(变量 <- 要遍历的数据 条件) x.foreach()等价于for循环 while(循环条件)
根据输入的数据不定参数进行计算
例：
println(num(1,2,3)) println(num(1,2,3,4)) def num(no:Int*) = { var result = 0 for(i <- no){ result += i } result }
第四章
封装：属性、方法封装到类中（类是被抽象出来的）
属性：person
private int id, String name, date birthday geter/seter
方法：eat sleep run
继承：
父类和子类之间的关系
子类继承父类，并且还可以重写override
子类继承父类，如果父类有的属性，子类可以不加var/val，父类的方法会执行
重写：子类需要修改父类的方法、属性时需要进行重写 override xxx
抽象类：类的一个或者多个方法、属性没有实现（只有定义）
想要调用，必须实现所有的类、方法，否则不能被调用
多态：父类的引用指向子类
Person person = new Person() User user = new User() val p = new User() //父类接口，子类实现功能
类的定义：
private 只在当前类中调用 _ 占位符，使用占位符必须指定var的数据类型
构造器：
主构造器：
跟在类名后面的属性叫主构造器 class Person（val name:String, val age:Int） 附属构造器: def this(name:String, age:Int, gender:String){ this(name,age) //附构造器第一句话必须调用主构造器或者其它附属构造器 this.gender=gender }
伴生类、伴生对象：
如果有一个class，还有一个和class同名的object， class是object的伴生类，object是class的伴生对象 object类可以直接val p = Person()
APPLY方法：
在object的apply方法中new class
类名() 调用的object.apply
对象() 调用的class.apply
case class：通常用在模式匹配中，调用时不用new，直接调用即可
trait：需要多个继承的时候with链接
第五章：Array 定长数组，定义以后数组长度不能改变
可变数组：scala.collection.mutable.ArrayBuffer +增加数据，++需要加入Array
不可变数组：scala.collection.immutable._
List: Nil 是一个不可变的空集合List，是有序的可以重复的 :_* 可以将Seq转化为list
Buffer：ListBuffer、ArrayBuffer 带Buffer都是可变的
Set：数据是不能重复的
Map:(key-value）键值对操作
第六章
匹配模式：
变量 match{ case x => xxx case _ => xxx //相当于java的 default }
条件模式匹配：
变量 match{ case x => xxx case _ if(xxx) => xxx //注意执行的先后顺序 case _ => xxx //相当于java的 default }
数组匹配：
def NameScore(array: Array[String]): Unit ={ array match{ case Array("zhangsan") => println("zhangsan") case Array(x,y) => println("x,y") case Array("zhangsan", _*) => println("Hi:zhangsan other one") // _* 无限匹配 case _ => println("erveryone") } } NameScore(Array("zhangsan")) NameScore(Array("zhangsan","lisi", "wangwu")) NameScore(Array("zhangwu"))
List匹配
def NameScroe(list: List[String]): Unit ={ list match{ case "zhangsan"::Nil => println("zhangsan") case x::y::Nil => println("x,y") case "zhangsan":: tail => println("Hi:zhangsan other one") case _ => println("erveryone") } } NameScroe(List("zhangsan","wangwu")) NameScroe(List("zhangsan","lisi", "wangwu")) NameScroe(List("zhangwu"))
类型匹配：
def ObjType(obj: Any){ obj match{ case x:Int => println("Int") case x:String => println("String") case x:Map[_,_] => x.foreach(print) case _ => println("other") } } ObjType(1) ObjType("1") ObjType(Map("key"->"value"))
异常处理：
try{ //要执行的代码 }catch{ //可以代码执行错误后，要进行提示或其它信息写到这里 }finally{ //一定会执行，记得要把资源关闭 } case class 对类进行模式匹配，必须要定义一个顶级的类
Some&None 模式匹配：
val b = Map("PK" -> 18, "zhangsan" -> 12, "lisi" -> 20) def gredeTest(name:String): Unit ={ val getGred = b.get(name) getGred match{ case Some(getGred) => println("this some") case None => println("this None") } } gredeTest("PK") gredeTest("lisi") gredeTest("wangwu")
第七章：字符串高级操作：
多行：借助于s"$常量或$变量" 进行打印
val a = "Hello" val b = "World" val c = s"$a $b!" println(c) 使用""""""进行多行打印 Shift + "" 按3次 val a1 = """ |Hello |Wolrd |! """.stripMargin println(a1)
匿名函数：匿名函数没有函数名，可以赋值给变量或常量或匿名函数
val a = (x:Int) => x+1 a(10) 结果：11 val add = (x:Int, y:Int) => x + y add(2,3) 结果：5
柯里化：将原来接收多个参数的函数变换成接收一个单一的参数
高阶函数：
Map：Map(x => （x,1）) 可以把数据进行Tuple（key-value）操作、柯里化 filter:根据条件过滤数据 faltten:将数据进行shuffle， val l = List(List(1,2), List(3,4)) l.flatten 结果：List[Int] = List(1, 2, 3, 4)
FlatMap：结合了flatten和map的特点
reduce：数据进行计算，例如加法：reduce(_+_)
reduceLeft、reduceRight 从左或右开始计算
fold: 数据进行计算，可以再进行单独加一些数据，例如加法，累加后额外再加1：reduce(1)(_+_)
foldLeft、foldRight 数据进行计算，例如加法：reduce(_+_)
foreach：循环遍历与for循环类似
偏函数：{}内的没有match的一组case语句可以进行模式匹配
//PartialFunction[String, String] 偏函数特征[输入参数,输出参数] def moshi:PartialFunction[String, String] = { case "wangwu" => "王五" case "lisi" => "李四" case _ => "None" } println(moshi("wangwu"))
第八章
隐士转换：通过implicit进行隐士转换，最好把隐士转换都放到一个类里面，方便调用------------面试重点
implicit def manToSuperMan(man: Man):SuperMan = new SuperMan(man.name) val superMan = new SuperMan("lisi") superMan.fly() class Man(val name:String){ def eat(): Unit ={ println(s"$name is eat.....") } } class SuperMan(val name:String){ def fly(): Unit ={ println(s"$name is fly ......") } }
隐士参数：对参数增加implicit
def testParam(implicit name:String){ println(name + "====================") } implicit val name = "zhangsan" testParam 隐士类：对类增加implicit implicit class classTest(x:String){ def add(a:Int) = a + x } println("12345".length)
第九章
读取文件：Source.fromFIle(文件路径)(文件编码可以不写)，getLines整行读取
读取MySQL数据：classOf[com.mysql.jdbc.Driver]
读取XML：this.getClass.getClassLoader.getResource("xml文件")
\ 某一层
\\ 所有
