初学者入门Scala讲解!!!Scala六大特性,Scala高阶语法讲解二【小二讲堂】

版权声明：本文为博主原创文章,转载请注明出处！！！小二学堂：https://blog.csdn.net/Mirror_w https://blog.csdn.net/Mirror_w/article/details/89392429

上篇入门级Scala介绍主要是对scala基本语法介绍下面继续高级语法的讲解
本篇博文主要针对新手入门Scala的详细介绍。主要是语法的介绍，代码案例全是小二手工操作出来的野生代码！！！

小二推荐：https://blog.csdn.net/Mirror_w/article/details/89348834

一、Scala介绍

Scala是一门多范式的编程语言，一种类似java的编程语言，设计初衷是实现可伸缩的语言 、并集成面向对象编程和函数式编程的各种特性。
总而言之，Scala是一种函数式面向对象语言，它融汇了许多前所未有的特性，而同时又运行于JVM之上。随着开发者对Scala的兴趣日增，以及越来越多的工具支持，无疑Scala语言将成为你手上一件必不可少的工具。

在Scala的创建之初，并没有怎么引起重视，随着Apache Spark和Apache Kafka这样基于Scala的大数据框架的崛起，Scala逐步映入大数据从业者的眼帘。
Scala的拥护者们觉得Scala的主要优势是速度和它的表达性。眼下使用scala的作为支撑公司开发语言的包含Foursquare和Twitter。2009年Twitter把大部分后台系统的开发语言从Ruby换成了Scala。

1.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和cla别
Scall中有calss和Object,定义class是可以传参，但是参数传递的时候一定要指定参数类型
-Scala中的object相当于java中的单例，类似于java中的工具类，object中定义的所有属性和方法都是静态的。
注意：scala中定义类和object的作用是将静态的与非静态的相剥离

9，Scala字符串

• 1). String

val str="abcd"
val str1="ABCD"
println(str.indexOf(98))
println(str1.indexOf("B"))
···
- 2). StringBuilder 可变
···
val builderstr=new StringBuilder()
 builderstr.append("abc")
 builderstr.append("ooo")
println(builderstr)
···
- 3). string操作方法举例
Ø 比较:equals
Ø 比较忽略大小写:equalsIgnoreCase
Ø indexOf：如果字符串中有传入的assci码对应的值，返回下标
String 的常见方法：
- String 方法
···
char charAt(int index)
返回指定位置的字符  从0开始
	
int compareTo(Object o)
比较字符串与对象
	
int compareTo(String anotherString)
按字典顺序比较两个字符串
	
int compareToIgnoreCase(String str)
按字典顺序比较两个字符串，不考虑大小写
	
String concat(String str)
将指定字符串连接到此字符串的结尾
	
boolean contentEquals(StringBuffer sb)
将此字符串与指定的 StringBuffer 比较。
	
static String copyValueOf(char[] data)
返回指定数组中表示该字符序列的 String
	
static String copyValueOf(char[] data, int offset, int count)
返回指定数组中表示该字符序列的 String
	
boolean endsWith(String suffix)
测试此字符串是否以指定的后缀结束
	
boolean equals(Object anObject)
将此字符串与指定的对象比较
	
boolean equalsIgnoreCase(String anotherString)
将此 String 与另一个 String 比较，不考虑大小写
	
byte getBytes()
使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
	
