Scala编程语言学习总结

                           Scala学习总结

一、Scala的简介

      Scala是一种基于JVM的编程语言，学习目的主要是为了Spark的学习与相关代码的编写。
    Scala的六大特征：

        1).Java和scala可以无缝混编，都是运行在JVM上的
	2).类型推测(自动推测类型)，不用指定类型  
	3).并发和分布式（Actor，类似Java多线程Thread） 
	4).特质trait，特征(类似java中interfaces 和 abstract结合)
	5).模式匹配，match case（类似java switch case）
	6).高阶函数（函数的参数是函数，函数的返回是函数），可进行函数式编程

二、Scala安装使用

1. windows安装,配置环境变量

• 官网下载scala2.10：https://www.scala-lang.org/download/2.10.4.html

• 下载好后安装。双击msi包安装,记住安装的路径。

• 配置环境变量（和配置jdk一样）
           ①新建SCALA_HOME，配置好Scala安装的目录位置信息。
           ②编辑Path变量，在后面追加如下：
             ;%SCALA_HOME%\bin;%SCALA_HOME%\jre\bin

• 打开cmd,输入：scala - version 看是否显示版本号，确定是否安装成功
  

2. Scala程序编译工具
       ①Scala ide
        下载网址：http://scala-ide.org/download/sdk.html
       ②推荐使用IDEA中配置scala插件
        1》 打开idea项目后，点击Configure->Plugins
        2》搜索scala，点击Install安装
        3》设置jdk，打开Project Structure,点击new 选择安装好的jdk路径
        4》创建scala项目，配置scala sdk(Software Development Kit)
   

三、Scala基础

1.数据类型

2.变量和常量的声明
    Scala中通常用var声明变量，可修改；用val声明常量，不可修改即不可对常量进行再赋值；不用指定数据类型，由Scala自己进行类型推测。
注意点： 在scala中每行后面不需要加分号，直接通过换行如来区分；但是一行中写了多个语句，语句与语句之间必须用分号来分割
例如：

var age = 18   ; var name = "angelababy"
    
    var heighat,score = 10
    val sex = "male"

3.类和对象

class :修饰的称为伴生类；定义在class中的属性都是动态的，用于实例化 的;scala中的class类默认可以传参数，默认的传参数就是默认的构造函数。class 类属性自带getter ，setter方法。使用class时要new （必须new，除非在对象伴生用apply方法【在加载类的时候默认自动调用】已实经例化好）,并且new的时候，class中除了方法不执行，其他都执行。

object: 修饰的称为伴生对象;定义在object中的属性（字段、方法）都是静 态的,main函数写在里面;scala 中的object是单例对象，相当于java中的工具类，可以看成是定义静态的方法的类.object不可以传参数。使用object时，不用new.

创建类

class Person{
  val name = "zhangsan"
  val age = 18
  def sayName() = {
    "my name is "+ name
  }
}

    在创建类时，可以在类名后面加入一个括号，括号中写定义的参数类型，括号中的参数就表示类的构造函数由括号内的参数组成。补充： ①当参数用var修饰那么可以通过对象修改其值；当参数用val修饰那么无法通过对象来修改值；当参数没有修饰符，那么在外部无法通过对象来调用。
      ②若想增加一个类的传入参数，则需要在声明的类中重写构造函数，这样就可以在mian函数中声明有增加的属性的对象，当然原来的对象也可以声明。
               重写this函数：

  /*
   *  重写的构造函数，参数不能有修饰符
   */
  def this (id:Int,name:String,facePower:Double ){
    //首先要调用父构造函数
    this(id,name)
    fcp = facePower
    
  }

创建对象

object Lesson_Class {
   def main(args: Array[String]): Unit = {
    val person = new Person()
    println(person.age);
    println(person.sayName())
  }
}

Apply方法
       使用此方法时，可以在main函数中不通过new来创建一个对象，即可以不用专门的一次一次地进行实例化，加载创建对象的这个类的时候，会自动调用apply这个方法，类似Java中的static静态块。
       Apply方法的使用用例：

object ScalaDemo01 {
  def main(args: Array[String]): Unit = {
    val p = new Person("zs",19)
     val person = Person("wagnwu",10)   //不用使用new来创建一个实例
  }
}

class Person(xname :String , xage :Int){
  val name = "zs"
  val age = xage
  var gender = "m"
  def this(name:String,age:Int,g:String){
    this(name,age)
    gender = g
  }
}

