Scala思维导图

Scala介绍

Scala特点

object helloscala{

def main(arg:Array[String]):Unit={

printlin("hello,scala")

}
}

①object表示一个伴生对象，可以理解成一个对象

②helloscala是对象名，他底层对应的类名是helloscala$

③当编写object helloscala时，底层会生成两个.class文件，分别时helloscala.class和helloscala$.class

（Java程序编写时只会生成一个.class文件）

④def表示一个方法，是一个关键字

⑤main表示方法的名字，是程序的入口

⑥args:Array[String]表示形参，Scala特点是参数名在前，类型在后

⑦Array[String]表示字符串类型的数组

⑧Unit=表示该函数的返回值为空（void）

Scala plugin下载地址：https://plugins.jetbrains.com/plugin/1347-scala/versions

1.打开idea

2.点击左上角file>settings

3.点击plugins

4.在搜索框中输入scala

5.如果没搜到则表示没有安装scala plugin

6.点击install plugin from disk

7.找到插件路径并点击ok

8.点击右下角apply

9.点击ok

10.重启idea

11.如果安装成功，则会在plugin中搜索到scala

1.点击file>new>project...

2.新建一个maven工程

3.到main下创建一个Scala文件夹

4.将Scala文件夹source成root(根目录)

①右键文件夹

②选择mark directory as

③选择source root

5.导入Scala framework

6.右键项目名（Scala）

7.点击add framework support...

8.从右边的选择栏中选择Scala

9.点击Use library 右侧的create

10.点击底侧的browse

11.找到Scala的安装主目录点击ok即可

12.创建Scala object

数据类型一览

数据类型说明

数据类型的强制转换

值类型和String类型的转换

一.标识符概念

1.Scala对各种变量，方法，函数等命名时使用的字符序列称为标识符

2.凡是自己可以取名字的地方都叫标识符

二.标识符的命名规则

Scala中的标识符声明基本和Java一致，但是细节上会有些变化

1.首字母为字母，后续可以接字母数字，美元符号，也可以接下划线

2.数字不可作为开头

3.首字符为操作符（比如+-*/），后续字符也要跟操作符，至少一个

4.操作符（比如+-*/）不能在标识符的中间或最后

5.关键字也是可以作为标识符，但是需要加上反引号，比如（`true`）

三.标识符命名的细节

1.在Scala中Int，Float不是关键字，而是预定义标识符。所以Int，Float可以作为标识符，但是不推荐

2.单独的下划线不能作为标识符（_）。因为_有很多其他的作用。

四.标识符命名注意事项

1.包名：尽量采取有意义的包名，简短，有意义

2.变量名，函数名，方法名尽量采用驼峰法

一.运算符介绍

运算符是一种特殊的符号，用来表示数据的运算，赋值和比较等

1.算术运算符 + - * / %

2.赋值运算符 =

3.关系运算符 < > = 等

4.逻辑运算符 与(&&) 或(||) 非(!)

5.位运算符 

二.算术运算符中的细节

1./除的运算规则：a/b的结果去整数部分，比如3/2=1

2.%取余的运算规则：a%b=a-a/b+b

三.关系运算符中的细节

1.如果两个浮点数进行比较，应当保证数据类型一致

1.从控制台接受用户的信息

import scala.io.StdIn

println("请输入姓名")

var name = StdIn.readLine

流程控制有三种

1.顺序控制

2.条件（分支）控制

3.循环控制 

条件控制
1.Scala条件控制和Java基本一样，Scala中没有三元表达式
2.注意：Scala用match替代了switch语句，而且更加强大

循环控制

break

continue

1.scala.collection 该包和子包，包含了Scala集合架构
①scala.collection.immutable 不可变的顺序数据结构
②scala.collection.mutable 可变的顺序数据结构
③scala.collection.concurrent 可变的并发数据结构
④scala.collection.parallel.immutable 不可变的并行数据结构
⑤scala.collection.parallel.mutable 可变的并行数据结构

2.scala.concurrent 并行编程的基础类

3.scala.io 输出和输入操作

4.scala.math 基本数学函数和附加数字类型 bigInt等

