package chapter01
/*
object:关键字,声明一个单例对象(伴生对象)
*/
object HelloWorld {
/*
main方法:从外部可以直接调用执行的方法
def 方法名称(参数名称:参数数据类型):方法返回值类型 = { 方法体 }
Scala中的泛型是用[]表示的
void用Unit代替
*/
def main(args: Array[String]): Unit = {
println("hello world")
}
}
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();
}
}
控制台标准输入
导入包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()
}
}
变量和数据类型
能使用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 //报错
注意,当用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""表示后面引号中是一串字符串模板,${变量名}
}
}
另外还有个格式化模板字符串,当我们想要输出一个高精度小数,但又需要四舍五入时
此时输出: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
整数类型
注意:定义Long型变量的时候,要在数据后面加个L。否则系统默认是将一个Int类型的数据赋值给一个Long型的变量。这样会报错。
//整数默认类型为Int 所以数据后面要加上L
val a:Long=123456789566L
//float和double
//定义小数时,默认是double类型,所以如果想要定义成float,在数据后面加f
val f1 : Float=1.235f
val d1=25.36 //double类型
字符类型
字符类型底层存储的是数字,因为是对应字符的ascll码值。
布尔类型
var flag1:Boolean=true
var flag2:Boolean=false
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
类型转换
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);
}
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)
scala强制类型转换
1.高精度转低精度时要用到强制类型转换。可能会导致部分数据的丢失,直接截断而不是向上向下取整、四舍五入取整等。
var a=2.63
var b=a.toInt //b=1
2.强转符号只针对最近的操作数有效
var a=1.63
var c=5.3
var b=c+a.toInt //b=6.3
//也可以用括号将要强制转换的部分括起来
var b=(a+c).toInt //b=6
3.数值与String类型转换
12.3要转换成Int类型得先转为double型