方法引用符

方法引用符： ：： （：：）该符号为引用运算符，而他所在的表达式被称为方法引用

回顾一下代码

public class text {
    public static void main(String[] args) {
        use(s-> System.out.println(s));//Lambda表达式
        use(System.out::println);//方法的引用

    }
    private static void use(text1 s){
        s.run("你好");
    }
}
  • Lambda表达式：usePrintable(s->System.out.println(s));
    分析：拿到参数s以后通过Lambda表达式，传递给System.out.println方法处理
  • 方法引用：usePrintable(System.out::println)
    分析：直接用System.out中的println发放来取代Lambda，代码更加简介

推导与省略

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

引用类方法

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

格式：类名：：静态方法

范例：Integer：：parselnt

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

//接口方法
public interface dsa {
    int  print(String i);
}

//主函数
public class dame implements  in {
    public static void main(String[] args) {
        //Lambda表达式
        use(s-> Integer.parseInt(s));
        //引用类方法
        use(Integer::parseInt);

    }
    private static void use(dsa s){
        int sd=s.print("100");
        System.out.println(sd);
    }
}

引用对象的实例方法

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

  • 格式：对象：：成员方法
  • 范例：“sjdfhaksjh”::toUpperCase

String 类中的方法：public String toUpperCase():把字符串变成大写的数据，然后在控制台输出

//接口
public interface casea {
    void up(String s);
}

//实现接口的方法
public class demo1 implements casea {

    @Override
    public void up(String s) {
        String s1 = s.toUpperCase();
        System.out.println(s1);
    }
}

//主方法
public static void main(String[] args) {
        use(s -> {//Lambda方法
            String s1=s.toUpperCase();
            System.out.println(s1);
        });
        //引用对象的实例方法
        demo1 de = new demo1();
        use(de::up);
        //Lambda表达式被对象的实例方法替代的时候，他的形式参数全部传给该方法作为参数；
    }
    private static void use(casea a){
        a.up("sdfsdfsdfsdf");
    }

引用类的实例方法

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

  • 格式：类名：：成员方法
  • 范例：String：：substring

String类中的方法：public String substring(int beginIndex,int endIndex) ;从beginIndex开始到endIndex结束，截取一个字符串，返回一个字串

//接口
public interface casea {
    String up(String s,int x,int y);
}

//主方法
public class demo2 {
    public static void main(String[] args) {
        //Lambda方法
        use((s,x,y)-> s.substring(x,y));
        //引用类的实例方法
        use(String::substring);

        //Lambda表达式被类的实例方法替代的时候
        //第一个参数作为调用者
        //后面的参数全部传递给该方法作为参数
    }
    private static void use(casea a){
        String s1 = a.up("helloworld", 2, 5);
        System.out.println(s1);
    }
}

引用构造器

引用构造器其实就是引用构造方法

  • 格式：类名：：new
  • 范例：Student：：new
//接口
  public interface StudentBuilder {
        Student build(String name,int age);
    }
//实现类
public class Student {
    private  int age;
    private String name;

    public Student() {
    }

    public Student(int age, String name) {
        this.age = age;
         = name;
    }

    public Student(String s, int i) {
        =s;
        this.age=i;
    }

    public void setAge(int age){
        this.age=age;
    }
    public void setName(String name){
        =name;
    }
    public int  getAge(){
        return this.age;
    }
    public String getName(){
        return ;
    }
}
//测试类
public class Studentdemo {
    public static void main(String[] args) {
        //使用Lambda方法
        use((String name,int age)-> new Student(age,name));
        //使用引用构造器
        use(Student::new);
    }
    
    private  static void use(StudentBuilder s){
        Student d = s.build("赵云", 26);
        System.out.println(d.getName() + "," + d.getAge());
    }


}