scala模式匹配之1、模拟枚举 2、option 3、泛型

package scaladay02.com.aura

1、//模拟枚举

object SimulatedEnume {
def main(args: Array[String]): Unit = {
//sealed case class来模拟枚举
//定义一个抽象类用sealed修饰表示

sealed abstract  class TrafficLight
//定义样例类来继承抽象类
case class RED(stop:String) extends TrafficLight
case  class YELLOW(waring:String) extends TrafficLight
case class GREEN(go:String) extends TrafficLight

// var tl:TrafficLight =RED("开车注意安全")

var t2:TrafficLight=GREEN(“绿灯请通行”)
//定义match模拟枚举
t2 match{
case RED(stop)=>{
println(stop)
}
case YELLOW(waring)=>{
println(waring)
}
case GREEN(go)=>{
println(go)
}

} }

def method1() {

//scala中定义枚举的正确格式，与java中定义的是不同的
class Season extends Enumeration {
val SPRING, SUMMER, AUTUMN, WINTER = Value
}
val season=new Season
println(“spring:”+season.SPRING)
}
}

package scaladay02.com.aura

2、**//定义option

// map集合中只有两个结果获取到和获取不到**
/**

如果我们直接获取option的操作，不论有值无值，同时避免无值时调用get报错，
一般都用getOrElse(default)。
*/
object OptionMap {
def main(args: Array[String]): Unit = {
mthod()
}
def mthod(): Unit ={
val map=Map(
(“Amertica”->“W.D.C”),
(“Japan”->“Tokoyo”),
(“South Korea”->“韩城”)

)
// val capital=map.get(“Amertica”)
// //option -->是一个sealed密封类，也就是说所有的子类都是可知的，不能再进行添加
// capital match {
// case Some(cc) => println(cc)
// case None => println(“火星”)
// }
println(map.getOrElse(“India”,“火星”))
}
}

package scaladay02.com.aura
//类型参数==泛型
/**

scala中定义泛型用的是[]而不是跟java中一样用<>
*/
object TypeParameters {
def main(args: Array[String]): Unit = {
val tool=new ToolInt
//泛型类不是很灵活因为一旦成员变量上面是用来这个类的泛型那么便无法在使用其他类型
println(tool.add(3,5))
println(tool.add(3,5,6))

val tool2=new Tool[String]
println(tool2.add(“abc”,“lmn”))
}
}

3、泛型

3.1//泛型类

class Tool[T]{
def add(a:T,b:T):T={
a
}
def add(arr:T*):T={
arr(0)

}}

package scaladay02.com.aura

3.2 * 泛型方法

/*
object GenericMethod {
def main(args: Array[String]): Unit = {
val tool1=new Tool1
tool1.showInt
tool1.showFloat
tool1.showString
}
}
class Tool1{
//泛型方法的定义注意泛型应在写在方法名后面用[]括起来
def showT{
println(arr.mkString(","))

}
}
注意成员变量上使用泛型不能自定义只能使用类上定义的泛型

package scaladay02.com.aura

3.3**//泛型的限定和视图的限定

/****

在scala中用来进行上限限定的语法结构是[T <:xxx]如果是使用通配符的话可以用？
在scala中用来定义下限限定的语法结构是[T>:xxx]若是使用通配符的话可以使用_
/
object Definition {
def main(args: Array[String]): Unit = {
val arr=ArrayInt
val strArr=ArrayString
println(“排序前的数组：”+arr.mkString(","))
selectSort(arr)
println(“排序后的数组：”+arr.mkString(","))
}
//定义排序方法在scala中让一个类型具备比较性一般用Comparable[T]
//在scala中让一个集合具体进行比较一般使用Comparator[T]
/*
- Int因为未进性扩展Comparable接口所以我们不能直接使用xx.comparaTo操作的
- 但是我们可以将[T <: Comparable[T]]改为[T <% Comparable[T]]则编译就可以通过了
- 因为此时底层进行了隐式转化
*/
def selectSortT<% Comparable[T]{
for (a <- 0 to arr.length){
for (b <-a until arr.length){
if (arr(a).compareTo(arr(b))>0){
swap(arr,a,b)
```
 }
```
}
}
}
def swapT{
var temp=arr(a)
arr(a)=arr(b)
arr(b)=temp

}
}