The Ultimate Java Masterclass: Beginner To Coding Superstar!

Master Java’s #1 Technologies and Become a Pro Developer with Spring, Spring Boot, Maven, JUnit, Mockito and more!

What you'll learn

Master Java from scratch with no prior experience required, gaining a strong foundation in one of the world’s most popular and high-demand programming languages

Learn industry-standard tools like Maven, Spring, and Spring Boot, used by top companies to develop modern Java applications, and boost your job-ready skills.

Understand the inner workings of Java frameworks, making you stand out from other developers and giving you confidence in interviews and professional settings.

Develop functional programming skills in Java, a highly sought-after skill in today’s job market, making your resume more competitive.

Master testing with JUnit and Mockito, ensuring your code is reliable and ready for professional environments—skills that hiring managers look for.

Get insights from real-world Java professionals, learning tips and tricks that take years to master, speeding up your journey to becoming a high-paid developer.

Start unlocking a high-paying career as a Java developer with the confidence and expertise to tackle real-world coding challenges right away!

Requirements

No prior programming experience needed—this course is designed for absolute beginners.

No software or tools required upfront—we’ll guide you through setting everything up step-by-step.

Basic computer literacy (using a PC or Mac) is all you need to get started.

Curiosity and motivation to learn Java and start your programming journey.

Willingness to practice what you learn with simple, guided exercises and real-world examples.

Open mind for learning new concepts—we break down complex ideas into easy-to-understand lessons!

Description

Master Java: Your Path to a High-Paying Software Engineering Career!Are you ready to kickstart a rewarding career in software engineering? Welcome to Introducing Java, the ultimate Udemy course that will set you up for success in one of the most lucrative and in-demand fields in tech—Java development!This isn’t just any programming course; it’s a complete career roadmap, brought to you by a seasoned Java professional with over 25 years of experience, including working with global giants like Goldman Sachs and agile startups. If you're serious about mastering Java and launching a well-paid career, this course is your ticket.Why This Course?You'll learn Java from the ground up, gaining hands-on experience with real-world examples. But we don't stop at just teaching you to code. You'll dive into industry-standard tools and frameworks that Java professionals use daily. Everything is broken down into concise, digestible lessons so you can build your skills quickly and effectively.This course is perfect for beginners or anyone looking to solidify their Java skills and take them to the next level.What You’ll Learn:Java: The World’s #1 Programming PlatformGet introduced to the power of Java, the foundation of countless enterprise applications and a must-know language for software developers. Start coding right away with practical examples and exercises designed to give you real-world experience.Maven: The World’s #1 Build ToolIn the real world, professional developers don’t just code; they manage and build projects efficiently. Learn Maven—the industry’s most widely used build tool—to break free from the IDE and develop a deeper understanding of how Java applications are built and managed.Spring: The World’s #1 Java FrameworkMaster the core concepts of Spring, the essential Java framework that underpins 99% of modern Java applications. You'll gain a rock-solid foundation that prepares you to dive into the world of Spring Boot.Spring Boot: The #1 Application Development FrameworkTake your Java development skills further by learning Spring Boot, the go-to framework for building modern Java applications. Not only will you learn to use it, but you’ll understand how it works under the hood—giving you an edge in any Java developer role.JUnit and Mockito: The #1 Tools for Java TestingQuality code is tested code! Learn how to write and run tests using JUnit and Mockito, the top tools for Java testing. These skills are essential for any developer looking to work professionally in Java.Functional Java: The Modern Way to Code in JavaDiscover the power of functional programming in Java. Since Java 8, functional programming has become an integral part of the language. You’ll dive deep into these concepts so you can write modern, clean, and efficient code.Extra Content You Won’t Find Anywhere Else!Extra Content #1: Get Inside the Mind of a Professional Java DeveloperGo beyond coding and immerse yourself in the mindset of a seasoned Java developer. We’re including exclusive podcast episodes from the popular "Java Easily" series, where you’ll learn the nuances of Java development straight from the pros.Extra Content #2: FAQs for New Java DevelopersStarting a new journey can come with lots of questions. We’ve compiled a detailed FAQ section addressing everything from how to land your first Java job to understanding who uses Java and why. These insights will give you the confidence to move forward.Why Choose This Course?This is more than just a Java tutorial. It’s a comprehensive, 360-degree learning experience. You’ll start with the basics, gain hands-on coding experience, explore the surrounding technologies, and even get insider advice on mindset and career success. By the end, you'll be fully prepared to launch a thriving career in software engineering with a complete toolkit of skills every Java developer needs.Plus, Java is one of the highest-paid programming languages, and demand for skilled developers is at an all-time high. This course gives you everything you need to stand out in the job market.Ready to Start Your Java Career?Don’t miss out on this opportunity to join the thousands of students who have already transformed their careers with this bestselling course. Whether you’re a total beginner or looking to upskill, this course will give you the knowledge, tools, and confidence to succeed as a professional Java developer.Enroll today and take the first step towards your new career in software engineering. Let’s make Java mastery your reality!

