Scala基本语法（一）

最新推荐文章于 2024-07-16 17:18:37 发布
最新推荐文章于 2024-07-16 17:18:37 发布
阅读量616 收藏
点赞数
分类专栏： flink 文章标签： scala java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43589217/article/details/122117568
版权

Scala语言特点

Scala是一门以Java虚拟机（JVM）为运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言（静态语言需要提前编译的如：Java、c、c++等，动态语言如：js）。
1）Scala是一门多范式的编程语言，Scala支持面向对象和函数式编程。（多范式，就是多种编程方法的意思。有面向过程、面向对象、泛型、函数式四种程序设计方法。）
2）Scala源代码（.scala）会被编译成Java字节码（.class），然后运行于JVM之上，并可以调用现有的Java类库，实现两种语言的无缝接。
3）Scala单作为一门语言来看，非常的简洁高效。
4）Scala在设计时，马丁·奥德斯基是参考了Java的设计思想，可以说Scala是源Java，同时马丁·奥德斯基也加入了自己的思想，将函数式编程语言的特点融合到JAVA中。

案例

helloworld

package com.xiaoming

object Scalademo1 {
  def main(args: Array[String]): Unit = {
    println("Hello Scala")
  }
}
//Scala完全面向对象，故Scala去掉了Java中非面向对象的元素，如static关键字，void类型
//

1）static
Scala无static关键字，由object实现类似静态方法的功能（类名.方法名），class关键字和Java中的class关键字作用相同，用来定义一个类；
2）void
对于无返回值的函数，Scala定义其返回值类型为Unit类

反编译

在这里插入图片描述
注释： Scala 注释使用和 Java 完全一样。