5.scala.sys 以其他进程和操作系统进行交互

6.scala.util.matching 常规操作包

函数式编程基础

函数式编程高级

一.方法，函数，函数式编程和面向对象概念

1.在Scala中，方法和函数几乎可以等同（比如它们的定义，使用，运行机制都是一样的），只是函数的使用方法更加灵活多样 【方法转函数】

2.函数式编程是从编程方式（范式）的角度来谈的。可以理解为，函数式编程把函数当成一个公民，充分并灵活利用函数，支持函数的多种使用方式。函数的创建不在依赖类或者对象

3.面向对象编程是以对象为基础的编程方式。

4.在Scala中函数式编程和面向对象编程融合在一起

二.函数的定义

1.基本语法
def Dog (n1:Int,n2:Int):Int={
 //语句。。。。
  return 返回值
}

①.函数声明关键字:def (definition)
②.返回值形式1：:返回值的类型=
③.返回值形式2：只有一个等号=，表示返回值类型不确定
④.返回值形式3：什么都没有，表示没有返回值，等价于:Unit=
⑤.代码块中如果没有return，则默认以执行到最后一行的结果作为返回值

三.函数的递归

1.在执行一个函数时，就创建一个新的受保护的独立空间（新函数栈）
2.函数的局部变量是独立的，不会相互影响
3.递归必须向退出递归条件逼近，否则就无限递归了
4.当一个函数执行完毕，或者遇到return，就会返回，遵守谁调用就返回给谁

1.函数的形参列表可以是多个，如果函数没有形参可以不带（）

2.形参列表和返回值列表的数据类型可以是值类型和引用类型

3.Scala中的函数可以根据函数体最后一行代码自行推断出函数的返回类型，那么在这种情况下，return关键字可以省略

4.因为Scala可以自行推断，所以返回值的类型也可以省略

5.如果函数明确使用return关键字，那么函数的返回类型就不能自行推断了，这时就要写成：返回值类型=，如果不写，即使有return，返回值为（）

6.如果函数声明无返回值（Unit），那么函数体中有return关键字，也不会有返回值

7.如果明确函数无返回值或者不确定返回值类型，那么返回值类型可以省略(或声明Any,因为Any是所有数据类型的父类)

8.Scala语法中任何语法结构都可以嵌套其他语法结构，即：函数中可以在声明定义函数，类中可再声明类，方法中可再声明方法

9.Scala函数的形参，在声明参数时，直接赋初始值（默认值），这是调用函数，如果没有指定实参，则会使用默认值。如果指定了实参，则实参覆盖默认值。指定默认值n:int=1

10.如果函数存在多个参数，每一参数都可以设定默认值，那么这个时候，参数到底是覆盖默认值，还是赋值给没有默认值的参数，这就不确定了（默认声明顺序【从左到右】），这种情况下，可以采用带名参数
def getSum(n1:Int=1){}
getSum(n1=2)

11.再Scala函数中形参默认是val，因此不能再函数中进行修改

12.递归函数未执行之前是无法推断出来结果类型，在使用时必须有明确的返回值类型

13.Scala函数支持可变参数，可变参数只能放在参数列表的最后
①//支持0到多个参数
def sum(args:Int*):Int={}

②支持1到多个参数
def sum(n:Int,args:Int*):Int={}

说明：args是集合，通过for循环可以访问到各个值 

1.过程的基本介绍

将函数的返回类型为Unit的函数称为过程，如果没有明确函数没有返回值，那么等号可以去掉。简单来说：没有返回值的函数称为过程。

一.惰性函数使用的场景
惰性计算（尽可能延迟表达式计算）是许多函数式编程语言的特性。惰性集合在需要时提供其元素，无需预先计算它们，这带来一些好处，首先，可以将耗时计算推迟到绝对需要的时候。其次，可以创造无限个集合，只要它们继续收到请求，就会继续提供元素。函数的惰性使用可以得到更高效的代码。Java并没有为惰性提供原生支持，Scala提供了

二.惰性函数介绍
当函数返回值被声明为lazy时，函数执行将会被推迟，直到我没首次对此取值，该函数才会执行。这种函数称之为惰性函数