Overview

Section 1: INTRODUCING JAVA - your ticket to a well-paid software engineering career!

Lecture 1 Welcome to the course!

Section 2: Overview of Java

Lecture 2 Section Introduction

Lecture 3 How Popular is Java?

Lecture 4 Who uses Java?

Lecture 5 Where is Java used?

Lecture 6 Why is the Java platform so popular?

Lecture 7 Why is the Java language so popular?

Lecture 8 Section conclusion

Section 3: Java Platform Components

Lecture 9 Section introduction

Lecture 10 Java's acronyms and abbreviations

Lecture 11 Platform independence in Java

Lecture 12 How WORA (write once, run anywhere) works

Lecture 13 Key terms in Java you need to know

Lecture 14 Compiling a Java program with the Java compiler (javac)

Lecture 15 Running a Java program (bytecode) on the JVM

Lecture 16 Introducing the concept of an IDE

Lecture 17 Flow of compiling and running a Java program

Lecture 18 Section conclusion

Section 4: The Java Development Kit (JDK)

Lecture 19 Section Introduction

Lecture 20 Steps to install the JDK

Lecture 21 Working out which JDK version to instal

Lecture 22 Downloading the JDK

Lecture 23 Running the JDK installer

Lecture 24 Exploring the installation package contents

Lecture 25 Setting the JAVA HOME environment variables

Lecture 26 Checking the environment variables have been set

Lecture 27 Verifying the Java compiler and Java virtual machine are installed

Lecture 28 Section Conclusion

Section 5: The IDE (Integrated Development Environment)

Lecture 29 Section introduction

Lecture 30 Choosing an IDE

Lecture 31 Overview of IDE features for programming

Lecture 32 How the IDE does syntax highlighting

Lecture 33 How the IDE shows errors

Lecture 34 How the IDE helps you

Lecture 35 IDE feature compiling source code

Lecture 36 IDE feature Running the code

Lecture 37 IDE feature Debugging programs

Lecture 38 The process of programming with an IDE

Lecture 39 Installing an IDE (Eclipse)

Lecture 40 Section conclusion

Section 6: Java Programming Syntax Basics

Lecture 41 Section Introduction

Lecture 42 Java Syntax Classes

Lecture 43 Java Syntax Method Declarations

Lecture 44 Java Syntax Variables

Lecture 45 Java Syntax Encapsulation

Lecture 46 Java Concept Objects calling other Objects

Lecture 47 The Main Method of a Java Program

Section 7: Writing, Compiling, Running and Debugging a Java Program with the IDE

Lecture 48 Section Introduction

Lecture 49 Creating a new Java project in Eclipse

Lecture 50 Creating a package

Lecture 51 Creating a class

Lecture 52 Importing and Default Imports

Lecture 53 Autocomplete in the IDE

Lecture 54 Javadoc in the IDE

Lecture 55 Using the dot to reference different objects

Lecture 56 Method overloading

Lecture 57 Passing a parameter to a method

Lecture 58 Running your Java program

Lecture 59 Exploring the project structure after a build

Lecture 60 Refactoring to extract and create a new method

Lecture 61 Calling a method in Java

Lecture 62 Modifying a method to take a parameter

Lecture 63 How the IDE helps you fix your code

Lecture 64 How the IDE lets you preview code it will write for you

Lecture 65 How to pass a paremeter to a method

Lecture 66 Debugging your Java program

Lecture 67 Suspending a program at a breakpoint

Lecture 68 Stepping into a method

Lecture 69 Inspecting variables in the live program

Lecture 70 Examining the call stack to see the steps a program took so far

Lecture 71 Stepping over a method

Lecture 72 The notion of scope and call stack method popping

Lecture 73 The power of a debugger

Lecture 74 Section conclusion

Section 8: LEARN JAVA - the world's Number 1 programming platform!

Lecture 75 Section introduction

Lecture 76 What is Programming?

Lecture 77 The Tools You Need

Section 9: Setting Up

Lecture 78 Section Introduction

Lecture 79 Installing the JDK on Windows

Lecture 80 Setting up Environment Variables on Windows

Lecture 81 Installing IntelliJ IDEA on Windows

Lecture 82 Installing the JDK on Mac

