Scala类型参数Demo代码

小灰灰 2022-04-13 08:43 251阅读 0赞

package com.zjw.ch18
    
    import scala.reflect.ClassTag
    
    object Ch18Test extends App { 
      /** * 泛型方法 */
      def getMiddle[T](array: Array[T]): T = { 
        array(array.length / 2)
      }
      println(getMiddle(Array(1, 2, 3, 4, 5, 6, 7)))
    
      /** * 类型变量上界界定 */
      def compare1[T <: Comparable[T]](first: T, second: T): Int = { 
        first.compareTo(second)
      }
       class Person4{ 
         def show(): Unit = { }
      }
      class Student4 extends Person4 { 
        override def show(): Unit = { 
          println("Hello I'm Student4 instance.")
        }
      }
      println(compare1("abc", "acb"))
      def showFunc[T <: Person4](instance: T): Unit = { 
        instance.show()
      }
      showFunc(new Student4)
    
      /** * 类型变量下界界定 */
      class Pair1[T](val first: T, val second: T) { 
        def replaceFirst[R >: T](newFirst: R) = new Pair1[R](newFirst, second)
      }
    
      /** * 视图界定 */
      def comapre2[T <% Comparable[T]](first: T, second: T): Int = { 
        first.compareTo(second)
      }
      println(comapre2(4332, 345))
    
      /** * 上下文界定 */
      def smaller[T: Ordering](first: T, second: T)(implicit ordering: Ordering[T]): T = { 
        if (ordering.compare(first, second) < 0) { 
          first
        } else { 
          second
        }
      }
      println(s"smaller is: ${smaller(3,6)}")
      def signal[T : Ordering](a: T, b: T): Int = implicitly[Ordering[T]].compare(a, b)
      println(s"signal(0, 5) result is: ${signal(0, 5)}")
    
      /** * ClassTag上下文界定 */
      def mkPairArray[T: ClassTag](first: T, second: T): Array[T] = { 
        Array[T](first, second)
      }
      println(mkPairArray(2, 3).mkString(","))
    
      /** * T协变 */
      class Animal1 { }
      class Bird1 extends Animal1 { }
      class Covariant[+T](t: T) { }
      val cov = new Covariant[Bird1](new Bird1)
      val cov2: Covariant[Animal1] = cov
    
      class Person3
      class Student3 extends Person3
      class Pair2[+T](val first: T, val second: T)
      def mkFriends(p: Pair2[Person3]): Unit = { 
        println("Hello I'm covariant.")
      }
      val pairStudent: Pair2[Student3] = new Pair2(new Student3, new Student3)
      mkFriends(pairStudent)
    
      /** * T逆变 */
      class Animal2 { }
      class Bird2 extends Animal2 { }
      class Contravariant[-T](t: T) { }
      val c: Contravariant[Animal2] = new Contravariant[Animal2](new Animal2)
      val c2: Contravariant[Bird2] = c
    
      trait Friend[-T] { 
        def befriend(someone: T)
      }
      class Person2 extends Friend[Person2] { 
        override def befriend(someone: Person2): Unit = { 
          println("friend , I'm Person2")
        }
      }
      class Student2 extends Person2 { 
        override def befriend(someone: Person2): Unit = { 
          println("friend , I'm Student2")
        }
      }
      def mkFriendWith(s: Student2, f: Friend[Student2]): Unit = { 
        f.befriend(s)
      }
      val susan = new Student2
      val fred = new Person2
      mkFriendWith(susan, fred)
    }