Java In-Depth Master Course | 100k Students

Complete Java Engineer

Comprehensive industry-vetted program integrated with time-tested design principles, best practices & instructor-led Java EE project. Trusted by 100k+ students.

Buy ₹9,000.00 Free Preview

80+ Hours Video, Lifetime Access

100k+ Students

50 Million+ Minutes Watched

This is hands down the greatest online course I've ever taken

Carlvin Sanon

Program Highlights

Trusted by over 100k Learners from 160+ Countries

Master Java Language

An industry-vetted, comprehensive curriculum to help you master Core & Advance Java including JVM internals.
Learn Best Practices

Learn design principles, best practices and coding conventions for writing well-designed, professional Java code. A USP of the program.
Instructor-led Project

Gain practical experience by implementing an instructor-led project using professional coding conventions.
World-class Faculty

Learn from a highly experienced instructor & industry veteran who helped many students kickstart their careers as confident Java engineers.
Fall in Love

Set firm foundation for rest of your career. Your Java skills will be on par with engineers at top companies like Google. That's our promise.
Professional Certification

You can optionally get certified as Complete Java Engineer! - our endorsement that you mastered Java and are industry-ready. See below for details on assessments.

Industry-vetted program to help you become a Complete & Professional Java Engineer!

Promo video explaining the need for Complete Engineers and how the course accomplishes that. Must watch.

Yes! Sign me Up

Course Objective

Become a Complete Java Engineer!

This Master Course has been meticulously developed for half-a-dozen years and follows a unique, industry-vetted curriculum to help you become a Complete & Professional Java Engineer. The curriculum has been designed to address several challenges many engineers are facing esp. when implementing large, complex software. Their solutions are often poorly implemented resulting in several rounds of "code refactoring" leading to loss of valuable time for the organization. This can be attributed to the way we are taught programming where focus is on teaching only programming language features without any emphasis on best practices & design principles needed for building good software. To address these short comings, the course has been built with a larger goal of teaching not just Java, but also how to write well-designed, professional code.

Course Description

A holistic approach

To address the shortcomings in current courses, the program takes a holistic approach by incorporating the following:

1. Comprehensiveness - To ensure that you master Java, the program is highly comprehensive covering most language features and discussing them at a very in-depth level. The program includes two parts - Core & Advance Java. Everything from Java language basics to concurrency and databases to functional-style and even modular programming are discussed. Each lecture is carefully crafted explaining the motivation with well thought out practical examples.

2. Best Practices & Design Principles - To further ensure you are industry-ready and can write well-designed, professional code, tons of industry standard best practices & design principles are discussed. This is a USP of the program.

3. Instructor-led Project - In addition to learning best practices, it is also good to have the experience of implementing something concrete. Towards this end, you'll implement an instructor-led Java EE Web application using professional coding conventions with Eclipse as IDE. This is akin to working with an experienced engineer on your first job.

The program can take around 4 months full-time to complete and is self-paced. Check out Core & Advance tabs for more specifics.

Mastering Core Java with Best Practices

The Core Java part constitutes the first 60% of the program and can take around 2 months full-time. Though this part covers the core fundamentals, you'll still learn many design principles & best practices followed in the industry. The instructor-led project also starts after learning object-oriented concepts and will be built progressively as we learn new concepts. You'll also learn how to use Eclipse professionally. Below is a high-level break-up of topics discussed under Core Java.

Language Basics & Object-Oriented Concepts
Eclipse Tutorial & JUnit Framework
JVM Internals, Exceptions, Input-Output
Collections Framework & Generics Basics
Using Git & GitHub from within Eclipse

Mastering the Advance Stuff

The Advanced Java part constitute last 40% of the course and it also takes around 2 months of full-time. Below is a high-level break-up of topics discussed under Advanced Java. The instructor-led project that started in the core part will be completed in this part. By the end you would have implemented a full Web application with MySQL as database. Finally, after being introduced to JPMS, you'll learn how to build software that is space-optimized, i.e., software that takes very little space.

