[Comparable,Bounds,T,Scala,Int]scala学习-泛型、界定、形变、this.type、复合类型、抽象类型

　　一、Scala中的泛型

　　class Triple[F: classtag, S : classtag, T : classtag](val f : F, val s : S, val t :T) //其中，classtag在scala.reflect.classtag中，并且classtag是隐式的，可省略；

　　val t1=new Triple("hadoop", "spark", "bigdata");

　　val t2=new Triple[String, Int, Double]("bigdata", 1, 1.0);

　　二、Scala中Bounds（界定）

　　一般的Bounds

　　<: 使得T必须是Comparable[T]的子类，这T类型的a，b才有compareto方法。

　　class Pair[T <: Comparable[T]](val a : T, val b : T)

　　if(apareto(b)> 0) a else b

　　View Bounds（视图界定）

　　class Pair2 [T <% Comparable[T]](val a : T, val b :T)

　　<% 使得T不是Comparable[T]的子类型，隐式转为它的子类。比如传入的是Int类型，Int类型没有实现Comparable[T]。故先要将Int隐式转为RichInt，此时RichInt是Comparable[T]的子类

　　class Pair3 [T <% Ordered[T]](val a : T, val b : T)

　　转为Ordered[T]，可以将对象以a > b 的形式进行比较。If(a>b) a else b，其实>是a的方法

　　Context Bounds

　　class Pair_Ordering [T : Ordering : classtag](val a : T, val b : T) {

　　def bigger(implicit ordered : Ordering[T])={

　　if(orderedpare(a, b) > 0) a else b

　　}

　　}

　　T :Ordering表示存在一个隐式值为Ordering[T]

　　Manifest、classManifest、classtag、TypeTag

　　利用Manifest可以创建泛型数组。Manifest中存储了T的实际类型的信息，在实际运行中作为参数运行在上下文环境中。其中T:Manifest和上文的T:Ordering都属于Context Bounds的用法

　　def arrayMake[T : Manifest](a : T, b : T)={

　　val array=new Array[T](2);

　　array(0)=a;

　　array(1)=b;

　　array;

　　}

　　后来，Manifest和classManifest分别被TypeTag和classtag所取代。Classtype的限定要弱于TypeTag。Classtype提供了运行时的类型信息，而TypeTag提供了所有的静态类型信息。而实际中，Classtype提供的运行时类型信息已经足够使用，因此在spark等中使用广泛。

　　def arrayMake2[T : classtag](elems : T*)=Array[T](elems : _*)

　　,这里可以看到T:classtag，自动隐式转为classtag[T]

　　arrayMake2(1,2).foreach(println)

　　主要是在运行时指定在编译时无法确定的比较高级别的类别的信息，不包括static级别的type信息。

　　多重界定

　　T <:A with B 表示T是A或B的子类。

　　T : A: B 是上下文界定。表示必须同时存在A[T]和B[T]的隐式值。

　　T <% A <% B 是视图界定，表示T可以隐式转为A且B。

　　T>: A <: B 表示A是T的下界，B是T的上界。并且，下界A必须写在上界B的前面，同时A一定是B的子类。

　　三、 Scala的类型约束

　　A=:=B 表示A类型等同B类型

　　A<:< B 表示A类型是B类的子类型

　　四、 Scala中的Variance

　　Variance称为形变 T

　　协变 +T

　　逆变 –T

　　class Person[+T](first : T, second : T) 则后面的first和second的类型必须是T的父类。-T的话，表示first和second的类型必须是T的子类。

　　五、 Scala中的链式调用

　　任何的类对象都有type属性:this.type

　　class Animal {

　　def breathe() : this.type={

　　//Todo

　　this

　　}

　　}

　　class Dog extends Animal {

　　def eat() : this.type={

　　//Todo

　　this

　　}

　　}

　　Val dog=new Dog; dog.breathe().eat();

　　六、 Scala中的路径依赖

　　内部类享有外部类的实例，可以访问外面类中的私有成员；而外部类不可以访问内部类中的私有成员。

