输入输出、文件读写、数据类型

package chapter01
/*
object:关键字，声明一个单例对象（伴生对象）
 */
object HelloWorld {
  /*
  main方法：从外部可以直接调用执行的方法
  def 方法名称（参数名称：参数数据类型）:方法返回值类型 = { 方法体 }
  Scala中的泛型是用[]表示的
  void用Unit代替
   */
  def main(args: Array[String]): Unit = {
    println("hello world")
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Scala中的object声明的是单例对象，也叫伴生对象，意思是跟另外一个类相伴相生。
在java中，若是要声明一个静态变量，可以在A类中用public static String s=" ";则使用该对象时： A.s 这样引用的是类而非对象。所以在Scala中删去了关键字static，而是直接用object声明一个单例对象。
在java中将静态变量声明在类中，引用：类名.变量名
而在Scala中，将该变量声明在类的伴生对象中，引用：对象名.变量名
这样就做到了面向对象。
java和Scala代码对比：

//java
public class test01 {
    public static String s="123";
    public static void main(String[] args) {
        System.out.println(test01.s);
    }
}

//Scala
package chapter01

class Student(name:String,age:Int){
  def printlnfo():Unit={
    println(name+" "+age+" "+Student.school)
  }
}
//定义一个Student类的伴生对象
object Student{
  val school:String="atguigu"

  def main(args: Array[String]): Unit = {
    var alice=new Student("allic",20)
    var bob=new Student("bob",15)
    alice.printlnfo();
    bob.printlnfo();
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

控制台标准输入

导入包import scala.io.StdIn

读写文件

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

object Student{
  def main(args: Array[String]): Unit = {
    //读取文件数据
    Source.fromFile("src/main/resources/test.txt").foreach(print);
    //写入数据
    val writer=new PrintWriter(new File("src/main/resources/test1.txt"))
    writer.write("helloaaaa")
    writer.close()
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

变量和数据类型

能使用val常量的地方就不要用变量var

//声明变量，值可以修改 variable
var i:Int=10   
//声明常量，值不可修改 value
val i:Int=10

//1.声明变量时，类型可省略，编译器自动推导，也就是类型推导
var a1=10
val a2=100

//2.类型确定后不可修改 说明Scala是强数据类型语言
var a1=10
a1="ggg"//报错

//3.声明变量时必须要有初始值
var a:Int //报错
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

注意，当用val声明了一个对象时，该常量的值也就是对象不能直接赋值成其他对象。但该对象的属性值可以改变（当然这里也要看属性值是变量还是常量）

字符串

object Student{
  def main(args: Array[String]): Unit = {
    //1.字符串通过+拼接
    val name:String="alice"
    val age:Int=10
    println(age+"岁的"+name+"在学校")
    //10岁的alice在学校

    //2.用*将字符串拼接多次
    println(name*3)//alicealicealice

    //3.printf:格式化输出 跟c语言用法一样
    printf("%d岁的%s在学校",age,name)

    //4.字符串模板（插值字符串）：通过$获取变量值
    println(s"${age}岁的${name}在学校")
    //s""表示后面引号中是一串字符串模板，${变量名}
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

另外还有个格式化模板字符串，当我们想要输出一个高精度小数，但又需要四舍五入时

此时输出:The num is 2.35
将s " "改成f " "，在变量${ }后面加上%2.2f。小数点前面那个2表示输出的值总长度为2（包括小数点），不够则整数部分前面补空格。小数点后面那个2表示输出的值精确到小数点后两位（四舍五入）。

若是println(raw" ")表示按双引号的内容直接输出，不做精确处理

//raw表示未加工的
val num:Double =2.3456
println(raw"The num is ${num}%2.2f")
//输出：The num is ${num}%2.2f
1
2
3
4

整数类型

注意：定义Long型变量的时候，要在数据后面加个L。否则系统默认是将一个Int类型的数据赋值给一个Long型的变量。这样会报错。

//整数默认类型为Int 所以数据后面要加上L
val a:Long=123456789566L
1
2

//float和double
//定义小数时，默认是double类型，所以如果想要定义成float，在数据后面加f
val f1 : Float=1.235f
val d1=25.36 //double类型
1
2
3
4

字符类型

字符类型底层存储的是数字，因为是对应字符的ascll码值。

布尔类型

var flag1:Boolean=true
var flag2:Boolean=false
1
2

Unit类型、Null类型、和Nothing类型

当程序出现异常，不返回任何值时，就用Nothing接收，因为异常不返回值，所以不能用null。

值类型不能赋值为null

var n=15
n=null //报错

var n:Int=null //报错

//空引用null
var student : Student = new Student("alice",20)
student = null 
1
2
3
4
5
6
7
8

类型转换

Java中自动类型转换

public static void main(String[] args){
    byte b=10;
    test(b);
}
public static void test(short b){
    System.out.print(b);
}
public static void test(char b){
    System.out.print(b);
}
public static void test(int b){
    System.out.print(b);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

byte是一个字节，short两个，int四个。因为方法中没有byte类型，只能将b自动转换成short类型，要是没有short类型就转换成int类型。而char是字符型，跟字节不属于一个类别，所以byte不会转换成char。如果只剩下char那个方法了，则会报错。

scala中自动类型转换
和java中大致相同

基本规则说明：

val a : Byte = 1
val b : Long = 2355
val c : Int= a + b  //报错，因为b是Long型，高精度赋值给低精度会报错
val c : Long = a + b //低精度a转高精度，可以
val c : Int = (a + b).toInt //强转，可以

val a:Byte=1
val b:Char='b'
val c:Byte=b //报错，（byte，short）和char之间不会互相自动转换
val c:Byte=b.toByte //强转，可以
var d:Int=a+b //可以，byte，short，char之间计算时先转换为int类型
println(a)
1
2
3
4
5
6
7
8
9
10
11
12

scala强制类型转换
1.高精度转低精度时要用到强制类型转换。可能会导致部分数据的丢失，直接截断而不是向上向下取整、四舍五入取整等。

var a=2.63
var b=a.toInt //b=1
1
2

2.强转符号只针对最近的操作数有效

    var a=1.63
    var c=5.3
    var b=c+a.toInt //b=6.3
    //也可以用括号将要强制转换的部分括起来
    var b=(a+c).toInt //b=6
1
2
3
4
5

3.数值与String类型转换


12.3要转换成Int类型得先转为double型