Advance Generics
Concurrency (aka Multi-threading)
Databases (SQL) & JDBC
Functional-style Programming
Introduction to Java EE
The Java Platform Module System (JPMS)
Custom Runtime Images

Be certified as Complete Java Engineer!

You can also optionally earn our Complete Java Engineer! certification - our endorsement that you've mastered Java and are ready to write professional-level code. To receive this certificate, apart from completing the lectures & quizzes, you would have to complete the below programming assessments all verified by our engineers.

20 coding exercises
Instructor-led project
Mini-project - implementing simple Java compiler

Get a glimpse of the teaching style!

Few Preview Lectures

This lecture conceptually explains basic concepts like Class & Object through nice illustrations.

Class & Objects

Introduces Switch statement. Explains how it is more readable, concise and efficient compared to if-statement.

Switch Statement: Introduction

This lecture demonstrates how a thread is launched and also put to sleep.

Launching a Thread!

Course curriculum

1. Motivation Behind Creating This Course
  FREE PREVIEW
2. Course Structure & Guidance on Doing the Course
  FREE PREVIEW
3. Schedule for College Students
1. Chapter Introduction
2. What is Java & Who is Using It?
3. Story behind Java's Creation ~ A Brief History
4. Compilation
5. Platform Dependency
6. Interpreter
7. Platform Independence in Java
8. Java Virtual Machine (JVM)
9. An Overview of Java SE
10. Java SE Release Cycles & Release History
11. Installing Java 17 on Windows
12. Installing Java on Mac
13. Installing Java on Linux
14. Setting Classpath Environment Variable
15. Writing First Java Program
16. Conclusion ~ Chapter 1
17. Chapter 2 Quiz
18. Important Q&A Discussions! (+)
1. Chapter Introduction
2. Class & Objects
  FREE PREVIEW
3. Absolute Java Basics
  FREE PREVIEW
