Scala学习(一)——基础语法

Scala语言是一种面向对象语言,结合了命令式(imperative)和函数式(functional)编程风格,其设计理念是创造一种更好地支持组件的语言。

 

特性

  • 多范式(Multi-Paradigm)编程语言,类似Java、C#;

  • 继承面向对象编程和函数式编程的特性;

    • 面向对象:[1]. 子类继承,[2]. 混入(Mixin)机制;

    • 函数式:支持高阶函数、嵌套函数,模式匹配,支持柯里化(Currying);

    • 类型推断(Type Inference):根据函数体中的具体内容推断方法的返回值类型

  • 更高层的并发模型,可伸缩;

  • 静态类型,编译时检查;

  • 允许与Java互操作(将来会支持与.Net互操作);

与Java对比

  • 如果用作服务器端开发,Scala的简洁、灵活性是Java无法比拟的;

  • 如果是企业级应用开发、Web开发,Java的强大是Scala无法匹敌的;

 

基础语法

表达式(Expressions)

表达式是可计算的语句。您可以使用println输出表达式的结果。

println(1) // 1
println(1 + 1) // 2
println("Hello!") // Hello!
println("Hello," + " world!") // Hello, world!

 

值(Values)

您可以使用val关键字命名表达式的结果。

val x = 1 + 1
println(x) // 2

命名结果(例如x)称为值。引用值不会重新计算它。值无法被重新分配。

val x = 1 + 1
x = 3 // This does not compile.

可以推断出值的类型,但您也可以显式声明类型,如下所示:

val x: Int = 1 + 1

注意类型声明Int如何在标识符x之后出现,你还需要一个“:”

 

变量(Variables)

变量就像值,除了你可以重新赋值。您可以使用var关键字定义变量。

var x = 1 + 1
x = 3 // This compiles because "x" is declared with the "var" keyword.
println(x * x) // 9

与值一样,您可以根据需要明确说明类型:

var x: Int = 1 + 1

 

块(Blocks)

您可以通过用{}包围表达式来组合表达式。我们称之为块。块中最后一个表达式的结果也是整个块的结果。

println({
  val x = 1 + 1
  x + 1
}) // 3

 

函数(Functions)

函数是带参数的表达式。

您可以定义一个返回给定整数加一的匿名函数(即无名称):

(x: Int) => x + 1

在=>的左边是参数列表。右边是涉及参数的表达式。

您也可以命名函数。

val addOne = (x: Int) => x + 1
println(addOne(1)) // 2

函数可能需要多个参数。

val add = (x: Int, y: Int) => x + y
println(add(1, 2)) // 3

或者它不需要参数。

val getTheAnswer = () => 42
println(getTheAnswer()) // 42

 

方法(Methods)

方法的外观和行为与函数非常相似,但它们之间存在一些关键差异。

方法使用def关键字定义。 def后跟名称,参数列表,返回类型和正文。

def add(x: Int, y: Int): Int = x + y
println(add(1, 2)) // 3

注意如何在参数列表和冒号之后声明返回类型:Int。

方法可以采用多个参数列表。

def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
println(addThenMultiply(1, 2)(3)) // 9

或者根本没有参数列表。

def name: String = System.getProperty("user.name")
println("Hello, " + name + "!")

还有一些其他差异,但就目前而言,您可以将它们视为与函数类似的东西。

方法也可以有多行表达式。

def getSquareString(input: Double): String = {
  val square = input * input
  square.toString
}

正文中的最后一个表达式是方法的返回值。 (Scala确实有一个return关键字,但它很少使用。)

关于方法(Method)和函数(Function)

  • 函数是一等公民,使用val语句可以定义函数,def语句定义方法;

  • 函数是一个对象,继承自FuctionN,函数对象有curried,equals,isInstanceOf,toString等方法,而方法不具有;

  • 函数是一个值,可以给val变量赋值,方法不是值、也不可以给val变量赋值;

  • 通过将方法转化为函数的方式 method _ 或 method(_) 实现给val变量赋值;

  • 若 method 有重载的情况,方法转化为函数时必须指定参数和返回值的类型;

  • 某些情况下,编译器可以根据上下文自动将方法转换为函数;

  • 无参数的方法 method 没有参数列表(调用:method),无参数的函数 function 有空列表(调用:function());

  • 方法可以使用参数序列,转换为函数后,必须用 Seq 包装参数序列;

  • 方法支持默认参数,函数不支持、会忽略之;

 

