Scala

var str = "abc"
str = "def"

val str = "abc"
// 不能再修改它的值！会报错
str = "def"

var str: String = _
str: String = null

var in: Int = _
in: Int = 0

var flo: Float = _
flo: Float = 0.0

var c: Char = _
c: Char = ?

// 普通变量，定义时就已经赋值
val test1 = "test1"
test1: String = test1

// lazy修饰，定义时没有被赋值
lazy val test2 = "test2"
test2: String = <lazy>

  // 使用时会被赋值
  test2
  res0: String = test2

val a: Int = 1;
// 可以直接使用对象的方法
println(a.toString)
// 也可以这样~
println(1.toString)

val s = "hello"
// 反转符
println(s.reverse)
// 丢弃字符 (丢弃前n个字符)
println(s.drop(3))
// 获取一定范围内的子串， 左开右闭[1,4)
println(s.slice(1, 4))

println("""hello world \n""")
// 原样输出：hello world \n

val s1 = new String("abc");
val s2 = new String("abc");
// 结果是true
println(s1 == s2)
// 在Scala中String的equals方法和==相同
println(s1.equals(s2))
// 如果想比较内存地址（引用）是否为是相同的，可以使用eq方法。返回false
println(s1.eq(s2))

// 一个三元组
val tuple = ("hello", "world", 1)
// 访问元组
println(tuple._1 + "," + tuple._2 + "," + tuple._3)
// 使用时还可以提取元组的内容到变量中
val (a, b, c) = tuple
// 访问元组
println(a + "," + b)

def tupleString2Int(tuple2: (String, String)): (Int, Int) = (tuple2._1.toInt, tuple2._2.toInt)

tupleString2Int(("1", "2"))

// 定义一个符号类型的变量s，变量s会被默认识别为Symbol类型
val s = 'start
// 显示声明符号类型
val s_ : Symbol = 'start
// 符号类型主要起标识作用，常用与模式匹配、内容判断中
// for example
if (s == s_) println(true) // 使用 == 来比较变量时，比较的是变量的内容而非引用
else println(false)
// 直接输出符号类型的变量会按原样输出
println("s = " + s)

import java.lang._
import Scala._
import Predf._

type Map[A, +B] = immutable.Map[A, B]
type Set[A] = immutable.Set[A]
val Map = immutable.Map
val Set = immutable.Set

def gcd(x: Int, y: Int): Int = {
  if (x % y == 0)
    y // 函数的返回值
  else
    gcd(y, x % y) // 函数的返回值
}

def sum(x: Int, y: Int) = x + y

def echo(str: String, strs: String*) = {
  println(str)
  strs.foreach(println)
}

echo("my", "name", "is", "zhangqiang")

val arr = Array("name", "is", "zhangqiang")
// _* 会告知编译器需要把 arr 中的每个元素都当作参数传递给函数，而不是将 arr 当作一个参数传递给函数。
echo("my", arr: _*)

val sum = (x: Int, y: Int) => {
  x + y
}

//  值函数不能在参数后面指定返回值类型
val sum = (x: Int, y: Int): Int => x + y

val concat = (cols: String *) = cols.mkString

def map[B](f: (A) => B): Array[B]

// 定义一个值函数，作用于数组中的每一个元素
val arr = Array(1, 2, 3, 4)
val increment1 = (x: Int) => {
  x + 1
}
val resultArr = arr.map(increment1)

val arr = Array(1, 2, 3, 4)
val resultArr = arr.map((x: Int) => {
  x + 1
})

// 因为arr是Int类型的数组，使用map的时候可以通过类型推断得知它的输入类型是Int，因此可以将输入参数的类型省略
arr.map((x) => {
  x + 1
})

// 在调用函数时，如果只有一个参数，可以用花括号`{}`来替代小括号`()`。map函数只有一个函数类型的参数。
arr.map {
  (x) => {
    x + 1
  }
}