Lecture 83 Setting up Environment Variables on Mac

Lecture 84 Installing IntelliJ IDEA on Mac

Section 10: First Steps

Lecture 85 Section Introduction

Lecture 86 Creating a New Project

Lecture 87 Creating and Loading a Template Project

Lecture 88 Welcome to the Challenge!

Lecture 89 Challenge Part 1 - Exercise

Lecture 90 Challenge Part 1 - Solution

Section 11: Variables

Lecture 91 Section Introduction

Lecture 92 What are Variables?

Lecture 93 ints

Lecture 94 doubles

Lecture 95 booleans

Lecture 96 Strings

Lecture 97 Primitives vs Class Types

Lecture 98 Conclusion

Lecture 99 Challenge Part 2 - Exercise

Lecture 100 Challenge Part 2 - Solution

Section 12: Expressions

Lecture 101 Section Introduction

Lecture 102 Numeric Expressions

Lecture 103 Boolean Expressions

Lecture 104 Simplifying Boolean Expressions

Lecture 105 Logical Operators

Lecture 106 Challenge Part 3 - Exercise

Lecture 107 Challenge Part 3 - Solution

Section 13: Strings

Lecture 108 Section Introduction

Lecture 109 String Concatenation

Lecture 110 String Operations

Lecture 111 Transforming Strings

Lecture 112 Boolean-based String Checks

Lecture 113 int-based String Checks

Lecture 114 Creating New Strings

Lecture 115 Challenge Part 4 - Exercise

Lecture 116 Challenge Part 4 - Solution

Section 14: Conditionals

Lecture 117 Section Introduction

Lecture 118 Logical Operators Recap

Lecture 119 The If Block

Lecture 120 The Else Block

Lecture 121 Alternate Flows with Elseif

Lecture 122 Thinking About Conditionals

Lecture 123 Dead Branches

Lecture 124 Refactoring to Simplify Conditionals

Lecture 125 Nested Conditionals

Lecture 126 U7: Good vs Bad Refactoring

Lecture 127 The Switch Statement

Lecture 128 Break Statements in Switches

Lecture 129 The Ternary Operator

Lecture 130 Challenge Part 5 - Exercise

Lecture 131 Challenge Part 5 - Solution

Section 15: Loops

Lecture 132 Section Introduction

Lecture 133 U8: What are Loops

Lecture 134 The While Loop

Lecture 135 The Do While Loop

Lecture 136 The For Loop

Lecture 137 Esoteric Loops

Lecture 138 Processing Collections with Streams

Lecture 139 The For Each Loop with Collections

Lecture 140 Challenge Part 6 - Exercise

Lecture 141 Challenge Part 6 - Solution

Section 16: Methods

Lecture 142 Section Introduction

Lecture 143 What are Methods?

Lecture 144 Creating a Method

Lecture 145 Calling a Method

Lecture 146 Passing Parameters

Lecture 147 Passing Multiple Parameters

Lecture 148 Returning Output from a Method

Lecture 149 Using a Returned Value

Lecture 150 Refactoring Inlining

Lecture 151 Refactoring Removing Unecessary Variables

Lecture 152 Challenge Part 7 - Exercise

Lecture 153 Challenge Part 7 - Solution

Section 17: Classes and Objects

Lecture 154 Section Introduction

Lecture 155 What are Objects?

Lecture 156 Creating a Class

Lecture 157 Visibility Modifiers

Lecture 158 Constructors

Lecture 159 The Default Constructor

Lecture 160 Instances and State

Lecture 161 Adding Methods to Classes

Lecture 162 Getters and Setters

Lecture 163 Why Encapsulation is Important

Lecture 164 Protecting the Integrity of Your Objects

Lecture 165 Composing Objects

Lecture 166 Referencing Other Objects

Lecture 167 Object References

Lecture 168 Stepping into an Objects Methods

Lecture 169 Concept of Inheritance

Lecture 170 Extending a Class

Lecture 171 Adding Custom Methods

Lecture 172 Creating Another Subclass

Lecture 173 Viewing the Type Hierarchy

Lecture 174 Superclass Variable References

Lecture 175 Concept of Polymorphism

Lecture 176 Abstract Methods

Lecture 177 Non-Instantiability of Abstract Classes

Lecture 178 Implementing Abstract Methods

Lecture 179 Custom Implementation of Superclass Methods

Lecture 180 Polymorphism in Action

Lecture 181 Recap of OO Concepts

Lecture 182 Challenge Part 8 - Exercise

Lecture 183 Challenge Part 8 - Solution

Section 18: Exceptions

