Java In-Depth: Become a Complete Java Engineer!

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

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 introduces some absolute fundamentals for writing Java programs, e.g., how to print text onto console.

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

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

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

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

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

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

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.

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!

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 are declared and how they are invoked. Finally, we will also discuss some of the benefits that we get due to 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. Demo is included couple of lessons down the line.

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.

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.

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

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.

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.

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.

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.

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

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

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.

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!

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

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

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!

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 and abstract methods. A short demo is included at the end of the lesson.

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.