OpenCourser
Learn skills that shape your future
Visit OpenCourser.com
Recent Updates:
Dec '24: Added an in-depth lecture on Pattern Matching for instanceof operator from Java 16. This feature helps with conciseness, readability, and safety of Java programs.
July '24: Two in-depth lectures on industry-standard Naming Conventions (under Coding Conventions series) have been added. These conventions are followed in the Java library as well as at Google and recommended by them.
Recent Updates:
Dec '24: Added an in-depth lecture on Pattern Matching for instanceof operator from Java 16. This feature helps with conciseness, readability, and safety of Java programs.
July '24: Two in-depth lectures on industry-standard Naming Conventions (under Coding Conventions series) have been added. These conventions are followed in the Java library as well as at Google and recommended by them.
This Master Course has been meticulously developed for a decade and follows a unique industry-vetted curriculum to help you become a Complete & Professional Java Engineer. Its goal is to equip you with Java skills that are needed to be part of top engineering teams like the ones at Google & Amazon. It has over 125,000 students from over 170 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.. 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 rules 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.
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 quiz tests what we have learnt about primitive variables.
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.
Save
Dedicated section on JVM internals is highly praised.
Provides a firm base for future Java development.
Prepares learners for professional roles and interviews.
Instructor is highly competent, responsive, and clear.
Offers a comprehensive, in-depth look at Java.
SaveOpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.
Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.
Find this site helpful? Tell a friend about us.
We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.
Your purchases help us maintain our catalog and keep our servers humming without ads.
Thank you for supporting OpenCourser.
