scala基本语法（一）

Scala基本语法（一）

1.符号字面量：‘x是表达式scala.symbol(“x”)的缩写
2.低精度向高精度不需要类型转换

val a:Byte=10;
val b:Long=a;

3.新增字符串插值：

val name="mys";
s"my name is ${name}";

4.变量（占位符）用于引用计算机内存地址，变量创建后会占用一定的内存空间。
基于变量的数据类型，操作系统会进行内存分配并且决定什么将被储存在保留内存中。
5.private仅在包含了成员定义的类或对象内部可见

一些知识点和代码实例

package scala

object func_examples {
  def main(args: Array[String]): Unit ={
    println(hello2("mys"))
  }

  /**
    * 定义函数
    * def 函数名(参数名:参数类型):返回值类型={ }
    * 返回值类型可以省略
    */
  def hello(name:String):String={
    s"hello,${name}"//字符串插值
  }

  def hello2(name:String)={
    s"hello2,${name}"
  }


  /**
    * if与for的使用
    */
  val l=List("alice","bob","mys")//赋初值
  for(
    s<-l//将l循环遍历给s  generator
  )println(s)//打印s

  for(
    s<-l
    if(s.length>3) //filter
  )println(s);

  val result_for = for {
    s <- l
    s1 = s.toUpperCase()//小写转大写
    if (s1 != "")
  }println("s1:"+s1)

  /**
    * try catch finally使用
    */
  val result_try=try{
    Integer.parseInt("dog")
  }catch{
    case _:Throwable=>0 //catch到异常，返回0
  }finally {
    println("always be printed")//不管怎样都会被调用
  }
  println("result_try:"+result_try)//打印返回结果


  /**
    * match使用
    */
  val code=3//先定义一个值code
  val result_match=code match{//匹配值code
    case 1=>"one"//如果code=1,返回one
    case 2=>"two"//如果code=2,返回two
    case _=>"others"//如果code为其他值,返回others
  }
  println("result_match:"+result_match)//打印返回值


  /**
    * 求值策略;
    * call by value:对函数实参求值，且仅求一次（常用）
    * call by name:函数实参每次在函数体内被用到时都会被求值（函数形参类型以=>开头）
    */
  def foo1(x:Int)=x //call by value
  def foo2(x: =>Int)=x //call by name 注：x:+空格+=>,空格不要省略

  def bar(x:Int,y: =>Int):Int=1
  def loop():Int=loop//递归函数，没有出口，死循环

  bar(1,loop)//res0: Int=1
  //bar(loop,1)//陷入死循环，无法计算出值


  /**
    * private仅在包含了成员定义的类或对象内部可见
    */
  class Outer{
    class Inner{
      private def f(): Unit ={
        println("f")
      }
      class InnerTest{
        f();//正确
      }
    }
    //(new Inner()).f();//错误，在成员定义的类外部
  }

  /**
    * 在 scala 中，对保护（Protected）成员的访问比 java 更严格一些。
    * 因为它只允许保护成员在定义了 ** 该成员的的类的子类中被访问。**
    * 而在java中，用protected关键字修饰的成员，除了定义了该成员的类的子类可以访问，
    * 同一个包里的其他类也可以进行访问。
    */
  class Super{
    protected def fun(): Unit ={
      println("fun")
    }
 }
 class Sub extends Super{
   fun()//正确
 }
 class Sub2{
   fun()//错误，在java中同一个包中正确
 }

  /**
    * scala可指定函数参数名，并不需要按照顺序传递参数
    */
  def printInt(a:Int,b:Int): Unit ={//指定函数参数名
    println("a:"+a)
    println("b"+b)
  }
  printInt(b=10,a=7)//不需要按照顺序传递参数


  /**
    * scala可向函数传递可变长度参数列表，在参数类型后加一个*
    * 循环打印字符串
    */
  def printString(args:String*): Unit ={
    var i:Int=0//定义一个整型变量i
    for(arg<-args){//循环遍历 将args赋值给arg
      println("srg["+i+"]:"+arg)//打印arg
      i=i+1
    }
  }
  printString("java","scala","python")