（1）单行注释：//
（2）多行注释：/* */
（3）文档注释

  def main(args: Array[String]): Unit = {
    println("Hello Scala")
    
    println(i)
    
    //（1）单行注释：//
    println("xiaoming")

    //（2）多行注释：/* */
    /*
    println("xiaoming")
    println("mingshao")
    */

    //（3）文档注释：/**
    //*
    //*/
    /**
      * println("xiaoming")
      * println("xiaoming")
      * println("xiaoming")
      */

基本语法

变量和常量

1）回顾：Java 变量和常量语法
变量类型 变量名称 = 初始值 int a = 10
final 常量类型 常量名称 = 初始值 final int b = 20
2）基本语法
var 变量名 [: 变量类型] = 初始值
val 常量名 [: 常量类型] = 初始值
注意：能用常量的地方不用变量

var i:Int = 10   //var修饰 可变
val j:Int = 20	 //val修饰 不可变
i = 20	//正确写法
j = 30	//错误写法

注意： var 修饰的对象引用可以改变，val 修饰的对象则不可改变，但对象的状态（值）
却是可以改变的。（比如：自定义对象、数组、集合等等）

object TestVar {
      def main(args: Array[String]): Unit = {
        // p1 是 var 修饰的，p1 的属性可以变，而且 p1 本身也可以变
        var p1 = new Person()
        p1.name = "xiaoming"
        p1 = null
        // p2 是 val 修饰的，那么 p2 本身就不可变（即 p2 的内存地址不能变），
        //但是，p2 的属性是可以变，因为属性并没有用 val 修饰。
        val p2 = new Person()
        p2.name = "mingshao"
        // p2 = null // 错误的，因为 p2 是 val 修饰的
      }
    }
    class Person {
      var name: String = "mingshao"
    }

数据类型

java数据类型

Java基本数据类型：char、byte、short、int、long、float、double、boolean
Java引用类型：（对象类型）
由于Java有基本类型，而且基本类型不是真正意义的对象，即使后面产生了基本类型的包装类，但是仍然存在基本数据类型，所以Java语言并不是真正意思的面向对象。
Java基本类型的包装类：Character、Byte、Short、Integer、Long、Float、Double、Boolean
注意：Java中基本类型和引用类型没有共同的祖先。

scala数据类型

1）Scala中一切数据都是对象，都是Any的子类。
2）Scala中数据类型分为两大类：数值类型（AnyVal）、引用类型（AnyRef），不管是值类型还是引用类型都是对象。
3）Scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）
4）Scala中的StringOps是对Java中的String增强
5）Unit：对应Java中的void，用于方法返回值的位置，表示方法没有返回值。Unit是 一个数据类型，只有一个对象就是()。Void不是数据类型，只是一个关键字
6）Null是一个类型，只 有一个对 象就 是null。它是所有引用类型（AnyRef）的子类。
7）Nothing，是所有数据类型的子类，主要用在一个函数没有明确返回值时使 用，因为这样我们可以把抛出的返回值，返回给任何的变量或者函数。

整型（Byte [1]、Short [2]、Int [4]、Long [8]）

val byte: Byte = 127
val short: Short = 10
val int: Int = 20
val long: Long = 123456879L

浮点类型（Float [4]、Double [8]）

val float: Float = 127.123f
val short: Double = 123.123 
//Scala 的浮点型常量默认为 Double 型，声明 Float 型常量，须后加‘f’或‘F’。

字符类型（char）

    //（1）字符常量是用单引号 ' ' 括起来的单个字符。
    val c1: Char = 'a'
    println(c1)
    //（2）\t ：一个制表位，实现对齐的功能
    println("姓名\t 年龄")
    //（3）\n ：换行符
    println("西门庆\n 潘金莲")
    //（4）\\ ：表示\
    println("c:\\岛国\\avi")
    //（5）\" ：表示"
    println("同学们都说：\"大海哥最帅\"")

布尔类型

object TestBooleanType {
    def main(args: Array[String]): Unit = {
      var isResult : Boolean = false
      var isResult2 : Boolean = true
    } 
}

字符串操作

object demo3 {
  def main(args: Array[String]): Unit = {
    val builder: StringBuilder = new StringBuilder()
    val str1: String = "abcd"
    val str2: String = "def"
	//这里‘.’可加可不加
    builder.append("abcd")
    builder.append(",")
    builder.append("efg")

    println(builder)

    //scala方式 进行连接字符串
    println(s"${str1}${str2}")

    val str3: String = "123"

    val int3: Int = Integer.parseInt(str3)
    println(int3)

    val int = str3.toInt
    println(int)

    val strN: String = "1,2,3,4,5,6,7,8,9"
	//split切分并转成list
    val list: List[String] = strN.split(",").toList
	//遍历list
    for (str<-list){
      print(str)
    }
    //在Scala中采取函数式编程思想进行遍历
    list.foreach(print)
    }
  }
}

scala链接数据库

package com.xiaoming

import java.sql.{Connection, DriverManager, PreparedStatement, ResultSet}

object demo3 {
  def main(args: Array[String]): Unit = {
  
    //链接mysql
    //创建链接
    val conn: Connection = DriverManager.getConnection("jdbc:mysql://master:3306/student","root","123456")

    //创建statement
    val st: PreparedStatement = conn.prepareStatement("select * from student where clazz=?")

    //设置参数
    st.setString(1,"理科一班")

    //执行
    val rs: ResultSet = st.executeQuery()
    while (rs.next()){
      val id: Int = rs.getInt("id")
      val name: String = rs.getString("name")
      val clazz: String = rs.getString("clazz")
      val gender: String = rs.getString("gender")
      val last_mod: String = rs.getString("last_mod")
      val age: Int = rs.getInt("age")

      println(s"${id},${name},${age},${gender},${clazz},${last_mod}")
    }
  }
}

面向对象

package com.xiaoming

/**
  * 面向对象：封装、继承、多态
  * 类中可以定义：属性、方法
  * {}就是默认的构造方法
  */