// 当用花括号`{}`来限定函数类型的参数时，不论函数体中有多少行代码，函数的花括号`{}`都可以省略。
arr.map {
  (x) => x + 1
}

// 在定义函数时，如果函数的输入参数只有一个，可以将()省略，map函数的参数是函数类型，这个函数的输入参数是一个。
arr.map {
  x => x + 1
}

// 对于值函数， => 左面的输入参数 x 在 => 右面只出现过一次，因此可以用占位符 _ 代替
arr.map {
  _ + 1
}

// val increment = (x:Int) => {1 + x} 的简写
val increment = 1 + _

val increment = 1 + (_: Int)

val increment: (Int) => Int = 1 + _

// withScope 的源码定义，它接收一个函数类型参数body，body是一个参数列表为空，返回值类型为泛型U的函数。
private[spark] def withScope[U](body: => U): U = RDDOperationScope.withScope[U](sc)(body)
// 调用 withScope，用`{}`替代`()`，因为是无参的函数，函数映射符`=>`也省略了。
def collectAsMap(): Map[K, V] = self.withScope {
  val data = self.collect()
  val map = new mutable.HashMap[K, V]
  map.sizeHint(data.length)
  data.foreach { pair => map.put(pair._1, pair._2) }
  map
}

def higherOrderFunction(f: (Double) => Double) = {
  f(1)
}

def higherOrderFunction(factor: Int): (Double) => Double = {
  (x: Double) => factor * x
}

// Array的map函数定义
def map[B](f: (A) => B): Array[B]

// Array类型的map函数
Array("kafka", "sparkstreaming", "elasticsearch").map(_ * 2)

// List类型的map函数
List("kafka", "sparkstreaming", "elasticsearch").map((_, 1))

// Map类型的map函数
Map("kafka" -> 1, "sparkstreaming" -> 2, "elasticsearch" -> 3).map(_._1)

// Array的flatMap函数定义
def flatMap[B](f: (A) => GenTraversableOnce[B]): Array[B]

// flatMap的使用
Array("Hello world", "This is John Snow").flatMap(
  sentence => {
    val words: Array[String] = sentence.split("")
    val statistics: Array[(String, Int)] = words.map(word => {
      (word, 1)
    })
    statistics
  })

// 简写
Array("Hello world", "This is John Snow").flatMap {
  _.split(" ").map((_, 1))
}

// Array的filter函数定义
def filter(p: (T) => Boolean): Array[T]

// filter的使用，返回大于3的元素
Array(1, 5, 7, 3, 4).filter(_ > 3)

// Array的reduce函数定义
def reduce[A1 >: A](op: (A1, A1) => A1): A1

// reduce的使用，结果是10
Array(1, 2, 3, 4).reduce((x1, x2) => {
  println(s"x1 = ${x1}, x2 = ${x2}")
  x1 + x2
})
// 输出结果
// x1 = 1, x2 = 2
// x1 = 3, x2 = 3
// x1 = 6, x2 = 4


// 简写
Array(1, 2, 3, 4).reduce(_ + _)

/**
 * reduce还有两个变种，reduceLeft()、reduceRight()。
 * reduceLeft()和reduce()一样，op函数按照集合中元素的顺序从左到右进行reduce操作，
 * 而reduceRight()作用顺序相反。
 * 只要记住left就是取元素的顺序和x1、x2的赋值顺序都是从左往右，
 * 计算结果也是先从左开始赋值(x1)，right就全部反过来就可以了。
 */
Array(1, 2, 3, 4).reduceRight((x1, x2) => {
  println(s"x1 = ${x1}, x2 = ${x2}")
  x1 + x2
})
// 输出结果
// x1 = 3, x2 = 4
// x1 = 2, x2 = 7
// x1 = 1, x2 = 9

// Array的fold函数定义
def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1

