Java033——方法的引用

港控/mmm° 2023-10-13 17:08 15阅读 0赞

## 一、Java方法引用说明 ##

Java方法引用是一种简化Lambda表达式的语法，它允许直接通过方法的名称来引用已经存在的方法，而不是定义Lambda表达式。方法引用可以使代码更简洁、易读，并提高可维护性

## 二、Java中的方法引用的四种形式 ##

### 2.1、引用静态方法 ###

引用静态方法的语法如下:

> 类名::静态方法名

1、这个语法中出现了一个新的操作符“`::`”，这是由两个英文冒号组成的操作符，冒号之间没有空格。  
2、这个操作符左边表示方法所属的类名，右边是方法名。  
3、需要注意的是，这个语法中方法名是没有圆括号的。

interface StaticMethodInterface {
         							// 测试接口
        int method(int a, int b);  								// 抽象方法
    }
    
    public class StaticMethodDemo{
        
        static int add(int x, int y) {
        								// 静态方法，返回两个参数相加的结果
            return x + y;                         					//返回相加结果
        }
    
        public static void main(String[] args) {
        
        	//语法： 类名::静态方法名
            StaticMethodInterface sm = StaticMethodDemo::add; 		//引用StaticMethodDemo类的静态方法
            int result = sm.method(15, 16);							//直接调用接口方法获取结果
            System.out.println("接口方法结果：" + result); 			//输出结果
        }
    }
    
    //运行结果
    接口方法结果: 31

### 2.2、引用成员方法 ###

语法如下:

> 对象名::成员方法名

与引用静态方法语法不同，这里操作符左侧的必须是一个对象名，而不是类名。这种语法也可以达到抽象方法按照类成员方法逻辑来实现的目的。

interface InstanceMethodInterface {
                            // 创建测试接口
        String method(Date date);                           // 带参数的抽象方法
    }
    
    class TestDemo {
        
        public String format(Date date) {
                          // 格式化方法
            // 创建日期格式化对象，并指定日期格式
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            return sdf.format(date);                       // 返回格式化结果
        }
    
        public static void main(String[] args) {
        
            // 创建类对象
            TestDemo demo = new TestDemo ();
            // 引用类对象的方法
            InstanceMethodInterface im = demo::format;
            Date date = new Date();                       // 创建日期对象
            System.out.println("默认格式：" + date);     	// 输出日期对象默认格式
            // 输出经过接口方法处理过的格式
            System.out.println("接口输出的格式：" + im.method(date));
        }
    }
    
    //运行结果
    默认格式：Fri Jul 14 22:40:40 CST 2023
    接口输出的格式：2023-07-14

### 2.3、引用构造方法 ###

#### 2.3.1、引用无参构造方法 ####

引用构造方法的语法如下:

> 类名::new

class TestDemo {
        
        public TestDemo() {
         // 无参构造方法
            System.out.println("调用无参构造方法");
        }
    
        public TestDemo(int i) {
         // 有参构造方法
            System.out.println("调用有参构造方法");
        }
    
        public static void main(String[] args) {
        
            // 引用ConstructorsTest1类的构造方法
            ConstructorsInterface1 a = TestDemo::new;
            TestDemo b = a.action(); // 通过无参方法创建对象
    
        }
    }
    
    //运行结果
    调用无参构造方法

#### 2.3.2、引用有参构造方法 ####

引用有参构造方法的语法与引用无参构造方法一样。区别就是函数式接口的抽象方法是有参数的。

class TestDemo {
        
        public TestDemo() {
         // 无参构造方法
            System.out.println("调用无参构造方法");
        }
    
        public TestDemo(int i) {
         // 有参构造方法
            System.out.println("调用有参构造方法，参数为：" + i);
        }
    
        public static void main(String[] args) {
        
            // 引用ConstructorsTest1类的构造方法
            ConstructorsInterface1 a = TestDemo::new;
            TestDemo b = a.action(5688); // 通过无参方法创建对象
    
        }
    }
    
    //运行结果
    调用有参构造方法，参数为：5688

#### 2.3.3、 引用数组构造方法 ####

语法如下:

> 类名()::new

创建函数式接口和测试类。定义接口时创建一个泛型 T，同时 T 作为抽象方法的返回值。抽象方法定义一个整型参数。创建接口对象时，将测试类数组作为泛型，并引用数组构造方法。通过接口方法创建测试类数组，再分别为每个数组元素赋值。

interface ArraysConsInterface<T> {
                           // 构造方法接口
        // 抽象方法返回对象数组，方法参数决定数组个数
        T action(int n);
    }
    
    class TestDemo {
        
        public static void main(String[] args) {
        
            // 引用数组的构造方法
            ArraysConsInterface<TestDemo[]> a = TestDemo[]::new;
            TestDemo array[] = a.action(3);      // 接口创建数组，并指定数组个数
            array[0] = new TestDemo();           // 给数组元素实例化
            array[1] = new TestDemo();
            array[2] = new TestDemo();
            // 如果调用或给array[3]赋值，代码则会抛出数组下标越界异常
            // array[3] = new ArraysConsDemo();
        }
    }

### 2.4、引用特定类型的实例方法： ###

语法如下:

> 特定对象::方法名。

// 示例：引用ArrayList实例的size方法
    List<String> list = new ArrayList<>();
    Supplier<Integer> sup = list::size;

#### 2.4.1、引用带泛型的方法 ####

import java.util.HashSet;
    interface ParadigmInterface<T> {
                                   // 测试接口
        int method(T[] t);                                      // 抽象方法
    }
    
    public class ParadigmDemo {
        // 测试类
        // 静态方法，使用泛型参数，在方法名之前定义泛型。此方法用于查找数组中的重复元素个数
        static public <T> int repeatCoount(T[] t) {
        
            int arrayLength = t.length;                     	// 记录数组长度
            java.util.HashSet<T> set = new HashSet<>(); 		// 创建哈希集合
            for (T tmp : t) {
                                			// 遍历数组
                set.add(tmp);  							// 将数组元素放入集合中
            }
            return arrayLength - set.size();                    // 返回数组长度与集合长度的差
        }
    
        public static void main(String[] args) {
        
            Integer a[] = {
        1, 1, 2, 3, 1, 5, 6, 1, 8, 8};   			// 整数数组
            
            String s[] = {
        "王", "李", "赵", "陈", "李", "孙", "张"};		// 字符串数组
            // 创建接口对象，Integer作为泛型，引入ParadigmDemo类的静态方法,方法名要定义泛型
            ParadigmInterface<Integer> p1 = ParadigmDemo::<Integer> repeatCoount;
            // 调用接口方法
            System.out.println("整数数组重复元素个数：" + p1.method(a));
            // 创建接口对象，String作为泛型，引入ParadigmDemo类的静态方法
     		// 方法名若不定义泛型，则默认使用接口已定义好的的泛型
            ParadigmInterface<String> p2 = ParadigmDemo::repeatCoount;
            // 调用接口对象方法
            System.out.println("字符串数组重复元素个数：" + p2.method(s));
        }
    }
    
    //运行结果
    整数数组重复元素个数：4
    字符串数组重复元素个数：1