class StudentScala(id: String, name: String, age: Int) {
  println("调用了默认的构造方法")
  // 定义类的属性 定义即赋值
  val _id: String = id
  val _name: String = name
  val _age: Int = age

  // 重写了父类的方法
  override def toString:String = s"StudentScala(${_id}, ${_name}, ${_age})"

  //重载构造方法
//  def this(id:String,name:String,age:Int){
//    this(id,name,age)
//    println("调用了新的构造方法")
//  }
}
object DemoStudent{
  def main(args: Array[String]): Unit = {
    val stu1: StudentScala = new StudentScala("001","小明",24)
    
    println(stu1)
  }
}

继承

package com.xiaoming

class A(id: String, name: String) {
  val _id: String = id
  val _name: String = name

  override def toString = s"A(_id=${_id}, _name=${_name})"

  def printAB(): Unit = {
    println("这是A的对象方法")
  }
}

class B(id: String, name: String, age: Int, clazz: String) extends A(id, name) {
  val _age: Int = age
  val _clazz: String = clazz

  override def toString = s"B(_id=${_id},_name=${_name},_age=${_age}, _clazz=${_clazz})"

  override def printAB(): Unit = {
    println("这是B的对象方法")
  }
}

object Demo4obj {

  def printTwice(a: A): Unit = {
    a.printAB()
    a.printAB()
  }

  def main(args: Array[String]): Unit = {
    val a: A = new A("001", "张三")
    val b: B = new B("002", "李四", 21, "文科一班")

    println(a._id)
    println(a._name)
    println(a)

    println(b._id)
    println(b._name)
    println(b._age)
    println(b._clazz)
    println(b)

    a.printAB()
    b.printAB()

    printTwice(b) // 多态 父类引用指向子类对象

    printTwice(a)

    // 样例类
    val caseStu: Demo5CaseClass = new Demo5CaseClass("003", "小明", 22, "男", "理科三班")
  }
}

样例类

package com.xiaoming

// 样例类
// 在样例类中定义的参数 默认由val修饰 不可以改变
// 如果需要对属性重新赋值 则需要在定义的时候 加上 var修饰
// 会自动实现get set（针对var修饰的属性）方法，还会实现序列化接口（可以在网络中进行传输）
case class CaseClassDemo2(val id: String, name: String, age: String, gender: String, clazz: String)

object Demo2 {
  def main(args: Array[String]): Unit = {
    // 创建样例类的对象
    // new关键字可以省略
    val stu: CaseClassDemo2 = CaseClassDemo2("002", "小明", "24", "男", "理科1班")

    println(stu.id)
    println(stu.name)
    println(stu.age)
    println(stu.gender)
    println(stu.clazz)
  }
}

函数式编程

1）面向对象编程

解决问题，分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题。
对象：用户
行为：登录、连接 JDBC、读取数据库
属性：用户名、密码
Scala 语言是一个完全面向对象编程语言。万物皆对象
对象的本质：对数据和行为的一个封装

2）函数式编程

解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用
这些封装好的步骤，解决问题。
例如：请求->用户名、密码->连接 JDBC->读取数据库
Scala 语言是一个完全函数式编程语言。万物皆函数。
函数的本质：函数可以当做一个值进行传递

3）在 Scala 中函数式编程和面向对象编程完美融合在一起了。

函数至简原则

（1）return 可以省略，Scala 会使用函数体的最后一行代码作为返回值
（2）如果函数体只有一行代码，可以省略花括号
（3）返回值类型如果能够推断出来，那么可以省略（ : 和 返回值类型*一起省略）
（4）如果有 return，则不能省略返回值类型，必须指定
（5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用
（6）Scala 如果期望是无返回值类型，可以省略等号
（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
（8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略