  /**
    * scala递归函数
    * 求阶乘
    */
  //def 函数名（参数名：参数类型）：返回值类型={ }
  def factorial(n:BigInt):BigInt={
    if(n<=1)
      1
    else
      n*factorial(n-1)
  }
  for(i<-1 to 10){//i从1到10
    println(i+"的阶乘："+factorial(i))
  }

  /**
    * 函数式编程
    * 函数与变量同等地位，可以不依赖于类、接口或object，单独存在，并可赋值给变量
    */

  /**
    * 函数是第一等公民
    * 1.把函数作为实参传递给另一个函数
    * 2.把函数作为返回值
    * 3.把函数赋值给变量
    * 4.把函数存储在数据结构里
    */


  /**
    * 把函数赋值给变量
    * 格式：val 变量名=函数名+空格+_
    */
  //定义一个函数
  def fun1(name:String): Unit ={
    println(name)
  }
  val fun_v=fun1 _//格式：val 变量名=函数名+空格+_

  fun1("spark")//直接调用函数
  println(fun_v("fun_v spark"))//输出变量，通过变量调用函数

  /**
    * 把函数作为返回值
    * 匿名函数
    * spark中常使用匿名函数（不给函数命名），然后将其赋值给一个变量
    * 格式：val 变量名=（参数名：参数类型）=> 函数体
    * 注：=>作用：对左边的参数进行右边的进行加工
    */
  val fun2_v = (name:String) => println(name)//fun2_v返回值：(name:String) => println(name) 类型：String;得到函数fun2_v
  fun2_v("fun2_v mys")

  /**
    * 函数类型
    * 格式：A => B
    * 表示接受类型A的参数，并返回类型B的函数
    * eg. Int => String 把整型映射为字符串的函数类型
    */

  /**
    * 高阶函数：用函数作为形参或返回值的函数
    */

  /**
    * @param name
    * @return
    * 高阶函数：函数作为返回值
    * 匿名函数：(message:String)=>println("匿名函数内容："+message)
    * 首先定义一个返回值是函数【匿名函数 】的函数：func_Returned
    * 然后将其返回值（匿名函数）赋值给变量returned，这样就得到了函数returned
    * returned函数与匿名函数直接关联
    * 因此returned(" scala") 相当于将参数传给匿名函数
    */
  def func_Returned(name:String)=(message:String)=>println("匿名函数内容："+message)  //func_Returned: (name: String)String => Unit
  val returned=func_Returned("spark")
  returned(" scala")


  /**
    * 高阶函数：函数作为形参和返回值
    * @param f 函数
    * @return  f(4,4)
    */
  def operate(f:(Int,Int) => Int)={
    f(4,4)
  }

  /**
    * 高阶函数：函数作为返回值
    * @return
    */
  def greeting()=(name:String) => {
    "hello "+name
  }

  /**
    * 柯里化：把多个参数单个拿出来放到括号里，串接起来
    */
  def curriedAdd(a:Int)(b:Int)=a+b
  curriedAdd(2)(2) //4

  /**
    * 可实现对每个某个加1的需求
    */
  val addOne=curriedAdd(1)_//a=1 b的值任意
  addOne(2)//传入一个值，赋值给b
  println( addOne(2))//因此返回值a+b=3

  /**
    * 尾递归：所有递归形式的调用都出现在函数的末尾
    * 当编译器检测到一个函数调用是尾递归的时候，
    * 就覆盖当前的活动记录而不是创建一个新的，即只有一个堆栈
    * @param n
    * @param m
    * @return m
    */
  @annotation.tailrec//尾递归标志
  def factorial(n:Int,m:Int):Int= {
    if (n <= 0) m
    else factorial(n - 1, m * n)
  }

  factorial(5,1)

}


![运行结果](https://img-blog.csdn.net/20180909090637370?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L215c19teXM=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)

---