object Person{
  def apply(name:String,age:Int)={
    new Person(name,age)  
  }
}

4.if{…}else{…}语句

    /**
     * if else 
     */
    val age =18 
    if (age < 18 ){
    	println("no allow")
    }else if (18<=age&&age<=20){
    	println("allow with other")
    }else{
    	println("allow self")
    }

5.for ,while,do…while
    ①to和until 的用法（不带步长，带步长区别）

 /**
     * to和until
     * 例：
     * 1 to 10 返回1到10的Range数组，包含10
     * 1 until 10 返回1到10 Range数组 ，不包含10
     */
    
    println(1 to 10 )//打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
    
    println(1 to (10 ,2))//步长为2，从1开始打印 ，1,3,5,7,9
    
    println(1 until 10 ) //不包含最后一个数，打印 1,2,3,4,5,6,7,8,9
    
    println(1 until (10 ,3 ))//步长为2，从1开始打印，打印1,4,7

    ②for循环（可加判断条件）

    //可以分号隔开，写入多个list赋值的变量，构成多层for循环
    //scala中 不能写count++ count-- 只能写count+
    //可以在for循环中加入条件判断
    var count = 0;
    for(i <- 1 to 10; j <- 1 until 10;if (i%2) == 0){
      println("i="+ i +",j="+j)
      count += 1
    }
    println(count);
    
    //例子： 打印小九九
    for(i <- 1 until 10 ;j <- 1 until 10){
      if(i>=j){
    	  print(i +" * " + j + " = "+ i*j+"	")  
      }
      if(i==j ){
        println()
      }
    }

补充： for循环用yield 关键字返回一个集合

/*
 *  yield 关键字
 *  1-100集合中的偶数存储到另一个集合
 *  yield关键字能够将符合要求的元素自动封装到一个集合中
 */
val rest = for(i <- 1 to 100; if i%2 == 0) yield i     //此时rest就为选择出的i构成的一个集合
for(elem <- rest) println(elem)

    ③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 )

6.函数
    ①普通函数

def fun (a: Int , b: Int ) : Unit = {
   println(a+b)
 }
fun(1,1)
    
def fun1 (a : Int , b : Int)= a+b
    println(fun1(1,2))  

    ②递归函数

 /**
     * 递归函数 
     * 5的阶乘
     */
    def fun2(num :Int) :Int= {  //必须写返回值类型
      if(num ==1)
        num
      else 
        num * fun2(num-1)
    }
    print(fun2(5))

    ③包含参数默认值的函数

 /**
   * 包含参数默认值的函数
   * 	1.	函数的参数有默认值，在调函数的时候可以传参，也可以不传参，
   * 	2.	若不传参使用的默认值，
   * 	3.	如果传参，默认值会被覆盖
   */
  def fun2(num1:Int = 10,num2:Int = 20) = {
    num1 + num2
  }
  
  def fun3(num1:Int,num2:Int = 20) = {
    num1 + num2
  }
  
  def fun4(num1:Int=10,num2:Int) = {
    num1 + num2
  }
  调用：
   println(fun2())
   println(fun3(100))
   println(fun4(num2=1000))

    ④可变参数个数的函数：函数参数可以是一个也可以是多个，随机灵活的

 def fun5(args:Double*) = {
    /**
     * 在scala中
     * 		+=前后的数值类型必须一致
     * 		+前后的数值类型可以不一致
     */
    var sum = 0.0
    for(arg <- args) sum += arg
    sum
  }

    ⑤匿名函数：没有函数名的函数

/**
 * 匿名函数
 * 1.有参数匿名函数
 * 2.无参数匿名函数
 * 3.有返回值的匿名函数
 * 注意：
 * 可以将匿名函数返回给定义的一个变量
 * 匿名函数不能显式声明函数的返回类型

 */
//有参数匿名函数
val value1 = (a : Int) => {
  println(a)
}
value1(1)
//无参数匿名函数
val value2 = ()=>{
  println("我爱Angelababy")
}
value2()
//有返回值的匿名函数
val value3 = (a:Int,b:Int) =>{
  a+b
}
println(value3(4,4)) 

    ⑥嵌套函数

    /**
     * 嵌套函数：
     * 		在函数体内有定义了一个函数
     */
    def fun7(num:Int)={
      def fun8(a:Int,b:Int):Int={
        if(a == 1){
          b
        }else{
          fun8(a-1,a*b)
        }
      }
      fun8(num,1)
    }

    ⑦偏应用函数：偏应用函数是一种表达式，不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数。在多个函数调用时，有共同的参数被使用，则可提取出来默认写死，只需要为函数提供部分的参数。

