Scala-模式匹配、样本式和泛型

模式匹配

//例一
var s = 'A'
s match{
	case 'A' => println(100)
	case 'B' => println(80)
	case 'C' => println(60)
	case _ if Character.isDigit(s) => println("无效的字符")
	case _ => println(0)
}
//例二
var str = "Hello World"
str(4) match{
	case ' ' => println("这是一个空格")
	case ch => println(ch)
}
//例三
var str : Any = 100
str match{
	case x : Int => println("这是一个整数")
	case s : String => println("这是一个字符串")
	case _ => println("这是其他类型")
}
//例四
var array = Array(1,2,3)
str match{
	case Array(0) => println("数组中只有一个0")
	case Array(x,y) => println("数组中只有两个元素")
	case Array(x,y,z) => println("数组中只有三个元素")
	case Array(x,_*) => println("数组中包含多个元素")
}
//例五
var list = List(1,2,3)
str match{
	case List(0) => println("列表中只有一个0")
	case List(x,y) => println("数组中只有两个元素"+(x + y))
	case List(x,y,z) => println("数组中只有三个元素"+(x + y + z))
	case List(x,_*) => println("数组中包含多个元素"+list.sum)
}

匹配类型

Any：表示任何类型

Unit：表示没有值，相当于void

Nothing：函数抛出异常时，返回值就是nothing，是任何类型的子类型

Null：所有引用类型的子类

特殊类型

Option：表示一个值是可选的（有值或者没有值）

Some：如果值存在，Option[T]就是一个Some[T]

None：如果值不存在，Option[T]就是一个None

Nil：空的list

样本类

class Fruit
class Apple(name : String) extends Fruit
class Orange(name : String) extends Fruit
var o = new Orange("orange")
println(a.instanceOf[Fruit])  //true
println(a.instanceOf[Apple])  //false

class Vehicle

case class Car(name : String) extends Vehicle

case class Bike(name : String) extends Vehicle

object Demo{
	def main(args : Array[String]) : Unit = {
		var car : Vehicle = new Car("Car")
		car match{
			case Car(name) => println("汽车"+name)
			case Bike(name) => println("自行车"+name)
			case _ => println("其他")
		}
	}
}

泛型

泛型类

class GenericClass[T] {
	//定义变量
	private var content : T = _  //初始值用_来表示
	//定义set get
	def set(value : T) = content = value
	def get() : T = content
}

object Demo{
	def main(args : Array[String]) : Unit = {
		//定义一个Int类型
		var v = new GenericClass[Int]
		v.set(100)
		println(v.get())
	}
}

泛型函数

import scala.reflect.ClassTag
def array(elem : Int*) = Array[Int](elem : _*)
def array[T : ClassTag](elem : T*) = Array[T](elem : _*)

上界与下界

class Vehicle

class Car(name : String) extends Vehicle{
	override def drive() : Unit = println("Car Driving")
}

class Bike(name : String) extends Vehicle{
	override def drive() : Unit = println("Bike Driving")
}

object Demo{
	// 定义交通工具
	def takeTraffic[T <: Vehicle](v : T) = v.drive()
	def main(args : Array[String]) : Unit = {
		var car : Vehicle = new Car
		takeTraffuc(car)
	}
}

视图与界定

/*
 * 调用IntToStr  Int => String
 * addTwoString("1","2")
 */
def addTwoString[T <% String](x : T,y : T) = x + "*****" + y
implicit def IntToStr(n : Int) : String = n.toString
addTwoString(1,2)

协变与逆变

协变：便是在类型参数前面加上+，泛型变量的值，可以是本身类型或者其子类类型

逆变：便是在类型参数前面加上-，泛型变量的值，可以是本身类型或者其父类类型

协变

class Animal

class Bird extends Animal

class Sparrow extends Bird

class EatSomething[+T](t : T)

object Demo {
	def main(args : Array[String]) :Unit = {
		var b : EatSomthing[Bird] = new EatSomthing[Bird](new Bird)

		var a : EatSomthing[Animal] = b
	}
}

逆变

class Animal

class Bird extends Animal

class Sparrow extends Bird

class EatSomething[-T](t : T)

object Demo {
	def main(args : Array[String]) :Unit = {
		var b : EatSomthing[Bird] = new EatSomthing[Bird](new Bird)

		var s : EatSomthing[Sparrow] = b
	}
}

隐式

隐式转换

class Fruit(name : String) {
	def getFruitName() : String = name
}

class Monkey(f : Fruit) {
	def say() = println("Monkey like "+f.getFruitName())
}

object Demo {
	def main(args : Array[String]) :Unit = {
		//实例化Fruit对象
		var b : Fruit = new Fruit("Banana")
		创建一个隐式转换
		implicit def like(f : Fruit) : Monkey = {
			new Monkey(f);
		}
		//实现say()方法
		f.say();
	}
}

隐式参数

使用implicit修饰的函数参数

def output(implicit name : String) = println("The value is "+name)
implicit val name : String = "*****"         
output       //The value is *****
def compareMin[T](a : T,b : T)(implicit order : T => Ordered[T]) = if(a < b) a else b
compareMin(1,2)   //1
compareMin("Hello","ABC")  //ABC

隐式类

object Demo {
	def main(args : Array[String]) :Unit = {
		println("两个数字的和为："+1.add(2))
		implicit class calculate(x : Int){
			def add(y : Int) : Int = x + y
		}
	}
}