三.注意事项和细节
1.lazy不能修饰var类型的变量
2.不但是在调用函数时，加了lazy，会导致函数的执行被推迟，我们在声明一个变量时，如果声明了lazy，那么变量值的分配也会被推出 例如：lazy val i =10

基本介绍

使用基本案例

一.Scala面向对象介绍

1.在Scala中一切皆为对象
2.面向对象的三大特征：封装，继承，多态

二.类和对象的区别

1.类是抽象的，概念的，代表一类事物，比如人类，猫类
2.对象是具体的，实际的，代表一个具体事物
3.类是对象的一个模板，对象是类的一个个体，对应一个实例
4.Scala中类和对象的区别和联系是跟Java一样的

三.属性（成员变量）

1.属性是类的一个组成部分，一般是值数据类型，也可以是引用类型。
2.属性的定义语法同变量，实例 【访问修饰符默认是私有的】var name:String=""
3.Scala中声明一个属性，必须给定默认值，然后根据默认值自动推断数据类型，数据类型可以省略
4.如果赋值为null，则一定要加类型，如果不加类型，那么该属性的类型就是null
5.属性的高级部分和构造器（构造方法/函数）相关。

四.方法

1.方法的调用机制
①当Scala程序开始执行时，先会在栈区开辟一个main栈。main栈是最后被销毁的
②当Scala程序执行到一个方法时，会开辟一个新栈
③每个栈是独立的空间，变量（基本数据类型）是独立的，相互不受影响，引用类型除外
④当方法执行完毕后，该方法的栈会被jvm回收

五.创建对象

基本语法 val | var 对象名[:类型] = new 类型()
1.如果我们不希望改变对象的引用（即：内存地址），应该声明val，否则声明var。Scala设计者推荐使用val，因为一般来说，我们只改变对象属性值，而不是改变对象的引用
2.Scala在声明对象变量时，可以根据创建对象的类型自动判断，所以类型声明可以省略，但是当类型和后面new对象类型有继承和多态时，就必须写了

六.对象创建流程分析

先看一个案例
class Person{
var age:Short=90
var name:String=_
def this(n:String,a:Int){
this()
this.name=n
this.age=a
}
}

var p:Person=new Person("马云","20")

流程分析
①加载类的信息（属性信息，方法信息）
②在内存（堆）中开辟空间
③使用父类的构造器（主和辅助）进行初始化
④使用主构造器对属性进行初始化
⑤使用辅助构造器对属性进行初始化
⑥将开辟的对象地址赋给p这个引用

基本说明

构造器使用注意事项和细节

属性高级（结合构造器）

Java包介绍

Scala包介绍

Scala包对象

包的可见性

封装

继承

多态

一.抽象类

在Scala中，通过abstract关键字标记并不能被实例化的类。方法不用标记abstract，只要省略方法体即可。抽象类可以拥有抽象字段，抽象字段就是没有初始化的字段

二.抽象类的价值

抽象类的价值更多的是在于价值，是设计者设计好后，让子类实现并继承抽象类（即：实现抽象类的抽象方法）

三.抽象类的使用注意事项和细节

1.默认情况下抽象类不能被实例化，但是在实例化时动态的实现了抽象类中所有的抽象方法，就可以实例化

2.抽象类不一定要包含abstract方法。也就是说抽象类可以没有abstract方法

3.一旦类中包含抽象方法或者抽象属性，这个类必须要声明abstract

4.抽象方法不能有主体，不允许使用abstract修饰

5.如果一个类继承了抽象类，那么这个类必须实现这个抽象类的所有抽象方法和抽象属性，除非它自己声明abstract

6.抽象方法和抽象属性不能使用private和final关键字，因为这些关键字是和重写/实现相违背的

7.抽象类可以有实现的方法

8子类重写抽象方法不需要加上abstract，加了也不会错

静态介绍

伴生对象小结

apply方法

特质基本介绍与快速入门

Java接口

Scala用特质代替接口

叠加特质

特质扩展

一.嵌套类

在Scala种，你几乎可以在任何语法结构中嵌套任何语法结构。如果类中可以再定义一个类，这样的类就是嵌套类，其他语法结构也是一样的。嵌套类类似于Java种的内部类

 面试题：Java种，类有哪五大成员？
