l5手机网站模板宣传网页制作
Scala编程基础
Scala：简洁优雅，函数式编程之美。
今天的目录有点长
目录
Scala编程基础
1.Scala创建类
2.Scala定义变量
3.val与var区别（考试）
4.scala数据类型（考试）
5.Scala条件表达式（选择题）
6.块表达式
7.循环
1）练习（菜就多练）：
2）代码改进
3）for循环中加判断条件
8.Scala函数式编程（核心）
1）Scala定义方法
①注意:
②练习1
③练习2
2）Scala定义函数
①重要思想
②练习：
③函数的声明及调用
④练习：
⑤Scala中map用法
3）方法转化为函数
说在前面
在Scala中 任何数据都是对象
在Scala中 所有的算数运算符都是方法
1.Scala创建类
Scala中将动态方法和静态方法分开了
Class类：放动态方法
Object类：放静态方法（static 比如main函数）
2.Scala定义变量
package com.oracle.jt
/*** Object中类方法都是静态的*/
object Test {def main(args: Array[String]): Unit = {print("山东人民万岁！")//定义变量的格式：[val|var] 变量名[:数据类型]=值;//scala能自己识别数据类型val a=23val b="ff"val c:String="33";var d="wangwu";var e=33.333//var val区别：val不能重新赋值d="wangfeng" //var可以重新赋值 是真正的变量print(a,b,c,d,e)}
}
3.val与var区别（考试）
val变量值不能更改 不能重新赋值 var变量的值可以更改
4.scala数据类型（考试）
Scala 和 Java 一样，有7种数值类型 Byte、char、Short、Int、Long、Float 和 Double(无包
装类型)和一个 Boolean 类型。没有包装类
package com.oracle.jtobject Test2 {def main(args: Array[String]): Unit = {val v1:Int=23;val v2:Float=34.5f;val v3:Double=34.8d;val v4:Long=23;val v5:Short=23;val v6:Byte=23;val v7:Char='f'val v8:Boolean=trueprint(v1,v2,v3,v4,v5,v6,v7,v8)}}
5.Scala条件表达式（选择题）
条件表达式： 在给一个变量赋值的时候 大家有没有见到过一个变量的取值 在不同的条件下 变量的值是不一样的如果结果不符合条件表达式 那么 控制台将输出 ( )
package com.oracle.jtobject Test3 {def main(args: Array[String]): Unit = {//条件表达式：//在给一个变量赋值的时候 大家有没有见到过一个变量的取值//在不同的条件下 变量的值是不一样的var b=23var a=if(b>20) 56 else 90;println(a)val c=if(b>50) 90print(c)//如果不符合条件 打印括号（）}
}
package com.oracle.jtobject Test3 {def main(args: Array[String]): Unit = {//条件表达式：//在给一个变量赋值的时候 大家有没有见到过一个变量的取值//在不同的条件下 变量的值是不一样的val str="aa"val f=if(str.equals("aa")) "fff" else "sss"print(f)//如果不符合条件 打印括号（）}
}
package com.oracle.jtobject Test3 {def main(args: Array[String]): Unit = {//条件表达式：//在给一个变量赋值的时候 大家有没有见到过一个变量的取值//在不同的条件下 变量的值是不一样的val a=2;val b=3;val c=if(a+b==5) 66 else 99;print(c)//如果不符合条件 打印括号（）}
}
6.块表达式
在Scala中 最后一行变量是用来赋值 或者当作返回值的
package com.oracle.jtobject Test4 {def main(args: Array[String]): Unit = {val a={//print(0.to(10).toBuffer)var b=0//求0-10的累加和for(a <- 0.to(10)){b=b+a}b // b放在for循环外 表示把b的值赋给a} //{} 块print(a)}}
7.循环
Scala中 for循环是用来遍历集合的
后面只能跟集合
Java中for循环是用来控制循环次数的
package com.oracle.jtobject Test6 {def main(args: Array[String]): Unit = {var a=Array(3,4,5,6,7)//Array()就是Java的数组//for(变量名<-集合){}for(elm<-a){println(elm)}}}
在Scala中 任何数据都是对象
//如果我想Java那样用for循环生成一串数字 那就只能使用下面的方法//var b=Array(0,1,2,3,4,5,6,7,8,9)var b1=0.until(10) //产生左闭右开的区间数字var b2=0.to(10) //产生闭开区间数字print(b1)println(b2)
1）练习（菜就多练）：
求1-100累加和 求1-100偶数和
package com.oracle.jtobject Test7 {def main(args: Array[String]): Unit = {val sum= {var s=0var s1=0for(sum<-0.to(100)){s=s+sum}s}println(sum)val sum2={var s= 0for(sum2<-0.to(100)){if(sum2%2==0) s=s+sum2 else s=s+0}s}print(sum2)}}
2）代码改进
package com.oracle.jtobject Test7 {def main(args: Array[String]): Unit = {val sum= {var s=0var s1=0for(sum<-0.to(100)){s=s+sum}s}println("1-100的累加和为："+sum)val sum2={var s= 0for(sum2<-0.to(100)){if(sum2%2==0) s=s+sum2 else s=s+0}s}println("1-100的偶数和为："+sum2)val sum3={var s= 0for(sum3<-0.to(100)){if(sum3%2==1) s=s+sum3 else s=s+0}s}print("1-100的奇数和为："+sum3)}
}
3）for循环中加判断条件
在for循环中 我们可以加判断条件 这样的话 对于求偶数和就变得更简单了
package com.oracle.jtobject Test8 {def main(args: Array[String]): Unit = {val a=1.to(10)var b=0for(elm <- a;if(elm%2==0)){b=b+elmprintln(elm)}print(b)}
}
8.Scala函数式编程（核心）
在Scala中 所有的算数运算符都是方法
package com.oracle.jtobject Test9 {def main(args: Array[String]): Unit = {val a=22val b=13val c=a.+(b)val d=a.*(b)val e=a./(b)val f=a.-(b)val g=a.%(b)print(c,d,e,f,g)}}
1）Scala定义方法
package com.oracle.jtobject Test10 {//Scala定义方法的格式/*** def 方法名 (a:数据类型,b:数据类型....) [={}]* []表示可以省略* 关于大括号 如果就一行代码 大括号可以省略* 关于等号 如果没有返回值 可以省略*/// 一行代码 可以省略 {}def add()=println("山东人民万岁")//有参数 无返回值 可以省略 = def add(a:Int,b:Double){val c=a+bprintln(c)}//有返回值 写 =def add(a:Int,b:Double,c:Int)={val d=a+b+cif(d>0) d else 13}def main(args: Array[String]): Unit = {add() //静态方法可以直接调用add(12,34.7)val res=add(12,34.6,78) //有返回值 接收一下print(res)}}
①注意:
//有返回值 写 = def add(a:Int,b:Double,c:Int): Unit={val d=a+b+cif(d>0) d else 13 }//有返回值 写 = def add(a:Int,b:Double,c:Int)={val d=a+b+cif(d>0) d else 13 }
②练习1
在主方法中传递一个带 , 的字符串给普通方法 普通方法返回以 , 为分隔符之后的数组
在主方法中打印数组中的每个元素
package com.oracle.jtobject Test11 {def main(args: Array[String]): Unit = {val s="jhw,yyq"val res=splt(s)for(elm <- res){println(elm)}}def splt(s:String):Array[String]={val res=s.split(",")res}}
③练习2
在主方法中 创建A对象 为A的对象赋值 传递A对象给普通方法 在普通方法中 打印A对象中的值
package com.oracle.jtclass A {private var Sname: String=_;private var Ssex: String = _;def getSname():String=Snamedef setSname(name:String):String={Sname=nameSname //返回姓名值}def getSsex():String=Ssexdef setSsex(sex:String):String={Ssex=sexSsex //返回性别值}
}package com.oracle.jtobject Test12 {def prt(a:A)={val name=a.getSname()val sex=a.getSsex()println(name)println(sex)}def main(args: Array[String]): Unit = {val a=new Aa.setSname("jhw")a.setSsex("nan")prt(a)}
}
2）Scala定义函数
①重要思想
目标：
1.学会定义函数（思想：函数是变量 函数是方法）
val 函数名=(a:参数类型,b:参数类型....)=>{代码块 返回值}
2.学会调用函数
函数名(参数值1,参数值2....)
为什么说Scala的一行代码抵得上Java的很多行代码？
因为Scala的代码都已经 以函数的形式写好了
可以直接调用使用
效果如下：
package com.oracle.jtobject Test13 {//函数的定义：val 函数名=(a:参数类型,b:参数类型....)=>{代码块 返回值}val add=(a:Int,b:Int)=>a+bdef main(args: Array[String]): Unit = {//函数的调用：函数名(参数值1,参数值2....)val d=add(13,45)println(d)}
}
②练习：
用函数实现下面的需求：
在主方法中传递一个带 , 的字符串给普通方法 普通方法返回以 , 为分隔符之后的数组
在主方法中打印数组中的每个元素
package com.oracle.jtobject Test14 {val splitString=(s:String)=>{val res:Array[String]=s.split(",")for(elm<-res){println(elm)}}def main(args: Array[String]): Unit = {var s="a,b,c,d,e"splitString(s)}
}
③函数的声明及调用
package com.oracle.jtobject Test13 {//函数的定义：val 函数名=(a:参数类型,b:参数类型....)=>{代码块 返回值}//val fun=(a:String,b:String,c:String)=>a+b+c//val add=(a:Int,b:Int)=>a+b//函数是变量 现在把它传递给一个方法//函数声明：把函数实现变为参数类型和返回值类型 然后起个名字就可以了def myAdd(f:(Int,Int)=>Int): Int ={//声明以后我们就可以调用了val res=f(12,23)res//直接写f(12,23)也没错 Scala简洁}def strconat(s:(String,String,String)=>String):String={val a="你"val b="好"val c="坏"s(a,b,c)}def main(args: Array[String]): Unit = {//函数的调用：函数名(参数值1,参数值2....)//val d=add(13,45)//println(d)//函数的实现val res1=myAdd((a:Int,b:Int)=>a+b) //方法右返回值 接收一下//val res1=myAdd(add)println(res1)val res2=strconat((a:String,b:String,c:String)=>a+b+c)//val res2=strconat(fun)println(res2)}
}
练习：写出 a-b 的函数式编程 （使用函数的声明和实现）
package com.oracle.jtobject Test15 {def mySub(f:(Int,Int)=>Int)={val a=12;val b=23;f(a,b)}def main(args: Array[String]): Unit = {val res = mySub((a: Int, b: Int) => a + b)print(res)}}
④练习：
定义一个方法 包括一个参数 参数类型是函数
函数有两个参数 Int String
返回Int和String的拼接
在主方法中 调用方法 并传递函数实现
package com.oracle.jtobject Test16 {def strAdd(f:(Int,String)=>String)={f(521,"一生一世")
// val a=521
// val b="一生一世"
// a+b}def intAdd(f:(Int,String)=>Int)={val a=521val b="一生一世"a+b}def main(args: Array[String]): Unit = {val res1=strAdd((a:Int,b:String)=>a+b)println(res1)val res2=strAdd((a:Int,b:String)=>a+b)print(res2)}}
package com.oracle.jtobject Test17 {def splitStr(f:(String)=>Array[String])={f("a,c,d,e")}def main(args: Array[String]): Unit = {//在实现的时候 我们可以不写类型val res=splitStr((f:String)=>f.split(","))for(elm<-res){println(elm)}val array=Array[String]("a,b","c,d","e,f")val a = array.map(s => s.split(","))println(a.toBuffer)}
}
⑤Scala中map用法
map是用来对数组中的每个元素做一对一类型转换的array.map的参数是String 返回值可以是任何类型
我们可以自己定义一下map的内容
package com.oracle.jtimport scala.collection.mutable.ArrayBufferclass ArrayDemo {val array=new ArrayBuffer[String]()def add(s:String): Unit ={array.append(s)}def map(f:(String => Array[String])): ArrayBuffer[Array[String]] ={val cvtArray=new ArrayBuffer[Array[String]]()for (elm<-array){cvtArray.append(f(elm))}cvtArray}}package com.oracle.jtobject Test20 {def main(args: Array[String]): Unit = {val array=new ArrayDemo()array.add("a,d")array.add("c,e")array.add("g,h")val res=array.map(x=>x.split(","))println(res)}}
我们也可以直接用 因为Scala已经给我们写好了
val array1=new ArrayBuffer[String]()array1.append("1,2")array1.append("3,5")array1.append("3,5")val res1 = array1.map(s => s.split(","))println(res1)
3）方法转化为函数
package com.oracle.jtobject Test21 {def add(a:Int,b:Int)=a+bdef main(args: Array[String]): Unit = {//把方法转换成函数val fun=add _val res=fun(213,456)println(res)}}