byte[] getBytes(String charsetName
使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
	
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符从此字符串复制到目标字符数组
	
int hashCode()
返回此字符串的哈希码
16	
int indexOf(int ch)
返回指定字符在此字符串中第一次出现处的索引（输入的是ascii码值）
	
int indexOf(int ch, int fromIndex)
返返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索
	
int indexOf(String str)
返回指定子字符串在此字符串中第一次出现处的索引
	
int indexOf(String str, int fromIndex)
返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
	
String intern()
返回字符串对象的规范化表示形式
	
int lastIndexOf(int ch)
返回指定字符在此字符串中最后一次出现处的索引
	
int lastIndexOf(int ch, int fromIndex)
返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索
	
int lastIndexOf(String str)
返回指定子字符串在此字符串中最右边出现处的索引
	
int lastIndexOf(String str, int fromIndex)
返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
	
int length()
返回此字符串的长度
	
boolean matches(String regex)
告知此字符串是否匹配给定的正则表达式
	
boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
测试两个字符串区域是否相等
28	
boolean regionMatches(int toffset, String other, int ooffset, int len)
测试两个字符串区域是否相等
	
String replace(char oldChar, char newChar)
返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的
	
String replaceAll(String regex, String replacement
使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串
	
String replaceFirst(String regex, String replacement)
使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串
	
String[] split(String regex)
根据给定正则表达式的匹配拆分此字符串
	
String[] split(String regex, int limit)
根据匹配给定的正则表达式来拆分此字符串
	
boolean startsWith(String prefix)
测试此字符串是否以指定的前缀开始
	
boolean startsWith(String prefix, int toffset)
测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
	
CharSequence subSequence(int beginIndex, int endIndex)
返回一个新的字符序列，它是此序列的一个子序列
	
String substring(int beginIndex)
返回一个新的字符串，它是此字符串的一个子字符串
	
String substring(int beginIndex, int endIndex)
返回一个新字符串，它是此字符串的一个子字符串
	
char[] toCharArray()
将此字符串转换为一个新的字符数组
	
String toLowerCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为小写
	
String toLowerCase(Locale locale)
使用给定 Locale 的规则将此 String 中的所有字符都转换为小写
	
String toString()
返回此对象本身（它已经是一个字符串！）
	
String toUpperCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为大写
	
String toUpperCase(Locale locale)
使用给定 Locale 的规则将此 String 中的所有字符都转换为大写
	
String trim()
删除指定字符串的首尾空白符
	
static String valueOf(primitive data type x)
返回指定类型参数的字符串表示形式

四、集合

1.数组
1). 创建数组
Ø new ArrayInt
赋值：arr(0) = xxx
Ø ArrayString
2). 数组遍历
Ø for
Ø foreach
3). 创建一维数组和二维数组
4). 数组中方法举例
Ø Array.concate：合并数组
Array.fill(5)(“bjsxt”)：创建初始值的定长数组
//1.创建数组

  val arr=new Array[Int](3)
  //赋值
  arr(0)=0
  arr(1)=1
  arr(2)=2

//2.创建数组

  val arr1=Array[String]("zhangsan","lisi","wangwu")


  //遍历数组
  //第一种方式
  for (i<-arr){
    println(i)
  }
  //第二种方式
  arr1.foreach(println(_))

   /**
     * 创建二维数组和遍历
     */

    val arr3 = new Array[Array[String]](3)
    arr3(0)=Array("1","2","3")
    arr3(1)=Array("4","5","6")
    arr3(2)=Array("7","8","9")
    for(i <- 0 until arr3.length){
      for(j <- 0 until arr3(i).length){
        print(arr3(i)(j)+" ")
      }
      println()
    }
        var count = 0
    for(arr <- arr3 ;i <- arr){
      if(count%3 == 0){
        println()
      }
      print(i+" ")
      count +=1 
    }
    
    arr3.foreach { arr  => {
      arr.foreach { println }
    }}
    
    
    val arr4 = Array[Array[Int]](Array(1,2,3),Array(4,5,6))
    arr4.foreach { arr => {
      arr.foreach(i => {
        println(i)
      })
    }}
    println("-------")
    for(arr <- arr4;i <- arr){
      println(i)
    }

• 数组中的常用方法：
  序号 方法和描述

