【Scala】（二）Scala 基本语法及操作、程序控制结构

object HelloSpark{
    def main(args:Array[String]):Unit = {
        println("Hello Spark!")
    }
}

/**
  * Scala基本语法:
  * 区分大小写
  * 类名首字母大写（MyFirstScalaClass）
  * 方法名称第一个字母小写（myMethodName()）
  * 程序文件名应该与对象名称完全匹配
  * def main(args:Array[String]):scala程序从main方法开始处理，程序的入口。
  *
  * Scala注释：分为多行/**/和单行//
  *
  * 换行符：Scala是面向行的语言，语句可以用分号（；）结束或换行符（println()）
  *
  * 定义包有两种方法：
  *   1、package com.ahu
  *      class HelloScala
  *   2、package com.ahu{
  *       class HelloScala
  *     }
  *
  * 引用：import java.awt.Color
  * 如果想要引入包中的几个成员，可以用selector（选取器）:
  *   import java.awt.{Color,Font}
  *   // 重命名成员
  *   import java.util.{HashMap => JavaHashMap}
  *   // 隐藏成员 默认情况下，Scala 总会引入 java.lang._ 、 scala._ 和 Predef._，所以在使用时都是省去scala.的
  *   import java.util.{HashMap => _, _} //引入了util包所有成员，但HashMap被隐藏了
  */

var str =
      """
        |第一行
        |第二行
        |第三行
      """.stripMargin
    println(str)

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

class Outer {
  class Inner{
    def start() = println("start")
    def end() = println("end")
    private def pause() = println("pause")
  }
  new Inner().start()
  new Inner().end()
  new Inner().pause() // 注意这里会报错
}

package p
{
    class Super
    {
        protected def f(){println("f")}
    }
    class Sub extends Super
    {
        f() //OK
    }
    class Other
    {
        (new Super).f() //Error:f不可访问
    }
}

package bobsrockets
{
    package navigation
    {
        //如果为private class Navigator,则类Navigator只会对当前包navigation中所有类型可见。
        //即private默认省略了[X],X为当前包或者当前类或者当前单例对象。
        //private[bobsrockets]则表示将类Navigator从当前包扩展到对bobsrockets包中的所有类型可见。
        private[bobsrockets] class Navigator
        {
            protected[navigation] def useStarChart() {}
            class LegOfJourney
            {
                private[Navigator] val distance = 100
            }
            private[this] var speed = 200
        }
    }
    package launch
    {
        import navigation._
        object Vehicle
        {
            //private val guide：表示guide默认被当前单例对象可见。
            //private[launch] val guide：表示guide由默认对当前单例对象可见扩展到对launch包中的所有类型可见。
            private[launch] val guide = new Navigator
        }
    }
}

def main(args: Array[String]): Unit = {
    val x = 1
    //判断x的值，将结果赋给y
    val y = if (x > 0) 1 else -1
    //打印y的值
    println("y=" + y)
    //支持混合类型表达式
    val z = if (x > 1) 1 else "error"
    //打印z的值
    println("z=" + z)
    //如果缺失else，相当于if (x > 2) 1 else ()
    val m = if (x > 2) 1
    println("m=" + m)
    //在scala中每个表达式都有值，scala中有个Unit类，写做(),相当于Java中的void
    val n = if (x > 2) 1 else ()
    println("n=" + n)
    //if和else if
    val k = if (x < 0) 0
    else if (x >= 1) 1 else -1
    println("k=" + k)
  }

def main(args: Array[String]): Unit = {
    val x = 0
    val result = {
      if(x < 0)
      else if(x >= 1)
        -1
      else
        "error"
    }
    println(result)
  }

def main(args: Array[String]): Unit = {
    var n = 10
    while ( {
      n > 0
    }) {
      println(n)
      n -= 1
    }
  }

def main(args: Array[String]): Unit = {
    //for(i <- 表达式),表达式1 to 10返回一个Range（区间）
    //每次循环将区间中的一个值赋给i
    for (i <- 1 to 10)
      print(i+"\t")
    //for(i <- 数组)
    println()
    val arr = Array("a", "b", "c")
    for (i <- arr)
      println(i)
    //高级for循环
    //每个生成器都可以带一个条件，注意：if前面没有分号
    for(i <- 1 to 3; j <- 1 to 3 if i != j)
      print((10 * i + j) + " ")
    println()
    //for推导式：如果for循环的循环体以yield开始，则该循环会构建出一个集合
    //每次迭代生成集合中的一个值
    val v = for (i <- 1 to 10) yield i * 10
    println(v)
  }

object TestScala {
  //定义一个方法
  //方法m2参数要求是一个函数，函数的参数必须是两个Int类型
  //返回值类型也是Int类型
  def m1(f:(Int,Int) => Int) : Int = {
    f(2,6)
  }
  //定义一个函数f1，参数是两个Int类型，返回值是一个Int类型
  val f1 = (x:Int,y:Int) => x+y
  //再定义一个函数f2
  val f2 = (m:Int,n:Int) => m*n
  //main方法
  def main(args: Array[String]): Unit = {
    //调用m1方法，并传入f1函数
    val r1 = m1(f1)
    println("r1="+r1)
    //调用m1方法，并传入f2函数
    val r2 = m1(f2)
    println("r2="+r2)
  }
}