// fold的使用，结果是10
Array(1, 2, 3, 4).fold(0)((x1, x2) => {
  println(s"x1 = ${x1}, x2 = ${x2}")
  x1 + x2
})
// 输出结果
// x1 = 0, x2 = 1
// x1 = 1, x2 = 2
// x1 = 3, x2 = 3
// x1 = 6, x2 = 4

// 简写
Array(1, 2, 3, 4).fold(0)(_ + _)

/**
 * fold同样也有两个变种，foldLeft()、foldRight()。
 * foldLeft()和fold()一样，op函数按照集合中元素的顺序从左到右进行fold操作，
 * 而foldRight()作用顺序相反
 */
Array(1, 2, 3, 4).foldRight(0)((x1, x2) => {
  println(s"x1 = ${x1}, x2 = ${x2}")
  x1 + x2
})
// 输出结果
// x1 = 4, x2 = 0
// x1 = 3, x2 = 4
// x1 = 2, x2 = 7
// x1 = 1, x2 = 9

// 自由变量(上下文)，在运行中随时可能发生变化
var factor = 2
// 函数
val f = (x: Int) => x * factor

f(2) // 得到结果 4

factor = 3

f(2) // 得到结果6

def higherOrderdFunction(f: Double => Double) = {
  println(f(1.7))
}

// 向上取整
val f1 = (x: Double) => Math.ceil(x)
// 向下取整
val f2 = (x: Double) => Math.floor(x)

higherOrderdFunction(f1) // 结果是2.0
higherOrderdFunction(f2) // 结果是1.0

def higherOrderFunction(factor: Int): (Double) => Double = {
  (x: Double) => factor * x
}

higherOrderFunction(3)(5.0) // 结果是 15.0

// 实际调用过程是下面的样子。
val f = higherOrderFunction(3) // f = (x: Double) => 3 * x
f(5.0) // 结果 15.0 

def curryMultiply(factor: Int)(x: Double) = factor * x
// 调用
curryMultiply(3)(5.0) // 结果是15.0

// 例如 hbase的scan方法
def scan(tableName: String, cf: String, startRow: String, stopRow: String)(processFn: (Result) => Unit) = {
  ...
}

// 在调用时如果参数只有一个时，可以用花括号{}代替小括号()
scan(t1, cf, startRow, stopRow) { r =>
  //TODO process result  
}  

val part = curryMultiply(3) _
part(5.0) // 结果是15.0

// 注意函数名和 _ 之间有空格
val part2 = curryMultiply _
part2(3)(5.0)

def price(x1: Double, x2: Double, x3: Double): Double = {
  x1 + x2 * x3
}

// 一个参数的部分应用函数，返回一个 Double => Double 类型的函数
def price_1 = price(_: Double, 699.0, 0.7)
// 调用
price_1(18.0)

// 两个参数的部分应用函数，返回一个 (Double, Double) => Double 类型的函数
def price_2 = price(_: Double, _: Double, 0.7)
// 调用
price_2(18.0, 699.0)

// 两个参数的部分应用函数，返回一个 (Double, Double, Double) => Double 类型的函数
def price_3 = price(_: Double, _: Double, _: Double)
// 调用
price_3(18.0, 699.0, 0.7)

// 等价与 price_3
def price_4 = price _

// 定义一个偏函数，只处理偶数值的参数
val isEven: PartialFunction[Int, String] = {
  case x if x % 2 == 0 => x + "is even"
}

// 对于定义域子集外的参数会抛出异常
isEven(11)
/*
Caused by: Scala.MatchError: 11 (of class java.lang.Integer)
	at Scala.PartialFunction$$anon$1.apply(PartialFunction.Scala:253)
	at Scala.PartialFunction$$anon$1.apply(PartialFunction.Scala:251)
	at com.zq.Scala.函数.部分应用函数$$anonfun$2.applyOrElse(部分应用函数.Scala:41)
	at com.zq.Scala.函数.部分应用函数$$anonfun$2.applyOrElse(部分应用函数.Scala:41)
	at Scala.runtime.AbstractPartialFunction.apply(AbstractPartialFunction.Scala:36)
	at com.zq.Scala.函数.部分应用函数$.<init>(部分应用函数.Scala:45)
	at com.zq.Scala.函数.部分应用函数$.<clinit>(部分应用函数.Scala)
	... 1 more
*/

