方法引用

发布于 2021-12-27  83 次阅读


1. 方法引用

  • 对于lambda表达式在特殊前提下的一种简写形式
  • 前提 : lambda表达式, 方法体的内容只有一句,并且是方法的调用
  • 有如下两种情况
    • 方法体是类调用静态方法
    • 方法体是对像调用实例方法

1.1. 类调用静态方法

  • 接口代码
package link.xiaomo.test5;

//Converter 转换器接口
public interface IConverter {
    //转换  接受一个字符串类型的数据 返回一个int类型的数据
    int convert(String s);
}
class A implements IConverter {
    @Override
    public int convert(String s) {
        //把字符串转为数字
        return Integer.parseInt(s);
    }
}
  • 测试代码
package link.xiaomo.test5;

public class Demo02 {
    public static void main(String[] args) {
        //方案1 自己写 接口实现类
//        A a = new A();
//        useIConverter(a);
        //方案2 匿名内部类
        useIConverter(new IConverter() {
            @Override
            public int convert(String s) {
                return Integer.parseInt(s);
            }
        });
        //方案3 lambda表达式
        useIConverter(s -> Integer.parseInt(s));
        //方案4  方法引用   类调用静态方法   类::方法名
        useIConverter(Integer::parseInt);
    }

    //使用转换器的方法 传入IConverter接口的实现类对象
    public static void useIConverter(IConverter converter) {
        int result = converter.convert("666666");
        System.out.println(result);
    }
}

1.2. 对像调用实例方法

1.2.1. 方法的参数是一个对象,然后在方法体中,参数调用了自己的实例方法 (参数对象的类::方法名)

  • 接口
//Converter 转换器接口
public interface IConverter {
    //转换  接受一个字符串类型的数据 返回一个int类型的数据
    int convert(String s);
}
  • 测试代码
package link.xiaomo.test6;

public class Demo02 {
    public static void main(String[] args) {
        //方案2 匿名内部类
        useIConverter(new IConverter() {
            @Override
            public int convert(String s) {
                //获取字符串的长度并且返回
                return s.length();
            }
        });

        //方案3 lambda表达式
        useIConverter(s -> s.length());

        //方案4  方法引用  s.length() 对象调用方法
        // 对象所属的类::调用的方法名
        useIConverter(String::length);
    }

    //使用转换器的方法 传入IConverter接口的实现类对象
    public static void useIConverter(IConverter converter) {
        int result = converter.convert("abcde");
        System.out.println(result);
    }
}

1.2.2. 在方法体中,有一个对象调用实例方法,把当前参数传入到这个调用的方法中 (对象::方法)

  • 接口
//字符串处理器
public interface StringHandler {
    //处理字符串
    void processString(String s);
}
  • 处理字符串 封装了一个类和方法
public class StringTest {
    //转大写  截取前5个    结果打印出来
    public  void testStr(String s) {
        //把字符串变为大写
        String s1 = s.toUpperCase();
        //把变成大写的字符串截取前5个 01234
        String s2 = s1.substring(0, 5);
        //把结果打印出来
        System.out.println(s2);
    }
}
  • 测试
package link.xiaomo.test7;

public class Demo02 {
    public static void main(String[] args) {
        StringTest st = new StringTest();

        useStringHandler(new StringHandler() {
            @Override
            public void processString(String s) {
                st.testStr(s);
            }
        });
        useStringHandler(s->st.testStr(s));

        //方法引用
        //对象调用方法  此时s是作为参数传入的
        // 对象::调用方法名
        useStringHandler(st::testStr);
    }

    //使用转换器的方法 传入IConverter接口的实现类对象
    public static void useStringHandler(StringHandler handler) {
        handler.processString("hello_world");
    }
}

1.2.3. 构造方法的形式

  • 方法体里使用new关键字创建对象, 参数全部传给了构造方法. (创建的对象的类::new)

代码

  • 接口
//学生工厂接口
public interface IStudentFactory {
    Student getStudent(String name, int age);
}
  • 测试 类名::new
package link.xiaomo.test8;

public class Demo01 {
    public static void main(String[] args) {
        useStuFactory(new IStudentFactory() {
            @Override
            public Student getStudent(String name, int age) {
                return new Student(name, age);
            }
        });
        useStuFactory((name, age) -> new Student(name, age));

        //方法引用  new创建实例对象的形式
        //  类名::new
        useStuFactory(Student::new);
    }

    //使用学生工厂的方法 传入学生工厂接口的实现类对象
    public static void useStuFactory(IStudentFactory factory) {
        //调用getStudent 返回一个学生对象
        Student s = factory.getStudent("小明", 30);
        System.out.println(s.name + "--" + s.age);
    }
}
如人饮水,冷暖自知。
最后更新于 2023-07-18