Java In-Depth: Become a Complete Java Engineer!
4.6 (1,154 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.
5,674 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Java In-Depth: Become a Complete Java Engineer! to your Wishlist.

Add to Wishlist

Java In-Depth: Become a Complete Java Engineer!

Comprehensive Java programming course integrated with design principles, best practices, demos & instructor-led project.
4.6 (1,154 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.
5,674 students enrolled
Created by Dheeru Mundluru
Last updated 9/2017
English
English [Auto-generated]
Current price: $70 Original price: $120 Discount: 42% off
30-Day Money-Back Guarantee
Includes:
  • 46 hours on-demand video
  • 6 Articles
  • 154 Supplemental Resources
  • 12 Coding exercises
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion

Training 5 or more people?

Get your team access to Udemy's top 2,000 courses anytime, anywhere.

Try Udemy for Business
What Will I Learn?
  • Get an in-depth understanding of core & advanced Java
  • Master design principles, best practices and coding conventions for writing well-designed, professional Java code
  • Implement instructor-led, industry-strength multi-threaded project in Eclipse using TDD principles & MVC design pattern
  • Set a firm foundation in Java for the rest of your career. You'll be a solid Java engineer by the end of this course.
  • Gain comprehensive understanding of JVM Internals ~ the incredible platform on which Java programs run
  • Set yourself up to become an Oracle Certified Associate, Java SE 8 Programmer (1Z0-808)
View Curriculum
Requirements
  • Familiarity in using computers
  • The 3 P's: Passion, Patience, and Perseverance. Please note it is not a crash course!!
Description

Update on July 27th, 2017: A new section on Date & Time API has been added. Includes both legacy and also the new API from Java 8. Includes a challenging coding exercise too.

What Students are Saying About This Course:

"This is by far the best advanced as well as beginner course I have ever read/seen since Andre LaMothe quit writing." ~ Stephen Jonson

"Got a job thanks to this course!" ~ Connor Lee

"This is THE best course on Java on Udemy - Period! Dheeru is not only passionate about what he is coaching but also OBSESSIVE and covers every minute detail of the subject ... Most lessons have demos which Dheeru makes sure that they do work without any glitches. He is a genius coder ... Plus, he bases the course on the best practices from the book "Effective Java" which is great. You get to cover most of this book if you study this course! ... Lastly, he uses an accurate and powerful English vocabulary I'm yet to see from other instructors. If you want to learn Java right from installing, configuring and all the way to mastering its advanced topics - look no further - you are at the right place => THIS - IS - IT !!!" ~ Richard Reddy

"This is a wonderful course. The Instructor is highly competent. He is a world-class instructor. I highly recommend this course to anyone who seriously wants to learn Java the right way or who desires to refurbish his or her Java skillset. Taking this course will definitely give you a tremendous appreciation for this great language." ~ Carrel d'Haiti

"... the most in depth Java course I've seen offered anywhere. I would suggest that this course is not only for the beginner but for the intermediate Java developer that wants to ensure their knowledge..." ~ Zenko Machina

"This is a fantastic course. I am a Java developer with over 10 years experience and soon to be looking for a new role. I wanted to brush up on all core Java concepts and this course goes way beyond what I was expecting. Particularly liked the Generics chapter and Collections though everything is covered in this course. Great course with awesome content and very well delivered and explained. Very happy." ~ Tony Perrin

"The best java course ever!" ~ Hamid Seleman, Senior Developer

"This course has so much depth and the Instructor is passionate, even weekly adding content to the course. I have been a Java developer for 8 years and hold a Masters degree in Computer Science ... This is honestly the very best online Java video course on the market... wish I had have had a course like this when I first started" ~ Clive Stewart

"Clear to understand, even for non-native English speaker. In depth explanation. I'd recommend not to skip familiar things, as you may learn some new insights." ~ Paul Kerkum

"I love this course for how comprehensive it is, how sincere and to the point the presenter is. For a newbie to Java, this should be the go to course...." ~ JSusan Koinonia

Course Overview:

Would you like to just acquire core Java skills or would you like to become a complete and a professional Java engineer right at the end of the course. If it is the latter, then you should read on ...

This comprehensive project-based course has been designed with following objectives:

  • To help you get an in-depth understanding of both core & advanced concepts in Java
  • To teach best practices & key design principles for writing effective Java programs
  • To help you gain practical experience in writing professional-level code via instructor-led implementation of a project. Project is implemented in Eclipse using MVC design pattern, TDD (Test-Driven Development) principles and other best practices. Project also incorporates few advanced multi-threading concepts.
  • To help you understand the inner workings of Java platform (aka JVM)
  • To teach how to effectively use Eclipse IDE to write, debug, and test Java programs


The motivation behind these objectives is to help you in becoming a complete & industry-ready engineer. Most Java courses focus only on teaching core fundamentals, which at the very best equip students with good basic skills to work on small-to-medium sized projects. Most of these students fall short when it comes to implementing more complex projects. To design elegant solutions for large, complex projects one needs to have a much deeper understanding of language features along with knowledge of the recommended best practices & design principles. More importantly one needs to know how to put all of these into practice. This comprehensive one-stop project-based course has been designed to equip students with these skills.

Course Specifics:

This course begins by giving a birds-eye view of Java covering everything from origin of Java to installing Java and writing your first Java program. Even the most fundamental concepts like compilation & interpretation are explained. All other topics are covered in-depth starting from language basics, object-oriented concepts & design (including Java 8 features like default & static methods in interfaces), JVM, exceptions, IO, data structures, generics, multi-threading, nested classes, enums and lambdas.

Each lecture has been very carefully crafted. Motivation behind every concept is clearly explained with well thought out examples and nice animations. Object-oriented concepts like inheritance & polymorphism are explained through a real-world case-study, which is also implemented as part of the course project. Every concept has been well-tested through ready-to-run, downloadable demo programs, which are implemented and executed in the course. Every chapter ends with a carefully crafted quiz to test what was learnt. Many chapters also include challenging coding exercises and student solutions are also auto-evaluated via JUnit scripts, i.e., students would instantly know whether their solution is right or wrong. One of the coding exercises is on Sentiment Analysis, which is a hot area in the industry.

The course project simulates a real-world product that is based on bookmarking concept. The project is instructor-led and is implemented using professional coding conventions & best practices. It follows good object-oriented design, incorporates MVC design pattern and also uses Test-Driven Development (TDD) methodology. Parts of the project use advanced multi-threading capabilities. Eclipse IDE is used for developing the entire project. There is also a separate dedicated chapter just for learning Eclipse IDE, which would give you a solid foundation in using Eclipse to effectively write, debug, and test Java programs. The chapter includes lessons to use Eclipse's debugger & JUnit unit testing framework.

Finally, the course also discusses over half of the best practices/design rules outlined in the popular Effective Java book. Many rules are actually demonstrated in code. This is one of the highlights of the course and will make you truly complete!


About the Instructor & On His Motivation for Building This Course:

I have around 15 years of experience in Java developing complex data integration & mining software for start-ups in silicon valley and elsewhere. After working for so many years with many excellent engineers, I realized that sometimes we fell short of developing the most effective solutions to some of the problems we were dealing with. This sometimes led to several rounds of refactoring resulting in loss of valuable time. This made me realize that it was a result of not being taught Java programming in the right way. I realized that a more holistic approach to teaching Java is needed where the language features are taught along with best practices & design principles that any serious developer must know. This course is a result of this realization and it has taken me around 3 years of full-time effort (considered equivalent to a decade if working on a part-time basis) in developing it. Building this course itself has been a wonderful journey for me and I hope you will also find this course to be equally enriching. I will continue to devote myself in building this course towards making it one of the best Java courses out there. Always, feel free to message me if you have any questions and I promise to address them as quickly as I can (almost always well within a day :)).


Who is the target audience?
  • Complete beginners. We got you covered. We'll start from compilation & interpretation.
  • Programmers switching from other languages
  • Java programmers who are not feeling confident about their existing Java skills
  • Java programmers who want to learn about design principles & best practices. Any serious programmer should know this stuff!
Curriculum For This Course
288 Lectures
45:55:26
+
Java: A High-level Overview
13 Lectures 01:29:16

This lesson discusses the core attributes and principles of Java.

Preview 06:42

Java has some unique features compared to other languages like C & C++. There is a certain motivation behind creating Java with those features instead of using a language like C++. In this lesson, we look at the story behind Java's creation. Interesting and an important history. Do check it out!!

Story behind Java's Creation ~ A Brief History
07:36

In this lesson, we will discuss about the compilation process. Very useful for absolute beginners. The lesson starts from absolute basics like machine & assembly language.

Preview 06:17

In this lesson, we will look at the platform dependency behavior of compiled languages like C.

Preview 02:19

In this lesson, we will learn about interpreters and how they make platform independence possible. 

Interpreter
07:53

In this lesson, we will learn how Java achieves platform independence without compromising on speed!

Preview 03:54

This lesson discusses JVM, which is the soul of Java. This lesson gives a good, high-level overview of JVM. JVM internals chapter will cover JVM at an in-depth level.

Java Virtual Machine
12:28

This lesson introduces Java SE platform and how it evolved over the years since its first release in 1996. Also, explains what JRE & JDK mean.

Preview 08:34

In this lesson, we will download & install Java on a windows machine. Resources section provides links that explain how it can be done on Linux & Mac.

Installing Java
13:05

Setting Classpath Environment Variable
04:11

Finally, in this lesson, we write our first Java program, compile and execute it. We will be writing tons of such programs in this course.

Writing First Java Program + Demo
10:29

Conclusion
02:40

Chapter Quiz
5 questions
+
Classes, Objects, and their Members
26 Lectures 03:31:41

This lesson very clearly explains what a class and an object is. After conceptually explaining them, we will see how they are represented in code.

Preview 08:21

This lesson introduces some absolute fundamentals for writing Java programs, e.g., how to print text onto console.

Absolute Java Basics + Demo
07:21

This lesson introduces variables. We will see how they are declared along with a discussion of static & dynamic typed languages!

Variables: Introduction
07:21

Variables can be of different kinds and we will learn about them in this lesson.

Variable Kinds
05:30

Java supports 8 primitive data types and we will see what those are.

Variables: Primitive Types
02:00

This lesson introduces all the integer data types. We will look at several examples and finally we will do a short demo too.

Preview 14:16

This lesson introduces the data types that represent floating point numbers. Some general rules of thumb with regards to floating point numbers & integers are also discussed (includes a recommendation from Effective Java).

Primitive Variables: Floating-point Numbers + Item 48
05:26

This lesson introduces the data types that represent characters & boolean values. A demo is also included.

Primitive Variables: Character & Boolean Types + Demo
12:39

To assign a variable of one type to a variable of another type, we need type casting, which is the subject of this lesson. Everything is demonstrated at the end of the lesson.

Variables: Type Casting + Demo
19:25

Variables: Object References
03:00

Statements + Demo
07:40

This lesson introduces our first data structure of the course, which is an Array. It is very in-depth and you will learn everything you need to know about an array. Lesson ends with a short demo. Very important lesson!

Preview 11:25

In the last lesson, we learnt about one dimensional array. Here, we will learn about two dimensional arrays, which is useful for representing things like matrices.

2D Arrays
07:22

Continuing our Array series, this lesson explains how to build a 3D array. This is just to help us get a firm grasp of Arrays. But, to keep it interesting, we use a data warehouse example.

3D Arrays + Demo
05:20

This lesson gives a very detailed introduction to methods. We will see how methods are declared and how they are invoked. Finally, we will also discuss some of the benefits that we get due to methods.

Methods: Introduction
09:28

Method Types
02:42

This is a very important and a very fundamental lesson. It explains how data is passed during method invocation. To understand it clearly, we also look at how variables (both primitives & object references) are represented in memory. Demo is included couple of lessons down the line.

Methods: How Data is Passed to Methods in Java?
12:21

This lesson introduces an important feature called method overloading, which allows us to maintain different versions of the same method, i.e., method names would be same, but parameters would vary. Demo is included in the follow-up lesson.

Method Overloading
03:46

Demo: Let's Test it All ~ Defining Methods, Pass Data and Method Overloading
04:24

This lesson discusses varargs parameter, which is a type of parameter that methods can have. It can give an illusion that methods are infinitely overloaded.

Methods: varargs + Demo
08:39

In this lesson, we will learn about constructors, which are typically used for initializing object state.

Constructors + Demo
16:12

In this lesson, we will look at 'this' reference, which can be used by objects to access their own variables & methods. But, that can be done directly accessing those variables & methods too. So, watch the video to learn where 'this' reference is really helpful.

this Reference + Demo
05:17

In this demo, we will implement a slightly extended version of the Student example, which we saw in the beginning of the chapter. Many of the concepts that we learnt in this lesson like arrays, constructors, this reference, etc. will be put to use.

Demo: Student Example
16:21

Demo: Reinitializing Object References ~ More Brainstorming!
09:45

Arrays with Object References
1 question

Conclusion
03:38

Chapter Quiz
17 questions
+
Method Building Blocks: Operators & Control-flow Statements
21 Lectures 02:16:29
Chapter Introduction
02:52

Operators
02:53

Arithmetic Operators
04:42

Arithmetic Operation Rules + Demo
08:55

Comparison Operators
06:00

Logical Operators
08:16

Demo: Comparison & Logical Operators
06:53

Bitwise Operators + Demo
09:24

Bit Shift Operators
05:37

Control-flow: if-statement
04:06

In this lecture, a control-flow statement called switch is introduced. switch in certain situations can be used as an alternative to if. To get a very clear understanding of switch syntax, we first take an example of an if-statement and gradually build the corresponding switch syntax comparing with the switch. A demo is also included.


Control-flow: switch + Demo
18:04

When is switch Preferred?
03:36

Control-flow: Ternary + Demo
07:26

Control-flow: for Statement + Demo
11:57

Item 46: Prefer for-each loops to traditional for loops
06:36

Computing GPA ~ Putting Operators & Control-flow to Test
1 question

Control-flow: while Statement
03:26

Control-flow: break Statement + Demo
09:27

Control-flow: continue + Demo
05:08

Variable Scope
05:16

Exercise
2 pages

Conclusion
05:55

Chapter Quiz
11 questions
+
Packages, Strings and Information Hiding
18 Lectures 02:28:11

This lesson gives a detailed introduction to Java API. Particularly, it introduces the concept of package, which is central to the organization of any API. We will next browse through the Java API on Oracle's Website. We will also briefly discuss about some of the popular open source 3rd party Java API. Finally, an Effective Java item will also be discussed.

Java API + Item 47 (Know and use the libraries)
09:21

This lesson will show you how to access classes in a package. There are different alternatives for this and all of them are covered. The lesson also you, which alternative is preferred. Finally, everything is tested out in code.

Accessing Packages + Demo
16:41

We now know what packages are and how we can access the classes they contain. In this lesson, we learn how to create a package using a demo. The demo also shows how class files can be created separately from the source code file, which is how it is maintained in a professional environment.

Creating Packages + Demo
12:48

Finally, we end our discussion on packages by looking at how we should name packages. Through an example, we will look at an issue that we may encounter due to bad naming convention. We will also look at a recommendation from an Effective Java item, which talks about naming conventions for packages.

Naming Packages
04:18

A Brief Note on Path & Classpath Environment Variables
02:33

One of the most commonly used features in Java are Strings. In this lesson, we will see how Strings are created.

Strings: Introduction
05:44

This lesson introduces the String class and we will explore several of its most commonly used methods through a demo.

String Class + Demo
19:46

This lesson gives you under-the-hood details on string creation. Specifically, we will discuss string pool, which is an area of heap where string objects declared via String literals are stored. At the end, we will test the concepts learned through a demo program.

String Pool & Interning + Demo
15:51

We know that a string is an immutable sequence of unicode characters. In this lesson, we will see what exactly string immutability is and why it was kept that way.

String Immutability
03:29

In this lesson, you will learn about string concatenation. We will see how strings can be concatenated using + operator. We will also see how string concatenation can be done using StringBuilder class.

String Concatenation + Demo
10:32

This lesson is about Effective Java item 51, which talks about the performance implications of using + operator. It is very important that you understand this. Otherwise, you may end up using + operator in a wrong way and end up writing inefficient code!!

Item 51: String Concatenation Performance
03:15

This lesson introduces escape sequences, which are important in inserting special characters in string & character literals.

Escape Sequences + Demo
04:50

Sentiment Analysis: Mining Pros & Cons ~ Putting String Class to Test
1 question

This lesson introduces access levels, which play a critical role in building well-designed software. They aid in Information Hiding, which is an important design principle that we will see next.

Access Levels
09:09

This lesson introduces us to Information Hiding, which is an important design principle for writing well-designed software. It uses access modifiers as the underlying tools. Couple of Effective Java items will be discussed in understanding this topic.

Information Hiding - Item 14: Use accessor methods, not public fields + Demo
10:58

Information Hiding - Item 13: Minimize the accessibility of classes and members
03:49

In this demo, we enhance the Student example we wrote earlier to incorporate Information Hiding principle that we learnt in the previous lesson. Specifically, we incorporate suggestion from Effective Java item 14 that suggests never to expose instance fields as public fields.

Demo: Student Example with Information Hiding
05:36

Conclusion
07:02

Chapter Quiz
6 questions
+
static, final, and Coding Conventions
15 Lectures 02:05:24
Chapter Introduction
02:28

Static Methods + Item 4: Enforce noninstantiability with a private constructor
07:10

Math Class + Demo
08:30

Static Variables + Demo
07:25

Initializers: Static & Instance + Demo
07:44

final Variable + Demo
09:44

Constant Variables + Demo
10:22

Boxed Primitives
10:46

Autoboxing + Demo
04:25

Item 49: Prefer Primitives to Boxed Primitives + Demo
11:37

Parsing API Response ~ Let's make use of Boxed Primitives & String class
1 question

Coding Conventions: Naming (Item 56: Use generally accepted naming conventions)
10:04

Coding Conventions: Structuring Programs (Item 45: Minimize the scope of local)
07:31

Coding Conventions: Stylistic + Demo
06:39

Coding Conventions: Comments + Demo
13:12

Conclusion
07:47

Chapter Quiz
4 questions
+
Case Study: A Social Bookmarking Application
2 Lectures 14:30
+
Serious OOP: Inheritance & Polymorphism
14 Lectures 02:13:18

This lesson introduces one of the fundamental features of OOP, which is inheritance. We will also learn what benefit we get from it and how it can be expressed in code although demo is included in the follow-up lesson.

Inheritance
08:27

Access Modifiers & Inheritance + Demo
12:27

IS-A Test
04:07

Hospital Management System (HMS) ~ Let's put Inheritance into practice!
1 question

This lesson introduces another fundamental feature of OOP, which is polymorphism. We discuss the benefits of it. At the end, we also do a demo of what we learnt!

Polymorphism + Demo
12:35

Casting Objects & instanceof Operator + Demo
10:06

Extending HMS with a Billing Component ~ Putting Polymorphism into Practice!
1 question

Java is considered a type safe language and in this lesson we will see why it is called so.

Type Safety
07:27

In this lesson, you will learn about how to redefine a superclass method's behavior from a subclass.

Method Overriding + Demo
14:49

This lesson is about how method invocations are handled within Java. In the demo, we will actually look at the bytecode to understand the whole process. This is very important topic, but is often ignored by most books & courses.

Method Binding + Demo
17:03

In this lesson, we will see what cannot be overridden.

What is Not Overridden? (final Method is one of them) + Demo
14:17

Demo: Fields are Not Overridden
03:03

In this lesson, we will learn about Object class, which is the mother of all classes!

Object Class + Demo + Item 10: Always override toString
07:52

Constructor Chaining + Demo
08:33

This entire chapter was about inheritance. However, sometimes we might want to do the opposite, which is to prevent inheritance. In this lesson, we will see why we would want to prevent inheritance and also how that can be achieved.

Preventing Inheritance
05:30

Conclusion
07:02

Chapter Quiz
10 questions
+
More Serious OOP: Abstract Classes & Interfaces
17 Lectures 02:22:39

We begin the chapter by looking at a new requirement in our case study. This requirement would lead us to learn about another important object-oriented feature. Watch the video to find out what the new feature is :)

