Lambda定义



lambda 表达式总是括在花括号中， 完整语法形式的参数声明放在花括号内，并有可选的类型标注， 函数体跟在一个 -> 符号之后。如果推断出的该 lambda 的返回类型不是 Unit，那么该 lambda 主体中的最后一个（或可能是单个） 表达式会视为返回值。

意思就是说lambda表达式一定要放在花括号 { } 中 , -> 前面是参数，后面是方法体就是你要拿这个参数进行的操作。如果你的lambda是有返回值的，-> 后面最后一个表达式会被视为返回值，代码如下：

Lambda就像一个简化的函数，如下：

lam1 对应的就是method1 ,两个参数，返回一个Int值。x+y 作为 -> 后面最后一个表达式返回
var lam1: (Int, Int) -> Int = { x: Int, y: Int -> x + y }

fun method1(x: Int, y: Int): Int {
    return x + y
}


lam2 对应的就是method2，如果表达式不需要返回值，x+y  只是做了一次运算，并没有返回 
var lam2: (Int, Int) -> Unit = { x: Int, y: Int -> x + y }

fun method2(x: Int, y: Int): Unit {
    x + y
}

lambda 主体中的最后一个（或可能是单个） 表达式会视为返回值。为啥非要这么说呢

var lam1: (Int, Int) -> Int = { x: Int, y: Int ->
 1操作 ➺  val sum = x + y
 2操作 ➺  println(sum)
 3操作 ➺  sum
}
注意：Kotlin不像java用 ; 作为结束标志，所以要每行写一个操作，如果放在一行编译就会报错！

 -> 后面有 1 ，2 ， 3  三个操作，最后3处的表达式作为返回值返回。

那如果  

var lam  = { x: Int, y: Int -> x + y }

前面声明不指定有没有返回值，x+y 会不会作为返回值返回呢？

var lam = { x: Int, y: Int -> x + y }
fun main() {

    println(lam(2, 3))

}

打印结果：

D:\AndroidStudio\android-studio\jre\bin\java.exe -
5

Process finished with exit code 0

结果是会作为返回值，如果不指定，会根据-> 后面返回表达式自动推算返回值，代码如下

修改1：
var lam = { x: Int, y: Int -> x > y }
打印结果
D:\AndroidStudio\android-studio\jre\bin\java.exe -
false

Process finished with exit code 0

修改2：
var lam = { x: Int, y: Int -> "Result $x $y" }
打印结果
D:\AndroidStudio\android-studio\jre\bin\java.exe -
Result 2 3

Process finished with exit code 0

=======================================================================

Lambda规则

我们通常看到的lambda印象最深就是，精简，最后简化到只剩一个 { } 都可以，虽然看不懂，就好厉害的感觉

那如何将一个函数方法改成一个lambda表达式呢？这就和下面lambda非常重要的几个规则有关

1  在 Kotlin 中有一个约定：如果函数的最后一个参数是函数，那么作为相应参数传入的 lambda 表达式可以放在圆括号之外 ，这种语法也称为拖尾 lambda 表达式。

fun main() {
 
    method3( "hello" ,  { x -> x + 6 } ) : 正常调用,
    ↓
    ↓
    ↓ 根据拖尾原则，如果lambda表达式在参数的最后一个位置
    ↓ 可以拿到圆括号外面
    ↓
    method3("hello") { x -> x + 6 }
   
}

fun method3(msg: String, lamParams: (Int) -> Int) {
                         
     两个参数：一个String，一个lambda表达式
}


2  如果一个 lambda 表达式只有一个参数，可以省略这个参数并忽略 ->。而这个被省略的参数可以用it代替

还是接着上面的代码继续修改
fun main() {
 
    method3( "hello" ,  { x -> x + 6 } ) : 正常调用,
    ↓
    ↓
    ↓ 根据拖尾原则，如果lambda表达式在参数的最后一个位置
    ↓ 可以拿到圆括号外面
    ↓
    method3("hello") { x -> x + 6 }
    ↓
    ↓ 根据单参数省略原则：
    ↓ 参数 x 省略，
    ↓ -> 省略
    ↓ x可用 it 代替   
    ↓
    method3("hello") {  it + 6 }
}

fun method3(msg: String, lamParams: (Int) -> Int) {
                         
     两个参数：一个String，一个lambda表达式
}

这样经过简化的之后，看起来很厉害的样子就出来了:  method3("hello") {  it + 6 }

 

3  如果 lambda 表达式的参数未使用，那么可以用下划线取代其名称：

fun main() {
 
    method("") { _, str -> str }
    分析：
     1 lambda表达式位置在method方法中参数最后一个可以拿到括号外面
     2 lambda表达式有两个参数，所以不能省略
     3 Int参数 在箭头后面的操作中没有用到，可以用 _ 代替
    
               
}

fun method(msg: String, lam: (Int, String) -> String) {

} 

这样就可以将函数精简为Lambda表达式了。


