Java基础00-方法引用32
1. 方法引用
1.1 体验方法引用
代码示例:
需求:
- 1:定义一个接口(Printable):里面定义一个抽象方法: void printString(String s);
- 2:定义一个测试类(PrintableDemo),在测试类中提供两个方法
一个方法是: usePrintable(Printable p)
一个方法是主方法,在主方法中调用usePrintable方法
接口:
//1:定义一个接口(Printable):里面定义一个抽象方法: void printString(String s); public interface Printable { void printString(String s); }
测试类:
//2:定义一个测试类(PrintableDemo),在测试类中提供两个方法 //一个方法是: usePrintable(Printable p) //一个方法是主方法,在主方法中调用usePrintable方法 public class PrintableDemo { public static void main(String[] args) { //Lambda表达式省略参数类型,是因为方法中有参数类型这样Lambda就可以推导出参数类型。 usePrintable(s -> System.out.println(s)); // 使用方法一引用,方法引用符:: //方法引用和Lambda一样都是推导出了参数类型,然后将参数放入println中。 usePrintable(System.out::println); } private static void usePrintable(Printable p) { p.printString("爱生活爱java"); } }
运行结果:
1.2 方法引用符
代码示例:
需求:
- 1:定义一个接口(Printable):里面定义一个抽象方法: void printInt(int i);
- 2:定义一一个测试类(PrintableDemo),在测试类中提供两个方法
一个方法是: usePrintable(Printable p)
一个方法是主方法,在主方法中调用usePrintable方法
定义接口:
//1:定义一个接口(Printable):里面定义一个抽象方法: void printInt(int i); public interface Printable { void printInt(int i); }
定义测试类:
//2:定义一一个测试类(PrintableDemo),在测试类中提供两个方法 //一个方法是: usePrintable(Printable p) //一个方法是主方法,在主方法中调用usePrintable方法 public class PrintableDemo { private static void usePrintable(Printable p) { p.printInt(666); } public static void main(String[] args) { //Lambda表达式 usePrintable(i -> System.out.println(i)); //方法引用 usePrintable(System.out::println); } }
运行结果:
1.3 Lambda表达式支持的方法引用
1.4 引用类方法
代码示例:
定义接口:
//1:定义一个接口(Converter),里面定义一个抽象方法: //int convert(String s); public interface Converter { int convert(String s); }
定义测试类:
//2:定义一一个测试类(ConverterDemo),在测试类中提供两个方法 //一个方法是: useConverter(Converter c) //一个方法是主方法,在主方法中调用useConverter方法 public class ConverterDemo { private static void useConverter(Converter c) { int number = c.convert("666"); System.out.println(number); } public static void main(String[] args) { // Lambda表达式 // 带有返回值类型的也可以省略 useConverter(s -> Integer.parseInt(s)); // 引用类方法,采用引用类方法格式 useConverter(Integer::parseInt); // Lambda表达式被类方法替代的时候,它的形式参数全部传递给静态方法作为参数 } }
运行结果:
1.5 引用对象的实例方法
代码示例:
定义类:
//1:定义一个类(PrintString),里面定义一个方法 // public void printUpper(String s): 把字符串参数变成大写的数据,然后在控制台输出 public class PrintString { public void printUpper(String s) { String result = s.toUpperCase(); System.out.println(result); } }
定义接口:
//2:定义一个接口(Printer),里面定义一个抽象方法 //void printUpperCase(String s); public interface Printer { void printUpperCase(String s); }
定义测试类:
//3:定义一个测试类(PrinterDemo),在测试类中提供两个方法 //一个方法是: usePrinter(Printer p) //一个方法是主方法,在主方法中调用usePrinter方法 public class PrinterDemo { private static void usePrinter(Printer p) { p.printUpperCase("HelloWordl"); } public static void main(String[] args) { // Lambda表达式,最简化模式 usePrinter(s -> System.out.println(s.toUpperCase())); // 引用对象的是实例方法 PrintString ps = new PrintString(); usePrinter(ps::printUpper); // Lambda表达式被对象的实例方法替代的时候,它的形式参数全部传递给该方法作为参数 } }
运行结果:
1.6 引用类的实例方法
代码示例:
定义接口:
//1:定义一个接口(MyString),里面定义一个抽象方法: . //String mySubString(String s,int x, int y); public interface MyString { String mySubString(String s, int x, int y); }
定义测试类:
//2:定义一个测试类(MyStringDemo),在测试类中提供两个方法 //一个方法是: useMyString(MyString my) //一个方法是主方法,在主方法中调用useMyString方法 public class MyStringDemo { private static void useMyString(MyString my) { String s = my.mySubString("HelloWorld", 2, 5); System.out.println(s); } public static void main(String[] args) { // Lambda表达式,最简模式 useMyString((s, x, y) -> s.substring(x, y)); // 引用类的实例方法 useMyString(String::substring); // Lambda表达式被类的实例方法替代的时候 // 第一个参数作为调用者 // 后面的参数全部传递给该方法作为参数 } }
运行结果:
1.7 引用构造器(构造方法)
代码示例:
定义类Student
//1:定义一个类(Student),里面有两个成员变量(name, age) //并提供无参构造方法和带参构造方法,以及成员变量对应的get和set方法 public class Student { private String name; private int age; public Student() { super(); } public Student(String name, int age) { super(); 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; } }
定义接口:
//2:定义一个接口(StudentBuilder),里面定义一个抽象方法 //Student build(String name, int age); public interface StudentBuilder { Student build(String name, int age); }
定义测试类:
//3:定义一个测试类(StudentDemo),在测试类中提供两个方法 //一个方法是: useStudentBuilder(StudentBuilder s) //一个方法是主方法,在主方法中调用useStudentBuilder方法 public class StudentDemo { private static void useStudentBuilder(StudentBuilder sb) { Student s = sb.build("林青霞", 20); System.out.println(s.getName() + "," + s.getAge()); } public static void main(String[] args) { // Lambda表达式 useStudentBuilder((name, age) -> new Student(name, age)); // 引用构造器 useStudentBuilder(Student::new); // Lambda表达式被构造器替代的时候,它的形式参数全部传递给构造器作为参数 } }
运行结果: