方法的引用

概念

public class demo01Printable {

public static void main(String[] args) {
   printString((s)->{ System.out.println(s); });//lambda表达式
/*
    分析：lambda表达式目的：打印参数传递的字符串
    1、System.out对象已经存在
    2、println方法也是已经存在的
    可以优化lambda表达式
 */
    printString(System.out::println);//方法引用写法 双冒号::
}
//定义一个方法 参数传递Prinable接口，对字符串进行打印
public static void printString(Printable p){
    p.print("HelloWorld");

}
}

通过对象名引用成员方法

/*
通过对象名引用成员方法
使用前提 对象名已经存在，成员方法已经存在

*/

public class demo01ObjectMethodReference {
//定义一个方法，方法的参数传递Printable接口
public static void printString(Printable1 p){
    p.print("HelloWorld");
}

public static void main(String[] args) {
    //调用printString方法，方法的参数是一个函数式接口 可以使用lambda表达式
    printString((s)->{
        //创建MethodRerObject对象
        demoMethodRerObject obj  =new demoMethodRerObject();
        //调用MethodRerObject对象的成员方法printUpperCaseString，把字符串按照大写输出
        obj.printUpperCaseString(s);
    });

    /*
       使用方法引用优化lambad表达式
       对象是已经存在的MethodRerObject
       成员方法已经存在的printUpperCaseString
       可以使用对象名引用成员方法
     */
    demoMethodRerObject obj2 =new demoMethodRerObject(); //创建MethodRerObject对象
    printString(obj2::printUpperCaseString);
    }
}
/*
定义一个打印的函数式接口
*/
@FunctionalInterface	
public interface Printable1 {
void print(String s);
}

public class demoMethodRerObject {
//定义一个成员方法，传递字符串，把字符串按照大写输出
public void printUpperCaseString(String str){
    System.out.println(str.toUpperCase());
}
}

类名引用静态成员方法

/*
通过类名引用静态成员方法
类已经存在 静态成员方法已经存在
*/

public class demoStaticMethodReference {
//定义一个方法 方法参数传递计算绝对值的整数 函数式接口Calcable
public static int method(int number,Calcable c){
    return c.calsAbs(number);
}

public static void main(String[] args) {
    //调用method方法，传递绝对值
    int method = method(-10, (n) -> {
        //对参数进行绝对值计算并返回结果
        return Math.abs(n);
    });
    System.out.println(method);
    /*
        使用方法引用优化lambda表达式
     */
    int method1 = method(-20, Math::abs);
    System.out.println(method1);


}
}
public interface Calcable {
//定义一个抽象方法 定义一个整数，对整数进行绝对值计算并返回
int calsAbs(int number);
}

super引用

/*
定义一个子类
*/

public class Man extends Human{
//重写

@Override
public void sayHello() {
    System.out.println("Hello,i am Man");
}
//定义一个方法参数传递Greetable接口
public void method(Greetable g){
    g.greet();
}
public void show(){
    //调用method方法 方法参数Greetable是一个函数式接口 可以传递lambda
    method(()->{
        Human h =new Human();
        h.sayHello();
    });
    /*
        使用super直接调用父类的成员方法
     */
    method(()->{
       super.sayHello();
    });
    /*
        使用super引用父类成员方法
     */
    method(super::sayHello);
}

public static void main(String[] args) {
    new Man().show();
}
}
/*
定义父类
 */

public class Human {
//
public void sayHello(){
    System.out.println("Hello,我是Human");
}
}
/*
定义见面的函数式接口
 */
@FunctionalInterface
public interface Greetable {
void greet();
}

this引用

/*
通过this引用本类的成员方法
*/

public class Husband {
//定义一个买房子的方法
public void buyHouse(){
    System.out.println("买房子咯");
}
//定义一个结婚方法
public void marry(Richable r){
    r.buy();
}
//定义一个开心方法
public void Happy(){
    //调用结婚方法 方法参数是函数式接口 使用lambda
    marry(()->{
        //使用this调用本类买房子的方法
        this.buyHouse();
    });
    /*
        使用引用优化lambda
     */
    marry(this::buyHouse);
}

public static void main(String[] args) {
    new Husband().Happy();
}
}
/*
定义一个富有的函数式接口
*/
@FunctionalInterface
public interface Richable {
void buy();
}

构造方法引用

/*
类的构造器 构造方法引用
*/

public class demo {
//定义一个方法，参数传递姓名和PersonBuilder接口，方法通过姓名创建Person对象
public static void printName(String name, PersonBuilder pb){
    Person person = pb.builderPerson(name);
    System.out.println(person.getName());
}

public static void main(String[] args) {
    //调用printName  方法的参数有函数式接口 可以传递lambda
    printName("jackboy",(String name)->{
        return new Person(name);
    });
    /*
        使用方法引用优化
     */
    printName("jackboy",Person::new);
}
}
/*
定义一个创建Person对象的函数式接口
 */
@FunctionalInterface
public interface PersonBuilder {
Person builderPerson(String name);
}
public class Person {
private String name;

public String getName() {
    return name;
}

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

public Person() {
}

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

数组的构造器引用

/*
数组的构造器引用
*/

public class demo02 {
/*
    定义一个方法 方法的参数传递创建数组的长度和ArrayBuilder接口
    方法内部根据传递的长度使用ArrayBuilder中的方法创建数组并返回
 */
public static int[] creatArray(int length,ArrayBuilder ab){
    return ab.builderArray(length);
}

public static void main(String[] args) {
    //调用方法 传递数组的长度和优化lambda表达式
    int[] ints = creatArray(10, int[]::new);
    System.out.println(ints.length);
    System.out.println(Arrays.toString(ints));
}
}
/*
定义一个创建数组的函数式接口
*/

@FunctionalInterface
public interface ArrayBuilder {
//定义一个创建int类型数组的方法，参数传递数组的长度，返回创建好的int类型数组
int[] builderArray(int length);
}