Java In-Depth: Become a Complete Java Engineer!

Comprehensive Java programming course integrated with design principles, best practices & instructor-led Java EE project

4.52 (22868 reviews)
Udemy
platform
English
language
Programming Languages
category
instructor
Java In-Depth: Become a Complete Java Engineer!
128,318
students
71.5 hours
content
Mar 2024
last update
$119.99
regular price

What you will learn

An industry-vetted, comprehensive curriculum to help you master Core & Advanced Java including JVM internals

Master design principles, best practices and coding conventions for writing well-designed, professional Java code

Get real-world experience by developing an instructor-led Java EE-based Web application

Set firm foundation in Java for the rest of your career. It is akin to a Master's Program in Java.

If entire course is done systematically, your Java skills will be on par with engineers at top companies like Google

Master Object-Oriented Programming concepts by using a real-world application as a case study

Master Exceptions, IO, Collections Framework, Generics, Multi-threading, Databases, etc. with best practices

Solid understanding of Functional-style Programming using Java 8 constructs like Lambdas & Streams

Description

Course Updates (March '24): In-depth lectures on Records (Java 16) and Switch Expressions & Arrow Labels (Java 14) have been added. These new features help in writing concise & safer code. Four relevant and interesting coding exercises on have also been added.

This Master Course has been meticulously developed for over 6 years and follows a unique, industry-vetted curriculum to help you become a Complete & Professional Java Engineer. It has over 125,000 students from over 160 countries ranging from complete beginners to experienced Java professionals. Top companies like IBM, TCS, Cognizant, Wipro, etc. are actively using this course to upskill their employees. It has been consistently ranked as one of Udemy's top 3 paid Java courses and has helped many students start their professional journey as "confident" Java programmers. Here is what some of the students had to say:

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

"I'm leaving this review a couple years after having completed this course. This is hands down the greatest online course I've ever taken. Extremely in-depth, extremely thorough, and Dheeru was always helpful when I asked questions. 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

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

"Absolutely amazing, complete and in depth course. I would recommend this course to everyone interested in Java and programming in general. Dheeru Mundluru is an exemplary and responsive instructor. He explains the concepts with such clarity and with examples that every thing makes perfect sense. When I started this course, I only had vague idea of programming and now after completing this course I have a solid foundation to build upon. I would certainly say that due to this course I have fell in love with Java language and its ecosystem" ~ Muhammad Arsal Abdullah

"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

"It helped me pass a paid internship interview in a reputable company and now i am getting a job." ~ Stephen

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

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

"The JVM internals section of this course itself is worth buying this course. Excellent teaching style." ~ Ryan Trang


Course Overview:

This course has been developed to just not teach core Java skills, but with a larger goal of helping you become a complete & professional Java engineer right by the end of this course. To realize this, it takes a holistic approach in teaching Java programming. To ensure that you master Java language, the course has been developed to be highly comprehensive covering most of the Java language features and discussing them at a very in-depth level. To further ensure you are industry-ready and can write well-designed, professional code, tons of industry-standard best practices & design principles are explained and demonstrated in code. Towards this end, you'll also implement an instructor-led Java EE Web application using professional coding conventions with Eclipse as IDE. If the entire course is done systematically, your Java skills will be on par with engineers at top companies like Google. Finally, all your questions will receive in-depth personalized responses within around 24 hours. Over 10000 questions have already been answered so far!

Special Note for College Students: Lecture three provides dedicated guidance with weekly and semester goals, integrating smoothly into your college schedule.


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 & design, JVM internals, exceptions, IO, collections framework, generics, multi-threading, databases, nested classes, enums, and functional-style programming via Java 8 constructs like lambdas & streams. You'll also learn about database designing, implementation (SQL), and how to interact with them from Java programs (via JDBC). The course also gives a very good introduction to Java EE technologies like Servlets & JSTL, which help in project implementation. Finally, an excellent Eclipse IDE tutorial is also included, which teaches you how to use Eclipse professionally for effectively writing, debugging and even testing Java programs using the JUnit framework.

Each lecture has been very carefully crafted explaining the motivation behind every concept. Each concept is clearly explained with well thought out examples & illustrations and is demonstrated in code. Object-oriented concepts like inheritance & polymorphism are explained through a real-world case-study, which is also implemented as part of the course project. Several challenging coding exercises & quizzes are included to reinforce what you've learned.

The course project involves building a bookmarking Web application that helps users bookmark items like Books, Movies, and Web pages and is built progressively as new concepts are learned. The project is instructor-led and is implemented using professional coding conventions & best practices. It follows good object-oriented design, incorporates MVC architectural pattern and also uses Test-Driven Development (TDD) methodology. Java EE stack comprising technologies like Servlets, JSP, and JSTL are used for building the application with MySQL as the database and Apache Tomcat as the Web server. Parts of the project use advanced multi-threading capabilities.

Finally, course also teaches several best practices & design principles that are essential for writing well-designed code. This is one of the highlights of the course and will make you truly complete!


Story behind Creating this Course:

The idea for building this Master Course has taken its roots during the instructor's (Dheeru Munduru) experience as a software engineer in Silicon Valley. After working for several years with many excellent engineers, Dheeru realized that sometimes the teams he worked with fell short of developing effective solutions. This led to several rounds of "code refactoring" resulting in loss of valuable time for the organization. This he realized was due to programming not being taught in the right way at most Universities & Colleges across the world. Students are mostly taught only core programming language features without any emphasis on best practices or design rules required for writing well-designed, professional-level code. Due to this, developers are often ill-equipped when they have to come up with good solutions for complex problems. This leads to some quick ad-hoc & incomplete learning, which often not only result in bad solutions, but also more importantly causes lot of stress on developer's part. This made Dheeru realize that a more holistic approach to teaching is needed where programming language features are taught along with best practices & design principles needed for building well-designed robust software. This course is a result of this realization and it has taken him over 6 years of full-time effort (considered equivalent to over a decade if working part-time) in developing it. He will continue to devote himself in building this course towards making it one of the best Java courses out there.

Content

Course Introduction

Why Yet Another Java Course?
Course Structure & UI Controls for Site Navigation
Terms of Service & Copyright

Java: A High-level Overview

Chapter Introduction
What is Java & Who is Using It?
Story behind Java's Creation ~ A Brief History
Compilation
Platform Dependency + Demo
Interpreter
Platform Independence in Java + Demo
Java Virtual Machine
An Overview of Java SE
Installing JDK 10 on Windows
Installing JDK 10 on Mac
Installing JDK10 on Linux
Setting Classpath Environment Variable
Writing First Java Program + Demo
Conclusion
Chapter Quiz
Important Q&A Discussions!

Classes, Objects and their Members

Chapter Introduction
Class & Objects
Demo: Absolute Java Basics
Variables: Introduction
Variable Kinds
Variables: Primitive Types
Primitive Variables: Integers + Demo
Primitive Variables: Floating-point Numbers + Item 48
Primitive Variables: Character Data Type + Demo
Primitive Variables: Boolean Data Type + Demo
Quiz: Variables
Variables: Type Casting + Demo
Variables: Object References
Statements + Demo
Arrays + Demo
2D Arrays
3D Arrays + Demo
Methods: Introduction + Demo
Method Types + Demo
How Data is Passed to Methods in Java? + Demo
Method Overloading + Demo
Methods: varargs + Demo
Constructors + Demo
this Reference + Demo
Demo: Student Example
Demo: Reinitializing Object References ~ More Brainstorming!
Arrays with Object References
Review of Exercise 1 Solution with Best Practices
Conclusion
Chapter Quiz
Important Q&A Discussions!

Method Building Blocks: Operators & Control-flow Statements

Chapter Introduction
Operators
Arithmetic Operators + Demo
Arithmetic Operation Rules + Demo
Quiz: Arithmetic Operators
Demo: Comparison Operators
Logical Operators + Demo
Car Price Estimator ~ Coding Exercise for Comparison & Logical Operators
Car Price Estimator ~ Putting Comparison & Logical Operators into Action
Car Price Estimator - Exercise Solution
Bitwise Operators + Demo
Quick Note on Bitwise Operators with Boolean Operands
Bit Shift Operators
Quiz: Bitwise & Bit Shift Operators
Control-flow: Demo: if-statement
Control-flow: switch + Demo
When is switch Preferred?
Quiz: switch Statement
Control-flow: Ternary + Demo
Control-flow: for Statement + Demo
Demo: More for Statement ...
Demo: for-each Statement (+ discussion on Item 46)
Variable Scope
Exercise
Computing GPA ~ Putting Operators & Control-flow to Test
Control-flow: while Statement
Control-flow: break Statement + Demo
Control-flow: continue + Demo
Recursion + Demo
Conclusion

Packages, Strings and Information Hiding

Chapter Introduction
Java API + Item 47 (Know and use the libraries)
Accessing Packages + Demo
Creating Packages & Classpath Management + Demo
Naming Packages
Strings: Introduction
String Class + Demo
String Pool & Interning + Demo
String Immutability
String Concatenation + Demo
Item 51: String Concatenation Performance
Escape Sequences + Demo
Sentiment Analysis: Mining Pros & Cons ~ Putting String Class to Test
Access Levels
Information Hiding - Item 14: Use accessor methods, not public fields + Demo
Information Hiding - Item 13: Minimize the accessibility of classes and members
Demo: Student Example with Information Hiding
Conclusion
Chapter Quiz
Important Q&A Discussions!

static, final, and Coding Conventions

Chapter Introduction
Static Methods + Item 4: Enforce noninstantiability with a private constructor
Math Class + Demo
Static Variables + Demo
Initializers: Static & Instance + Demo
final Variable + Demo
Constant Variables + Demo
Boxed Primitives
Autoboxing + Demo
Item 49: Prefer Primitives to Boxed Primitives + Demo
Parsing API Response ~ Let's make use of Boxed Primitives & String class
Coding Conventions: Naming (Item 56: Use generally accepted naming conventions)
Coding Conventions: Structuring Programs (Item 45: Minimize the scope of local)
Coding Conventions: Stylistic + Demo
Coding Conventions: Comments + Demo
Conclusion
Chapter Quiz
Important Q&A Discussions!

Case Study: A Social Bookmarking Application

thrill.io ~ A Social Polymarking App!
Case Study

Serious OOP: Inheritance & Polymorphism

Inheritance
Access Modifiers & Inheritance + Demo
IS-A Test
Hospital Management System (HMS) ~ Let's put Inheritance into practice!
Polymorphism + Demo
Casting Objects & instanceof Operator + Demo
Extending HMS with a Billing Component ~ Putting Polymorphism into Practice!
Type Safety
Method Overriding + Demo
Minor Correction in First Method Overriding Rule
Method Binding + Demo
What is Not Overridden? (final Method is one of them) + Demo
Demo: Fields are Not Overridden
Object Class + Demo + Item 10: Always override toString
Constructor Chaining + Demo
Preventing Inheritance
Conclusion
Chapter Quiz

More Serious OOP: Abstract Classes & Interfaces

New Requirement: thrill.io for Kids
Abstract Classes & Methods + Demo
Item 20: Prefer class hierarchies to tagged classes
Computing Health Insurance Premium for Staff ~ Let's put Abstract Classes & Methods into practice!
New Requirement: Sharing Bookmarks
Multiple Inheritance & Diamond Problem
Interfaces
More on Interfaces
Demo: Interfaces
Interfaces: A Conceptual View
Item 18: Prefer interfaces to abstract classes
Item 52: Refer to objects by their interfaces
Computing Health Insurance Premium for Staff (Part 2) ~ Let's put Interfaces into practice!
Marker Interfaces
Cloneable Interface + Demo
default Methods (Java 8) + Demo
Recap of default Methods
default Methods: Other Benefits + Demo
Static Methods in Interfaces + Demo
Conclusion
Chapter Quiz
Important Q&A Discussions!

Programming with Eclipse IDE

Introduction
Installing Eclipse
Writing a Java Program in Eclipse
Eclipse Build Process
Importing Demo Code
Source Code Navigation
Automatic Source Code Cleaning & Generation
Code Refactoring
Using Eclipse Debugger
JUnit & Debugging
Shortcuts Cheat Sheet
Conclusion

Project: Implementing a Social Bookmarking App

Project Introduction
MVC Architecture
Implementing Entities
Implementing Manager Classes - Demonstrates Singleton Pattern!!
Implementing Constant Exporting Classes
Implementing Data Store
Implementing Dao Classes
Launching the Application
Implementing User Bookmarking Feature
Implementing Kid-Friendly Eligibility Criteria Using TDD
Marking Bookmarks as Kid-Friendly
Implementing Sharing Feature: Part 1 (Implementing Shareable Interface)
Implementing Sharing Feature: Part 2 (View, Controller and Manager)

JVM Internals

Introduction
Lifetime of a Type
Lifetime of a Type: Class Loading
Lifetime of a Type: Linking
Demo: Lifetime of a Type
Quiz: Lifetime of a Type
Reflection
Accessing Class Object
Demo: Reflection
Simulate a Basic Unit Testing Framework ~ Putting reflection into action!
Runtime Data Areas
Method Area & Heap
Method Table
Garbage Collection: Introduction
Garbage Collection Algorithms
GC: Generational Collections
Demo: Tuning Heap & Analyzing GC Cycles
Item 6: Eliminate Obsolete Object References
Stack
Stack Frame
Instruction Set: invokespecial & invokevirtual + Demo
Conclusion
Chapter Quiz

Exceptions with Best Practices

Chapter Introduction
Demo: Exceptions & Exception Handling
Demo: Multiple Exceptions & Polymorphically Referencing Exceptions!!
Checked & Unchecked Exceptions + Demo
Exceptions & Method Overriding
finally Block + Demo
try-with-resources Statement + Demo
Demo: Suppressed Exceptions
Demo - Best Practices: Creating New Exceptions (Items 58 & 65)
Demo - Best Practices for Capturing Failure Information (Item 63)
Demo - Item 61: Throw exceptions appropriate to the abstraction
Extending Compute GPA Exercise with Exceptions
Exceptions: More Advice ... (Items 57, 59, 60, 62, and 38)
Assertions
Demo: Assertions
Conclusion
Chapter Quiz

Input-Output

Chapter Introduction
Character Encoding + Demo (Prerequisite)
Stream IO
Byte Streams
Reading Byte-Oriented Files Efficiently + Decorator Pattern + Demo
Character Streams
Reading & Writing Text Efficiently
Project Extension: Reading User & Bookmark Data from Text Files (Demo)
Project Extension: Downloading WebLinks & Writing to Disk (Demo)
Demo: Reading User Input from Console using BufferedReader & Scanner
The File Class + Demo
Serializing Java Objects + Demo
Deserialization & Versioning + Demo
Demo: Decoding with Compatible Encoding Scheme
Conclusion
Chapter Quiz
Input-Output ~ Important Q&A Discussions!

Collections Framework (aka Data Structures)

Chapter Introduction
Collection Interface
List Interface
ArrayList - Introduction
Demo: ArrayList
Iterator + Demo
List Iterator + Demo
LinkedList
Queue & Deque Interfaces
ArrayDeque + Demo
Flight Reservation System ~ Putting Lists & Queues into Action!
Hash Table
Set Interface & HashSet + Demo + Overriding hashCode & Equals (Item 9) + Item 52
LinkedHashSet + Demo
SortedSet & NavigableSet
TreeSet (Comparable & Comparator) + Demo
Demo: More TreeSet ~ Exploring NavigableSet Methods
TreeSet & Comparator Exercise
Map Interface
Demo: HashMap + Excercise
Demo: Beware of Creating Mutable Keys
LinkedHashMap + Demo
SortedMap, NavigableMap and TreeMap + Demo
Demo: Arrays Class
Demo: Arrays Class (Part 2) ~ Parallelized Operations from Java 8
Demo: Collections Class
Best Practice: Return empty arrays or collections instead of nulls (Item 43)
Conclusion - A Quick Summary
Chapter Quiz
Collections ~ Important Q&A Discussions!

Generics

Chapter Introduction ~ Motivation & Agenda
Generic & Parameterized Types
Demo: Creating Generic Types
Project Extension: Replacing Arrays with ArrayLists (Part 1)
Project Extension: Replacing Arrays with ArrayLists (Part 2)
Bounded Type Parameter + Demo
Item 23: Don’t use raw types in new code + Demo
Unbounded Wildcard + Demo
Invariance + Demo + Item 25: Prefer lists to arrays
Generic Methods (Items 26 & 27: Favor generic types/methods)
Demo: Generic Methods & Generic Constructors
Bounded Wildcards: Motivation + Demo
Bounded Wildcards + Item 28: Use bounded wildcards to increase API flexibility
Demo: Bounded Wildcards
Generics Restrictions
Conclusion - A Quick Summary
Chapter Quiz
Important Q&A Discussions!

Nested Classes

Chapter Introduction
Nonstatic Member Classes + Demo
Anonymous Classes + Demo & Item 21 ~ About Function objects
Local Classes + Demo
Static Member Classes + Demo + Item 22: Favor Static Member Classes
Variable Scope with Nested Classes
Conclusion - A Quick Summary
Anonymous Class & Static Member Class Exercise

enums

enums: Motivation & Introduction + Item 30: Use enums instead of int constants
Enum Class + Demo
enums with State & Behavior + Demo
Nested enums + Demo
Project Extension: Converting Constant Exporting Classes to Enums
enums with Constant-specific Behavior + Demo
Chapter Quiz

Concurrency (aka Multi-threading)

Chapter Introduction ~ Motivation & Agenda
Threads: Introduction
Demo: Launching Threads and Making them to Sleep!
Demo: Thread Naming, Prioritization and Joining + Item 73 (Avoid thread groups)
Race Condition + Demo
Synchronization + Demo + Item 66: Synchronize access to shared mutable data
Java Memory Model (JMM)
Volatile Variables + Demo
Atomic Variables + Demo
Synchronization Best Practices (+ Item 67: Avoid excessive synchronization)
Thread Cooperation & Management + Demo
Demo: wait & notify
Thread Interruption + Demo
Explicit Locks (Reentrant Lock) + Demo
Quiz: Concurrency Part 1
Item 69: Prefer concurrency utilities to wait and notify
Executor Framework + Demo (Item 68: Prefer executors and tasks to threads)
Executor Service & Future
Demo: ExecutorService & Future
Tasks with Time Limits + Demo
Project Extension: Downloading Web Links Concurrently
Project Extension: Implementing Background Job to Download Web Links
Quiz: Concurrency Part 2

Date & Time API ~ Covers Java 8 & also Legacy API

Agenda
Background ~ epoch, UTC, Timezone ...
Legacy API ~ Date & Calendar Classes + Demo
New Date & Time API ~ Introduction
Demo: New Date & Time API
Implementing Flight Booking Feature ~ Putting new Date & Time API into practice!

Database Implementation & JDBC API

Database Introduction & Chapter Agenda
Installing MySQL Database & MySQL Workbench
Database Design & Normalization
Database Design using MySQL Workbench
Project Ext.: Creating Database via CREATE & INSERT Queries + Storage Engines
Installing JDBC Driver
Writing SELECT Queries with Multiple Tables, GROUP BY, ORDER BY, etc.
Project Extension: Loading Data from Database via JDBC API
Project Extension: Saving Bookmarking Data via INSERT Queries
Project Extension: ALTER Query & Saving Kid-Friendly Details via UPDATE Queries
Useful Links to Some Tutorials

Functional-style Programming ~ Lambdas & Streams (Java 8)

Functional-style Programming: Motivation & Chapter Agenda
Lambdas ~ Introduction
Demo: Lambdas
Demo: Capturing Variables from Lambdas ~ Closures!
Quiz: Lambdas
Predicate, (Bi) Function, and Unary Operator Interfaces + Demo
Demo: Consumer, Supplier, and Primitive Functional Interfaces
Quiz: Functional Interfaces
Demo: Method References
Demo: Constructor References
Streams + Demo
Stream Operations: An Overview
Demo: Slicing a Stream
Demo: Stream Matching Operations
Demo: Stream Finding Operations & Optional Class
Stream Reduction Operations + Demo
Mutable Reduction with Collection Operations + Demo
collect() with Collector
Demo: Collecting Stream into List & Set
Demo: Grouping Stream Elements
Demo: Summarizing Groups & Generating Multi-level Groups
Important Q&A Discussions!

Introduction to Java EE & Web-enabling Project

Motivation & Agenda
Web Basics
Java EE & Servlet Containers
Installing Tomcat
BooksAloha! ~ Creating & Deploying a Web Application using Servlets
Servlet Life Cycle
Implementing BooksAloha! as MVC using JSP
Using JSTL to Improve Presentation Layer
Project Extension: Web-enabling thrill.io Project
Project Extension: Implementing Browse Functionality
Project Extension: Implementing Bookmarking & MyBooks Functionality
Project Extension: Implementing Login Functionality with Session
JAR Files - Introduction
Demo: Creating & Manipulating JAR Files

Bonus Lessons

Big O Notation
Java on Web: Websites & Social Media Groups to Follow
Follow-up Steps Towards Becoming a Full-Stack Java Developer!

Reviews

Dennis
October 27, 2023
It was an wonderful course that really honed into details that are necessary to build a solid foundation for becoming a Java Developer! 10/10 would recommend.
Maxwell
September 23, 2023
This course has proven to be very instrumental to my successful career in programming. I'm currently enrolled in the Bachelor's Degree Computer Science at the University of the People and this course has gone a long way to make life easy for me. Thanks a million for the time taken to put together this wonderful course. Maxwell
Gwendolyn
August 9, 2023
Course is thoroughly explained and gives plenty of practice. I look forward to it being a supplement to my university classes.
Miriam
August 3, 2023
The Instructor wastes your time explaining things you shouldn't do and forget the most important like showing in deep what you should know. On top of that, he has too complicated thinking and gives unnecessary and too complicated examples for simple topics. The structure of the course is terrible. There is a fundamental sequence of topics that should be presented at the beginning of the course for a general better understanding of Java and this, especially for Beginner. Please, don't waste your money and time here. Bro Code and CS50 on Youtube or Coursera offers better, more enjoyable and free content than this course.
Ravindra
May 7, 2023
excellent course, takes it slow and steady and coverage of key topics and fundamentals is very thorough.
Pratap
April 30, 2023
This course was part of a new hire training we had in my new job. The course is very comprehensive and the best practices taught gave us really good insights into professional coding conventions. Can't wait to implement some of them in a real project.
Naveen
April 26, 2023
One of the most indepth course clearly explained by the tutor. Highly recommended. One of the best onilne courses i have experienced. Best tutor with indepth knowledge of the subject.
Sandya
April 24, 2023
I am an absolute beginner with no prior experience in programming. I now have a good understanding of Core Java due to this course. Will have to work more to further solidify my understanding of the language something which I will be doing. Thanks to the instructor for all the effort he has put into this course.
Anidil
April 19, 2023
Example codes should be short and simple so that students can easily grasp. For instance, while explaining inheritance he has 6 tabs with 6 classes open and switching between tabs as he explain. Hard to keep track. May be I have to watch multiple times. I have no doubt about instructor's knowledge and experience. But could have been better . He explains theory first on slides and then code demo. I don't think it is a good style. Both should be combined. Also some videos are overwhelming with too much details. Anyways I will stick with it some more and see how it goes.
Anonymized
April 18, 2023
Good knowledge, but toooooooooooo lenghtyyyyyyyyyyyyyyyy. U get bored in between and want to stop listening the lecturer. Rest - very informative and totally worth it.
Lourdes
April 9, 2023
Awesome introduction. The instructor navigates through the content, clarifying which topics are important for each level and why. The studen is provided with clear explanation on how to use every resource included in the courwe.
Md
March 28, 2023
It was lots of learning in depth of Java. Thanks for this wonderful course!!! Whatever the skill you have in java I believe you will learn a lot from this course. Without any second thought go ahead enrol it.
Shivang
March 13, 2023
The best course to ever exist on Java. Close your eyes & enroll in this course without any second thought.
Timuzhin
March 7, 2023
At first accent was a little bit hard to understand, but the way he teaches everything is very simple and understandable, got a lot of value from this course.
Rushikesh
February 28, 2023
ok , very good course but you are explaining the new concept first time and you are explaining it verbally and imagining the scenario in your mind , we are clueless . This is course for who know JAVA already.

Coupons

DateDiscountStatus
6/18/202288% OFF
expired
6/23/202279% OFF
expired

Charts

Price

Java In-Depth: Become a Complete Java Engineer! - Price chart

Rating

Java In-Depth: Become a Complete Java Engineer! - Ratings chart

Enrollment distribution

Java In-Depth: Become a Complete Java Engineer! - Distribution chart

Related Topics

358540
udemy ID
11/28/2014
course created date
9/4/2019
course indexed date
Bot
course submited by