On November 6th 2022, Trisha and I launched our book, Getting to Know IntelliJ IDEA. It’s taken us over two years to write, and it contains a wealth of information; in fact, it contains everything you need to get started using IntelliJ IDEA. We wrote the book because the tools we use matter, and being able to use them effectively improves our productivity and happiness.
What’s in the book?
The book is over 350 tightly packed A4/US letter-sized pages. The eBook page count, of course, is much larger, at just under 1000 pages… That’s because there are plenty of:
…. annotated screenshots
… guided tutorials
… helpful use cases
… chapter introductions
… chapter summaries
… and that’s before we get started on the Trisha Tips
… and Helen Hints:
… plus much more!
How is the book structured?
The book is split into four parts, each of which has a different goal so that you can either read the book front to back, which I recommend if you’re new to IntelliJ IDEA, or you can dip in and out as you need to which more experienced users may want to do.
Part I lays the foundations of what IntelliJ IDEA is, what the key elements of the interface are, and how you can get the most from them. It also introduces the three guiding principles for IntelliJ IDEA:
Always Green – IntelliJ IDEA strives to keep your code compiling by flagging errors as they happen and assisting with keeping it syntactically correct.
Keyboard First – Using IntelliJ IDEA’s keyboard shortcuts speeds you up in your day-to-day tasks. You probably won’t learn them all, but learning the ones you use helps keep you focused.
In the Flow – We all know the feeling when you’re happily coding and don’t want distractions; we have provided lots of tips and tricks to help you stay in this zone while using IntelliJ IDEA.
Part II builds on the foundations laid in Part I for writing and reading code, which is a huge part of our daily jobs. It introduces some key features that help do the heavy lifting in IntelliJ IDEA so you can focus on doing what you do best – figuring out solutions to problems! There are many opportunities for you to try stuff out with the code snippets we have provided, which are all available on GitHub.
Part III takes it to the next level and uses guided tutorials to show you how to open, run, test, and debug real applications. These tutorials get you up and running quickly and introduce you to IntelliJ IDEA’s features so you can explore them at your own pace. Part III also discusses working with dependencies, build tools and version control; central components for real-world applications.
Part IV is where the book pivots to specific functionality you can use in your day-to-day workflow. This is where you can discover areas of IntelliJ IDEA that you might not be familiar with. We’ve included many features that can support you and introduced the “Frequently Asked Questions” element to answer your questions. The Table of Contents gives you clues as to what’s in here!
One of the super cool things about IntelliJ IDEA is how much code you can generate with minimum effort. Yes, it’s not the 1990s anymore, we’re no longer measured on how many lines of code we generate (thankfully), but you also know that Java has its fair share of boilerplate code.
These shortcuts load the Generate menu! Here’s a quick tour of where you can use it in Java projects in IntelliJ IDEA. It’s not a complete list; let me know where else we can use it please!
New Java Class
In the Project Window, you can use this shortcut to create a whole host of things which are project and folder specific. If you use the shortcut on your directory that is marked as your sources root (usually src) in a Java project you get the option to create a new Java file (among other things). You’re then asked to select between a Class, Interface, Record (Preview), Enum or Annotation. It’s a speedy way of creating new classes for your project.
Before we move on, a closely related shortcut is the one we use for a new Scratch File. It’s ⌘⇧N on macOS, or Ctrl+Shift+Alt+Ins on Windows/Linux. You can select to create a new Scratch file using ⌘N on macOS, or Alt+Ins on Windows and Linux in the Project Tool window, but it’s worth committing the scratch file shortcut to memory too as it’s handy to be able to dump some code or notes in an area outside your project and share it across IntelliJ IDEA projects.
Constructors
Now that you’ve got your class, you may want to generate a constructor or two. However, before we do that, let’s add a couple of variables to our class:
public class GenerateCode {
private final String name = "Helen";
private int age;
private String mood;
}
We can use the same shortcut to make ourselves a constructor. We get some options here because we’ve got some fields in our class:
IntelliJ IDEA is asking us if we want to pass our fields into our Constructor.
If we select both and click OK we have our Constructor with the parameters passed in.
public class GenerateCode {
private final String name = "Helen";
private int age;
private String mood;
public GenerateCode(int age, String mood) {
this.age = age;
this.mood = mood;
}
}
Other Class-Based Generate Options
We don’t need to stop there either. There’s a whole host of code that IntelliJ IDEA can generate for us at this stage including:
Getter
Setter
Getter and Setter
equals() and hashCode()
toString()
Override Methods
Delegate Methods
Test
While we’re here, Java Records are coming and IntelliJ IDEA is ready. Another way you could generate code if you’re not ready to move to Java Records is to use the Generate shortcut to create a new Java record, and then you can convert the Java record to a normal Java class with ⌥⏎ on macOS, or Alt+Enter on Windows and Linux with your caret on the class name.
Implement Methods
When our Java class implements an interface, we need to ensure that we implement that interface’s methods. The Generate menu helps us here too. Let’s say that our code looks like this, and we’re implementing NewInterface:
public class GenerateCode implements NewInterface {
private final String name = "Helen";
private int age;
private String mood;
}
When we use ⌘N on macOS, or Alt+Ins on Windows and Linux this time, we see select a new option call Implement Methods:
The keyboard shortcut is ⌃I on macOS, or Ctrl+I on Windows/Linux.
This allows you to generate the code required to implement the methods in the Java interface that we’re implementing with the @Override annotation.
Now IntelliJ IDEA has generated that code for us:
public class GenerateCode implements NewInterface {
private final String name = "Helen";
private int age;
private String mood;
@Override
public void doSomething() {
}
@Override
public void goSomewhere() {
}
}
This also works for overriding methods from superclasses/super abstract classes.
Add Parameters / Arguments
Another useful trick you so is to use ⌘N on macOS, or Alt+Ins on Windows and Linux when you’re in a dialogue, and you need to add more rows or data. For example, we added a default constructor to our class, but we now want to refactor it to change the signature. Our code currently reflects the default constructor:
public class GenerateCode{
private final String name = "Helen";
private int age;
private String mood;
public GenerateCode() {
}
}
Let’s refactor the Constructor with ⌘F6 on macOS, or Ctrl+F6 on Windows/Linux. In the Change Signature dialogue, you can use ⌘N on macOS, or Alt+Ins on Windows/Linux to add a new parameter. This saves you using your mouse to click the little + icon.
This trick works in all the dialogue boxes that require additional lines to be added that I’ve found so far.
Generate Test Methods
Finally, everyone loves a good test and rightly so. We’ve already mentioned that you can use the Generate menu from a Java method to generate a corresponding test class. However, once you’re in the test class, you can use ⌘N on macOS, or Alt+Ins on Windows and Linux again to create much of the boilerplate code you might need, including (for JUnit5 at least):
Test Method
SetUp Method
TearDown Method
BeforeClass Method
AfterClass Method
If you are working with a different testing framework, your Generate menu will give you other relevant options.
Summary
Java may be a little clunky on the boilerplate side of things, but IntelliJ IDEA takes the heavy lifting out of that to a large extent so along with the shorcut for intention actions, it’s a compelling combination.
I haven’t always been lazy; it’s a fairly recent addition to my repertoire of skills. And do you know who I blame? I blame IntelliJ IDEA. I used to check that I’d completed a statement correctly, I used to look at javadoc, I used to check I’d closed my parentheses correctly, but now I don’t give things a second glance.
No, really, it is. Back when I was a (cough) younger adult, we had to type out all the code, we also thought it was cool to mix drinks that turned into something akin to gorilla snot. Maybe we weren’t that smart, but I am discovering one thing at a rapid rate, IntelliJ IDEA was smarter than me, even 20 years ago (I’d like to say it was a low bar).
I took a long break from coding, about 20 years, in fact. When I left coding, I wrote code in Vi and had memorised that very useful shortcut :wq. IDE’s were around, but in fledgeling forms. Recently I came back to coding, and I walked straight into IntelliJ IDEA’s open arms.
Exhitbit 1 – Statement Completion
Never one to take responsibility for my own actions, I’d like to offer up exhibit one – Statement Completion in IntelliJ IDEA. When you use the combination of Cmd+Shift+Enter, on macOS or Ctrl+Shift+Enter on Windows/Linux, IntelliJ IDEA completes it for you so that it will compile. I don’t even know where the semi-colon button is on my keyboard anymore; I don’t need it. Allow me to demonstrate.
Try this one.
Rubbish right? Naturally, it won’t compile.
Use Statement Complete and boom, we get this.
IntelliJ IDEA is kind and pops the caret in the right place as part of Statement Complete too. Sure, it’s only a few characters, but there’s a deep-seated comfort in knowing IntelliJ IDEA made it compile. It might not do what you want yet, but that’s your problem, mostly. I recommend you train your fingers to master this one, it will help you sleep at night.
Exhibit 2 – Live Templates
I covered these in detail in this blog, but here’s a quick recap.
Remember the days when you had to type the whole `for i` loop out? Well, they’re as dead as the shell-suit fashion of the 1990s.
After we press return, the Live Template in IntelliJ IDEA does all the boring stuff for us.
Incidentally, you should press Tab to move to the next point that needs your input (the red squiggle).
A few more of my favourites are:
psfs will give you public static final String
And
soutv (in a fori loop will give you System.out.println("i = " + i);)
There's 35 more for you to check out with your beverage of choice! There's no keyboard shortcut for Live Templates; they'll just appear when you summon them by starting to type what you want.
Exhibit 3 – Post-Fix Completion
It seems like the humble dot is extremely powerful in IntelliJ IDEA. It does Basic Completion automatically, but, it also does something very cool in that it can be used to tell IntelliJ IDEA to wrap whatever you just typed in some more code.
We’re just mere humans, we obey the laws of the languages we speak and write (mostly), but thinking is hard. Allow me to demonstrate. We don’t think:
I want to output some text to the console.
I want to write some text.
No. We think:
I want to write some text.
Oh, also, I want to output that text to the console.
This is exactly what Post-Fix Completion does. It builds on live templates, where applicable, and helps your brain to flow in the order of things that it’s probably become accustomed to over the years (many in my case).
Before post-fix completion, the earlier example becomes:
I want to Output some text to the console
sout.-> System.out.println();
And then I want to write the text to output
"I wandered lonely as a cloud"
But, with post-fix completion:
I want to write some text.
"I wandered lonely as a cloud"
Oh, also, I want to output that text to the console
.sout -> System.out.println("I wandered lonely as a cloud");
There are 46 types of Post-Fix Completion in IntelliJ IDEA 2020.2. That’s a lot of time saved in your day and a lot of language-based syntactic-sugar for your thinking-brain. Other cool examples include:
assert to create an assertion based on a boolean expression, for example: is2020OverYet.assert
Becomes
assert value;
My favourite code construct, the humble for (and fori loops):
Lastly, this one is pretty cool. I like var and this is one way that IntelliJ IDEA takes the notion of var to make your life just a little easier. You can use .var to ask IntelliJ IDEA to declare something that you’ve created as the correct explicit variable type. Let’s look at the String.var portion of this:
You will also have the option to use the var type for real at this point if you want to. Now, var is fabulous, but Java is still a statically typed language. If you, as a human-being (presumably), can’t figure out what type it is, please don’t use var as the variable type. Using .var is geat, but declaring something as type var is a big no-no if the type of the expression is not quickly decipherable. Gift your fellow humans (right now, we all need it) by stating the type that it evaluates to when all is said and done. They’ll thank you for it and you’ll help them sleep better at night.
Exhibit 4 – Smart Completion
With IntelliJ IDEA you get Basic Completion out of the box, but Smart Completion is just an extra finger tap away by using Ctrl+Shift+Space. Smart Completion not only analyses what could be correct, but it takes it one step further and looks at the context of the surrounding code to make the right decision. If IntelliJ IDEA can determine the appropriate type for the right-hand side of an assignment statement, initiating a variable, a return statement, arguments of a method call and more, it will filter the list to just that. To show you the power of Smart Completion, I’ll show it to you alongside basic completion for comparison.
First up, we’ll invoke Basic Completion (no ‘dot’ so it won’t come up automatically in this case). Note that I have a space after new.
HashMap hashMap = new
With basic completion we get a whole list of options, some valid, some not so much.
But, with Smart Completion, we get a much shorter, more relevant list.
Okay, let’s look at a return statement next.
With basic completion.
And with smart completion.
You get the idea, it's very useful! Here is the keyboard shortcut that you need:
Did Your IDE Make You Lazy Too?
There’s a lot of advantages to being lazy. It affords you more time for yourself, and your loved ones for a start. However, it’s more than that, being a developer isn’t all about writing code; there’s also:
Thinking / flow time
Working out what your code needs to do
Asking questions / Answering questions
Mentoring others / Being mentored yourself
So much more!
Being lazy isn’t a bad thing, it’s an efficiency gain that allows me to focus on the things that matter, which isn’t checking my parentheses are correct or remembering to put a semi-colon after my statement. No, it’s taking time for myself and those around me. Sure, it’s IntelliJ IDEA’s fault, but I am happy that we’re here!
Until recently, I last wrote Java in anger in 2002. IntelliJ IDEA had just been released; it wasn’t remotely on my radar. I honestly can’t remember what IDE we were using back then, but it certainly was a very long way to the fully featured IDE that JetBrains produce today. Here’s my experience of using IntelliJ IDEA for the first time.
Downloading IntelliJ IDEA
There’s a lot going on when you first load IntelliJ IDEA, but I learned pretty quickly that there are also some good first steps you can take to make your experience a little more comfortable. The first thing I would say is that it’s an enterprise tool so there is a learning curve. There’s no getting around that – it’s the same with any new piece of enterprise software; you do need to give it some time and be willing to go on a learning journey. Fortunately for us, JetBrains have, in my opinion, done a very good job at supporting developers on that learning curve. So, if you’re sitting comfortably, here are my recommendations.
Figure out which version of IntelliJ IDEA you need. I once offended my now-colleague Trisha Gee by asking her which IDE to use because I didn’t know that IntelliJ IDEA Community was free. Foolishly, I assumed that because it was an insanely powerful IDE that it couldn’t possibly be free. I was appropriately schooled by a rather irritated Trisha and told in no uncertain terms that I could use IntelliJ IDEA for FREE. Honestly? Mind blown. I then decided that there must be a catch, so I assumed (see a pattern here?) that it would only be free for me to muck about and not free for commercial development. Wrong again, Helen, wrong again.
Next up, download JetBrains Toolbox, even if you’re only using IntelliJ IDEA. I promise you it’s worth it. This cute little box will sit on your toolbar, chill out and manage all the installs and updates to IntelliJ IDEA with minimal input from yourself. Use your new JetBrains toolbox to download the version of IntelliJ IDEA you require and manage your licensing requirements.
Okay, great! You’ve got a shiny version of IntelliJ IDEA downloaded. Let’s get started!
Running IntelliJ IDEA for the First Time
You’ll be asked to choose between Darcula and Light for your UI theme. I am not getting into this argument. I like light, deal with it. Click Next: Default Plugins to move on (unless you’re in a rush in which case click Skip Remaining and Set Defaults). IntelliJ IDEA does a great job of selecting the plugins that you’re most likely to need – these are the Default plugins. You can disable some of them if you want to but if you’re not entirely sure just leave them because you can tinker with them later.
Click Next: Featured plugins, this is a list of plugins that are the most common ones. Feel free to go rummaging around for plugins, but keep it real – the more plugins IntelliJ IDEA has, the more it has to deal with as well as being your awesome IDE. I recommend you build the plugins up so you get used to IntelliJ IDEA out-of-the-box-almost to start with. With that in mind, you should definitely go ahead and grab Key Promoter X and IDE Features Trainer if you’re new to IntelliJ IDEA (which you probably are given you’re reading this)! Now click Start Using IntelliJ.
Little note here, if you screw up your settings and want to unwrap IntelliJ IDEA all over again, go to File > Manage IDE Settings > Restore Default Settings. This is relatively new and can be a very useful learning experience.
Starting a New Project in IntelliJ IDEA
I’m going to go ahead and start a new project. Here’s where we need to sort our Java version out. IntelliJ IDEA is pretty smart about this. It will go and look for the Java versions you’ve already got installed, if there are any. If it finds them, it will populate the Project SDK with them. If it doesn’t find any it gives you an option to download them. You can select your Vendor and your Version and click Download. I recommend you leave the default Location because again, IntelliJ IDEA is smart and knows exactly where to look to find what it needs.
You can select additional libraries here if you want to and you know what you want. I am going to leave them blank and click Next.
Next up, we have Templates. You can create templates from existing projects to recreate later, however on new installations the only template available will be Command Line App. This is a boilerplate Java application with a class and a method. If you’re new to IntelliJ IDEA, it’s worth selecting this option just to get a feel for the file structure and inner workings.
Go ahead and enter a Project name. The Project location will be constructed from the name although you can change it if required. If you want to change the Base package you can do but for now, I recommend you go ahead and click Finish.
And there you have it! One shiny new IntelliJ IDEA project!
A Note on the ‘Release Version’
If you’re anything like me, the first thing you do is throw caution to the wind and go change a bunch of settings in the IDE because you ‘know what you’re doing’. Well, turns out, I didn’t! So, word of warning – if you see this error, it means your ‘Project bytecode version’ is set to something higher than your ‘Project SDK’ (and thus Project language level)’:
Check your SDK setting by using ⌘; on macOS, or Ctrl+Alt+Shift+S on Windows/Linux and looking at your Project Settings > Project, specifically your Project SDK and Project Language Level values and make a note of them.
Next, check your Project Bytecode version by using ⌘, on macOS or Ctrl+Alt+S and search for Build, Execution, Deployment > Compiler > Java Compiler. Your Project bytecode setting needs to either be the same as your Project language level, or something lower than it, such as Java 11. Then you can rebuild the project.
Being new to IntelliJ IDEA, something else that I wondered was what’s the difference between the Project SDK and the Project language level. As it turns out, the Project SDK are the tools you need to develop Java (seems fair), whereas the Project Language Level refers to the assistance that IntelliJ IDEA will give you in the editor. The two settings can be different as well. Your Project language level will restrict what inspections IntelliJ IDEA applies to your code and determine which compiler is used to turn your Java code into bytecode. You can override the compiler settings as I showed above if you don’t want to compile your code with the Project Language Level.
Summary
I can remember hating getting my environment set up at university – and I screwed it up regularly too. There is absolutely no doubt that IntelliJ IDEA makes the whole process of running ‘HelloWorld.java’ a whole lot easier. It does a great job of obfuscating the settings until you need them and will hold your hand throughout the process of setting up your environment without you breaking into a sweat about your classpath setting. Yes, you can break it, but you can also fix it very easily.
The discussion of whether to use an IDE, or not, is one that polarises people. As someone returning to Java after a long period of absence, working with an IDE of this calibre is like having a really knowledgeable friend help you achieve your goal (to run HelloWorld.java) and just that, as quickly and as efficiently possible. I know I’m still scratching the surface of what IntelliJ IDEA can do, but I’m a huge fan of the right information at the right time (which is when I need it) and IntelliJ IDEA does this very well. I’m looking forward to finding out more!
