[Java知识库]5、Scala变量和数据类型

Scala变量和数据类型

先在此声明，Scala的基本数据类型和Java一样

注释

Scala注释使用和Java完全一样

注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，再用代码去体现。

基本语言法

• 单行注释：//
• 多行注释：/**/
• 文档注释：/** * */

/**
 * 文档注释：
 * 
 * 程序的入口方法
 * @param args 外部传入的参数
 * @author laingzai
 * @version 1.0
 *          //单行注释
 *          /* 
 *          多行注释
 *          */
 */
object Test01_Comment {
  def main(args: Array[String]): Unit = {
    //单行注释 打印输出
    //println("hello Scala")

    /*多行注释 多行输出
    println("hello Scala")
    println("hello Scala")
    println("hello Scala")
    println("hello Scala")
    println("hello Scala")
    println("hello Scala")
     */
    println("hello Scala")
  }
}

代码规范

1. 使用一次tab操作，实现缩进，默认整体向右边移动，用shift + tab整体向左移
2. 或者使用ctrl + alt + L 来进行格式化
3. 运算符两边习惯性各加一个空格。比如：2 + 4 * 5
4. 一行最长不超过80个字符，超过的请使用换行展示，尽量保持格式优雅

变量和常量

常量：在程序执行的过程中，其值不会被改变的变量

• Java变量和常量语法
  • 变量类型 变量名称 = 初始值 int a = 10
  • final常量类型 常量名称 = 初始值 final int b = 20
• Scala基本语法
  • var 变量名 [: 变量类型] = 初始值 var i:Int = 10
  • val 常量名 [: 常量类型] = 初始值 val j:Int = 20

注意：能用常量的地方不用变量 
Java是先写类型再写名称
Scala是先写名称再写类型中间用:分隔
Scala能使用常量尽量多用常量，变量少使用（面对对象语言、函数式语言）一个值等于什么就是什么

• 案例

1、声明变量时，类型可以省略，编译自动推导，即类型推导
2、类型确定后，就不能修改，说明Scala是强数据类型语言
3、变量声明时，必须要有初始值
4、在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val修饰的变量不可改

package day02

import day01.Student

object Test02_Variable {
  def main(args: Array[String]): Unit = {
    //声明一个变量的通过语法
    var a: Int = 10
//    1、声明变量时，类型可以省略，编译自动推导，即类型推导
    var a1 = 10
    val b1 = 24
//    2、类型确定后，就不能修改，说明Scala是强数据类型语言
    var a2 = 15 //a2类型为Int
//    a2 = "hello"
//    3、变量声明时，必须要有初始值
//    var  a3: Int
//    4、在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val修饰的变量不可改
    a1 = 18
//    b1=24
    var liangzai = new Student("liangzai", 24)
    liangzai = new Student("Liangzai", 25)
    liangzai = null
    val diaomao = new Student("diaomao", 21)
    diaomao.age = 29
    diaomao.printerInfo()
  }
}

运行结果：
diaomao 29 zhongguo

如果想要对值进行修改，可以在声明前加上val或var

标识符的命名规范

Scala 对各种变量、方法、函数等命名时使用的字符序列称为标识符。即：凡是自己可以起的名字的地方都叫标识符。

• 命名规则

