Scala简介

package com.zy

object test {
  //能简则简
  var bb=100
  def main(args:Array[String]):Unit={
    println("hello scala")
    AAA.show()
    println(bb)

    //var和val
    var value1=100//自动推断类型
    var value2:Int=100//自己规定

    val  value3=200//同java常量
    val  value4="你好"

    //----------------
    value1=200
    println(value1)
    //value3=800   编译报错


    var result=1.to(10)
    println(result)//Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    println(1 to 10)//结果同上
    println(1 until 10)//Range(1, 2, 3, 4, 5, 6, 7, 8, 9)


    var  value5="ABC".toLowerCase()
    println(value5)
    //如果括号没有副作用【理解如果该方法在此次使用中不需要填入参数，那么小括号可以省略】
    var value6="EHPD".toLowerCase
    println(value6)


    println(!true)//false
    println("he"+"llo"=="hello")//true
    println(1==1.0)//true   同Java


    //if表达式有值
    var result1=if (3>1)
      {
        println(111)
        1+2
        50+60//默认最后一行为返回值
      }
    else 200
    println(result1)//110

    var s=0
    if (3>1) s=100 else s=200
    println(s)


    var result2:Any=if (3>1) "adult" else 0
    println(result2)


    //理论上不满足条件，又没有else，会输出unit---表现形式()
    val result3=if (5<4) "你好"
    println(result3)//输出   ()

    //带c风格
    printf("Hello,%s! You are %d years old", "Fred", 42)//Hello,Fred! You are 42 years old


    //接收控制台输入
    //var name=readLine("请输入你的名字")
    //println(name)


    println()
    var  sum=0;
    while (sum<10){
      println("a")
      sum+=1//不能sum++
    }//a1a2a3a4a5a6a7a8a9a10

    var sum2=0
    do {
      println("b")
      sum2+=1

    }while(sum2<10)//b1b2b3b4b5b6b7b8b9b10



    for(i <- 1 to 9; j <- 1 to i) {
      var ret = i * j
      print(s"$i*$j=$ret\t")//不带$默认都是字符串，带$表示取值
      if(i == j) {
        println
      }
    }
println()
    for(i <- 1 to 9; j <- 1 to i if i!=j) {//if相当于给内层循环增加了条件【循环守卫】
      var ret = i * j
      print(s"$i*$j=$ret\t")//不带$默认都是字符串，带$表示取值
      if(i == j) {
        println
      }
    }


    println("")
    println("------------------------------")
    import scala.util.control.Breaks._//导包的位置不定
    var n = 15
    breakable {
      for(c <- "Spark Scala Storm") {
        if(n == 10) {
          println()
          break
        } else {
          print(c)
        }
        n -= 1
      }
    }




    println("-----------------------------")
    //关键词yield记录迭代关键值--记录在一个数组中
     val ints = for (i<- 1 to 10 ) yield(i%2)
    println(ints)//Vector(1, 0, 1, 0, 1, 0, 1, 0, 1, 0)
    val array = for (i<- Array(1,2,3,4,6) ) yield(i+1)
    //返回一个数组 [I@52af6cff
    println(array)
    for (a<- array){
      println(a)//2
                //3
                //4
                //5
                //7
    }
    //让小弟yield在记录关键值后进行二次加工



    //异常的处理
    try{

      //1/0
      var arr=Array(1,2,3)
      println(arr(9))
    }catch {
      case e:ArithmeticException=>{println("除数不能为零"+e.getMessage)}
      //case e:Exception=>{println("有异常\t"+e.getMessage)}
      case _=>{println("如果在异常列表找不到，就走这个case")

      }

    }

    finally {
      println("this is 必须要执行的语句")
    }

  }

}

 

函数

package com.zy

import scala.io.Source

object test2 {
  //简约而不简单
  def main(args: Array[String]): Unit = {//Unit无返回值
    val vv= myFunction("小明",30)
    println(vv)

    val xxx = myFunction2("xxx")

    println(xxx)

    aa//无参函数
    //val aa=0//与函数名称相同时会报错，因为函数无参数时括号可省略


    val i = myFunction4(5)
    println("5的阶乘"+i)


    myFunction9("如花",num=60,age=90)//未命名的参数是排在前面

    myFunction10("aa","bb","cc")
    //实际可变参数传入的是一个Array，但是我们不能传数组
    val arr=Array("hh","jj","kk")
    myFunction10(arr:_*)//逐个传入数组的每个元素


    myFunction11


  }

  def myFunction(name:String,age:Int): Int ={
    println(name+"\t"+age)
    10//默认找最后一行当作返回值
    //return 20
    //println("abcd")
    //30//写在return后面虽然不报错但不会返回

  }

  //单行函数
  def  myFunction2(name:String):Unit=println("你好")//返回值为()

  def aa():Unit={
    println("我是aa")
  }

  def myFunction3()={
    10
  }

  //递归函数必须指定返回值，不能让其自动推断
  def myFunction4(num:Int):Int={
    if (num==1){
      1
    }else{//在方法内部自己调用自己
      num*myFunction4(num-1)//根据阶乘的公式，推出来的代码逻辑【数学】
    }
  }

  def  myFunction5()="哈哈"//这个函数的返回值是String
  def  myFunction6(){"你好"}//这个函数无返回值
  def myFunction7():Unit={10}//这个函数无返回值
  def myFunction8()=println("haha")//这个函数无返回值


  //默认参数
  def  myFunction9(name:String,age:Int=100,num:Int=20): Unit ={
    println(name+"\t"+age+"\t"+num)
  }

  //可变参数【只允许最后一个参数可变长度】(0-n)
  def myFunction10(names:String*): Unit ={
    for (a<- names){
      println(a)

    }

  }


  //懒---褒义词--提升称许性能，节约资源---用到时才初始化
  def myFunction11():Unit={
  lazy val txt=Source.fromFile("C:\\Users\\a\\Desktop\\abc.txt").mkString
    println(1)
    println(1)
    println(1)
    println(1)
    println(txt)//没有这一句时不初始化，文件都不会去找
  }
}