scala基础语法

落日映苍穹つ 2022-10-18 12:52 232阅读 0赞

## 1.变量 ##

scala中变量有两种类型：可变型和不可变型。  
可变型：变量的值可以在声明后进行修改；  
不可变型：变量的值在声明后无法被修改。  
scala中使用var或val关键字声明变量。其中var用于声明可变类型的变量；val用于声明不可变类型的变量。声明变量时具体语法下：

//声明时指定类型
    var a : Int = 2
    val b: String = "333"
    
    //声明时不指定类型
    var c = 123
    val d = "no Type"

我们可以在声明时，在变量名后通过:指定参数类型，也可以不指定。对于val声明的变量，如果你后面进行修改，编译器会提示错误。  
scala中的对象字段可以是可变型也可以是不可变型的，但是不能既是可变型又是不可变型。方法的参数通常是不可变型的，无论你使用什么关键字修饰。  
一般来说，对于可变型的变量，系重新赋值后，系统不会重新创建对象。  
scala提供一种特别的声明变量关键字`lazy val`,他的后面一般跟一个表达式，主要特征是其绑定的表达式不会立即被计算，直到第一次被访问时才计算，并将结果绑定到该标识符上，下一次被访问时直接返回。

## 2.数据类型 ##

scala是一种jvm语言，因此他与java有共同的一些数据类型，包括精度。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>Byte</td> 
   <td>8位带符号值，范围为 -128~127</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>Short</td> 
   <td>16位带符号值，范围为-32768~32767</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>Int</td> 
   <td>32位带符号值，范围为-2147483648~2147483647</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>Long</td> 
   <td>64位带符号值范围为： -922337203685477580~9223372036854775807</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>Float</td> 
   <td>32位单精度浮点数</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>Double</td> 
   <td>64位双精度浮点值</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>Char</td> 
   <td>16位无符号Unicode字符</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>String</td> 
   <td>字符序列</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>Boolean</td> 
   <td>true/false</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>Unit</td> 
   <td>相当于无值</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>Null</td> 
   <td>Null或空引用</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td>Nothing</td> 
   <td>每个包含无值的其他类型子类型</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td>Any</td> 
   <td>any类型any对象的子类型</td> 
  </tr> 
  <tr> 
   <td>1 4</td> 
   <td>AnyRef</td> 
   <td>any参考类型的子类型</td> 
  </tr> 
 </tbody> 
</table>

scala中的对象没有原生类型，具体的类型就为相当于java的包装类。scala中的类型一般是由给变量所赋的值推断出来的，所以我们一般需要在初始化时候就对其赋值。但是scala没有给具体的类型的默认初始化值。

## 3.导入语句 ##

scala引用包的关键字为import，跟java相比更加灵活。比如我们在java中需要导入Math下的sin和cos两个类，java中的写法是：

import java.lang.Math.sin;
    import java.lang.Math.cos;

scala允许使用\{\}来表明导入的对象集合来自同一个父包，于是上面的导入可以变成：`import java.lang.Math.{sin,cos}`。  
如果需要导入math下的所有对象，可以使用\_通配符即：`import math._`；  
如果想排除某些对象，可以使用`import math.{cos=>,_}`,表示排除cos对象；  
有时，我们会遇到导入两个不同包的相同对象的问题，java中的处理是在对象上赘述上对象的具体来源包，scla中提供重命名对象的方式，比如我们需要将cos重命名为MyCos，写法为：`import math.{cos=>MyCos}`

## 4.方法 ##

scala中方法定义的语法结构为：

def functionName ([list of params]) : [return type] = { 
         function body
         value_to_return
    }

其中方法参数可以为多个也可以为一个或者没有，多个使用，隔开；返回的类型可以也可以不定义；不定义时Scala编译器会推断出其返回类型。方法体中的return关键字也可不定义，如果不定义会默认返回最后一次的赋值结果。

/**
        * main方法
        * @param args
        */
      def main(args: Array[String]): Unit = { 
        var a : Int = 2
        println(a)
        multipleParams(3, 4)
    
      }
    
      /**
        * 多个参数
        * @param a 参数1
        * @param b 参数2
        * @return
        */
      def multipleParams(a : Int , b: Int) : Int = { 
        if ( a > b) a else b
      }
    
      /**
        * 没有定义返回类型
        * @param a
        * @return
        */
      def noReturn(a : String) = "hello" + a

## 5. 类 ##

scala中的类与java中一致，都是使用class关键字声明，他可以包含方法、值、变量、类型、对象、特质、类。其可以被实例化。其在类后可以定义全局的参数传递。

class App { 
      //成员变量
      var sum = 0
      
      /**
        * 多个参数
        * @param a 参数1
        * @param b 参数2
        * @return
        */
      def multipleParams(a : Int , b: Int) : Int = { 
        if ( a > b) a else b
      }
    
      /**
        * 内部类
        */
      class innerClass{ 
        val c = 1
    
        def main(args: Array[String]): Unit = { 
          println(c)
        }
      }
    }

在scala中，类是可以扩展的，其他类可以使用extends关键字，通过继承父类的所有成员并额外定义自己的成员（对于final修饰的，其子类不可以重载）。  
如父类如下：

