Refactoring Java with IntelliJ IDEA
4.3 (16 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
116 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Refactoring Java with IntelliJ IDEA to your Wishlist.

Add to Wishlist

Refactoring Java with IntelliJ IDEA

Learn to refactor like you mean it, stress-free, using IntelliJ IDEA's built-in refactorings
4.3 (16 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
116 students enrolled
Created by James Richardson
Last updated 11/2016
English
Curiosity Sale
Current price: $10 Original price: $40 Discount: 75% off
30-Day Money-Back Guarantee
Includes:
  • 1.5 hours on-demand video
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Navigate code seamlessly
  • Refactor Java code like a pro
  • Put away that mouse, and avoid RSI
  • Understand design decisions made when refactoring
View Curriculum
Requirements
  • Knowledge of the Java language is required
  • A copy of IntelliJ IDEA either Community (free) or Ultimate
Description

Everybody knows that they should refactor their code to make sure that it is as easy as possible to maintain and understand.

Refactoring by editing text introduces errors, and there can be long times when the code won't even compile, because a refactoring is part way through. Using automated refactoring tools means that your code will compile all the time, allowing tests to be run after every change.

IntelliJ IDEA provides a huge number of tools to make refactoring of even very large codebases pain-free. 

This course starts at the beginning, showing how to refactor a small codebase using IntelliJ IDEA's automated tools, building up skills that can be applied to huge source trees without breaking a sweat.

It demonstrates that, often, code can be refactored without actually typing any code at all!

It also helps the student understand that refactoring is also about making design decisions.

Each lesson is easily digested in under 15 minutes, teaching techniques that are immediately useful in the real world.

This course requires a copy of IntelliJ IDEA, which is a free download.

The author and the course content is not affiliated with Jetbrains s.r.o  - although is a long time user and fan of their products!

Who is the target audience?
  • Anybody writing Java software
Students Who Viewed This Course Also Viewed
Curriculum For This Course
17 Lectures
01:19:49
+
Introduction
3 Lectures 03:50

This is the beginning of the course - Refactoring Java with IntelliJ IDEA. 

Here we talk about what the course is going to teach, and talk about the lecture format.


Preview 01:44

In this lesson, you'll learn how to get the code from github, so that you can work along with the course, with your own copy of IDEA.

Cloning the tutorial code
01:07

Here we learn a great secret of effective and productive programming

Don't use the mouse
00:59
+
Getting Ready
2 Lectures 02:10

We take a short your of our example codebase, and learn about the classes that we'll be refactoring.

Overview of the codebase
01:15

As IntelliJ IDEA is so configurable, it can be difficult to align settings between different users. Here we learn how to configure the settings that were used on this course.

Import inspection settings
00:55
+
Getting started with refactoring
3 Lectures 12:23

IntelliJ has some pretty cool in-built refactorings for specific situations. Here we learn how to use one of them.

Preview 04:19

A discussion about refactoring - why should anybody even bother?

Preview 02:15

Here we see that you don't really even need to type any code to effect some major changes to a codebase. We can find and fix bugs almost without trying.

Let IDEA refactor for you
05:49
+
Refactoring
5 Lectures 31:05

Here we learn how to use IntelliJ IDEA's "Extract Variable" and "Extract Method" refactorings. There are some surprising quirks in how they work - It's not as obvious as it might seem!

Extract variable and method
07:12

Rename methods, variables and all manner of other symbols across a codebase in fractions of a second. Here we see how.

Rename
02:28

Functionality can be lying around all over the place. Here we use the "Extract Method" refactoring to clean it up and put it in the right place.

Extracting and modifying methods
04:44

Continuing to tidy up, this time moving methods between classes.

Moving classes and methods
07:05

We make extensive use of the "Intention Menu" as we continue to tidy up the code.

Introducing parameters
09:36
+
Finding and fixing bugs
1 Lecture 09:27

We add some tests, with some surprising and unexpected consequences.

Writing tests, fixing bugs
09:27
+
More Refactoring
2 Lectures 18:33

In this lecture we up the ante with the refactoring, using "Extract Interface, and add just a small extra feature to the system.

Extract interface
05:33

The business owners have a far more complex feature to add to our system. Here we find out if our previous refactorings have made it easier or harder. We write some acceptance tests, and attempt to implement our feature before lunchtime.

Adding new functionality
13:00
+
Wrap Up
1 Lecture 02:21

Some closing thoughts about IntelliJ IDEA and refactoring in general.

Preview 02:21
About the Instructor
James Richardson
4.3 Average rating
16 Reviews
116 Students
1 Course
Principal Software Developer

James has designed and implemented large scale software systems at many well-known global organisations - ranging from high-speed financial systems, to consumer electronics in millions of people's front room.

He has over twenty years of professional software design experience, and is often invited into software projects to help them refactor both the large and small scale design of the software - to enable safe iterative and incremental software delivery.