New Requirement: thrill.io for Kids
06:14

In this lesson, we will learn about abstract classes and abstract methods. A short demo is included at the end of the lesson.

Abstract Classes & Methods + Demo
06:27

Item 20: Prefer class hierarchies to tagged classes
05:58

Computing Health Insurance Premium for Staff ~ Let's put Abstract Classes & Methods into practice!
1 question

New Requirement: Sharing Bookmarks
05:20

Multiple Inheritance & Diamond Problem
04:08

In this lesson, we will learn all about interfaces. Very important lesson it is!

Interfaces
13:34

This lesson demonstrates most of the stuff we learnt in the previous lesson about interfaces.

Demo: Interfaces
11:23

We learn about interfaces from a syntax standpoint. Now, we will learn about how interfaces are actually used from a conceptual standpoint.

Interfaces: A Conceptual View
07:50

Item 18: Prefer interfaces to abstract classes
07:56

Item 52: Refer to objects by their interfaces
03:20

Computing Health Insurance Premium for Staff (Part 2) ~ Let's put Interfaces into practice!
1 question

Marker Interfaces
06:44

Cloneable Interface + Demo
06:03

default Methods (Java 8) + Demo
18:51

Recap of default Methods
04:17

default Methods: Other Benefits + Demo
10:09

Static Methods in Interfaces + Demo
11:48