class App (x : Int, y : Int){ 
      //成员变量
      var sum = x + y
      final val name = "app"
    
      /**
        * 多个参数
        * @param x 参数1
        * @param y 参数2
        * @return
        */
      def create(x : Int , y: Int) : App = { 
        println(name)
        new App(x, y)
      }
    
    }

子类代码：

class AppChildren (a : Int, b : Int, c : String) extends App (a, b){ 
    
      val name1 : String = "AppChildren"
      //重新定义父类中的非final类型参数
      override val sum = a - b
    
      /**
        * 重载父类的方法需要使用override关键字
        * @param x 参数1
        * @param y 参数2
        * @return
        */
      override def create(x : Int , y: Int) : AppChildren = { 
        println(name)
        new AppChildren(x, y, name)
      }
    
    }

这里需要注意的是，重载父类的参数或者方法需要使用override关键字修饰。对于final修饰的不能进行重载。

## 6.对象 ##

scala使用object关键字声明对象，这个对象与java中不同的是，其不能被实例化（即不能像java一样使用new创建其实例）。创建时，前面使用object声明，其中可以定义变量，方法以及类。scala的main方法不是在类的内部，而是在对象中。  
比如我们需要在对象中调用创建的App类，则需要使用

object HelloApp { 
    
      def main(args: Array[String]): Unit = { 
         val app: App = new App
         app.sum = 2
         println(app.sum)
      }
    }

## 7.特质 ##

特质是scala中的一个新概念，他们看起来像是抽象类，只是没有构造器，声明一个特质需要使用trait关键字，后面跟着特质名称和代码体。如果需要扩展特质，可以使用extends关键字。特质不能被实例化。

trait Animal { 
      val age : Int
      val name : String
    }

## 8.抽象类 ##

scala的抽象类与java中一致，使用abstract关键字修饰，可以定义抽象和非抽象方法，他可以与java中互操作。

## 9.构造器 ##

scala提供两种不同类型的构造器，主构造器和辅助构造器。主构造器就是类本身，并且其参数列表就在类名之后。辅助构造器位于代码体的第一行，必须调用一个之前已经定义好的辅助构造器或主构造器。

class Animal (name : String, age : Int){ 
    
       def getName() : String = { 
          name
       }
      
      def getAge() : Int = { 
          age
      }
      
    }

使用该构造器时，通过`val animal = new Animal("dag", 1)`;

class Animal (name : String, age : Int){ 
      
      //调用了自身的主构造器方法
      def this(name : String) = this(name, 0) 
    
       def getName() : String = { 
          name
       }
    
      def getAge() : Int = { 
          age
      }
    
    }

## 10. 访问修饰符 ##

<table> 
 <thead> 
  <tr> 
   <th>修饰符</th> 
   <th>类</th> 
   <th>伴生对象</th> 
   <th>包</th> 
   <th>子类</th> 
   <th>项目</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>默认/无修饰符</td> 
   <td>是</td> 
   <td>是</td> 
   <td>是</td> 
   <td>是</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>protected</td> 
   <td>是</td> 
   <td>是</td> 
   <td>是</td> 
   <td>否</td> 
   <td>否</td> 
  </tr> 
  <tr> 
   <td>private</td> 
   <td>是</td> 
   <td>是</td> 
   <td>否</td> 
   <td>否</td> 
   <td>否</td> 
  </tr> 
 </tbody> 
</table>

这里主要是私有成员和受保护的成员。私有成员只能在包含该成员定义的类或者对象内部才可见。对于受保护的成员只能在定义该类的子类中才可以访问。

package HelloApp { 
    
      class SuperClass { 
        
        
        private def printName: Unit = { 
          println("name is yang")
        }
        
        protected def printAge = { 
          println("age is 2")
        }
      }
      
      class Children extends SuperClass{ 
        //子类可以调用未修饰或protected的成员
        printAge
        
      }
      
      class SubClass { 
        val a = new SubClass
        //通过创建实例调用报错
        //a.printName
        //a.printAge
      }
    
    }

scala的访问修饰符可以使用限定符进行修饰，格式为private\[x\]或protected\[x\]表示访问在X内部是私有或者受保护的，X可以未封闭包、类或者单例对象。

package HelloApp { 
    
      class SuperClass { 
    
    
        private[SuperClass] def printName: Unit = { 
          println("name is yang")
        }
    
        protected[this] def printAge = { 
          println("age is 2")
        }
    
        def getInfo(obj: SuperClass): Unit = { 
          obj.printName
          obj.printAge //报错
        }
      }
    
    }

## 11.异常处理 ##

scala中异常处理同样采用try,catch和finally来处理。与java中区别主要是catch中支持case去进行不同的处理。具体示例如下：

try { 
       //需要进行异常处理的代码块
     }catch { 
       case null: NullPointerException => handleNullEceptioion(null)
       case outIndex: IndexOutOfBoundsException => handleIndexOutOfBoundException(outIndex)
       //_为占位符，不表示特殊意义
       case _: Throwable => println("expection:")
     }finally { 
       
     }