Scala变量和数据类型，整数、浮点、字符、布尔、Unit、Null和Nothing类型，类型转换、强制类型转换

NeilVicia

已于 2022-06-19 22:33:33 修改

阅读量681

点赞数 1

文章标签：大数据 scala

于 2021-11-26 22:15:02 首次发布

本文链接：https://blog.csdn.net/liuyongsheng666/article/details/121569700

版权

package chapter01

object demo1 {
  def main(args: Array[String]): Unit = {
    println("hello world")
    System.out.println("hello bigdata")
  }
}

package chapter01

object demo2 {
  def main(args: Array[String]): Unit = {
    println("hello maven")

    val a=2
    var b=29
    print(a*(b+a))
  }

}

package chapter01

class Student(name:String,var age:Int) {
  def printInfo():Unit={
    println(name+"\t"+age+"\t"+Student.school)
  }

}

//引入伴生对象
object Student{
  val school:String="njzb"

  def main(args: Array[String]): Unit = {
    val alice = new Student("alice",12)
    val bob = new Student("bob",20)
    alice.printInfo()
    bob.printInfo()
  }

}

package chapter02

object Test01_Comment {
  def main(args: Array[String]): Unit = {
    println("hello")
  }
}

package chapter02

import chapter01.Student

object Test02_Variable {
  def main(args: Array[String]): Unit = {
    //声明一个变量的通用语法
    var a: Int = 10
//    （1）	声明变量时，类型可以省略，编译器自动推导，即类型推导
    var a1 = 10
    val b1 = 23

//    （2）	类型确定后，就不能修改，说明 Scala 是强数据类型语言。
    var a2=15 //a2类型为Int
//    a2 ="hello"

//    （3）	变量声明时，必须要有初始值
//    var a3:Int
//    （4）	在声明/定义一个变量时，可以使用 var 或者 val 来修饰，var 修饰的变量可改变， val 修饰的变量不可改。
    a1=12

//    b1=25

    var alice = new Student("alice",20)
    alice=new Student("cat",24)
    var bob=new Student("bob",24)
    bob.age=25
    alice.printInfo()
    bob.printInfo()

package chapter02

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

    //1、以字母或者下划线开头 后接字母 数字 下划线
    //标识符的命名规范
    var hello:String=""
    var Hello123=""
    val _abc=123

//    val h-b=""
//    val 123abc=222

    //2、以操作符开头 且只包含操作符（+ - = 、# ！等）

    val -=+ ="hello"
    println(-=+)

    //（3）用反引号`....`包括的任意字符串，即使是Scala关键字（39个）也可以
    var `if`="aaa"
    println(`if`)





  }

}

package chapter02

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

    //（1）	字符串，通过+号连接
    val name:String="alice"
    val age:Int=18
    println(age+"岁的"+name+"在尚硅谷学习")

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


    //（2）	printf 用法：字符串，通过%传值。用某种格式化方法对字符串进行设计和设置
    //d Int s String   f格式化的意思

    printf("%d岁的%s在尚硅谷学习",age,name)
    println()


    //（3）	字符串模板（插值字符串）：通过$获取变量值
    //s"${}"模板字符串
    println(s"${age}岁的${name}在尚硅谷学习")

    val num:Double=2.3456
    println(f"The num is ${num}%2.3f") //格式化模板字符串
    println(raw"The num is ${num}%2.3f")


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

package chapter02

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}来学习")


  }
}

package chapter02

import java.io.{File, PrintWriter}

import scala.io.Source

object Test06_FileIO {
  def main(args: Array[String]): Unit = {
    //1.从文件中读取数据
    Source.fromFile("E:\\创建工程\\scalatest\\src\\main\\resources\\test.txt").foreach(print)


    //2.将数据写入文件
    val writer=new PrintWriter(new File("src\\main\\resources\\output.txt"))
    writer.write("hello world java writer")
    writer.close()

  }

}

package chapter02

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


    val a3 = 12 //整数默认类型为Int
    val a4 = 12345678999L  //长整型数值定义

    val b1:Byte = 10
    val b2:Byte =(10+20)
    println(b2)

    val b3:Byte=(b1+20).toByte
    println(b3)

    //2.浮点类型
    val f1:Float=1.2345f
    val d1=34.2245

    println(f1)
    println(d1)

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

    val c2:Char='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")

    //字符变量底层保存ASCII码
    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)



    //5.空类型
    //5.1 空值Unit

    def m1():Unit={
      println("m1被调用执行")
    }

    val a:Unit = m1()
    println(a)

    //5.2 空引用Null

//    val n:Int=null error 一个值类型 不能接收一个空引用
    var student:Student =new Student("zhangsan",20)
    student = null //student 可以赋值为null的前提 它是引用类型
    println(student)

    //5.3 Nothing
    def m2(n:Int):Int={  //定义公共父类 范围越小越好 所以不是Any 而是Int
      if(n==0)
        throw new NullPointerException
      else
        return n //if else 返回类型的公共父类 即不能是Nothing 因为Nothing是所有类型的子类
    }

    val b:Int =m2(100)
    println(b)





  }

}

package chapter02

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

    //一、自动类型转换
    //1）	基本说明（1）自动提升原则：有多种类型的数据混合运算时，
    // 系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。
    val a1:Byte=10
    val b1:Long=2353L
    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:Byte=b3.toByte
    val c3:Int=b3
    println(c3)

    //（4）	byte，short，char 他们三者可以计算，在计算时首先转换为 int 类型。
    val a4:Byte=12
//    val b4:Short=a4 //error
    val b4:Short=25
    val c4:Char='c'
    val result4:Int=a4+b4
    val result44:Int=a4+b4+c4
    println(result4)
    println(result44)

    //二、强制类型转换

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


    //3.数值类型和String类型的转换
    //(1)数值转String
    val n:Int=27
    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(f2)






  }

}

package chapter02
/*
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位 130比128多了2 0010
源码 0000 0000 0000 0000 0000 0000 1000 0010
补码 0000 0000 0000 0000 0000 0000 1000 0010

截取最后一个字节 Byte
得到补码 1000 0010
对应源码 1111 1110
-126
 */

//做强制类型转换后 正数变负数 范围溢出 128得到-128 130比128大2 转换之后 溢出的也比-128大2
//强制类型转换 会造成精度的缺失或者数据的溢出
//byte -128到127
object Test09_Problem_DataTypeConversion {
  def main(args: Array[String]): Unit = {
    val n:Int=130
    val b:Byte=n.toByte
    println(b)
  }


}

NeilVicia

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Scala变量和数据类型，整数、浮点、字符、布尔、Unit、Null和Nothing类型，类型转换、强制类型转换

package chapter01object demo1 { def main(args: Array[String]): Unit = { println("hello world") System.out.println("hello bigdata") }}package chapter01object demo2 { def main(args: Array[String]): Unit = { println("hello maven").
复制链接

扫一扫