1.属性
2.方法
3.内部类
4.构造器
5.代码块

二.回顾：Java内部类

在Java种，一个类的内部又完整的嵌套了另一个完整的类结构。被嵌套的类成为内部类（inner class），嵌套其他类的类称为外部类。内部类最大的特点就是可以直接访问私有属性，并且可以体现类于类的之间的包含关系

三.Java内部类的分类

1.从定义在外部类的成员位置上来看
①成员内部类（没有用static修饰）
②静态内部类（用static修饰）

2.定义在外部类局部位置上（比如方法内）来看
①分为局部内部类（有类名）
②匿名内部类（没有类名）

四.Scala嵌套类的使用
1.内部类如果想要访问外部类中的属性，可以通过外部类对象访问。即访问方式：外部类名.this.属性名

2.内部类如果想要访问外部类的属性，也可以通过外部类别名访问（推荐）。即访问方式：外部类别名.this.属性名

五.类型投影

是指在方法声明上，如果使用 外部类#内部类 的方式，表示忽略内部类对象关系，等同于Java内部类的操作，我们将这种方式称为类型投影

隐式转换和隐式参数

隐式类

隐式转换细节

集合的基本介绍

数组(Array)

元组(Tuple)

列表(List)

队列(Queue)

映射(Map)

集(Set)

map映射操作

flatmap扁平化操作

filter过滤

reduce化简

fold折叠

scan扫描

groupBy分组

zip拉链

iterator迭代器

stream流

view视图

线程安全

操作符

一.基本介绍

Scala中的模式匹配类似于Java中中的switch语法，但是更加强大

模式匹配语法中，采用match关键字声明，每个分支采用case关键字进行声明，当需要匹配时，会从第一个case分支开始，如果执行成功，就会执行相应的逻辑代码，如果不匹配，则继续执行下一个分支case。如果所有的case都不匹配，那么会执行case_分支，类似于Java中default

二.代码案例

val oper = '#'
val n1 = 20
val n2 = 10
var res = 0
oper match {
/*
1.match类似于Java的switch，
2.如果匹配成功，则会执行=> 后面的代码块
3.匹配顺序是从上往下
4.=>后面的代码块不需要写break，因为match会自动退出
5.如果所有的case都不匹配，则会执行case_后的代码块
6.如果所有的case都不匹配，并且没有case_，则会抛出异常MatchError
4.可以再match中使用其他类型，不仅仅是Char
*/
case '+' => res = n1 + n2
case '-' => res = n1 - n2
case '*' => res = n1 * n2
case '/' => res = n1 / n2
case _ => println("oper error")
}

println("res=" + res)

条件守卫

模式匹配中的变量

匹配数组

匹配列表

匹配元组

匹配对象

声明变量中的匹配

for循环中的模式匹配

一.基本介绍

1.样例类仍然是类

2.样例类用case关键字进行声明

3.样例类是为模式匹配而优化的类

4.构造器中的每一参数都成为了val，除非显示的声明var (不推荐)

5.在样例类对应的伴生对象中存在apply方法，可以是在实例化时不使用new关键字，就可以直接构造出对象

6.也提供unapply方法，让模式匹配可以正常的工作

7.将自动生成toString，equal，hashCode和copy方法（有点类似模板类，直接生成使用）

8.除了上述外，样例类和其他类完全一样，可以添加字段和方法

二.样例类的基本写法

abstract class Amount
case class Dollar(n:Int) extends Amount //这里的形参会在底层被声明成val
case class Currency(n:Int,s:Stirng) extends Amount
case Object NoAmount extends Amount

①样例类的使用案例一
val arr =Array(Dollar(1000),Currency(5000,"RMB"),noAmcount)
for (item <- arr){
val res = item match {
//样例类会自动创建unapply方法，会将创建对象传入的参数提取出来
case Dollar(n) => "$"+n
case Currency(k,v) => k+" "+v
case _ => "sdfasdf"
}
println(res)
}


