Scala知识准备
=> 的应用场景
1.表示函数的返回类型,比如定义一个函数变量,Int表示函数x的返回类型
def multi(x : Int):Int = x * 3
val x : Int => Int = multi
println(x(4))
2.定义匿名函数 => 左边是入餐,右边是函数体
val fun = (x: Int) => x + 1
3.模式匹配
val max = x > y match {
case true => 1
case false => 0
}
4.By-Name Parameters(传名参数),可以理解为函数的入参既可以是指定类型的值,也可以是返回参数为制定类型的函数
def doubles(x: => Int) = {
println("Now doubling " + x)
x * 2
}
def f(x: Int): Int = {
println(s"Calling f($x)")
x
}
doubles(f(3))
运行结果:最后值为6
Calling f(3)
Now doubling 3
Calling f(3)
策略模式
策略模式在《Design Patterns: Elements of Reusable Object-Oriented Software》的定义
Define a family of algorithms, encapsulate each one, and make them inter changeable.Strategy lets the algorithm vary independently from clients that use it.
大意是说定义一系列算法,封装每个算法,使算法通用。策略模式使算法独立于使用算法的客户端。
策略模式中的角色
- 策略接口,定义调用策略时的方法名称
- 策略的具体实现,比如针对一个数组求和、求乘积等,都算是一个策略。统一继承策略接口
- 策略上下文,持有具体策略类的实例
类图如下
策略模式的实现
1.函数式编程实现
object Strategy {
def main(args: Array[String]): Unit = {
val a = Array(9.12, 9.25, 8.87, 9.99, 6.99, 7.88)
val compute1 = setStrategy(strategyOne)
val compute2 = setStrategy(strategyTwo)
println(compute1(a))
println(compute2(a))
}
//计算代数平均值(具体策略实现)
def strategyOne(scores: Array[Double]): Double = {
var sum: Double = 0
scores.foreach(s => sum = sum + s)
sum/scores.length
}
//计算几何平均值(具体策略实现)
def strategyTwo(scores: Array[Double]): Double = {
var multi: Double = 1
scores.foreach(s => multi = multi * s)
Math.pow(multi, 1.0/scores.length)
}
//返回具体的计算方法(相当于策略决策者,相当于策略上下文)
def setStrategy(concreteStrategy: Array[Double] => Double) = {
scores: Array[Double] => {
concreteStrategy(scores)
}
}
}
2.面向对象实现
添加策略接口
trait StrategyInterface
object StrategyInterface {
def apply(kind: String) = kind match {
case "one" => new StrategyOne()
case "two" => new StrategyTwo()
}
}
策略类
case class StrategyOne extends StrategyInterface
case class StrategyTwo extends StrategyInterface
参考:
https://www.cnblogs.com/wjunge/p/10043079.html