概述
简介
Scala将面向对象和函数式编程结合在一个简洁的高级语言中。 Scala的静态类型有助于避免复杂应用程序中的错误，其JVM和JavaScript运行时可让你构建高性能系统，轻松访问庞大的库生态系统
Scala的安装
官网下载scala:https://www.scala-lang.org/
Windows版本安装
- 双击安装，无脑下一步
- 配置环境变量
SCALA_HOME=E:scala
Path中追加 %SCALA_HOMEbin%
- cmd进入黑窗口输入scala,出现如下信息说明配置成功
C:UsersAdministrator>scala
Welcome to Scala 2.11.12 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_161).
Type in expressions for evaluation. Or try :help.
Linux版本安装
[root@CentOSA ~]# rpm -ivh scala-2.11.12.rpm
Preparing... ########################################### [100%]
1:scala ########################################### [100%]
[root@CentOSA ~]# scala
Welcome to Scala 2.11.12 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_191).
Type in expressions for evaluation. Or try :help.
scala>
IDEA集成Scala开发
安装Scala插件，重启idea
变量
Scala语言中没有原始数据类型，这一点和Java语言不同，在Scala中一切且对象。以下是Scala语言中常见类型和类型间的继承关系。
在Java中常见的基本类型在Scala中都被剔除了,Scala将值类型和引用类型分离。所有的数值变量类型都是 AnyVal的子类，这些变量的值都有字面值。对于一些对象类型的变量都是 AnyRef的子类。对于 AnyRef类下的变量（除String类型），一般不允许直接赋值字面量，都需要借助 new关键创建。
变量声明
Scala语言是一种可以做类型自动推断的强类型的编程语言。变量的类型可通过编译器在编译的时候推断出最终类型。因此Scala中声明一个变量主需要告知编译器该变量的值是常量还是变量，例如：例如声明一个变量使用var即可，如果声明的是一个常量使用val关键字。因此Scala中变量声明的语法如下：var|val 变量名[:类型] = 变量值[:类型]
var a:Int = 1:Int
var b:Int = 1
var c = 1:Int
var d = 1
Scala所有的变量在声明时可以省略类型，并不意味之Scala是一种弱类型的编程语言，程序一旦编译后，类型固定，不可以更改。
数值转换
以下是黑窗口命令结果
scala> var i=1
i: Int = 1
scala> var b:Byte=i.asInstanceOf[Byte]
b: Byte = 1
scala> var b:Byte=i.toByte()
<console>:12: error: Byte does not take parameters
var b:Byte=i.toByte()
scala> var b:Byte=i.toByte
b: Byte = 1
用户可以使用asInstanceOf[类型]这种方式在数值间转换。该方式只适合类型兼容的时候使用，如果类型不兼容可以使用toInt、toChar、…等可以将常规参数自动转换为数值类型。
scala> var sex="true"
sex: String = true
scala> sex.toBoolean
res2: Boolean = true
scala> sex.asInstanceOf[Boolean]
java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Boolean
at scala.runtime.BoxesRunTime.unboxToBoolean(BoxesRunTime.java:85)
... 32 elided
数组
声明一个int类型的数组：
val array:Array[Int] = Array(1,2,3)
元组
元组是在Scala编程语言中的一种特殊变量，该变量可以组合任意几种类型的变量，构建一个只读的变量类型。访问元组的成员可以使用_元素下标访问。（一个元组最多有22个元素）
//元组，只读
var t:(String,Int)=("zhanghaonan",18)
print(t._1+t._2+"岁")
var t = (1,1,1,1,1,1,"adsf",1)
print(t._7)
分支循环
if
修饰的代码分支可以赋值给一个变量
var i:Int=new Random().nextInt(30)
var a = if (i<30){
"唵"
}else if(i<60){
"哞"
}else if(i<90){
"咪"
}
println(a)
Break
Scala 语言中默认是没有 break 语句，但是在 Scala 2.8 版本后可以使用另外一种方式来实现 break 语句。当在循环中使用 break 语句，在执行到该语句时，就会中断循环并执行循环体之后的代码块。Scala 中 break 的语法有点不大一样，格式如下：
var loop=new Breaks
loop.breakable({
do{
i -= 1
print(i+"t")
if(i==1) {
loop.break()
}
}while(i!=0)
})
for循环
- 遍历数组
var array = Array(1,2,3,4,5)
for(i<-array){
println(i)
}
var array = Array("苦","海","翻","起","爱","恨")
for(i<-0.to(array.length-1)){
print(array(i))
}
var array=Array("a","b","c")
for( index <- 0 until array.length){
print(array(index)+"t")
}
- for循环可以使用多个循环因子
//99乘法表
for(i<-1 to 9;j <- 1 to i){
print(s"$i*$j="+(i*j)+"t")
if(i==j) println()
}
- for循环嵌套if
for(i<-1 to 9;if(i%2==0 || i%3==0) ){
print(s"$it")
}
- 数组计算
var array=0 to 9
val results = for(i <- array;if(i%2==0)) yield i*i
for(i <- results){
println(i)
}
模式匹配（类似Java中的switch-case）
模式匹配是检查某个值（value）是否匹配某一个模式的机制，一个成功的匹配同时会将匹配值解构为其组成部分。它是Java中的switch语句的升级版，同样可以用于替代一系列的 if/else 语句。
- 数值匹配
val x: Int = Random.nextInt(10)
var result= x match {
case 0 => "zero"
case 1 => "one"
case 2 => "two"
case 3 => "three"
case 4 => "four"
case _ => "other"
}
println(result)
- 类型匹配
var array=Array("zs",true,new Date(),1000.0)
var x=array(new Random().nextInt(array.length))
var result= x match {
case v:String => "name"
case v:Boolean => "sex"
case x:Date => "birth"
case x:Double => "salary"
case _ => "未知"
}
println(result)
函数
- 标准函数
def sum(x:Int,y:Int):Int={
return x+y
}
//可以省略返回值类型
def sum(x:Int,y:Int)={
x+y
}
- 可变长参数
def sum(args:Int*):Int={
var sum:Int=0
for(arg<-args){
sum+=arg
}
}
- 参数默认值
def hello(msg:String="hey",name:String="xiaoming"):Unit={
print(msg+","+name)
}
- 内嵌函数
def factorial(x:Int)={
def mulit(i:Int):Int={
if(i > 0){
i*mulit(i-1)
}else{
1
}
}
mulit(x)
}
等价
def factorial(x:Int):Int={
if(x>0){
x*factorial(x-1)
}else{
1
}
}
- 柯里化（Currying）
在计算机科学中，柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数的函数，并且返回接受余下的参数的新函数的这种技术。
def sum1 (x:Int,y:Int):Int={x+y}
//sum1变成下面的形式
def add(x: Int)(y: Int): Int = {
x + y
}
var result = add(1)(_)
//下划线“_” 作为第二参数列表的占位符， 这个定义的返回值为一个函数，当调用时会给调用的参数加一
print(result(2))
//结果为3，在应用时应该使用这种形式：sum(1)(2)
add(1)(2) 实际上是依次调用两个普通函数（非柯里化函数），第一次调用使用一个参数 x，返回一个函数类型的值，第二次使用参数y调用这个函数类型的值。
匿名函数
Scala中，函数可以没有命名，此时函数被称为匿名函数。
可以直接定义匿名函数之后，将函数赋值给某个变量；也可以直接将定义的匿名函数传入其他函数中。
Scala 中定义匿名函数的语法：(参数名：参数类型)=>函数体
var f:(Int,Int)=>Int = (x:Int,y:Int)=>{x*y}
print(f(4,5))
def a(x: Int, y: Int)(b: (Int, Int) => Int): Int = {
b(x, y)
}
print(a(1,2)((i:Int,j:Int)=>i+j))
高阶函数的类型推断
高阶函数可以自动推断出参数类型，而不需要写明类型；而且对于只有一个参数的函数，还可以省去其小括号；如果仅有一个参数在右侧的函数体内只使用一次，则还可以将接收参数省略，并且可以参数用_来替代。
函数和变量
- 定义一个是变量的函数
var f:(Int,Int)=>Int = (x:Int,y:Int)=>Int
- 声明一个函数
sum:(Int,In)=>Int = (x,y)=>{x+y}
最后
以上就是爱笑蛋挞为你收集整理的Scala基础和函数的全部内容，希望文章能够帮你解决Scala基础和函数所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复