目录
变量和数据类型
代码规范
（1）使用tab实现缩进，默认整体向右移动；shift+tab整体向左移；
（2）使用ctrl + alt + L来进行格式化；
（3）运算符两边习惯性各加一个空格；
（4）一行最长不超过80个字符，超过的换行，尽量保持格式优雅。
变量和常量
常量：在执行过程中值不会被改变的量。
Java：变量和常量（回顾对比）
变量类型 变量名称 = 初始值 int a = 5
final常量类型 常量名称 = 初始值 final int a = 5
scala变量和常量
var 变量名 [：变量类型] = 初始值 var i:int = 5
val 常量名 [：常量类型] = 初始值 val j:int = 5
注：能够使用常量的地方不用变量。
object VarAndVal {
def main(args: Array[String]): Unit = {
//（1）声明变量时，类型可以省略，编译器会自动推导
var age = 18
age = 30
// age = "tom" // 错误
//（2）Scala是强数据类型,类型确定后不能修改
// var name //错误
//（3）变量声明时必须要有初始值
//（4）在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val 修饰的变量不可改
var num1 = 10 // 可变
val num2 = 20 // 不可变
num1 = 30 // 正确
// num2 = 100 //错误，因为num2是val修饰的
//（5）var,val对象的状态（值）可以改变的。（比如：自定义对象、数组、集合等等）
// var修饰的属性可以改变，本身也可以改变
var p1 = new Person()
p1.name = "ddd"
p1 = null
// val修饰的本身不可变，但是属性是可变，因为属性并没有用val修饰
val p2 = new Person()
p2.name="ppp"
}
}
class Person(){
var name : String = "zj"
}标识符的命名规范
Scala对各种变量、方法、函数等命名时使用的字符序列称为标识符。即：凡是自己可以命名的都叫标识符。
命名规则：Scala中的标识符声明，基本和Java是一致的，细节上有变化，有以下三种规则：
（1）以字母或者下划线开头，后接字母、数字、下划线；
（2）以操作符开头，必须只包含操作符（+ - * / # !等）；
（3）用反引号``包括的任意字符串，即使是Scala关键字（39个）也可以；
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）字符串通过+号连接；
（2）printf用法：字符串通过%传值；
（3）字符串模板（插入值字符串）：通过$获取变量值；
object CharType {
def main(args: Array[String]): Unit = {
var name: String = "jeffry"
var age: Int = 20
//（1）字符串通过+号连接
println(name + " " + age)
//（2）printf用法:字符串通过%传值
printf("name=%s age=%d\n", name, age)
//（3）字符串通过$引用
//多行字符串:用三个双引号包围就可以实现;
//在scala中stripMargin默认“|”作为连接符
val s =
"""
|这是多行字符串
| 空格
| 空格
|完成！
|""".stripMargin
println(s)
//如果需要对变量进行运算，那么可以加${}
val s1 =
s"""
|name="$name" and age=${age+2}
|""".stripMargin
println(s1)
val s2 = s"name=$name"
println(s2)
}
}
键盘输入
可以使用键盘输入语句来接收用户输入的数据。
基本语法：
StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()
import scala.io.StdIn
object Input {
def main(args: Array[String]): Unit = {
// 1 输入姓名 StdIn.readLine()
println("input name:")
var name = StdIn.readLine()
// 2 输入年龄 StdIn.readShort()
println("input age:")
var age = StdIn.readShort()
// 3 输入工资 StdIn.readDouble()
println("input sal:")
var sal = StdIn.readDouble()
// 4 打印
println("name=" + name)
println("age=" + age)
println("sal=" + sal)
}
}
数据类型
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]
|
8
位有符号补码整数。数值区间为
-128
到
127=2的（8-1）次方-1
|
|
Short [2]
|
16
位有符号补码整数。数值区间为
-32768
到
32767=2的（16-1）次方-1
|
|
Int [4]
|
32
位有符号补码整数。数值区间为
-2147483648
到
2147483647=2的（32-1）次方-1
|
|
Long [8]
|
64
位有符号补码整数。数值区间为
-9223372036854775808
到9223372036854775807=2的（64-1）次方-1
|
（1）Scala各整数类型有固定的表示范围和字段长度，不受具体操作的影响，以保证Scala程序的可移植性。
（2）Scala的整型，默认为Int型，声明Long型，须加‘l’或‘L’。
（3）Scala程序中变量常声明为Int型，不足以表示大数才会使用Long。
浮点类型
| 数据类型 | 描述 |
|
Float [4]
|
32
位，
IEEE754
标准的单精度浮点数
|
|
Double [8]
|
64
位，
IEEE754
标准的双精度浮点数
|
字符类型
char
字符类型可以表示单个字符，字符类型是Char
object Char {
def main(args: Array[String]): Unit = {
//（1）字符常量用单引号' '括起来
var c1: Char = 'a'
println("c1=" + c1)
//注意：涉及自动类型提升，编译器可以自定判断是否超出范围，idea报错不影响执行
var c2: Char = 'a' + 1
println("c2=" + c2)
//（2）\t ：一个制表位，实现对齐的功能
println("姓名\t年龄")
//（3）\n ：换行符
println("姓名\n年龄")
//（4）\\ ：表示\
println("c:\\user\\jeffry")
//（5）\" ：表示"
println("他说：\"好坏！好坏！！！\"")
}
}
布尔类型
Boolean
布尔类型也叫Boolean类型，占1个字节，数据只允许取true和false。
Unit类型、Null类型和Nothing类型
| 数据类型 | 描述 |
| Unit | 表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例()，这个实例也没有实质意义。 |
| Null | Null类型只有一个值null。 Null可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）。 |
| Nothing | Nothing类型在Scala的类型中层级最低，它是任何其他类型的子类型。当一个函数我们确定没有正常的返回值就可以用Nothing来指定返回类型，这样可以把返回的值（异常）赋给其它的函数或者变量（兼容性）。 |
类型转换
数值类型自动转换
Scala程序在进行赋值或者运算时，精度小的数值类型自动转换为精度大的数值类型，这个就是自动类型转换（隐式转换）。
数据类型按精度大小排序为：
object ValueTransform {
def main(args: Array[String]): Unit = {
//（1）自动提升原则：
// 有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的数值类型，然后再进行计算
var n = 1 + 4.0
println(n) // n就是Double
//（2）把精度大的数值类型赋值给精度小的数值类型时，会报错，反之就会进行自动类型转换
var n2 : Double= 1.0
//var n3 : Int = n2 //错误
println(n2)
//（3）（byte，short）和char之间不会相互自动转换。
var n4 : Byte = 1
//var c1 : Char = n4 //错误
var n5 : Int = n4
println(n4,n5)
//（4）byte，short，char三者可以计算，计算时转换为int类型
var n6 : Byte = 1
var c2 : Char = 1
var nn : Int = n6 + c2 //当n6 + c2结果类型是int
println(n6,c2,nn)
}
}
强制类型转换
强制类型转换是自动类型转换的逆过程，将精度大的数值类型转换为精度小的数值类型。使用时要加上强制转函数，但可能造成精度降低或溢出。
Java : int num = (int)2.5
Scala : var num : Int = 2.7.toInt
object ForceTransform {
def main(args: Array[String]): Unit = {
//（1）将数据由高精度转换为低精度需要使用强制类型转换
var n1: Int = 2.5.toInt
println(n1)
//（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
var r1: Int = 10 * 3.5.toInt + 6 * 1.5.toInt // 10 *3 + 6*1 = 36
var r2: Int = (10 * 3.5 + 6 * 1.5).toInt // 44.0.toInt = 44
println("r1=" + r1 + " r2=" + r2)
}
}
数值类型和string类型转换
我们经常需要将基本数值类型转成String类型。或者将String类型转成基本数值类型。
（1）基本类型转String类型
语法：将基本类型的值+"" 即可
（2）String类型转基本数值类型
语法：.toInt、.toFloat、.toDouble、.toByte、.toLong、.toShort
object StringTransform {
def main(args: Array[String]): Unit = {
//（1）基本类型转String类型
var str1 : String = true + ""
var str2 : String = 1.500 + ""
var str3 : String = 10 + ""
println(str1,str2,str3)
//（2）String类型转基本数值类型
var s1 : String = "123"
var n1 : Byte = s1.toByte
var n2 : Short = s1.toShort
var n3 : Int = s1.toInt
var n4 : Long = s1.toLong
var n5 : Float = s1.toFloat
var n6 : Double = s1.toDouble
println("s1=" + s1,"byte:" + n1,"short:" + n2,"int:" + n3,"long:" + n4,"float:" + n5,"double:" + n6)
}
}
注：在将String类型转成基本数值类型时，要确保String类型能够转成有效的数据，比如不能把"hello world"转成一个整数。
2571
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
