标签：Comparable val scala Int Inner new type class def
一、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)
}
}
标签：Comparable,val,scala,Int,Inner,new,type,class,def 来源： https://blog.csdn.net/linjingyg/article/details/121819052
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。