②样例类的使用案例二
val amt = Currency(1500,"RMB")
val amt2 = amt.copy() //利用amt对象copy一个新的对象
println(amt.n,amt2.s) //样例类会将形参创建成一个可读不可写的属性，所以可以访问读取
val amt3 = amt.copy(n=1800) //copy时也可以指定参数
println(amt3) //这里可以直接数据对象的属性，因为底层有toString方法

一.基本介绍
操作原理类似于正则表达式

三.最佳实践案例-商品捆绑打折出售
现在有一些商品，请使用Scala设计相关的样例类，完成商品捆绑打折出售。要求商品捆绑可以是单个商品，也可以是多个商品。打折时按照折扣x元进行设计.能够统计出所有捆绑商品打折后的最终价格

①
//设计样例类
abstract class Item
case class Book(desc:String,price:Double) extends Item
//discount表示优惠的金额
case class Bundle(desc:String,discount:Double,item: Item*) extends Item

②三个知识点
val sale = Bundle("书籍",10,Book("漫画",40),Bundle("文学书籍",20,Book("阳关",80),Book("围城",30)))
//知识点一：取出漫画二字
val res = sale match {
case Bundle(_,_,Book(desc,_),_*) => desc
}
println(res)

//知识点二(@表示法)：取出漫画二字，和后面所以的内容，并存放到元组中。_*表示匹配多个Bundle
val res2 = sale match {
case Bundle(_,_,Book(desc,_),b @ _*) => (desc,b)
}
println(res2)

//知识点三：取出漫画二字，和后面的Bundle对象。
//说明因为没有使用 _* 即明确说明没有多个Bundle,所以返回的rest，就不是ArraySeq了。
val res3 = sale match {
case Bundle(_,_,Book(desc,_),rest) => (desc,rest)
}
println(res3)

③实现项目
def price(it: Item): Double ={
it match {
case Book(_,p) => p
case Bundle(_,disc,its @ _*) => its.map(price).sum - disc
}
println(price(sale))

一.基本介绍

1.如果想让case类的所有子类都必须在申明该类的相同源文件中定义，可以将样例类通过超类声明为sealed，这个超类就成为了密封类

2.密封类就是不能在其他文件中定义子类

偏函数的引出

偏函数介绍

偏函数的化简形式

做为参数的函数

基本介绍

匿名函数的简写（参数类型推断）

一.基本介绍

可以传入函数的函数就作高阶函数，在某些情况下也可以返回一个函数

二.代码演示

//定义一个高阶函数
def test(f:Double => Double,n:Double): Double ={
f(n)
}

val res = test((n:Double) => n+n,6)
println(res)

三.高阶函数返回函数类型

//创建一个高阶函数，它可以返回一个匿名函数
def test(n:Int) ={
(m:Int) => n-m
}

//调用这个高阶函数
//分步骤操作
val f1 = test(2) //这里会将2传递给 n ，即返回的结果是 (m:Int) =>2-m 是一个匿名函数
println(f1(4)) //这里会将4 传递给 m ,即会返回 2-4 = -2
//可以将上面的分步操作一次性完成
val res = test(3)(7)
println(res)
}

一.基本介绍

闭包（closure）就是一个函数和与其相关的引用环境组合的一个整体（实体）。

二.代码演示

def test(n:Int) ={
(m:Int) => n-m
}

//调用这个高阶函数
//分步骤操作
val f1 = test(2) //这里会将2传递给 n ，即返回的结果是 (m:Int) =>2-m 是一个匿名函数
println(f1(4)) //这里会将4 传递给 m ,即会返回 2-4 = -2
//可以将上面的分步操作一次性完成
val res = test(3)(7)
println(res)

三.代码小结

1.test函数返回的是 (m:Int) => n-m 匿名函数，因为该函数引用到了函数外的变量 n ，那么该函数和 n 整体形成了一个闭包。val f1 = test(2)这里的f1就是一个闭包

2.可以这样理解，返回函数是一个对象，而n就是该对象的一个字段，它们共同形成了一个闭包

3.当多次调用f1时（可以理解多次调用闭包），发现使用的是同一个n ，所以 n 不变

