Java8新特性方法引用、构造器引用

绝地灬酷狼 2023-03-02 13:13 13阅读 0赞

# 方法引用与构造器引用 #

### 文章目录 ###

*  方法引用与构造器引用
 *   *  一、方法引用
     *   *  1. 静态方法的引用
         *  2. 非静态方法的引用
         *  3. 方法引用的特殊情况
     *  二、构造器引用
     *  三、数组引用

## 一、方法引用 ##

*  如果在lambda表达式中需要处理的逻辑比较复杂，一般情况会单独的写一个方法，在lambda表达式中直接引用这个方法即可
 *  方法引用：引用一个已经存在的方法，使其替代lambda表达式完成接口的实现
 *  格式
    
     *  使用 :: 将 类（或对象）与 方法名 分隔开，::之前是方法的调用者
     *  主要有以下两种情况
        
         *  类 :: 静态方法
         *  对象 :: 非静态方法

### 1. 静态方法的引用 ###

*  格式：**类 :: 静态方法**

(1) 使用Lambda表达式的方式

//定义一个接口
    private static interface Calculate { 
        int calculate(int a, int b);
    }
    
    public static void main(String[] args) { 
        //使用Lambda表达式，在Lambda体中定义具体的逻辑
        Calculate calculate = (x, y) -> { 
            if (x > y) { 
                return x - y;
            } else if (x < y) { 
                return y - x;
            }
            return x + y;
        };
    
        System.out.println(calculate.calculate(10, 10)); //20
    }

(2) 在Lambda表达式中调用已经存在的静态方法

//定义一个接口
    private static interface Calculate { 
        int calculate(int a, int b);
    }
    
    public static void main(String[] args) { 
        //使用Lambda表达式调用已经存在的静态方法
        Calculate calculate = (x, y) -> calculate(x, y);
    
        System.out.println(calculate.calculate(10, 10)); //20
    }
    
    //定义一个静态方法
    //此方法的参数类型、个数以及返回值类型都与函数式接口中的方法一致
    private static int calculate(int x, int y) { 
        if (x > y) { 
            return x - y;
        } else if (x < y) { 
            return y - x;
        }
        return x + y;
    }

(3) 使用静态方法引用的方式

public class Test { 
        //定义一个接口
        private static interface Calculate { 
            int calculate(int a, int b);
        }
    
        public static void main(String[] args) { 
            //静态方法引用
            //Test是当前类的名称
            Calculate calculate = Test::calculate;
    
            System.out.println(calculate.calculate(10, 10)); //20
        }
    
        //定义一个静态方法
        private static int calculate(int x, int y) { 
            if (x > y) { 
                return x - y;
            } else if (x < y) { 
                return y - x;
            }
            return x + y;
        }
    }

*  **注意事项**
    
     *  在引用的方法后面，不要添加小括号
     *  引用的这个方法，参数（数量、类型）和返回值类型，必须要跟接口中定义的一致

### 2. 非静态方法的引用 ###

*  格式：**对象 :: 非静态方法**
 *  **注意事项**
    
     *  在引用的方法后面，不要添加小括号
     *  引用的这个方法，参数（数量、类型）和返回值类型，必须要跟接口中定义的一致

public class Test { 
    
        //定义一个接口
        private static interface Calculate { 
            int calculate(int a, int b);
        }
    
        public static void main(String[] args) { 
            //使用当前类的对象引用一个非静态方法
            Calculate calculate = new Test()::calculate2;
            System.out.println(calculate.calculate(10, 20)); //-10
        }
    
        //定义一个非静态方法
        private int calculate2(int a, int b) { 
            if (a != b) { 
                return a - b;
            }
            return a + b;
        }
    }

### 3. 方法引用的特殊情况 ###

*  格式：**类 :: 非静态方法**
 *  何时使用
    
     *  当函数式接口中的抽象方法的参数包含了某一个对象，而实现此抽象方法的方法体中仅调用此对象的某一个成员方法时，可以直接使用此对象所属的类调用此成员方法
 *  **注意事项**
    
     *  在引用的方法后面，不要添加小括号

(1) 使用Lambda表达式的方式

public class Lambda3 { 
        //定义一个类
        private static class Person { 
            private String name;
    
