JAVA单排日记-2020/2/4-方法引用—具体使用

1.通过对象名引用成员方法

创建类，添加成员方法

public class Calculation {//创建类
	//构造方法
    public Calculation() {
    }
	//成员方法，实现数本身加100
    public void add(Integer a){
        System.out.println(a+100);
    }
}

主程序

import org.w3c.dom.ls.LSOutput;

import java.util.function.Consumer;

public class Demo03 {
    public static void main(String[] args) {
    	//创建Calculation类对象，对象名cal
        Calculation cal = new Calculation();
        
		//Lambda表达式
		acceptAdd(10,(i)->{
    		cal.add(i);
		});

		//Lambda表达式简写
		acceptAdd(10,i->cal.add(i));
		
		//方法引用，通过对象名引用成员方法，简化Lambda表达式
        acceptAdd(10,cal::add);
    }

    //创建Consumer<T>函数式接口方法
    public static void acceptAdd(Integer i1,Consumer<Integer> con){
        con.accept(i1);
    }
}

2.通过类引用静态方法

创建类，添加静态方法

public class Calculation {//创建类
	//构造方法
    public Calculation() {
    }
	//静态方法，实现数本身加100
    public static void add(Integer a){
        System.out.println(a+100);
    }
}

主程序

import org.w3c.dom.ls.LSOutput;

import java.util.function.Consumer;

public class Demo03 {
    public static void main(String[] args) {
    	//不用创建Calculation类对象，对象名cal，静态方法可以直接用对象引用
        //Calculation cal = new Calculation();
        
		//Lambda表达式
		acceptAdd(10,(i)->{
    		Calculation.add(i);
		});

		//Lambda表达式简写
		acceptAdd(10,i->Calculation.add(i););
		
		//方法引用，通过类引用静态方法，简化Lambda表达式
        acceptAdd(10,Calculation::add);
    }

    //创建Consumer<T>函数式接口方法
    public static void acceptAdd(Integer i1,Consumer<Integer> con){
        con.accept(i1);
    }
}

3.通过super引用父类成员方法

如果存在继承关系，当Lambda中需要出现super调用时，也可以使用方法引用进行替代。

创建父类对象及其成员方法：

public class Fu {
    //构造方法
    public Fu() {
    }

    //创建父类成员方法，供子类调用
    public void fuPrint(String str){
        System.out.println(str+"--->我是父类成员方法");
    }
}

创建子类对象，在子类成员方法中，以不同的方式，调用父类对象中的成员方法

import java.util.function.Consumer;

public class Zi extends Fu {
    //构造方法
    public Zi() {
    }

    //带有函数式接口Consumer<T>的方法
    public void accptCon(String s, Consumer<String> consumer){
        consumer.accept(s);
    }

    //1.在Lambda表达式中，通过创建父类对象，调用父类方法的写法
    public void Zi01(){
        accptCon("01.Lambda+创建父类对象",(s)->{
            Fu fu = new Fu();
            fu.fuPrint(s);
        });
    }

    //2.在Lambda表达式中，通过使用关键字super,调用父类方法的写法
    public void Zi02(){
        accptCon("02.Lambda+super",(s)->{
            super.fuPrint(s);
        });
    }

    //3.在简化的Lambda表达式中，通过使用关键字super,调用父类方法的写法
    public void Zi03(){
        accptCon("03.简化Lambda+super",s->super.fuPrint(s));
    }

    //4.方法引用，通过使用关键字super,调用父类方法的写法
    public void Zi04(){
        accptCon("04.通过super引用父类成员方法",super::fuPrint);
    }

}

主程序调用子类成员方法：

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

        test.Zi01();
        test.Zi02();
        test.Zi03();
        test.Zi04();
    }
}

4.通过this引用本类成员方法

this代表当前对象，如果需要引用的方法就是当前类中的成员方法，那么可以使用“this::成员方法”的格式来使用方法引用。首先是简单的函数式接口：

创建类对象

import java.util.function.Consumer;

public class Zi extends Fu{
    //构造方法
    public Zi() {
    }

    //子类本身的成员方法
    public void ZiPrint(String str){
        System.out.println(str+"--->我是Zi类本身的成员方法");
    }

    //带有函数式接口Consumer<T>的方法
    public void accptCon(String s, Consumer<String> consumer){
        consumer.accept(s);
    }

    //1.在Lambda表达式中，通过使用关键字this,调用本类方法的写法
    public void Zi02(){
        accptCon("01.Lambda+this",(s)->{
            this.ZiPrint(s);
        });
    }

    //2.在简化的Lambda表达式中，通过使用关键字this,调用本类方法的写法
    public void Zi03(){
        accptCon("02.简化Lambda+this",s->this.ZiPrint(s));
    }

    //3.方法引用，通过使用关键字this,调用本类方法的写法
    public void Zi04(){
        accptCon("03.通过this引用本类成员方法",this::ZiPrint);
    }

}

主程序调用对象成员方法

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

        test.Zi02();
        test.Zi03();
        test.Zi04();
    }
}

4.类的构造器引用(即函数式接口返回值为类)

由于构造器的名称与类名完全一样，并不固定。所以构造器引用使用 类名称::new 的格式表示

定义一个Person类，带有姓名成员变量

public class Person {
    private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

定义一个函数式接口，用来接收姓名，返回Person类

@FunctionalInterface
public interface PrintName {
    Person Print(String s);
}

主方法

import java.util.function.Consumer;
import java.util.function.Supplier;

public class Demo {
    public static void main(String[] args) {
    
    //使用Lambda表达式，重写函数式接口的抽象类
      method("1号",(s)->{
          return new Person(s);
      });
      
      //使用方法引用，类名称::new，重写函数式接口的抽象类
      method("2号",Person::new);
    }


    public static void method(String name,PrintName pn){
        Person one =pn.Print(name);
        System.out.println(one);
    }
}

5.数组的构造器引用(即函数式接口返回值为数组，本质同4)

定义一个函数式接口，用来接收数字，返回数组

@FunctionalInterface
public interface arrayInterface {
    int[] arrays(int a);
}

主程序

public class Dmeo04 {
    public static void main(String[] args) {
        int[] a1 = methodArrays(4, (i) -> {
            return new int[i];
        });

        int[] a2 =methodArrays(6,int[]::new);

        System.out.println(a1.length);
        System.out.println(a2.length);
    }

    public static int[] methodArrays(int len, arrayInterface arr) {
        return arr.arrays(len);
    }
}