Conclusion
12:37
+
Programming with Eclipse IDE
12 Lectures 01:35:54
Introduction
02:10

Installing Eclipse
05:31

Writing a Java Program in Eclipse
11:00

Eclipse Build Process
11:13

Importing Demo Code
05:26

Source Code Navigation
10:34

Automatic Source Code Cleaning & Generation
10:30

Code Refactoring
02:46

Using Eclipse Debugger
17:35

JUnit & Debugging
18:03

Shortcuts Cheat Sheet
00:23

Conclusion
00:43
12 More Sections
About the Instructor
Dheeru Mundluru
4.5 Average rating
1,200 Reviews
5,872 Students
3 Courses
PhD, CTO & Principal Instructor at Semantic Square

A passionate software engineer and instructor, Dheeru has around 15 years of experience developing innovative software for start-ups in silicon valley and elsewhere. He is considered as one of the top instructors on Udemy and has reached out to thousands of students from over 100 countries. He holds a Ph.D. in Computer Science from University of Louisiana at Lafayette (USA). His expertise includes developing complex Web data integration & mining software with Java as the main programming language. Coming from the start-up world, he also has extensive end-to-end experience in developing Web applications using frameworks/tools such as Spring, Hibernate, Solr, MySql, etc. Dheeru is passionate about developing products that are easy-to-use, intelligent, and well-architected. Writing well-crafted code that follows the best design practices is of utmost importance to him. He brings the same level of passion and completeness to his teaching. Every concept is covered at a very in-depth level clearly explaining the motivation behind their introduction. He strongly believes in "learn by involving" teaching principle and thus his courses involve tons of live demos, an industry standard project, coding exercises that are auto-evaluated and several quizzes. Prior to his current gig at his start-up Semantic Square, Dheeru worked for around 5 years as a Principal Engineer for NimbleCommerce, an e-commerce start-up in Santa Clara, California. Before NimbleCommerce, he worked as a Research Scientist at Local Corporation, a local search company in Irvine, California. He also published and presented half-a-dozen research papers at top conferences and workshops such as International Conference on Data Mining (ICDM) and Geographic Information Retrieval (GIR). During his graduate-school days, as a teaching assistant for Search & Data Mining courses, he designed course assignments and often gave guest lectures on Web data mining.