            public void setName(String name) { 
                this.name = name;
            }
    
            public String getName() { 
                return name;
            }
        }
    
        //函数式接口，要获取Person类中的name属性
        @FunctionalInterface
        private interface MyInterface { 
             String get(Person person);
        }
    
        public static void main(String[] args) { 
             MyInterface lambda1 = x -> x.getName();
        }
    }

(2) 使用方法引用的方式

public class Lambda3 { 
        //定义一个类
        private static class Person { 
            private String name;
    
            public void setName(String name) { 
                this.name = name;
            }
    
            public String getName() { 
                return name;
            }
        }
    
        //函数式接口
        @FunctionalInterface
        private interface MyInterface { 
             String get(Person person);
        }
    
        public static void main(String[] args) { 
             MyInterface lambda2 = Person::getName;
        }
    }

(3) 再举一个例子

public class Lambda3 { 
        private static class Person { 
            private String name;
    
            public void setName(String name) { 
                this.name = name;
            }
    
            public String getName() { 
                return name;
            }
        }
    
        //为name属性赋值
        @FunctionalInterface
        private interface MyInterface { 
            void set(Person person, String name);
        }
    
        public static void main(String[] args) { 
            MyInterface lambda2 = Person::setName;
        }
    }

## 二、构造器引用 ##

*  使用场景：如果函数式接口中定义的方法，仅仅是为了得到一个类的对象，此时就可以使用构造器引用，使其替代lambda表达式完成接口的实现
 *  格式：**类 :: new** （无论有参、无参构造器new之后都没有括号）
 *  可以通过函数式接口中的方法的参数，自动区分引用不同的构造器

(1) 使用Lambda表达式的方式

public class Lambda2 { 
        private static class Person { 
            String name;
            int age;
            
            public Person() { }
        }
    
        @FunctionalInterface
        private interface GetPersonWithNoneParameter { 
            Person get();
        }
    
        public static void main(String[] args) { 
            //使用lambda表达式实现GetPersonWithNoneParameter接口
            GetPersonWithNoneParameter getPerson = () -> new Person();
    
            Person person = getPerson.get();
        }
    }

(2) 使用构造器引用的方式

public class Lambda2 { 
        private static class Person { 
            String name;
            int age;
            
            public Person() { }
        }
    
        @FunctionalInterface
        private interface GetPersonWithNoneParameter { 
            Person get();
        } 
    
        public static void main(String[] args) { 
            //使用构造器引用实现GetPersonWithNoneParameter接口
            GetPersonWithNoneParameter getPerson = Person::new;
    
            Person person = getPerson.get();
        }
    }

(3) 多个构造器的情况

public class Lambda2 { 
        private static class Person { 
            String name;
            int age;
    
            public Person() { }
    
            public Person(String name) { 
                this.name = name;
            }
    
            public Person(String name, int age) { 
                this.name = name;
                this.age = age;
            }
        }
    
        @FunctionalInterface
        private interface GetPersonWithNoneParameter { 
            Person get();
        }
    
        @FunctionalInterface
        private interface GetPersonWithSingleParameter { 
            Person get(String name);
        }
    
        @FunctionalInterface
        private interface GetPersonWithMultipleParameter { 
            Person get(String name, int age);
        }
    
        public static void main(String[] args) { 
    
            //自动的根据方法中的参数的个数和类型匹配Person中的构造器，如果有，引用对应的构造器，如果没有则报错
    
            //实现GetPersonWithNoneParameter接口
            GetPersonWithNoneParameter getPerson = Person::new;
    
            //实现GetPersonWithSingleParameter接口
            GetPersonWithSingleParameter getPerson2 = Person::new;
    
            //实现GetPersonWithMultipleParameter接口
            GetPersonWithMultipleParameter getPerson3 = Person::new;
        }
    }

## 三、数组引用 ##

*  格式：**类型\[\] :: new**
 *  可以把数组看成是一个特殊的类，则写法与构造器引用一致

//使用内置函数式接口Function中的R apply(T t)
    @Test
    public void test4(){ 
        //Lambda表达式形式
        Function<Integer,String[]> func1 = length -> new String[length];
    
        //数组引用的形式
        Function<Integer,String[]> func2 = String[] :: new;
    }