　　Scala中内部类必须依赖于外部类的实例。外部类实例不同，则内部类也不同，依赖于外部类，称为路径依赖，不同路径下的内部类，类型不同。

　　class Outter {

　　private[this] val x=1

　　class Inner {

　　private[this] val y=x + 1

　　}

　　}

　　object PathDependencies extends App {

　　val out1=new Outter

　　val out2=new Outter

　　//out1.Inner和out2.Inner在不同路径下，类型不同

　　val inner1 : out1.Inner=new out1.Inner

　　val inner2 : out2.Inner=new out2.Inner

　　//类型投影，out1.Inner,out2.Inner是Outter#Inner的子类

　　val inner3 : Outter#Inner=new out1.Inner

　　val inner4 : Outter#Inner=new out2.Inner

　　}

　　七、 Scala中的结构体类型

　　//传入实现get方法的匿名类实例

　　init(new {def get()=println("geted")})

　　//申明一个含有get方法的类型，类型于c语言中的结构体类型

　　type X={//不需要像java那样，通过接口和实现接口来限制

　　def get() : Unit

　　}

　　def init1(res : X)={

　　res.get

　　}

　　init1(new {def get()=println("geted again")})

　　object A {def get()=println("geted In A")}

　　init1(A)

　　八、 Scala中的复合类型

　　trait A //接口A

　　trait B //接口B

　　class C extends A with B {//继承A,B,实现get的C

　　def get()=println("hello compoundtype!")

　　}

　　object CompoundType {

　　//复合类型，该QQ号买号类型表示既是A又是B，同时还要实现get方法

　　type CompoundType=A with B {def get():Unit}

　　def init(x : CompoundType)={

　　x.get()

　　}

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

　　init(new C)

　　}

　　}

　　九、 Scala中的InfixType

　　object InfixType {

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

　　//右结合的表达式

　　"Spark" >>: "Hadoop">>: Log

　　val list=List()

　　val newList=1 :: 2 :: list

　　println(newList)

　　class Infix_Type[A, B]

　　val it : Infix_Type[Int, String]=null

　　val it1 : Int Infix_Type String=null

　　val cons=Constant("1", "2")

　　cons match {

　　case "1" Constant "2"=> {

　　println("spark!")

　　}

　　}

　　}

　　}

　　case class Constant(first : String, second : String)

　　object Log {

　　def >>: (data : String) : Log.type={ // >>: 这是方法名

　　println(data);

　　Log

　　}

　　}

　　十、Self Types

　　自类型， 相当于对当前实例关键this起一个别名。用法如下：//有点类似于javascript中的var self=this; 的用法

　　Class Outter {

　　self=>

　　val i

　　Class Inner {

　　def foo(){ println(self.i) }

　　}

　　}

　　主要用途在对this的一种限定，必须要混入另一个类型。用法如下：

　　trait S1

　　class S2 {

　　this:S1=>

　　}

　　val s=new S2 with S1 //实例化S2的时候需要with S1

　　class S3 extends S2 with S1 //extends S2的时候需要 with S1

　　十一、 Scala中的依赖注入

　　通过self type的用法，实现依赖组件的注入

　　object DependenceInjection extends App {

　　T.authorize()

　　}

　　trait Logger{

　　def log(msg:String)

　　}

　　class Auth{

　　auth : Logger=> //关键点

　　val key="hello di"

　　def authorize()={

　　log(key)

　　//Todo

　　}

　　}

　　//T对象继承Auth则必须with Logger实现log方法

　　object T extends Auth with Logger {

　　override def log(msg:String)={

　　println(msg)

　　}

　　}

　　十二、 Scala中的抽象类型AbstractType

　　抽象类通过type声明类型，但不指定具体的类型

　　在子类中指定相关类型，和实现抽象类中的方法

　　trait Reader {

　　type input <: java.io.Serializable //input 必须是Serializable的子类

　　type results

　　def read(str : input) : results

　　}

　　class FileReader extends Reader {

　　type input=String

　　type results=BufferedSource

　　override def read(str : input):results={

　　Source.fromFile(str)

　　}

　　}