class<\/code>, public<\/code>, static<\/code> and args[]<\/code> for now; we’ll talk about it later”. If you have ever mentioned these lines to a new Java student, who is about to execute their first ‘HelloWorld’ program, know that this is changing. If you are that student, well, congratulations, getting started is simpler in Java :-).<\/p>\n\n\n\nInitially released as a preview language feature in Java 21, Simple Source Files and Instance Main Methods<\/a> is currently being previewed for the fourth time in Java 24. This feature is for folks starting to learn Java. It simplifies the initial steps for students when they start learning basics, such as variable assignment, sequence, conditions and iteration. Students no longer need to declare an explicit class to develop their code, or write their main()<\/code> method using this signature – public static void main(String [])<\/code>, or use System.out.println()<\/code> to output values to console. With this feature, classes could be declared implicitly, the<\/i> main()<\/code> method can be created with a shorter list of keywords and println()<\/code>\/ readln()<\/code> methods can be used to write to and read from console.<\/p>\n\n\n\nIn this blog post, I’ll cover why and how this feature is helpful for students using hands-on coding examples. I\u2019ll also cover some details and frequently asked questions relevant to educators or experienced programmers. Let’s get started.<\/p>\n\n\n\n
Hi Students – Your HelloWorld code is changing<\/h2>\n\n\n\n
HelloWorld<\/i> refers to the first piece of executable code that anyone writes when they start learning a new language or a framework. It usually includes executing bare minimum code, such as printing ‘Hello World’ on the console to ensure the setup is okay. In Java, it meant writing a class with a method main()<\/code>. As the name suggests, main()<\/code> is one of the most important methods. It defines the entry point of execution, when a class executes.<\/p>\n\n\n\nWhat happens when you see that your ‘HelloWorld’ code executed as expected? It brings a lot of joy and a sense of winning to the one executing it. I still remember the time when I was able to run my first piece of code in Java. I believe we kind of never forget our firsts, both in life, love and coding!<\/p>\n\n\n\n
Let\u2019s see how your HelloWorld code is changing.<\/p>\n\n\n\n
Class \u2018HelloWorld\u2019 before and after Java 21<\/h2>\n\n\n\n
Before<\/i> Java 21, you would need to define a class, say, HelloWorld<\/code>, that defined a main()<\/code> method with a specific list of keywords, to print any text, say, ‘Hello World’ to the console, as follows:<\/p>\n\n\n\npublic class HelloWorld {\n public static void main(String[] args) {\n System.out.println(\"Hello World\");\n }\n}\n<\/pre>\n\n\n\nWith Java 21 this initial step was shortened and changed a little with Java versions 22, 23 and 24. Now (with Java 24), you can define a source code file, say, HelloWorld.java, with the following code, to print a message to the console (it doesn\u2019t need to define a class, it has a shorter signature for method main()<\/code> and System.out.println()<\/code> is shortened to println()<\/code>):<\/p>\n\n\n\nvoid main() {\n println(\"Hello World\");\n}\n<\/pre>\n\n\n\nThe preceding code is simpler than what was required earlier. Let\u2019s see how this change could help you focus on what you need, rather than what you don\u2019t.<\/p>\n\n\n\n
Reducing cognitive complexity<\/h2>\n\n\n\n
One of the main benefits of the minimalistic main()<\/code> method and not having to write an explicit class is – the code is concise and to the point. It introduces less concepts or keywords that could otherwise overwhelm new students. Here’s an image to compare the difference in the preceding code snippets:<\/p>\n\n\n\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/02\/compare-mains-1.png\")
<\/figure>\n\n\n\nOf course, you could ignore the terms class<\/code>, public<\/code>, static<\/code>, args[]<\/code>, System.out<\/code> as suggested by your teacher, but they do use space in your memory every time you look at it. These little things pile up, in coding or life, overwhelming one. The minimalist main()<\/code> and implicit enclosing class reduce cognitive complexity for you.<\/p>\n\n\n\nCompiling and executing your code<\/h2>\n\n\n\n
Once you are done writing your code, the next step is to execute it.<\/p>\n\n\n\n
On the command prompt, you could use just the java<\/code> command to compile and execute this code (courtesy of Launch Single-File Source-Code Programs<\/a>, since Java 11). Assuming you have defined your code in a source code file, say, HelloWorld.java, you could use the following commands to execute it:<\/p>\n\n\n\nC:\\code\\MyHelloWorldProject\\java HelloWorld.java\n<\/pre>\n\n\n\nFor your quick information, since Java 22, it is possible to skip the compilation process multiple for code defined in multiple source code files too. Check out this link<\/a> for details.\n\n\n\nHowever, since ‘Simple Source Files and Instance Main Methods’ is a preview language feature, you should add the flag --enable-preview<\/code> with --source 24<\/code> with these commands, as follows:<\/p>\n\n\n\nC:\\code\\MyHelloWorldProject\\java --enable-preview --source 24 HelloWorld.java\n<\/pre>\n\n\n\nSooner or later, you might switch to using an IDE to write your code. If you wish to use IntelliJ IDEA for creating instance main methods, here\u2019s a quick list of steps to follow. Create a new Java project, select the build system as IntelliJ (so you could use Java compiler and runtime tools), create a new file, say, HelloWorld.java with your instance main method and set the properties to use Java 24, before you run your code, as shown in the following gif (It could save you from typing out the compilation\/ execution commands on the command prompt each time you want to execute your code):<\/p>\n\n\n\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/02\/new-proj.gif\")
<\/figure>\n\n\n\nAre you wondering if it would be better to create a ‘Java class’ instead of a ‘File’ in the ‘src’ folder? The option of selecting a Java class would generate the body of a bare minimum class, say, public class HelloWorld { }<\/code>. Since we are trying to avoid unnecessary keywords in the beginning, I recommended creating a new ‘File’ which wouldn\u2019t include any code.<\/p>\n\n\n\nIf you plan to use IntelliJ IDEA, here are its configuration details. Java 24 support is available in IntelliJ IDEA 2025.1 EAP<\/a>. The final release of this version is planned for March 2025.<\/p>\n\n\n\nIn your Project Settings, set the SDK to Java 24. For the language level, select \u201824 (Preview) – Flexible consructor bodies, simple source files, etc.\u2019 on both the Project and Modules tab, as shown in the below settings screenshot:<\/p>\n\n\n\n![\"\"\/](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/02\/proj-settings.png\")
<\/figure>\n\n\n\nLet\u2019s move beyond the simple \u2018Hello World\u2019 code and explore further.<\/p>\n\n\n\n
What else can main() do apart from printing messages to the console?<\/h2>\n\n\n\n
It is an interesting question. Let\u2019s check out a few code examples<\/a> below to learn more about it.<\/p>\n\n\n\nExample 1. Variable declarations, assignments and simple calculations<\/h3>\n\n\n\n
The initial steps in learning programming start with basics, such as declaring variables, assigning values, simple calculations and checking the values (by printing them to the console). Here\u2019s a common example that covers them all – calculating the total amount returned by a bank for a specified interest rate and principal amount. Let’s define this code in a source code file, say, CalcInterest.java:<\/p>\n\n\n\n
void main() {\n double principal = 17000;\n double rate = 0.07;\n double interest;\n\n interest = principal * rate;\n principal = principal + interest;\n\n println(\"Interest = \" + interest);\n println(\"Amount after 1 year = \" + principal);\n}\n<\/pre>\n\n\n\nIn the next example, let\u2019s code something interesting – more than basic calculations, such as, printing a pattern .<\/p>\n\n\n\n
Example 2. Print patterns, such as, big letters using a specified character<\/h3>\n\n\n\n
Here\u2019s another interesting problem that includes basics, such as, variable assignments, conditional statements (via if-else<\/code>) and iteration (via for<\/code>).<\/p>\n\n\n\nThe following code prints a letter P, using the letter X (as specified by the variable charToPrint<\/code>), that is 10 lines in height (as specified by the variable size<\/code>):<\/p>\n\n\n\nvoid main() {\n int size = 10;\n char charToPrint = 'X';\n for (int i = 0; i < size; i++) {\n for (int j = 0; j < size; j++) {\n if (j == 0 || (i == 0 || i == size \/ 2) && j < size - 1 || (j == size - 1 && i <= size \/ 2)) {\n print(charToPrint + \" \");\n } else {\n print(\" \");\n }\n }\n println();\n }\n}\n<\/pre>\n\n\n\nThe following gif shows the output of the preceding code:<\/p>\n\n\n\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/02\/print-pattern-letter-p.gif\")
<\/figure>\n\n\n\nDo you think you would be up for creating methods that could include logic to print other letters of the alphabet (A – Z), or even other alphabets (like the Devnagri)? Just asking :-)<\/p>\n\n\n\n
Before we move forward, did you know you could overload methods, that is, define multiple methods with the same name, such as, \u2018main\u2019 in your source code file? Which of these methods main()<\/code> method would execute when you run your source code file? IntelliJ IDEA displays the run icon next to the<\/i> main()<\/code> method in your source code. The following gif shows how that icon moves when you change the signature of a main<\/code> method:<\/p>\n\n\n\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/02\/which-main.gif\")
<\/figure>\n\n\n\nLet\u2019s take a step forward in the next example by animating words spanning multiple lines.<\/p>\n\n\n\n
Example 3. Animating multiline text – one word at a time<\/h3>\n\n\n\n
Soon, you\u2019ll find yourself using other concepts like, say, iterating words in a String, single and multiple line comments, using other classes from core Java API like Threads, perhaps also some exception handling. Here\u2019s an example of a multiline String that is displayed like animated text, one word at a time (all of which can be coded within the main()<\/code> method):<\/p>\n\n\n\n\/**\n * The main method animates the display of lines of text by printing each word with a pause in between.\n * It splits the given text into individual lines, then splits each line into words.\n * It prints each word followed by a space, and pauses for a specified amount of time between each word.\n *\/\nvoid main() {\n \/\/ Text to animate\n String text = \"\"\"\n Why did the Java programmer bring a shovel to work? To 'dig' into the data structures!\n Why was the Java developer always so calm? Because they never lost their stack trace!\n Why did the Java developer go broke? Because he used up all his cache!\n Why did the Java developer always carry a pen? To 'interface' with their notes!\n \"\"\";\n\n \/\/ Split into individual lines\n String[] lines = text.split(\"\\n\");\n\n \/\/ Loop through lines\n for (String line : lines) {\n String[] words = line.split(\" \");\n\n \/\/ Loop through words\n for (int i = 0; i < words.length; i++) {\n\n\t \/\/ Print the word\n print(words[i] + \" \");\n \/\/ Pause to create the animation effect\n try {\n Thread.sleep(200); \/\/ Change this number to modify word display speed\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n \/\/ Start printing on the next line\n println();\n }\n}\n<\/pre>\n\n\n\nThe following gif shows the output of the preceding code:<\/p>\n\n\n\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/02\/animate-words.gif\")
<\/figure>\n\n\n\nIf you are feeling adventurous, perhaps you could try other animations too – like animating each letter or decreasing the speed by which the words are printed to console. Are you up for this challenge :-)<\/p>\n\n\n\n
Example 4. Data structure problems<\/h3>\n\n\n\n
I\u2019ve seen that both students and experienced programmers enjoying solving problems that involve data structures. So, here\u2019s one for you (which can be coded using just the main()<\/code> method): Given an array of integers, find the maximum subarray sum. The subarray must be contiguous, but could be of any length.<\/p>\n\n\n\nBelow is the code for your reference:<\/p>\n\n\n\n
void main(String[] args) {\n int[] nums = {-2, 1, -3, 4, -1, 2, 1, -5, 4};\n int maxEndingHere = nums[0];\n int maxSoFar = nums[0];\n\n for (int i = 1; i < nums.length; i++) {\n maxEndingHere = Math.max(nums[i], maxEndingHere + nums[i]);\n maxSoFar = Math.max(maxSoFar, maxEndingHere);\n }\n\n int maxSum = maxSoFar;\n println(\"Maximum subarray sum: \" + maxSum);\n}\n<\/pre>\n\n\n\nExample 5. Text based Hangman game<\/h3>\n\n\n\n
Here\u2019s another example that shows code for a text based hangman game – a simple game that asks you to guess one letter at a time. If the letter appears in the target guess word, it reveals itself in the word. This example uses the Scanner<\/code> class from the Java API, which could be accessed either by using the full name while defining its variable, or by including an import<\/code> statement outside the main()<\/code> method (this helps you to get familiar with using concepts like importing other classes in an incremental way):<\/p>\n\n\n\nvoid main() {\n String[] words = {\"java\", \"programming\", \"computer\", \"algorithm\", \"developer\"};\n String targetWord = words[(int) (Math.random() * words.length)];\n\n StringBuilder guessedLetters = new StringBuilder(targetWord.length());\n for (int i = 0; i < targetWord.length(); i++) {\n guessedLetters.append(\"_\");\n }\n\n int attempts = 6;\n println(\"Welcome to Hangman!\");\n println(\"Try to guess the word. You have \" + attempts + \" attempts.\");\n\n while (attempts > 0) {\n println(\"Current word: \" + guessedLetters);\n String input = readln(\"Enter a letter: \");\n char guess = input.charAt(0);\n\n boolean found = false;\n StringBuilder updatedWord = new StringBuilder(guessedLetters);\n for (int i = 0; i < targetWord.length(); i++) {\n if (targetWord.charAt(i) == guess) {\n updatedWord.setCharAt(i, guess);\n found = true;\n }\n }\n\n if (found) {\n guessedLetters = updatedWord;\n println(\"Correct guess! Updated word: \" + guessedLetters);\n } else {\n attempts--;\n println(\"Incorrect guess! You have \" + attempts + \" attempts left.\");\n }\n\n if (guessedLetters.toString().equals(targetWord)) {\n println(\"Congratulations! You guessed the word: \" + targetWord);\n break;\n }\n }\n\n if (attempts == 0) {\n println(\"Game Over. The word was: \" + targetWord);\n } \n}\n<\/pre>\n\n\n\nThe following gif shows the output of the preceding code:<\/p>\n\n\n\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/02\/hangman-play.gif\")
<\/figure>\n\n\n\nHere\u2019s another challenge for you – I just realized that the input in the preceding code is case sensitive. It doesn\u2019t work if you type \u2018A\u2019 instead of \u2018a\u2019. Could you make it ignore the case of the letters that are typed?<\/p>\n\n\n\n
The intent with all these examples is that you could use minimum ceremonial code to start learning basics in Java.<\/p>\n\n\n\n
Changing an implicit class to a regular class<\/h3>\n\n\n\n
When you are ready to level up and work with other concepts like user defined classes, you could also covert the implicit classes and code that we used in the previous examples, to regular classes, as shown below:<\/p>\n\n\n\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/02\/convert-to-reg-class.gif\")
<\/figure>\n\n\n\nIn the next section, I\u2019ll answer a few questions that might seem more interesting for folks who are not new to Java and are interested in knowing more about this feature.<\/p>\n\n\n\n
Some details and FAQs<\/h2>\n\n\n\n
Let\u2019s start by sharing that the name of this feature changed from its initial release, which is not common.<\/p>\n\n\n\n
A little bit of history<\/h3>\n\n\n\n
The name of this feature changed more than once since it was previewed in Java 21. This feature was introduced as Unnamed Classes and Instance Main Methods<\/a>. Its name changed to Implicitly Declared Classes and Instance Main Methods<\/a> in Java 22. There was no change to its name in Java 23<\/a>. In Java 24, the name of this feature is changed again – Simple Source Files and Instance Main Methods<\/a>.<\/p>\n\n\n\nChanging name of a Java feature is not usual. It could happen if the changes in the feature no longer reflect the intention of its initial name.<\/p>\n\n\n\n
What do you mean by \u2018instance\u2019 main() method?<\/h3>\n\n\n\n
This feature refers to the main method as an instance main method since it doesn\u2019t use the keywords static with its declaration. In the past, the main method was defined using the static keyword, so that it could be accessed even without the need of creating any objects of the class in which it was defined.<\/p>\n\n\n\n
Behind the scenes, a source code file with an instance main method is compiled to a regular class with a no-arg constructor. Its instance main method is executed by creating an instance of this class, followed by calling main() on it.<\/p>\n\n\n\n
What happens when you create a source code file with method main(), but no class declaration?<\/h3>\n\n\n\n
Behind the scenes, the Java compiler creates an implicit top level class, with a no-argument constructor, so that these classes don\u2019t need to be treated in a way that is different to the regular classes.<\/p>\n\n\n\n
Here\u2019s a gif that shows a decompiled class for you for the source code file AnimateText.java:<\/p>\n\n\n\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/02\/decompile.gif\")
<\/figure>\n\n\n\nInteracting with console – println() vs. System.out.println() calls<\/h3>\n\n\n\n
To make it simpler for new developers to interact with the console, that is, output messages to console and to read input from it, a new class – java.io.IO<\/code> was created in Java 23. It contains just a handful of overloaded readln()<\/code> and println()<\/code> methods (as shown below):<\/p>\n\n\n\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/02\/IO-class-struc.png\")
<\/figure>\n\n\n\nClass java.io.IO<\/code> is automatically imported in implicit classes. So, instead of using System.out.println()<\/code>, you can now use println()<\/code> to output messages to a console (and readln()<\/code> to read from console). Interestingly, println()<\/code> was added to this class in Java 24.<\/p>\n\n\n\n
![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/02\/println-import.gif\")
<\/figure>\n\n\n\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/02\/create-a-main-method.gif\")
<\/figure>\n\n\n\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/02\/extract-method-inline-variables.gif\")
<\/figure>\n\n\n\n