// 除了定义一个变量是PartialFunction[Int, String]类型的，还可以直接定义函数
def partial: PartialFunction[Any, Unit] = {
  case x: Int => println("Int")
  case x: String = > println ("String")
}

class Person {
  // 声明一个成员变量，Scala中的成员变量在声明时必须要初始化，可以使用占位符。如果在定义时确实不需要初始化，则需要将类定义为抽象类。
  var name: String = null
}

class Person {
  // 声明一个成员变量，Scala中的成员变量在声明时必须要初始化，可以使用占位符。如果在定义时确实不需要初始化，则需要将类定义为抽象类。
  val name: String = null
}

class Person {
  private var name: String = null
}

val girlFriend = new Female("xx")

// 对于无参的构造函数，可以省略()
val singleDog = new Dog

person = new Person
// 显式调用setter
person.name_$eq("zhangsan")

// getter
val name = person.name

// 隐式调用setter
person.name = "lisi"

import Scala.beans.BeanProperty

class Person {
  @BeanProperty var name: String = null
}

object Person {
  private var num: Int = _

  def increment() = {
    num += 1
  }
}

// 不需要创建对象，通过单例对象名称就可以直接访问其成员方法了
Person.increment()

object Main {
  def main(args: Array[String]): Unit = {
    var num = 1
    println(num)
  }
}

object Main extends App {
  var num = 1
  println(num)
}

// 伴生类
class Student {
  private var name: String = null

  def getStudentNo = {
    Student.incrementNo()
    // 伴生类中可以直接访问伴生对象Student的私有成员studentNo
    Student.studentNo
  }
}

// 伴生对象
object Student {
  private var studentNo: Int = 0

  def incrementNo() = {
    studentNo += 1
  }

  // 伴生对象中可以直接访问伴生类中的私有成员name
  def printName() = println(new Student().name)
}

val arr = Array(1, 2, 3, 4, 5)

// 其实它调用的是伴生对象Array中的apply方法
object Array extends FallbackArrayBuilding {
  /** Creates an array of `Int` objects */
  // Subject to a compiler optimization in Cleanup, see above.
  def apply(x: Int, xs: Int*): Array[Int] = {
    val array = new Array[Int](xs.length + 1)
    array(0) = x
    var i = 1
    for (x <- xs.iterator) {
      array(i) = x; i += 1
    }
    array
  }
}

// 伴生类
class Student {
  private var name: String = null
}

// 伴生对象
object Student {
  private var studentNo: Int = 0

  def incrementNo() = {
    studentNo += 1
  }

  // apply方法，当使执行Student()时就会调用伴生对象的apply()方法，类似与构造方法。
  def apply: Student = new Student()
}

// 如果不写 var 默认成员变量是 val 的
class Student(var name: String, var age: Int) {
  // 类体中的执行代码会在构造函数中执行。
  println("this is construct method")
}

class Student(var name: String, var age: Int = 18)

// age 使用默认值 18
new Student("zhangsan")

class Student private(var name: String, var age: Int)

// 无参的主构造函数
class Student {
  private var name: String = null
  private var age: Int = 0

  // 辅助构造函数
  def this(name: String) {
    // 调用无参的默认主构造函数，这是必须的，否则会报错
    this()
    this.name = name
  }

  // 辅助构造函数同样可以指定默认值
  def this(name: String, age: Int = 18) {
    // 调用一个参数的辅助构造函数
    this(name)
    this.age = age
  }
}

// 定义私有的主构造函数
class Student private {
  private var name: String = null
  private var age: Int = 0

