Scala入门【变量和数据类型】

目录

Scala基本认知

Hello Scala

方法的定义

伴生对象

Java：

Scala：

2、变量和数据类型

2.1、注释

2.2、变量和常量

Java中的变量和常量

Scala基本语法

2.3、标识符

2.4、字符串

基本语法

2.5、标准输入输出

基本语法

2.6、文件的读写

2.7、数据类型（重点）

1、整型（Byte、Short、Int、Long）

2、字符类型（Char）

1、字符和ASCII码的相互转化

3、布尔类型

4、Unit、Null类型和Nothing类型

5、类型转换

5.1、自动类型转换

5.2、强制类型转换

5.3、数值类型和String类型的转换

6、数据溢出

---

Scala基本认知

        Scala是一种Java虚拟机(JVM)上的编程语言，它结合了面向对象编程和函数式编程的最佳特性。

        Scala具有静态类型系统和类型推断功能，这使得编写代码变得更加简明和紧凑。

---

Hello Scala

//ovject：声明一个单例对象（伴生对象）
object Test {
//Unit相当于Java的void,Array是Scala的一个集合类型,中括号[]代表泛型
  def main(args: Array[String]): Unit = {
    println("hello Scala")
    sayHello()
    //可以直接使用Java的System来打印输出
    System.out.println("hello Java")
  }

  def sayHello(): Unit = {
    println("hello Scala")
  }
}

方法的定义

def  函数名(参数名 : 参数类型) : 返回值类型 = {
    //函数体
}

伴生对象

        相比较Java，Scala是一门完全面向对象的语言；这是因为Java的设计之处存在一些不是面向对象的地方。我们面向对象，要求我们的任何行为（方法）都必须从对象出发，但Java往往并没有这么做，比如：通过类名调用静态方法、静态变量等。

        在Scala中，被 class 修饰的叫类，被 object 修饰的叫伴生对象。只要是伴生对象中的变量和方法，就相当于Java中被static修饰了，可以通过 类名.变量名/函数名 来获得。

        在Scala中，类和伴生对象必须拥有相同的名称，它们之间的关系是一对一的，彼此之间可以访问对方的私有成员。伴生对象中的方法和属性可以被视为对类的补充，通常用于实现工厂模式等场景，并且在调用时可以直接使用伴生对象的名称，无需实例化类。

我们以一个Student类为例：

Java：

public class Student {
    private String name;
    private int age;
    private static String school = "xx大学";

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void printInfo(){
        System.out.println(this.name + " " + this.age + " " + Student.school);
    }

    public static void main(String[] args) {
        Student student1 = new Student("Bob",18);
        Student student2 = new Student("Tom",18);
        student1.printInfo();
        student2.printInfo();
    }
}

Scala：

• Scala在声明一个类的时候，直接就把属性都定义好了，所以Scala都不需要构造方法。我们通过伴生对象来获取所有Student类的公有变量school。
• Scala的类和伴生类名字必须相同并且在同一文件内！
• class 类内不能运行main方法，只能在单例（伴生类）中执行main方法！

import chapter01.Student.school

class Student(name: String,age: Int) {
  def printInfo(): Unit = {
    //不需要this 因为这就是一个对象
    println(name+" "+age+" "+school)
  }
}

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

  def main(args: Array[String]): Unit = {
    val stu = new Student("李大喜", 25)
    stu.printInfo()
  }
}

---

2、变量和数据类型

2.1、注释

Scala的注释和Java完全相同。

2.2、变量和常量

Java中的变量和常量

• 变量: 变量类型 变量名 = 初始值         int age = 10
• 常量: 常量类型 变量名 = 初始值         final int VALUE = 10

Scala基本语法

• var 变量名[: 变量类型] = 初始值         var age: Int = 10
• val 常量名[: 常量类型] = 初始值          val VALUE: Int = 10

