首页 计算机学科 java 知识点

方法引用符【理解】

  • 方法引用符

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

  • 推导与省略

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

# 3.3 引用类方法【应用】

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

  • 格式

    类名：：静态方法

  • 范例

    Integer::parseInt

    Integer 类的方法：public static int parseInt (String s) 将此 String 转换为 int 类型数据

  • 练习描述

    • 定义一个接口 (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 表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数
# 3.4 引用对象的实例方法【应用】
引用对象的实例方法，其实就引用类中的成员方法

  • 格式
    对象：：成员方法
  • 范例
    "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 表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数
# 3.5 引用类的实例方法【应用】
引用类的实例方法，其实就是引用类中的成员方法

  • 格式
    类名：：成员方法
  • 范例
    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);
        }
    }
  • 使用说明
    Lambda表达式被类的实例方法替代的时候
第一个参数作为调用者
后面的参数全部传递给该方法作为参数

# 3.6 引用构造器【应用】
引用构造器，其实就是引用构造方法

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