fun method5(str: String, x: Int, bool: Boolean) {
    str + x + bool
}
    ↓
    ↓ 精简
    ↓
{ str: String, x: Int, bool: Boolean -> str + x + bool }

然后将这个Lambda表达式赋值给lam5
var lam5  = { str: String, x: Int, bool: Boolean -> str + x + bool }
 


main(){
    method6是用method5 的函数形式作为参数
    我们分别传递 method5 和 lambda5 到method6中，完全没有问题，说明精简是对的
    method6(lam5)
    method6(::method5)
 
}
fun method6(m: (String, Int, Boolean) -> Unit) {
                 
       参数是(String, Int, Boolean) -> Unit这么一个表达式
 
}

=======================================================================

Lambda显示声明返回值：

  Lambda 禁止直接使用return关键字，我们可以使用限定的返回语法： return@函数名 从Lambda 显式返回一个值。 否则，将隐 式返回最后一个表达式的值。

lambda默认将 -> 最后一个表达式作为返回值返回
method("") { _, str ->  str }

也可以显示的 return 返回值
method("") { _, str -> return@method str }

 =======================================================================

匿名函数：

   当想要显示指定lambda 表达式的返回类型，我们可以使用匿名函数的形式

fun(x: Int, y: Int): Int = x + y

fun关键词后面并没有和普通函数一样有一个函数名，所以叫匿名函数。

而且如果返回值可以推算得出返回值也是可以省略的，即：fun(x: Int, y: Int) = x + y 也是可以的

注意：

1 匿名函数参数必须放在括号里面，不能像lambda表达式一样简化处理。

2 Lambda表达式与匿名函数之间的另一个区别是非局部返回的行为：这是什么意思呢？

官方文档是这样说的：一个不带标签的 return 语句总是在用 fun 关键字声明的函数中返回。这意味着 lambda 表达式中的 return 将从包含它的函数返回，而匿名函数中的 return 将从匿名函数自身返回。

非局部返回，这就牵扯到了 inline 内联函数

说的是 内联函数 如果被处理成了Lambda表达式的时候，return 返回的是外部那个调用内联函数的函数，而不是内联函数本身。(注意：前面说过Lambda是禁止直接使用return关键字，要使用必须是：return@函数名 这种形式。但是内联函数使用Lambda就可以直接使用 return关键字)。看代码：

fun song(f: (String) -> Unit) {

}

inline fun speak(f: (String) -> Unit) {

}
fun behavior() {
    
    song {
        println("song $it")
        return //此处报错: 'return' is not allowed here
    }

    speak {
        println("speak $it")
        return  //此处没问题
    }
    
}

fun main() {

    behavior()

}

song() 方法没有内联不允许在 Lambda 中直接 return 所以报错。

而我们函数调用顺序为  

main() -> behavior() -> speak

这样我们在  speak的参数lambda表达式里面 return，结束的是哪个函数呢？

结束的是 behavior 函数。因为 speak 是内联函数。编译的时候就变成下面样子，。

调用处大体示意：                                 编译时大体示意：
fun main() {                                    fun main() {

    behavior {                                     behavior {
       
         speak {                            
            println("speak $it")                         println("speak $it")
             return                                      return  
            }

      }                                                   }

}                                                   }



所以 return 的就是 behavior 函数了。

(注：内联函数能不能return还有其他限制，这里就不说了。)

上面说 lambda 表达式中的 return 将从包含它的函数返回，而匿名函数中的 return 将从匿名函数自身返回。说的是Lambda在内联函数的情况下。

 

 

 

 

 

 

 

 

 

 

局部变量


概念： 声明在函数内部的变量，必须先赋值再使用。


作用范围： 定义行开始到所在的代码块结束。


注意： 多个变量，在重合的作用范围内，不可出现重名（命名冲突）。
public class TestLocalVariables{
	public static void main(String[] args){
    	int a = 10;//局部变量
        System.out.println(a);//输出为 10
        if (a % 2 == 0){
            //int a = 20;//重名的局部变量
          //System.out.println(a);
        	int b = 20;//局部变量，这个b仅在此if结构下可用
            System.out.println(b);//打印结果为 20
        }//代码块结束，b变量回收
        int b = 30;//新变量赋值                  不建议定义相同名字的变量，重新定义新变量名
        System.out.println(b);//输出结果为30
    }
}

归一化有很多种方法，第一次遇到LRN是在Alexnet中，用于对卷积层的输出结果进行归一化。公式如下：



这里的i表示第i个通道，(x,y)为某个像素点位置。这里的意思就是说，我要把卷积层输出的第i个通道的(x,y)位置的值进行归一化。为什么叫局部响应呢？个人认为是因为每次归一化某个值得时候，要参考某个与该值相关的局部区域内的响应值，那这个局部区域怎么定呢？



这里是使用与该值具有同一位置（x,y）且与通道i距离为n/2的那些值。先写这些，以后理解了再说。

参考：https://blog.csdn.net/u014296502/article/details/78839881

红色框框  表示成员变量

蓝色框框  表示局部变量

 

形参   表示局部变量 

实参   表示成员变量