idea javaagent参数加在哪里

今天我们用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")