scala学习(1)

最新推荐文章于 2025-08-04 15:47:37 发布

doudoudouy

最新推荐文章于 2025-08-04 15:47:37 发布

阅读量74

点赞数

CC 4.0 BY-SA版权

文章标签： scala 学习开发语言

本文链接：https://blog.youkuaiyun.com/doudoudouy/article/details/134867455

本文介绍了Scala编程中的基本概念，包括伴生对象的使用、变量和常量的区别、数据类型（包括AnyVal和AnyRef）、循环控制机制、以及函数式编程特性如匿名函数和闭包。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、伴生对象

1、object 相当于class的单个实例，因此，在object里声明的变量都是静态变量，静态方法

2、伴生类和伴生对象必须存放在一个.scala文件之中

3、object里的构造器，也就是object 内部不在method中的代码，都属于构造器的内容

package chapter01

class Student(name: String, age: Int) {

  def printInfo(): Unit = {
    println(name + " " + age + " " + Student.school);
  }

}

//引入伴生对象
object Student{
  val school: String = "gdgy";

  def main(args: Array[String]): Unit = {
    val tom = new Student("Tom", 20)
    tom.printInfo()
  }
}

二、变量和常量

1、scala中能使用常量的地方，不要使用变量；变量声明时必须要有初始值，val修饰的变量不可改；类型确定后就不能修改，说明scala是强类型数据语言

var 变量名 [: 变量类型] = 初始值 var i: int = 10

val 常量名 [: 常量类型] = 初始值 val i: int = 10

2、java中用final修饰符来区分常量和变量

三、数据类型

1、Scala中一切数据都是对象，都是Any的子类，分两种：数值类型(AnyVal)和引用类型(AnyRef)，不管那种类型都是对象。

2、Scala中的StringOps是对Java中的String增强，Unit对应java中的void，用于方法返回值的位置，表示方法没有返回值，Unit是一个数据类型，只有一个对象就是()，Void不是数据类型，只是一个关键字。

3、Unit为空值，Null为空引用，Nothing为任何其他类型的子类型，当一个函数确定没有正确的返回值，可以用Nothing来指定返回类型，不确定返回值。

package chapter01

object DataType {

  def main(args: Array[String]): Unit = {
    def m1(): Unit = {
      println("m1被调用执行")
    }

    val a = m1;
    //返回Unit类型，为()空值
    println(a)

    //值类型不能赋值空引用
//    val n: Int = null
    var student: Student = new Student("anma", 12)
    student = null
    println(student)
    //Nothing是所有类型的子类
    //def m2(n: Int): Nothing这里返回值不能写这个
    def m2(n: Int): Int = {
      if (n == 0)
        throw new NullPointerException
      else
        return n
    }
    
    val b = m2(0)
    println(b)

  }

}

四、循环控制

1、循环守卫，相当于continue的效果。2

2、循环步长

3、yield生成一个集合类型作为for循环的返回值

4、循环中断，scala中去掉了continue和break，采用抛出异常的方式退出

package chapter01

import scala.util.control.Breaks

object ForLoop {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 10){
      if (i != 5){
        println(i)
      }
    }
    //循环守卫
    for (i <- 1 to 10 if i != 5){
      println(i)
    }
    //循环步长
    for (i <- 1 to 10 by 2){
      println(i)
    }
    //生成一个集合类型作为for循环的返回值
    val ints = for (i <- 1 to 10) yield i
    println("ints:" + ints)
    //退出循环
    try{
      for (i <- 0 until 5){
        if (i ==3)
          throw new RuntimeException
        println(i)
      }
    }catch{
      case e: Exception => //什么都不做只是退出循环
    }
    println("循环外的代码")
    //退出循环，使用scala中的Breaks类的break方法，实现异常的抛出和捕捉
    Breaks.breakable( //其实就是try catch
      for (i <- 0 until 5){
        if (i ==3)
          Breaks.break()
        println(i)
      }
    )

  }

}

五、函数式编程

1、匿名函数，省略了函数名的函数。

package chapter01

object Lambda {

  def main(args: Array[String]): Unit = {

    def dualFun(fun: (Int, Int)=>Int): Int = {
      fun(1, 2)
    }
    val add = (a: Int, b: Int) => a+b
    val minus = (a: Int, b: Int) => a-b
    println(dualFun(add))
    println(dualFun(minus))
    //匿名函数简化
    println(dualFun((a, b) => a+b))
    println(dualFun((a, b) => a-b))
    //再次简化
    println(dualFun(_+_))
    println(dualFun(_-_)) //a-b
    println(dualFun(-_+_)) //b-a
  }

}

2、闭包和柯里化

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。以内层函数作为返回值定义外层函数，内层函数使用外层函数的变量或参数。柯里化是把一个参数列表的多个参数，变成多个参数列表的过程。

package chapter01

object Closure {

  def main(args: Array[String]): Unit = {

    def addFour(): Int=>Int = {
      val a = 4
      def addB(b: Int): Int = {
        a + b
      }
      addB
    }

    def addFour1(a: Int): Int=>Int = {
      def addB(b: Int): Int = {
        a + b
      }
      addB
    }
    println(addFour1(35)(24))
    //简写
    def addFour2(a: Int): Int=>Int = {
      b => a+b
    }
    def addFour3(a: Int): Int=>Int = a + _
    //柯里化
    def addFour4(a: Int)(b: Int): Int = a + b
  }
}