Scala 语言学习之泛型（7）

class Person[T]{
  private var name:T = _

  def setName(name:T) = {this.name = name}
  def getName():T = {this.name}
}

// ***********测试*****************
object Person{
  def main(args:Array[String]):Unit = {
    var p = new Person[String]()
    p.setName("hello")
    println(p.getName())
  }
}

//* 泛型函数
// 创建一个固定类型的数组
// 普通函数
def mkInt(elems:Int*) = Array[Int](elems:_*)
def mkString(str:String*) = "mkString"

// 使用泛型函数，可以接收任意类型
def mkArray[T:ClassTag](elems:T*) = Array[T](elems:_*)

// ***********测试*****************
// 普通函数只能传入相对应类型的参数
mkInt(1,2,3)
mkString("hello", "world")

// 泛型函数可以传入任意类型的参数
mkArray(11.26,665, 84, "hello")

class Person1{
  def gender() = {println("gender")}
}

class Man extends Person1{
  override def gender() = {println("man")}
}

class Women extends Person1{
  override def gender() = {println("women")}

object UpperBoundsAndLowerBounds {
  // 定义一个泛型函数，通过上界的方式指定泛型的范围必须是 Person1 的子类或者Person1 类，并调用类中的 gender 方法
  def getGender[T <: Person1](g:T) = {g.gender()}

  def main(args:Array[String]): Unit = {
    // 创建一个Person1 对象 ，调用getGender 方法调用 Personal 中的 gender 方法
    var p:Person1 = new Person1
    getGender(p)

    // 创建一个 Man 对象 ，通过 getGender 方法调用Man 类中的 gender 方法
    var m = new Man
    getGender(m)
  }

}

def int2String[T <% String](x:T, y:T) = {
  println(x + "*****" + y)
}

// ***********测试*****************
int2String("hello", "world")
implicit def int2String1(n:Int):String = {n.toString}
int2String(100, 120)

//* 协变和逆变   在类型的前面加入 +号，就可以使类的特征变为协变了
// 将子类对象转换为父类对象称为协变 +
// 将父类对象转换为子类对象称为逆变 -
package demo1{
  // 父类
  class Animal{}
  // 子类
  class Bird extends Animal
  class Sparrow extends Bird
  
  // 吃东西的类      协变
  class EatSomethings[+T](t:T){}

  // ***********测试*****************
  object Demo1{

    def main(args:Array[String]): Unit={
      // 创建一个吃东西的对象
      var c1:EatSomethings[Sparrow] = new EatSomethings[Sparrow](new Sparrow)

      var c2:EatSomethings[Animal] = c1
    }
  }
}

class Fruit(name:String){
  def getFruitName():String = {name}
}

class Monkey(f:Fruit){
  def say() = {println("Monkey like " + f.getFruitName()) }
}

// ***********测试*****************
object ImplicitDemo {
  def main(args:Array[String]):Unit = {
    var f:Fruit = new Fruit("bnanan")

    // 调用 fruit 的方法，希望 Monkey这个say 方法来实现
    // 需要将 fruit 的对象转换为 monkey 对象， 即定义一个隐匿转换函数
    implicit def fruit2Monkey(f:Fruit):Monkey = {new Monkey(f)}     // 将 fruit 对象转换为 Monkey 对象
    // 调用Monkey中的 say 方法
    f.say()
  }
}

// 隐式参数
def testParam(implicit name:String) = {println("The value is " + name)}
implicit val name:String = "这是一个隐式值"

// ***********测试*****************
testParam
//---------------------------------------------------------------

// 带隐式参数的泛型函数
// Ordered[T] 使类型可排序，
//     原型：def smaller
// (implicit order:T      =>    Ordered[T])
def smaller[T](a:T, b:T)(implicit order:T => Ordered[T]) = if(order(a) < b) a else b

// ***********测试*****************
smaller(100, 56)
smaller("hello", "hi")

object testImplicit {

  // 定义一个隐式类
  implicit class Calc(x:Int){
    def add(a:Int):Int = a + x
  }

  // ***********测试*****************
  def main(args:Array[String]):Unit = {
    println("两个数字的和：" + 1.add(2))
  }
}