/**
 * 偏应用函数
 */
def log(date :Date, s :String)= {
  println("date is "+ date +",log is "+ s)
}

val date = new Date()
log(date ,"log1")
log(date ,"log2")
log(date ,"log3")

//想要调用log，以上变化的是第二个参数，可以用偏应用函数处理
val logWithDate = log(date,_:String)    //下划线相当于占位符的作用，手动传入即可
logWithDate("log11")
logWithDate("log22")
logWithDate("log33")

    ⑧ 高阶函数：函数的参数是函数，或者函数的返回类型是函数，或者函数的参数和函数的返回类型是函数的函数。

 //函数的参数是函数
    def hightFun(f : (Int,Int) =>Int, a:Int ) : Int = {
      f(a,100)
    }
    def f(v1 :Int,v2: Int):Int  = {
      v1+v2
    }
    
    println(hightFun(f, 1))
    
    //函数的返回是函数
    //1，2,3,4相加
    def hightFun2(a : Int,b:Int) : (Int,Int)=>Int = {
      def f2 (v1: Int,v2:Int) :Int = {
        v1+v2+a+b
      }
      f2
    }
    println(hightFun2(1,2)(3,4))
    
    //函数的参数是函数，函数的返回是函数
    def hightFun3(f : (Int ,Int) => Int) : (Int,Int) => Int = {
      f
    } 
    println(hightFun3(f)(100,200))
    println(hightFun3((a,b) =>{a+b})(200,200))
    //以上这句话还可以写成这样
    //如果函数的参数在方法体中只使用了一次 那么可以写成_表示
    println(hightFun3(_+_)(200,200))

    ⑨柯里化函数

    /**
       * 柯里化函数
       * 		可以理解为高阶函数的简化
       * 		klhFun函数就是对嵌套函数这种情况的高阶函数的简化版
       */

      def klhFun(a:Int)(b:Int) = a*b
      具体：
      def klhAllFun(a:Int):(Int)=>Int = {
        val fun = (b:Int)=>a*b
        fun
      }

7.Scala字符串

val str1 = "hello bi"
    val str2 = "hello sh"
    val flag = str1.equalsIgnoreCase(str2)    
    println(flag)
    
    str1.split(" ")

    val strBuilder = new StringBuilder
    strBuilder.append("hello\t")
    strBuilder.append("bj")
    println(strBuilder)
    println("hello Angelababy".hashCode())

string操作方法举例
1.比较:equals
2.比较忽略大小写:equalsIgnoreCase
3.indexOf：如果字符串中有传入的assci码对应的值，返回下标

  /**
     * String && StringBuilder
     */
    val str = "abcd"
    val str1 = "ABCD"
    
    println(str.indexOf(97))
    println(str.indexOf("b"))

    println(str==str1)
    /**
     * compareToIgnoreCase
     * 
     * 如果参数字符串等于此字符串，则返回值 0；
     * 如果此字符串小于字符串参数，则返回一个小于 0 的值；
     * 如果此字符串大于字符串参数，则返回一个大于 0 的值。
     * 
     */
    println(str.compareToIgnoreCase(str1))
    
    val strBuilder = new StringBuilder
    strBuilder.append("abc")
//    strBuilder.+('d')
    strBuilder+ 'd'
//    strBuilder.++=("efg")
    strBuilder++= "efg" 
//    strBuilder.+=('h')
    strBuilder+= 'h' 
    strBuilder.append(1.0)
    strBuilder.append(18f)
    println(strBuilder)

8.数组

 //数组  new String[10]
    /**
     * Array关键词 创建一个长度为10 的Int类型的数组
     * 如果创建了一个Int类型的数组，那么初始值都是0
     * String类型的数组，初始是null
     * Boolean类型的数组，初始是false
     */
    val nums = new Array[Int](10)
    for(index <- 0 until nums.length){
      nums(index) = index * index
    }
    nums.foreach {println }
    
    //二维数组
    val secArray = new Array[Array[String]](10)
    for(index <- 0 until secArray.length){
      secArray(index) = new Array[String](10)
    }
    
    //往二维数组中填充数据    
   /* for(i <- 0 until secArray.length){
      for(j <- 0 until secArray(i).length){
        secArray(i)(j) = i*j + ""
      }
    }*/
    for(i <- 0 until secArray.length;j <- 0 until secArray(i).length){
      secArray(i)(j) = i*j + ""
    }

