从Java到Scala,Scala快速入门(1)

参考

https://www.runoob.com/scala/scala-tutorial.html

目标:对熟悉java语法的人,快速入门到scala

环境安装

  1. 安装jdk环境
  2. 安装scala : http://www.scala-lang.org/downloads

运行代码

运行方式和java一样,scalac编译,scala运行

object HelloWorld {

   def main(args: Array[String]) = {
      println("Hello, world!") // 输出 Hello World
   }
}

注意

Scala 基本语法需要注意以下几点:

  • 区分大小写 - Scala是大小写敏感的,这意味着标识Hello 和 hello在Scala中会有不同的含义。

  • 类名 - 对于所有的类名的第一个字母要大写。

  • 驼峰命名规则(类名,变量名等)

  • 保存文件时,应该保存它使用的对象名称(记住Scala是区分大小写),并追加".scala"为文件扩展名。 (如果文件名和对象名称不匹配,程序将无法编译)。
    示例: 假设"HelloWorld"是对象的名称。那么该文件应保存为’HelloWorld.scala"

  • def main(args: Array[String]) - Scala程序从main()方法开始处理,这是每一个Scala程序的强制程序入口部分。

变量

Scala 与 Java有着相同的数据类型,Scala是纯面向对面的,没有基本数据类型int,只有Int类,其他也一样,Int也是有方法调用的

  • Unit 表示无值,和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值,写成()。
  • Null null 或空引用
  • Nothing Nothing类型在Scala的类层级的最底端;它是任何其他类型的子类型。
  • Any Any是所有其他类的超类(类型Object)
  • AnyRef AnyRef类是Scala里所有引用类(reference class)的基类

String

在 Scala 中,字符串的类型实际上是 Java String,它的类型为 String (java.lang.String),它本身没有 String 类。

数组

定义

var z = Array("Runoob", "Baidu", "Google")
var z:Array[String] = new Array[String](3)

访问

z(0) = "Runoob"; z(1) = "Baidu"; z(4/2) = "Google"

遍历

var myList = Array(1.9, 2.9, 3.4, 3.5)
 // 输出所有数组元素
 for ( x <- myList ) {
    println( x )
 }

多维数组

val myMatrix = Array.ofDim[Int](3, 3)

创建范围数组

import Array._

object Test {
   def main(args: Array[String]) {
      var myList1 = range(10, 20, 2)
      var myList2 = range(10,13)//10,11,12
   }
}

定义变量

val a= 1//常量,不可变
var b = "xx" //变量,自动判断类型
var string : String="123"//指定类型

运算符

和java一样,但是没有a++

if else

和java一样

循环语句

whiledo while 和java一样
for循环比较特殊
以下是几种常见的用法
单循环

object Test {
   def main(args: Array[String]) {
      var a = 0;
      // for 循环
      for( a <- 1 to 10){
         println( "Value of a: " + a );
      }
   }
}

双循环

object Test {
   def main(args: Array[String]) {
      var a = 0;
      var b = 0;
      // for 循环
      for( a <- 1 to 3; b <- 1 to 3){
         println( "Value of a: " + a );
         println( "Value of b: " + b );
      }
   }
}

遍历集合

for( x <- List ){
   statement(s);
}

循环+判断

object Test {
   def main(args: Array[String]) {
      var a = 0;
      val numList = List(1,2,3,4,5,6,7,8,9,10);

      // for 循环
      for( a <- numList
           if a != 3; if a < 8 ){
         println( "Value of a: " + a );
      }
   }
}

for+yeild

object Test {
   def main(args: Array[String]) {
      var a = 0;
      val numList = List(1,2,3,4,5,6,7,8,9,10);

      // for 循环
      var retVal = for{ a <- numList 
                        if a != 3; if a < 8
                      }yield a

      // 输出返回值
      for( a <- retVal){
         println( "Value of a: " + a );
      }
   }
}

函数(Scala 也是一种函数式语言,所以函数是 Scala 语言的核心。)

语法和java有很大不同

def functionName ([参数列表]) : [return type] = {
   function body
   return [expr]
}

例子

object add{
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b
      return sum
   }
}

//可以末尾不加return关键字也可以
object add{
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b
      sum
   }
}

// 返回类型也可以不写,自动推断
object add{
   def addInt( a:Int, b:Int ) = {
      var sum:Int = 0
      sum = a + b
      sum
   }
}

此外,可变参数,函数传名调用,递归调用,默认参数都很简单

高阶函数

不太懂
https://www.runoob.com/scala/higher-order-functions.html

函数嵌套

我们可以在 Scala 函数内定义函数,定义在函数内的函数称之为局部函数。

object Test {
   def main(args: Array[String]) {
      println( factorial(0) )
      println( factorial(1) )
      println( factorial(2) )
      println( factorial(3) )
   }

   def factorial(i: Int): Int = {
      def fact(i: Int, accumulator: Int): Int = {
         if (i <= 1)
            accumulator
         else
            fact(i - 1, i * accumulator)
      }
      fact(i, 1)
   }
}

匿名函数

def add2 = new Function1[Int,Int]{  
    def apply(x:Int):Int = x+1;  
} 
//箭头左边是参数列表,右边是函数体。
var inc = (x:Int) => x+1 // 这是一个函数变量
var x = inc(7)-1 //调用
var mul = (x: Int, y: Int) => x*y
var userDir = () => { System.getProperty("user.dir") }

偏应用函数

我们可以使用偏应用函数优化以上方法,绑定第一个 date 参数,第二个参数使用下划线(_)替换缺失的参数列表,并把这个新的函数值的索引的赋给变量。以上实例修改如下:

import java.util.Date

object Test {
   def main(args: Array[String]) {
      val date = new Date
      val logWithDateBound = log(date, _ : String)

      logWithDateBound("message1" )
      Thread.sleep(1000)
      logWithDateBound("message2" )
      Thread.sleep(1000)
      logWithDateBound("message3" )
   }

   def log(date: Date, message: String)  = {
     println(date + "----" + message)
   }
}

函数柯里化(Currying)

首先我们定义一个函数:
def add(x:Int,y:Int)=x+y
那么我们应用的时候,应该是这样用:add(1,2)
现在我们把这个函数变一下形:
def add(x:Int)(y:Int) = x + y
那么我们应用的时候,应该是这样用:add(1)(2),最后结果都一样是3,这种方式(过程)就叫柯里化。
其本质是普通函数+匿名函数,2次调用
def add(x:Int)=(y:Int)=>x+y
所以可以分开调用2次也可以

val result = add(1) 
val sum = result(2)

闭包

https://www.runoob.com/scala/scala-closures.html

你可能感兴趣的:(scala,开发语言,java)