4. Identifiers - A Note on Naming Rules
5. Variables: Introduction
6. Declaring & Re-initializing Variables
7. Assignment: Currency Converter - Creating a Class with Variables
8. Variables: Primitive Types
9. Primitive Variables: Integers
10. Question on Binary Representation of Negative Number
11. Other Integer Literal Formats
12. Use byte & short Variables Judiciously (+)
13. Primitive Variables: Floating-point Numbers
14. Floating-point Pitfalls*
15. Primitive Variables: Character Data Type
16. Alternate ways to initialize char variables
17. Primitive Variables: Boolean Data Type
18. Quiz: Primitive Variables
19. Variable Kinds - Instance, Static, and Local Variables
20. Multi-variable Declaration Statements
21. Variables: Type Casting
22. Variables: Object References
23. Statements
24. Arrays
25. Assignment: Currency Converter - Array Creation & Accessing its Elements
26. 2D Arrays
27. 3D Arrays
28. Methods: Introduction
29. Method Types ~ Instance & Static Methods + Demo
30. Summary on Accessibility of Members from Static & Instance Methods
31. Assignment: Currency Converter - Invoking Methods of an Object
32. How Data is Passed to Methods in Java?
33. Method Overloading
34. Methods: varargs
35. Brief Summary on varargs Parameter
36. Constructors
37. Constructor Overloading
38. Constructor Overloading ~ Alternate way of delegating
39. Minor Note on Method Invocation & Implicit Narrowing Conversion
40. this Reference
41. Demo: Reinitializing Object References ~ More Brainstorming! (Incl. Assignment)
42. Minor Note on Executing StudentTest and a Java 11 Feature
43. Coding Exercise 1: Implementing Instructor Class ~ Manipulating Arrays with Object References
44. Review of Exercise 1 Solution with Best Practices
45. Conclusion
46. Chapter 3 Quiz
47. Important Q&A Discussions! (+)
1. Chapter Introduction
2. Operators
3. Arithmetic Operators
4. Arithmetic Operation Rules
5. Minor Clarification on Arithmetic Operator Precedence Rule
6. Quiz: Arithmetic Operators
7. Note on Student Class
8. Comparison Operators
9. Logical Operators with Operator Precedence
10. Car Price Estimator ~ Coding Exercise for Comparison & Logical Operators
11. Coding Exercise 2: Car Price Estimator ~ Putting Comparison & Logical Operators into Action
12. Car Price Estimator - Exercise Solution Review
13. Bitwise Operators
14. Quick Note on Bitwise Operators with Boolean Operands
15. Bit Shift Operators
16. Quiz: Bitwise & Bit Shift Operators
17. Control-flow: if-statement
18. Coding Exercise: Amusement Park Ticket Price Calculator ~ Putting if statements into Action
19. Switch Statement: Introduction
20. Switch Restrictions
21. Arrow Labels in Switch (Java 14)
22. Switch Expressions (Java 14)
23. Quiz: switch Statement
24. Control-flow: Ternary
25. Additional Notes on Ternary Operator
26. Control-flow: for Statement
27. More for Statement ...
28. Another Look at Nested for Statement
29. for-each Statement*
30. Variable Scope
31. Exercise
32. Coding Exercise 3: Computing GPA ~ Putting Operators & Control-flow to Test
33. Computing GPA - Exercise Solution Review
34. Demo: while Statement
35. Demo: do Statement (incl. Scanner Class for taking Input)
36. Blocks
37. break Statement
38. Labeled Statement & Labeled break
39. continue Statement & Labeled continue
40. Recursion
41. Minor Correction in Binary Search Code
42. Conclusion
1. Chapter Introduction
2. Java API*
3. Accessing Packages
4. Creating Packages & Classpath Management
5. Naming Packages
6. Access Levels
7. More on private Modifier
8. Chapter 5 Quiz: Packages & Access Levels
1. Introduction
2. Installing Eclipse
3. Writing a Java Program in Eclipse
4. Eclipse Build Process
5. Importing Demo Code
6. Source Code Navigation
7. Automatic Source Code Cleaning & Generation
8. Shortcuts Cheat Sheet
1. Chapter Introduction
2. Strings: Introduction
3. String Class
4. replace() vs replaceAll(regex) & join()
5. Generating URL Path Variables: Strings Coding Exercise (Problem Discussion)
6. Coding Exercise: Generating URL Path Variables ~ Putting String Methods in Action
7. Coding Exercise Solution Review: Generating URL Path Variables
8. Text Parsing with substring() & indexOf()
9. Assignment: Calculating Term Frequency in a Document
10. String Pool & Interning
11. String Immutability
12. String Concatenation
13. String Concatenation Performance*
14. Escape Sequences
15. Strings - Important Q&A Discussions! (+)
16. Coding Exercise 4: Sentiment Analysis: Mining Pros & Cons ~ Putting String Class to Test
17. Math Class
18. Boxed Primitives & Static Factory Methods*
19. Uses of Boxed Primitives
20. Autoboxing
21. Boxed Primitives & Immutability
22. Prefer Primitives over Boxed Primitives*
23. Coding Exercise 5: Parsing API Response ~ Let's make use of Boxed Primitives & String class
24. Chapter 7 Quiz
1. Chapter Introduction
2. Initializers: Static & Instance
3. Note on Instance Initialization Blocks
4. final Variable (+)
5. Constant Variables
6. Chapter 8 Quiz
1. Chapter Introduction
2. Information Hiding - Use Accessor Methods*
3. Enhancing Student Example with Information Hiding
4. Minimize Accessibility of Classes & Members*
5. Coding Conventions: Introduction
  FREE PREVIEW