通常，我们能用常量就不用变量（函数式编程的思想）。Scala的变量类型可以省略。

• Scala中，类型确定后不可修改，说明Scala是强语言类型。
• Scala在声明变量时必须有初始值。

object Test {

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

    //声明变量的通用语法
    var a: Int = 10
    var name: String = "Tom"

    //1.声明变量可以忽略类型
    var b = 10
    val c = 10
}

• 被常量符 val 修饰的类不可以修改（只是说这个类的不能被复制，并不是说不能修改它的属性），但是如果这个类的属性是被 var 修饰，那么它的属性是可以修改的。

var stu = new Student("alice",20)
stu = new Student("Alice",20)

val stu2 = new Student("Bob",20)
stu2.age = 21
//stu2 = stu    //这样不行的

• 我们可以在声明类（class）的时候来指定属性是常量还是变量

//name可以通过对象修改,age不可被修改
class Studnt(name: String,val age: Int){

}

2.3、标识符

标识符就是我们的变量名、函数名，也就是说，只要是我们可以自己起名字的地方，都是标识符。Scala中的标识符规则基本与Java一致。但有自己不一样的地方：

• 可以以操作符（+ - * / # !）作为标识符，但是必须只包含操作符。
• 可以使用关键字，但需要用反引号 `` 包起来

var +-*/ = "hello"
println(+-*/)

val `if` = "hi"
println(`if`)

2.4、字符串

字符串的用法我越看越像 Python

基本语法

• 通过+拼接
• printf格式化：可通过%传值
• 字符串模版：可通过$获取字符串值（类似于shell脚本中的${}，可以省去花括号{}），一般我们为了将变量区分开来都会加花括号
• 原格式输出："""文本"""（使用三引号包起来）

object Test02 {

  def main(args: Array[String]): Unit = {
    //+拼接
    println("神探狄仁杰 "+"李元芳")

    //%d 整型, %s 字符串类型
    val age = 58
    val name = "李元芳"
    printf("不死战神%s今年%d岁了",name,age)

    //输出三个 李元芳
    println(name*3)

    //李元芳今年58岁了
    println(s"${name}今年${age}了")

    //输出小数 %2.2f 的意思是整个数的长度不够2就补空格,小数后面保留两位
    val value: Double = 2.345
    println(f"${value}%2.2f")

   //输出多行并保持原格式输出
   val sql = s"""
       |select *
       |from
       |  student
       |where
       |  name = ${name}
       |and
       |  age > ${age}
       |""".stripMargin
    println(sql)
  }

}

2.5、标准输入输出

基本语法

StdIn.readLine、StdIn.readInt、StdIn.readDouble、StdIn.readFloat...

import scala.io.StdIn

//...

//输入
val name = StdIn.readLine()
val age = StdIn.readInr()
//输出
println(s"姓名:${name} 年龄:${age}")

2.6、文件的读写

读取文件十分简单，就像Python那样容易，直接导入 scala.io.Source。

但是写入文件Scala并没有提供相关的API，因为我们的Java已经提供了，而我们Scala又可以直接使用Java的API。

import java.io.{File, PrintWriter}
import scala.io.Source

object Test04_io {

  def main(args: Array[String]): Unit = {
    //1.从文件中读取数据 foreach是函数式编程的内容,意思是传入一个函数将文本顺便打印出来
    //从项目路径下读取文件 默认当前路径是idea的当前项目路径最顶层
    Source.fromFile("src/main/resources/test_read.txt","utf-8").foreach(print)
    
    //2.将数据写入文件
    val writer = new PrintWriter(new File("src/main/resources/test_write.txt"))
    val content =
      """hello spark
        |hello java
        |hello scala
        |""".stripMargin
    writer.write(content)
    writer.close()
  }

}

2.7、数据类型（重点）

Java八大数据类型 ：byte、short、int、long、float、double、boolean、char。