Scala中的标识符声明，基本和Java是一致的，但是细节上会有所变化，有以下三种规则：
1、以字母或者下划线开头，后接字母、数字、下划线
2、以操作符开头，且只包含操作符(+ - * / # ! 等)
3、用反引号`....`包括的任意字符串，即使是Scala关键字(39个)也可以
//package,import,class,object,trait,extends,with,type,for
//private,protected,abstract,sealed,final,implicit,lazy,override
//try,catch,finally,throw
//if,else,match,case,do,while,for,return,yield
//def,val,var
//this,super
//new
//true,false,null

• 案例

package day02

object Test03_Identifier {
  def main(args: Array[String]): Unit = {
//    1、以字母或者下划线开头，后接字母、数字、下划线
    val hello: String = ""
    var Hello123 = ""
    val _abc = 123
//    val h-b = "" //语法错误，这里IDEA不报错
//    val 123abc = 234
//    2、以操作符开头，且只包含操作符(+ - * / # ! 等)
    val -+/% = "hello"
    println(-+/%)
//    3、用反引号`....`包括的任意字符串，即使是Scala关键字(39个)也可以
//    val if = ""
    val `if` = "if"
    println(`if`)
  }
}

输出结果：
hello
if

字符串输出

• 基本语法

1、字符串，通过 + 号连接
2、printf用法：字符串，通过%传值
3、字符串模板（插值字符串）：通过$获取变量值

• 案例

package day02

object Test04_String {
  def main(args: Array[String]): Unit = {
//    1、字符串，通过 + 号连接
    val name: String = "liangzai"
    val age: Int = 24
    println(age + "岁的" + name + "在熬夜写博客")

    // * 用于将一个字符串复制多次拼接
    println(name * 3)

//    2、printf用法：字符串，通过%传值
    printf("%d岁的%s在熬夜写博客\n",age,name)

//    3、字符串模板（插值字符串）：通过$获取变量值
    println(s"${age}岁的${name}在熬夜写博客")

    val  num:Float = 3.1415F
    val num1:Double = 2.3456
    println(f"The num is ${num}")
    println(f"The num1 is ${num1}%2.2f")    //格式化模板字符串
    println(raw"The num1 is ${num1}%2.2f")  //原样输出

    // 三引号表示字符串，保持多行字符串的原格式输出
  val sql =  s"""
       |select *
       |from
       |  student
       |where
       |  name = ${name}
       |and
       |  age > ${age}
       |""".stripMargin
    println(sql)
  }
}

输出结果：
24岁的liangzai在熬夜写博客
liangzailiangzailiangzai
24岁的liangzai在熬夜写博客
24岁的liangzai在熬夜写博客
The num is 3.1415
The num1 is 2.35
The num1 is 2.3456%2.2f

select *
from
  student
where
  name = liangzai
and
  age > 24

键盘输入

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。

• 基本语法

StdIn.readLine()
StdIn.readShort()
StdIn.readDouble()

• 案例

需求：可以从控制台接收用户信息，【姓名、年龄、薪水】

package day02

import scala.io.StdIn
object Test05_StdIn {
  def main(args: Array[String]): Unit = {
    // 输入信息
    println("请输入您的姓名：")
    val name : String = StdIn.readLine()
    println("请输入您的年龄：")
    val age: Int = StdIn.readInt()

    // 控制台打印输出
    println(s"年轻${age}岁的${name}在熬夜写博客")
  }
}

输出结果：
请输入您的姓名：
靓仔
请输入您的年龄：
24
年轻24岁的靓仔在熬夜写博客

文件操作读、写

package day02

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

object Test06_FileIo {
  def main(args: Array[String]): Unit = {
    //1、从文件中读取数据
    Source.fromFile("src/main/resources/Test.txt").foreach(print)

    // 2、将数据写入文件
    val writer = new PrintWriter(new File("src/main/resources/Put.txt"))
    writer.write("Learn Hello Scala day day up!")
    writer.close()
  }
}

输出结果：
Hello world
Hello Java
Hello Shell
Hello SQL
Hello BigData
Hello Redis
Hello Hadoop
Hello HBase
Hello Scala

数据类型

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）的子类。

整数类型（Byte、Short、Int、Long）

Scala的整数类型就是用存放整数值的，比如18,24,3456 等等。

• 整型分类

• 案例

package day02

object Test07_DataType {
  def main(args: Array[String]): Unit = {
    // 1、整数类型
    val a1: Byte = 127
    val a2: Byte = -128

    //    val a2: Byte = 128 //error 超出类型范围

    val a3 = 18 //整数默认类型为Int
    //    val a4 = 12345678923456 //error 超出类型范围
    val a4 = 12345678923456L //长整型数值定义

    val b1: Byte = 10
    //    val b2: Byte = 10 + 20 // :Int 这里运行是不报错的，但是不能这么写
    val b2 = 10 + 20 //默认为Int类型
    println(b2)

//    val b3: Byte = (b1 + 20) //这里编译不通过
    val b3 = (b1 + 20).toByte
    println(b3)

    // 2、浮点类型
    val f1: Float = 3.14F //需要加F，不建议f(开发规范)
    val d1 = 3.1415 //默认double类型
  }
}

字符类型(Char)

• 1、基本说明

字符类型可以表示单个字符，字符类型是Char

• 2、案例
  • 字符常量是用单引号 ’ ’ 括起来的单个字符
  • \t ：一个制表位，实现对齐功能
  • \n : 换行符
  • \ : 表示\
  • " : 表示"

布尔类型：Boolean

• 基本说明
  • 布尔类型也叫Boolean类型，Boolean类型只允许取值true和false
  • Boolean类型占1个字节

package day02

object Test07_DataType {
  def main(args: Array[String]): Unit = {
    // 1、整数类型
    val a1: Byte = 127
    val a2: Byte = -128

    //    val a2: Byte = 128 //error 超出类型范围

    val a3 = 18 //整数默认类型为Int
    //    val a4 = 12345678923456 //error 超出类型范围
    val a4 = 12345678923456L //长整型数值定义

    val b1: Byte = 10
    //    val b2: Byte = 10 + 20 // :Int 这里运行是不报错的，但是不能这么写
    val b2 = 10 + 20 //默认为Int类型
    println(b2)

    //    val b3: Byte = (b1 + 20) //这里编译不通过
    val b3 = (b1 + 20).toByte
    println(b3)

    // 2、浮点类型
    val f1: Float = 3.14F //需要加F，不建议f(开发规范)
    val d1 = 3.1415 //默认double类型

    // 3、字符类型
    val c1: Char = 'a'
    println(c1)
    val c2: Char = '9' //字符9
    println(c2)

    //特殊字符
    val c3: Char = '\t' //制表符
    val c4: Char = '\n' //换行符
    println("abc" + c3 + "def")
    println("abc" + c4 + "def")

    // 转义字符
    val c5 = '\\' //表示\自身
    val c6 = '\"' //表示"
    println("abc" + c5 + "def")
    println("abc" + c6 + "def")

    //字符变量底层保存ASCLL码
    val i1: Int = c1
    println("i1:" + i1)
    val i2: Int = c2
    println("i2:" + i2)

    val c7: Char = (i1 + 1).toChar
    println(c7)
    val c8: Char = (i2 - 1).toChar
    println(c8)

    // 4、布尔类型
    val isTrue: Boolean = true
    println(isTrue)
  }
}

输出结果：
30
30
a
9
abc	def
abc
def
abc\def
abc"def
i1:97
i2:57
b
8
true

Unit类型、Null类型和Nothing类型

• 基本说明

• 案例

package day02

import day01.Student

object Test07_DataType {
  def main(args: Array[String]): Unit = {
    // 5、空类型
    // 5.1、空值Unit
    def m1(): Unit = {
      println("m1被调用执行")
    }

    val a = m1()
    println("a:" + a)

    // 5.2、空引用Null
    //    val n:Int = null //error 一个值不能接收空引用
    var student = new Student("laingzai", 24)
    student = null //引用类型
    println(student)

    //5.3、Nothing
    //    def m2(n: Int): Nothing = {
    //        throw new NullPointerException
    //    }
    def m2(n: Int): Int = {
      if (n == 0)
        throw new NullPointerException
      else
        return n
    }

    //异常抛出下面的打印并不执行
    val b: Int = m2(2)
    println("b:" + b)
  }
}

运行结果：
m1被调用执行
a:()
null
b:2

原码

final abstract class Unit private extends AnyVal {
  // Provide a more specific return type for Scaladoc
  override def getClass(): Class[Unit] = ???
}
object Unit extends AnyValCompanion {

  /** Transform a value type into a boxed reference type.
   *
   *  @param  x   the Unit to be boxed
   *  @return     a scala.runtime.BoxedUnit offering `x` as its underlying value.
   */
  def box(x: Unit): scala.runtime.BoxedUnit = scala.runtime.BoxedUnit.UNIT

  /** Transform a boxed type into a value type.  Note that this
   *  method is not typesafe: it accepts any Object, but will throw
   *  an exception if the argument is not a scala.runtime.BoxedUnit.
   *
   *  @param  x   the scala.runtime.BoxedUnit to be unboxed.
   *  @throws     ClassCastException  if the argument is not a scala.runtime.BoxedUnit
   *  @return     the Unit value ()
   */
  def unbox(x: java.lang.Object): Unit = x.asInstanceOf[scala.runtime.BoxedUnit]

  /** The String representation of the scala.Unit companion object. */
  override def toString = "object scala.Unit"
}

UNIT原码

package scala.runtime;


public final class BoxedUnit implements java.io.Serializable {
    private static final long serialVersionUID = 8405543498931817370L;

    public final static BoxedUnit UNIT = new BoxedUnit();

    public final static Class<Void> TYPE = java.lang.Void.TYPE;
    
    private Object readResolve() { return UNIT; }

    private BoxedUnit() { }

    public boolean equals(java.lang.Object other) {
	return this == other;
    }

    public int hashCode() {
	return 0;
    }

    public String toString() {
	return "()";
    }
}

类型转换

Java面试题（隐式类型转换）:

public class TestDataTypeConversion {
    public static void main(String[] args) {
        //自动类型转换原则
        byte b = 10;
        test(b);
        char c = 'a';
        test(c);
        short c2 = (short) c;
        test(c2);
    }

    public static void test(byte b) {
        System.out.println("bbbb");
    }

    public static void test(short s) {
        System.out.println("sssss");
    }

    public static void test(char c) {
        System.out.println("cccc");
    }

    public static void test(int i) {
        System.out.println("iiii");
    }
}

输出结果：
bbbb
cccc
sssss

Scala数值类型自动转换

当Scala程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数值类型，这个就是自动类型转换（隐式转换）。数据类型按精度（容量）大小排序为：

• 基本说明

1、自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算
2、把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换
3、(byte,short) 和 char 之间不会互相自动转换
4、byte,short ,char 他们三者可以计算，在计算时首先转换为int类型

• 案例

package day02

object Test08_DataTypeConversion {
  def main(args: Array[String]): Unit = {
    //    1、自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算
    val a1: Byte = 10
    val b1: Long = 2353
    val result1: Long = a1 + b1
    val result11: Int = (a1+b1).toInt //强制类型转换

    //    2、把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换
    val a2: Byte = 10
    val b2: Int = a2
//    val c2:Byte = b2 //error
    val c2: Byte = b2.toByte
    //    3、(byte,short) 和 char 之间不会互相自动转换
    val a3: Byte = 10
    val b3: Char = 'b'
//    val c3: Byte = b3 //error
    val c3: Int = b3
    println(3)

    //      4、byte,short ,char 他们三者可以计算，在计算时首先转换为int类型
    val a4: Byte = 18
    val b4: Short = 24
    val c4: Char = 'c'
//    val result4: Short = (a4 + b4)
    val result4: Int = a4 + b4
    val result44: Int = a4 + b4 + c4
    println(result4)
    println(result44)
  }
}

运行结果：
3
42
141

强制类型转换

• 基本说明

自动类型转换的逆过程，将精度大的数组类型转换为精度小的数值类型。使用时要加上强制转函数，但可能造成精度降低或溢出，要格外注意

Java : int num = (int)2.5
Scala : var num: Int = 2.5.toInt

• 案例

1、将数据由高精度转换为低精度，就需要使用到强制转换
2、强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级

package day02

object Test08_DataTypeConversion {
  def main(args: Array[String]): Unit = {
    // 2、强制类型转换
    //    1、将数据由高精度转换为低精度，就需要使用到强制转换
    val n1: Int = 2.5.toInt
    println("n1:" + n1)

    val n2: Int = -2.8.toInt
    println("n2:" + n2)

    //    2、强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
    val n3: Int = 2.6.toInt + 3.7.toInt //这样会造成数值精度丢失
    val n4: Int = (2.6 + 3.7).toInt
    println("n3:" + n3)
    println("n4:" + n4)

    // 3、数值类型和String类型的转换
    // (1) 数值转String
    val n: Int = 27
    //    val s:String = n.toString
    val s: String = n + ""
    println(s)

    // (2) String转数值
    val m: Int = "12".toInt
    val f: Float = "12.3".toFloat
    val f2: Int = "12.3".toDouble.toInt
    println(m)
    println(f)
    println(f2)
  }
}

运行结果：
n1:2
n2:-2
n3:5
n4:6
27
12
12.3
12

Scala面试题

package day02

/*
128 : Int类型，占4个字节，32位
原码: 0000 0000 0000 0000 0000 0000 1000 0000
补码: 0000 0000 0000 0000 0000 0000 1000 0000

截取最后一个字节，Byte
得到补码 1000 0000
表示最大负数 -128

130 : Int类型，占4个字节，32位
原码: 0000 0000 0000 0000 0000 0000 1000 0010
补码: 0000 0000 0000 0000 0000 0000 1000 0010

截取最后一个字节，Byte
得到补码 1000 0010
对应原码 1111 1110
-126
 */
object Test09_DataTypeConversion {
  def main(args: Array[String]): Unit = {
    val n: Int = 128
    val b: Byte = n.toByte
    println(b)

    val n1: Int = 130
    val b1: Byte = n1.toByte
    println(b1)
  }
}

运行结果：
-128
-126

到底啦！给靓仔一个三连吧！? つ ?_? ?つ