9.List集合

   /**
    * list集合
    * 
    * list集合是一个不可变的集合
    * 可变的list集合
    */
    println("=========List==========")
    val list = List(1,2,3,4,5)
    list.contains(6)
    val dropList = list.drop(2)
    dropList.foreach { println }
    list.reverse
    list.take(3).foreach(println)
    val mapList1 = list.map { x=> x +"" }
    mapList1.foreach { x=>println(x) }
    println(list.exists { x => x > 300 })
    println(list.mkString("\t"))
    
    val logList = List("hello bj","hello sh")
    val mapList = logList.map { _.split(" ") }
//    mapList.foreach { x => x.foreach { println } }
    //flatMap方法   flat扁平 
    val flatMapList = logList.flatMap{_.split(" ")}
    flatMapList.foreach { println }

/**
     * 不可变的list集合
     * 创建list集合的方式：
     * 		1、List（1,2,3）
     * 		2、Nil关键创建  Nil：空List
     * 				::往集合中添加元素
     */
    val list = 2::1::Nil
    
    /**
     * 可变的list集合
     */
    val listBuffer = new ListBuffer[String]
    listBuffer.+=("hello")
    listBuffer.+=("bj")
    listBuffer.foreach { println }
    
    listBuffer.-=("hello")

10.set集合

   //创建 
    val set1 = Set(1,2,3,4,4)
    val set2 = Set(1,2,5)
    //遍历
    //注意：set会自动去重
    set1.foreach { println}
   for(s <- set1){
      println(s)
    }
    println("*******")
   /**
    * 方法举例
    */
    
   //交集
   val set3 = set1.intersect(set2)
   set3.foreach{println}
   val set4 = set1.&(set2)
   set4.foreach{println}
   println("*******")
   //差集
   set1.diff(set2).foreach { println }
   set1.&~(set2).foreach { println }
   //子集
   set1.subsetOf(set2)
   
   //最大值
   println(set1.max)
   //最小值
   println(set1.min)
   println("****")
   
   //转成数组，list
   set1.toArray.foreach{println}
   println("****")
   set1.toList.foreach{println}
   
   //mkString
   println(set1.mkString)
   println(set1.mkString("\t"))

11.Map集合

 val map = Map(
                  "1" -> "bj",
                  2 -> "sh",
                  3 -> "gz"
                )
    val keys = map.keys
    val keyIterator = keys.iterator
    while(keyIterator.hasNext){
      val key = keyIterator.next()
      /**
       * map集合的get方法返回值是一个Option类型的对象
       * Option类型有两个子类型  分别为some None
       */
       Map中的方法 ：
       1.	filter:过滤，留下符合条件的记录
       2.	count:统计符合条件的记录数
       3.	contains：map中是否包含某个key
       4.	exist：符合条件的记录存在不存在

      println(key + "\t" + map.get(key).get)
    }
     
     /**
      * getOrElse 原理：
      * 		去集合中去取数据，若不存在返回默认值
      */
     println(map.get(4).getOrElse("default"))
    
     for(k <- map)
       println(k._1 + "\t" + k._2)     //分别取第一个位置的数据和第二个位置的数据，即Key-Value
       
     map.foreach(x=>println(x._1 + "\t" + x._2))    
     
     
     map.filter(x=>{
       Integer.parseInt(x._1 + "") >= 2
     }).foreach(println)
     
     val count = map.count(x=>{
       Integer.parseInt(x._1 + "") >= 2
     })
     println(count)
     
     /**
     合并Map的操作：
     1.++  例：map1.++(map2)  --map1中加入map2
     2.++:  例：map1.++:(map2) –map2中加入map1
     注意：合并map会将map中的相同key的value替换
     **/

