Java In-Depth: Become a Complete Java Engineer! [2026]

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.

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

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.

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

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

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

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.

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

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.

This lesson introduces some absolute fundamentals for writing Java programs. We will learn about the valid ways for naming classes, variables, and methods in Java. We will see how to print text onto console, how to perform arithmetic operations like addition and subtraction, and how to disable code and to also write comments explaining the code.

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

In this lecture, we provide an in-depth demonstration of variable declaration and variable re-initialization. We will explore all the valid and invalid methods of performing these actions. Since Java is a statically-typed language, we will also conduct tests to illustrate its behavior.

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

This lecture introduces the four integer primitive data types in Java: byte, short, int, and long. We take an in-depth look at these data types including their bit depth (number of bits needed to represent them) and the range of values they support. We also discuss about int and long literals.

This lecture explains that int and long literals can be expressed in other formats like hexadecimal, binary, and octal.

This lecture introduces the two floating-point data types in Java: float & double. We delve into these data types, exploring their bit depths (the number of bits needed to represent them) and the range of values they can accommodate.

This lecture is important and it discusses the pitfalls involving float and double data types as they are not accurate.  The lecture suggests alternate approach when we need accurate results.

This lecture gives an in-depth introduction to char data type in Java. We discuss about how characters are internally represented in Java. We also discuss little bit about Unicode character set and UTF-16 encoding scheme.

This lecture discusses about what instance variables, static variables and local variables are. In this lecture, we will extend the earlier demo and we will create multiple objects each with their unique state.

This lecture shows that variables of the same type can be declared in a concise way by using a single declaration statement.

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.

In Java, a variable can be a primitive variable or an object reference. Primitive variables are already discussed in earlier lecture. In this lecture, we discuss what an object reference is.

In this lecture, we formally discuss about Statements. We discuss about the three kinds of statements we can have in Java.

Gives a very clear and in-depth introduction to arrays in Java. We look at the different ways to create an array. We will also see how we can create an array that stores only primitives and also an array that stores only object references.

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.

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.

This lesson gives a very detailed introduction to methods. We will see how methods in Java are declared and how they are invoked and the values they return are used. We also see how sometimes variable casting would have to be used. Finally, we will also discuss some of the benefits that we get due to methods.

In this lecture, we look at instance and static methods that a class in Java can have. We will see how object state can be changed via instance methods.

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.

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. We will also look at few method overloading examples in the Java library.

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.

This lesson introduces Constructor, which help in creating objects and even initializing their state. In demo, Student class is further improved by incorporating a Constructor that initializes state. Lecture also discusses about empty return statements.

This lecture discusses constructor overloading in Java and the need for it. Demo further improves on the Student class to incorporate overloaded constructors and the use of this() invocation for invoking an overloaded constructor. We also look at a class in Java library that has overloaded constructors.

In the previous lecture, we looked at how one or more constructors invoke a primary constructor. This lectures simply shows that a primary constructor in a class can invoke other constructor although this is not a common scenario.

This lecture introduces 'this reference' for accessing shadowed or hidden instance variables. The demo program Student class is further improvised to incorporate this reference.

This lecture includes another round of clear brainstorming on how object references behave when they are reassigned with other object references and also with brand new objects. The lecture also includes a nice assignment whose solution is demonstrated in the lecture.

Introduces the types of operators we have in Java, which will be discussed in the follow up lectures. Lectures also discusses unary, binary, and ternary operators.

Provides a comprehensive introduction to arithmetic operators including an in-depth discussion on pre & post arithmetic operators and compound arithmetic assignment operators. The lecture also shows how pre & post increment operators can be used in the context of arrays for manipulating array indices.

Introduces comparison operators (also referred to as relational operators) in Java. Their usage with both primitives and object references are demonstrated.

Through realistic examples, this lecture takes a deep dive into Logical Operators in Java. After introducing the operators, we also look at operator precedence across the three logical operators. Finally, we also discuss operator precedence across logical operators, arithmetic operators, and comparison operators.

In the previous lecture, we have learnt a bit about building business logic via logical operators. So, armed with the newly learned knowledge, in this coding exercise, we will write some neat business logic for estimating the price of a used car. In this video, we explain the problem and the template code that will be given to you. The actual coding exercise would be next lecture where you will submit your solution. In the lecture following the coding exercise, we discuss the solution.

if-statements play a vital role in building the business logic of any application. In lecture, we take an in-depth look at if-statement. It clearly discusses all the different scenarios when an if-statement is used in a method.

Through this and follow up lectures we take a deep dive into Switch Statements & Switch Expressions (Java 14). In this lecture, we start off with the traditional switch statement syntax. We first look at when it can be used as an alternative to if-statement. We see how switch is more readable, concise and also efficient compared to if-statement. We progressively build the syntax even highlighting its limitations, which will be addressed via Arrow Labels (Java 14 feature) in a subsequent lecture.

In this lecture, we continue our discussion of Switch statements and look at few important restrictions there are on Switch selector and case labels. First half of the lecture focuses on Switch selector restrictions while the second half focuses on case label restrictions.

In this lecture, we look at Arrow Labels that were introduced in Java 14. Arrow labels help in writing concise, cleaner, readable, and safer code. Traditional switch syntax has few limitations and we systematically address those limitations via arrow labels. One limitation is also addressed using traditional syntax too.

In this lecture, we see how we can write even more readable, compact, and safer code by using Switch Expressions from Java 14. With Switch Expressions, syntax-wise we can have many different confusing scenarios. In this lecture, we systematically discuss every single scenario. For e.g., we discuss how a switch expression can also include traditional case label syntax that includes a colon.