1	
def apply( x: T, xs: T* ): Array[T]
创建指定对象 T 的数组, T 的值可以是 Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean。
2	
def concat[T]( xss: Array[T]* ): Array[T]
合并数组
3	
def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit
复制一个数组到另一个数组上。相等于 Java's System.arraycopy(src, srcPos, dest, destPos, length)。
4	
def empty[T]: Array[T]
返回长度为 0 的数组
5	
def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T]
返回指定长度数组，每个数组元素为指定函数的返回值。
以上实例数组初始值为 0，长度为 3，计算函数为a=>a+1：
scala> Array.iterate(0,3)(a=>a+1)
res1: Array[Int] = Array(0, 1, 2)
6	
def fill[T]( n: Int )(elem: => T): Array[T]
返回数组，长度为第一个参数指定，同时每个元素使用第二个参数进行填充。
7	
def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]]
返回二数组，长度为第一个参数指定，同时每个元素使用第二个参数进行填充。
8	
def ofDim[T]( n1: Int ): Array[T]
创建指定长度的数组
9	
def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]]
创建二维数组
10	
def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]]
创建三维数组
11	
def range( start: Int, end: Int, step: Int ): Array[Int]
创建指定区间内的数组，step 为每个元素间的步长
12	
def range( start: Int, end: Int ): Array[Int]
创建指定区间内的数组
13	
def tabulate[T]( n: Int )(f: (Int)=> T): Array[T]
返回指定长度数组，每个数组元素为指定函数的返回值，默认从 0 开始。
以上实例返回 3 个元素：
scala> Array.tabulate(3)(a => a + 5)
res0: Array[Int] = Array(5, 6, 7)
14	
def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]]
返回指定长度的二维数组，每个数组元素为指定函数的返回值，默认从 0 开始。

2.list集合

• 1）. 创建list
  val list = List(1,2,3,4)
  Ø Nil长度为0的list
• 2）. list遍历
  foreach ，for
• 3）. list方法举例
  Ø filter:过滤元素
  Ø count:计算符合条件的元素个数
  Ø map：对元素操作
  Ø flatmap ：压扁扁平,先map再flat

//创建创建集合
val list = List(1,2,3,4,5)
//1.遍历集合
list.foreach(println(_))
//2.遍历集合
list.foreach{x=>print(x)}
//count 计数统计，统计出集合中大于3的个数
val value=list.count{x=> x>3}
print(value)

• 4)可变长的list

//可变长的List
val nameList = List(
  "hello bjsxt",
  "hello xasxt",
  "hello shsxt"
)
val listbuffer=ListBuffer[Int](1,2,3,4,5)
listbuffer.append(6,7,8)
listbuffer.foreach(print(_))

• 5)map

//字符串切分--map
val nameList = List(
  "hello bjsxt",
  "hello xasxt",
  "hello shsxt"
)
val stringses: List[Array[String]] = nameList.map(one=>{one.split(" ")})
//遍历
stringses.foreach(arr=>{arr.foreach(println)})

• flatmap 数据扁平化

//flatMap
val strings: List[String] = nameList.flatMap(one=>{one.split(" ")})
strings.foreach(println(_))

• 6)list的filter过滤器

//map
val nameList = List(
  "hello bjsxt",
  "hello xasxt",
  "hello shsxt"
)
//filter---过滤掉不是“prttern_str”的
val strings: List[String] = nameList.filter(one=>{"hello bjsxt".equals(one)})
//遍历
strings.foreach(println)
//将指定pattern_的过滤掉
val strings1: List[String] = nameList.filter(onr=>{!"hello bjsxt".equals(onr)})
strings1.foreach(println)

• 7)count计数

val lists=List[Int](1,2,3,4,543,2,21,1,2)
//count计数
val i: Int = lists.count(one=>{1==one})
println(i)

• list基本操作语法:

