object HelloScala {
  def main(args: Array[String]): Unit = {
    println("hello scala")
    System.out.println("hello java")
  }
}

object VariableDemo {
  def main(args: Array[String]) {
    //使用val定义的变量值是不可变的，相当于java里用final修饰的变量
    val i:Int = 1
    //使用var定义的变量是可变得，在Scala中鼓励使用val
    var s1 = "hello"
    var s2 = "hello"
    //Scala编译器会自动推断变量的类型，必要的时候可以指定类型
    //变量名在前，类型在后
    //import java.lang._
    val s3:String = "bigdata"
    val s4:java.lang.String = "bigdata"
  }
}

package com.bigdata.basic

object OperationDemo {
  def main(args: Array[String]): Unit = {
    var a = 1 + 2
    var b = 1.+(2)
    println(a)//3
    println(b)//3.0

    //var c = a++ //错误
    a += 1
    a.+=(1)
    println(a)//5
  }
}

val `val` = 123

package com.bigdata.basic

object ConditionDemo {
  def main(args: Array[String]) {
    val x = 1
    //判断x的值，将结果赋给y
    val y = if (x > 0) 1 else -1
    //打印y的值
    println(y)

    //支持混合类型表达式
    val z: Any = if (x > 1) 1 else "error"
    //打印z的值
    println(z)

    //如果缺失else，相当于if (x > 2) 1 else ()
    val m = if (x > 2) 1
    println(m)

    //在scala中每个表达式都有值，scala中有个Unit类，用作不返回任何结果的方法的结果类型,相当于Java中的void，Unit只有一个实例值，写成()。
    val n = if (x > 2) 1 else ()
    println(n)

    //if和else if
    val k = if (x < 0) 0
    else if (x >= 1) 1 else -1
    println(k)
  }
}

package com.bigdata.basic

object BlockExpressionDemo {
  def main(args: Array[String]) {
    val x = 0
    //在scala中{}中包含一系列表达式，块中最后一个表达式的值就是块的值
    val result : Any= {
      if (x < 0){
        -1
      } else if(x >= 1) {
        1
      } else {
        "error"
      }
    }
    //result的值就是块表达式的结果
    println(result)
  }
}

package com.bigdata.basic

object BlockExpressionDemo2 {
  def main(args: Array[String]): Unit = {
    val a = 1
    val b = 2
    val result = {
      val c = a + b
      val d = c + a
      d
    }
    println(result)
  }
}

package com.bigdata.basic

object WhileDemo {
  def main(args: Array[String]): Unit = {
    var n = 1;
    val while1 = while(n <= 10){
      n += 1
    }
    println(while1)
    println(n)
    
    println("===============")

    import scala.util.control.Breaks
    val loop = new Breaks
    loop.breakable{
      while(n <= 20){
        n += 1;
        if(n == 18){
          loop.break()
        }
      }
    }
    println(n)
  }
}

package com.bigdata.basic

object ForDemo {
  def main(args: Array[String]) {
    //1.for(i <- 表达式),表达式1 to 10返回一个Range []
    //to为[]  until 为 [)
    //每次循环将区间中的一个值赋给i
    for (i <- 1 to 10)//[1,10]
      println(i)

    println("==========")
    for (i <- 1 to 10 by 2)//[1,10]步长为2
      println(i)

    println("==========")

    for (i <- 1 until 10)//[1,10)
      println(i)

    println("==========")


    //2.for(i <- 数组)
    val arr = Array("a", "b", "c")
    for (i <- arr)
      println(i)

    //总结:
    /*for(变量名 <- 集合){
      循环体
    }*/

    //3.高级for循环
    //每个生成器都可以带一个条件，注意：if前面没有分号
    for(i <- 1 to 3; j <- 1 to 3 if i != j)
      print((10 * i + j) + " ")
    println()


    //4.for推导式：如果for循环的循环体以yield开始，则该循环会构建出一个集合
    //即将遍历过程中处理的结果返回到一个变量
    //每次迭代生成集合中的一个值
    val v = for (i <- 1 to 10) yield i * 10
    println(v) // 10,20,30..100
    //也就是说:如果for循环的循环体以yield开始,for循环会返回一个集合


    //5.{}和 ()都可以
    //当for 推导式仅包含单一表达式时使用()括号，当其包含多个表达式时使用{}括号
    for(
      i <- 1 to 3; //[1,3]
      j = 4 - i//[3,1]
    )
      print(i * j + " ")
    println()

    for {
      i <- 1 to 3;
      j = 4 - i
    }
      print(i * j + " ")
    println()
  }
}

object MethodAndFunctionDemo {
  def main(args: Array[String]): Unit = {
    //1.静态方法（scala中没有静态方法这个概念，需要通过伴生类对象来实现）
    val a: Double = math.sqrt(100)//对象名.方法名
    println(a)

    //2.非静态方法，使用对象调用
    val s = "HelloWorld"
    val len: Int = s.length
    println(len)

    //3.apply方法是调用时可以省略方法名的方法。用于构造和获取元素：
    //Array(1,2,3) 等同于 Array.apply(1,2,3)
    val arr1 = Array(1,2,3)
    println(arr1.mkString(","))
    val arr2 = Array.apply(1,2,3)
    println(arr2.mkString(","))
    
    //"Hello"(1)  等同于  "Hello".apply(1)    //输出e
    val c1: Char = "Hello"(1)
    println(c1)
    val c2 = "Hello".apply(1)
    println(c2)

    //4.update方法也是调用时可以省略方法名的方法，用于元素的更新
    //arr1(1) = 5  等同于  arr2.update(1,5)
    arr1(1) = 5
    println(arr1.mkString(","))
    arr2.update(1,5)
    println(arr2.mkString(","))

    //5.定义并调用函数
    val fun = (x:Int) => x * 10
    val arr3: Array[Int] = arr1.map(fun)
    println(arr3.mkString(","))
  }
}

