Lambda--方法引用

一、类的静态方法

我们在重写方法的时候，方法体中“只有一行代码”，并且这行代码是“调用了某个类的静态方法”，并且我们把要重写的抽象方法中“所有的参数都按照顺序传入了这个静态方法中”，这个时候我们就可以引用类的静态方法

package lambda;

import java.util.function.Supplier;

public class SupplierImpl implements Supplier<Test1> {
    @Override
    public  Test1 get() {
        System.out.println("------SupplierImpl-----");
        return Test1.test();
    }
}

 用实现的方式

package lambda;

import java.util.function.Supplier;

/**
 * 静态方法引用
 */
public class Test1 {
    public static Test1 test(){
        System.out.println("调用test方法");
        return null;
    }

    public static void main(String[] args) {
        Supplier<Test1> supplier1 = new SupplierImpl();
        supplier1.get();
    }
}

使用匿名内部类的方式：

package lambda;

import java.util.function.Supplier;

/**
 * 静态方法引用
 */
public class Test1 {
    public static Test1 test(){
        System.out.println("调用test方法");
        return null;
    }

    public static void main(String[] args) {

        Supplier<Test1> supplier1 =new Supplier<Test1>() {
            @Override
            public Test1 get() {
                System.out.println("匿名内部类实现");
                return null;
            }
        };
        supplier1.get();
    }
}

进一步改造，使用lambda的方式实现：

package lambda;

import java.util.function.Supplier;

/**
 * 静态方法引用
 */
public class Test1 {
    public static Test1 test(){
        System.out.println("调用test方法");
        return null;
    }

    public static void main(String[] args) {
        Supplier<Test1> supplier1 = () -> {
            return Test1.test();
        };
        supplier1.get();

    }
}

lambda再优化：

package lambda;

import java.util.function.Supplier;

/**
 * 静态方法引用
 */
public class Test1 {
    public static Test1 test(){
        System.out.println("调用test方法");
        return null;
    }

    public static void main(String[] args) {
        Supplier<Test1> supplier1 = () -> test();
        supplier1.get();
    }
}

使用类的静态方法

package lambda;

import java.util.function.Supplier;

/**
 * 静态方法引用
 */
public class Test1 {
    public static Test1 test(){
        System.out.println("调用test方法");
        return null;
    }

    public static void main(String[] args) {
        Supplier<Test1> supplier1 = Test1::test;
        supplier1.get();
    }
}

二、类的构造方法

package lambda;

import java.util.function.Supplier;

public class TestCon {
    public static void main(String[] args) {
        Supplier<TestCon> supplier =() -> new TestCon();
    }
}

用类的构造方法优化：

package lambda;

import java.util.function.Supplier;

public class TestCon {
    public static void main(String[] args) {
        Supplier<TestCon> supplier =TestCon::new;
    }
}

三、 对象的实例方法

我们在重写方法的时候，方法体中“只有一行代码”，并且这行代码是“调用了某个对象的成员方法”，并且我们把要重写的抽象方法中“所有的参数都按照顺序传入了这个成员方法中”，这个时候我们就可以引用对象的实例方法

匿名内部类的方式实现：

package lambda;
import java.util.function.Supplier;

public class TestObject {
    public TestObject a(){
        System.out.println("实例对象的实例方法");
        return null;
    }

    public static void main(String[] args) {
        Supplier<TestObject> supplier = new Supplier<TestObject>() {
            @Override
            public TestObject get() {
                TestObject testObject = new TestObject();
                return testObject.a();
            }
        };
        supplier.get();
    }
}

lambda的实现方式 

package lambda;
import java.util.function.Supplier;

public class TestObject {
    public TestObject a(){
        System.out.println("实例对象的实例方法");
        return null;
    }

    public static void main(String[] args) {
        Supplier<TestObject> supplier = () -> new TestObject().a();
        supplier.get();
    }
}

再简化:

package lambda;
import java.util.function.Supplier;

public class TestObject {
    public TestObject a(){
        System.out.println("实例对象的实例方法");
        return null;
    }

    public static void main(String[] args) {
        Supplier<TestObject> supplier = new TestObject()::a;
        supplier.get();
    }
}

四、类的实例方法
我们在重写方法的时候，方法体中“只有一行代码”，并且这行代码是“调用了第一个参数的成员方法”，并且我们把要重写的抽象方法中“剩余的所有参数都按照顺序传入这个成员方法中”，这个时候我们就可以引用类的实例方法

package lambda;


public interface MyInter {
    public void test(Test3 test3,int param2,int param3);
}

使用匿名内部类的方式实现 

package lambda;


public class Test3 {
    public void test3(int param1,int param2){
        System.out.println(param1 + "-------" + param2);
    }
    public static void main(String[] args) {
        MyInter myInter = new MyInter() {
            @Override
            public void test(Test3 test3, int param2, int param3) {
                test3.test3(param2,param3);
            }
        };
        myInter.test(new Test3(),1,2);
    }
}

使用类的实例方法

package lambda;


public class Test3 {
    public void test3(int param1,int param2){
        System.out.println(param1 + "-------" + param2);
    }
    public static void main(String[] args) {
        MyInter myInter = Test3::test3;
        myInter.test(new Test3(),1,2);
    }
}