1	def +(elem: A): List[A]
前置一个元素列表
2	def ::(x: A): List[A]
在这个列表的开头添加的元素。
3	def :::(prefix: List[A]): List[A]
增加了一个给定列表中该列表前面的元素。
4	def ::(x: A): List[A]
增加了一个元素x在列表的开头
5	def addString(b: StringBuilder): StringBuilder
追加列表的一个字符串生成器的所有元素。
6	def addString(b: StringBuilder, sep: String): StringBuilder
追加列表的使用分隔字符串一个字符串生成器的所有元素。
7	def apply(n: Int): A
选择通过其在列表中索引的元素
8	def contains(elem: Any): Boolean
测试该列表中是否包含一个给定值作为元素。
9	def copyToArray(xs: Array[A], start: Int, len: Int): Unit
列表的副本元件阵列。填充给定的数组xs与此列表中最多len个元素，在位置开始。
10	def distinct: List[A]
建立从列表中没有任何重复的元素的新列表。
11	def drop(n: Int): List[A]
返回除了第n个的所有元素。
12	def dropRight(n: Int): List[A]
返回除了最后的n个的元素
13	def dropWhile(p: (A) => Boolean): List[A]
丢弃满足谓词的元素最长前缀。
14	def endsWith[B](that: Seq[B]): Boolean
测试列表是否使用给定序列结束。
15	def equals(that: Any): Boolean
equals方法的任意序列。比较该序列到某些其他对象。
16	def exists(p: (A) => Boolean): Boolean
测试谓词是否持有一些列表的元素。
17	def filter(p: (A) => Boolean): List[A]
返回列表满足谓词的所有元素。
18	def forall(p: (A) => Boolean): Boolean
测试谓词是否持有该列表中的所有元素。
19	def foreach(f: (A) => Unit): Unit
应用一个函数f以列表的所有元素。
20	def head: A
选择列表的第一个元素
21	def indexOf(elem: A, from: Int): Int
经过或在某些起始索引查找列表中的一些值第一次出现的索引。
22	def init: List[A]
返回除了最后的所有元素
23	def intersect(that: Seq[A]): List[A]
计算列表和另一序列之间的多重集交集。
24	def isEmpty: Boolean
测试列表是否为空
25	def iterator: Iterator[A]
创建一个新的迭代器中包含的可迭代对象中的所有元素
26	def last: A
返回最后一个元素
27	def lastIndexOf(elem: A, end: Int): Int
之前或在一个给定的最终指数查找的列表中的一些值最后一次出现的索引
28	def length: Int
返回列表的长度
29	def map[B](f: (A) => B): List[B]
通过应用函数以g这个列表中的所有元素构建一个新的集合
30	def max: A
查找最大的元素
31	def min: A
查找最小元素
32	def mkString: String
显示列表的字符串中的所有元素
33	def mkString(sep: String): String
显示的列表中的字符串中使用分隔串的所有元素
34	def reverse: List[A]
返回新列表，在相反的顺序元素
35	def sorted[B >: A]: List[A]
根据排序对列表进行排序
36	def startsWith[B](that: Seq[B], offset: Int): Boolean
测试该列表中是否包含给定的索引处的给定的序列
37	def sum: A
概括这个集合的元素
38	def tail: List[A]
返回除了第一的所有元素
39	def take(n: Int): List[A]
返回前n个元素
40	def takeRight(n: Int): List[A]
返回最后n个元素
41	def toArray: Array[A]
列表以一个数组变换
42	def toBuffer[B >: A]: Buffer[B]
列表以一个可变缓冲器转换
43	def toMap[T, U]: Map[T, U]
此列表的映射转换
44	def toSeq: Seq[A]
列表的序列转换
45	def toSet[B >: A]: Set[B]
列表到集合变换
46	def toString(): String
列表转换为字符串

3.set

1. 创建set
   注意：set集合会自动去重
   //创建set集合
   val s=Set(1,2,3,4,1)

• 2.set遍历

foreach，for
//遍历1
for(a<-s)
  println(a)
//遍历2
s.foreach(println)

3. set方法举例

Ø 交集：intersect ,&
Ø 差集: diff ,&~
Ø 子集:subsetOf
Ø 最大:max
Ø 最小:min
Ø 转成数组，toList
Ø 转成字符串：mkString(“~”)

• 代码演示：