4.当使用闭包时，主要搞清楚返回函数引用了函数外的哪些变量，因为它们组合成了一个整体（实体），形成了一个闭包

四.添加后缀名的案例

object clusureDemon {
def main(args: Array[String]): Unit = {
val f = makeSuffix(".jpg")
println(f("scala")) //scala.jpg
println(f("python.jpg")) //python.jpg
}
/*
传入一个文件名，如果这个文件名带有后缀名，那么直接返回；
如果这个文件名没有后缀名，则为它添加一个后缀名并返回
*/

def makeSuffix(suffix:String) ={
(fileName:String) => {
if (fileName.endsWith(suffix)) fileName
else fileName+suffix
}
}
}

五.闭包的好处
1.返回的匿名函数和 test(n:Int) 的 n 变量组合成了一个闭包，因为返回的函数要引用 n 这个变量
2.可以反复引用上一次传入的值

一.基本介绍（curry）

1.函数编程中，接收多个参数的函数都可转换成接收一个参数的函数，这个转换过程就是函数柯里化
2.柯里化就是证明了函数只需要一个参数而已。在前面的学习中也用到了函数柯里化
3.柯里化是面向函数思想的必要产生结果

二.代码演示

编写一个函数，接收两个整数，可以返回两个数的乘积，要求:
1.使用常规的方式完成
2.使用闭包的方式完成
3.使用函数柯里化完成

//常规方式
def fun1(x:Int,y:Int): Int ={
x*y
}

//闭包方式（使用匿名函数）
def fun2(x:Int) ={
(y:Int) => x*y
}