object MethodAndFunctionDemo2 {
  def main(args: Array[String]): Unit = {
    val a = m1(2,3)
    println(a)
    val b = factorial(4)
    println(b)//4*3*2*1==24
    shout4("abc") //"abc4"
    shout4(content="abc")//"abc4"
    shout4(content="abc",leg=3)//"abc3"
    shout4(leg=3,content="abc")//"abc3"
    val s1: Int = sum(1,2)
    println(s1)
    val s2: Int = sum(1,2,3)
    println(s2)
  }
  //1.方法的返回值类型和return可以不写，编译器可以自动推断出来
  //def 方法名(参数名:参数类型,参数名:参数类型):返回值类型={方法体}
  def m1(x:Int,y:Int):Int = {
    x*y
  }

  //2.对于递归方法，必须指定返回类型
  def factorial(n: Int): Int = {
    if(n <= 0)
      1
    else
      n * factorial(n - 1)
  }
  //f(3) --> 3*f(2) -->3*2*f(1) -->3*2*1*f(0) -->3*2*1*1 ==> 6

  //3.如果方法没有返回值,返回Unit类型(返回值为Unit的方法也叫过程)
  def shout1(content: String) : Unit = {
    println(content)
  }

  //4.返回Unit类型，类型也可以省略
  def shout2(content: String) = {
    println(content)
  }

  //5.返回值类型有多种可能，此时为Any
  def shout3(content: String):Any = {
    if(content.length >= 3)
      content + "喵喵喵~"
    else
      3
  }

  //6.带有默认值参数的方法，调用时，可以只给无默认值的参数传递值，也可以都传递，新值会覆盖默认值；
  //传递参数时如果不按照定义顺序，则可以通过参数名来指定
  def shout4(content: String, leg: Int = 4) = {
    println(content + "," + leg)
  }

  //7.可变参使用 变量名:类型* （类似Java的...）
  def sum(args: Int*) = {
    var result = 0
    for(arg <- args)
      result += arg
    result
  }
}

object FunctionDemo {
  def main(args: Array[String]): Unit = {
    //定义函数方式1:
    //函数名称= (参数名:参数类型) => 函数体
    val f1 = (x:Int,y:Int) => x + y
    val i1 = f1(1,2)//3
    println(i1)

    //定义函数方式2:(了解)
    //函数名称:(参数类型) =>函数返回值类型= (参数名称:参数类型) =>函数体
    val f2:(Int,Int) => Int = (x,y) => x + y
    val i2 = f2(1,2);
    println(i2)
  }
}

def main(args: Array[String]): Unit = {
  val f1 = (x:Int) => x
  val f2 = (x:Int,y:Int) => x + y
  val f3 = (x:Int,y:Int,z:Int) => x + y + z
  println(f1)
  println(f2)
  println(f3)
}

object MethodAndFunctionDemo3  {
  def main(args: Array[String]): Unit = {
    //定义了一个函数,参数是2个Int,返回值是
    val f1 = (x:Int,y:Int) => x + y
    //或者这样定义:
    //函数名称:(参数类型) =>函数返回值类型=(参数引用)=>函数体
    //val f1:(Int,Int)=>Int=(x,y)=>x+y
    val f2 = (x:Int,y:Int) => x * y

    //调用方法,并把函数作为参数传递给方法
    val r1 = m1(f1)
    val r2 = m1(f2)

    println(r1)//8
    println(r2)//12
  }

  //定义了一个方法,参数是函数类型,方法的返回值是Int,而函数的参数是2个Int,返回值是Int
  def m1 (f:(Int,Int)=>Int):Int={
    //方法体中调用了函数,并传递了2个参数给函数,
    //并把函数的返回值,当作方法的返回值给方法的调用者返回
    f(2,6)
  }
}

def main(args: Array[String]): Unit = {
  val f1 = m1 _
  println(f1)
}

def m1 (f:(Int,Int)=>Int):Int={
  f(2,6)
}

object FunctionDemo {
  def main(args: Array[String]): Unit = {
    //定义函数方式1:
    //函数名称=(参数名称:类型)=>函数体
    val f1 = (x:Int,y:Int) => x + y
    //定义函数方式2:(了解)
    //函数名称:(参数类型)=>返回值类型 = (参数列表)=>函数体
    val f2:(Int,Int)=>Int=(x,y)=>x - y

    val r1 = m1(f1);
    println(r1)//4

    val r2 = m1(f2);
    println(r2)//2

    val r3 = m1((x:Int,y:Int)=>x*y)
    println(r3)//3

  }

  //定义一个方法,方法的参数接收一个函数
  def m1(f:(Int,Int)=>Int): Int ={
    f(3,1)
  }
}

object LazyDemo {
  def main(args: Array[String]): Unit = {
    //使用lazy修饰变量,只有当这个变量被使用到的时候,变量的赋值代码才会真正的执行
    lazy val msg = init()
    println("init方法调用了,但是没有执行")
    println(msg)
  }
  def init(): String = {
    println("init方法执行")
    "嘿嘿嘿，我来了~"
  }
}

object ExceptionDemo {
  def main(args: Array[String]): Unit = {
    try {
      println(divider(10, 0))
    } catch {
      case ex: Exception => println("捕获了异常：" + ex)
    } finally {
      println("释放资源")
    }
  }

  def divider(x: Int, y: Int): Float = {
    if (y == 0) throw new Exception("0作为了除数")
    else x / y
  }
}