Lecture 184 Section Introduction

Lecture 185 Concept of an Exception

Lecture 186 Try Catch Blocks

Lecture 187 Scoping in Try Blocks

Lecture 188 Happy Path and Error Path

Lecture 189 Throwing Exceptions

Lecture 190 Creating and Throwing Your Own Exceptions

Lecture 191 Chaining Exceptions

Lecture 192 Checked Exceptions

Lecture 193 Non-checked Exceptions

Lecture 194 Differences Between Checked and Non-Checked Exceptions

Lecture 195 Bubbling Exceptions Up the Call Stack

Lecture 196 Runtime Exception Handling in Nested Method Calls

Lecture 197 Checked Exception Handling in Nested Method Calls

Lecture 198 Exceptions and Non-Void Methods

Lecture 199 Multiple Catch Blocks

Lecture 200 Alternate Exceptions in a Catch Block

Lecture 201 Ordering of Catch Blocks

Lecture 202 Challenge Part 9 - Exercise

Lecture 203 Challenge Part 9 - Solution

Section 19: Collections

Lecture 204 Section Introduction

Lecture 205 Lists

Lecture 206 The Collection Interface

Lecture 207 Sets

Lecture 208 Lists vs Sets

Lecture 209 Maps

Lecture 210 Coding with Classes and Collections

Lecture 211 Using Your Own Classes with Collections

Lecture 212 The Equals Method with Collections

Lecture 213 Implementing Hash Code and Equals

Section 20: Wrapping Up

Lecture 214 Well Done and Thank You!

Section 21: LEARN MAVEN - the world's Number 1 build platform!

Lecture 215 Welcome to the Course!

Lecture 216 Course Resource Links

Lecture 217 Setting Up for the Command Line

Section 22: Installation Basics

Lecture 218 Section Introduction

Lecture 219 Checking if you have Maven Installed

Lecture 220 Installing Maven on Windows

Lecture 221 Installing Maven on Linux

Lecture 222 Installing Maven on Mac with sdkman

Lecture 223 A Quick Tour of the Maven Installation

Section 23: Fundamentals of Maven

Lecture 224 Section Introduction

Lecture 225 Creating a Maven Project with the Quickstart Archetype

Lecture 226 The Structure of a Maven Project

Lecture 227 Performing Simple Build Tasks with Maven

Lecture 228 Maven Invocation Modes

Lecture 229 The Project Object Model and POM File

Lecture 230 The Super POM and Effective POM

Lecture 231 Maven Build Lifecycles and Phases

Lecture 232 Resolving a Simple Dependency

Lecture 233 Resolving a Complex Dependency

Lecture 234 Analyzing Dependencies with Dependency Tree

Lecture 235 Finding Dependencies in the Maven Central Repository

Lecture 236 The Maven Local Repo Cache

Lecture 237 Population of the Local Maven Repo Cache

Lecture 238 Maven Plugins

Lecture 239 The Maven Help Plugin

Lecture 240 Creating a Web App Project

Section 24: Working with Maven in an IDE

Lecture 241 Section Introduction

Lecture 242 Creating a Maven Project from Scratch in IntelliJ IDEA

Lecture 243 Importing and Using a Maven Project in IntelliJ IDEA

Lecture 244 Creating a Maven Project from Scratch in Eclipse

Lecture 245 Importing and Using a Maven Project in Eclipse

Section 25: Wrapping Up

Lecture 246 Thank You and Where Next?

Section 26: LEARN SPRING - the world's Number 1 Java framework!

Lecture 247 Section Introduction

Lecture 248 Key Spring Resources you Need to Know

Lecture 249 Configuring a project's dependencies to use Spring

Lecture 250 Adding the Spring BOM to Better Manage Dependency Versions

Section 27: Creating the Spring Container with Application Contexts

Lecture 251 Section Introduction

Lecture 252 A Look at the Application Context (aka Spring Container)

Lecture 253 Creating the File System XML Applicatiion Context

Lecture 254 Configuring Autocomplete when Writing Spring XML Configuration

Section 28: Creating, Retrieving and Using Spring-Managed Beans

Lecture 255 Section Introduction

Lecture 256 Creating a Bean Managed with Spring's XML Container Configuration

Lecture 257 Retrieving and Using a Bean from the Spring Container

Lecture 258 Using the Classpath XML Application Context

Lecture 259 Understanding Singleton Scope

Lecture 260 Understanding Prototype Scope

Lecture 261 Understanding How Spring Creates Stateless Beans

Section 29: Understanding Dependency Injection and Inversion of Control

Lecture 262 Section Introduction