6. Naming Conventions: Typographical Rules*
7. Naming Conventions: Grammatical Rules*
8. Coding Conventions: Structuring Programs*
9. Coding Conventions: Stylistic
10. Coding Conventions: Comments
1. thrill.io ~ A Social Polymarking App!
2. Case Study
1. Inheritance
2. Access Modifiers & Inheritance + Demo
3. Note on Recommended Order for Modifiers (+)
4. IS-A Test
5. Coding Exercise 6: Hospital Management System (HMS) ~ Let's put Inheritance into practice!
6. Polymorphism + Demo
7. Casting Objects & instanceof Operator + Demo
8. Coding Exercise 7: Extending HMS with a Billing Component ~ Putting Polymorphism into Practice!
9. Type Safety
10. Method Overriding + Demo
11. Minor Correction in First Method Overriding Rule
12. Method Binding + Demo
13. Question on Method Binding
14. What is Not Overridden? (final Method is one of them) + Demo
15. Demo: Fields are Not Overridden
16. Object Class + Demo*
17. Constructor Chaining + Demo
18. Note on Constructor Inheritance
19. Preventing Inheritance
20. Conclusion
21. Chapter 11 Quiz
1. New Requirement: thrill.io for Kids
2. Abstract Classes & Methods + Demo
3. Demo: Constructors in Abstract Classes
4. Prefer Class Hierarchies over Tagged Classes*
5. Coding Exercise 8: Computing Health Insurance Premium for Staff ~ Let's put Abstract Classes & Methods into practice!
6. New Requirement: Sharing Bookmarks
7. Multiple Inheritance & Diamond Problem
8. Interfaces
9. Update to Interfaces due to Java 9
10. More on Interfaces
11. Note on Next Lecture on Interfaces
12. Demo: Interfaces
13. Interfaces: A Conceptual View
14. Prefer Interfaces over Abstract Classes*
15. Refer Objects via Interfaces*
16. Coding Exercise 9: Computing Health Insurance Premium for Staff (Part 2) ~ Let's put Interfaces into practice!
17. Marker Interfaces
18. Cloneable Interface + Demo
19. Deep Cloning of Objects
20. default Methods (Java 8) + Demo
21. Recap of default Methods
22. default Methods: Other Benefits + Demo
23. Static Methods in Interfaces + Demo
24. Private Methods in Interfaces
25. Conclusion
26. Chapter 12 Quiz
27. Important Q&A Discussions!
1. Using Eclipse Debugger
2. JUnit & Debugging
3. Shortcuts Cheat Sheet
1. Project Introduction
2. MVC Architecture
3. Implementing Entities
4. Implementing Manager Classes - Demonstrates Singleton Pattern!!
5. Implementing Constant Exporting Classes
6. Implementing Data Store
7. Implementing Dao Classes
8. Launching the Application
9. Implementing User Bookmarking Feature
10. Implementing Kid-Friendly Eligibility Criteria Using TDD
11. Marking Bookmarks as Kid-Friendly
12. Minor Coding Correction in Previous Lecture
13. Implementing Sharing Feature: Part 1 (Implementing Shareable Interface)
14. Troubleshooting StringUtils Compilation Issue
15. Implementing Sharing Feature: Part 2 (View, Controller and Manager)
1. Introduction
2. Lifetime of a Type within JVM
3. Lifetime of a Type: Class Loading
4. Lifetime of a Type: Linking
5. Short Note on Resolution Step for Better Clarity
6. Demo: Lifetime of a Type
7. Quiz: Lifetime of a Type
8. Reflection
9. Accessing Class Object
10. Demo: Reflection
11. Coding Exercise 10: Simulate a Basic Unit Testing Framework ~ Putting reflection into action!
12. Runtime Data Areas (JVM Memory)
13. Method Area & Heap
14. Method Table
15. Garbage Collection: Introduction
16. JVM's Garbage Collection Algorithms
17. Important Questions on GC Algorithm (+)
18. GC: Generational Collections
19. Demo: Tuning JVM Heap & Analyzing GC Cycles
20. Eliminate Obsolete Object References (aka Memory Leaks)*
21. Stack Frame
22. Stack
23. Instruction Set: invokespecial & invokevirtual + Demo
24. Conclusion
25. Chapter 15 Quiz
1. Chapter Introduction
2. Demo: Exceptions & Exception Handling
3. Demo: Multiple Exceptions & Polymorphically Referencing Exceptions!!
4. Checked & Unchecked Exceptions + Demo
5. Exceptions & Method Overriding
6. finally Block + Demo
7. try-with-resources Statement + Demo
8. Demo: Suppressed Exceptions
9. Demo - Best Practices: Creating New Exceptions*
10. Demo - Best Practices for Capturing Failure Information*
11. Demo - Best Practice: Exception Translation & Chaining*
12. Coding Exercise 11: Extending Compute GPA Exercise with Exceptions
13. Bit of Brainstorming! (+)
14. Exceptions: More Advice ...*
15. Assertions
16. Demo: Assertions
17. Conclusion
18. Chapter 16 Quiz
19. Exceptions ~ Important Q&A Discussions!
1. Chapter Introduction
2. Character Encoding + Demo (Prerequisite)
3. Stream IO
4. Byte Streams
5. Reading Byte-Oriented Files Efficiently + Decorator Pattern + Demo
6. Character Streams
7. Reading & Writing Text Efficiently
8. Project Extension: Reading User & Bookmark Data from Text Files (Demo)
9. Project Extension: Downloading WebLinks & Writing to Disk (Demo)
10. Demo: Reading User Input from Console using BufferedReader & Scanner
11. The File Class + Demo
12. Serializing Java Objects + Demo
13. Deserialization & Versioning + Demo
14. Demo: Decoding with Compatible Encoding Scheme
15. Conclusion
16. Chapter 17 Quiz
17. Input-Output ~ Important Q&A Discussions! (+)
1. Chapter Introduction
2. Collection Interface
3. List Interface
4. ArrayList - Introduction
5. Demo: ArrayList
6. Iterator + Demo
7. List Iterator + Demo
8. LinkedList
9. Queue & Deque Interfaces
10. ArrayDeque + Demo
11. Coding Exercise 12: Flight Reservation System ~ Putting Lists & Queues into Action!
12. Hash Table
13. Set Interface & HashSet + Demo + (Overriding hashCode & Equals)*
14. LinkedHashSet + Demo
15. SortedSet & NavigableSet
16. TreeSet (Comparable & Comparator) + Demo
17. Demo: More TreeSet ~ Exploring NavigableSet Methods
18. Coding Exercise 13: TreeSet & Comparator Exercise
19. Map Interface
20. Demo: HashMap + Excercise
21. Demo: Beware of Creating Mutable Keys
22. LinkedHashMap + Demo
23. Note on LinkedHashMap Implementation (+)
24. SortedMap, NavigableMap and TreeMap + Demo
25. Demo: Arrays Class
26. Further Clarification on Arrays.asList() Explanation
27. Demo: Arrays Class (Part 2) ~ Parallelized Operations from Java 8
28. Demo: Collections Class
29. Best Practice: Return Empty Arrays or Collections*
30. Conclusion - A Quick Summary
31. Chapter 18 Quiz
32. Collections ~ Important Q&A Discussions! (+)
1. Chapter Introduction ~ Motivation & Agenda
2. Generic & Parameterized Types
3. Demo: Creating Generic Types + Type Erasure Discussion
4. Project Extension: Replacing Arrays with ArrayLists (Part 1)
5. Project Extension: Replacing Arrays with ArrayLists (Part 2)
6. End of Part 1 (Core Java) of the Course
7. Bounded Type Parameter + Demo
8. Avoid Raw Types in New Code*
9. Unbounded Wildcard + Demo
10. Invariance + Demo + Prefer Lists to Arrays*
11. Generic Methods*
12. Demo: Generic Methods & Generic Constructors
13. Important Question on Type Inference & Invariance (+)
14. Bounded Wildcards: Motivation + Demo
15. Bounded Wildcards & More Expressive APIs*
16. Demo: Bounded Wildcards
17. Generics Restrictions
18. Conclusion - A Quick Summary
19. Chapter 19 Quiz
20. Important Q&A Discussions!
1. Chapter Introduction
2. Nonstatic Member Classes & Adapters + Demo
3. Note on Nonstatic Member Classes - From Java 16 Onwards (+)
4. Anonymous Classes + Demo & Function Objects*
5. Local Classes + Demo
6. Fix in Previous Demo on Local Classes for Java 9 and above
7. Static Member Classes (Favor them!) + Demo*
8. Variable Scope with Nested Classes
9. Conclusion - A Quick Summary
10. Coding Exercise 14: Anonymous Class & Static Member Class Exercise
1. enums: Motivation & Introduction (Avoid int Constants)*
2. Enum Class + Demo
3. enums with State & Behavior + Demo
4. Nested enums + Demo
5. Project Extension: Converting Constant Exporting Classes to Enums
6. enums with Constant-specific Behavior + Demo
7. Bit of Brainstorming! (+)
8. Chapter 21 Quiz
1. Chapter Introduction ~ Motivation & Agenda
2. Threads: Introduction
3. Minor Correction on Thread States
4. Demo: Launching Threads and Making them to Sleep!
5. Demo: Thread Naming, Prioritization and Joining (Avoid Thread Groups)*
6. Race Condition + Demo
7. Synchronization + Demo*
8. Java Memory Model (JMM)
9. Volatile Variables + Demo
10. Atomic Variables + Demo
11. Important Question on Atomic Variable (+)
12. Synchronization Best Practices*
13. Thread Cooperation & Management + Demo
14. Demo: wait & notify
15. Thread Interruption + Demo
16. Explicit Locks (Reentrant Lock) + Demo
17. Hijacked Signal: Single Condition Queue with signal notification (+)
18. Prefer Concurrency Utilities over wait & notify*
19. Executor Framework + Demo*
20. Executor Service & Future
21. Demo: ExecutorService & Future
22. Tasks with Time Limits + Demo
23. Project Extension: Downloading Web Links Concurrently
24. Project Extension: Implementing Background Job to Download Web Links
1. Agenda
2. Background - epoch, UTC, Timezone ...
3. Legacy API - Date & Calendar Classes + Demo
4. New Date & Time API - Introduction
5. Demo: New Date & Time API
6. Coding Exercise 15: Implementing Flight Booking Feature ~ Putting new Date & Time API into practice!
1. Database Introduction & Chapter Agenda
2. Installing MySQL Database & MySQL Workbench
3. Database Design & Normalization
4. Database Design using MySQL Workbench
5. Project Ext.: Creating Database via CREATE & INSERT Queries + Storage Engines
6. Installing JDBC Driver
7. Writing SELECT Queries with Multiple Tables, GROUP BY, ORDER BY, etc.
8. Project Extension: Loading Data from Database via JDBC API
9. Project Extension: Saving Bookmarking Data via INSERT Queries
10. Project Extension: ALTER Query & Saving Kid-Friendly Details via UPDATE Queries
11. Useful Links to Some Tutorials
1. Functional-style Programming: Motivation & Chapter Agenda
2. Lambdas - Introduction
3. Demo: Lambdas
4. Demo: Capturing Variables from Lambdas ~ Closures!
5. Quiz: Lambdas
6. Lambdas: Important Q&A Discussions!
7. Predicate, (Bi) Function, and Unary Operator Interfaces + Demo
8. Demo: Consumer, Supplier, and Primitive Functional Interfaces
9. Quiz: Functional Interfaces
10. Demo: Method References
11. Demo: Constructor References
12. Streams + Demo
13. Stream Operations: An Overview
14. Demo: Slicing a Stream
15. flatMap Operation
16. Demo: flatMap Operation
17. Demo: Stream Matching Operations
18. Demo: Stream Finding Operations & Optional Class
19. Stream Reduction Operations + Demo
20. Assignment: Let's test our skills on reduce() operation
21. Assignment Solution
22. Coding Exercise 16: Covid Tracking with reduce()
23. Solution: Covid Tracking with reduce()
24. Special Cases of Reduction Operation
25. Mutable Reduction with Collection Operations + Demo
26. collect() with Collector
27. Demo: Collecting Stream into List & Set
28. Coding Exercise 17: Covid Tracking with collect()
29. Demo: Grouping Stream Elements
30. Demo: Summarizing Groups & Generating Multi-level Groups
31. Side-effect Free Functions
32. Demo: Streams & Side-effect Free Functions
33. Conclusion
34. Important Q&A Discussions!
1. Motivation & Agenda
2. Web Basics
3. Java EE & Servlet Containers
4. Installing Tomcat
5. BooksAloha! ~ Creating & Deploying a Web Application using Servlets
6. Servlet Life Cycle
7. Implementing BooksAloha! as MVC using JSP
8. Using JSTL to Improve Presentation Layer
9. Project Extension: Web-enabling thrill.io Project
10. Project Extension: Implementing Browse Functionality
11. Project Extension: Implementing Bookmarking & MyBooks Functionality
12. Project Extension: Implementing Login Functionality with Session
13. JAR Files - Introduction
14. Demo: Creating & Manipulating JAR Files
15. Important Q&A Discussion on Spring & Java EE Relation
1. Chapter Introduction & Agenda
2. Motivation: Stronger Encapsulation
3. Motivation: Ease of Understanding
4. Motivation: Smaller Distributables
5. Motivation: Reliable Configuration
6. Anatomy of a Module
7. Demo: Creating Downloader & Indexer Modules
8. Interoperability: Pre-Java 9 Code on Java 9 & Later
9. Module Path & Module Resolution
10. Demo: Creating Modular JARs
11. Demo: Achieving Reliable Configuration with Modules
12. Demo: Creating Modules from within Eclipse
13. Demo: Creating Modular JAR from within Eclipse
14. Unnamed Modules: Using Modular Code
15. Unnamed Modules: Using Modular Code from Command Line
16. Minor Correction in Previous Lecture
17. Automatic Modules: Using Non-Modular Code
18. Demo: Automatic Modules
19. Note on Auto-Suggest Option in Previous Lecture
20. Chapter Summary
1. Custom Runtime Images: Introduction
2. Demo: Custom Runtime Image with Platform Modules
3. Minor Note on Previous Lecture
4. Custom Runtime Image with few Application Modules: A First Look
5. jdeps: Java Dependency Analysis Tool
6. Converting Automatic Module into Explicit Module
7. Custom Runtime Image with Application Modules
8. Important Note on Executing App Module in Previous Lecture
9. Conclusion
1. Record: Introduction
2. Records with Explicit Constructors
3. Restrictions on Records
4. [NEW] Pattern Matching for instanceof Operator (Java 16)
5. [NEW] Pattern Matching for switch: Motivation & Introduction (Java 21)
6. [NEW] Demo: Pattern Matching for switch (Java 21)
7. [NEW] Pattern Switch with Records, enums, and other types
8. [NEW] Demo: Guarded Pattern Case Labels
9. Section Introduction
1. Closing Comments
2. Java in around 18 Minutes!
1. Problem Description
2. Solution Overview - Discussion on Front-end of a Compiler
3. System Design & Grading
1. Module Introduction & Agenda
2. Introduction to Version Control System (VCS)
3. Introduction to Git
4. Setting-up Project Code - Simulating a Professional Set-up!
5. Creating Git Repository & Committing Code from Eclipse
6. Hosting Repository on GitHub
7. Team Collaboration Set-up
8. Cloning Repository & Committing Code from Eclipse
9. Pull & Update from Remote Repository from Eclipse
1. Important Resources for Features Not Discussed in Course
2. Big O Notation
3. Java on Web: Websites & Social Media Groups to Follow
4. Follow-up Steps Towards Becoming a Full-Stack Java Developer!

