（一）Scala

憨

1. scala语言简洁

scala是运行在JVM上的多范式编程语言，同时支持面向对象和面向函数编程

2. scala开发环境搭建

jdk（jvm）

scala编译器（scala SDK）

scala sdk是scala语言的编译器，要开发scala程序，必须要先安装SDK

到IDEA官网下载对应版本的IDEA scala插件：

http://plugins.jetbrains.com/plugin/

下载与IDEA版本一致的scala插件

3. scala的基础语法

  ：paste

输入代码块
ctrl+D结束
====================================================================
for循环
for（i <- 表达式/数组/集合）{
　　表达式
}
--------------------------
守卫：在for表达式中可以添加if判断语句，这个if判断就称为守卫
for（i <- 表达式/数组/集合 if 表达式）{
　　表达式
}

==================================================================
方法和函数
方法：语法
def methodName（参数名：参数类型，参数名：参数类型）：[return type]={
　　//一些列的代码
}
--------------------------
1 方法的参数，可以给默认参数
def add(x:Int =0,y:Int=0):Int={
　　x+y
}
2 指定参数的名称来调用
 add(x=1)
3 变长参数：如果方法的参数是不固定的，可以定义一个方法的参数是变长参数
语法格式：
　　def 方法名（参数名：参数类型*）：返回值类型={
　　　　方法体
　　}
def add(num:Int*):Int={
　　num*sum
}

add(1,2,3,4,5)
>:15

=====================================================================
函数：scala支持函数式编程，
语法：
val 函数变量名=（参数名：参数类型，参数名：参数类型.....）=>函数体
一个函数最多22个参数
========================================================================
方法转换为函数
有时候需要将方法转换为函数，作为变量传递，就需要将方法转换为函数
使用_即可将方法转换为函数
========================================================================

数组
scala中数组的概念是和java类似，可以用数组来存放一组数据
scala中，有两种数组，一种是定长数组，另一种是变长数组
定长数组：
定长数组值得是数组的长度是不允许改变的
数组的元素是可以改变的
语法：
val /var 变量名 = new Array[元素类型]（数组长度）
val /var 变量名 = Array（元素1，元素2，元素3......） 

变长数组：
变长数组值得是数组的长度是可变的，可以往数组总添加、删除元素
创建变长数组，需要提前导入ArrayBuffer类
import scala.collection.mutable.ArrayBuffer
语法：
val/var a = ArrayBuffer[元素类型]
创建带有初始元素的ArrayBuffer
val/var a = ArrayBuffer（元素1,元素2，元素3）


元组
val t1 = "lisi1"-> "lisi2" - > 30

映射Map
可变
不可变

Set集合
没有重复元素的集合
不保证插入顺序

List列表
可以保存重复的值
有先后顺序
============================================================================
函数式编程：
1 foreach
2 map
3 flatmap
4 filter
5 sort（sorted默认排序，soryBy指定字段排序，sortWith自定义排序）
　　soryBy：
　　val list=List（"1 hadoop","2 spark","3 flink"）
　　list.soryBy(x=>x.split(" ")(1))
　　sortWith自定义排序：
　　def sortWith(lt:(A,A)=>Boolean):List[A]
　　val list=List(1,2,5,3,8,0)
　　list.sortWith((x,y)=>x>y) //降序
　　list.sortWith((x,y)=>x<y)// 升序

6 groupBy 按照函数将列表分成不同的组
　　def groupBy[k](f:(A)=>k):Map[k,List[A]]
　　val a = List("张三" -> "男", "李四" -> "女", "王五" -> "男")
　　a.groupBy(_._2)

7 reduce：reduce表示将列表，传入一个函数进行聚合计算
　　def reduce[A1>:A](op:(A1,A1)=>A1):A1
op:(A1,A1)=>A1
第一个A1类型参数为：当前聚合后的变量
第二个A1类型参数为：当前要进行聚合的元素

