标签：String val Scala Int 基础 Oop1 println 操作 def
数据类型| 数据类型 | 描述 |
| Byte | 8位有符号补码整数。数值区间为 -128 到 127 |
| Short | 16位有符号补码整数。数值区间为 -32768 到 32767 |
| Int | 32位有符号补码整数。数值区间为 -2147483648 到 2147483647 |
| Long | 64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807 |
| Float | 32 位, IEEE 754 标准的单精度浮点数 |
| Double | 64 位 IEEE 754 标准的双精度浮点数 |
| Char | 16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF |
| String | 字符序列 |
| Boolean | true或false |
| Unit | 表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。 |
| Null | null 或空引用 |
| Nothing | Nothing类型在Scala的类层级的最底端；它是任何其他类型的子类型。 |
| Any | Any是所有其他类的超类 |
| AnyRef | AnyRef类是Scala里所有引用类(reference class)的基类 |
变量声明
在学习如何声明变量与常量之前，我们先来了解一些变量与常量。- 一、变量： 在程序运行过程中其值可能发生改变的量叫做变量。如：时间，年龄。
- 二、常量 在程序运行过程中其值不会发生变化的量叫做常量。如：数值 3，字符'A'。
变量类型引用
在 Scala 中声明变量和常量不一定要指明数据类型，在没有指明数据类型的情况下，其数据类型是通过变量或常量的初始值推断出来的。 所以，如果在没有指明数据类型的情况下声明变量或常量必须要给出其初始值，否则将会报错。 var myVar = 10 ; val myVal = "Hello, Scala!" ; 以上实例中，myVar 会被推断为 Int 类型，myVal 会被推断为 String 类型。Scala 多个变量声明
Scala 支持多个变量的声明： val xmax , ymax = 100 // xmax, ymax都声明为100 如果方法返回值是元组，我们可以使用 val 来声明一个元组： scala > val pa = ( 40 , "Foo" ) pa : ( Int , String ) = ( 40 , Foo ) object ScalaDemo { def main(args:Array[String]):Unit={ val name="James" println(s"Hello,$name") println(s"1+1=${1+1}") val height=1.9d val height1=1.32d val height2=1.5d val salary=2000.38 val name1="liSan" val name2="zhang" val salary1=400000 val salary2=4000.38 println(f"$name%s is $height%4.2f meters tall，月薪：$salary%9.2f 元") println(f"$name1%s is $height1%4.2f meters tall，月薪：$salary1%9.2f 元") println ( f" $ name2 %s is $ height2 %4.2f meters tall，月薪： $ salary2 %9.2f 元" ) 运行结果 Hello,James 1+1=2 James is 1.90 meters tall，月薪： 2000.38 元 liSan is 1.32 meters tall，月薪：400000.00 元 zhang is 1.50 meters tall，月薪： 4000.38 元 在控制台输入数字 println("请输入数字：") val num =StdIn.readInt() for循环 fo'r(i<-0 until 10)print(i）//从0到9 fo'r(i<-0 to 10)print(i）//从0到10 fo'r(i<-0 until 10 reverse)print(i）//从9到0 元组 val tp=(1,"hello","d")//最长22个 println(tp._1)--->1 println(tp._2)--->hello println(tp._3)--->d 遍历元组 1.def p:Iterator[Any]={tp.productIterator}//val p: Iterator[Any]=tp.productIterator//val p =tp.productIterator for(in<-p){//迭代器 println(in) } 2.tp.productIterator.foreach(x=>println(x))//增强for 二元组置换（特殊） val t=new t1[String,Int]("chen",26)// val t= ("chen",26) println(t._1,t._2) val swap: (Int, String) = t.swap//置换,二元组特殊方法，其他没有 println(swap._1,swap._2) println(swap._1) 部分函数 def alarmMsg(title:String,content:String,height:Double):Unit={ println(title+"\t"+content+":"+height) } alarmMsg("警报","空气甲醛浓度",21.42d)---> 警报 空气甲醛浓度为:21.42 val title="警报" def alarmMsg2=alarmMsg(title,content:String,height:Double) alarmMsg2("空气甲醛浓度为：",21.43d)---> 警报 空气甲醛浓度为:21.32 def alarmMsg3=alarmMsg(content,height:Double) alarmMsg3(12.45d) ---> 警报 空气甲醛浓度为:21.32 偏函数 def funPartition2:PartialFunction[Int,String]={ case 1=>"优秀" case 2=>"良好" case 3=>"合格" case _=>"不及格" } println(funPartition2(3))---->合格 println(funPartition2(4))---->不及格 val arr:Array[Int]=Array(1,3,4,3,2) val strings:Array[String] = arr.collect(funPartition2) 遍历 println(strings.toList) 或 for(in<-strings){ println(in) } 函数作为返回值 def funTest():(String,String)=>String={ def funDemo(str:String,str1:String):String={ str+"@@"+str1 } funDemo } println(funTest()("hello","world")) 函数作为参数 def funTest1(f:(Int,Int)=>Int)):Int={ val a=100 val b=50 f(a,b) } val sum=(a:Int,b:Int)=>a+b val ji=(a:Int,b:Int)=>a*b println(sum(2,3))---->5 println(funTest(sum)))---->150 println(funTest(ji)))---->5000 递归函数 def ji(num:Int):Int{ if(num==1) 1 else num*ji(num-1) } 样例类+模式匹配 case class Teachers(name:String,age:Int) def match3(teacher:Teachers):Unit={ teacher match{ case Teachers("zs",age)=>println("hello"+age) case Teachers("kb15",4)=>println("kb15学习4个月") case Teachers(name,32)=>println("名字"+name+"年龄"+32) } } match3(Teachers("kb15",4)) def match4(level:String,name:String):Unit={ level match{ case "A"=>println("优秀") case "B"=>println("良好") case "C" if name=="zs"=>println("合格") case "C"=>println("合格") case _ if name=="bolo"=>println("特殊学生") case _=>println("不及格") } } match4("A","zs") 隐式类implicit 1.直接在object +类名{}中写 2.新建一个隐式类，然后在直接import 包名.类名._ 引用 使用类 package cn.kgc import cn.kgc.Impliciteg._ class ImplicitDemo{} object ImplicitDemo { val a:Int="3" val b:String=3 val c:Double="3.5" //调用函数有隐式参数的方法时 传值>隐式参数>大于默认值 def sum(a:Int)(implicit b:Int):Int={ //隐式参数必须写在后面,且同类型只能出现一个 val sum1: Int = a + b println(str+" "+sum1) sum1 } println(sum(1)) //sum(1) val i: Int = sum(10) //println(i) //val j: Int =sum(10)(2)//已传入参数为主 // println(j) val demo=new ImplicitDemo // private val i1: Int = demo.ji(10, 20) println(demo.ji(10, 20)) // private val str1: String = demo.madeString("kb15") println(demo.madeString("kb15")) def main (args:Array[String]):Unit={} } 隐式类 object Impliciteg { implicit val num:Int=10//隐式参数 implicit val str:String="hello" implicit def stringToInt(value:String):Int={ Integer.parseInt(value) } implicit def intToString(value:Int):String={ value.toString } implicit def stringToDouble(value:String):Double={ //Integer.parseInt(value).toDouble java.lang.Double.parseDouble(value) } implicit class numOperation(implicitDemo: ImplicitDemo){ def ji(a:Int,b:Int):Int={ println("进入隐式类",a,b) a*b } } implicit class tringOperation(implicitDemo: ImplicitDemo){ def madeString(str:String):String={ str+" "+str.length } } } 构造参数 package cn.kgc //伴生类 class Oop1 (name:String,age:Int){//scala默认的主构造函数 private var uname:String=name private var uage :Int=age private var uaddress:String=_ def this(){ this(" ",0) println("无参") } def this(name:String){ this(name,0) } def this(age:Int){ this("",0) } def this(name:String,age:Int,address:String){ this(name,age) this.uaddress=address } def showMsg():Unit={ println("进入到Oop1 class showMsg()方法中") println(this.uname,this.age,this.uaddress) Oop1.showObjectMsg println(Oop1.like) println("进入到Oop1 class showMsg()方法，最后一行") } } //伴生对象 object Oop1{ private var like:String="篮球" def sum(a:Int,b:Int):Int={ println(a,b) a+b } def showObjectMsg()={ println("Object Oop1 showOjbectMsg") } //加上可以省去new对象 def apply(name: String, age: Int): Oop1 = new Oop1(name, age) def apply(name: String): Oop1 = new Oop1(name) def apply(age: Int): Oop1 = new Oop1(age) def apply(): Oop1 = new Oop1() def apply(name: String, age: Int, address: String): Oop1 = new Oop1(name, age, address) def main(args:Array[String]):Unit={ println("main") // val oop=new Oop1("chen",26) val oop2 = new Oop1 // val oop3 = new Oop1("kb11") // val oop4 = new Oop1(12) // val oop5 = new Oop1("gree", 21, "安德门") oop2.showMsg val opp6=Oop1 val opp7=Oop1("zs") println("main end") // println(oop.uname) } }标签：String,val,Scala,Int,基础,Oop1,println,操作,def 来源： https://blog.csdn.net/w_mchen/article/details/121705132
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。