About this course

₹9,000.00
511 lessons
81.5 hours of video content
20 Coding Exercises, Quizzes and Instructor-led Project
Duration: 4 months approx.
Self-paced, lifetime access

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

MEET YOUR INSTRUCTOR

Dheeru Mundluru is the instructor for this program. A passionate software engineer & educator, Dheeru has around 15 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). He is an experienced online instructor with over half-a-dozen years of teaching experience with over 100k students globally. He has also been rated as one of the top instructors on Udemy. His engineering expertise includes developing complex Web data integration & mining software with Java as the main programming tool. Coming from start-up world, he also has extensive end-to-end experience in developing Web applications using technologies such as Spring, Hibernate, MySQL, and Solr.

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.

What our students are saying

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

Stephen Jonson

One of the best courses I have taken on coding in general! On par with courses you can take from Stanford Engineering Everywhere.

Kaloyan T

This is hands down the greatest online course I've ever taken ... To really benefit from this course, you'll have to sit there and bang your head but if you take careful notes and make sure you can explain each step you're taking to solve a problem, you'll come out on top. I am now a data engineer and this course is one of the biggest catalysts for my transition into tech.

Carlvin Sanon

Few Companies where our Alumni Work

Frequently Asked Questions

Is the course for complete beginners?

Yes. Course is especially designed to help "absolute" beginners to truly master Java and use it professionally. Only requirement is you need to put in lot of effort and work through the course patiently & systematically. So, no prerequisites.

