scala初识(一)

Scala基础语法

• 当编写Scala程序时,它可以被定义为通过调用彼此的方法进行通信的对象的集合.
  • 对象-对象有状态和行为.一个对象是类的实例.例如-狗有状态:颜色,名称,品种;行为:摇摆,吃东西等
  • 类-可以将类定义为描述与该类相关的行为/状态的模板/蓝图
  • 方法-一个方法基本上是一种行为.一个类可以包含很多方法.将逻辑代码写入方法中,数据在方法中操纵并且执行所有的动作
  • 字段-每个对象都有其唯一的一组实例变量,成为字段.对象的状态是由分配给这些字段的值来创建的
  • 闭包-闭包是一个函数,其返回值取决于在此函数之外声明的一个或多个变量的值
  • 特征-特征封装了方法和字段定义,然后可以通过将他们混合到类中来重用他们,特征用于通过指定支持的方法的签名来定义对象类型

基础语法

• 以下是Scala编程中的基本语法和编码约定
  • 区分大小写-Scala是区分大小写的,比如标识符Hello和hello在Scala中标识不同的含义(对象)
  • 类名称-对于所有类名,第一个字母应为大写.如果使用多个单词来形成类的名称,则每个内部单词的第一个字母应该是大写
  • 方法名称-所有的方法名称应以小写字母开头.如果使用多个单词形成方法的名称,则每个内部单词的第一个字母应该是大写
  • 程序文件名-程序文件的名称应与对象名称完全匹配.保存文件时,你应该使用对象名称保存它.并将.scala附加到文件名称的末尾
  • def main(args: Array[String])-Scala程序从main()方法开始,这个每个Scala程序的强制性部分

Scala标识符

• 所有的Scala组件都需要名称.用于对象,类,变量和方法的名称称为标识符.关键字不能用作标识符,标识符区分大小写
• 字母数字标识符
  • 以字母或下划线开头,后面可以有更多的字母,数字或下划线.注:$字符是Scala中的保留关键字,不应在标识符中使用
• 运算符标识符
  • 由一个或多个运算符字符组成,运算符字符是可打印的ASCII字符.如:+,:,?,~或#
  • Scala编译器将在内部将标识符转换成具有嵌入式$字符的合法Java标识符
• 混合标识符
  • 由字母数字标识符组成,后面跟着一个下划线和一个操作符标识符
• 字面标识符
  • 一个文字标识符是一个随意的字符串,包含在后面的勾号(…)中

Scala变量

• 变量是保存存储值的内存位置的名称.这意味着当创建变量时,可以在内存中保留一些空间
• 根据变量的数据类型,编译器分噢诶内存并决定可以存储在预留内存中的内容.因此,通过为变量分配不同的数据类型,可以在这些变量中存储整数,小数或字符

变量声明

• Scala具有用于声明变量的不同语法.他们可以被定义为值,即常量或变量
  • 使用关键字var声明的变量是一个可以改变值的变量,称为可变变量
  • 使用关键字val声明的变量是一个不能被改变的变量,称为不可变变量

可变数据类型

• 变量的类型在变量名称和等号之前指定.可以通过其数据类型来定义任何类型的Scala变量

val or val VariableName : DataType = [Initial Value]

• 如果你没有为变量分配任何初始值,则有效的语法如下

var myVar : Int;
val myVal : String;

可变类型推断

• 当为变量分配初始值时,Scala编译器可以根据分配给它的值来推断变量的类型.这被称为变量类型推断,因此,可以编写这样的变量声明

var myVar = 10;
val myVal = "Hello"

• 默认情况下,myVar将会被计算推断为Int类型,myVal将计算推断为String类型变量

多个赋值

• Scala支持多个赋值,如果代码块或方法返回一个元组(Tuple - 保持不同类型的对象的集合),则可以将元组分配给一个val变量

变量的作用域

• Scala中的变量可以有三个不同的范围,具体取决于他们被使用的位置.他们可以作为字段存在,作为方法参数和局部变量存在
• 字段 - 字段属于对象的变量.这些字段可以从对象中的每个方法的内部访问,根据字段声明的访问修饰符,也可以在对象外部访问字段,对象字段可以是可变和不可变类型,可以使用var或者val来定义
• 方法参数 - 方法参数是在调用该方法时用于传递方法中的值的变量,方法参数只能从方法内部访问,但是如果从方法外部引用了对象,则可以在外部访问传入的对象,方法参数始终是不可变的,由val定义
• 局部变量 - 局部变量是在方法中声明的变量,局部变量只能从方法内部访问,但如果从方法返回,则你创建的对象可能会转义该方法,局部变量可以是可变和不可变的类型,可以使用var或者val定义

