Lambda表达式
public class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println("多线程程序启动了");
}
}
public class LambdaDemo {
public static void main(String[] args) {
//实现类的方式实现需求
/* MyRunnable my=new MyRunnable();
Thread t1=new Thread(my);
t1.start();*/
//匿名内部类的方式改进
/* new Thread(new Runnable(){
@Override
public void run() {
System.out.println("多线程程序启动了");
}
}).start();*/
//Lambda表达式的方式改进
new Thread( () -> {
System.out.println("多线程程序启动了");
}).start();
}
}
Lambda表达式的代码分析:
():里面没有内容,可以看成是方法形式参数为空
->:用箭头指向后面要做的事情
{}:方法里面的内容
组成lambda表达式的三要素:形式参数,箭头,代码块
Lambda表达式的使用前提
有一个接口
接口中有且仅有一个抽象方法
public interface Eatable {
void eat();
}
public class EatableImpl implements Eatable{
@Override
public void eat() {
System.out.println("饭后走一走,活到九十九");
}
}
public class EatableDemo {
public static void main(String[] args) {
Eatable e=new EatableImpl();
userEatable(e);
userEatable(new Eatable() {
@Override
public void eat() {
System.out.println("饭后走一走,活到九十九");
}
});
userEatable( () ->{
System.out.println("饭后走一走,活到九十九");
});
}
private static void userEatable(Eatable e){
e.eat();
}
}
public interface Flyable {
void fly(String s);
}
public class FlyableDemo {
public static void main(String[] args) {
useFlyable(new Flyable() {
@Override
public void fly(String s) {
System.out.println(s);
System.out.println("你喜欢的人那么优秀,你确定你不努力吗");
}
});
useFlyable( (String s)->{
System.out.println(s);
System.out.println("你喜欢的人那么优秀,你确定你不努力吗");
});
}
private static void useFlyable(Flyable f){
f.fly("看有灰机");
}
}
public interface Addable {
int add(int x,int y);
}
public class AddableDemo {
public static void main(String[] args) {
useAddable(new Addable() {
@Override
public int add(int x, int y) {
return x+y;
}
});
useAddable( (int x,int y)->{
return x+y;
});
}
public static void useAddable(Addable a) {
int x=a.add(5,6);
System.out.println(x);
}
}
public interface Addable {
int add(int x,int y);
}
public interface Flyable {
void fly(String s);
}
public class AddableDemo {
public static void main(String[] args) {
useAddable((int x,int y)->{
return x+y;
});
//参数的类型可以省略
useAddable((x,y)->{
return x+y;
});
useFlyAble((String s)->{
System.out.println(s);
});
//参数的类型可以省略
useFlyAble((s)->{
System.out.println(s);
});
//如果参数有且仅有一个,小括号可以省略
useFlyAble(s->{
System.out.println(s);
});
//如果代码块的语句只有一条,可以省略大括号和分号
useFlyAble(s->System.out.println(s));
//如果代码块的语句只有一条,可以省略大括号和分号 如果有return,return也要省略
useAddable((x,y)->x+y);
}
private static void useFlyAble(Flyable f){
f.fly("看有灰机");
}
private static void useAddable(Addable a){
int i = a.add(5, 5);
System.out.println(i);
}
}
接口组成
public interface MyInterface {
void show1();
void show2();
}
public class MyInterfaceImplOne implements MyInterface{
@Override
public void show1() {
System.out.println("One show1");
}
@Override
public void show2() {
System.out.println("One show2");
}
}
public class MyInterfaceImplTwo implements MyInterface{
@Override
public void show1() {
System.out.println("Two show1");
}
@Override
public void show2() {
System.out.println("Two show2");
}
}
public class MyInterfaceDemo {
public static void main(String[] args) {
MyInterface my=new MyInterfaceImplOne();
my.show1();
my.show2();
}
}
随着业务的服务,这个接口的功能已经不能满足需要了,需要新增方法(所有实现抽象类都需要写抽象方法 比较麻烦)
这个方法也可以被重写
这里的public可以省略
默认方法,主要用来接口升级而不破坏现有的方法
public interface Inter {
void show();
default void method(){
System.out.println("Inter 中的默认方法执行了");
};
public static void test(){
System.out.println("Inter 中的静态方法执行了");
}
}
public class InterImpl implements Inter{
@Override
public void show() {
System.out.println("show方法执行了");
}
}
public class InterDemo {
public static void main(String[] args) {
Inter i=new InterImpl();
i.show();
i.method();
Inter.test();
}
}
接口中的静态方法public可以省略
public interface Inter {
default void show1(){
System.out.println("show1方法开始执行");
System.out.println("初级工程师");
System.out.println("中级工程师");
System.out.println("高级工程师");
System.out.println("show1方法结束执行");
}
default void show2(){
System.out.println("show2方法开始执行");
System.out.println("初级工程师");
System.out.println("中级工程师");
System.out.println("高级工程师");
System.out.println("show2方法结束执行");
}
static void method1(){
System.out.println("method1开始执行");
System.out.println("初级工程师");
System.out.println("中级工程师");
System.out.println("高级工程师");
System.out.println("method1结束执行");
}
static void method2(){
System.out.println("method2开始执行");
System.out.println("初级工程师");
System.out.println("中级工程师");
System.out.println("高级工程师");
System.out.println("method2结束执行");
}
}
public class InterImpl implements Inter{
}
public class InterDemo {
public static void main(String[] args) {
Inter i=new InterImpl();
i.show1();
i.show2();
Inter.method1();
Inter.method2();
}
}
可以写私有方法来提取相同的代码
私有的静态方法,既可以被默认方法调用,也可以被静态方法调用
方法引用符 ::
public interface Printable {
void printString(String s);
}
public class PrintableDemo {
public static void main(String[] args) {
usePrintable(s->System.out.println(s));
//方法引用符
usePrintable(System.out::println);
}
public static void usePrintable(Printable p){
p.printString("张三");
}
}
public interface Converter {
int convert(String s);
}
public class PrintableDemo {
public static void main(String[] args) {
useConverter(s->{
return Integer.parseInt(s);
});
useConverter(s->Integer.parseInt(s));
//引用类方法
useConverter(Integer::parseInt);
}
public static void useConverter(Converter c){
int i=c.convert("10");
System.out.println(i);
}
}
public interface Printer {
void printUpperCase(String s);
}
public class PrintString {
public void printUpper(String s){
String result=s.toUpperCase();
System.out.println(result);
}
}
public class PrinterDemo {
public static void main(String[] args) {
usePrinter(s ->System.out.println(s.toUpperCase()));
//引用对象的实例方法
PrintString p=new PrintString();
usePrinter(p::printUpper);
}
public static void usePrinter(Printer p){
p.printUpperCase("HelloWorld");
}
}
public interface MyString {
String mySubString(String s,int x,int y);
}
public class MyStringDemo {
public static void main(String[] args) {
useMyString((s,x,y)-> s.substring(x,y));
//引用类的实例方法
useMyString(String::substring);
//Lambda表达式被类的实例方法替代的时候
//第一个参数作为调用者
//后面的参数全部传递给该方法作为参数
}
private static void useMyString(MyString my){
String s=my.mySubString("zhangsan",2,5);
System.out.println(s);
}
}
public class Student {
private String name;
private int age;
}
public interface StudentBuilder {
Student build(String name,int age);
}
public class StudentDemo {
public static void main(String[] args) {
useStudentBuilder((name,age)->{
// Student s=new Student(name,age);
// return s;
return new Student(name,age);
});
useStudentBuilder((name,age)->new Student(name,age));
//引用构造器
useStudentBuilder(Student::new);
}
private static void useStudentBuilder(StudentBuilder sb){
Student s=sb.build("张三",20);
System.out.println(s.getName()+","+s.getAge());
}
}