Lecture 263 Coding Beans to Use Constructor Dependency Injection

Lecture 264 Interpreting a Spring Container Exception

Lecture 265 Applying Constructor Dependency Injection to XML Config

Lecture 266 Verifying the Constructor Dependency Injection

Lecture 267 The Sharability of Beans in an IoC Container

Lecture 268 The Benefits of Dependency Injection in an IoC Container

Lecture 269 The Hollywood Principle

Lecture 270 Coding Beans to Use Setter Dependency Injection

Lecture 271 Applying Setter Dependency Injection in XML Configuration

Lecture 272 Verifying the Setter Dependency Injection with Debugger

Section 30: Autowiring Dependencies in the Spring Container

Lecture 273 Section Introduction

Lecture 274 Adding Component Scanning to Autodetect Spring Bean Annotations

Lecture 275 Coding Beans to be Automanaged and Autowired by Spring w Annotations

Lecture 276 Advantage of Annotation-based Configuration over XML Configuration

Lecture 277 Verifying the Annotation-driven Autowired Beans

Lecture 278 Spring's Stereotype Annotations for Better Code Reusability

Lecture 279 Setter Dependency Injection with Annotations

Lecture 280 Constructor Dependency Injection with Annotations

Lecture 281 Using the Annotation-Based Application Context

Lecture 282 Creating a Java Configuration Class

Lecture 283 Applying Java-based configuration with @Bean

Lecture 284 Using Scopes with Java-based Configuration

Lecture 285 Modeling a More Complex Application to Demonstrate Autowiring Issues

Lecture 286 Resolving Ambiguous Arguments of the Same Type by Narrowing

Lecture 287 Resolving Ambiguous Arguments of the Same Type Using @Qualifier

Section 31: Using Properties and Profiles in Spring Projects

Lecture 288 Section Introduction

Lecture 289 Injecting Properties with @Value in Spring Managed Beans

Lecture 290 Exploring Property Overriding in Spring

Lecture 291 Using properties with PropertyPlaceholder in XML Configuration

Lecture 292 Specifying default properties for property values

Lecture 293 Exceptions for Missing property keys in Spring

Lecture 294 Resolving Property Values in a Bean definition in XML Configuration

Lecture 295 Accessing the Current Active Profiles with the Environment interface

Lecture 296 Setting the current active profile programmatically and with switch

Lecture 297 Creating Profile-specific bean configuration

Lecture 298 Conditional Beans with @Profile

Section 32: Getting to Know the Spring Container

Lecture 299 The Proxy Design Pattern

Lecture 300 Seeing Proxies in Action

Lecture 301 The Disadvantages of a Regular Proxy

Lecture 302 Understanding JDK Dynamic Proxies

Lecture 303 Dynamic Proxies in Spring

Lecture 304 How Spring Makes Service Methods Transactional using Proxies

Lecture 305 Spring Managed Bean Lifecycle Callback Methods

Lecture 306 JDK Standard Lifecycle Annotations @PostConstruct @PreDestroy

Lecture 307 Sequence of Spring Container Callbacks on a Spring Managed Bean

Lecture 308 Application Container Callbacks and Events

Lecture 309 Aware Interfaces to Access Lower-Level Spring Components

Section 33: Accessing Databases with Spring

Lecture 310 Creating and Configuring Data Sources

Lecture 311 Creating a Data Access Object to Access a Database

Lecture 312 Connection Pool Data Sources in Spring

Lecture 313 Creating a JDBC Template to Access a Database

Lecture 314 Using JDBC Templates to Insert and Query Data

Lecture 315 Using JDBC DAO Support to Remove Boilerplate JDBC Code

Section 34: Aspect Oriented Programming in Spring

Lecture 316 Preparing a Spring Project to Use Aspects

Lecture 317 Creating a Spring Managed Bean to be Intercepted

Lecture 318 Registering the Dispatcher Servlet as Front Controller

Lecture 319 Advising Beans in Spring

Lecture 320 Understanding Pointcuts and Joinpoints

Lecture 321 Accessing Joinpoints Programmatically within an Aspect

Lecture 322 Coding Dynamic Advice with Around

Section 35: Web Application Development in Spring

Lecture 323 Preparing a Maven Project to Use Spring MVC

Lecture 324 Creating the Web Application Context

Lecture 325 Creating a Controller Class

Lecture 326 Configuring the Jetty Plugin in Maven to Run a Web App

Lecture 327 Setting Up Remote Debugging of a Web App

Lecture 328 Understanding the Dispatcher Servlet Processing Flow

Lecture 329 Writing a Controller to Service Web Requests