  // 都赋上默认值
  def this(name: String = "zhangsan", age: Int = 18) {
    // 调用一个参数的辅助构造函数
    this()
    this.name = name
    this.age = age
  }

  override def toString: String = {
    s"name = ${this.name}, age = ${this.age}"
  }
}

// 结果是 name = zhangsan, age = 18
println(new Student().toString)

class Person(var name: String, var age: Int) {
  // 类中的执行语句，相当于写在类的主构造函数中
  println("调用Person(父)类的主构造函数")
}

class Student(name: String, age: Int, var grade: String) extends Person(name: String, age: Int) {
  // 类中的执行语句，相当于写在类的主构造函数中
  println("调用Student(子)类的柱构造函数")
}

new Student("张三", "18", "大学一年级")

object Practice extends App {

  // 伴生类
  class Car(var carType: String, var color: String) {

    // 内部类
    class Wheel(var radius: Double) {}

    // 内部对象
    object Tools {
      def navigation(destination: String) = println(s"开往$destination")
    }

  }

  // 伴生对象
  object Car {

    // 内部类
    class Descriptor(car: Car) {
      override def toString: String = s"${car.color}的${car.carType}"
    }

    // 内部对象
    object Printer {
      def printDescriptor(descriptor: Descriptor) = println(descriptor)
    }

  }

  val car = new Car("凯迪拉克", "黑色")
  // 创建一个伴生对象中的内部类对象
  val descriptor = new Car.Descriptor(car)
  // 调用伴生对象中的内部对象中的方法
  Car.Printer.printDescriptor(descriptor)
  // 创建一个伴生类中的内部类对象
  val wheel = new car.Wheel(631.9)
  // 调用伴生类中的内部对象中的方法
  car.Tools.navigation("希尔顿酒店")
}

class Person(var name: String, var age: Int) {
  // 这是Scala方法重写的语法，与Java不同。
  override def toString: String = s"name:${name},age:${age}"
}

/**
 * Student中的name和age并没有var修饰，因为这两个成员变量是继承自Person类
 * 而 var grade:String 是新增加的成员 
 */
class Student(name: String, age: Int, var grade: String) extends Person(name, age) {
  override def toString: String = s"${super.toString},grade:${grade}"
}

class Person(var name: String, var age: Int) {
  def squat(): Unit = {
    println("人蹲")
  }

  def sayName(): Unit = {
    println(s"我是$name")
  }
}

class Zombie(name: String, age: Int) extends Person(name, age) {
  override def squat(): Unit = {
    println("小僵尸蹲")
  }

  def zombieJump(): Unit = {
    println("小僵尸跳")
  }
}


// 声明一个Person类型的变量p，将子类Zombie类型的对象赋值给它
val p: Person = new Zombie("秦始皇", 5000)
p.squat()
p.sayName()
// 因为p声明为Person类型，所以对象p无法调用Zombie类特有的方法zombieJump()，除非将其强转为Zombie类。

abstract class Person {
  // 抽象成员变量
  var name: String

  // 抽象成员方法，注意abstract只能用于修饰class
  def squat()

  // 具体成员变量
  var age: Int = 5000

  // 具体成员方法
  def sayName(): Unit = {
    println(s"我是$name")
  }
}

class Zombie extends Person {
  // 对抽象成员变量和抽象成员方法重写时 override 关键字可以省略
  override var name: String = "嬴政"

  override def squat(): Unit = {
    println("小僵尸蹲")
  }
}

package com.zq

trait TraitTest {
  // 方法声明
  def add(o: Any)

  def delete(o: Any)

  def update(o: Any)

  def select(id: String): Any
}

trait Trait1

trait Trait2

trait Trait3

class A extends Trait1 with Trait2 with Trait3

tarit Cloneable extends java.lang.Cloneable {}

trait TraitTestAll {
  // 具体成员变量
  var id = "0000001"
  // 抽象成员变量
  var record: String

