Java基础00-方法引用32

1. 方法引用

Java8新特征之方法引用

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表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数
    }
}

运行结果：