Introduces ternary operator, which can be used as a shorthand for if-else statements where if & else blocks have single statements.

Normally, a statement is executed only once. In this lecture, for statement is introduced, which repetitively executes some computation as long as a particular condition is true. When the condition is false, the computation is no longer executed. for statement is referred to as an iterative statement and this lecture introduces the basic syntax.

A very important lecture that delves into different ways in which a for-statement can be used to solve different problems. We look at the different ways in which an array can be iterated, which will help us see how the three expressions in the for statement's parenthesis would change. We will also a use case of one of the bit shift operators. Finally, we will also look at nested for statements.

This lecture discusses for-each statement, which was introduced in Java 5. It allows for convenient iteration of arrays and other data structures that will be seen in Collections Framework section. It has a simple & cleaner syntax. We also see why for-each statement is preferable over traditional for statement when it comes to nested iteration of arrays. We also discuss when a for-each cannot be used and would have to use a traditional for statement.

In this lecture, we learn what a labeled statement is and how it enables in breaking out of nested constructs via a labeled break. First half of the lecture illustrates breaking out of nested loops while the second half focuses on breaking out of nested if statements and blocks.

In this lecture, you will learn about continue statement along with labeled continue.

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.

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.

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.

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

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

Continuing the discussion on String class methods, this lecture introduces replace() method. This lecture also discussed how replaceAll() method is different from replace() by giving a glimpse of regular expressions that replaceAll() handles. Finally, join() method is discussed too.

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.

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.

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.

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

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

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.

In this lecture, we will see Information Hiding design principle in action by enhancing the Student class from being a tightly coupled class to loosely coupled class, which gives the benefit of Class Invariance as well as the flexibility to change internal implementation without affecting client code.

In the previous lecture, we looked at how making instance variables private and having accessors will enable loose coupling. This lecture builds on the previous one to discuss Information Hiding design principles for Classes and class members like Methods.

This lecture demonstrates how we can create a Java program and how IDE speeds up application development by automatically compiling the program. The notion of Project & Module along with windows like Tool Windows and Settings are shown.

Shows module settings window where the different dependencies that a module depends on are set like Java version, external libraries, and other modules in the project. The lecture also discusses IntelliJ IDE's static analysis concept along with Java's backward compatibility guarantee. Similarly, dependency settings in Eclipse IDE referred to as Build Path is also shown.

In this lecture, we import the demo code developed so far in the course. We will also delete the modules created earlier.

An important lecture that shows how to navigate through source code. We look at shortcuts for navigating into methods from method invocation statements, finding method usages, finding method call hierarchy, searching for classes/methods/fields, etc.

This lectures shows several shortcuts for formatting our code. We will see how import statements can be organized, how badly formatted code can be reformatted as per standard conventions, how to disable a block of code, etc.

This lecture shows shortcuts for automatically generating source code. We will look at generating control-flow statements like for-each, constructors, and getters & setters.

Demonstrates how code can be refactored towards improving code readability and maintainability. Specifically, we will look at shortcuts for extracting logic into methods and how literals can be replaced with variables.

Demonstrates how code can be refactored towards improving code readability and maintainability. Specifically, we will look at shortcuts for extracting logic into methods and how literals can be replaced with variables.

This lecture talks about how classes & class members like methods are designed and structured. The recommendations promote loose coupling.

This lecture focuses on stylistic aspects like how to indent statements and how to wrap long statements.

This lecture discusses when and how to write comments. It talks about the two comment types: implementation & documentation comments (javadoc).

This lecture introduces one of the fundamental features of OOP, which is Inheritance. We will learn how Inheritance helps in achieving better design by eliminating duplicate code and promoting code reuse.

In this lecture, we will revisit access modifiers and discuss their role in the context of Inheritance.

In this lecture, we learn how we can check if two classes can be related via inheritance. We also touch upon composition and how we can test for it.

This lecture introduces Polymorphism, which is another core feature of Object-Oriented Programming. Polymorphism is a by-product of Inheritance. We will see how Polymorphism allows us to write flexible & clean code.

In this lecture, we further explore polymorphism by discussing two realistic use-cases. In the process, we also revisit Information Hiding design principle in the context of super classes and subclasses.

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

In this lecture, you will learn about how to redefine a superclass method's behavior from a subclass via method overriding. You'll also see how we can use super keyword to access an overridden method in the super class.

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.

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

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

An in-depth demonstration of how constructor chaining works for creating objects with valid state. The lecture also discusses about the notion of static context for the arguments of super() or this() invocation statements. Furthermore, we also discuss when exactly instance variables and instance initializer blocks are initialized. Finally, Flexible Constructor Bodies introduced in Java 25 is briefly demonstrated.

The lecture gives an in-depth introduction into Flexible Constructor Bodies, which was introduced in Java 25. This enhancement enables in creating much more readable and effective constructors.

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.

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

In this lesson, we will learn about abstract classes & abstract methods. The lecture includes an in-depth demo.

Although Abstract classes cannot be instantiated, they still can have constructors and this lectures discusses about this aspect and how that can be helpful.

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

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

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

In this lecture, we discuss one of the most fundamental design principles, which is referring to objects by their interfaces. We will see how it helps in writing loosely-coupled code by being able to change implementations without affecting client code. The concept is demonstrated for different scenarios like method parameters, fields, and method return type.

This lecture is an in-depth introduction to Local Variable Type Inference feature from Java 10. It helps in declaring local variables in a concise way improving code readability. The lecture also clearly discusses why the feature is restricted to only local variables.