方法引用符、引用类方法、引用对象的实例方法、引用类的实例方法及引用构造器

港控/mmm° 2024-04-06 09:34 80阅读 0赞

**目录**

一、方法引用符

二、引用类方法

三、引用对象的实例方法

四、引用类的实例方法

五、引用构造器

--------------------

## 一、方法引用符 ##

方法引用符：

**::** 该符号位引用运算符，而它所在的表达式被称为方法引用

推导与省略：

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

## 二、引用类方法 ##

引用类方法，其实就是引用类的静态方法

格式：

> **类名::静态方法**

范例：

> **Integer::parseInt**
> 
> Integer类的方法：public static int parseInt(String s)将此String类型数据

练习描述：

> ● 定义一个接口(Converter)，里面定义一个抽象方法int convert(String s);
> 
> ● 定义一个测试类(ConverterDemo)，在测试类中提供两个方法
> 
> ● 一个方法是：useConverter(Converter c)
> 
> ● 一个方法是主方法，在主方法中调用useConverter方法

代码演示：

public interface Converter {
        int convert(String s);
    }
    public class ConverterDemo {
        public static void main(String[] args) {
            //Lambda写法 
            useConverter(s -> Integer.parseInt(s));
            //引用类方法 
            useConverter(Integer::parseInt);
        }
        private static void useConverter(Converter c) {
            int number = c.convert("666");
            System.out.println(number);
        }
    }

使用说明：

> Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数

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

引用对象的实例方法，其实就引用类中的成员方法

格式：

> **对象::成员方法**

范例：

> **"HelloWorld"::toUpperCase** 
> 
> String类中的方法：public String toUpperCase() 将此String所有字符转换为大写

练习描述：

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

代码演示：

public class PrintString {
        //把字符串参数变成大写的数据，然后在控制台输出 
        public void printUpper(String s) {
            String result = s.toUpperCase();
            System.out.println(result);
        }
    }
    
    public interface Printer {
        void printUpperCase(String s);
    }
    
    public class PrinterDemo {
        public static void main(String[] args) {
            //Lambda简化写法 
            usePrinter(s -> System.out.println(s.toUpperCase()));
    
            //引用对象的实例方法 
            PrintString ps = new PrintString();
            usePrinter(ps::printUpper);
        }
    
        private static void usePrinter(Printer p) {
            p.printUpperCase("HelloWorld");
        }
    }

使用说明：

> Lambda表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数

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

引用类的实例方法，其实就是引用类中的成员方法

格式：

> **类名::成员方法**

范例：

> **String::substring** 
> 
> **public String substring(int beginIndex,int endIndex)** 
> 
> 从beginIndex开始到endIndex结束，截取字符串。返回一个子串，子串的长度为endIndex-beginIndex

练习描述：

> ● 定义一个接口(MyString)，里面定义一个抽象方法：
> 
>  **String mySubString(String s,int x,int y);**
> 
> ● 定义一个测试类(MyStringDemo)，在测试类中提供两个方法
> 
> 一个方法是：**useMyString(MyString my)**
> 
> 一个方法是主方法，在主方法中调用useMyString方法

代码演示：

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**

练习描述：

> ● 定义一个类(Student)，里面有两个成员变量(name,age)
> 
> 并提供无参构造方法和带参构造方法，以及成员变量对应的get和set方法
> 
> ● 定义一个接口(StudentBuilder)，里面定义一个抽象方法
> 
> Student build(String name,int age);
> 
> ● 定义一个测试类(StudentDemo)，在测试类中提供两个方法
> 
> 一个方法是：useStudentBuilder(StudentBuilder s)
> 
> 一个方法是主方法，在主方法中调用useStudentBuilder方法

代码演示：

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;
        }
    }
    
    public interface StudentBuilder {
        Student build(String name,int age);
    }
    
    public class StudentDemo {
        public static void main(String[] args) {
            //Lambda简化写法 
            useStudentBuilder((name,age) -> new Student(name,age));
    
            //引用构造器 
            useStudentBuilder(Student::new);
    
        }
    
        private static void useStudentBuilder(StudentBuilder sb) {
            Student s = sb.build("林青霞", 30);
            System.out.println(s.getName() + "," + s.getAge());
        }
    }

使用说明：

> Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数