scala 初探（二）

一般地 scala val对应于C++ const


Scala有一些 比较灵活的使用方法
如所谓 前缀方法及后缀方法
实际就是 方法 没有参数及只有一个参数 当这种情况下
可以将该方法使用 前缀或后缀的形式进行调用。

一个简单的例子如下：

package scalaStudy/**  * Created by admin on 2017/4/18.  */case class MyBool(x: Boolean){  def and(that: MyBool): MyBool = {    if (x) that else this  }  def or(that:MyBool): MyBool = if(x) this else that  def negate: MyBool = MyBool(!x)  def not(x: MyBool) = x.negate  def xor(x: MyBool, y: MyBool) = (x or y) and not(x and y)}object MainCall {  def main(args: Array[String]): Unit ={    println("call main")    var boolInstance = new MyBool(true)    println(boolInstance negate);    println(boolInstance xor(new MyBool(true), new MyBool(false)))  }}

该类后3种方法的定义中使用了前后缀 运算符进行定义


由于scala中可以将可调用对象最为参数进行传入，当然 将函数体本身进行传入也是支持的
因为函数体本身可以看成一个 没有函数参数的可调用对象。
这种调用方式被简化 使得如下的形式是可以运行的(直接使用函数体作为参数输入)

 object TargetTest1 extends App{   def whileLoop(cond: => Boolean)(body: => Unit): Unit ={     if(cond){       body       whileLoop(cond)(body)     }   }   var i = 10   whileLoop(i > 0){     println(i)     i -= 1   } }

 下面是第二个例子

object TargetTest2 extends App{  def loop(body: => Unit): LoopUnlessCond = new LoopUnlessCond(body)  protected class LoopUnlessCond(body: => Unit){    def unless(cond: => Boolean): Unit ={      body      if(!cond) unless(cond)    }  }  var i = 10  loop{    println("i = " + i);   i -= 1;  }.unless(i == 0)}

通过上面两个例子主要要进行展示的是scala在初始化类时 可以灵活地使用
body进行初始化 相当于对于所要实现的功能的“装填”
一般其它语言是不使用这种形式进行初始化的
一般当如Java要实现类似功能时 一般使用的是继承方式
个人认为 这个语言给予此种功能的目的在于 进一步利用将函数作为传递对象（Higher-order Functions）
的优点 如 Scala中的Future对象一般的构造就可以是一个可执行的函数体
将功能进行封装来传递 这是一种非常类似于脚本语言的思想。


Java中一般实现单继承 故当要实现MixIn这种混合继承情况 定义一个MixIn类
就必不可少 在Scala中实现了以extends... with ...的继承 这作为混成类的继承方式
给出了另一个解决方案 下面是一个例子

abstract class AbsIterator {  type T  def hasNext: Boolean  def next: T}trait RichIterator extends AbsIterator{  def foreach(f: T=> Unit): Unit ={    while(hasNext){      f(next)    }  }}class StringIterator(s: String) extends AbsIterator{  type T = Char  private var i = 0  override def hasNext = i < s.length  override def next = {val ch = s.charAt(i);i += 1; ch}}object StringIteratorTest{  def main(args: Array[String]): Unit ={    //class Iter extends StringIterator(args(0)) with RichIterator    class Iter extends StringIterator("jack") with RichIterator    val iter = new Iter    iter foreach println  }}

Scala 如同Python支持闭包（Nested Methods）定义与使用的方法也与Python类似 不具体给出例子。


Scala 支持 柯里化(curry) 表现为支持类似偏函数的函数输出, 这在Python中表现为functools
中的partial固定部分参数（C++ functional bind） 返回新的函数对象
下面是一个例子

object CurryTest extends App{  def filter(xs: List[Int], p: Int => Boolean): List[Int] = {    if (xs.isEmpty) xs    else if (p(xs.head)) xs.head :: filter(xs.tail, p)    else filter(xs.tail, p)  }  def modN(n: Int)(x: Int)= ((x % n) == 0)  val nums = List(1,2,3,4,5,6,7,8)  println(filter(nums, modN(2)))  println(filter(nums, modN(3)))}

从上面的例子中可以看到使用Scala写递归(reduce) 函数的易实现。
回顾一下机器学习的基本知识会发现
其在机器学习中也是有实现 意义的 如 AdaBoost提升算法
通过相同的迭代形式 更新样本权重 将新权重返回改的拟合模型
作为下一步进行训练的输入 就可以利用上面的递归形式。


Scala 函数支持模式匹配(pattern match) 这个特点在Scala 初探(一)中
已经提到了 这里还要说明的是 在使用模式匹配时 可以规定返回不同的类型
下面是一个简单的例子

object MatchTest2 extends App {  def matchTest(x: Any): Any = x match {    case 1 => "one"    case "two" => 2    case y: Int => "scala.Int"  }  println(matchTest("two"))  println(matchTest(1))  println(matchTest(10))}