8 fold fold与reduce很像，但是多了一个指定初始值参数
　　def fold[A1>:A](z:A1)(op:A1,A1)=>A1):A1
z:A1 初始值
================================================================
高阶函数
使用函数值作为参数，或者返回值为函数只的函数和方法，均称之为 高阶函数

1 匿名函数
定义一个数组
val aray = Array(1,2,3,4)
array.map(x=>x*10)
2 柯里化
方法可以定义多个参数列表，当使用较少的参数列表调用多参数列表的方法时，会产生一个新的函数
该函数接受剩余的参数列表作为其参数，这就被称为柯里化

3 闭包
函数里面引用外面类成员变量叫做闭包引用
var factor = 10
val f1 = (x:Int) => x*factor
定义的函数f1，它的返回值是依赖于不在函数作用域的一个变量
后期必须要获取到这个变量才能执行
spark和flink程序的开发中大量的使用到函数，函数的返回值依赖的变量
可能都需要进行大量的网络传输去得到。这里就需要这些变量实现序列化进行网络传输

============================================================================================

scala面向对象编程之类
憨
类的定义
scala是支持面向对象的，也有类和对象的概念
定义一个Customer类，并添加成员变量/成员方法
添加一个main方法，并创建Customer类的对象，并给对象赋值，打印对象中的成员
调用成员方法

类的构造器
主构造器
主构造器是指在类名的后面跟上一些列参数
class 类名（var/val 参数名：类型 = 默认值，var/val 参数名：类型 = 默认值）{
　　构造代码块
}

辅助构造器
在类中使用this来定义
def this（参数名：类型，参数名：类型）{
　　。。。
}

注意：定义一个辅助构造器，第一行必须调用主构造器、其他辅助构造器或者super父类的构造器
===================================================================
scala面向对象编程之对象
scala中的object
scala中没有Java中的静态成员的。
如果将来我们需要用到static变量、static方法，就要用到scala中的单例对象object
定义object
　　定义单例对象和定义类很像，就是把class换成object

scala中的伴生对象
在同一个scala文件，有一个class和object具有同样的名字
那么就称这个object是class的伴生对象，class是object的伴生类；
伴生类和伴生对象的最大特点是，可以相互访问：

scala中的object的apply方法
我们之前使用过这种方式来创建一个Array对象
创建一个Array对象
val a = Array（1,2,3,4）
这种写法非常简便，不需要再写一个new，然后敲一个空格，再写类名

实现伴生对象的apply方法

scala中object的main方法
scala和java一样，如果要运行一个程序，必须有一个main方法
而在java中main方法时静态的，而在scala中没有静态方法

也可以继承自App Trait（特质），然后将需要编写的main方法中的代码
写在object的构造方法体内，其本质是调用了Trait这个特质中的main方法
（可以对小白装逼，然并卵；好鸡儿无聊，TTRS牛逼，拒绝口嗨，做个实力派）

========================================================================================
scala面向对象编程之继承
scala和java一样，使用extends关键字来实现继承，可以在子类中定义父类中没有的
字段和方法，或者重写父类的方法
1 继承extends
2 override和super
3 isInstanceOf和asInstanceOf
 　is判断对象是否为指定类的对象
　　as将对象转换为指定类型
4 getClass和classOf
　　对象.getClass可以精确获取对象的类型
　　classOf[X]可以精确获取类型
　　使用==操作符可以直接比较
5 访问修饰符
6 调用父类的construct？？？？？？？？？？？？？？？？？？？
7 抽象类
8 匿名内部类

