Scala语言基础-基础语法

注意点

• scala语言区分大小写
• 类名遵循大驼峰写法（AaaBbbCcc）
• 方法名遵循小驼峰写法（aaaBbbCcc）
• 类名与文件名一致
• 注释
  • 单行注释： // 单行注释
  • 多行注释：
    /*
    多行注释
    */
• 包定义：
  • package com.one
    class HelloScala{
    …
    }
  • package con.one{
    class HelloScala
    …
    }
• 导包:import java.awt.Color
• 选择导包：import java.awt.{Color,Font}
• 导包别名：import java.util.{HashMap => JavaHashMap}
• 隐藏导包：import java.util.{HashMap => _, _}
• 默认导包：java.lang._ 、 scala._ 和 Predef._

数据类型

数据类型	描述
Byte	8位有符号补码整数。数值区间为 -128 到 127
Short	16位有符号补码整数。数值区间为 -32768 到 32767
Int	32位有符号补码整数。数值区间为 -2147483648 到 2147483647
Long	64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807
Float	32位IEEE754单精度浮点数
Double	64位IEEE754单精度浮点数
Char	16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF
String	字符序列
Boolean	true或false
Unit	表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Null	null 或空引用
Nothing	Nothing类型在Scala的类层级的最低端；它是任何其他类型的子类型。
Any	Any是所有其他类的超类
AnyRef	AnyRef类是Scala里所有引用类(reference class)的基类

变量与常量

object HelloScala {
  def main(args: Array[String]): Unit = {
    // val声明的对象是常量，不可被修改
    val a = "不可被修改"

    // var声明的对象是变量，可以被修改
    var b = "可被修改"

    // scala会自定推断数据类型，如果需要指定，则：
    var c:String = "指定数据类型"
  }
}

• val修饰常量，var修饰变量，最好使用val声明对象
• scala会自动推断数据类型，如果需要手动指定可以在对象名后加：数据类型

权限修饰符

scala的权限修饰符与java一致，分为private、protected、缺省、public。具体用法也一样不再赘述。
需要说的是scala语言有一个作用保护域的概念：
作用域保护：Scala中，访问修饰符可以通过使用限定词强调。
private[x] 或者 protected[x]
private[x]：这个成员除了对[…]中的类或[…]中的包中的类及他们的伴生对象可见外，对其他的类都是private。

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
        }
    }
}

在这个例子中,类Navigator使用 private[bobsrockets] 来修饰,这表示这个类可以被bobsrockets包中所有类型访问,比如通常情况下 Vehicle无法访问私有类型Navigator,但使用包作用域之后,Vechile 中可以访问Navigator。

if-else if-else语句

scala的if语句有点特殊，因为他的if语句有返回值，类似于三目运算符。

object HelloScala {
    def main(args: Array[String]): Unit = {
        val x = 1
        val y = if(x > 0) x else -1
        println(y)

        // 也可以返回混合数据类型
        val z = if(x > 0) x else "hahaha":String
        println(z)

        // 如果不带else，就表示  else ()  scala中的()表示null或void
        val a = if(x < 0) x
        println(a)

        // 同样，也可以使用if-else if-else
        val b = if (x < 0) 0
                else if (x >= 1) 1
                else -1
        println(b)


        // 也可以使用语句块来表示
        val result = {
            if(x < 0)
                -1
            else if(x >= 1)
                1
            else
                "error"
        }
        println(result)
    }
}

总结：

1）if条件表达式它是有返回值的

2）返回值会根据条件表达式的情况会进行自动的数据类型的推断。

while语句

和Java的while语句用法一致。

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

注意点：scala不支持自增(++)自减(–)

for语句

object HelloScala {
    def main(args: Array[String]): Unit = {
        // 普通的for循环  for(变量 <- 可迭代对象(to表达式/数组/集合))
        for(i <- 1 to 10)
            // scala也可以使用这种类似Python的缩进分块写法
            println(i)

        // 高级for循环，可以带一个条件
        for(i <- 1 to 3; j <- 1 to 3 if i != j)
            println((10 * i + j) + " ")

        // for循环推导式，会生成一个集合对象
        val v = for (i <- 1 to 10) yield i * 10
        println(v)       
    }
}

总结：

1）在scala里面没有运算符，都有的符号其实都是方法。

2）在scala里面没有++ – 的用法

3）for( i <- 表达式/数组/集合)

4）在for循环里面我们是可以添加if表达式

5）有两个特殊表达式需要了解：

for(i <- 1 to 3)
	println(i)
    1
    2
    3

for(i <- 1 until 3)
	println(i)
    1
    2

6）如果在使用for循环的时候，for循环的时候我们需要获取，我们可以是使用yield关键字。

方法和函数

方法使用def关键字定义，拿main方法举例：

object HelloScala {
    def main(args: Array[String]): Unit = {
    	println("Hello Scala")
    }
    关键字  方法名(参数列表:参数类型):返回值类型={
		方法体
	}
	
	// 也可以简单的定义：
	def sum(a:Int,b:Int):Int = a + b
	//方法的返回值类型可以不写，编译器可以自动推断出来，但是对于递归函数，必须指定返回类型。
    //如果不写等号，代表没有返回值。
}

函数的定义就比较简单，scala的函数有浓郁的高阶函数味道。

object HelloScala {
    def main(args: Array[String]): Unit = {
    	val sum = (a:Int,b:Int) => a + b
    	// 函数主要就是看 => 这个符号，在scala语言中，符号实际上是内置函数
    	println(sum(1,2))
    }
}

对于scala这个函数式编程语言来说，函数式当之无愧的“一等公民”，它可以像任何其他数据类型一样被传递和操作。

object HelloScala {
    //定义一个方法
    //方法m1参数要求是一个函数，函数的参数必须是两个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)
    }
}

方法也可以转换成函数

object HelloScala {
    def m1(f:(Int,Int) => Int) : Int = {
        f(2,6)
    }
    val f1 = (x:Int,y:Int) => x+y

    //main方法
    def main(args: Array[String]): Unit = {
        // 将方法m1转换为函数m2 , 只需要通过符号_
        val m2 = m1_
        m2(f1)
    }
}