本篇博文是小二针对工作中有帮助的初学者精心总结！！！
小二大讲堂推荐：Pyhton入门讲解
一、scala简介
什么是scala
Scala是一门多范式的编程语言，一种类似java的编程语言 ，设计初衷是实现可伸缩的语言 、并集成面向对象编程和函数式编程的各种特性。
在很多地方Scala都很像Java，但是比Java更为函数式编程，这句话主要从三句话就可以理解“一切都是对象”，“一切都是函数”以及“一切都是表达式”三方面理解。
首先是一切都是对象，这大概和Python很像，因为即便是数字1都有一系列的方法，所以我们可以调用1.toDouble将Int类型的1转换为Double类型的1。
然后是一切都是函数，表现为可以重载操作符，Python很像，在一定程度上我总觉的Scala是Java和Python生的孩子，只不过遗传基因比较大的卵子是Java提供的，而比较小的那颗精子则是Python提供的。
最后是一切都是表达式，if(){}else{}这样的语句块是有返回值的。
二、Scala六大特性
1.seamless java interop
和java语言是无缝整合运行在JVM上的
可以与java进行方法的互相调用
2.type inference 类型的自动推断
var 定义变量
val 定义常量
3.concurrency& distribution 并行和分布式
底层有一个actor通信模型，解决了死锁的问题，底层利用队列的方式，解决节点之间的集群
4、traits特质和特性
将java中个接口、抽象类等进行整合
5.pattern matching 模式匹配
类似java中的switch…case…scala关键字：match匹配
6.higher-order functioins 高阶函数
体现scala面向函数的特性的一种方式，“一切皆函数”
Scala语言的注意事项：
-建议类名首字母大写 ，方法首字母小写，类和方法命名建议符合驼峰命名法。
-scala 中的object是单例对象，相当于java中的工具类，可以看成是定义静态的方法的类。object不可以传参数。另：Trait不可以传参数
-scala中的class类默认可以传参数，默认的传参数就是默认的构造函数。
重写构造函数的时候，必须要调用默认的构造函数。
-class 类属性自带getter ，setter方法。
-使用object时，不用new,使用class时要new ,并且new的时候，class中除了方法不执行，其他都执行。
-如果在同一个文件中，object对象和class类的名称相同，则这个对象就是这个类的伴生对象，这个类就是这个对象的伴生类。可以互相访问私有变量。
三、scala中语法介绍以及六大特性
-scala中定义常量使用val,常量不可变，定义变量用var,变量可变，在定义常量和变量是会有类型自动推断机制。
-scala中每行有自动的分号推断机制，不需要在每行结束时进行写封号
尽量使用val常量定义，因为JVM的GC更容易回收
-Object和clas类的区别
Scall中有calss和Object,定义class是可以传参，但是参数传递的时候一定要指定参数类型
-Scala中的object相当于java中的单例，类似于java中的工具类，object中定义的所有属性和方法都是静态的。
注意：scala中定义类和object的作用是将静态的与非静态的相剥离
1.创建类和对象
–类中常量的定义–建议 var
–类中变量的定义–val
-类中对象的创建，对象不可以传递参数了，但是传递参数时
只是自动找apply方法。使用object对象时不能使用类
–创建类，类的创建时可以传递参数，但是必须要指定数据类型
代码演示：
*
1.常量和变量的定义
2.对象参数的传递
*/
class Person(xname:String,xage:Int){
val name=xname
val age=xage
var sex='f'
def this(xname:String,xage:Int,xsex:Char){
this(xname,xage)
this.sex=xsex
}
def fun1(): Unit ={
print(s"name is ${xname} ,age is ${xage} ,sex is ${sex}")
}
}
object ScalaDemo01 {
/**
* object中不可以传参，当创建一个object时，如果传入参数，那么会自动寻找object中的相应参数个数的apply方法。
*
*/
def main(args: Array[String]): Unit = {
val person=new Person("zhangsan",18,'f')
// person.fun1()
ScalaDemo01("lulu")
}
def apply(name:String)={
print(s"name is $name")
}
}
2、伴生类和伴生对象
类和对象具有相同的名称
/*
伴生类和伴生对象：
类名和对象名是相同的名称
*/
class Student{
def showMsg(name:String): Unit ={
print(s"the student`s name is $name")
}
}
object Student{
def main(args: Array[String]): Unit = {
//创建伴生对象
var stu=new Student();
stu.showMsg("zhangsan")
}
}
3…条件判断以及循环语句
条件判断
var age=19
if(age<18){
print(s"she is $age year old")
}else{
print(s"she is a man")
}
for循环 包括1-10左右都是闭区间
for (i<-1 to 10){
println(i)
}
until：不包括右侧的10，左开右闭
for (i<- 1 until 10){
println(i)
}
打印偶数
for(i<-1 to 10 ;if(i%2==0)){
println(i)
}
利用嵌套for循环打印九九乘法表
for (i<- 1 to 9){
for (j<- 1 until 10){
if(i>=j){
print(s"$j * $i = ${i*j}\t")
}
if(i==j){
println()
}
}
}
将两层循环进行整合
for (i<- 1 to 9;j<- 1 until 10){
if(i>=j){
print(s"$j * $i = ${i*j}\t")
}
if(i==j){
println()
}
}
- scala中不能使用count++，count—只能使用count = count+1 ，count += 1
var count=0
var sum=0
while(count<100){
sum+=count
count+=1
}
print(sum)
- for循环用yield 关键字返回一个集合
//返回一个Vector数组集合
var arr=for(i<- 1 until 100;if(i>50)) yield i
print(arr)
for (n<-arr)
println(n)
- while循环，while（）{}，do {}while()
/**
* while 循环
*/
var index = 0
while(index < 100 ){
println("第"+index+"次while 循环")
index += 1
}
index = 0
do{
index +=1
println("第"+index+"次do while 循环")
}while(index <100 )
4、Scala方法与函数
l 方法定义语法 用def来定义
l 可以定义传入的参数，要指定传入参数的类型
l 方法可以写返回值的类型也可以不写，会自动推断，有时候不能省略，必须写，比如在递归方法中或者方法的返回值是函数类型的时候。
l scala中方法有返回值时，可以写return，也可以不写return，会把方法中最后一行当做结果返回。当写return时，必须要写方法的返回值。
l 如果返回值可以一行搞定，可以将{}省略不写
l 传递给方法的参数可以在方法中使用，并且scala规定方法的传过来的参数为val的，不是var的。
如果去掉方法体前面的等号，那么这个方法返回类型必定是Unit的。这种说法无论方法体里面什么逻辑都成立，scala可以把任意类型转换为Unit.假设，里面的逻辑最后返回了一个string，那么这个返回值会被转换成Unit，并且值会被丢弃。
- 1.scala的有参方法和无参方法
//定义无参方法
def fun1(): Unit ={
print("无参方法")
}
//有参方法
def fun2(name:String,age:Int): Unit ={
print(s"${name} is ${age} year old")
}
- 2.递归方法
//递归方法
def diGui(num:Int) :Int ={
if(num==1)
num
num*diGui(num-1)
}
-
3.参数有默认值的方法
-如果参数有默认值，如果方法调用的时候没有传递参数，则就是默认的参数，如果传递了参数就是传递的,新值会覆盖默认值
l 默认值的函数中，如果传入的参数个数与函数定义相同，则传入的数值会覆盖默认值。
如果不想覆盖默认值，传入的参数个数小于定义的函数的参数，则需要指定参数名称def fun3(a :Int = 10,b:Int) = { println(a+b) } fun3(b=2) -
4.可变参数的方法
def main(args: Array[String]): Unit = {
fun(1,2,3,4,5,6,7,8,9)
}
//可变参数的方法
def fun(num:Int*)={
var sum=0
for(n<-num){
sum+=n
}
print(sum)
}
- 5.匿名函数
1）. 有参匿名函数
//匿名函数
var fun= (name:String)=>{
print(s"有参匿名函数 $name")
}
//函数调用
fun("匿名函数")
}
- 2.） 无参匿名函数
//匿名函数
var fun= ()=>{
print("无参匿名函数")
}
//函数调用
fun()
- 3）. 有返回值的匿名函数
//有返回值的匿名函数
var fun= (a:Int,b:Int)=>{
a+b
}
//函数调用
print(fun(1,2))
l 可以将匿名函数返回给val定义的值
l 匿名函数不能显式声明函数的返回类型
- 6.嵌套方法
def main(args: Array[String]): Unit = {
print(fun1(1))
}
def fun1(num:Int)={
def fun2(a:Int,b:Int): Int ={
a+b
}
fun2(num,2)
}
- 7、偏应用函数
def main(args: Array[String]): Unit = {
var date =new Date();
log(date,"log1")
log(date,"log2")
log(date,"log3")
}
//偏应用函数
def log(date:Date,s:String)={
println(s"date is $date ,log is $s")
}
- 8、高阶函数
函数的参数是函数，或者函数的返回类型是函数，或者函数的参数和函数的返回类型是函数的函数。
l 函数的参数是函数
def main(args: Array[String]): Unit = {
println(highFun(fun1,1))
}
//函数的参数是函数
def highFun(f: (Int, Int) => Int, a: Int) ={
fun1(a, 100)
}
def fun1(a:Int,b:Int): Int ={
a+b
}
l 函数的返回是函数
def main(args: Array[String]): Unit = {
println(highFun(1,2)(3,"math"));
}
//函数的参数是函数
def highFun(a:Int,b:Int):(Int,String)=>String ={
val s=a+b
def fun(s:Int,v2:String)={
s"the $v2 is "+s
}
fun
}
l 函数的参数和函数的返回是函数
def main(args: Array[String]): Unit = {
println(highFun(fun,"lisi")(2,10))
}
//函数的参数和函数的返回是函数
def highFun(f:(Int,Int)=>String,name:String) :(Int,Int)=>String={
fun
}
def fun(a:Int,b:Int):String={
"the student "+a*b
}
8、柯里化函数
高阶函数的简化
def main(args: Array[String]): Unit = {
println(fun(1,2)(3,4))
}
def fun(a:Int,b:Int)(c:Int,d:Int)={
a+b+c+d
}
语法介绍重点还在后续博文中，敬请关注小二课堂
小二推荐：算法大学堂