Lecture 330 Rendering a JSP-Based View with View Resolvers

Lecture 331 Understanding How a Request is Serviced

Lecture 332 Passing a Model to the View for More Dynamic Pages

Lecture 333 Injecting the HTTP Servlet Request and Response into a Controller

Lecture 334 Passing Request Parameters and Query Strings to a Controller

Lecture 335 Spring MVC: Using Path Variables to Access Parts of the Request Path

Section 36: LEARN SPRING BOOT - the world's Number 1 Java application framework!

Lecture 336 Welcome to the Course!

Section 37: Getting Started

Lecture 337 Section Introduction

Lecture 338 Creating a Spring Boot Application with Spring Initializr

Lecture 339 Exploring a Spring Initilizr Generated Spring Boot Project

Lecture 340 Using Maven with Spring Boot

Lecture 341 Using Gradle with Spring Boot

Lecture 342 Running and Debugging Spring Boot Apps in the IDE

Lecture 343 Understanding Layered Architecture in Spring Applications

Lecture 344 Important Spring Boot Resources You Should Know

Section 38: Taking a Tour of a Sample Spring Boot Application

Lecture 345 Section Introduction

Lecture 346 Downloading Spring Pet Clinic

Lecture 347 Building the Sprint Pet Clinic Application

Lecture 348 Running the app and taking a tour of the application

Lecture 349 Examining the project and it's dependencies in the IDE

Lecture 350 Examining the controllers and web layer

Lecture 351 Examining the repositories and data layer

Lecture 352 Examining the startup of a Spring Boot application

Lecture 353 Examining the application properties, logging configuration and profiles

Lecture 354 Summing Up the essence of how a spring boot application works

Section 39: Understanding Starter Dependencies

Lecture 355 Section Introduction

Lecture 356 Understanding Spring Boot Starter Dependencies

Lecture 357 Relating the Spring Boot dependency graph within your IDE

Lecture 358 Looking at the Flattened Resolved Dependencies Set

Lecture 359 Changing the Starter Dependency to Bring in a Tech Stack

Lecture 360 Relationship of Starter Dependencies w Autoconfiguration

Section 40: Understanding Autoconfiguration

Lecture 361 Section Introduction

Lecture 362 How Spring Boot Creates the Spring Application Container

Lecture 363 How @SpringBootApplication Configures a Spring Boot App

Lecture 364 Spring Factories for Autoconfigured Libraries

Lecture 365 Understanding a Typical Autoconfiguration

Lecture 366 Property Injection in Autoconfiguration Classes

Lecture 367 Conditions and Excluding and Overriding Autoconfiguration

Lecture 368 Debugging Autoconfiguration by Enabling Autoconfig Reporting

Section 41: Understanding Spring Boot Properties

Lecture 369 Section Introduction

Lecture 370 Common Properties in Spring Boot Which You Can Configure

Lecture 371 Injecting Properties into Spring Managed Beans

Lecture 372 Providing Default Values for Properties

Lecture 373 Overriding Properties at Runtime with System Properties

Lecture 374 Specifying Properties in YAML File Format

Lecture 375 Accessing Nested Properties and Strongly-Typed Property Values

Section 42: Exploring Startup of a Spring Boot Application

Lecture 376 Section Introduction

Lecture 377 Examining a Foundational Spring Boot Project

Lecture 378 Registration of Important Spring Application Listeners

Lecture 379 Preparing and Establishing the Spring Application Context

Lecture 380 Creating the Beans of the Spring Runtime

Lecture 381 Creating the Embedded Tomcat Web Server

Lecture 382 Publishing Spring Events to Application Listeners

Section 43: Wrapping Up

Lecture 383 Thanks and Wrap Up

Section 44: LEARN JUNIT AND MOCKITO - the world's Number 1 tools for Java testing!

Lecture 384 Welcome to the Course!

Lecture 385 Getting Help and Support

Lecture 386 Overview of the Course Structure

Lecture 387 A quick welcome and note on the course format

Section 45: Unit Testing Foundations

Lecture 388 Section Introduction

Lecture 389 What is Unit Testing?

Lecture 390 What is JUnit?

Lecture 391 Introducing a Simple Unit Test in JUnit

Lecture 392 Structure of a Unit Test

Lecture 393 Conventions for Writing Unit Tests

Lecture 394 Characteristics of Proper Unit Tests

Lecture 395 What are Assertions?

Section 46: Creating a Java Project which uses JUnit

Lecture 396 Section Introduction

Lecture 397 Creating a Java project which includes JUnit using Maven Quickstart

Lecture 398 Introducing a typical Java project structure (production vs test trees)

