How to create a Java extension method

Introduction

Use extension methods to "add" the original type without creating a new derived type, recompiling, or otherwise modifying the original type. method into an existing type. Although an extension method is a special form of static method, it can be called like an instance method of the extension type. For client code written in C# and Visual Basic, there is no significant difference between calling an extension method and calling the method actually defined in the type.

Languages ​​that support extension methods

In fact, many programming languages ​​support extension methods, such as C#, Visual Basic, Kotlin, etc., but our Java language has not yet supported it. JDK9 began to support the extension of java functions through jmod, and JDK16 promised to provide dynamic library calling solutions. However, as JDK8 users, if we also want to use extension methods, we have to find another way.

C

#

/// 扩展方法
public static class ExpandMethod {
    /// 两个数相加
    public static int Sum(this int num,int num2) {
        return num + num2;
    }
}
public class Program {
    static void Main(string[] args) {
        /// 调用位置
        Console.WriteLine(3.Sum(2));
    }
}

Visual Basic

Imports System.Runtime.CompilerServices
Module Module3
    Sub Main()
        Dim ex As New ExampleClass
        ' 调用位置
        ex.ExampleMethod("Extension method")
    End Sub 
    Class ExampleClass
        ' Define an instance method named ExampleMethod. 
        Public Sub ExampleMethod()
            Console.WriteLine("Instance method")
        End Sub 
    End Class
    <Extension()> 
    Sub ExampleMethod(ByVal ec As ExampleClass, 
            ByVal stringParameter As String)
        Console.WriteLine(stringParameter)
    End Sub 
End Module

Kotlin

// 扩展函数(本类中扩展方法)
class Test1 {
    var name: String = "boyi.chen"
}
fun Test1.temp() {
    println("增加扩展函数,打印扩展类的属性name=${this.name}")
}
fun main(args: Array<String>) {
    // 调用位置
    Test1().temp()
}

The protagonist appears

Java8 itself does not support extension methods, but we can pass Implementing extension methods through plug-ins is the same as using extension methods directly. Lombok is one of the plug-ins.

Lombok @ExtensionMethod

Through the Lombok @ExtensionMethod annotation, it helps us generate static methods that are directly called during program compilation. Of course, the IDEA plug-in can provide better support. Let’s look at specific examples below.

/**
 * lombok测试
 *
 * @author reboot
 */
@ExtensionMethod(StringUtil.class)
public class LombokTest {
    public static void main(String[] args) {
        System.out.println("".isBlank());
    }
    /**
     * 字符串工具
     *
     * @author reboot
     */
    public static class StringUtil {
        /**
         * 字符串判空
         *
         * @param targetStr 目标str
         * @return boolean
         */
        public static boolean isBlank(String targetStr) {
            return targetStr == null || "".equals(targetStr);
        }
    }
}

The compiled content can see that the method has been converted from "".isBlank() to LombokTest.StringUtil.isBlank(""). This is how Lombok provides us with the syntax of the extension method. Sugar, really sweet.

The above is the detailed content of How to create a Java extension method. For more information, please follow other related articles on the PHP Chinese website!