lamda表达式
lamda表达式是jdk1.8新特性之一
lamda表达式的前提：有一个函数式接口。
函数式接口定义：接口中有一个函数。
下面用代码做演示。
首先接口中的函数时无参的
本来是下面这样的：接口，接口实现类，和main方法。也就是说需要一个接口，两个类。
package com.yang;
public class Noargs {
public static void main(String[] args) {
Ilike like = new Like();
like.likeLamda();
}
}
//定义函数式接口
interface Ilike{
void likeLamda();
}
//定义接口实现类
class Like implements Ilike{
@Override
public void likeLamda() {
System.out.println("I like Java");
}
}
然后实现类可以用静态内部类代替，就演化成：一个接口，一个类！
package com.yang;
public class Noargs {
//静态内部类
static class Like implements Ilike{
@Override
public void likeLamda() {
System.out.println("I like Java");
}
}
public static void main(String[] args) {
Ilike like = new Like();
like.likeLamda();
}
}
//定义函数式接口
interface Ilike{
void likeLamda();
}
而静态内部类还可以用局部内部类来代替。
package com.yang;
public class Noargs {
public static void main(String[] args) {
//局部内部类
class Like implements Ilike{
@Override
public void likeLamda() {
System.out.println("I like Java");
}
}
Ilike like = new Like();
like.likeLamda();
}
}
//定义函数式接口
interface Ilike{
void likeLamda();
}
局部内部类再简化，就是匿名内部类：没有类的名称，必须借助接口或者父类。
package com.yang;
public class Noargs {
public static void main(String[] args) {
//匿名内部类
Ilike like = new Ilike() {
@Override
public void likeLamda() {
System.out.println("I like Java");
}
};
like.likeLamda();
}
}
//定义函数式接口
interface Ilike{
void likeLamda();
}
再简化，就是lamda表达式了。比匿名内部类，省略了：
package com.yang;
public class Noargs {
public static void main(String[] args) {
//lamda表达式
Ilike like = () -> {
System.out.println("I like Java");
};
like.likeLamda();
}
}
//定义函数式接口
interface Ilike{
void likeLamda();
}
然后是有参的
package com.yang;
public class Args {
public static void main(String[] args) {
Ilove love = new Love();
love.loveLamda(2);
}
}
//函数式接口
interface Ilove{
void loveLamda(int a);
}
//实现类
class Love implements Ilove{
@Override
public void loveLamda(int a) {
System.out.println("I love Java" + a);
}
}
静态内部类：
package com.yang;
public class Args {
//静态内部类
static class Love implements Ilove{
@Override
public void loveLamda(int a) {
System.out.println("I love Java" + a);
}
}
public static void main(String[] args) {
Ilove love = new Love();
love.loveLamda(2);
}
}
//函数式接口
interface Ilove{
void loveLamda(int a);
}
局部内部类：
package com.yang;
public class Args {
public static void main(String[] args) {
//局部内部类
class Love implements Ilove{
@Override
public void loveLamda(int a) {
System.out.println("I love Java" + a);
}
}
Ilove love = new Love();
love.loveLamda(2);
}
}
//函数式接口
interface Ilove{
void loveLamda(int a);
}
匿名内部类：
package com.yang;
public class Args {
public static void main(String[] args) {
//匿名内部类
Ilove love = new Ilove(){
@Override
public void loveLamda(int a) {
System.out.println("I love Java" + a);
}
};
}
}
//函数式接口
interface Ilove{
void loveLamda(int a);
}
lamda表达式：
package com.yang;
public class Args {
public static void main(String[] args) {
Ilove love = (int a) ->{
System.out.println("I love Java" + a);
};
love.loveLamda(2);
}
}
//函数式接口
interface Ilove{
void loveLamda(int a);
}
还可以再简化：去掉参数类型。
package com.yang;
public class Args {
public static void main(String[] args) {
//去掉参数类型
Ilove love = (a) ->{
System.out.println("I love Java" + a);
};
love.loveLamda(2);
}
}
//函数式接口
interface Ilove{
void loveLamda(int a);
}
还可以去掉括号：
package com.yang;
public class Args {
public static void main(String[] args) {
//去掉括号
Ilove love = a ->{
System.out.println("I love Java" + a);
};
love.loveLamda(2);
}
}
//函数式接口
interface Ilove{
void loveLamda(int a);
}
还可以去掉花括号：
package com.yang;
public class Args {
public static void main(String[] args) {
//去掉花括号
Ilove love = a -> System.out.println("I love Java" + a);
love.loveLamda(2);
}
}
//函数式接口
interface Ilove{
void loveLamda(int a);
}
但是要注意：
1.lamda表达式只能在只有一行代码的情况下才能简化为一行（就是去掉花括号的情况），如果有多行的话，只能用花括号。
2.前提是：接口时函数式接口
3.如果是多个参数的话，去掉参数类型时，要去掉只能都去掉，而且必须要加上括号。