In Java development, JShell has become an indispensable tool for developers looking to streamline their coding process. Introduced in Java 9 as the official Java REPL (Read-Eval-Print Loop), JShell enables interactive programming by allowing developers to execute Java code snippets, evaluate expressions, and test new concepts on-the-fly without the need for a full-fledged project setup. This powerful feature significantly improves the efficiency and productivity of Java developers.<\/p>\n\n\n\n
This article is intended for experienced Java developers who are already familiar with the basics of JShell and want to explore its advanced usage and customization options. By the end of this article, you’ll not only gain a deeper understanding of JShell’s capabilities but also learn how to tailor it to your specific needs, ultimately elevating your Java development experience. Let’s dive into the world of JShell and unveil its advanced features, customizations, and best practices.<\/p>\n\n\n\n
JShell is packed with a variety of features that make it a powerful tool for Java developers. In this section, we’ll cover some of the most useful features that contribute to JShell’s ease of use and efficiency.<\/p>\n\n\n\n
One of the standout features of JShell is its tab completion and code suggestions. This functionality allows you to type partial code fragments, press the ‘Tab’ key, and JShell will automatically suggest potential completions. This feature not only saves time but also helps avoid typing errors. Additionally, JShell’s code suggestions include relevant methods, variables, and class names from the current context, making it easier to discover and use available APIs.<\/p>\n\n\n\n
JShell keeps track of your command history, allowing you to easily navigate through previously executed code snippets and commands using the up and down arrow keys. This feature is particularly useful for quickly re-executing or modifying previously entered code. You can also use the ‘\/history’ command to display a complete list of your input history, which can be helpful for reviewing past actions or exporting your work.<\/p>\n\n\n\n
JShell provides various command-line options that enable you to customize its behavior and tailor it to your preferences. Some of these options include setting the initial classpath, enabling or disabling feedback, and launching JShell with a specific JDK version. Moreover, JShell can be integrated with popular Java Integrated Development Environments (IDEs) like IntelliJ IDEA and Eclipse, allowing you to use JShell’s interactive features directly within your favorite development environment.<\/p>\n\n\n\n
JShell is designed to handle errors gracefully and provide meaningful feedback to help you quickly identify and fix issues. When you encounter a syntax error or runtime exception, JShell displays a detailed error message with relevant information to help you diagnose the problem. Additionally, JShell’s error recovery mechanism allows you to fix the problematic code snippet and automatically updates any dependent code snippets, saving you the trouble of manually correcting all related errors. This feature is particularly useful in an interactive environment where code snippets are often built incrementally and depend on each other.<\/p>\n\n\n\n
In this section, we’ll delve into more advanced JShell features and explore how you can use them to further enhance your interactive programming experience.<\/p>\n\n\n\n
JShell allows you to define methods and lambda expressions, enabling you to create reusable code snippets and modularize your interactive code. You can define methods in JShell just like you would in a regular Java source file. Here’s an example:<\/p>\n\n\n
jshell> int<\/span> sum<\/span>(int<\/span> a, int<\/span> b)<\/span> <\/span>{ return<\/span> a + b; }\n| created method sum<\/span>(int<\/span>,int<\/span>)<\/span>\n<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nSimilarly, you can create lambda expressions to represent anonymous functions:<\/p>\n\n\n
jshell> Function<Integer, Integer> square = x -> x * x;\n| created variable square : Function<Integer, Integer> = $Lambda$16<\/span>\/0x000000080012bc40<\/span>@3f<\/span>8e7a01<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nWorking with imports and classes<\/h3>\n\n\n\n
JShell automatically imports several commonly used Java packages, such as java.io, java.util, and java.math. However, you can also import additional packages or specific classes as needed:<\/p>\n\n\n
jshell> import<\/span> java.time.LocalDateTime;<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nYou can also define your own classes within JShell, allowing you to create more complex and structured code:<\/p>\n\n\n
jshell> class<\/span> Person<\/span> <\/span>{\n ...> private<\/span> String name;\n ...> private<\/span> int<\/span> age;\n ...> \n ...> Person(String name, int<\/span> age) {\n ...> this<\/span>.name = name;\n ...> this<\/span>.age = age;\n ...> }\n ...> \n ...> String getName<\/span>()<\/span> <\/span>{ return<\/span> name; }\n ...> int<\/span> getAge<\/span>()<\/span> <\/span>{ return<\/span> age; }\n ...> }\n| created class<\/span> Person<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nEvaluating expressions and statements<\/h3>\n\n\n\n
JShell can evaluate both expressions and statements, allowing you to perform calculations, create variables, or execute methods on the fly. Here are some examples:<\/p>\n\n\n
jshell> int result = sum(5, 3);\n| created variable result : int = 8\n\njshell> square.apply(4);\n| Expression value is: 16\n| assigned to temporary variable $1 of type Integer<\/code><\/span><\/pre>\n\n\nManaging code snippets and their dependencies<\/h3>\n\n\n\n
As you work with JShell, you may end up with numerous code snippets, some of which depend on others. JShell provides several built-in commands to help you manage these snippets and their dependencies:<\/p>\n\n\n\n
\n\/list<\/strong><\/code>: Lists all code snippets in the current session.<\/li>\n\n\n\n\/edit <id><\/strong><\/code>: Opens an editor to modify a specific code snippet.<\/li>\n\n\n\n\/drop <id><\/strong><\/code>: Removes a code snippet and its dependencies.<\/li>\n\n\n\n\/save <filename><\/strong><\/code>: Saves your code snippets to a file.<\/li>\n<\/ul>\n\n\n\nWhen you modify or remove a code snippet, JShell automatically updates any dependent snippets, ensuring that your code remains consistent.<\/p>\n\n\n\n
For example, suppose you have two snippets that depend on each other:<\/p>\n\n\n
jshell> String greet<\/span>(String name)<\/span> <\/span>{ return<\/span> \"Hello, \"<\/span> + name + \"!\"<\/span>; }\n| created method greet<\/span>(String)<\/span>\n\njshell> String greeting <\/span>= greet(\"John\"<\/span>);\n| created variable greeting : String = \"Hello, John!\"<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nIf you modify the greet<\/strong><\/code> method, JShell will automatically update the greeting<\/strong><\/code> variable:<\/p>\n\n\njshell> String greet<\/span>(String name)<\/span> <\/span>{ return<\/span> \"Hi, \"<\/span> + name + \"!\"<\/span>; }\n| replaced method greet<\/span>(String)<\/span>\n| update modified variable greeting : String <\/span>= \"Hi, John!\"<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nCustomization and Configuration<\/h2>\n\n\n\n
JShell offers several customization and configuration options to help you create a tailored interactive programming environment. In this section, we’ll explore some of these options and how they can be used to enhance your JShell experience.<\/p>\n\n\n\n
JShell startup configuration<\/h3>\n\n\n\n
You can configure JShell to load custom settings or code snippets automatically when it starts up. To do this, create a startup script file containing JShell commands, code snippets, or imports, and then pass the file to JShell using the --startup<\/strong><\/code> command-line option:<\/p>\n\n\njshell --startup my_startup.jsh<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nFor example, you might create a my_startup.jsh<\/strong><\/code> file with the following contents:<\/p>\n\n\nimport<\/span> java.time.LocalDateTime;\nimport<\/span> java.util.stream.Collectors;\n\nSystem.out.println(\"Welcome to JShell!\"<\/span>);<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nCustomizing feedback mode<\/h3>\n\n\n\n
JShell provides several built-in feedback modes that control the amount and format of the information displayed when you execute code snippets. You can switch between these modes using the \/set<\/strong><\/code> command:<\/p>\n\n\njshell> \/set feedback [verbose|normal|concise|silent]<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nAlternatively, you can create a custom feedback mode by modifying an existing mode or defining a new one. To do this, use the \/set<\/strong><\/code> command with a mode<\/strong><\/code> parameter:<\/p>\n\n\njshell> \/set mode my_custom_mode normal\njshell> \/set prompt my_custom_mode \"\\u001B[32mjs> \\u001B[0m\"<\/span>\njshell> \/set feedback my_custom_mode<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nThis example creates a custom mode based on the normal<\/strong><\/code> mode, but with a green-colored prompt.<\/p>\n\n\n\nDefining custom commands and aliases<\/h3>\n\n\n\n
JShell allows you to define custom commands and aliases using the \/alias<\/strong><\/code> command. This can be useful for creating shortcuts to frequently used actions or adding new functionality to JShell. Here’s an example of defining a custom alias:<\/p>\n\n\njshell> \/alias now \/eval LocalDateTime.now()\njshell> \/now\n| Expression value is: 2023<\/span>-04<\/span>-17<\/span>T18:31<\/span>:40.817697<\/span>\n| assigned to temporary variable $1<\/span> of type LocalDateTime<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nIn this example, we created a custom alias now<\/code> that evaluates the current date and time using the LocalDateTime.now()<\/strong><\/code> method.<\/p>\n\n\n\nUsing external libraries and custom classpath<\/h3>\n\n\n\n
JShell allows you to use external libraries and custom classpath settings to extend its functionality. To use an external library, download the JAR file and add it to JShell’s classpath using the --class-path<\/strong><\/code> command-line option:<\/p>\n\n\njshell --class<\/span>-path<\/span> path<\/span>\/to<\/span>\/your<\/span>\/library<\/span>.jar<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nAlternatively, you can add the JAR file to the classpath during an active JShell session using the \/env<\/strong><\/code> command:<\/p>\n\n\njshell> \/env --class<\/span>-path<\/span> path<\/span>\/to<\/span>\/your<\/span>\/library<\/span>.jar<\/span>\r<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nOnce the library is added to the classpath, you can import and use its classes and methods just like you would in a regular Java project:<\/p>\n\n\n