object TestFunction {
    /**
     * def 这是一个函数
     * f 函数名
     * s: String 函数的参数
     * Unit: 函数的返回值类型，这里相当于void
     * {} : 方法体
     */
  def main(args: Array[String]): Unit = {
    //（0）函数标准写法
    def f(s: String): String = {
      return s + " jinlian"
    }
    println(f("Hello"))

    // 至简原则:能省则省
    //（1） return 可以省略,Scala 会使用函数体的最后一行代码作为返回值
    def f1(s: String): String = {
      s + " jinlian"
    }
    println(f1("Hello"))

    //（2）如果函数体只有一行代码，可以省略花括号
    def f2(s: String): String = s + " jinlian"

    //（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
    def f3(s: String) = s + " jinlian"
    println(f3("Hello3"))

    //（4）如果有 return，则不能省略返回值类型，必须指定。
    def f4(): String = {
      return "ximenqing4"
    }
    println(f4())

    //（5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用
    def f5(): Unit = {
      return "dalang5"
    }
    println(f5())

    //（6）Scala 如果期望是无返回值类型,可以省略等号
    // 将无返回值的函数称之为过程
    def f6() {
      "dalang6"
    }
    println(f6())

    //（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
    def f7() = "dalang7"
    println(f7())
    println(f7)
    //（8）如果函数没有参数列表，那么小括号可以省略,调用时小括号必须省略
    def f8 = "dalang"
    //println(f8())
    println(f8)
    //（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
    def f9 = (x:String)=>{println("wusong")}
    def f10(f:String=>Unit) = {
      f("")
    }
    f10(f9)
    println(f10((x:String)=>{println("wusong")}))
  }
}

高阶函数

package com.xiaoming

object demo7Fuc2 {
  def main(args: Array[String]): Unit = {
    /**
      * 函数式编程（高阶函数、面向函数编程）
      * 面向对象编程：把对象传来传去 注意在将对象传给函数的时候有类型的限制 以及 对象作为返回值的时候也有类型的限制
      * 面向函数编程：把函数传来传去 注意在将函数传给函数的时候有类型的限制 以及 函数作为返回值的时候也有类型的限制
      *
      * 函数式编程的分类：
      * 1、以函数作为参数
      * 2、以函数作为返回值
      *
      * 怎么去描述函数的类型？
      * 1、跟def关键字无关
      * 2、跟函数名也无关
      * 3、跟函数实现的功能也无关
      * 4、跟函数的参数名称也无关
      * 5、实际上函数的类型 由参数的类型（个数、顺序）及返回值的类型共同决定
      * 参数的类型 => 返回值的类型
      */

    println(func1("100"))
    println(func2(200))
    println(funcX(func1))

    // 调用"匿名函数"
    println(ff("100", 4))

    // 如果函数逻辑比较简单 可以使用匿名函数进行简化
    println(funcX((str: String) => {str.toInt + 5})) // 205

    /**
      * 匿名函数的省略规则：
      * 1、函数体只有一行代码，花括号可以省略
      * 2、如果匿名函数作为另一个函数的参数传入 参数的类型可以省略
      * 3、如果参数只有一个 括号可以省略
      * 4、如果参数只被使用的一次 则可以省略 并用下划线_替代
      */
    println(funcX((str: String) => str.toInt + 6)) // 206
    println(funcX((str) => str.toInt + 6)) // 206
    println(funcX(str => str.toInt + 7)) // 207
    println(funcX(_.toInt + 8)) // 208
  }

  def func1(str: String) = str.toInt + 1

  def func2(i: Int) = i + 3

  def funcX(f: String => Int): Int = {
    val i: Int = f("200")
    i
  }

  //匿名函数
  (str1: String, str2: Int) => str1.toInt + str2
  // 匿名函数也可以拥有名字
  // 函数类型  =》返回值类型
  val ff: (String, Int) => Int = (str1: String, int1: Int) => {
    str1.toInt + int1
  }
}

数组遍历(map、foreach方法)