//创建set集合
    val s1=Set(1,2,3,4,1)
    val s2=Set(1,3,5)


    //交集
   val ints: Set[Int] = s1.intersect(s2)
   val ints: Set[Int] = s1.&(s2)

    //差集
    val ints: Set[Int] = s1.diff(s2)
   val ints: Set[Int] = s1.&~(s2)


    //子集
    val bool: Boolean = s1.subsetOf(s2)
    println(bool)

    //求集合中最大值
    println(s1.max)

    //求集合中的最小值
    println(s1.min)

    //转成数组
    val list: List[Int] = s1.toList

    //转成字符串
    val string: String = list.mkString

        //遍历
   ints.foreach(println)

• Set的语法方法总结：
  下表列出了 Scala Set 常用的方法：
  序号 方法及描述

1	
def +(elem: A): Set[A]
为集合添加新元素，x并创建一个新的集合，除非元素已存在
2	
def -(elem: A): Set[A]
移除集合中的元素，并创建一个新的集合
3	
def contains(elem: A): Boolean
如果元素在集合中存在，返回 true，否则返回 false。
4	
def &(that: Set[A]): Set[A]
返回两个集合的交集
5	
def &~(that: Set[A]): Set[A]
返回两个集合的差集
6	
def +(elem1: A, elem2: A, elems: A*): Set[A]
通过添加传入指定集合的元素创建一个新的不可变集合
7	
def ++(elems: A): Set[A]
合并两个集合
8	
def -(elem1: A, elem2: A, elems: A*): Set[A]
通过移除传入指定集合的元素创建一个新的不可变集合
9	
def addString(b: StringBuilder): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区
10	
def addString(b: StringBuilder, sep: String): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区，并使用指定的分隔符
11	
def apply(elem: A)
检测集合中是否包含指定元素
12	
def count(p: (A) => Boolean): Int
计算满足指定条件的集合元素个数
13	
def copyToArray(xs: Array[A], start: Int, len: Int): Unit
复制不可变集合元素到数组
14	
def diff(that: Set[A]): Set[A]
比较两个集合的差集
15	
def drop(n: Int): Set[A]]
返回丢弃前n个元素新集合
16	
def dropRight(n: Int): Set[A]
返回丢弃最后n个元素新集合
17	
def dropWhile(p: (A) => Boolean): Set[A]
从左向右丢弃元素，直到条件p不成立
18	
def equals(that: Any): Boolean
equals 方法可用于任意序列。用于比较系列是否相等。
19	
def exists(p: (A) => Boolean): Boolean
判断不可变集合中指定条件的元素是否存在。
20	
def filter(p: (A) => Boolean): Set[A]
输出符合指定条件的所有不可变集合元素。
21	
def find(p: (A) => Boolean): Option[A]
查找不可变集合中满足指定条件的第一个元素
22	
def forall(p: (A) => Boolean): Boolean
查找不可变集合中满足指定条件的所有元素
23	
def foreach(f: (A) => Unit): Unit
将函数应用到不可变集合的所有元素
24	
def head: A
获取不可变集合的第一个元素
25	
def init: Set[A]
返回所有元素，除了最后一个
26	
def intersect(that: Set[A]): Set[A]
计算两个集合的交集
27	
def isEmpty: Boolean
判断集合是否为空
28	
def iterator: Iterator[A]
创建一个新的迭代器来迭代元素
29	
def last: A
返回最后一个元素
30	
def map[B](f: (A) => B): immutable.Set[B]
通过给定的方法将所有元素重新计算
31	
def max: A
查找最大元素
32	
def min: A
查找最小元素
33	
def mkString: String
集合所有元素作为字符串显示
34	
def mkString(sep: String): String
使用分隔符将集合所有元素作为字符串显示
35	
def product: A
返回不可变集合中数字元素的积。
36	
def size: Int
返回不可变集合元素的数量
37	
def splitAt(n: Int): (Set[A], Set[A])
把不可变集合拆分为两个容器，第一个由前 n 个元素组成，第二个由剩下的元素组成
38	
def subsetOf(that: Set[A]): Boolean
如果集合A中含有子集B返回 true，否则返回false
39	
def sum: A
返回不可变集合中所有数字元素之和
40	
def tail: Set[A]
返回一个不可变集合中除了第一元素之外的其他元素
41	
def take(n: Int): Set[A]
返回前 n 个元素
42	
def takeRight(n: Int):Set[A]
返回后 n 个元素
43	
def toArray: Array[A]
将集合转换为数组
44	
def toBuffer[B >: A]: Buffer[B]
返回缓冲区，包含了不可变集合的所有元素
45	
def toList: List[A]
返回 List，包含了不可变集合的所有元素
46	
def toMap[T, U]: Map[T, U]
返回 Map，包含了不可变集合的所有元素
47	
def toSeq: Seq[A]
返回 Seq，包含了不可变集合的所有元素
48	
def toString(): String
返回一个字符串，以对象来表示