Scala 中数据类型分为两大类：数值类型（ AnyVal ）、 引用类型（AnyRef ）， 不管是值类型还是引用类型都是对象。

1、整型（Byte、Short、Int、Long）

• Byte：-128~127
• Short：-32768~32767（三万二左右）
• Int：-2147483648~2147483647（二十一亿左右）
• Long：-9223372036854775808~-9223372036854775807（超级大）

Scala中默认的整数类型为 Int，所以默认定义一个Long类型需要在数值后+ L。

Scala中默认的浮点数类型为 Double，所以默认定义一个Float类型需要在数值后+ F。

    val a1: Byte = 10
    val a2: Byte = -128

    val a3: Byte = 10+10
    //强制转换
    val a4: Byte = (a1 + 10).toByte

    //short 3万2左右
    val b1: Short = 32000
    val b2: Short = 32767

    //int 21亿
    val c1: Int = 2100000000

    //几乎无穷大
    val d1: Long = 123456789123456L
    
    //浮点数
    val f1: Float = 1.2345F

2、字符类型（Char）

基本用法和Java一致

1、字符和ASCII码的相互转化

    val word: Char = 'a'
    val ascii: Int = word
    println(s"${word}的ASCII码为 "+ascii)

    val asc: Int = 98
    val wo: Char = asc.toChar
    println(s"ASCII码${asc}对应的字符为 "+wo)

3、布尔类型

boolean 类型占 1 个字节，用法和Java一致。

val isTrue: Boolean = 1==1
println(isTrue)    //true

4、Unit、Null类型和Nothing类型

• Unit：表示空值，函数返回值为空，相当于 void。Unit只有一个实例，写作 () 。
• Null：表示空引用，Null类型只有一个实例 null，数值类型不可以复制为 null，引用类型才可以。
• Nothing：Nothing 类型在 Scala 的类层级最低端；它是任何其他类型的子类型。 当一个函数，我们确定没有正常的返回值，可以用 Nothing 来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性）。

  def say_hello(name: String): Unit = {
    println(f"hello ${name}!")
  }

  def method(n: Int): Nothing ={
    throw new NullPointerException
  }

    //Unit
    //输出方法的结果
    val res = say_hello("tom")
    println(res)  //输出 ()

    //这里要用 var 因为我们要对变量重新赋值
    //数值类型不可以复制为 null,只有引用类型才能被复赋值为 null
//    var k = 10
//    k=null
//    println(k)

    val aa: Null = null
    println(aa) //null


    var student: Student = new Student("alice",19)
    student = null
    println(student)    //null

5、类型转换

5.1、自动类型转换

Java 数据类型自动转换：

• byte -> short -> int 
• char -> int

Scala 数据类型自动转换：

    //低精度->高精度 自动转换
    val bb: Byte = 10
    val cc: Short = bb
    println(cc) //10
    //高精度->低精度 强制转换
    val dd: Byte = cc.toByte
    println(dd) //10

5.2、强制类型转换

//高精度->低精度 强制转换
var num1: Int = 2.5.toInt
var num2: Int = 2.9.toInt
//取整是取整数部分
print(num)    //2
print(num)    //-2

5.3、数值类型和String类型的转换

//数值->String
val s:String = 1.5+""

//String->数值
val m: Int = "12".toInt

val f: Int = "12.3".toFloat.toInt    //小数字符串不能直接转Int,要先转浮点数

6、数据溢出

Byte能表示-128~127，我们把Int类型的130强制转换为Byte：

    val num: Int = 130
    val res: Byte = num.toByte
    println(res)    //输出-126

/**
     * 130: Int类型,32位,4个字节
     * 原码: 0000 0000 1000 0010
     * 补码: 0000 0000 1000 0010
     *
     * 截取最后一个字节做强转
     * 得到补码 1000 0010
     * 对应原码 1111 1110 符号位不变,其余取反+1
     * -126

类推 131 -> -125,132 -> -124
     */