When does the course start and finish?

You can start & finish it anytime. For someone completely new to programming, it can take around 3-4 months of full-time effort to complete it the right way.

Are all course lectures accessible on sign-up?

The last 5 sections (starting from JPMS) will be accessible one week after enrollment. Rest of the content is accessible right away.

Is the course helpful for Java professionals too?

Absolutely. As mentioned in course description, a USP of this course is its in-depth coverage of design principles & best practices for building well-designed software. The course was designed after realizing that many software engineers were lacking these skills.

Is the course fee refundable?

No. To ensure course is right fit, please review the preview videos, course description and curriculum carefully.

I don't need certification. Can I still sign-up?

Yes. Complete Java Engineer certification is optional. It is our endorsement that you've mastered Java and are ready to write professional-level code. Please check out the Professional Certification section in Course Description to learn about its requirements.

Discover your potential, starting today

Enroll today

This is hands down the greatest online course I've ever taken

Carlvin Sanon

Master Java Language

Learn Best Practices

Instructor-led Project

World-class Faculty

Fall in Love

Professional Certification

Industry-vetted program to help you become a Complete & Professional Java Engineer!

Course Description

A holistic approach

Mastering Core Java with Best Practices

Mastering the Advance Stuff

Be certified as Complete Java Engineer!

Few Preview Lectures