5.元组

• 1). 元组定义
  与列表一样，与列表不同的是元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的。
• 2). 创建元组与取值
  Ø val tuple = new Tuple（1） 可以使用new
  Ø val tuple2 = Tuple（1,2） 可以不使用new，也可以直接写成val tuple3 =（1,2,3）
  Ø 取值用”._XX” 可以获取元组中的值
  注意：tuple最多支持22个参数

//tuple创建方式一
var tuple1=new Tuple1(1)
//tuple创建方式二
var tuple3=Tuple3(1,2,3)
//tuple创建方式三
var tuple5=(1,2,3,4,5,6)

//tuple遍历不支持for foreach
  val iterator: Iterator[Any] = tuple5.productIterator
  while (iterator.hasNext)
    println(iterator.next())

//迭代器foreach
iterator.foreach(println)

1). swap,toString方法

6.trait特性

• 概念理解
  Scala Trait(特征) 相当于 Java 的接口，实际上它比接口还功能强大。
  与接口不同的是，它还可以定义属性和方法的实现。

一般情况下Scala的类可以继承多个Trait，从结果来看就是实现了多重继承。Trait(特征) 定义的方式与类类似，但它使用的关键字是 trait。

扫描二维码关注公众号，回复： 5958041 查看本文章

• 2.举例：trait中带属性带方法实现
  注意：
  Ø 继承的多个trait中如果有同名的方法和属性，必须要在类中使用“override”重新定义。
  Ø trait中不可以传参数

trait Read {
  val typeRead="name"
  val gender="m"
 
  def read(name:String){
    print(s"$name is reading...")
  }

}
trait Listen{
  val typeListen="listen"
  val gender="f"
  def listen(name:String){
    print(s"$name is listening ...")
  }
}
class Person() extends Read with Listen{
 override val gender="f"
  
}
object ScalaD {
 
  def main(args: Array[String]): Unit = {
    val p =new Person();
       p.read("name")
  }

}

. 举例：trait中带方法不实现

object ScalaD1 {
  def main(args: Array[String]): Unit = {
    val p1 = new Point(1, 2)
    val p2 = new Point(1, 3)
    p1.isEqual(p2)
    p1.isNotEqual(p1)
  }

}

trait Equal {
  //定义接口
  def isEqual(x: Any): Boolean
  def isNotEqual(x: Any) = {
    !isEqual(x)
  }
}

class Point(x: Int, y: Int) extends Equal {
  val xx = x
  val yy = y
  def isEqual(p: Any) = {
    p.isInstanceOf[Point] && p.asInstanceOf[Point].xx == xx
  }

}

7.模式匹配match

• 1.概念理解：
  Scala 提供了强大的模式匹配机制，应用也非常广泛。
  一个模式匹配包含了一系列备选项，每个都开始于关键字 case。
  每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。
• 2.代码及注意点
  Ø 模式匹配不仅可以匹配值还可以匹配类型
  Ø 从上到下顺序匹配，如果匹配到则不再往下匹配
  Ø 都匹配不上时，会匹配到case _ ,相当于default
  match 的最外面的”{ }”可以去掉看成一个语句

object MatchDemo {