12.元组

 /**
      * 元组 vs list
      * list创建的时候指定了泛型，那么集合中必须是这个泛型的对象
      * 元祖中可以包含任意类型的元素，这些元素使用一对小括号来封装，Tuple关键字
      * 
      * 
      */
     val t2 = Tuple2(1,"hello")
     val tt2 = (1,"hello")
     
     val t3 = Tuple3(1,true,"hello")  //可以存放Int、boolean、String多种不同的类型
     val tt3 = (1,true,"hello")
     
     val moreTuple = (1,2,3)   
     
      val tupleIterator = tt3.productIterator    //元组的遍历
      while(tupleIterator.hasNext){
      println(tupleIterator.next())
    }
     //toString方法
     println(tt3.toString())
     //swap交换    注意只有二元组对象才会有这个方法
     val swapt2 = tt2.swap
     println(swapt2._1 + "\t" + swapt2._2)

13.Trait特性
       ①Trait的概念理解
1》 Scala Trait(特征) 相当于 Java 的接口，实际上它比接口还功能强大。
2》与接口不同的是，它还可以定义属性和方法的实现。抽象类和接口的结合。
3》一般情况下Scala的类可以继承多个Trait，从结果来看就是实现了多重继承。Trait的继承用exten关键字继承，多继承时多个Trait之间用with连接。
4》Trait(特征) 定义的方式与类类似，但它使用的关键字是 trait。
5》继承的多个trait中如果有同名的方法和属性，必须要在类中使用“override”重新定义。
6》trait中不可以传参数

trait Read {
  val readType = "Read"
  val gender = "m"
  def read(name:String){
	println(name+" is reading")
  }
}

trait Listen {
  val listenType = "Listen"
  val gender = "m"
  def listen(name:String){
	println(name + " is listenning")
  }
}

class Person() extends Read with Listen{
  override val gender = "f"
}

object test {
  def main(args: Array[String]): Unit = {
    val person = new Person()
    person.read("zhangsan")
    person.listen("lisi")
    println(person.listenType)
    println(person.readType)
    println(person.gender)
    
  }
}

14.模式匹配Match…Case…
      ①概念理解
=>Java中的模式匹配为 switch case ；
=>Scala 提供了强大的模式匹配机制，应用也非常广泛，除了匹配值还可以匹配类型，类型的匹配必须要有变量名。
=>一个模式匹配包含了一系列备选项，每个都开始于关键字 case。
=>每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。

object Lesson_Match {
  def main(args: Array[String]): Unit = {
    val tuple = Tuple6(1,2,3f,4,"abc",55d)
    val tupleIterator = tuple.productIterator
    while(tupleIterator.hasNext){
      matchTest(tupleIterator.next())
    }
    
  }
  /**
   * 注意点：
   * 1.模式匹配不仅可以匹配值，还可以匹配类型
   * 2.模式匹配中，从上到下顺序匹配，如果匹配到对应的类型或值，就不再继续往下匹配
   * 3.模式匹配中，都匹配不上时，会匹配到 case _ ，相当于default
   * 4. 模式匹配的时候，模式范围小的在最前面
   */
  def matchTest(x:Any) ={
    x match {
      case x:Int=> println("type is Int")    //类型匹配，必须要有变量名
      case 1 => println("result is 1")
      case 2 => println("result is 2")
      case 3=> println("result is 3")
      case 4 => println("result is 4")
      case x:String => println("type is String")
//      case x :Double => println("type is Double")
      case _ => println("no match")
    }
  }
}

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

/**
      * 样例类
      * 使用case 来修饰的类就叫样例类
      * 
      * 样例类和普通类有什么区别？
      * 样例类默认帮你实现了toString,equals，copy和hashCode等方法。
			样例类可以new, 也可以不用new 
      */
     val s1 = Student(1,1)
     val s2 = Student(2,2)
     val s3 = Student(3,3)
     val s4 = Student(4,4)
     val s5 = Student(5,5)
     
     val sl = List(s1,s2,s3,s4,s5)
     //样例类+match case
     sl.foreach { x => x match {
       case Student(1,1) => println("1 1")    //值匹配，且使用了样例类已经写好了的toString方法。
       case s:Student => println("Student" + s)    //类型匹配
       case _ => println("_______")
     } }
  } 
}
//样例类
case class Student(val id :Int ,val age :Int)