  // 具体成员方法
  def add(o: Any) = println("add")

  // 抽象成员方法
  def select(id: String): Any
}

abstract class Logger {
  println("Logger.") // 执行语句
}

trait DailyLogger extends Logger {
  println("DailyLogger.") // 执行语句
}

trait FileLogger extends Logger {
  println("FileLogger.") // 执行语句
}

class DailyFileLogger extends DailyLogger with FileLogger {
  println("DailyFileLogger.") // 执行语句
}

def main(args: Array[String]): Unit = {
  new DailyFileLogger()
}

abstract class Logger(msg: String)

class Logger(msg: String)

abstract class Animal {
  // 注意 abstract 关键词在Scala中只能用于修饰class，这里必须省略。
  def describe(): Unit
}

trait Donkey extends Animal {
  override def describe(): Unit = println("I'm donkey.")
}

trait Horse extends Animal {
  override def describe(): Unit = println("I'm horse.")
}

class Mule extends Donkey with Horse

def main(args: Array[String]): Unit = {
  val firstMuleInTheWorld = new Mule
  // 让我们听听它会说什么呢
  firstMuleInTheWorld.describe()
}

package com {

  class Test1 {}
  package zq {

    class Test2 {}

  }

}

package com.zq.Scala.practice

// 用package关键字修饰的单例对象
package object Math {
  val PI = 3.1415926
}

class Computation {
  // 这样可以直接通过package object直接访问成员
  def computeArea(r: Double) = Math.PI * r * r
}

import java.util.{HashMap => JavaHashMap}
import Scala.collection.mutable.HashMap

import Scala.collection.mutable.HashMap
import java.util.{HashMap => _, _}

package com.zq

package object implicits {
  // 用 implicit 关键字声明的函数就是隐式函数
  implicit def String2StringBuffer(str: String) = new StringBuffer(str)
}

package com.zq.test

object Test {
  // 引入隐式函数

  import com.zq.implicits._

  // == 定义完成之后，下面的代码可以编译通过的原因：
  // 1、编译器发现赋值对象的类型与最终类型不匹配时，会在当前作用域范围内查找能将 String 转换成 StringBuffer
  // 类型的隐式实体(隐式转换函数、隐式类、隐式对象)，而`String2StringBuffer`刚好满足要求，因此可以编译通过。
  // 2、当第一步没有成功，则在隐式参数类型的作用域(与该类型相关的全部伴生模块)里查找，
  //   (1)例如对于类`class A extends B with C with D`的对象进行隐式转换，A、B、C、D 的伴生对象都会被搜索。
  //   (2)对于参数化类型，例如要对`List[String]`类型的对象进行隐式转换，则会搜索 List、String 的伴生对象
  //   (3)如果 A 是某个`object`中的内部类， 如`O.A`则对与 class A 的隐式转换也会搜索 object O
  //   (4)如果 A 是类型注入 S#A，那么 S 和 A 的伴生对象都会被搜索
  // == 对于隐式函数的注意事项：
  // 1、隐式函数的函数名可以是任意的，隐式转换与函数名无关，只与函数签名(输入参数类型与返回值类型)有关，
  // 如果在当前作用域范围内存在函数签名相同但是函数名称不同的两个隐式函数，在进行隐式转换的时候会报错，提
  // 示有歧义
  // 2、隐式函数只有一个形参，如果有多个参数就失去隐式函数的意义了，编译器永远也不会使用到这个隐式函数
  // 3、不支持嵌套的隐式转换，A 能隐式转换成 B，B 能隐式转换成 C，但 A 不能通过两次隐式转换转成 C
  // 4、代码如果在不实用隐式转换的前提下就能变异通过就不会使用隐式转换
  val sb: StringBuffer = "heihei"
}

