Java——方法引用之引用类方法、引用对象的实例方法、引用类的实例方法、引用构造器

绝地灬酷狼 2024-03-26 17:48 83阅读 0赞

*  一、方法引用符
 *  二、Lambda表达式和方法引用代码分析
 *  三、Lambda表达式支持的方法引用
 *  四、引用类方法
 *  五、引用对象的实例方法
 *  六、引用类的实例方法
 *  七、引用构造器

## 一、方法引用符 ##

## :: 该符号是引用运算符，它所在的表达式被称为方法引用      二、[Lambda表达式][Lambda]和方法引用代码分析 ##

**1、Lambda表达式**

usePrintable(s -> System.out.println(s));

拿到参数s之后，通过Lambda表达式，传递给System.out.println方法去处理

**2、方法引用**

usePrintable(System.out::println);

直接使用System.out中的println方法来取代Lambda，代码更加的简洁

**3、推导与省略**

*  如果使用Lambda，根据“可推导就是可省略”的原则，无需指定参数类型，无需指定的重载形式，它们都将被自动推导
 *  如果使用方法引用，也是同样可以根据上下文进行推导
 *  方法引用是Lambda的孪生兄弟

## 三、Lambda表达式支持的方法引用 ##

常见的引用方式：

*  引用类方法
 *  引用对象的实例方法
 *  引用类的实例方法
 *  引用构造器

## 四、引用类方法 ##

*  引用类方法其实就是引用类的静态方法
 *  格式：类名::静态方法
 *  范例：Integer::parseInt  
    Integer类的方法：public static int parentInt(String s)，将String转换为int类型数据
 *  **Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数**

public interface Converter {
        
           int convert(String s);
    }

public class ConvertDemo {
        
        public static void main(String[] args) {
        
            //Lambda表达式
            useConvert(s -> Integer.parseInt(s));

public class ConvertDemo {
        
        public static void main(String[] args) {
        
            //Lambda表达式
            useConvert(s -> Integer.parseInt(s));
    
            //引用类方法
            useConvert(Integer::parseInt);
        }
    
        public static void useConvert(Converter c) {
        
            int number = c.convert("666");
            System.out.println(number);
        }
    }

## 五、引用对象的实例方法 ##

*  引用对象的实例方法，其实就是引用类中的成员方法
 *  格式：对象::成员方法
 *  范例：“HelloWorld”::toUpperCase  
    String类中的方法：public String toUpperCase()，将String所有字符转换为大写
 *  **Lambda表达式被对象的实例化方法替代的时候，它的形式参数全部传递给该方法作为参数**

**练习**

*  定义一个类(PrintString)，里面定义一个方法  
    public void printUpper(String s)：把字符串的参数编程大写的数据，然后在控制台输出
 *  定义一个接口(Printer)，里面定义一个抽象方法  
    void printUpperCase(String s)
 *  定义一个测试类(PrinterDemo)，在测试类中提供两个方法  
    usePrinter(Printer p)  
    主方法：调用usePrint方法

PrintString类

public class PrintString {
        
        public void printUpper(String s) {
        
            String result = s.toUpperCase();
            System.out.println(result);
        }
    }

Printer接口

public interface Printer {
        
        void printUpperCase(String s);
    }

PrinterDemo测试类

public class PrinterDemo {
        
        public static void main(String[] args) {
        
            //Lambda表达式
            usePrinter(s -> System.out.println(s.toUpperCase()));
    
            //引用对象的实例方法
            PrintString ps = new PrintString();
            usePrinter(ps::printUpper);
        }
    
        public static void usePrinter(Printer p) {
        
            p.printUpperCase("HelloWorld");
        }
    }

## 六、引用类的实例方法 ##

*  引用类的实例方法，其实就是引用类中的成员方法
 *  格式：类名::成员方法
 *  范例：String::substring  
    String类中的方法：public String subString(int beginIndex, int endIndex)，从beginIndex开始到endIndex结束，截取字符串。返回一个子串，子串的长度式endIndex-beginIndex
 *  **Lambda表达式被类的实例方法替代的时候，第一个参数作为调用者，后面的参数全部传递给该方法作为参数**

public interface MyString {
        
        String mySubString(String s, int x, int y);
    }

public class MyStringDemo {
        
        public static void main(String[] args) {
        
            //Lambda表达式
            useMyString((s, x, y) -> s.substring(x, y));
    
            //引用类的实例方法
            useMyString(String::substring);
        }
    
        private static void useMyString(MyString my) {
        
            String s = my.mySubString("HelloWorld", 2, 5);
            System.out.println(s);
        }
    }

## 七、引用构造器 ##

*  引用构造器，其实就是引用构造方法
 *  格式：类名::new
 *  范例：Student::new
 *  Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数

**练习**

Student类

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;
        }
    }

StudentBuilder接口

public interface StudentBuilder {
        
        Student build(String name, int age);
    }

StudentDemo测试类

public class StudentDemo {
        
        public static void main(String[] args) {
        
            //Lambda
           /* useStudentBuilder((String name,int age)->{
                Student s = new Student(name,age);
                return s;
            });*/
            //上述代码可简化为
            useStudentBuilder(((name, age) -> new Student(name, age)));
    
            //引用构造器
            useStudentBuilder(Student::new);
        }
    
        private static void useStudentBuilder(StudentBuilder sb) {
        
            Student s = sb.build("zlx", 18);
            System.out.println(s.getName() + "," + s.getAge());
        }
    }

[Lambda]: https://so.csdn.net/so/search?q=Lambda%E8%A1%A8%E8%BE%BE%E5%BC%8F&spm=1001.2101.3001.7020