类(Classes)

您可以使用class关键字定义类,后跟其名称和构造函数参数。

class Greeter(prefix: String, suffix: String) {
  def greet(name: String): Unit =
    println(prefix + name + suffix)
}

方法greet的返回类型是Unit,它表示返回没有任何意义。它与Java和C中的void类似地使用。(不同之处在于,因为每个Scala表达式必须具有某个值,实际上存在Unit类型的单例值,write()。它不携带任何信息。)

您可以使用new关键字创建类的实例。

val greeter = new Greeter("Hello, ", "!")
greeter.greet("Scala developer") // Hello, Scala developer!

 

样本类(Case Classes)

Scala有一种特殊类型的类,称为样本类。默认情况下,样本类是不可变的,并按值进行比较。您可以使用“case class”关键字定义案例类。

case class Point(x: Int, y: Int)

您可以在没有new关键字的情况下实例化样本类。

val point = Point(1, 2)
val anotherPoint = Point(1, 2)
val yetAnotherPoint = Point(2, 2)

并且它们按值进行比较。

if (point == anotherPoint) {
  println(point + " and " + anotherPoint + " are the same.")
} else {
  println(point + " and " + anotherPoint + " are different.")
}
// Point(1,2) and Point(1,2) are the same.
if (point == yetAnotherPoint) {
  println(point + " and " + yetAnotherPoint + " are the same.")
} else {
  println(point + " and " + yetAnotherPoint + " are different.")
}
// Point(1,2) and Point(2,2) are different.

 

对象(Objects)

对象是它们自己定义的单个实例。你可以把它们想象成自己班级的单身人士。

您可以使用object关键字定义对象。

object IdFactory {
  private var counter = 0
  def create(): Int = {
    counter += 1
    counter
  }
}

您可以通过引用其名称来访问该对象。

val newId: Int = IdFactory.create()
println(newId) // 1
val newerId: Int = IdFactory.create()
println(newerId) // 2

 

抽象类

你可以定义一个抽象类,它定义了一些方法但没有实现它们。取而代之是由扩展抽象类的子类定义这些方法。你不能创建抽象类的实例。

abstract class Shape {      
  def getArea():Int    // subclass should define this      
} 
class Circle(r: Int) extends Shape {      
  def getArea():Int = { r * r * 3 }      
} 
val s = new Shape //error: class Shape is abstract; cannot be instantiated                     
val c = new Circle(2)

 

特质(Traits)

特质是包含某些字段和方法的类型。可以组合多种特质。
您可以使用trait关键字定义特质。

trait Greeter {
  def greet(name: String): Unit
}

特质也可以有默认实现。

trait Greeter {
  def greet(name: String): Unit =
    println("Hello, " + name + "!")
}

您可以使用extends关键字扩展traits并使用override关键字覆盖实现。

class DefaultGreeter extends Greeter
class CustomizableGreeter(prefix: String, postfix: String) extends Greeter {
  override def greet(name: String): Unit = {
    println(prefix + name + postfix)
  }
}
val greeter = new DefaultGreeter()
greeter.greet("Scala developer") // Hello, Scala developer!
val customGreeter = new CustomizableGreeter("How are you, ", "?")
customGreeter.greet("Scala developer") // How are you, Scala developer?

在这里,DefaultGreeter只扩展了一个特质,但它可以扩展多个特质。

什么时候应该使用特质而不是抽象类?

如果你想定义一个类似接口的类型,你可能会在特质和抽象类之间难以取舍。这两种形式都可以让你定义一个类型的一些行为,并要求继承者定义一些其他行为。一些经验法则:

  • 优先使用特质。一个类扩展多个特质是很方便的,但却只能扩展一个抽象类。

  • 如果你需要构造函数参数,使用抽象类。因为抽象类可以定义带参数的构造函数,而特质不行。例如,你不能说trait t(i: Int) {},参数i是非法的。

 

Main方法

Main方法是程序的切入点。 Java虚拟机需要将main方法命名为main,并使用一个参数,即一个字符串数组。
使用对象,您可以按如下方式定义main方法:

object Main {
  def main(args: Array[String]): Unit =
    println("Hello, Scala developer!")
}

 

本文主要翻译自Basics|Scala Documentation

posted @ 2018-07-24 21:22  FlyingWarrior  阅读(188)  评论(0编辑  收藏  举报