scala类，循环，8种方法函数

scala类，循环，8种方法函数

类和对象

规则：

1 Scala object相当与Java中的单例，object中定义的全是变量，因此执行时先被加载执行

2 Scala中定义变量使用var，定义常量使用val，变量和常量类型可以省略不写，会自动推断

3 Scala中每行后都会有分号自动推断机制，不需要显式写出 “；”

4 建议在Scala中使用驼峰命名法

5 Scala类中可以传参，传参一定要指定类型，有了参数就有了默认构造，类中的属性默认有getter和setter方法

6 类中重写构造时，构造中第一行必须先调用默认的构造，def this(…)(…)

7 Scala中当new class时，类中除了方法不执行（除了构造方法）没其他都执行

8 在同一个Scala文件中，class每次和object名称一样时，这个类叫这个对象的伴生类，这个对象叫做这个类的伴生对象，他们之间可以相互访问

循环

if-else

​ 和java用法一样

for

​ 几种常见用法

  /**
   *for  循环
   */
   
//    var r = 1 to 10
//    var r1 = 1 to 10
//    for (i <- 1 until 10){
//      for (j <- 1 until 10){
//        if(i >= j){
//          print(i+"*"+j+"="+i*j+"\t")
//        }
//        if (i ==j ){
//          println()
//        }
//      }
//    }

//    for (i <- 1 until 10;j <- 1 until 10){
//        if(i >= j){
//          print(i+"*"+j+"="+i*j+"\t")
//        }
//        if (i ==j ){
//          println()
//        }
//    }

//    for(i <- 1 to 1000;if(i>500);if(i%2 == 0)){
//      println(i)
//    }

//    for(i <- 1 to 1000 if(i>500) if(i%2 == 0)){
//      println(i)
//    }

    //将数据放在集合中  Vector
//    val a = for(i <- 1 to 100;if(i>50);if(i%2 == 0)) yield i
//      println(a)

do-while

/**
  * while
  * do-while  循环
  */
  
var i = 0
while (i<100){
  println(s"第 $i 次执行。。。")
  i += 1
}

do {
  println(s"第 $i 次执行。。。")
  i += 1
}while(i<100)

方法定义

规则：

1 方法体中最后返回值可以使用return，如果使用return，那么方法体的返回值类型一定要指定

2 如果方法体中没有return，默认将方法体中最后一行计算的结果当做返回值返回，方法体的返回值类型可以省略，会自动推断返回值的类型

3 定义方法传入的参数一定要指定类型

4 方法的方法体如果可以一行ko，那么方法体的“{…}”逻辑关系产生的{}，可以省略

5 如果定义方法时，省略了方法名称和方法体之间的“=”，那么无论方法体最后一行计算的结果是什么，都过会被丢弃，返回Unit

def main(args: Array[String]): Unit = {
  def max(a:Int,b:Int):Int={
    if(a>b){
      return a
    }else{
      return b
    }
  }
  val c : Int = max(2,3)
  println(c)

  def max(a:Int,b:Int):Int = if(a>b) a else b
  val d : Int = max(2,3)
  println(d)
}

递归方法

​ 递归方法要显式声明函数的返回值类型

/**
  * 递归方法
  */
def fun(num:Int):Int={
  if (num == 1){
    1
  }else{
    num*fun(num-1)
  }
}
println(fun(num = 5))

参数有默认值的方法

​ 想使用默认值就忽略，不行使用就调用时赋值

/**
  * 参数有默认值的方法
  */
def fun(a:Int=10,b:Int=20)={
  a+b
}
println(fun(b=200))

可变长参数的方法

​ 定义数据类型后加 *

   /**
      * 可变长参数的方法
      * 定义数据类型后加 *
      */
    def fun(s:String*)={
//        for(elem<-s){
//          println(elem)
//      }

      // =>前是匿名函数
     // s.foreach(elem => {println(elem)})
     
     //简化版匿名函数
     //s.foreach(println(_))
     s.foreach(println)
    }
    fun("a","b","dfdf")

//传任意类型用 Any*

匿名函数

​ => 就是匿名函数，多用于方法中

​ 匿名函数在遍历中如果只使用一次，匿名函数内部的别名则可以用 _ 表示（详述看上例）

  /**
    *匿名函数
    */
  def fun=(a:Int,b:Int)=>{
    a+b
  }

}

嵌套方法

/**
  * 嵌套方法
  */
def fun(num:Int)={
  def fun1(a:Int):Int={
    if (a==1){
      1
    }else{
      a*fun1(a-1)
    }
  }
  fun1(num)
}
println(fun(num = 5))

偏应用函数

​ 某些情况下，方法中参数非常多，调用这个方法非常频繁，每次调用只有固定的某个参数变化，其他的都不变，可以定义偏应用函数来实现，进而达到简化代码目的

/**
  * 偏应用函数
  */
def showLog(date:Date,log:String)={
  println(s"date is $date , log is $log")
}
val date = new Date()
showLog(date,log = "a")
showLog(date,log = "b")
showLog(date,log = "c")

def fun= showLog(date,_:String)
fun("aaa")
fun("bbb")
fun("ccc")

高阶函数

/**
  * 高阶函数
  * 1 方法的参数是函数
  * 2 方法的返回是函数			必须显式的声明返回函数类型（2-1），加_不用显式（2-2）
  * 3 方法的参数和返回都是函数
  */
  
//方法的参数是函数
//1-1 
def fun(a:Int,b:Int):Int = {
  a+b
}
def fun1(f:(Int,Int)=>Int,s:String):String = {
  val i :Int = f(100,200)
  i + "#" +s
}
val result = fun1(fun,"scala")
println(result)

//1-2
def fun3(f:(Int,Int)=>Int,s:String):String = {
  val i :Int = f(100,200)
  i + "#" +s
}
val result2 = fun3((a:Int,b:Int)=>{a*b},"scala")
println(result2)


    //方法的返回是函数
	//2-1
//    def fun(s:String):(String,String)=>String = {
//      def fun1(s1:String,s2:String):String = {
//        s1+"----"+s2+"~~~"+s
//      }
//      fun1
//    }
	
	//2-2
    def fun(s:String)= {
      def fun1(s1:String,s2:String):String = {
        s1+"----"+s2+"~~~"+s
      }
      fun1 _
    }
    println(fun("a")("b","c"))
    
    
    //方法的参数和返回都是函数
//    def fun(f:(Int,Int)=>Int):(String,String)=>String = {
//      val i :Int = f(1,2)
//      def fun1(s1:String,s2:String):String = {
//        s1+"---"+s2+"---"+i
//      }
//      fun1
//    }
//    println(fun((a,b)=>{a+b})("a","b"))

柯里化函数

/**
  * 柯里化函数
  */
def fun(a:Int,b:Int)(c:Int,d:Int)={
  a+b+c+d
}
println(fun(1,2)(3,4))