一、泛型的概念
泛型的定义为：参数化类型，即所有操作的数据类型被指定为一个参数。
在Scala中，用[]表示（在java中使用<>）。
举例：
val arr = ArrayBuffer[String]()
arr.insert(0, "a")
val arr1 = ArrayBuffer[Int]()
arr1.insert(0, 1)
泛型是对数据的类型的约束。
二、泛型方法
泛型方法指的是：把泛型定义放在方法声明上。即：该方法的参数类型是由泛型来决定的。在调用方法时，明确具体的数据类型。
三、泛型方法的格式
定义方法： def 方法名[泛型名称1，泛型名称2，. . .] (参数列表 ) = { }
调用方法： 方法名[类型1，类型2，] (参数列表)
如果在参数列表中可以推断出对应的类型，则可以省略方括号[类型1,类型2]
package imp
object imps {
implicit class StronfInt(n:Int ) {
def ! : Int = {
var rst = 1
for (i <- 1 to n) {
rst *= i
}
rst
}
}
implicit class StrongString(s:String) {
def isPhone:Boolean = {
val reg = "^1[35678]\d{9}$".r
reg.matches(s)
}
def isIDCard: Boolean = {
val reg = "^[1-9]\d{5}(18|19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}[\dXx]$".r
reg.matches(s)
}
}
}
package imp
import scala.language.postfixOps
import imp.imps._
object imp07 {
def main(args: Array[String]): Unit = {
println(4!) // 24
println(5!) // 120
println("13614254456".isPhone)
}
}
-
两个函数长的一样！！！！ 只有参数的类型不同。
-
定一个名为getMiddle的方法，用来获取输入列表中的中间位置上的元素
-
1 2 3 4 5 6 7
object fx01 {
def getMiddle(arr:Array[Int]):Int = {
arr(arr.length/2)
}
def getMiddle(arr:Array[String]):String = {
arr(arr.length/2)
}
def main(args: Array[String]): Unit = {
val arr1 = Array(1,2,3,4,5,6,7)
println(s"arr1的中间元素是: ${getMiddle(arr1)}")
val arr2 = Array("a","b","c")
println(s"arr2的中间元素是: ${getMiddle(arr2)}")
// val arr3 = Array(1.1,2.2,3.3)
}
}
四、理解泛型
1、泛型和数据类型有什么区别？
case class Student()
val s1 = Student()
val list = ArrayList[Student]()
list += s1
ArrayList 是数据类型，Student 是泛型。 他们不是一个层次的概念。 类型内部的数据使用泛型来约束。
2、泛型的声明方式:
从外部把类型传入到类的内部，好比是传入参数一样。所以，泛型也称之为类型参数。如果参数没有传递，就说明不需要类型的约束，它也不会发生错误。而是采用通用类型。
3、在编译时有效，在运行时会失效。
也就是说在代码被编译之后，在产生的代码中是看不到泛型相关的代码的。
def getMiddle[T](arr:Array[T]):T = {
arr(arr.length/2)
}
def main(args: Array[String]): Unit = {
val arr1 = Array(1,2,3,4,5,6,7)
println(s"arr1的中间元素是: ${getMiddle[Int](arr1)}")
val arr2 = Array("a","b","c")
println(s"arr2的中间元素是: ${getMiddle[String](arr2)}")
val arr3 = Array(1.1,2.2,3.3)
println(s"arr2的中间元素是: ${getMiddle[Double](arr3)}")
}
五、泛型类
泛型类指的是：把泛型定义放在类的声明上。即：该类中的参数类型是由泛型来决定的。在创建对象的时候，再来明确具体的数据类型。
格式：class 类[T](val 变量：T)
// 泛型类
class Ractangle[X](var w: X, var h: X) {
def getArea(): Unit = {
println(w, h)
}
}
def main(args: Array[String]): Unit = {
val r1 = new Ractangle[Double](1.5, 2)
r1.getArea()
}
写泛型类的步骤格式：先写一个普通的类 -> 把参数的类型（或者返回值的类型，或者内部属性成员的类型）改成泛型名 -> 在类名的后面添加[泛型]
