目录
出现的背景
外部类
代码
运行
内部类
代码
运行
匿名内部类
代码
运行
Lambda 表达式简介
Lambda 表达式的结构
lambda表达式
代码
运行
什么是功能接口（Functional interface）
代码
接口
实现类
使用方法重写
使用lambda表达式
运行
出现的背景
匿名函数 为了简化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();
}
}
运行