package com.xiaoming

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

    //创建一个数组
    val array: Array[Int] = Array[Int](1, 2, 3, 4, 5, 6, 7, 8)

    //遍历
    var index: Int = 0
    while (index < array.length) {
      println(array(index))
      index += 1
    }

    // 让每一个array中的元素扩大两倍
    var index2: Int = 0
    while (index2 < array.length) {
      array(index2) = array(index2) * 2
      //      println(array(index2))
      index2 += 1
    }
    println(array.mkString(","))

    // Scala的思想
    // foreach方法：需要传入一个函数f：参数类型为Int，返回值类型为Unit
    // foreach方法会将array中的每一个元素依次作为参数传递给函数f
    // println是一个函数：参数类型为Any，返回值类型为Unit

    // 遍历
    array.foreach(println)

    println("*" * 50)
    //其他遍历方式
    for (elem <- array) {
      println(elem)
    }

    println("*" * 50)
    for (i <- 0 to array.length - 1) {
      println(array(i))
    }

    for (i <- Range(0, array.length)) {
      println(array(i))
    }
    for (i <- 0 until array.length) {
      println(array(i))
    }

    // map方法接收一个函数f：参数为Int类型（与array中每个元素的类型有关），返回值类型任意（自己定义）
    // map方法同foreach方法的差异在于有没有返回值

    def extend2(int: Int): String = {
      (int * 2).toString
    }
    // map方法会将array中的每一个元素作为参数传给函数f，最后会将变换后的结果作为新的数组返回
    val array2: Array[String] = array.map(extend2)
    println(array2.mkString(","))
    //使用匿名函数简化
    println(array.map(_ * 2).mkString(","))
  }
}
纯欲天花板_
关注
专栏目录
scala 语法
qq_44648148的博客
12-08 275
定义变量 变量类型首字母大写 定义变量常用val var 定义变量 var k = "abc" //定义字符串变量 var k : String = "abc" //定义字符串变量 k="abcd" val定义常量(定义的变量不可以改变值，相当于java中的final scala中不支持i++和++i scala的数据类型 scala和java一样，有7中数值类型Byte、Char、Short、Int、Long、Float和Double（无包装类型）和一个Boolean类型。 var i : Int
Scala | Scala基础语法一
XING_Gou的博客
07-24 351
知识点一： eclipse更改字体:window->preference->color and font->下拉basic->text font->点击Edit编辑->修改字体 scala worksheet 是IDE工具提供的交互式编译模式，左侧写代码，右侧出结果，一般用于测试练习想看结果，需要保存文件。快捷键：ctrl+s scala的变量和常量 变量：var(variable的缩写)，变量声明后可以修改 常量：val(value的缩写)，常量一经声明，不
SCALA 语法
qq_37466464的博客
11-29 308
1.区分大小写 2.类名第一个大写 3.所有的方法名称的第一个字母用小写。 4.程序文件名 与对象名称匹配（新版本不需要，建议一致） 5.程序入口 def main(args:Array[String]) 标识符 Scala 数据类型 byte shout int long char boolean float double 以及和java不同的 String 字符序列 Unit 表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Un...
Scala 语法基础篇
最新发布
2301_79349971的博客
07-16 1705
Range 属于值类型的超类 AnyVal，表示一个连续的数字序列。通过 to方法或 until方法创建val r:Range = START until END by STEP // STEP缺省默认为1val a:Range = 1 until 10 by 2 // 创建了一个半开范围，从 1 开始（包含 1），到 10 结束（不包含 10），步长为 2。val r:Range = START to END by STEP // STEP缺省默认为1。
SCALA语法
weixin_42117812的博客
09-18 173
一、SCALA相关 1. scala简介 scala是运行在 JVM 上的多范式编程语言，同时支持面向对象和面向函数编程 早期scala刚出现的时候，并没有怎么引起重视，随着Spark和Kafka这样基于scala的大数据框架的兴起，scala逐步进入大数据开发者的眼帘。scala的主要优势是它的表达性。 官网地址 http://www.scala-lang.org 2. 为什么要使用s...
scala语法
sinat_22336563的博客
06-07 1700
根据documents记录一些零碎的知识点，学习一定程度后再总结一下。1 basic1.1 Variables and ValuesVariables和Values分别用var和val表示，他们之间的区别是var可以重复赋值，而val赋值后不可改变，相当于const。val x = 1+1 var y: Int = 1 + 1 y = 3 变量的type类似c++11中auto会自己推断，同时也可以
Scala语法教程
weixin_51497782的博客
02-17 1974
Scala详细的语法教程，非常细致
Scala 基础语法
01-03
如果你之前是一名 Java 程序员，并了解 Java 语言的基础知识，那么你能很快学会 Scala 的基础语法。 Scala 与 Java 的最大区别是：Scala 语句末尾的分号 ; 是可选的。 我们可以认为 Scala 程序是对象的集合，通过...
Scala函数式编程专题--scala基础语法介绍
08-18
Scala 函数式编程专题 -- Scala 基础语法介绍 本文主要介绍 Scala 基础语法的相关知识点，旨在帮助读者更好地理解和学习 Scala 编程语言。 一、Scala 语言简介 Scala 是一种现代化的、多范式的编程语言，运行于 ...
Scala基础语法教程一、基础语法与变量(idea版本)
李知恩从零开始学Java
07-15 548
环境需求 环境：win10 开发工具：IntelliJ IDEA 2021.2 maven版本：3.6.3 目录 基本语法 标识符 Scala 关键字 Scala 注释 空行和空格 换行符 Scala 包 引用 Scala 数据类型 Scala 基础字面量 整型字面量 浮点型字面量 布尔型字面量 字符字面量 字符串字面量 多行字符串的表示方法 Null 值 Scala 转义字符 Scala 变量 变量声明............
Scala基本语法
11号车厢
07-28 680
文章目录1、数据类型2、变量声明3、元组Tuple4、强制类型转换5、迭代6、流程控制和循环7、函数 1、数据类型 Scala有8种数据类型: Boolean:true/false Byte:8位,有符号 Short:16位,有符号 Int:32位,有符号 Long:64位,有符号 Char:16位,无符号 Float:32位,单精度浮点数 Double:64位,双精度浮点数 Scala 中所有...
Scala——基本语法
qq_42873479的博客
10-16 983
Scala基本语法1 语法的简单说明2 基本语法2.1 注释2.2 变量和常量2.3 标识符的命名规范2.4 字符串输出2.5 键盘输入2.6数据类型2.7 整数类型（Byte、Short、Int、Long）2.8 浮点类型（Float、Double）2.9 字符类型（Char)2.10 布尔类型：Boolean2.11 Unit类型、Null类型和Nothing类型2.12 类型转换2.12.1 数值类型自动转换2.12.2 强制类型转换2.12.3 数值类型和String类型间转换 Scala是一门以J
scala基础语法
蓝色格子ren的博客
07-08 744
1.变量 scala中变量有两种类型：可变型和不可变型。 可变型：变量的值可以在声明后进行修改； 不可变型：变量的值在声明后无法被修改。 scala中使用var或val关键字声明变量。其中var用于声明可变类型的变量；val用于声明不可变类型的变量。声明变量时具体语法下： //声明时指定类型 var a : Int = 2 val b: String = "333" //声明时不指定类型 var c = 123 val d = "no Type" 我们可以在声明时，在变量名后通过:指定参数类型，也可以不
Scala的基本语法
qq_45453185的博客
03-28 1296
一、基本概念 Scala中一共是39个关键字： package, import, class, object, trait, extends, with, for，private, protected, abstract, sealed, final, implicit, lazy, override，try, catch, finally, throw ，if, else, match, case, do, while, return, yield，def, val, var ，this, super，
scala基本语法（一）
倩mys的博客
09-08 220
1、Scala 2、变量声明需要初始值
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值