  def main(args: Array[String]): Unit = {
    val tuple = Tuple6(1,2,"23",55d,2,0)
    val iterator = tuple.productIterator
    while(iterator.hasNext){
      matchTest(iterator.next())
    }
  }

/*

• 模式匹配时，不仅可以匹配值还可以匹配函数
• 模式匹配时，如果匹配到对应的类型，就不会向下继续匹配了
• 模式匹配时，如果匹配不上，会自动匹配case_值
  */

 def matchTest(x: Any) = {
   x match {
     case x: Int => println("type is int ")
     case 1 => println("reslult is 1")
     case x: String => println("type is string")
     case _=> println ("no match")
   }
 }
}

8,偏函数

如果一个方法中没有match 只有case，这个函数可以定义成PartialFunction偏函数。偏函数定义时，不能使用括号传参，默认定义PartialFunction中传入一个值，匹配上了对应的case,返回一个值，只能匹配同种类型。
object partationDemo {

/*

• 偏函数创建
• PartialFunction[String,String]
• 第一个参数是调用方法时必须要传递的
• 第二个参数是返回的类型
  */

def myFun:PartialFunction[String,String]={
  case "hello"=>{"value is hello"}
  case "a"=>{"this is a "}
  case _=>{"this is a undefine"}
}

def main(args: Array[String]): Unit = {
    print(myFun("a"))    
}

}

9.样例类(case classes)

• 1.概念理解
  使用了case关键字的类定义就是样例类(case classes)，样例类是种特殊的类。实现了类构造参数的getter方法（构造参数默认被声明为val），当构造参数是声明为var类型的，它将帮你实现setter和getter方法。
  Ø 样例类默认帮你实现了toString,equals，copy和hashCode等方法。
  Ø 样例类可以new, 也可以不用new

object casedemo {
  def main(args: Array[String]): Unit = {
    val h1 = new Human("zhangsan",1)
    val h2 = new Human("zhangsan",1)
    //当不是样例类的时候，返回fasle
    println(h1.equals(h2))
  }
  
}
case class Human(name:String,age:Int){
  
}

10,隐式转换

隐式转换是在Scala编译器进行类型匹配时，如果找不到合适的类型，那么隐式转换会让编译器在作用范围内自动推导出来合适的类型。

• 1.隐式值与隐式参数
  隐式值是指在定义参数时前面加上implicit。隐式参数是指在定义方法时，方法中的部分参数是由implicit修饰【必须使用柯里化的方式，将隐式参数写在后面的括号中】。隐式转换作用就是：当调用方法时，不必手动传入方法中的隐式参数，Scala会自动在作用域范围内寻找隐式值自动传入。
• 隐式值和隐式参数注意：
  1). 同类型的参数的隐式值只能在作用域内出现一次，同一个作用域内不能定义多个类型一样的隐式值。
  2). implicit 关键字必须放在隐式参数定义的开头
  3). 一个方法只有一个参数是隐式转换参数时，那么可以直接定义implicit关键字修饰的参数，调用时直接创建类型不传入参数即可。
  4). 一个方法如果有多个参数，要实现部分参数的隐式转换,必须使用柯里化这种方式,隐式关键字出现在后面，只能出现一次
  /*

• 隐式转换
• 隐式值和隐式参数 ：当调用函数时会到对象中找符合条件的隐式参数
• 注意：

•  不能有两个隐式参数，当不需要隐式参数时，直接传递就行了
  

•  当有隐式参数和非隐式参数时，就可以使用柯里化参数就行了
  

*/

object Lession_implicitTest {

 implicit val sname = "zhgnsan"
 def fun(age:Int)(implicit name: String) {
   print(s"$name is a $age boy")
 }
 def main(args: Array[String]): Unit = {
   fun(12)
 }
 }

• 1.） 隐式转换函数
  隐式转换函数是使用关键字implicit修饰的方法。当Scala运行时，假设如果A类型变量调用了method()这个方法，发现A类型的变量没有method()方法，而B类型有此method()方法，会在作用域中寻找有没有隐式转换函数将A类型转换成B类型，如果有隐式转换函数，那么A类型就可以调用method()这个方法。
  隐式转换函数注意：隐式转换函数只与函数的参数类型和返回类型有关，与函数名称无关，所以作用域内不能有相同的参数类型和返回类型的不同名称隐式转换函数。

