目录
出现的背景
匿名函数 为了简化Java中的匿名内部类
事件监听 写一个类实现 ActionListener 接口(外部类)
\|/
内部类 类在其他地方用不到,索性就把这个类定义在类的内部使用
好处:1.内部可以使用外部类的成员
2.其他地方发现不了
\|/
往往内部类至使用一次,还要创建一个内部类,麻烦
Java为了简化语法,new 接口/抽象类 创建了一个匿名的类的对象
外部类
代码
package com.ffyc.demo;
import java.util.ArrayList;
public class Demo1 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("b");
arrayList.add("c");
arrayList.add("a");
//排序,定义排序规则
arrayList.sort(new StringComparator());
System.out.println(arrayList);
}
}
package com.ffyc.demo;
import java.util.Comparator;
public class StringComparator implements Comparator<String> {
public static void main(String[] args) {
}
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
}
运行
内部类
代码
package com.ffyc.demo;
import java.util.ArrayList;
import java.util.Comparator;
public class Demo1 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("b");
arrayList.add("c");
arrayList.add("a");
//排序,定义排序规则
arrayList.sort(new StringComparator());
System.out.println(arrayList);
}
/*
内部类来实现接口
*/
static class StringComparator implements Comparator<String> {
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
}
}
运行
匿名内部类
代码
package com.ffyc.demo;
import java.util.ArrayList;
import java.util.Comparator;
public class Demo1 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("b");
arrayList.add("c");
arrayList.add("a");
//排序,定义排序规则
//匿名内部类,为了减少类的创建
//此处功能核心是compareTo方法,但是Java是面向对象的,方法的不能独立存在的,必须将方法包装在对象中
arrayList.sort(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
});
System.out.println(arrayList);
}
}
运行
Java8之前,函数/方法是不能当作参数传递的,必须将函数包装在对象中。
但是核心就是函数完成某个功能而已,还需要创建一个对象,成本高。
Java8开始,对这一语法进行了简化,匿名内部类都不需要创建了,直接将函数作为参数传递了。
Lambda 表达式简介
lambda 是匿名函数,把函数当作参数一样传递
lambda是一个“语法糖”,就是一个名词,某种语法可以简化开发称为语法糖
装箱 拆箱
自动类型转换
泛型
Lambda 表达式的结构
(参数列表)->{函数体}
()->{
}
lambda表达式
代码
package com.ffyc.demo;
import javax.swing.*;
import java.util.ArrayList;
import java.util.Comparator;
public class Demo1 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("b");
arrayList.add("c");
arrayList.add("a");
//排序,定义排序规则
arrayList.sort((a,b)->{
return a.compareTo(b);
});
System.out.println(arrayList);
new JButton().addActionListener((e)->{
System.out.println(e.getWhen());
});
}
}
运行
什么是功能接口(Functional interface)
Lambda 表达式只支持函数式接口 也就是只有一个抽象方法的接口.功能 接口是 java 8 中的新增功能,它们只允许一个抽象方法。这些接口也称为单抽 象方法接口。Java 8 也引入了一个注释,即@FunctionalInterface,当你注释 的接口违反了 Functional Interface 的契约时,它可以用于编译器级错误。
代码
接口
package com.ffyc.demo;
//使用lambda表达式 也是有要求的,一个接口中只能有一抽象方法
//为什么?因为函数是匿名的,全靠语法的推断
@FunctionalInterface
//添加@FunctionalInterface注解的接口中,只能有一个抽象方法
public interface Computer {
int add(int a,int b);
//int sub(int a,int b);
}
当接口中定义了两个方法时,@FunctionalInterface会检测语法错误,会报错。
实现类
使用方法重写
package com.ffyc.demo;
public class Demo2 {
static class comImpl implements Computer{
@Override
public int add(int a, int b) {
return a+b;
}
}
public void test(Computer computer){
int res = computer.add(10, 20);
System.out.println(res);
}
public static void main(String[] args) {
new Demo2().test(new comImpl());
}
}
使用lambda表达式
package com.ffyc.demo;
public class Demo2 {
public void test(Computer computer){
int res = computer.add(10, 20);
System.out.println(res);
}
public static void main(String[] args) {
//底层会将匿名对象包装到一个对象中,
new Demo2().test((a,b)->{
return a+b;
});
new Thread(()->{
System.out.println("使用lambda创建了一个线程,并重写了run方法");
}).start();
}
}