Scala篇

Unit 表示无值，和java中void等同。

Nothing 所有其他类型的子类型，表示没有值

Any 所有类型的超类型，任何实例都属于Any类型

AnyRef 所有引用类型的超类

AnyVal 所有值类型的超类

 Scala：

1.Scala object相当于java中的单例，object中定义的全是静态的。相当于java的工具类。Object不可以传参，对象要传参，使用apply方法。

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

3.Scala中每行后面都会有分号自动推断机制，不用显示写出“；”

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

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

6.类中重写构造时，构造中第一行必须先调用默认的构造。def this（....）{....}

7.Scala中当new class 时，类中除了方法不执行【除了构造方法】，其他都执行。

8.在同一个scala文件中，class名称和object名称一样时，这个类叫做这个对象的伴生类，这个对象叫做这个类的伴生对象，他们之间可以互相访问私有变量。

方法定义：

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

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

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

4.方法的方法体如果可以一行搞定，那么方法体的“{...}”可以省略

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

package com.bjsxt.scala

class Person(xname:String,xag:Int){
    val name = xname
    var age = xag
    var gender = 'M'
  def this(yname:String, yage:Int, ygender:Char){
    this(yname,yage)
    this.gender = ygender
  }
  def sayName()={
    println("hello world..." + Lesson_ClassAndObj.name)
  }

}

object Lesson_ClassAndObj {
  val name = "wangwu"
  def main(args: Array[String]): Unit = {
    val p = new Person("zhangsan",20)
    println(p.gender)
    val p1 = new Person("diaochan",18,'F')
    println(p1.gender)
//    p.age = 500
//    println(p.name)
//    println(p.age)
//    p.sayName()

//    val a = 100
//    var b = 200
//    b = 300
//    println(b)
  }
}

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

def main(args: Array[String]): Unit = {
  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*)={
      s.foreach(println)
//      for (elem<-s){
//        println(elem)
//      }
    }
    fun("hello","a","b","c")

匿名函数：“=>”就是匿名函数，多用于方法的参数是函数时，常用匿名函数

 

def fun:(Int,Int)=>Int = (a:Int,b:Int)=>{
  a+b
}
println(fun(100,200))

var funl:String => Unit = (s:String) => {
  println(s)
}
funl("hello")

 嵌套方法

def fun(num:Int)={
  def function1(a:Int):Int = {
    if (a == 1){
      1
    }else{
      a*function1(a - 1)
    }
  }
  function1(num)
}
println(fun(5))

偏应用函数：某些情况下，方法中参数非常多，调用这个方法非常频繁，每次调用只要固定的某个个参数变化，其他都不变，可以定义偏应用来实现。

def showLog(date:Date,log:String)={
  println(s"data is $date,log is $log")
}
val date = new Date()
showLog(date,"a")
showLog(date,"b")
showLog(date,"c")

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

 高阶函数：

1.方法的参数是函数

def function1(f:(Int,Int)=>Int,s:String):String = {
  val i = f(100,200)
  i+"#"+s
}
val result = function1((a:Int,b:Int)=>{a*b},"scala")
println(result)

2.方法的返回值是函数

def function1(s:String)={
  def function2(s1:String,s2:String):String ={
    s1+"~"+s2+"#"+s
  }
  function2 _
}
println(function1("a")("b","c"))

3.方法的参数和返回值都是函数

def function0(f:(Int,Int)=>Int):(String,String)=>String = {
  val i:Int = f(1,2)
  def function1(s1:String,s2:String):String = {
    s1+"@"+s2+"*"+i
  }
  function1
}
println(function0((a,b)=>{a+b})("hello","world"))

柯里化函数

def function1(a:Int,b:Int)(c:Int,d:Int)={
  a+b+c+d
}
println(function1(1,2)(3,4))