/*
 * 隐式方法 implicit
 */
object Lession_implicitTest2 {

  //创建隐式方法传递Pig对象,返回一个Bird
  implicit def PigToBird(p: Pig): Bird = {
    //将pig的name传递给Bird并返回一个Bird对象
    new Bird(p.name)
  }

  def main(args: Array[String]): Unit = {
    val p = new Pig("xiaozhu")
    //此处调用Pig的canFly方法时，向后首先会在Pig类中进行寻找，如果没有则就会在对象中寻找有没有隐式付昂发
    p.canFly()

  }
}
//创建Bird对象
class Bird(xname: String) {
  val name = xname
  def canFly() = {
    print(s"$name can fly")
  }
}
//创建Pig对象
class Pig(xname: String) {
  val name = xname

}

11.Actor Model

• 1.概念理解
  Actor Model是用来编写并行计算或分布式系统的高层次抽象（类似java中的Thread）让程序员不必为多线程模式下共享锁而烦恼,被用在Erlang 语言上, 高可用性99.9999999 % 一年只有31ms 宕机Actors将状态和行为封装在一个轻量的进程/线程中，但是不和其他Actors分享状态，每个Actors有自己的世界观，当需要和其他Actors交互时，通过发送事件和消息，发送是异步的，非堵塞的(fire-andforget)，发送消息后不必等另外Actors回复，也不必暂停，每个Actors有自己的消息队列，进来的消息按先来后到排列，这就有很好的并发策略和可伸缩性，可以建立性能很好的事件驱动系统。
• Actor的特征：
  Ø ActorModel是消息传递模型,基本特征就是消息传递
  Ø 消息发送是异步的，非阻塞的
  Ø 消息一旦发送成功，不能修改
  Ø Actor之间传递时，自己决定决定去检查消息，而不是一直等待，是异步非阻塞的
• 什么是Akka
  Akka 是一个用 Scala 编写的库，用于简化编写容错的、高可伸缩性的 Java 和Scala 的 Actor 模型应用，底层实现就是Actor,Akka是一个开发库和运行环境，可以用于构建高并发、分布式、可容错、事件驱动的基于JVM的应用。使构建高并发的分布式应用更加容易。
  spark1.6版本之前，spark分布式节点之间的消息传递使用的就是Akka，底层也就是actor实现的。1.6之后使用的netty传输。

import scala.actors.Actor

object Lenson_actor {

  /**
    *Actor用于消息发送，此处只是单项发送
    *
    */
  def main(args: Array[String]): Unit =  {
      var actor = new MyActor()
    actor.start()
    actor !"hello"
  }
}
class MyActor extends Actor{
   def act(): Unit = {
      receive{
        case s:String=>{print("this is a string type")}
        case _=>{print("no number")}
      }
  }
}


import scala.actors.Actor

object Lenson_actor {


  /**
    *Actor用于消息发送，此处只是单项发送
    *
    */
  def main(args: Array[String]): Unit =  {
      var actor1 = new MyActor1()
      var actor2 = new MyActor2(actor1)
    actor1.start()
    actor2.start()

  }
}
class MyActor1() extends Actor{
   def act(): Unit = {
      receive{
        case msg:MSG=>{
          if("zhangsan".equals(MSG)){
            println("I am  zhangsan")
          }else{
            println("I am lisi")
          }
          msg.actor!"successfully"
        }
        case _=>{print("no number")}
      }
  }
}
case class MSG(actor:Actor,Log:String)

class MyActor2(actor:Actor) extends Actor{
    actor ! MSG(this,"zhangsan")
  def act(): Unit = {

    receive{
      case s:String=>{
        print(s"msg : $s")
        actor ! MSG(this,"lisi")
      }
      case _=>{print("no number")}
    }
  }
}

敬请关注小二学堂，后续更新详解~！！！
小二学堂：https://blog.csdn.net/Mirror_w