1.Scala概述
- scala是一门多范式编程语言，集成了面向对象编程和函数式编程等多种特性。
- scala运行在虚拟机上，并兼容现有的Java程序。
- scala源代码被编译成java字节码，所以运行在JVM上，并可以调用现有的Java类库。
2.第一个Scala程序
HelloScala.scala
object HelloScala{
def main(args:Array[String]){
println("HelloScala,I love you!")
}
}
cmd --->e:--->scalac HelloScala.scala
运行过程需要先编译，再执行。
编译后生成2个文件
运行 scala HelloScala
输出结果Hello Scala
3.Scala的基本语法
3.1 基本概述
*Scala基本语法：
* 区分大小写
* 类名首字母大写（MyFirstScalaClass）
* 方法名称第一个字母小写（myMethodName()）
* 程序文件名应该与对象名称完全匹配
*
* def main(args:Array[String]):scala 程序从main方法开始执行，程序的入口
*
* Scala注释：分为单行注释 // 和多行注释 /* */
*
* 引入:import java.util.HashMap
* 如果想要引入包中的几个成员，可以使用selector(选取器)：
* import java.awt.{color,Font}
*
* //重命名成员
* import java.util.{HashMap => JavaHashMap}
* //隐藏成员
* 默认情况下，Scala总归引入 java.lang._、scala._和Predef._ 所以在使用的时候都是省去了scala.的
*
*/
3.2 常用数据类型
Scala和Java一样，有7种数值类型：Byte、Char、Short、Int、Long、Float和Double(无包装类型)和一个Boolean类型。
3.3 变量声明
object VariableDemo {
def main(args: Array[String]): Unit = {
//使用val定义的变量值是不可变的，相当于java里用final修饰
val i =1
//使用var定义的变量是可变的，在Scala中鼓励使用val 方便垃圾回收
val j =1
//Scala编译器会自动推断变量的类型，必要的时候可以指定类型
val str : String = "hello world"
}
}
3.3 条件表达式
Scala的条件表达式比较简洁
object ConditionDemo {
def main(args: Array[String]): Unit = {
//赋 初值 x
val x = 1
//判断x的值，并将结果赋值给y
val y = if(x>0) 1 else -1
//打印y值
println(y)
//支持混合类型表达式
val z = if(x>1) 1 else "error condition"
//打印z值
println(z)
//在Scala中 每一个表达式都有值，scala中有一个Unit类，写作（）,相当于Java中的void
//如果缺失else 相当于 val m = if(x >2) 1 else ()
val m = if(x >2) 1
println(m)
//if 和 else if 的混用
//如果x<0 返回0
//如果0<=x<1,返回-1
//如果x>=1返回1
val k = if(x <0 ) 0 else if (x>=1) 1 else -1
println(k)
}
}
运行结果
3.4 访问修饰符
Scala访问修饰符和Java基本一样，分别有private、protected、public。
默认情况下，Scala对象的访问级别是public
(1) 私有对象
用private关键字修饰的成员仅在包含了成员定义的类或对象内部可见。
object Outer {
class Inner{
def start() = println("start")
def end()=println("end")
//将pause方法用private修饰
private def pause() = println("pause")
}
def main(args: Array[String]): Unit = {
new Inner().start()
new Inner().
new Inner().end()
}
}
(2) protected
和私有成员类似，Scala的访问控制比Java来说稍显严格，在Scala中，由protected定义的成员只能由定义该成员和其派生类型访问。而在Java中，由protected定义的成员可以由同一个包中的其他类型访问。在Scala中，可以通过该其他方式来实现这种功能。
class Super {
protected def f() = println("f")
}
class Sub extends Super{
//可以直接调用父类f()
f()
}
class Other{
(new Super).f()//Error:f不可以访问到
}
(3) public
public访问控制为Scala定义的缺省方法，所以没有使用private和protected修饰的成员（定义的类和方法）都是”公开的“，这样的成员可以在任何地方被访问。Scala不需要使用public来指定”公开访问“修饰符。
注意：Scala中定义的类和方法默认都是public的，但在类中声明的属性默认是private的
(4) 作用保护域
作用域保护：Scala中，访问修饰符可以通过使用限定词强调
private[x] 或者protected[x]
private[x]：这个成员除了对[...]中的类或[...]中的包中的类及他么的伴生对象可见外，对其他的类都是private
3.5 Scala运算符
与Java一样，不过Scala的运算符实际上是一种方法。
3.6块表达式
object BlockExpressionDemo {
def main(args: Array[String]): Unit = {
val x=0
//在Scala中{}中包括一系列的表达式，块中最后一个表达式的值就是块的值
var result = {
if(x <0){
-1
}else if(x >=1){
1
}else{
"error"
}
}
//result的值就是块表达式的值
println(result)
}
}
运行结果： error
3.7 循环
在Scala中有for循环和while循环，用for循环比较多
for循环语法结构： for( i < - 表达式/数组/集合)
object forDemo {
def main(args: Array[String]): Unit = {
//for (1 <- 表达式),表达式 1 to 10返回一个Range(区间)
//每次循环将区间中的一个赋给i
for (i <- 1 to 10)
println(i)
//for(i <- 数组)
val arr = Array("a","b","c")
for (i <- arr)
println(i)
//高级for循环
//每个生成器都可以带一个条件，注意：if前面没有分号
for(i <- 1 to 3;j <- 1 to 3 if i !=j)
print(10*i+j+" ")
println()
/*运行结果：
12 13 21 23 31 32
*/
//for推导式：如果for循环的循环体以yield开始，则该循环会构造出一个集合
//每次迭代生成集合中的一个值
val v = for (i <- 1 to 10) yield i*10
println(v)
/*
运行结果：Vector (10, 20, 30 ... 100)
*/
//表示从1 到 2 不包括3
for (i<- 1 until(3))
print(i+" ") // 运行结果： 1 2
}
}
总结：
1）在scala里没有运算符，+-*/%等操作符实际上都是方法，例如：a+b 是如下方法调用的简写： a+(b)
- 在scala中没有++ --的用法
3）for(i <- 表达式/数组/集合)
4）在for循环里面可以添加if表达式
5）有两个特殊的表达式需要了解：
To 1 to 3 1 2 3 包括3
Until 1 Until 3 1 2 不包括3 - 如果在使用for循环的时候，可以伴随使用yield关键字对结果进行收集。
4.方法和函数
4.1 定义方法
方法的返回值类型可以不写，编译器可以自动推断出来。但是对于递归函数，必须指定返回类型
4.2 定义函数
4.3 方法和函数的区别
在函数式编程语言中，函数是“头等公民”，它可以像任何其他数据类型一样被传递和操作
案例：首先定义一个方法，在定义一个函数，然后将函数传递到方法里面。
object TestScala {
//定义一个方法
//方法m1参数要求是一个函数，函数的参数必须是两个Int类型
def m1(f:(Int,Int) => Int):Int = {
f(2,6)
}
//定义一个函数f1,参数是两个Int类型。返回值是一个Int类型
val f1 = (x:Int,y:Int) =>x+y
//定义一个函数f2
val f2 =(m:Int,n:Int)=> m * n
//main方法
def main(args: Array[String]): Unit = {
//调用m1方法，并传入f1函数
val r1 = m1(f1)
println("r1="+r1) //运行结果：r1 = 8
//调用m1方法，并传入f2函数
val r2 = m1(f2) //运行结果： r2 = 12
println("r2 ="+r2)
}
}
4.4 将方法转换为函数
