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
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:
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.
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 :)).
This lesson discusses the core attributes and principles of Java.
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 lesson, we will 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 lesson introduces Java SE platform and how it evolved over the years since its first release in 1996. Also, explains what JRE & JDK mean.
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.
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.
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, 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.
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.
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.
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.