Lecture 399 Understanding the basic coding conventions for creating unit tests

Section 47: Writing and Running Unit Tests with JUnit and IntelliJ IDEA

Lecture 400 Section Introduction

Lecture 401 Assertions and JUnit's fail-fast test failure mechanism

Lecture 402 Creating a test method with the @Test annotation

Lecture 403 Running a unit test within the IDE and understanding test success

Lecture 404 Understanding test failures with exceptions

Lecture 405 Failing a unit test explicitly with Assert.fail

Lecture 406 Using Assert.fail to check validation logic in a try/catch

Lecture 407 An introduction to the JUnit Assertions API

Lecture 408 Structuring unit tests with Arrange/Act/Assert

Lecture 409 Adding comments to assertions and test failures to aid diagnostics

Lecture 410 Coding a unit test following Arrange-Act-Assert

Lecture 411 Keeping test setup DRY with @Before

Lecture 412 Understanding test fixture instantiation

Section 48: Unit Testing with Mock Objects and Mockito

Lecture 413 Section Introduction

Lecture 414 What is Mockito and what are Mock Objects?

Lecture 415 Introduction to testing with mock objects

Lecture 416 Configuring Projects to Use Mockito

Lecture 417 Creating a project which uses JUnit and Mockito

Lecture 418 Coding a Layered Architecture - Presentation Layer

Lecture 419 Coding a Layered Architecture - Business Layer

Lecture 420 Coding a Layered Architecture - Persistence Layer

Lecture 421 Putting the correct packages in place to respect the layering

Lecture 422 Writing a test for the Login Controller in the presentation layer

Lecture 423 Understanding the test fixture setup when writing mock tests

Lecture 424 Writing a test for the Authentication Service in the business

Lecture 425 Thinking about design decisions when unit testing

Section 49: Looking at the Hamcrest Assertions Library

Lecture 426 Section Introduction

Lecture 427 Evolving the Domain and Repository Classes

Lecture 428 Ignoring Tests with @ignore

Lecture 429 Implementing a Finder in the Repository

Lecture 430 Implementing Business Logic in the Service

Lecture 431 Configuring Maven to use Java 8

Lecture 432 Evolving the Repository Class

Lecture 433 Adding a Parameter-driven Finder to the Service

Lecture 434 Refactoring to Evolve a New Service

Lecture 435 Generating Test Methods in the IDE and Toggling Between Code

Lecture 436 Introducing the JUnit Mockito Runner and @Mock

Lecture 437 Analyzing Production Code to Determine How to Write Arrange Section

Lecture 438 Using Mockito's @InjectMocks to Create the SUT and Dependencies

Lecture 439 Keep Yourself Motivated by Checking the Happy Path Test Output

Lecture 440 Using the JUnit Assertions API to write the Assert Section

Lecture 441 Thinking About the Weaknesses of the JUnit Assertions API

Lecture 442 The Importance of Checking Your Work as you Go

Lecture 443 Replacing JUnit with Hamcrest assertions and asserting collections

Lecture 444 Understanding and Reading Hamcrest Test Failures

Lecture 445 Quick thoughts on Hamcrest individual vs collection Assertions

Lecture 446 Don't invoke unneeded production code in your test classes

Lecture 447 Understanding Evaluation of Hamcrest Matchers

Lecture 448 Thinking about why we keep production code to a minimum in tests

Lecture 449 Upgrading a JUnit project to use the full Hamcrest version

Lecture 450 Creating Complex Hamcrest Assertions with allOf and Property Matchers

Section 50: LEARN FUNCTIONAL JAVA - the world's Number 1 way of coding modern Java!

Lecture 451 Welcome to the Course!

Lecture 452 Section Introduction

Lecture 453 Difference Between Object-Oriented and Functional Programming Styles

Lecture 454 A Quick Look at the Main Java 8 Features

Section 51: Lambda Expressions and Functional Interfaces

Lecture 455 Passing Behaviour with Lambda Expressions

Lecture 456 Lambda Expressions Syntax and Examples

Lecture 457 An introduction to Functional Interfaces with Examples

Lecture 458 Using Function Descriptors to Choose Compatible Target Types

Section 52: Pipelines and Streams

Lecture 459 An Overview of Streams, Intermediate and Terminal Operations

Lecture 460 Pipeline Collection Processing and Stream API Common Operations

Section 53: Other Features

Lecture 461 What is an Optional and How Are They Used

Lecture 462 Understanding the Optionals API

Lecture 463 Mapping and Filtering with Optionals

Lecture 464 Understanding Default Methods

Lecture 465 Understanding Method References and Their Different Types

