2.变量和数据类型

2.1 注释

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

2.2 变量和常量

-变量：在程序执行过程中，其值可以改变
-常量：在程序执行过程中，其值不可以改变
-Java
	 >变量
		数据类型 变量名 = 值
    	int a = 10
  	>常量
   		final 数据类型 变量名 = 值
-Scala
	>变量
  		var 变量名:数据类型 = 值
 		var a:Int = 10
 	>常量
   		val 变量名:数据类型 = 值
  		val a:Int = 10

//（1）声明变量时，类型可以省略，编译器自动推导，即类型推导
    var a = 10  //默认整形为Int、默认浮点型为Double
    println(a)
//（2）类型确定后，就不能修改，说明Scala是强数据类型语言
    var a:Int = 10
    a = "abc"   //错误用法，数值型不可以转换为字符串
//（3）声明变量时，必须要有初始值（）
    //Java中局部变量需要初始化，成员变量有默认值
    var a:Int    //错误用法，没有初始化
    println(a)
//（4）在声明定义一个变量时，可以使用var或者val来修饰，var修饰的变量可以改变，val修饰的变量不可以改变
    var a:Int = 10
    val b:Int = 20
    a = 30
    b = 40   //b的类型为常量不可以改变
//（5）var修饰的对象引用可以改变，val修饰的对象则不可以改变，但对象的状态(值)却是可以改变的。(比如：自定义对象、数组、集合等等)
    var student1 = new Student
    student1 = new Student()   //错误用法
    val student2 = new Student
    student2 = new Student()
    student1.name = "lisi"
    student2.name = "lisi"
 //（6）在实际开发的过程中，优先选择var和val中的谁？
    //优先选择val(val用的多一点)
    val s:String = "abc"

2.3 标识符的命名规范

定义：凡是可以自己命名的地方都叫标识符
（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

// （1）以字母或者下划线开头，后接字母、数字、下划线
    var hello: String = "" // ok
    var Hello12: String = "" // ok
    //var 1hello: String = "" // error 数字不能开头
    //var h-b: String = "" // error   不能用-
    //var x h: String = "" // error   不能有空格
    var h_4: String = "" // ok
    var _ab: String = "" // ok
    //var Int: String = "" // ok 因为在Scala中Int是预定义的字符,不是关键字，但不推荐

    var _: String = "hello" // ok 单独一个下划线不可以作为标识符，因为_被认为是一个方法
    //println(_)

//（2）以操作符开头，且只包含操作符（+ - * / # !等）
    var +*-/#! : String = "" // ok
    //var +*-/#!1 : String = "" // error 以操作符开头，必须都是操作符

//（3）用反引号`....`包括的任意字符串，即使是Scala关键字（39个）也可以
    //var if : String = "" // error 不能用关键字
    var `if` : String = "" // ok 用反引号`....`包括的任意字符串,包括关键字

2.4 字符串输出

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

//  （1）字符串，通过+号连接
    var name:String = "jingjing"
    var age:Int = 18
    println(age + "岁的" + name + "在200105班级学习")
//  （2）printf用法：字符串，通过%传值。
    //printf("%d岁的%s在200105班级学习", age, name)
//  （3）字符串模板（插值字符串）：通过$获取变量值
    //println(s"${age}岁的${name}在200105班级学习")
    var sql:String =
    s"""
      |select
      |	*
      |from
      |	student
      |where
      |	name = ${name}
      |and
      |	age = ${age}
      """.stripMargin   //加上.stripMargin不顶行首
    println(sql)

2.5 键盘输入

基本语法
	StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()

	println("请输入你的芳名：")
    val name:String = StdIn.readLine()
    println("请输入你的芳龄：")
    val age:Int = StdIn.readInt()
    println(s"欢迎${age}的${name}来尚谷学习")

2.6 数据类型

Java基本类型
	byte、short、int、long、float、double、char、boolean
Java基本包装类
	Byte、Short、Integer、Long、Float、Double、Boolean、Character

2.6.1

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

2.6.2 整数类型

Scala各整数类型有固定的表示范围和字段长度，不受具体操作的影响，以保证Scala程序的可移植性
Scala的整型，默认为Int型，声明Long型，须后加‘l’或‘L’
Scala程序中变量常声明为Int型，除非不足以表示大数，才使用Long

 // 正确
        var n1:Byte = 127
        var n2:Byte = -128
 // 错误
        // var n3:Byte = 128
        // var n4:Byte = -129