Welcome to the Course!

Java: A High-level Overview

Classes, Objects and their Members

Method Building Blocks: Operators & Control-flow Statements

Packages & Access Levels

Programming with Eclipse IDE - Tutorial

java.lang: The Fundamental Classes

Initialization Blocks & final Variables

Information Hiding Design Principle & Professional Coding Conventions

Case Study: A Social Bookmarking Application

Serious OOP: Inheritance & Polymorphism

More Serious OOP: Abstract Classes & Interfaces

Debugging Java Programs & Unit Testing with JUnit

Project: Implementing a Social Bookmarking App

JVM Internals

Exceptions with Best Practices

Input-Output

Collections Framework (aka Data Structures)

Generics

Nested Classes with Best Practices

enums

Concurrency (aka Multi-threading)

Date & Time API - Covers Java 8 & Legacy API

Database Implementation & JDBC API

Functional-style Programming - Lambdas & Streams

Introduction to Java EE & Web-enabling Project

The Java Platform Module System (JPMS)

Custom Runtime Images

Modern Java - Recently Released Features

Conclusion - Java in around 18 Minutes!

Certification Project: Crafting a Simple Compiler

Using Git & GitHub from Eclipse - A Practical Introduction

Bonus Lessons

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

MEET YOUR INSTRUCTOR

What our students are saying

Frequently Asked Questions