scala入门7-隐式转换和泛型

隐式转换和泛型

1、隐式转换

	object Test01 {
		/**
		* 隐式转换的解析:
		* 当需要使用隐式转换的时候，首先从当前的作用域中查找是否有符合条件的隐式转换
		* 如果说隐式转换不在当前作用域，需要进行导入之后再使用:
		* 1、如果隐式方法定义在Object中,导入的时候使用: import 包名.object名称.隐式转换方法名（隐式属性同理）
		* 2、如果隐式方法定义在class中,导入的时候使用:（隐式属性不支持）
		*    1、创建对象
		*    2、对象名.隐式转换方法名
		*/
		def main(args: Array[String]): Unit = {
			//隐式方法
			val x: Int = 1.0
		
			//隐式属性
			println(m1(30))
			//隐式属性也可以手动赋值
			println(m1(30)(90))
		
			//隐式类
			val person = new Person("fang", 18).maxPerson(new Person("yire", 20))
			println(person.name)
		}
		
		/**
		* 一、隐式方法
		* 1、在普通的方法前加上implicit关键字
		* 2、当类型与目标类型不一致时，会尝试找作用域内的隐式方法，所以这类方法的入参为当前类型，出参为目标类型
		* 3、当调用了不属于这个类的方法时，同样会尝试调用隐式方法
		*/
		implicit def doubleToInt(x: Double): Int = {
			x.toInt
		}
		
		/**
		* 二、隐式属性
		* 在普通属性前添加implicit关键字
		*/
		implicit val y: Int = 20
		//不能同时存在两个隐式属性，不然运行会报错，或者在导入时指定导入哪个
		//  implicit val y2: Int = 20
		
		/**
		* 隐式属性的使用
		*/
		def m1(x: Int)(implicit y: Int) = {
			x + y
		}
		
		/**
		* 三、隐式类
		*/
		implicit class ImplicitClass(x: Person) {
			def maxPerson(p: Person) = {
			if (p.age > x.age)
				p
			else
				x
			}
		}
		
		class Person(var name: String, var age: Int)
		
	}

2、泛型

1.泛型方法和泛型类

object Test02 {
	def main(args: Array[String]): Unit = {
		//泛型方法
		m1("sss")
		m1(20)
		m1(List(1, 2, 3, 4))
		//泛型类
		println(new Person[String]("aaaa").name)
		println(new Person[Int](111).name)
		println(new Person[List[String]](List("a", "b", "c")).name)
	}
	
	/**
	* 泛型方法，在方法名后面用[]定义
	*/
	def m1[T](x: T) = {
		println(x)
	}
	
	/**
	* 泛型类
	*/
	class Person[T](var name: T)

}

2.协变和逆变

object Test03 {
	def main(args: Array[String]): Unit = {
		var arr1: List[A] = List(new A, new A)
		var arr2: List[AA] = List(new AA, new AA)
		arr1 = arr2
		//在java中是不允许这么做的，泛型的对象没有泛型的继承关系
		println(arr1)
	
		//协变 +T ，泛型的对象和泛型的继承关系一样
		var arr3: List[B[A]] = List(new B[A], new B[A])
		var arr4: List[B[AA]] = List(new B[AA], new B[AA])
		arr3 = arr4
		println(arr3)
	
		//逆变 -T ，泛型的对象和泛型的继承关系相反
		var arr5: List[C[A]] = List(new C[A], new C[A])
		var arr6: List[C[AA]] = List(new C[AA], new C[AA])
		arr6 = arr5
		println(arr6)
	
		//不变 T，java中的就是这个
		var arr7: List[D[A]] = List(new D[A], new D[A])
		var arr8: List[D[AA]] = List(new D[AA], new D[AA])
		//    arr7 = arr8
		//    arr8 = arr7
	}
	
	class A
	
	class AA extends A
	
	/**
	* 泛型类
	* 协变 +T ，泛型的对象和泛型的继承关系一样
	* 逆变 -T ，泛型的对象和泛型的继承关系相反
	* 不变 T，java中的就是这个
	*/
	class B[+T]
	
	class C[-T]
	
	class D[T]

}

3.泛型上下限

object Test04 {
	def main(args: Array[String]): Unit = {
		val ba = new B[A]
		val baa = new B[AA]
		//下限：限制泛型为AA或其父类
		//    val baaa = new B[AAA]

		//上限：限制泛型为AA或其子类
		//    val ca = new C[A]
		val caa = new C[AA]
		val caaa = new C[AAA]
	}

	class A

	class AA extends A

	class AAA extends AA

	class AAAA extends AAA

	/**
	* >: 下限：限制泛型为AA或其父类
	*
	* @tparam T
	*/
	class B[T >: AA]

	/**
	* <: 上限：限制泛型为AA或其子类
	*
	* @tparam T
	*/
	class C[T <: AA]

}

4.上下文限定

object Test05 {

	class B[T]
	
	implicit val x: B[Int] = new B[Int]
	
	/**
	* 上下文限定
	* 将泛型和隐式转换结合的产物
	*/
	def main(args: Array[String]): Unit = {
		m1(1)
		m2(1)
	}
	
	
	//隐式转换
	def m1[A](a: A)(implicit b: B[A]): Unit = {
		println("m1")
	}
	
	//上面式子以上下文限定的方式可以写为
	def m2[A: B](a: A): Unit = {
		println("m2")
	}
}