1、lambda表达式练习
(1)
package learn;
public interface Flyable {
void fly(String s);
}
package learn;
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("飞机自驾游");
}
});//匿名内部类
//Lambda表达式
useFlyable(s -> {
System.out.println(s);
System.out.println("飞机自驾游");
});
}
public static void useFlyable(Flyable f) {
f.fly("风和日丽,晴空万里");
}
}
(2)
package learn;
public interface Addable {
int add(int x,int y);
}
package learn;
public class AddableDemo {
public static void main(String[] args) {
useAddable(new Addable() {
@Override
public int add(int x, int y) {
return x+y;
}
});
//Lambda表达式
useAddable((x,y)-> x+y);
}
public static void useAddable(Addable a) {
int sum=a.add(10,20);
System.out.println(sum);
}
}
2、接口组成更新:
若一个类同时实现了多个接口,且多个接口中的默认方法名相同。
此时必须进行方法重写
方法重写内容可以是:
(1)可选择保留其中的一个,通过 接口名.super.方法名 选择保留哪个接口的默认方法
(2)自己重写内容
package learn;
public interface Test1 {
public default void show(){
System.out.println("test");
}
}
package learn;
public interface Test2 {
public default void show(){
System.out.println("test2");
}
}
package learn;
public interface Test3 {
public default void show(){
System.out.println("test3");
}
}
package learn;
public class Test implements Test1,Test2,Test3{
@Override
public void show() {
Test2.super.show();
}
}
package learn;
public class TestDemo {
public static void main(String[] args) {
Test td=new Test();
td.show();
//test2
}
}
3、Lambda表达式支持的方法引用
常见引用方式:
(1)引用类方法:类名::静态方法
Lambda表达式被类方法替代的时候,它的形式参数全部传递给静态方法作为参数
package learn;
public interface Converter {
int convert(String s);
}
package learn;
public class TestDemo {
public static void main(String[] args) {
useConverter(Integer::parseInt);
useConverter(s -> Integer.parseInt(s));
}
public static void useConverter(Converter c) {
int number=c.convert("666");
System.out.println(number);
}
}
(2)引用对象的实例方法:对象::成员方法
Lambda表达式被对象的实例方法替代的时候,它的形式参数全部传递给该方法作为参数
package learn;
public interface Printer {
void printUpperCase(String s);
}
package learn;
public class PrintString {
public void printUpper(String s){
s=s.toUpperCase();
System.out.println(s);
}
}
package learn;
public class TestDemo {
public static void main(String[] args) {
usePrinter(new Printer() {
@Override
public void printUpperCase(String s) {
PrintString ps=new PrintString();
ps.printUpper(s);
}
});//匿名内部类
usePrinter( s -> new PrintString().printUpper(s));//lambda表达式
usePrinter(s -> s.toUpperCase());//lambda中指定的操作方案,在PrintString类中已经存在相同方案
PrintString p=new PrintString();
usePrinter(p::printUpper);
}
public static void usePrinter(Printer p) {
p.printUpperCase("helloworld");
}
}
(3)引用类的实例方法:类名::成员方法
Lambda表达式被类的实例方法替代的时候,第一个参数作为调用者,后面的参数全部传递给该方法作为参数
package learn;
public interface MyString {
String mySubString(String s,int x,int y);
}
package learn;
public class TestDemo {
public static void main(String[] args) {
use(String::substring);
use((s,x,y)->s.substring(x,y));
}
public static void use(MyString ms) {
String res=ms.mySubString("HelloWorld",2,5);
System.out.println(res);
}
}
(4)引用构造器:类名::new
Lambda表达式被构造器替代的时候,它的形式参数全部传递给构造器作为参数
package learn;
public interface StudentBuilder {
Student build(String name,int age);
}
package learn;
public class TestDemo {
public static void main(String[] args) {
//use((name, age) -> new Student(name,age));
use(Student::new);
}
public static void use(StudentBuilder sb) {
Student s=sb.build("林青霞",30);
System.out.println(s.getName()+","+s.getAge());
}
}
package learn;
public class Student {
private String name;
private int age;
public Student(){
}
public Student(String name,int age){
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}