//函数柯里化方式
def fun3(x:Int)(y:Int): Int ={
x*y


println(fun1(2,3)) //调用普通函数
println(fun2(2)(5)) //调用闭包函数
println(fun3(2)(7)) //调用柯里化函数

三.案例
/*
比较两个字符串在忽略大小写的情况下是否相等，注意，这里是两个任务：
全部转大写（或小写）
比较是否相等
针对这两个操作，我们用一个函数去处理的思想，其实也变成了两个函数处理的思想（柯里化）
*/

def eq(s1:String,s2:String): Boolean ={
s1.equals(s2)
}

//创建一个隐式类，用来增加集合的操作方法
implicit class TestEq(s:String){
def checkEq(ss:String)(f:(String,String) => Boolean): Boolean ={ //函数柯里化的方式
f(s.toLowerCase(),ss.toLowerCase())
}
}

val str = "hello"
val res = str.checkEq("HELLO")(eq)
println(res)

//方式二，直接传入一个匿名函数，并利用类型推断简写这个匿名函数
val res2 = str.checkEq("Hello")(_.equals(_))
println(res2)

一.基本介绍

控制抽象是这样的函数
1.参数是函数
2.函数参数没有输入值也没有返回值

二.代码演示

//像这样，参数是函数，函数没有输入值也没有返回值的函数，就是控制抽象
def myRun(f:()=>Unit): Unit ={
new Thread{
override def run(): Unit = {
f()
}
}.start()
}

myRun { //这里就是调用myRun这个函数
() => //这里表示没有传入参数也没有返回值
println("开始干活！")
Thread.sleep(5000)
println("干完了")
}

三.案例
/*
利用控制抽象写出until函数，实现一下代码
var n = 10
while (n > 0){
n -= 1
println(n)
}
*/

var x = 10
until(x > 0){
x -= 1
println(x)
}

//创建一个控制抽象函数，这里也用到了函数柯里化
def until(f1: => Boolean)(f2: => Unit): Unit = {
if (f1){
f2
until(f1)(f2)
}

子主题

子主题

基本介绍

Actor模型

Actor模型说明

Actor工作机制

Actor间传递消息机制

一.代码演示
//当我们继承Actor之后，就是一个Actor了，核心方法receive（抽象方法）需要重写
class actorToActor extends Actor{
//1.receive 方法会被该 Actor 的 mailbox（实现了Runable接口） 调用
//2.当mailbox 接收到消息后，就会调用receive方法
//3.Receive是一个偏函数
//4.type Receive = PartialFunction[Any, Unit] ---> 可以接收任意类型的值，没有返回值

override def receive: Receive = {
case "hello" => println("hello too")
case "ok" => println("ok too")
case "exit" => {
println("接受到exit，退出指令~~~")
context.stop(self) //停止了当前的ActorRef，即停掉了mailbox
context.system.terminate() //停止了ActorSystem
}
case _ => println("没有接受到值")
}
}

object actorToActorDemo{
//先创建一个ActorSystem，专门用于创建创建actor
private val actorSystem = ActorSystem("actorSystem") //括号里面的是ActorSystem的名字
//利用ActorSystem创建一个actor的引用，即实例化actorToActor类 "A_actor"这个是actor引用(ActorRef)的名字
//Props[actorToActor]这里运用了反射机制
private val a_actorRef: ActorRef = actorSystem.actorOf(Props[actorToActor],"A_actor")

def main(args: Array[String]): Unit = {
//通过a_actorRef给A_actor发消息，实际上 是发送到A_actor的mailbox，然后通过mailbox提交给A_actor
//这里是有序发送
//mailbox是Runable机制，所以程序需要手动结束
a_actorRef ! "ok"
a_actorRef ! "hello"
a_actorRef ! "exit"
}
}

二.Actor自我通讯机制小结和说明

当程序执行 val a_actorRef: ActorRef = actorSystem.actorOf(Props[actorToActor],"A_actor")，就会完成如下任务

1.actorSystem是ActorSystem("actorSystem")这样创建的

2.这里的Prop[actorToActor]会使用反射机制，创建一个actorToActor对象，如果是actorSystem.actorOf(Prop(new actorToActor),"a_actorRef") 就是使用new的方式创建一个a_actorRef对象，这里Porp要用小括号

3.先创建一个actorToActor对象的代理对象a_actorRef，使用a_actorRef才能发送消息。

4.会在底层创建Dispatcher Message，这是一个线程池，用于纷分发消息，消息会发送到对应的Actor的mailbox

5.会在底层创建actorToActor的mailbox对象，该对象是一个队列，可以接受dispatcher Message发送的消息

6.mailbox实现了Runnable接口，是一个线程，一直运行并调用actor的receive方法，因此dispatcher Message向mailbox发消息时，actor的receive就可以得到消息

7.a_actorRef ! "ok"，表示把ok消息发送到actorToActor的mailbox（通过dispatcher Message转发）

一.代码演示
class AActor(actorRef: ActorRef) extends Actor {
val bActorRef :ActorRef = actorRef
var count = 0

override def receive: Receive = {
case "start" => {
println("游戏开始！！")
self ! "我打!"
}
case "我打!" => {
println("我是A aaaaaaa")
count += 1
Thread.sleep(1000)
bActorRef ! "我打!" //向B Actor发送 “我打”
if (count == 10) { //当count等于10时，关闭AActor和BActor和ActorSystem
context.stop(self)
context.stop(sender())
context.system.terminate()
}
}
}
}

class BActocr extends Actor {
override def receive: Receive = {
case "我打!" => {
println("我是B bbbbbbbbbb")
Thread.sleep(1000)
sender() ! "我打!" //向发件人发送 “我打”
}
}
}

object ActorGame extends App {
//创建ActorSystem，名字叫做actorSystem
val actorSystem = ActorSystem("actorSystem")
val BRef: ActorRef = actorSystem.actorOf(Props[BActocr], "B")
val ARef: ActorRef = actorSystem.actorOf(Props(new AActor(BRef)), "A")
ARef ! "start"
}

二.Actor的receive方法小结

1.每个Actor都有对应的mailbox
2.mailbox实现了Runnable接口，一直处于运行状态
3.当消息到达mailbox时，mailbox就会调用receive方法，将消息推送给对应的Actor

Akka支持面向大并发后端服务程序

1.网络编程有两种
1.TCP socket编程，是网络编程的主流。之所以叫TCP socket编程，是因为底层是基于ICP/IP协议的。比如：QQ聊天
2.b/s结构的http编程，我们使用浏览器去访问服务器时，使用的就是http协议，而http底层依旧是用tcp socket实现的。比如：京东

2.TCP/IP协议
TCP/IP协议，中文译名叫做传输控制协议/因特网互联协议，又叫网络通讯协议，这个协议时internet最基本的协议，Internet国际互联网的基础，简单的说，就是由网络层的ip协议和传输层的icp协议组成的

3.端口使用注意
1.在计算机（尤其是服务器）要尽量的少开端口
2.一个端口只能被一个程序监听
3.如果使用netstat -an 可以查看本机有哪些端口在监听
4.可以使用netstat -anb 来查看监听端口pid，在结合任务管理器关闭不安全的端口

一.学习设计者模式的必要性

1.面试需要
2.读源码时可以用到，尤其是一些大型的框架使用设计模式
3.设计模式能让专业人之间交流方便
4.提高代码的易维护性
5.设计模式是编程经验的总结，简单理解：即通用的编程应用场景的模式化，套路化（站在软件设计层面思考）

二.设计模式的介绍

1.设计模式是程序员在面对同类软件工程设计问题上所总结出来的有用的经验，它不是代码，是一种思想
2.设计模式的本质提高了软件的维护性，通用性和扩展性，并降低了软件的复杂度
3.设计模式不限于某种语言

三.设计模式的分类（23种）

1.创建型模式：单例模式，抽象工厂模式，建造者模式，工厂模式，原型模式

2.结构性模式：适配器模式，桥接模式，装饰模式，组合模式，外观模式，享元模式，代理模式

3.行为者模式：模板方法模式，命令模式，迭代器模式，观察者模式，中介者模式，备忘录模式，解释器模式，状态模式，策略模式，职责链模式，访问者模式 

一.基本介绍
1.如果我们要求函数的参数可以接受任意泛型。可以使用泛型，这个类型可以代表任意的数据类型。

2.例如List，在创建List时，可以传入整型，字符串，浮点数等等任意类型。那是因为List在类定义时引用了泛型。

二.泛型应用案例1
1.编写一个Message类

2.可以构建Int类型的Message,String类型的Message.

3.要求使用泛型来完成设计,(说明：不能使用Any)

Java下界 下界

Scala上界

在Scala里表示某个类型是A类型的子类型，也称上限或者上界。使用<:关键字。语法如下
[T <: A]
//使用通配符
[_ <: A]

Scala下界
在Scala中下界，使用 >: 关键字
[T >: A] //表示T的下界是A
//使用通配符
[_ >: A]

Scala下界使用小结

①对于下界，可以传入任意类型

②传入和A直系的，是A父类就按照A父类处理，如果是A的子类，则按照A处理

③如果传入的对象与A无关，一律按照Object处理

④也就是说下界可以随便传，只是处理方式不一样

⑤不能使用上界的思路来类推下界的含义

一.基本介绍
1.Scala的协变(+)，逆变(-)，协变covariant、逆变contravariant、不可变invariant

2.对于一个带类型参数的类型，比如 List[T]，如果对A及其子类型B，满足 List[B]也符合List[A]的子类型，那么就称为covariance(协变) ，如果 List[A]是 List[B]的子类型，即与原来的父子关系正相反，则称为contravariance(逆变)。如果一个类型支持协变或逆变，则称这个类型为variance(翻译为可变的或变型)，否则称为invariance(不可变的)

3在Java里，泛型类型都是invariant，比如 List<String> 并不是 List<Object> 的子类型。而scala支持，可以在定义类型时声明(用加号表示为协变，减号表示逆变)，如: trait List[+T] // 在类型定义时声明为协变这样会把List[String]作为List[Any]的子类型。

二.应用实例

在这里引入关于这个符号的说明，在声明Scala的泛型类型时，“+”表示协变，而“-”表示逆变 
C[+T]：如果A是B的子类，那么C[A]是C[B]的子类，称为协变 
C[-T]：如果A是B的子类，那么C[B]是C[A]的子类，称为逆变 
C[T]：无论A和B是什么关系，C[A]和C[B]没有从属关系。称为不变.

val t: Temp[Super] = new Temp[Sub]("hello world1")
class Temp3[A](title: String) { //Temp3[+A] //Temp[-A]
override def toString: String = {
title
}}

//支持协变
class Super
class Sub extends Super