2.6.3 浮点类型

Scala的浮点型常量默认为Double型，声明Float型常量，须后加‘f’或‘F’

var n7 = 2.2345678912f
var n8 = 2.2345678912
println("n7=" + n7)
println("n8=" + n8)

2.6.4 字符类型

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

//（1）字符常量是用单引号 ' ' 括起来的单个字符。
        var c1: Char = 'a'
        println("c1=" + c1)
		//注意：这里涉及自动类型提升，其实编译器可以自定判断是否超出范围，
    	//不过idea提示报错
		var c2:Char = 'a' + 1
		println(c2)     
//（2）\t ：一个制表位，实现对齐的功能
        println("姓名\t年龄")
//（3）\n ：换行符
        println("西门庆\n潘金莲")
//（4）\\ ：表示\
        println("c:\\岛国\\avi")
//（5）\" ：表示"
        println("同学们都说：\"大海哥最帅\"")

2.6.5 布尔类型

布尔类型也叫Boolean类型，Booolean类型数据只允许取值true和false
boolean类型占1个字节。

var isResult : Boolean = false
var isResult2 : Boolean = true

2.6.6 Unit类型

Unit类型用来标识过程，也就是没有明确返回值的函数。
由此可见，Unit类似于Java里的void。Unit只有一个实例——( )，这个实例也没有实质意义

		def sayOk : Unit = {// unit表示没有返回值，即void
        }
        println(sayOk)
	
	//null可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）
        var cat = new Cat();
        cat = null	// 正确
        var n1: Int = null // 错误
        println("n1:" + n1)

2.7 类型转换

2.7.1自动类型转换

（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。
    var b1:Byte = 10
    var n:Long = 20L
    var res = n + b1
（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
    var b:Byte = 10
    var n:Int = b   //将精度小的数据赋值给精度大的数据，会自动类型转换（隐式转换）
    var b1:Byte = n  //将精度大的数据赋值给精度晓得数据，报错
（3）（byte，short）和char之间不会相互自动转换。
    var b:Byte = 10
    var c:Char = b
    val c:Char = 96
    val n:Int = c
（4）byte，short，char他们三者可以计算，在计算时首先转换为int类型。
    var b:Byte = 10
    var s:Short = 20
    var c:Char = 30
    val i = b + s + c

2.7.2强制类型转换

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

// （1）将数据由高精度转换为低精度，就需要使用到强制转换
		var n:Int = 2.5.toInt
		println(n)
// （2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
    	var n:Int = 2.5.toInt +3.6.toInt
    	var n:Int = (2.5 + 3.6).toInt

2.7.3 数值类型向String转换

//数值类型和String类型间转换
   	 	//数值---->字符串
    	var n = 10 + ""

    	//字符串----->数值
		var res = "12.3".toInt   //报错NumberFormatException
		println(res)
   	 	var res = "12.3".toDouble.toInt
    	println(res)

2.8 强制转换面试题

package com.atguigu.scala.chapter02

/**
 * 强转面试题
 *
 * 128在scala中默认是Int类型，应该有32位  （正数 源码，反码，补码一样）
 * 源码 0000 0000 0000 0000 0000 0000 0000 0000 1000 0000
 * 补码 0000 0000 0000 0000 0000 0000 0000 0000 1000 0000
 *
 * 负数补码：1000 0010  反码：0111 1101   源码：0111 1110
 *
 * 转Byte 对Int数据进行截取，剩8位
 *  补码  1000 0000   （负数）约定当前这个值为这个范围的最小值   取反+1
 *        0000 0000    （0）
 *
 * 源码 1000 0000 0000 0000 0000 0000 0000 0000 1000 0010
 * 反码 1111 1111 1111 1111 1111 1111 1111 1111 0111 1101  +1 ->
 * 补码 1111 1111 1111 1111 1111 1111 1111 1111 0111 1110
 *
 * 截取 补码： 0111 1110 ——> 源码 ：0111 1110   126
 */
object Scala08_DataType {
  def main(args: Array[String]): Unit = {
	//var b:Byte = 128.toByte      //-128
   // var b:Byte = 130.toByte      //-126
    var b:Byte = (-130).toByte    //126
  }
}