Scala中的构造器和高阶函数

构造器

在定义类时可以定义主构造器。主构造器可以同时声明字段。

/**
 * 主构造器
 * @author Administrator
 */
//在scala中，类和方法交织在一起
class TestClass51(val name:String = "" ,val age:Int = 0){  
  
  println("name="+ name + " age=" + age)
  
}

object TestScala51 {
  def main(args: Array[String]): Unit = {
    val c = new TestClass51(age = 18)
  }
}

/**
 * 辅助构造器
 * @author Administrator
 */
//在scala中，类和方法交织在一起
class TestClass52(){  
  var name:String = "" 
  var age:Int = 0
  
  def this(name:String){
    this()  //第一行调用主构造器
    this.name = name
  }
  
  def this(name:String , age:Int){
    this(name)  //第一行必须调用主构造器或者其他辅助构造器
    this.age = age
  }
//  println("name="+ name + " age=" + age)
  
}

object TestScala52 {
  def main(args: Array[String]): Unit = {
    val c = new TestClass52("zhangsan",20)
    println(c.name)
    println(c.age)
  }
}

高阶函数

函数可以赋给变量 首先，在scala中，函数是一等公民。

 

匿名函数 函数的形式是 (形参列表)=>返回值类型

函数作为形参

既然函数可以作为参数，那么在调用的时候我们会传递函数的变量过去。那么，我们可以省略函数的定义，在调用的时候直接把函数的实现（即匿名函数）过去。

函数作为形参 对于只有一个参数的，可以只写函数体。 fun3(a=>a+2) 如果形参只有一个，可以在函数体中使用_代替。 fun3(_+2) 函数作为形参的终极版本。

把匿名函数放在函数体内

/**
 * 高阶函数 要为spark做铺垫的话一定要讲高阶函数
 * Scala中的语法很灵活,公司要自己统一开发规范. 声明方法可以用def 还可以用val和var
 * @author Administrator
 */
object TestScala53 {
  def main(args: Array[String]): Unit = {
//================================================================    
    //在scala中把函数称之为一等公民 
    def add(a:Int , b:Int) = {
      a + b
    }
    val c = add(3,2)
    println(c)//打印5
//================================================================    
    
    //需求 将一个函数的实现传递给另外函数
    //应用场景:将一个函数指定另外一个别名；传递函数的实现给另外的函数
    def func1 = add _  //指的是将一个函数的实现传递给另外一个函数  而不是忘记了给该函数传递参数
    println(func1(1,3))//打印4
    
//================================================================
    
    def func2 = (x:Int) => {x + 2}  //匿名函数
    println(func2(100))//打印102
    
//================================================================

    //定义一个接收函数的函数
    def func3(f:(Int) => Int) = {
      f(100) * 2
    }
    
    def func4(a:Int) = {
      a + 1
    }
    println(func3(func4 _))//打印202 (100+1)*2  传递一个已有的函数给func3
    
    println(func3((x:Int) => x + 10))//打印 220 (100+10)*2=220 将一个匿名函数传递给func3
    
    //Scala中总有一些你意想不到的写法
    println(func3((x) => x + 10))//打印 220 简写一 类型简写,去掉Int类型 x的类型,程序自己推断
    println(func3( x => x + 10 ))//打印 220 简写二
    println(func3(_ + 10))  //打印 220 简写三
    
      /*
                以上简写的条件
      1.匿名函数作为参数
        2.只有一行代码
        */
//================================================================
    
    def func5(f:(Int,Int) => Int) = {
      f(2,3)
    }
    println(func5((x:Int,y:Int) => x + y))//打印5
    println(func5((x,y) => x + y)) //打印5 简写一
    println(func5(_ + _)) //打印5 简写二
      
      /*
               总结“_” 所能代表的意义
        1、用于取元组值
        2、代表一个占位符
        3、指的是将一个函数的实现传递给另外一个函数  而不是忘记了给该函数传递参数
        4、代表符合条件的每一个元素
        */
    
//================================================================
    
    /*常见的高阶函数*/
    //1.filter map
    var d = (1 to 10).filter( _ % 2 == 1).map(_ * 3)
    println(d.mkString(","))//打印 3,9,15,21,27
    //filter( _ % 2 == 1) 过滤出1,3,5,7,9
    
    var e = (1 to 10).filterNot( _ % 2 == 1)
    println(e.mkString(","))//打印 2,4,6,8,10
    
    var f = (1 to 10).reduceLeft(_ + _)//reduceLeft是左累加  1+2 3+3 6+4 .....(1+2+3+...+10=55) 
    println(f)//打印 55
    
    (1 to 10).map("*" * _).foreach(println _)
    //foreach是操作前面产生的每个元素
    /*
             打印输出
          *
          **
          ***
          ****
          *****
          ******
          *******
          ********
          *********
          **********     
     */
    
//================================================================
    
    //练习
    def func6(x:Int) = {
      (x:Int) => {
        x + 2
      } * 2
    }
    println(func6(1))//打印输出 <function1> 传递进去参数之后就一个函数.
    println(func6(1)(2))//打印输出8 (如果把x:Int改成y:Int 就会输出6)就近原则
  }
}