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)就近原则
   }
 }