package com.yz9

import org.junit.Test

import scala.collection.mutable.ListBuffer

class test {
@Test
def test1(): Unit ={
val abc = new Abc[String,Int]("小明",20)
println(abc.name)
println(abc.age)

}

@Test
def test2(): Unit ={
val list = ListBuffer[String]()
list.append("小","大")

 for(s<- list){  
   println(s)

 }

}

@Test
def test3(): Unit ={
//在函数上使用泛型
def show[T,S,J](a:T,b:S)=println(s"$a------$b")
show("小白",333)
}

@Test
def test4(): Unit ={
val st = new student[Int](1,66)
println(st.bigger) //Int不行 加上隐士转换可以

val st2 = new student\[String\]("a","b")  
println(st2.bigger)//行

val st3 = new student\[Long\](3,55)  
println(st3.bigger)//Long不行  加上隐士转换可以

val st4 = new student\[Integer\](5,66)  
println(st4.bigger)//Integer(Java类型)可以  

}

@Test
def test5(): Unit ={
//scala本身不支持泛型 协变和逆变
//要想使用 协变 (java向上转型) 泛型前写+
// 逆变 (java向下转型) 泛型前写-

//val list1:MyList\[Person\]=new MyList\[St\]//协变ok  
//val list2:MyList\[St\]=new MyList\[Person\]//逆变编译就报错

val list3:YouList\[St\]=new YouList\[Person\]//逆变ok  

// val list4:YouList[Person]=new YouList[St]//协变编译报错
}

@Test
def tset6(): Unit ={
//类型通配符
//定义一个方法
def show(p:Pair[_<:Person]): Unit ={
println("ok")

}  
//调用  
show(new Pair\[Person\](new St,new Tc))

}

}
class Pair[T](first:T,second:T){
println("运行成功")
}
class Person
class St extends Person
class Tc extends Person
class MyList[+T]//支持协变
class YouList[-T]//支持逆变

//给T一个上限 T<:类型 Int和Long不行 // T<% 类型 %可以促使隐士转换 例如Int-》RichInt //Comparable的子类一定有compareTo方法 class student[T <%Comparable[T]](first:T,second:T){ //"".compareTo()字符串有该方法 //66.compareTo(77)long有该方法 //取出大值 def bigger= if (first.compareTo(second)>0) first else second

}

case class Abc[T,S](name:T,age:S)//T和S只是类型的占位，使用时再指定

package com.yz9

import java.io.File

import org.junit.Test

import scala.io.Source

class test2 {

@Test
def test1(): Unit ={
//val x:Int=3.5 报错

//定义一个隐士转换函数  

implicit def double2int(num:Double):Int=num.toInt

val a:Int=3.3//隐式（看不出来）转换  
println(a)//3  

}

@Test
def test2(): Unit ={
//定义一个读文件方法
implicit def file2myFile(file: File):MyFile =new MyFile(file)

//使用file调用MyFile的方法,依赖了隐士转换\[相当于为file对象增加了一个方法，丰富了类库api\]  
new File("C:\\\\Users\\\\a\\\\Desktop\\\\abc.txt").read()

//做隐士转换函数时注意：  
//1 有一个单个参数（需要转谁把谁当参数）  
//2 返回值就是需要转型的目标类型

}
//定义一个class
class MyFile(file: File){
def read()= println(Source.fromFile(file).getLines().mkString)
}

}

package com.yz9

import java.io.File

import scala.io.Source

object MyImplicitFunction {
//要集中放在object里，不然引用时找不到

//定义隐式函数
implicit def show(x:Double)=x.toInt

//定义一个读文件方法
implicit def file2myFile(file: File):MyFile =new MyFile(file)
//定义一个class
class MyFile(file: File){
def read()= println(Source.fromFile(file).getLines().mkString)
}

//隐式值
implicit val a:Int=999

implicit def string2int(x:String): Int =x.toInt

}

package com.yz9

import java.io.File

import org.junit.Test

class test3 {
@Test
def test1(): Unit ={

import com.yz9.MyImplicitFunction.\_//引用  
val a:Int=33.3//有隐士转换，所有的double都能当作int来用  
new File("C:\\\\Users\\\\a\\\\Desktop\\\\abc.txt").read()

}

@Test
def test2(): Unit ={
import com.yz9.MyImplicitFunction._
//隐士参数 会被隐式值自动赋值
def show(name:String)(implicit age:Int): Unit ={
println(s"$name----$age")
}

show("张三")  
val x:Int="33"  

}

}