scala基本语法
我们可以根据scala 菜鸟教程来学习
地址为：
https://www.runoob.com/scala/scala-tutorial.htm
1.变量声明
/**
* 定义变量使用var或者val关 键 字
* 语法:
* var | val 变量名称(: 数据类型) =变量值 */
// 使用val修饰的变量, 值不能为修改,相当于java中final修饰的变量
val name = "tom"
name=”李四” //错误
// 使用var修饰的变量,值可以修改
var age = 18
age=40 //正确 ，可以修改
// 定义变量时,可以指定数据类型,也可以不指定,不指定时编译器会自动推测变量的数据类型
val name2 : String = "jack"
2.变量声明字符串的格式化输出
valal name = "JackMa"
val price = 998.88d
val url = "www.baidu.com"
// 普通输出,注意这里是可以使用逗号分隔的，但是在java中，我们是需要用“+”号拼接
println("name=" + name,"price="+price,"url="+url)
// 'f'插值器允许创建一个格式化的字符串，类似于C语言中的printf。
// 在使用'f'插值器时，所有变量引用都应该是printf样式格式说明符，如％d ,％i ,％f等 。
// 这里$name％s打印String变量name,
println(f"姓名：$name%s,价格：$price%1.3f,网址：$url%s")
println(f"姓名：$name,价格：$price,网址：$url")
// 's'插值器允许在字符串中直接使用变量
// 下列语句中将String型变量（$name）插入到普通字符串中
println(s"name=$name,price=$price,url=$url")
//'s'插值器还可以处理任意形式的表达式
val m=12;
val n=33;
println(s"m+n=${m+n}")
println(s"1+1=${1+1}") //output "1+1=2"
3.条件表达式
//if语句的使用
var faceValue=98
var res1=if (faceValue>90) "帅的一批" else "有点恼火"
println(res1)
//3>5 不成立，且代码没有else分支，那么res2应该输出什么呢？
var i=3
var res2=if (i>5) i
println(res2)// output ()代表空
// 支持嵌套，if...else if ...else代码过多时可以使用{}
val score=85
var res3={
if(score<60)"不及格"
else if(score>=60&&score<70)"及格"
else if (score>=80&&score<90)"优秀"
else "非常优秀"}
println(f"res3=$res3")
输出
4.循环语句
// 定一个数组
var arr = Array(1, 2, 3, 4, 5, 6)
//遍历数组中么个元素
for (ele <- arr) {
print(ele+" ")
} /*output:1 2 3 4 5 6*/
println("")
// 0 to 5 =>会生成一个范围集合Range（0,1,2,3,4,5),左闭右闭
for (i <- 0 to 5) {
print(i+" ") /*output:0,1,2,3,4,5*/
}
println("")
// 0 until 5 =>会生成一个范围集合Range（0,1,2,3,4)，左闭右开
for (i <- 0 until 5) {
print(i+" ")/*output:0,1,2,3,4*/
}
println("")
// for循环中可以增加守卫，下面这段语句是打印arr数组中的偶数
for (i <- arr if i % 2 == 0) {
print(i+" ")
} /*input:2,4,6*/
println("\n********************双层for循环****************************")
//双层for循环
for (i <- 1 to 3; j <- 1 to 3 if i != j) {
print(i * 10 + j + " ")
} /*output:12,13,21,23,31,32*/
for (i <- 1 to 3) {
for(j <- 1 to 3 if i != j)
{
println(i * 10 + j + "")
}
}
输出：
1 2 3 4 5 6
0 1 2 3 4 5
0 1 2 3 4
2 4 6
********************双层for循环****************************
12 13 21 23 31 32 12
13
21
23
31
32
********************yield 关键字将满足条件的e的值又组合成一个数组****************************
2
4
6
4运算符和运算符重载
Scala 中的+-*/%等操作符的作用与 Java 一样，位操作符 &|^>><<也一样。
只是有 一点特别的：这些操作符实际上是方法。
例如：
a+b
是如下方法调用的简写：
a.+(b)
a 方法 b 可以写成 a.方法(b)
例如：
var a=4;
var b=5;
var c=a+b;
var d=a.+(b);
println(c) //输出是9
println(d) //输出是9
4方法的定义与调用
//方法声明使用关键字def .
def f1(): Unit =
{
//函数体
println("我是方法体")
}
//方法名为f1. 无参数， 返回值类型为Unit，表示没有返回值
def f2(m:Int,n:Int):Int={
return m+n;
//或者直接写m+n 不用带关键字 return
}
//函数调用 和java相同
f1();
var m=f2(4,5);
println(m)
//方法体比较简单的方法还可以如下声明方式
def sayHello1 = print("Say BB1")
def sayHello2() = print("Say BB2")
sayHello1 // 如果方法没有()调用时不能加()
sayHello2() // 可以省略( ) ,也可以不省略
4函数的定义与调用
函数声明使用val关键字，类似声明变量
val m1= println("我是m1函数")
val m2:(Int,Int)=>Int=(x,y)=>{ x+y }
val m3:(Int,Int)=>Unit=(x,y)=>{ var z=x+y;println(z)}
val m4=(x:Int)=>{x+4;}
注意：
方法与函数的区别
- 声明方式不同
- 函数可以作为方法的参数
通过 Val 函数=方法 _ 把方法转为函数
//声明一个参数为函数的方法， 第一个参数是函数名，第二个参数是参数
Func：Int=>Int 前面的Int表示函数的参数Int类型, 后面的Int表示函数的返回值是Int类型
def cal(func:Int=>Int,x: Int): Unit ={
var r= func(x);
println(r)
}
（func:Int参数名称和类型，Int,x: Int 返回值类型和返回值参数）
例如：如下方法可以作为cal方法的参数
def f1(x:Int): Int ={
x+10;
}
调用cal方法 .注意这里的f1是方法，可以直接作为函数的参数，
系统默认f1转为函数。
cal(f1,4);
也可以使用这样, 先转为函数，后传值。
val f1_m=f1 _;
cal(f1_m,4);
5可变参数
格式. 注意后面的* , params是任意的一个变量。在函数内部就是一个数组了。可以接受多个参数。
//说白了，可变参数就是使用一个数组取接收值
def m2(params: Int *): Unit ={
for(x<-params){
println(x)
}
}
练习代码：
object C1 {
def main(args: Array[String]): Unit = {
// 1、基础变量
val name="zhh"
//name="zzz" //错误 val不能修改
var name3="zhh" //var可修改
name3="zzz"
val name2:String="jack"
// 2、变量声明字符串的格式化输出
val age=18
val address="desfsff"
println("name1="+name,"age1="+age,"address="+address)
println(f"name2=$name%s,age2=$age%s,address=$address%s")
println(f"name3=$name ,age3=$age,address=$address%s")
println(s"name4=$name ,age4=$age,address=$address")
var m=100
var n=3
println(s"m/n=${m/n}")
println(s"m/n=${m*1.0/n}")
var i=3
var res=if (i>5) i
//3、循环遍历
var a1=Array(1,2,3,4,5,6);
for(v <- a1) //<-循环遍历a1 将每次遍历的值赋值给v
{
print(v+" ")
}
println()
a1.foreach(v => print(v+" ")) //v相当于函数参数，print(v+" ")相当于函数体 （相当于匿名函数，，，整体类似于函数function(v）{})
println()
for(i <- 1 to 3)
{
print(i+" ")
}
println()
// 输出数组a1的内容
for(i <- 0 to a1.length-1)
{
print(a1(i)+" ") //用a1(i)表示数组元素
}
println()
for(i <- a1 if i%2 ==0 )
{
print(i+" ") //if i%2 ==0 限制输出条件
}
println()
//双层for循环
for (i <- 1 to 3; j <- 1 to 3 if i != j) {
print(i * 10 + j + " ")
} /*output:12,13,21,23,31,32*/
println()
// 与上面循环等价
for (i <- 1 to 3) {
for(j <- 1 to 3 if i != j)
{
print(i * 10 + j + " ")
}
}
println()
//4、方法
var c2=new C2(); //实例对象
c2.f1();
// 5、函数
//此处为main函数中内容
println("我是main函数的内容")
f2();
m3(3,4) //带参数的函数需要调用（一般不这样用）
//......(1)显式转换
val f3_hanshu=f3 _; //显式转换 方法f3转换为函数
cal(f3_hanshu,20);
//.....显式转换结束
//....（2）隐式转换
cal(f3,20); //20作为f3的参数传给方法f3
// 调用cal方法 .注意这里的f1是方法，可以直接作为函数的参数，
// 系统默认f1转为函数。
//.....隐式转换结束
//（3）可变参数
m2(canshu =1,3,4,5,2,5);
}
//显式转换，隐式转换。。。。。。。
def f3(m:Int): Int ={ //f3作为参数传给方法cal,即f3为参数fun1,
return m+10;
}
def cal (fun1: Int=>Int,m:Int) : Unit ={ //func:Int参数名称和类型，Int,x: Int 返回值类型和返回值参数
var t=fun1(m);
println(t)
}
//显式转换结束，隐式转换结束。。。。。
//可变参数..............
def m2(canshu : Int *): Unit ={
for(x<-canshu ){
print(x+" ")
}
println()
}
//说白了，可变参数就是使用一个数组取接收值，func此时相当于一个数组
可变参数结束..............
// 5、函数
//程序会先执行hashu,和hanshu2（val 一个函数相当于已经实例化类似于是个变量） 后执行main函数！！！！！
def f2(): Unit ={
println("我是方法f2")
}
def f1(x:Int,y:Int): Int ={
return x+y;
}
val hanshu=println("我是函数hanshu")
val hanshu2={println("我是函数hanshu2222")}
val m3:(Int,Int)=>Int=(x,y)=>{ //带参函数
println("dsfdfsfsff")
x+y
} //m3是函数名称，(Int,Int)函数的参数类型，Int是返回值类型 (x,y)返回值参数，{ x+y }为返回值
} package com.zhh
class C2 {
// 4、方法声明
def f1(): Unit ={
println("我是C2.f1")
var t=f2(n1=3,n2=4) //调用方法f2
println(t)
}
def f2(n1:Int,n2:Int): Int ={
// 不能改变n1的值，可用用另一个变量赋予n1的值
var m=n1;
m=222;
return n1+n2
}
}结果为：
我是函数hanshu
我是函数hanshu2222
(name1=zhh,age1=18,address=desfsff)
name2=zhh,age2=18,address=desfsff
name3=zhh ,age3=18,address=desfsff
name4=zhh ,age4=18,address=desfsff
m/n=33
m/n=33.333333333333336
1 2 3 4 5 6
1 2 3 4 5 6
1 2 3
1 2 3 4 5 6
2 4 6
12 13 21 23 31 32
12 13 21 23 31 32
我是C2.f1
7
我是main函数的内容
我是方法f2
dsfdfsfsff
30
30
1 3 4 5 2 5 常量和变量
val声明出来的为常量，不能再次赋值；可以省略类型，scala会自动推导。
var声明出来的为变量，可以再次赋值；可以省略类型，scala会自动推导。
var a = "xxx"; 等同于 var a : String = "xxx";
a = "String 2";
val b = 2;
b = 3; // 会出错
声明多个变量：
val a, b = "xxx"; // a, b的值都是 "xxx"
scala的常用数据类型：
Byte：内置转换为scala.runtime.RichByte
Char：内置转换为scala.runtime.RichChar
Short：内置转换为scala.runtime.RichShort
Int：内置转换为scala.runtime.RichInt
Long：内置转换为scala.runtime.RichLong
Float：内置转换为scala.runtime.RichFloat
Double：内置转换为scala.runtime.RichDouble
Boolean：内置转换为scala.runtime.RichBoolean
这些类型都是类，Scala并不区分基本类型与引用类型。
与java基本类型相对应，但拥有更多的方法，因为会转换为相应的RichXxxx，在转换后的类里添加scala语言层面的方法。
例如：
1.toLong，其中1会被转换为RichInt类型的实例。
1.to(5)会产生Range(1, 2, 3, 4, 5)
任意有穷数字：
BigInt：
BigDecimal：
字符串：
String：对应于scala.collection.immutable.StringOps
类型转换
使用方法，没有强制转换一说。
如：var a : Int = 1
var b : Long = a.toLong
操作符重载
val value = 8 + 5
其中，+ 这些操作是方法。
完整的是val value = (8).+(5)；
(8)转换成Int对象，调用Int对象的+方法（方法名为+）。
没有++，--操作符，因为相应类型是不可变的。
Scala方法调用的简略写法
方法的简略写法：
a 方法 b
完整写
a.方法(b)
例：1.to(2)，可简略写为1 to 2
apply方法：
a(b)
完整为
a.apply(b)
例： "xxx"(2) 实际转换为 "xxx".apply(2)
常用来构造对象
方法作为参数：
匿名方法：
x, y => x + y 或
+
x, y 表示为参数；=>指向方法体；x + y计算和并返回。
+ 中，第一个“”表示第一个参数，第二个“”表示第二个参数。
例："sU".count(_.isUpper)
"sU".count(x => x.isUpper)
import
import math._
作用是导入scala.math包下所有类和对象。以scala.开头的包可以省略。
单例对象object
object定义的对象为单例，可以直接使用 对象名.方法(参数) 进行调用，类似java中的static方法。
伴生对象：拥有与class类同名的object定义的对象。
Scala doc
数学函数位于scala.math包中，而不是位于某个类中；
使用数值类型，使用RichInt、RichDouble等；
使用字符串，使用StringOps；