/**
 * 隐式类
 * 通过implicit关键字定义一个隐式类，隐式类的主构造函数接受 String 类型参数
 * 这样当一个 String 类型的变量调用隐式类中的方法时，就会进行 String 类型到隐
 * 式类类型的隐式转换
 */
object Test {

  implicit class Dog(val name: String) {
    def bark = println(s"Dog $name is barking")
  }

}

// String类型本身没有bark方法，此时进行了隐式转换
"大狗".bark

/**
 * == 隐式类的原理：
 * 隐式类会最终被翻译成如下代码，隐式类是通过隐式函数来实现的，隐式类的代
 * 码更简洁，但是也会使代码更加“迷幻”
 * == 隐式类的注意事项：
 * 1、只能在`class/trait/object`内部定义`implicit class`
 * 2、构造函数只能有一个非隐式参数，如果有多个非隐式参数，同样的也无法用于隐式转换了。
 * 但是可以有隐式参数如：`implicit class A(s: String)(implicit i: Int)`
 * 3、implicit 不可以用于`case class`
 */
class Dog(val name: String) {
  def bark = println(s"Dog $name is barking")
}

implicit def string2Dog(name: String) = new Dog(name)

implicit val x: Int = 1

trait Multiplicable[T] {
  def multiply(x: T): T
}

/**
 * 隐式对象:整型数据的相乘
 */
implicit object MultiplicableInt extends Multiplicable[Int] {
  override def multiply(x: Int): Int = x * x
}

/**
 * 隐式对象：字符串数据的乘积
 */
implicit object MultiplicableString extends Multiplicable[String] {
  override def multiply(x: String): String = x * 2
}

// 定义一个函数，函数具有泛型参数，限定泛型`T`为`Multiplicable`的子类
def multiply[T: Multiplicable](x: T) = {
  // 使用 implicitly 方法，主动搜索`Multiplicable[T]`类型的隐式对象
  val ev = implicitly[Multiplicable[T]]
  ev.multiply(x)
}

// 调用隐式对象`MultiplicableInt`中的`multiply(x: Int)`方法
println(multiply(5))
// 调用隐式对象`MultiplicableString`中的`multiply(x: String)`方法
println(multiply("5"))

/**
 * == 隐式参数：
 * implicitly 函数被定义在`scala.Predef`对象中，其中的参数`e`使用了`implicit`
 * 关键字修饰，这种形式的参数叫做隐式参数
 * == 隐式参数的注意事项：
 * 函数在定义的时候，只支持最后一组参数使用`implicit`表明这是一组隐式参数，这样在调用
 * 该函数的时候，可以不用向传递隐式参数传递实参，编译器会自动寻找一个`implicit`修饰的
 * 值、对象或函数作为该参数的实参
 */
@inline def implicitly[T](implicit e: T) = e

// 使用隐式参数定义`multiply`函数
def multiply[T: Multiplicable](x: T)(implicit ev: Multiplicable[T]) = ev.multiply(x)

/**
 * 调用
 * 他会在当前作用域查找类型为`Multiplicable[T]`的隐式对象，然后根据泛型`T`的实际
 * 类型决定调用哪一个隐式对象中的方法
 */
println(multiply(5))
println(multiply("5"))

import java.util.Comparator

// 定义一个隐式值
implicit val c: Comparator[Int] = new Comparator[Int] {
  override def compare(a: Int, b: Int): Int = a - b
}

def max[T](a: T, b: T)(implicit cp: Comparator[T]): T = {
  if (cp.compare(a, b) > 0) a else b
}

// 类型参数声明 T: Comparator 就表示存在一个 Comparator[T] 类型的隐式值。
def max[T: Comparator](a: T, b: T): T = {
  // implicitly 是在 Predef.scala 里定义的，它是一个特殊的方法，编译器会记录当前上下文里的隐式值，而这个方法则可以获得当前上下文指定类型的隐式值。
  val cp = implicitly[Comparator[T]]
  if (cp.compare(a, b) > 0) a else b
}