Section 54: Java 8 Coding Demos: Lambda Expressions and Functional Interfaces

Lecture 466 Section Introduction

Lecture 467 A Look at the Functional Interfaces API

Lecture 468 Coding and Referencing a Simple Lambda Expression

Lecture 469 Refactoring a Lambda Expression by Adapting a Functional Interface

Lecture 470 Providing Alternative Functional Interface Target Types for Lambdas

Lecture 471 Refactoring a Lambda Expression with its Method Reference

Lecture 472 Coding with the Consumer Functional Interface

Lecture 473 Coding with the Supplier Functional Interface

Lecture 474 Coding with the Function Functional Interface

Lecture 475 Coding with the Predicate Functional Interface

Section 55: Java 8 Coding Demos: The Stream API

Lecture 476 Coding a Collection of Domain Classes for Stream Processing

Lecture 477 Coding with the Streams API to Process a Complex Collection

Section 56: Java 8 Coding Demos: Other Features

Lecture 478 Coding with Bound and Unbound Instance Method References

Lecture 479 Coding with Static Method References

Lecture 480 Coding with Constructor Method References

Section 57: Wrapping Up

Lecture 481 Well Done and Thanks!

Section 58: ADDITIONAL CONTENT #1: Get Inside the Mind of a Professional Java Developer!

Lecture 482 #1: A Big Welcome to the Java Easily Podcast!

Lecture 483 #2: Why You Think You Struggle with Unit Testing

Lecture 484 #3: How to Become a Fully-Fledged Java Developer

Lecture 485 #4: How to Approach Object-Oriented Design

Lecture 486 #5: An Overview of the Java Platform for Complete Beginners to Java

Lecture 487 #6: What is Object Oriented Programming and Why Is It So Popular?

Lecture 488 #7: The Quickest Way to Learn Java for Absolute Beginners

Lecture 489 #8: What to do When You Feel Stuck as a Java Developer

Lecture 490 #9: Demystifying Java Classpaths

Lecture 491 #10: How Java Projects Are Developed and Managed

Lecture 492 #11: Essential Meetings Every Java Developer Should Know About

Lecture 493 #12: How a Java Developer Evolves from Beginner to Expert

Lecture 494 #13: How an IDE Makes Coding Easier

Lecture 495 #14: The Premium Developer Experience IDEs Give You

Lecture 496 #15: Why IDEs Are Super Useful for Analyzing Code

Lecture 497 #16: How To Fix Your Mindset to Get Coding Quickly

Lecture 498 #17: How To Start Coding Java Even If You Don't Know Where to Begin

Lecture 499 #18: Understanding Encapsulation in Object Oriented Programming

Lecture 500 #19: Explaining Inheritance Syntax in Java

Lecture 501 #20: Learning Why Polymorphism is an Awesome Feature in Java

Lecture 502 #21: Introducing Design Patterns to Develop Java Super Powers!

Lecture 503 #22: Unraveling the Most Common Compilation Errors that Beginners Encounter

Lecture 504 #23: What To Do When You're Overwhelmed By Java Tooling

Lecture 505 #24: The Differences Between Contracting and Going Permanent as a Java Developer

Lecture 506 #25: Demystifying the Top 3 Collection Classes in Java

Lecture 507 #26: The Different Competency Levels from Beginner to Expert Java Developer

Lecture 508 #27: Don't Have Time To Learn Java? Here's the Solution!

Lecture 509 #28: I'm a Java Developer and I Want to QUIT!

Section 59: ADDITIONAL CONTENT #2: Frequently Asked Questions for Brand New Java Developers!

Lecture 510 FAQ: Do I need to know math to learn Java?

Lecture 511 FAQ: Do I need to know other programming languages to learn java?

Lecture 512 FAQ: How do I get a job with Java programming skills?

Lecture 513 FAQ: What can I do with Java?

Lecture 514 FAQ: What is Java and how is it different from other programming languages?

Lecture 515 FAQ: What kind of computer do I need to code Java programs?

Lecture 516 FAQ: What tools do I need to program with Java?

Absolute beginners with no coding experience who want to start a career in software development.,Aspiring programmers looking to master Java and unlock high-paying job opportunities.,Students and professionals from any background who are eager to learn a valuable, in-demand skill.,Self-learners who want a structured, step-by-step guide to mastering Java from the ground up.,Career changers who are ready to enter the tech industry and need an easy-to-follow path into software engineering.,Java developers at any level who want to solidify their foundation and advance their skills with industry-standard tools and frameworks.,Anyone curious about coding and ready to dive into the exciting world of software engineering with a practical, hands-on approach.