16.Actor Model
     ①概念理解
         Actor Model是用来编写并行计算或分布式系统的高层次抽象（类似java中的Thread）让程序员不必为多线程模式下共享锁而烦恼,被用在Erlang 语言上, 高可用性99.9999999 % 一年只有31ms 宕机Actors将状态和行为封装在一个轻量的进程/线程中，但是不和其他Actors分享状态，每个Actors有自己的世界观，当需要和其他Actors交互时，通过发送事件和消息，发送是异步的，非堵塞的(fire-andforget)，发送消息后不必等另外Actors回复，也不必暂停，每个Actors有自己的消息队列，进来的消息按先来后到排列，这就有很好的并发策略和可伸缩性，可以建立性能很好的事件驱动系统。

Actor的特征：
1.ActorModel是消息传递模型,基本特征就是消息传递
2.消息发送是异步的，非阻塞的
3.消息一旦发送成功，不能修改，类似于邮件的发送来往
4.Actor之间传递时，自己决定决定去检查消息，而不是一直等待，是异步非阻塞的

//Actor与Actor之间通信
case class Message(actor:Actor,msg:Any)

class Actor1 extends Actor{
  def act(){
    while(true){
      receive{
        case  msg :Message => {      //类型匹配
          println("i sava msg! = "+ msg.msg)
          
          msg.actor!"i love you too !"
          }
        case msg :String => println(msg)
        case  _ => println("default msg!")
      }
    }
  }
}

class Actor2(actor :Actor) extends Actor{
  actor ! Message(this,"i love you !")
	def act(){
		while(true){
			receive{
  			case msg :String => {
  			  if(msg.equals("i love you too !")){
  			    println(msg)
  			   actor! "could we have a date !"
  			  }
  			}
  			case  _ => println("default msg!")
			}
		}
	}
}

object Lesson_Actor2 {
  def main(args: Array[String]): Unit = {
    val actor1 = new Actor1()
    actor1.start()
    val actor2 = new Actor2(actor1)
    actor2.start()
  }
}

17.Scala的隐式转换系统
        隐式转换，在编写程序的时候可以尽量少的去编写代码，让编译器去尝试在编译期间自动推导出这些信息来，这种特性可以极大的减少代码量，提高代码质量.
    ①隐式值+隐式视图
通过implicit进行隐式的声明

  object Scala09 {
  def main(args: Array[String]): Unit = {
//隐式值：
//  implicit var abc = "Dilireba"
    implicit var cba = "Angelababy"
    sayName   //直接调用，不用传参 
  /* 将变量声明为implicit，编译器在执行sayName方法时发现缺少一个String类型的参数，
      此时会搜索作用域内类型为String的隐式值
      并且将搜索到的隐式值作为sayName的参数值
   */

    
    //    1.隐式转换必须满足无歧义规则
    //    2.声明隐式参数的类型最好是自定义的数据类型，
    //    3.不要使用Int,String这些常用类型，防止碰巧冲突
    //    4.一般要将自定义的对象设置为隐式的
    
    //  隐式视图  --》隐式转换为目标类型：把一种类型自动转换到另一种类型
    implicit def string2Int(num:String) = Integer.parseInt(num) 
	
    //addNum参数是tring，不符合要求，那么他在编译的时候，发现作用域内
    //    有一个隐式方法，正好这个方法的参数是String 返回值是Int  此时
    //调用隐式方法，返回一个Int值，在将Int传给addNum
	
    println(addNum("1000"))
 
  }
  
  
  def addNum(num:Int) = {
      num + 1000
    }
  
  def sayName(implicit name:String) = {
    println("I Love " + name)
  }
  
}

    ②隐式类

   注意点：
    1.其所带的构造参数有且只能有一个
    2.隐式类必须被定义在类，伴生对象和包对象里
    3.隐式类不能是case class（case class在定义会自动生成伴生对象与2矛盾）
    4.作用域内不能有与之相同名称的标示符
    
package com.hpe.scala

object Scala10 {
  def main(args: Array[String]): Unit = {
    //  隐式类   导包要从包名开始
    import com.hpe.scala.Util._     //Util下的所有类
    "abc".getLength()
    /**
     * "abc"这个字符串想要调用getLength，但是自己没有实现这个方法
     * 发现作用域内有一个隐式转换的类，类的构造函数的参数是String类型
     * 自己传给构造函数，得到这个类的对象，近而调用getLength方法
     */
  }
}

object Util{
  implicit class Int2String(s:String){
    def getLength() = s.length
  }
}

补充点：“_”在scala中的意义

1. _表示所有 、2.占位符、3.简写模式