今天我们用IDEA实现scala操作
首先我们要在IDEA
中安装scala
插件
打开 file
进入Settings
找到Updates
取消勾选,然后OK
再在Settings
如下:
安装完,创建scala工程
然后在src
创建scala
类即可。
下面就开始我们今天的正题。
函数的定义与调用
scala要求必须给出所有参数的类型,但是不一定给出函数返回值的类型,只要右侧函数体中不包含递归的语句,scala就自己根据右侧的表达式推断出返回值类型。
class demoa {
def sayHello(name:String,age:Int)={
if(age>18){
printf("hi %s ,you are big boy\n",name);age}
else {
printf("hi %s ,you are a little boy\n",name);age
}
}
}
实现类
object Demo {
def main(args: Array[String]) {
//demoa------------ 函数的定义与调用
val p = new demoa
p.sayHello("xiaona",23)
}
}
结果
hi xiaona ,you are big boy
例
class Sumdemo {
def sum(n:Int)={
var sum = 0;
for (i <- 1 to n)
sum += i
print(sum)
}
}
实现类
object Demo {
def main(args: Array[String]) {
//Sumdemo------------
val a = new Sumdemo()
a.sum(6)
}
}
//结果
//21
//Process finished with exit code 0
默认参数
class demo1 {
//默认参数
def sayHello(fistName:String,
middleName:String="wang",lastName:String="corft")={
print(fistName + " " + middleName + " " + lastName)
}
}
实现类
object Demo {
def main(args: Array[String]) {
//demo1------------默认参数
val a = new demo1
// a.sayHello("haha")
//结果 haha wang corft
// a.sayHello("wang","zhang")
//结果 wang zhang corft
a.sayHello("li","han","guo")
//结果 li han guo
//在调用函数时,也可以不按照函数定义的参数顺序来传递参数,而是使用带名参数的方式来传递。
// a.sayHello(fistName = "Mick", lastName = "Nina", middleName = "Jack")
//结果 Mick Jack Nina
//还可以混合使用未命名参数和带名参数,但是未命名参数必须排在带名参数前面。
a.sayHello("Mick", lastName = "Nina", middleName = "Jack")
//结果 Mick Jack Nina
}
}
java与scala实现默认参数的区别
class Javademo {
// Java与Scala实现默认参数的区别
def sayHello(name: String, age: Int = 20) {
print("Hello, " + name + ", your age is " + age)
}
}
实现类
object Demo {
def main(args: Array[String]) {
val q = new Javademo
q.sayHello("leo")
//结果 Hello, leo, your age is 20
}
}
变长参数
class Candemo {
//变长参数
def sum(nums:Int*)={
var res = 0;
for (num<- nums)
res += num
print(res)
}
}
实现类
object Demo {
def main(args: Array[String]) {
//Candemo------------变长参数
val w = new Candemo
w.sum(1,2,3,6,7)
//19
w.sum(1,2,3)
//6
}
}
使用序列调用变长参数
过程
在Scala中,定义函数时,如果函数体直接包裹在了花括号里面,而没有使用=连接,则函数的返回值类型就是Unit。这样的函数就被称之为过程。过程通常用于不需要返回值的函数。
过程还有一种写法,就是将函数的返回值类型定义为Unit。
scala> def sayHello(name:String)="Hello " + name
sayHello: (name: String)String
scala> sayHello("tyler ")
res2: String = "Hello tyler "
scala> def sayHello(name:String){print("Hello "+ name);"Hello " + name}
sayHello: (name: String)Unit
scala> sayHello("wang")
Hello wang
lazy值
在Scala中,提供了lazy值的特性,也就是说,如果将一个变量声明为lazy,则只有在第一次使用该变量时,变量对应的表达式才会发生计算。这种特性对于特别耗时的计算操作特别有用,比如打开文件进行IO,进行网络IO等。
import scala.io.Source._
lazy val lines = fromFile("C://Users//Administrator//Desktop//test.txt").mkString
即使文件不存在,也不会报错,只有第一个使用变量时会报错,证明了表达式计算的lazy特性。
val lines = fromFile("C://Users//Administrator//Desktop//test.txt").mkString
lazy val lines = fromFile("C://Users//Administrator//Desktop//test.txt").mkString
def lines = fromFile("C://Users//Administrator//Desktop//test.txt").mkString
在Scala中,异常处理和捕获机制与Java是非常相似的。
try {
throw new IllegalArgumentException("x should not be negative")
} catch {
case _: IllegalArgumentException => println("Illegal Argument!")
} finally {
print("release resources!")
}
import java.io._
try {
throw new IOException("io exception")
} catch {
case _: IllegalArgumentException => println("Illegal Argument!")
}
try {
throw new IOException("user defined exception")
} catch {
case e1: IllegalArgumentException=> println("illegal argument")
case e2: IOException=> println("io exception")