scala基础语法

最新推荐文章于 2024-02-22 12:35:32 发布

原创最新推荐文章于 2024-02-22 12:35:32 发布 · 948 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#scala #scala基础语法 #var和val #访问修饰符 #异常处理

scala 专栏收录该内容

5 篇文章

订阅专栏

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有共同的一些数据类型，包括精度。

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

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. 访问修饰符

修饰符	类	伴生对象	包	子类	项目
默认/无修饰符	是	是	是	是	是
protected	是	是	是	否	否
private	是	是	否	否	否

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

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