========================================================================
scala面向对象编程之trait特质
特质是scala中代码复用的基础单元
它可以将方法和字段定义封装起来，然后添加到类中
与类继承不一样的是，类继承要求每个类都只能继承一个超类，而一个类可以添加任意
数量的特质
特质的定义和抽象类的定义很像，但是它是使用trait关键字
1 作为接口使用
使用extends来继承trait（scala不论是类还是特质，都是使用extends关键字）
如果要继承多个trait，则使用with关键字
2 定义具体的方法
和类一样，trait中还可以定义具体的方法
3 定义具体方法和抽象方法
在trait中，可以混合使用具体方法和抽象方法
4 定义具体字段和抽象字段
在trait中可以定义具体字段和抽象字段
继承trait的子类自动拥有trait中定义的字段
字段直接被添加到子类中
5 实例对象混入trait
trait还可以混入到实例对象中，给对象实例添加额外的行为
只有混入trait的对象才具有trait中的方法，其他的类对象不具有trait中的行为
使用with将trait混入到实例对象中
6 trait调用链
类继承了多个trait后，可以一次调用多个trait中的同一个方法，只要让多个trait中的
同一方法在最后都依次执行super关键字即可，类种调用多个trait中都有这个方法时
首先会从最右边的trait方法开始执行，然后一次往左执行，形成一个调用链条。
trait T1{
　　def xxx()={}
}
trait T2 extends T1{
　　override def xxx()={
　　　　new_XXX
　　　　super.xxx()
　　}
}
trait T3 extends T2{
　　override def xxx()={
　　　　new_new_xxx
　　　　super.xxx()
　　}
}

7 trait的构造机制
8 trait继承class

=================================================================
模式匹配和样例类
scala有一个十分强大的模式匹配机制，可以应用到很多场合
switch
类型查询
以及快速获取数据
并且scala还提供了样例类，对模式匹配进行了优化，可以快速进行匹配
1 匹配字符串

val arr = Array("hadoop", "zookeeper", "spark", "storm")
val name = arr(Random.nextInt(arr.length))
name match {
  case "hadoop" => println("hadoop====>")
  case "zookeeper" => println("zookeeper===>")
  case "spark" => println("spark===>")
  case _ => println("滚蛋")
}

2 匹配类型
3 匹配数组
4 匹配集合
5 匹配元组
6 匹配样例类
7 Option类型
8 偏函数
样例类
样例类是一种特殊类，它可以用来快速定义一个用于保存数据的类（类似于Java POJO类）
而且它会自动生成apply方法，允许我们快速地创建样例类实例对象，后面在开发
编程和spark、flink这些框架也都会经常使用它
语法：
case class 样例类名（成员变量1：类型1，成员变量2：类型2）

样例对象
使用case object可以创建样例对象，样例对象是单例的，而且它没有主构造器
样例对象是可序列化的
case object 样例对象名
用作模式匹配

Option类型
在scala中Option类型用样例类来表示可能存在或也可能不存在的值
Option类型有2个子类
一个是Some
　　Some包装了某个值
一个是None
　　None表示没有值

偏函数
被包在花括号内没有match的一组case语句是一个偏函数
它是PartialFunction[A,B]的一个实例
　　A代表输入参数类型
　　B代表返回结果类型
　　可以理解为：偏函数是一个参数和一个返回值的函数

异常处理：
在scala中，可以使用异常处理来解决这个问题
在scala里，借用了模式匹配的思想类做异常的匹配
try{
　　代码
} 
catch {
　　case ex：异常类型1=>代码
　　case ex：异常类型2=>代码
}
finally{
　　代码
}

抛出异常：
使用throw new Exception（"这是一个异常"）

提取器（Extractor）？？？？？？？？？？？？？？？？？？？？？？？
泛型
隐式转换和隐式参数
隐式转换
scala提供的隐式转换和隐式参数功能，是非常有特色的功能
隐式转换其核心就是一个使用implicit关键字修饰的方法 实现把一个原始类
转换成目标类，进而可以调用目标类中的方法
隐式参数
所谓的隐式参数，指的是在函数或者方法中，定义一个用implicit修饰的参数，
此时scala会尝试找到一个指定类型的用implicit修饰的参数，即隐式值
并注入参数

必须定义在一个object中





憨憨biu，biu SnakeVenom_