Java In-Depth: Become a Complete Java Engineer!
4.4 (8,988 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
43,994 students enrolled

Java In-Depth: Become a Complete Java Engineer!

Comprehensive Java programming course integrated with design principles, best practices & instructor-led Java EE project
4.4 (8,988 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
43,994 students enrolled
Created by Dheeru Mundluru
Last updated 4/2020
English
English [Auto-generated], Italian [Auto-generated], 1 more
  • Portuguese [Auto-generated]
Current price: $48.99 Original price: $74.99 Discount: 35% off
21 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 63 hours on-demand video
  • 18 articles
  • 282 downloadable resources
  • 15 coding exercises
  • Full lifetime access
  • Access on mobile and TV
  • Assignments
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Gain in-depth understanding of core & advanced features of Java including JVM internals
  • Master design principles, best practices and coding conventions for writing well-designed, professional Java code
  • Get real-world experience by developing an instructor-led Java EE-based Web application using technologies like JSP, Servlets and MySQL
  • Set firm foundation in Java for the rest of your career. That's a promise!
  • Master Object-Oriented Programming concepts by using a real-world application as a case study
  • Master Exceptions, IO, Collections Framework, Generics, Multi-threading, Databases, etc. with best practices
  • Solid understanding of Functional-style Programming using Java 8 constructs like Lambdas & Streams
  • Set yourself up to become an Oracle Certified Associate, Java SE 8 Programmer (1Z0-808)
Course content
Expand all 350 lectures 63:45:40
+ Java: A High-level Overview
17 lectures 02:35:28

This lecture gives a high-level overview of what Java is and what aspects of it make it a truly complete and one of the most widely used programming languages. The lecture also highlights how Java is being used in the industry by organizations such as Google, Apple and NASA.

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 09:51

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

Platform Dependency + Demo
08:38

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

Interpreter
07:50

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

Preview 08:57

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
14:01

This lectures gives a good high-level overview of the Java SE platform

An Overview of Java SE
21:28
Java SE Release Cycles & Release History
06:49
Installing JDK 10 on Windows
19:13
Installing JDK 10 on Mac
04:46
Installing JDK10 on Linux
06:52
Setting Classpath Environment Variable
09:20
Writing First Java Program + Demo
16:15
Conclusion
02:40
Chapter Quiz
5 questions
Important Q&A Discussions!
01:22
+ Classes, Objects and their Members
28 lectures 05:01:23

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 12:58

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

Demo: Absolute Java Basics
17:13

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
In this assignment, you will create a class, declare few variables and print their values. You can skip this assignment if you are familiar with Java programming.
Currency Converter - Creating a Class with Variables
1 question

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.

Primitive Variables: Integers + Demo
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 Data Type + Demo
11:27
Quiz: Variables
6 questions

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!

Arrays + Demo
11:25
In this assignment, you will modify the CurrencyConverter class that you created in previous assignment. You will be replacing the currency variables with a single array.
Currency Converter - Array Creation & Accessing it Elements
1 question

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 + Demo
20:51
Method Types + Demo
21:27
In this assignment, you will create a new class MoneyTransferService that will make use of CurrencyConverter class. You can skip this assignment if you are familiar with Java programming.
Currency Converter ~ Invoking Methods of an Object
1 question

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.

How Data is Passed to Methods in Java? + Demo
18:18

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 + Demo
10:21

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
Review of Exercise 1 Solution with Best Practices
21:43
Conclusion
03:38
Chapter Quiz
12 questions
Important Q&A Discussions!
07:29
+ Method Building Blocks: Operators & Control-flow Statements
25 lectures 04:39:17
Operators
04:09
Arithmetic Operators + Demo
22:13
Arithmetic Operation Rules + Demo
08:55
Quiz: Arithmetic Operators
3 questions
Demo: Comparison Operators
14:45
Logical Operators + Demo
28:14
Car Price Estimator ~ Coding Exercise for Comparison & Logical Operators
19:48
Car Price Estimator ~ Putting Comparison & Logical Operators into Action
1 question
Car Price Estimator - Exercise Solution
06:06
Bitwise Operators + Demo
09:24
Quick Note on Bitwise Operators with Boolean Operands
00:48
Bit Shift Operators
05:37
Quiz: Bitwise & Bit Shift Operators
4 questions
Control-flow: Demo: if-statement
18:05

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
Quiz: switch Statement
3 questions
Control-flow: Ternary + Demo
07:26
Control-flow: for Statement + Demo
11:57
Demo: More for Statement ...
21:54
Demo: for-each Statement (+ discussion on Item 46)
18:42
Variable Scope
05:16
Exercise
2 pages
Computing GPA ~ Putting Operators & Control-flow to Test
1 question
Control-flow: while Statement
03:26
Control-flow: break Statement + Demo
09:16
Control-flow: continue + Demo
05:08
Recursion + Demo
27:01
Conclusion
05:55
+ Packages, Strings and Information Hiding
18 lectures 02:43:48
Chapter Introduction
02:29

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
Creating Packages & Classpath Management + Demo
29:39

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

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
Important Q&A Discussions!
01:19
+ static, final, and Coding Conventions
16 lectures 02:06:53
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
Important Q&A Discussions!
01:29
+ Serious OOP: Inheritance & Polymorphism
15 lectures 02:13:49

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
Minor Correction in First Method Overriding Rule
00:31

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
19 lectures 02:37:56

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
18:44
More on Interfaces
08:08

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
Chapter Quiz
7 questions
Important Q&A Discussions!
01:59
+ Programming with Eclipse IDE
12 lectures 01:35:45
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:14
Conclusion
00:43
Requirements
  • The 3 P's: Passion, Patience, and Perseverance. Please note it is not a crash course!!
  • Top Concentration. Over half-year of your self-study effort is packed into 63 hours. So, no fluff!!
Description

This Master Course has been meticulously developed for over 4 years and has over 40000 students from over 150 countries ranging from complete beginners to experienced Java professionals. Top companies like Intel, PayPal, Pinterest, Wipro are actively using this course to upskill their employees. It has been consistently ranked as one of Udemy's top 3 paid Java courses and has helped many students start their professional journey as "confident" Java programmers. Here is what some of the students had to say:

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

"... This one should be the best seller of all the other ... " ~ Brady Adams

"This is a wonderful course. The Instructor is highly competent. He is a world-class instructor ... Taking this course will definitely give you a tremendous appreciation for this great language." ~ Carrel d'Haiti

"I have bought so many courses but this course has been a game changer to me . It is in depth as the name says. It helped me pass a paid internship interview in a reputable company and now i am getting a job. Thank you so much Dheeru Mundluru for releasing such a great course. You deserve 5+" ~ Stephen

"... 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

"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. ... 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

"The JVM internals section of this course itself is worth buying this course. Excellent teaching style." ~ Ryan Trang


Course Overview:

This course has been developed to just not teach core Java skills, but with a larger goal of helping you become a complete & professional Java engineer right by the end of this course. To realize this, it takes a holistic approach in teaching Java programming. To ensure that you master Java language, the course has been developed to be highly comprehensive covering most of the Java language features and discussing them at a very in-depth level. To further ensure you are industry-ready and can write well-designed, professional code, tons of best practices & design principles are explained and demonstrated in code. Towards this end, you'll also implement an instructor-led Java EE Web application using professional coding conventions with Eclipse as IDE. Finally, all your questions will receive in-depth personalized responses within around 24 hours. Over 5000 questions have been answered!


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, JVM internals, exceptions, IO, collections framework, generics, multi-threading, databases, nested classes, enums, and functional-style programming via Java 8 constructs like lambdas & streams. You'll also learn about database designing, implementation (SQL), and how to interact with them from Java programs (via JDBC). The course also gives a very good introduction to Java EE technologies like JSP, Servlets and JSTL, which help in project implementation. Finally, an excellent Eclipse IDE tutorial is also included, which teaches you how to use Eclipse professionally for effectively writing, debugging and even testing Java programs using the JUnit framework.

Each lecture has been very carefully crafted explaining the motivation behind every concept. Each concept is clearly explained with well thought out examples & illustrations and is demonstrated in code. Object-oriented concepts like inheritance & polymorphism are explained through a real-world case-study, which is also implemented as part of the course project. Several challenging coding exercises & quizzes are included to reinforce what you've learned. Your solutions for coding exercises are also auto-evaluated to help you instantly know whether or not the solution is correct.

The course project involves building a bookmarking Web application that helps users bookmark items like Books, Movies, and Web pages and is built progressively as new concepts are learned. The project is instructor-led and is implemented using professional coding conventions & best practices. It follows good object-oriented design, incorporates MVC architectural pattern and also uses Test-Driven Development (TDD) methodology. Java EE stack comprising technologies like Servlets, JSP, and JSTL are used for building the application with MySQL as the database and Apache Tomcat as the Web server. Parts of the project use advanced multi-threading capabilities.

Finally, course also teaches several best practices & design principles that are essential for writing well-designed code. This is one of the highlights of the course and will make you truly complete!


Story behind Creating this Course:

The idea for building this Master Course has taken its roots during the instructor's (Dheeru Munduru) experience as a software engineer in Silicon Valley. After working for several years with many excellent engineers, Dheeru realized that sometimes the teams he worked with fell short of developing effective solutions. This led to several rounds of "code refactoring" resulting in loss of valuable time. This he realized was due to programming not being taught in the right way at most Universities & Colleges across the world. Students are mostly taught core programming language features without any emphasis on best practices or design rules required for writing well-designed code. Due to this, developers are often ill-equipped when they have to come up with good solutions for complex problems. This leads to some quick ad-hoc & incomplete learning, which often not only result in bad solutions, but also more importantly causes lot of stress on developer's part. This made Dheeru realize that a more holistic approach to teaching is needed where programming language features are taught along with best practices & design principles needed for building well-designed robust software. This course is a result of this realization and it has taken him over 4 years of full-time effort (considered equivalent to over a decade if working part-time) in developing it. He will continue to devote himself in building this course towards making it one of the best Java courses out there.

Who this course is for:
  • 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!