Eclipse Guided Tour for Java

Learning a robust, extensible integrated development environment for Java is an essential skill. Eclipse is one that runs on Windows, macOS, and Linux. Get productive quickly and learn to leverage the power of the Eclipse Oxygen release.
Course info
Level
Beginner
Updated
Mar 2, 2018
Duration
3h 39m
Table of contents
Description
Course info
Level
Beginner
Updated
Mar 2, 2018
Duration
3h 39m
Description

Being an efficient developer requires a certain level of mastery over your tools. In this course, Eclipse Guided Tour for Java, you will gain the knowledge and expertise needed to efficiently utilize the tools at your disposal in Eclipse. First, you will learn how to leverage the major features of Eclipse. Second, you will discover how to customize your environment. Next, you will explore critical key shortcuts. Finally, you will gain insight into the design philosophy of Eclipse which will allow you to be well-prepared for other languages and future releases. At the completion of this course, you will have both a deeper understanding of how Eclipse is organized and a set of tips, tricks, and techniques that will make you more efficient and effective at both developing and maintaining code.

About the author
About the author

Tod has been programming anything he can get his hands on since 1980 when he accidentally discovered an Apple ][ at Argonne National Labs.

More from the author
Field Guide to Binary
Beginner
21m
Aug 1, 2018
Introduction to Ada 2012
Beginner
4h 12m
Jun 19, 2015
More courses by Tod Gentille
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hi, this is Tod Gentille. I'm in sunny Southern California. I don't know where you are, but I know you're watching the Eclipse Guided Tour For Java on Pluralsight. And whether you're new to Eclipse or you've been using it for years, I'm going to show you some tricks you didn't know existed, so stick around. Investing some time in learning just how powerful the Eclipse IDE is will pay you dividends for years to come. While this course will focus on using Eclipse in Java, Eclipse supports many other languages, an that's an advantage Eclipse has over many other Java IDEs. The extensible nature of Eclipse means it can easily keep up and adapt to all the latest development tool changes. A large community behind Eclipse means you get regular updates and support for all the latest tools. Now in this course, we're going to explore the details of the workbench itself, editing tips, customizing Eclipse, how to navigate and search, and how to type less and code more with the powerful refactoring code generation and other tools hiding inside Eclipse. By the end of this course, you'll feel at home in Eclipse, be more productive, laugh out loud when someone asks you what's this quick access feature all about, and you'll know the most important techniques for exploring and discovering more on your own. Let me be your docent, and let's get started on our Eclipse Guided Tour For Java.

Getting Started
Welcome to the Eclipse Guided Tour Course. My name is Tod Gentille. This course is designed to make you quickly productive in the Eclipse integrated development environment. Eclipse is a very capable and sometimes complex product. For flexibility, it's designed on a plug-in architecture. This makes it extremely useful for software development for a wide variety of languages and target platforms. So even though you're learning it for Java, your investment here can pay off many times over. It's used for desktop programs, embedded programs, web page development, and even mobile platform development. In this module, we'll explore getting started and a little bit about the Eclipse architecture.

Exploring the Eclipse Workbench
Welcome back. This is Tod Gentille. In this module, we're going to take an in-depth look at the Eclipse Workbench. I want you to have a good overview of how Eclipse is laid out and designed to work, so that you can maximize your productivity once you start developing with Eclipse. In this module, you first want to be aware of the terms Eclipse uses for various facets of the IDE. This will allow you to recognize the choices you'll need to make in menus and toolbars, but the majority of this module will be spent in Eclipse itself. Two of the basic building blocks of Eclipse are views and perspectives. A view is the Eclipse name for a unique content area that accomplishes a given task. Package Explorer, Outline, and the Console are examples of three views. A perspective is just the layout of a particular collection of views. As soon as we open Eclipse, we are in a particular perspective. There are some useful built-in perspectives including the default that we've already seen, one for browsing code, one for debugging, and one for source code management with Git. There are other preexisting perspectives, and you can create more and customize the existing ones. We're about to jump back into Eclipse and look at some of the basics of views and perspectives, but we'll also look at some of the basic view of Chrome, so you understand how quickly the layout of Eclipse can change on you. Since Eclipse is used to develop software, we will take our turn at producing the mandatory Hello World example. I'll conclude with a look at the Quick Access feature of Eclipse. I like to think of Quick Access as the one feature to rule them all. Quick Access will let you do almost anything in Eclipse without lifting your hands from the keyboard. If you're going to memorize or reassign a keyboard shortcut, this is the one. Let's go to Eclipse.

Digging Deep into the Project/Package Explorer
Welcome to the Project Explorer module of the Eclipse Guided Tour. This is Tod Gentille. We're going to take an in-depth look at the Project Explorer and some associated tasks. Project Explorer is easier to demonstrate if we have a large number of files, so we'll download the JUnit5 source code. Once we have the source code, we'll switch over to Eclipse, and look at some context-sensitive actions you can take on the Explorer view itself and on the folders and files inside that view. Most of these actions are applicable to software development in multiple languages. We'll take a brief look at the iconography used by Java, and I'll show you where to find the comprehensive list of the icons used. Java has a couple of extra views, the Project Explorer and Navigator view, and we'll briefly look at those. We'll also develop our first external tool to allow us to quickly navigate to any source file in the Explorer. This will work for Mac, but Windows and Linux users should be able to quickly adapt it to those operating systems. We'll finish up this module with a look at working sets.

Editing Code
Welcome to the Editing code module of the Eclipse Guided Tour. This is Tod Gentille. We're going to dig into the text editor in this module, and look at multiple ways that Eclipse can improve your productivity. We'll start with the editor view itself, and look at some of the options for customizing the layout of that view. Then we'll talk about Eclipse Content Assist feature. If you've ever used Visual Studio, Content Assist is similar to the IntelliSense feature of Visual Studio. In addition to Content Assist features, Eclipse can do real-time code analysis for you. Code analysis will find most of your compiler errors and even some legitimate, but suspect code before you ever build your project. Sometimes code analysis might have different ideas about valid code than you, so we'll look at how to bend it to your will. We'll dig into the Editor Preferences pane. We'll also take a look at a feature that under certain circumstances is extremely useful, but easy to forget about, block editing mode. In the Editor view, we'll start with editor tabs, how to move tabs around and tile the editor in the various configurations. We'll also examine the double-clicking behavior of a tab, and how the layout configuration affects that behavior. We'll finish up with what happens when you have too many editor tabs for a given editing pane. We'll then look at the Code Folding region and Marker Bar regions of the editor. Inside the Marker Bar, we'll look at three functional areas, tasks, bookmarks, and breakpoints. We'll finish up the Editor view with the highlighting that happens in the Marker Bar and a unique feature of Eclipse, Show Source of Selected Element Only.

Customizing Eclipse
Welcome to the Customizing Eclipse module. This is Tod Gentille. We're going to look at some common ways you can customize Eclipse to suite your working style. We'll start with a look at the major operations you can perform on perspectives, and we'll examine the various ways you can customize the toolbar. We'll also look briefly at that closely-related menu customization. Then we'll look more in depth at keyboard shortcuts. We've already assigned a couple of shortcuts, but we'll look at all the details of the process and the various options that are available. We'll explore some of the additional views that are available in Eclipse, and look at a couple that you might find useful. Finally, we'll look at the facilities for importing and exporting your settings, so you can take your customizations along with you to a new machine or to a new version of Eclipse. There are four major operations you can perform on a perspective. You can modify an existing perspective, add a new perspective, switch among perspectives, and delete a perspective. Well okay, there are five major operations, because you can also reset a perspective to its initial state, but my robot only has four fingers. Let's just go to a demo and look at these operations.

Navigating Code
Welcome to the Navigating Code module. This is Tod Gentille. There are many, many ways you can navigate around your code in Eclipse. I'm amazed how often I see developers doing things the hard way in Eclipse simply because they don't know about all of the powerful features offered. Luckily, you won't be one of those developers. I've broken code navigation up into two modules. In this module, we'll cover the basic code navigation techniques that I think you'll find useful in your daily work. Even though I'm calling them basic, there are a lot of tools and techniques here that you really should know. In the next module, we'll look at some more advanced techniques that I think you'll still use pretty frequently. We'll start with a look at the navigation menu, and navigating to resources from the Project Explorer and similar views. The navigation menu is context aware, so the options will change based on what portion of Eclipse has the current focus. We'll look at both navigating to resources, which lets us see where resources reside in the project, and the ability to directly open a resource by name. One of my favorite features of Eclipse is how hovering is implemented. We'll look at how that works and how to customize it. There are two very similar outline windows in Eclipse, the Outline view, which is a dockable window and the Quick Outline view, which is a pop-up window. We'll see how to use both of these and look at navigating, filtering, sorting, and the moving capabilities of both those views. We'll also look at the very useful capabilities of navigating with the editor history. Navigation can also be done by annotation, so we'll also see how that is done and how to customize it. Finally, we'll take a look at the Breadcrumb feature that lets us both see where we are and allows us to navigate to almost anywhere else in the current project. Let's go over to Eclipse and get started.

Searching and Navigating with More Power
Welcome to the Searching and Navigating with More Power module of the Eclipse Guided Tour. This is Tod Gentille. There are various code navigation features that showed up in earlier modules, but didn't get expressly mentioned. So these old friends are going to help us power up our navigation. This includes techniques for searching a single file, multiple files, and even for files that aren't part of your workspace. And if you've been wondering about the bar on the right-side of the editor, we're finally going to highlight and explain the purpose of the overview ruler. We'll sum up with a look at how you can quickly jump to any build errors or warnings in your code to correct them.

Making the IDE Work Harder for You
Welcome to Making the IDE Work Harder for You, the final module of the course. This is Tod Gentille. Congratulations on making it this far. You deserve to kick back and relax. Let me take this opportunity to remind you about the course discussion board, and to remind you that you can rate the course. I'll also sneak in another reference to the course channel I set up, in case you forgot. It's a shortened bit. ly link, eclipse_java. In this module, we're going to take a look at a variety of features, some of which really elevate Eclipse into being a top-tier IDE. We'll start with shortcuts, some tips for picking up shortcuts, and mention a few less-obvious shortcuts that are worth knowing about. I'll also give the Mac users a reward for making it this far, and show you another way you can quickly type those odd Mac symbols into the key preferences dialog. There are also some general tips and tricks that didn't fit nicely into any other category, so we'll cover a handful of those in this module. The order you do things can affect how helpful Content Assist is, so we'll talk briefly about imports. Any time you find yourself typing a similar code pattern more than once, you should consider code templates instead, either through using the built-in templates or creating your own. We'll also look at code generation. You can think of code generation as code templates that know a few extra tricks. Automated refactorings can be a huge time savor, we'll talk about them in general, but we'll only have time to go over a few of them. We'll look at how to create your own code format profile, so you can take full advantage of the automated source code formatter. And we'll finally take a look at the built-in and online help. Next up, some key things you need to know about shortcuts.