Java In-Depth: Become a Complete Java Engineer!

A comprehensive Java course integrated with time-tested design practices, live demos, and an industry-strength project.
4.6 (289 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.
1,579 students enrolled
$19
$85
78% off
Take This Course
  • Lectures 252
  • Exercises 4 coding exercises
  • Length 36.5 hours
  • Skill Level All Levels
  • Languages English
  • Includes Coding Exercises New!
    Lifetime access
    30 day money back guarantee!
    Available on iOS and Android
    Certificate of Completion
Wishlisted Wishlist

How taking a course works

Discover

Find online courses made by experts from around the world.

Learn

Take your courses with you and learn anywhere, anytime.

Master

Learn and practice real-world skills and achieve your goals.

About This Course

Published 6/2016 English

Course Description

Update on November 3rd, 2016: One new video "Generics Restrictions" has been added to Generics.

Few Representative Student Reviews:

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

"This is a very thorough and comprehensive course on Java. Probably 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

"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 course is very well done. ... This is honestly the very best online Java video course on the market.... I 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

----------------------------------------------------------------------------------------------------------------

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
  • 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 (including relevant Java 8 features), JVM, exceptions, IO, data structures, generics, multi-threading, nested classes, enums, and annotations.

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. Few of the chapters also include challenging coding exercises and student solutions are also auto-evaluated via JUnit scripts. 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 proper coding conventions & best practices. The project incorporates MVC design pattern and uses Test-Driven Development (TDD) methodology. The entire project is implemented using the popular Eclipse IDE. There is also a separate dedicated chapter just for learning Eclipse IDE. It will 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 several best practices/design rules outlined in the popular Effective Java book. 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 over 10 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 the best practices & design principles that any serious developer must know. This course is a result of this realization and it has taken me around 2 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.


What are the requirements?

  • Familiarity in using computers
  • The 3 P's: Patience, perseverance, and passion. Please note it is not a crash course!!

What am I going to get from this course?

  • Get an in-depth understanding of core & advanced Java
  • Write professional Java code following proper design principles & best practices
  • Confidently work on large, industry-standard projects. Yes, you'll be ready!!

What 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

What you get with this course?

Not for you? No problem.
30 day money back guarantee.

Forever yours.
Lifetime access.

Learn on the go.
Desktop, iOS and Android.

Get rewarded.
Certificate of completion.

Curriculum

Section 1: Course Introduction
Why Yet Another Java Course?
Preview
05:22
Course Structure & UI Controls for Site Navigation
Preview
10:30
Terms of Service & Copyright
Preview
Article
Section 2: Java: A High-level Overview
Chapter Introduction
Preview
02:00
06:04

This lesson discusses the core attributes and principles of Java.

06:23

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!!

06:17

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.

02:19

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

07:35

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

03:54

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

08:12

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.

06:36

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.

13:05

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.

10:29

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.

Conclusion
02:40
Chapter Quiz
5 questions
Section 3: Classes, Objects, and their Members
Chapter Introduction
02:02
08:21

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.

07:21

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

05:18

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

03:43

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

01:31

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

10:04

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

03: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).

10:04

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

09:18

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: Object References
03:00
Statements
03:15
11:25

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!

07:22

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.

05:20

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.

09:28

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.

Method Types
02:42
12:21

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.

03:46

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.

Demo: Writing Methods, Passing Data, and Method Overloading
04:24
08:39

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.

06:38

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

05:17

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.

08:28

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.

Arrays with Object References
1 question
Conclusion
03:38
Chapter Quiz
12 questions
Section 4: Method Building Blocks: Operators & Control-flow Statements
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
18:12

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.


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
10 questions
Section 5: Packages & Information Hiding
Chapter Introduction
02:29
09:21

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.

16:41

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.

12:50

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.

04:18

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.

A Brief Note on Path & Classpath Environment Variables
Article
05:44

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

10:06

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

12:48

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.

03:29

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.

10:32

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.

03:15

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!!

04:50

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

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

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.

10:58

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 13: Minimize the accessibility of classes and members
03:49
05:36

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.

Conclusion
07:02
Chapter Quiz
4 questions
Section 6: static, final, and Coding Conventions
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

Students Who Viewed This Course Also Viewed

  • Loading
  • Loading
  • Loading

Instructor Biography

Dheeru Mundluru, PhD, CTO & Principal Instructor at Semantic Square

A passionate software engineer and instructor, Dheeru has 10 years of experience developing innovative software for start-ups in silicon valley and elsewhere. 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, and several quizzes. Prior to his current gig at his start-up SemanticSquare, 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.

Ready to start learning?
Take This Course