Scala类和对象

• 类是对象的模板,定义一个类后,可以使用关键字new来创建一个类的对象.通过对象可使用定义的类的所有功能

类基础

import java.io._

class Point(xc:Int, val yc:Int) {
  var x: Int = xc
  var y: Int = yc
  def move(dx:Int, dy:Int) {
    x = x + dx
    y = y + dy
    println("Point x location : " + x);
    println("Point y location : " + y);
  }
}

object Demo {
  def main(args: Array[String]) {
    val pt = new Point(10, 20);
    // Move to a new location
    pt.move(10, 10);
  }
}

• 如上所述,Point类定义了两个变量x和y以及一个move方法,它没有返回值
• 使用类的名称作为一个雷构造函数,构函数可以使用多个参数
• 我们在其他类中可以使用关键字new来创建对象,然后访问类的字段和方法

扩展类

• 在Scala中,我们可以扩展一个Scala类,使用与Java中相同的方法设计继承的类(使用extends关键字).但有两个限制
  • 方法重写需要override关键字
  • 只有主构造函数可以通过参数调用基类构造函数

import java.io._

class Point(xc:Int, val yc:Int) {
  var x: Int = xc
  var y: Int = yc
  def move(dx:Int, dy:Int) {
    x = x + dx
    y = y + dy
    println("Point x location : " + x);
    println("Point y location : " + y);
  }
}

class Location(override val xc: Int, override val yc: Int, val zc: Int) extends Point {
  var z: Int = zc
  def move(dx: Int, dy: Int, dz: Int) {
    x = x + dx
    y = y + dy
    z = z + dz
    println("Point x location : " + x);
    println("Point y location : " + y);
    println("Point z location : " + z);
  }
}

object Demo {
  def main(args: Array[String]) {
    val pt = new Location(10, 20, 15);
    // Move to a new location
    pt.move(10, 10, 5);
  }
}

• Location类是一个使用extends关键字创建的继承类.这样的扩展子句有两个效果
  • 使Location类从Point类继承所有非私有成员
  • 使类型Location称为Point类类型的子类型
• 在Point类中的move方法和Location类中的move方法不会覆盖move的相关定义,因为他们是不同的定义

隐性类

• 当类在范围内时,隐式类允许与类的主构造函数进行隐式对话.隐式类是一个标有implicit关键字的类

// 语法 - 以下是隐式类的语法.这里,隐式类始终位于对象范围内,所有的方法定义都被允许,因为隐式类不能是顶级类
object <object name> {
  implicit class <Class name>(<Variable>: Data type) {
    def <method>(): Unit = 
  }
}

• 下面演示如何使用隐式类,创建一个名称为IntTimes的隐式类,并定义一个times()方法.time()包含一个循环事务,它将按给定的次数执行语句
• Run.scala

object Run {
  implicit class IntTimes(x: Int) {
    def times [A](f: =>A): Unit = {
      def loop(current: Int): Unit = 
      if(current > 0) {
        f
        loop(current - 1)
      }
      loop(x)
    }
  }
}

• Demo.scala

import Rnu._

object Demo {
  def main(args: Array[String]) {
    4 times println("hello")
  }
}

• 注意
  • 隐式类必须在另一个类/对象/特征中定义(不再顶层)
  • 隐式类在其构造函数中只能使用一个非默认参数
  • 隐式类作用域中不可以具有与隐式类相同名称的任何方法,成员或对象

单例对象

• Scala比Java更面向对象,因为在Scala中不能拥有静态成员,Scala它使用单例对象.单例是一种只能有一个实例的对象,使用Object关键字对象而不是类关键字创建单例.由于无法实例化单例对象,因此无法将数据传递给主构造函数

import java.io._

class Point(val xc:Int, val yc: Int) {
  var x: Int = xc
  var y: Int = yc
  def move(dx: Int, dy: Int) {
    x = x + dx
    y = y + dy
  }
}

object Demo {
  def main(args: Array[String]) {
    val point = new Point(10, 20)
    printPoint
    
    def printPoint {
      println("Point x location : " + point.x)
      println("Point y location : " + point.y)
    }
  }
}