Java REPL Tutorial. -> System.out.println("Hi"); Hi

Transcription

1 Java REPL Tutorial Introduction The Java REPL (Read-Evaluate-Print-Loop) is a command line tool that facilitates exploratory programming by providing interactive use of Java Programming Language elements. It is ideal both for learning the Java language and exploring unfamiliar code (include new Java APIs). Typical Java development means writing a complete program, then compiling it (fixing any errors), the running it, figuring out what is wrong, editing, and repeating. With the Java REPL you can enter program elements one at a time, immediately seeing the result and adjusting accordingly. During development, code can be pasted into the REPL, and/or working code pasted from the REPL into a program editor. Getting Started The REPL accepts Java statements, variable, method, and class definitions, imports, and expressions. I'll refer to these pieces of Java code as snippets. For example, you can enter a statement at the prompt, any side-effects will take place and any output displayed (what the user types in italics): -> System.out.println("Hi"); Hi -> By default, the REPL will give you descriptive information about what you enter. Here, a variable is defined: -> int x = 45 Added variable x of type int with initial value 45 Note that terminating semicolons will be automatically added if missing. When an expression is entered, a temporary variable is created so that the value can be referenced later: -> Expression value is: 4 assigned to temporary variable $1 of type int When the REPL detects that an entry is incomplete, it prompts for more, as in this method definition: -> String twice(string s) { >> return s + s; Added method twice -> twice("ocean") Expression value is: "OceanOcean" assigned to temporary variable $2 of type String Commands The Java REPL has a number of commands for settings and queries. They are distinguished from snippets by a leading slash. You can get information on the current variables, methods, and classes with the /vars, /methods, and /classes commands. You can get a list of entered active snippets with the /list command. For example: -> /vars int x = 45 int $1 = 4 String $2 = "OceanOcean"

2 -> /methods twice (Ljava/lang/String;)Ljava/lang/String; printf (Ljava/lang/String;[Ljava/lang/Object;)V -> /list 9 : System.out.println("Hi") 10 : int x = 45; 11 : : String twice(string s) { return s + s; 13 : twice("ocean") You will note that the types and values of variables, and the type signature of methods are displayed. You might also note that the listing starts at snippet 9 (this is surprising to people and will be changed) and that there is a method which we did not define. This is because the REPL has start-up entries that are silently and automatically executed before the REPL starts, so that you can get to work quickly. These aren't listed unless you request to see them with /list all : -> /list all 1 : import java.util.*; 2 : import java.io.*; 3 : import java.math.*; 4 : import java.net.*; 5 : import java.util.concurrent.*; 6 : import java.util.prefs.*; 7 : import java.util.regex.*; 8 : void printf(string format, Object... args) { System.out.printf(format, args); 9 : System.out.println("Hi") 10 : int x = 45; 11 : : String twice(string s) { return s + s; 13 : twice("ocean") Several common imports and a handy printf method are the default start-up entries. You can personalize your start-up entries with the /setstart command (whose argument is a file name to read), all subsequent invocations of the REPL will use the entries you specified. This start-up file may contain snippets (such as imports) and/or commands. The /savestart is useful if you wish to create your file as a variant to the default startup. Use /help for a list of commands. Other important commands include /exit to leave the REPL, /save to save your snippets, /open to read them back in, and /classpath to add to the paths that will be searched for referenced classes. You may have noticed that the REPL is quite chatty, you can set the amount and format of output with the /feedback command, for example /feedback concise. If you plan to primarily use the REPL by pasting from other windows, you may wish to toggle off the prompt with /prompt. Place these setting in your start-up file and use /setstart to have them apply to future sessions. Changing Definitions To change the definition of a variable, method, or class you have previously entered, simply enter a new definition. For example, the method we defined above can get new new definition: -> String twice(string s) { >> return "Twice:" + s; Modified method twice -> twice("thing") Expression value is: "Twice:thing"

3 assigned to temporary variable $3 of type String Note that rather than saying Added method, as before, it says Modified method -- this means that the definition was changed, but has the same signature, and thus all existing usages continue to be valid. You may also change definitions in incompatible ways. For example: -> String x Replaced variable x of type String We have changed the type of the variable x, note that it now says Replaced. More on this later. Forward Reference Because a goal of the REPL is to support exploratory programming (and because some forms of programming require it), the REPL allows you to define methods whose bodies reference methods, variables, or classes which are not yet defined. Let's say you wish to define a method for the volume of a sphere, you can enter the formula: -> double volume(double radius) { >> return 4.0 / 3.0 * PI * cube(radius); Added method volume, however, it cannot be invoked until method cube(double), and variable PI are declared The REPL allows the definition but warns of what is yet to be defined. The definition may be referenced, but if execution is attempted, it will fail: -> double PI = Added variable PI of type double with initial value Attempted to call volume which cannot be invoked until method cube(double) is declared. -> double cube(double x) { return x * x * x; Added method cube Expression value is: assigned to temporary variable $2 of type double With all definitions in place, volume now works. I'll use this code to illustrate more about incompatible replacement. Let's say you aren't happy with the precision of PI: -> BigDecimal PI = new BigDecimal(" ") Replaced variable PI of type BigDecimal with initial value This is incompatible with the definition of volume(), but, by default, no warning will be displayed until the code is executed this is to prevent flurries of uninteresting updates. You can see this information by using a different feedback setting: /feedback verbose. Executing the volume() method will display the issue: Attempted to call volume which cannot be invoked until this error is addressed -- bad operand types for binary operator '*' first type: double second type: java.math.bigdecimal return 4.0 / 3.0 * PI * cube(radius); ^ ^

4 History The REPL maintains a history of snippets and commands. You navigate this history to re-enter or edit prior input with the up/down/left/right arrows. Entered text will be inserted. The Delete key can be used to delete text. Press the Enter key to accept the history line again (modified or not). You can move a snippet at a time by using control-up and control-down (that is holding the control key while pressing the up or down key). Tab Completion Press the tab key to complete the current entry. For example: vol<tab> Will be replaced with: volume( If there is more than one completion the set of completions will be listed. Editors This feature is being actively explored. Feedback much appreciated. Final feature very likely to be different. To more easily edit past entries, particularly one's of many lines, you can invoke an editor on the snippet by providing its name or id (number in /list): /edit volume Or, for all snippets and to enter new ones, /edit without an argument. When you save in the editor, any snippet that is changed or new will be entered, you will see the feedback from the snippets in the REPL window however there will be no REPL prompt and you cannot enter commands or snippets in the REPL window until the editor is closed. If you do not specify an editor, an internal editor will be provided. Specify the editor to invoke with the /seteditor command. The argument to the command is the external editor you wish to use. This editor must open its own window. For example: -> /seteditor kwrite Editor set to: kwrite -- note: editor MUST run in its own window -> /edit... user defines x in the external editor window and selects save... Added variable x of type int with initial value 6... user closes the external editor... ->

5 Exceptions In an exception backtrace, a location within REPL entered code is displayed as the #id/linenumber, where snippet id is the number displayed in /list and linenumber is the linenumber within the snippet. So, below, the exception occurs in snippet #9 aka divide() on the second line of divide: -> int divide(int x, int y) { >> return x / y; Added method divide -> divide(5, 0) java.lang.arithmeticexception thrown: / by zero at divide (#9:2) at (#10:1) -> /list 9 : int divide(int x, int y) { return x / y; 10 : divide(5, 0) Updated: July 6, 2015