创建测试对象:

public class Str {
    public String a;
    public String b;

    public Str() {
    }

    public Str(String s, String s1) {
        System.out.println("构造器引用1");
    }

    public static void getAstaictB() {

        System.out.println("static方法引用");
    }

    public static void getAstaictB(String s, String s1) {
        System.out.println("static方法引用1");
    }

    public String getAandB() {
        System.out.println("实例方法引用");
        return a + b + "return";
    }

    public String getAandB(String s, String s1) {
        System.out.println("实例方法引用1");
        return a + b + "return";
    }

    public void setAB(String s, String s1) {
        System.out.println("类的任意对象的实例方法引用");
    }
}

测试：

public class MenthodQuoteTest {
    public static void main(String[] args) {

        /**
         * 静态方法的方法引用
         */
        //lambda表达式
        MyInterface myInterface = (a, b) -> Str.getAstaictB(a, b); //不限制方法的调用：可调用Str.getAstaictB(),调用不同的方法得到不同的结果
        myInterface.set("aa", "bb");
        //静态方法引用
        MyInterface myInterface1 = Str::getAstaictB;  //特别注意：只能引用和接口一致参数的静态方法
        myInterface1.set("aa", "bb");

        System.out.println("==============================");

        /**
         * 实例方法的方法引用
         * 需要有一个实例对象
         */
        //lambda表达式
        Str str = new Str();
        MyInterface myInterface2 = (a, b) -> str.getAandB(a, b); //不限制方法的调用
        myInterface2.set("aa", "bb");
        //实例方法引用
        MyInterface myInterface3 = str::getAandB;  //特别注意：只能引用和接口一致参数的实例方法
        myInterface3.set("aa", "bb");

        System.out.println("==============================");
        /**
         * 类的任意对象的实例方法引用
         * 1、方法引用的通用特性：方法引用所使用方法的入参和返回值与lambda表达式实现的函数式接口的入参和返回值一致；
         * 2、lambda表达式的第一个入参为实例方法的调用者，后面的入参与实例方法的入参一致。
         */
        //lambda表达式
        MyInterface1 myInterface4 = (s, a, b) -> s.setAB(a, b); //不限制方法的调用
        myInterface4.set(new Str(), "aa", "bb");
        //类的任意对象的实例方法引用
        MyInterface1 myInterface5 = Str::setAB;  //特别注意：只能引用和接口一致参数的实例方法
        myInterface5.set(new Str(), "aa", "bb");

        System.out.println("==============================");
        /**
         * 构造器引用
         */
        //lambda表达式
        MyInterface myInterface6 = (a, b) -> new Str(a, b); //不限制方法的调用
        myInterface6.set("aa", "bb");
        //类的任意对象的实例方法引用
        MyInterface myInterface7 = Str::new;  //特别注意：只能引用和接口一致参数的实例方法
        myInterface7.set("aa", "bb");

    }

    @FunctionalInterface
    interface MyInterface {
        public void set(String a, String b);
    }

    @FunctionalInterface
    interface MyInterface1 {
        public void set(Str s, String a, String b);
    }
}

结果：
static方法引用1
static方法引用1

==============================

实例方法引用1
实例方法引用1

==============================

类的任意对象的实例方法引用
类的任意对象的实例方法引用

==============================
构造器引用1
构造器引用1