Professional Java Developer Career Starter Java Foundations

Covers Java 17 & Earlier, Streams/Lambdas, Regex, TDD/Testing, Optionals, JDBC/SQL Intro to Spring & More Using IntelliJ
Professional Java Developer Career Starter Java Foundations
File Size :
83.28 GB
Total length :
87h 51m



Terry Martin


Last update

Last updated 12/2022



Professional Java Developer Career Starter Java Foundations

What you’ll learn

Foundations of the Java programming language
Object-oriented programming
Classes & Objects
Functional programming with Lambdas & Streams API
Testing & Test-Driven Development (TDD) with JUnit
Regular Expressions
Powerful features of IntelliJ IDE (Editor): Refactoring, Debugger, Creation of Project Types: Native, Maven, Gradle
Reflection API
Creating Annotations
Basics of Web application programming with the Spring Framework

Professional Java Developer Career Starter Java Foundations


No programming experience needed.
You should be familiar with downloading files to your computer from the Internet.
You should know how to find files on your computer.
You should know how to install typical software on your computer.


Note: This course is intended for absolute beginners to programming OR those who don’t mind a slower pace to learning Java. If you’re looking for a faster-paced course, this may not be for you (though you can play back at 2x speed & may still find great things to learn). Also, even for those who already know some basic Java, you could skip over the parts you already know and focus on those you may not, like Regex, Streams/Lambdas API, Optionals, Date/Time, SQL/Database/JDBC sections that even seasoned Java developers may not know as well as they should. Many of my sections on these APIs are as long or longer than MANY stand-alone courses dedicated to just one of these topics – for similar prices. Check out my preview videos from each of those sections to gauge how deep I go into each topic.If you’re interested in starting a new career as a professional software developer, learn the fundamentals from an instructor who has interviewed, hired, managed & mentored numerous developers over the years. This course will teach you all the REAL Java skills you need to land your first job and excel. It focuses on skills you’re actually likely to use most often and tries to de-emphasize more “academic” knowledge.   The instructor has taken his experiences and observations of both successful and unsuccessful developer candidates to create a course that tries to ensure success in landing highly-coveted developer jobs.In this course, you’ll learn such topics as:Object Oriented Programming (OOP) Too many so-called “Java” developers have learned the syntax of the language but have no idea how to harness its actual power to write sophisticated software that’s easier to maintain and collaborate on.Regular ExpressionsAnother unfortunate observation is that a majority of Java developers are very weak with Regular Expressions. This is unfortunate because so much of what Java tends to be used for, involves processing text and checking that it is valid or parsing key information out of it. Without the use of Regular Expressions, these tasks require considerable amounts of error-prone code that is inflexible and difficult to maintain.Functional Programming with Lambdas & Streams APIAnother sore-spot among a large number of Java developers. As of 2021, Java 17 is out, but the Functional programming APIs of Lambdas & Streams were introduced into Java with version 8. We’ve observed that developers simply aren’t keeping up with these powerful (not-so-new anymore) techniques that help keep Java competitive and efficient in an increasingly functional programming world. You can sift through large datasets with ease and significantly less code with these APIs.OptionalsTony Hoare, the inventor of the programming concept of “null”, called its invention his “billion-dollar mistake” dating back to 1965. That mistake has gone on to wreak havoc across numerous programming language ever since. Optionals seek to remedy that mistake. Unfortunately, not enough Java developers have learned and embraced the power of using Optionals. This topic seeks to remedy that shortcoming.Java 8 Date/Time APIJava was introduced in 1995 and heralded as the great, shiny new programming language of our time. To a large degree, one could argue that it is indeed, that. However, mistakes were made along the way. One of those mistakes was the way dates & times were handled. Java 8 made major strides in fixing those mistakes, but as with Optionals, Lambdas and many other topics mentioned, not enough developers have taken the time to learn the new and greatly improved Java 8 Date/Time API. We’ll show you how to keep time the right way.Working with Databases & SQLOne of the topics where it seems Java developers actually have kept up (mostly) is in learning modern ways to work with databases in Java – primarily through the use of frameworks like Spring Boot. However, one unfortunate side-effect of the massive levels of abstraction these frameworks afford us, is that many developers have little-to-no idea of what these frameworks are doing or how to use them to maximum effect. We’ll peel back the covers and give a solid foundation of the basics to better empower developers as they inevitably continue to use frameworks to make this work easier. An Introduction to The Spring Framework & Spring BootThe Spring Framework & its sibling, Spring Boot, have absolutely revolutionized modern Java software development – particularly for business. Dare I say virtually no company doing Java these days, even considers doing it without Spring or at least one of its few and much less popular competitors. You WILL have to learn Spring to be a true and well-rounded Java developer competitive in the job market. Though this course if focused on the fundamentals of Java, we knew we had to whet your appetite for the full(er) stack of Java development. Spring is what most companies use to enable their Java applications to become web applications and web services and talk to databases. This module will set you up for Neutrino’s upcoming course dedicated to the topic in full (because it deserves its own course).So, if you’re willing to put in the work, come join us and begin the next phase of your career.


Section 1: Getting Started with Java

Lecture 1 Welcome to the World of Java

Lecture 2 What is Java?

Lecture 3 Install JDK 17 on Windows

Lecture 4 Install JDK 17 on MacOS

Lecture 5 Installing a Java Editor (IntelliJ IDE)

Lecture 6 Hello World: Our First Simple Application

Lecture 7 Asking for Help

Lecture 8 Coding Exercises for the Whole Course

Lecture 9 Playing with Java Quickly & Easily

Section 2: Classes, Object & Methods

Lecture 10 Object Orientation

Lecture 11 Class Basics

Lecture 12 Variables & Data Types

Lecture 13 Simple Collections with Arrays

Lecture 14 Methods

Lecture 15 Varargs

Lecture 16 Static Methods

Lecture 17 Static Variables

Lecture 18 Static Initializers

Lecture 19 The Object Superclass

Lecture 20 Member Visibility: Methods

Lecture 21 Member Visibility: Fields

Lecture 22 Constructors

Lecture 23 Getters & Setters

Lecture 24 Exercises

Section 3: Working with Text

Lecture 25 Intro

Lecture 26 Creating Strings

Lecture 27 Upper & Lower Casing

Lecture 28 Strings: Blank or Empty?

Lecture 29 Replacing Text Within Strings

Lecture 30 Removing White Space – strip()

Lecture 31 Getting Individual Characters of a String – charAt()

Lecture 32 Comparing String for Alphabetical Order – compareTo()

Lecture 33 Determining if Text is Contained in a String – contains()

Lecture 34 String Concatenation – concat

Lecture 35 Determining the Length of a String – length()

Lecture 36 Getting Parts of a String – substring

Lecture 37 Searching within a String – indexOf()

Lecture 38 Splitting String Apart – split()

Lecture 39 Beginning & Ending of Strings – startsWith() & endsWith()

Lecture 40 Comparing Strings for Equality – contentEquals()

Lecture 41 Exercises

Section 4: Regular Expressions

Lecture 42 Intro to Regular Expressions

Lecture 43 ABCs of Regular Expressions: Part One

Lecture 44 ABCs of Regular Expressions: Part Two

Lecture 45 Capture Groups: Part One

Lecture 46 Capture Groups: Part Two

Lecture 47 Named Capture Groups

Lecture 48 Comments in Regular Expressions

Lecture 49 Wrapping Up Phone Number Parsing

Lecture 50 Additional Character Classes

Lecture 51 Parsing a Real Text Document

Lecture 52 Greedy Operators

Lecture 53 Finding Multiple Matches

Lecture 54 Exercises

Section 5: Numbers

Lecture 55 Introduction to Numbers

Lecture 56 Bits and Bytes

Lecture 57 Hexadecimal Numbers

Lecture 58 Numeric Data Types

Lecture 59 Bigger Numbers

Lecture 60 Floating Point Numbers

Lecture 61 Beyond Decimal

Lecture 62 Simple Math Operations

Lecture 63 Standard Math Functions

Lecture 64 More on Random Numbers

Lecture 65 Coding Exercise: Calculating the Area of a Circle

Lecture 66 Coding Exercise: Calculating Centripetal Force

Lecture 67 Comparing Numbers

Lecture 68 Introducing BigDecimal

Lecture 69 Using BigDecimal

Lecture 70 More on BigDecimal & BigInteger

Lecture 71 Coding Exercise: Calculating Compound Interest

Lecture 72 Formatting Numbers

Lecture 73 Customizing Number Formatters

Lecture 74 Additional Ways to Format Numbers

Lecture 75 Numeric Wrapper Classes

Lecture 76 Exercises

Section 6: Control Flow

Lecture 77 Intro to Control Flow

Lecture 78 Conditionals with If/Else

Lecture 79 Control Flow Inequalities

Lecture 80 The Switch Statement

Lecture 81 Switch Statement: New Features

Lecture 82 Switch Statement Pattern Matching JDK 17 Preview

Lecture 83 While Loops: Part One

Lecture 84 While Loops: Part Two

Lecture 85 Do/While Loops: Part One

Lecture 86 Do/While Loops: Part Two

Lecture 87 For Loops

Lecture 88 A Simpler For Loop

Lecture 89 The Enhanced For Loop

Lecture 90 Applying Loops to Regex

Lecture 91 Exercises

Section 7: Testing Code

Lecture 92 Intro to Testing

Lecture 93 Setting Up

Lecture 94 Our First Test

Lecture 95 Writing the Second Test

Lecture 96 Testing Edge Cases

Lecture 97 Testing Annuity Calculation

Lecture 98 Reimplementing the Guessing Game with TDD

Lecture 99 Guessing Game TDD Part Two

Lecture 100 Implementing Randomness

Lecture 101 Testing for Randomness: A Deeper Explanation

Lecture 102 Tracking the Number of Guesses

Lecture 103 Handling More than Four Guesses

Lecture 104 Wrapping up Testing

Lecture 105 Reimplementing the Guessing Game User Interface

Lecture 106 Debugging Code: Part One

Lecture 107 Debugging Code: Part Two

Lecture 108 Exercises

Section 8: More OOP

Lecture 109 Intro

Lecture 110 Enums

Lecture 111 Enum Ordinals

Lecture 112 Enum Methods

Lecture 113 Enum Fields

Lecture 114 Enum ValueOf

Lecture 115 The ‘this’ Keyword

Lecture 116 Setup for More Advanced OOP Topics

Lecture 117 Employee Salaries Continued

Lecture 118 Completing Other Employee Cases

Lecture 119 Introducing a Programmer Class

Lecture 120 Implementing the Other Employee Classes

Lecture 121 Introducing Interfaces

Lecture 122 Revisiting Class Hierarchies

Lecture 123 Completing the Employee Class Hierarchy

Lecture 124 Dealing with the Null Case

Lecture 125 Introducing Abstract Classes

Lecture 126 Factory Methods

Lecture 127 Nested Classes

Lecture 128 Other Types of Nested Classes

Lecture 129 Records

Lecture 130 Lambdas Versus Anonymous Classes

Lecture 131 Composition Versus Inheritance

Lecture 132 Default Methods

Lecture 133 Comparing Classes with ‘instanceof’

Lecture 134 OOP Recap

Lecture 135 Exercises

Lecture 136 Solutions & Explanations to Exercises 8.1

Lecture 137 Solutions & Explanations to Exercises 8.2 – 8.3

Lecture 138 Solutions & Explanations to Exercises 8.4 – 8.9

Lecture 139 Solutions & Explanations to Exercises 8.10 – 8.19

Lecture 140 Solutions & Explanations to Exercises 8.20 – 8.22

Section 9: Collections

Lecture 141 Intro to Collections

Lecture 142 List Basics

Lecture 143 Linked Lists

Lecture 144 Looping with Iterators

Lecture 145 Loose Ends of Lists

Lecture 146 Additional List Methods

Lecture 147 List.contains() & Object.equals()

Lecture 148 Implementing Comparator to Sort Lists

Lecture 149 Implementing Comparable to Sort Lists

Lecture 150 Intro to Sets

Lecture 151 Sets & Hashcode

Lecture 152 LinkedHashSet

Lecture 153 TreeSet

Lecture 154 Intro to Maps

Lecture 155 A Map Scenario

Lecture 156 Using Map Implementations

Lecture 157 Additional Map Methods

Lecture 158 Wrapping Up

Lecture 159 Exercises

Section 10: Streams & Lambdas

Lecture 160 Intro to Streams & Lambdas

Lecture 161 First Steps into Streams API

Lecture 162 Streams Explained

Lecture 163 Creating Streams

Lecture 164 Summing with Streams

Lecture 165 Sorting with Streams

Lecture 166 Filtering with Streams

Lecture 167 Additional Filtering Techniques

Lecture 168 Flattening Streams of Streams

Lecture 169 Alternatives to Filter

Lecture 170 The Map Reduce Pattern

Lecture 171 Intro to More Advanced Streams

Lecture 172 Big Data Summing

Lecture 173 Domain Models with Streams API

Lecture 174 Grouping Records

Lecture 175 Summing by Groups

Lecture 176 Nested Groupings

Lecture 177 Reducing with Collect

Lecture 178 Partitioning vs Grouping

Lecture 179 Functional Interfaces

Lecture 180 Functional Methods of Collections

Lecture 181 Exercises

Section 11: Loose Ends

Lecture 182 Exceptions

Lecture 183 Checked Exceptions

Lecture 184 Generics: Part One

Lecture 185 Generics: Part Two

Lecture 186 Optionals: Part One

Lecture 187 Optionals: Part Two

Lecture 188 Dates & Times: Intro

Lecture 189 Dates & Times: Periods & Durations

Lecture 190 Dates & Times: Time Zones

Lecture 191 Dates & Times: Parsing & Formatting

Lecture 192 Dates & Times: Temporal Adjustors & Immutability

Section 12: Databases

Lecture 193 Getting Started with Databases

Lecture 194 Installing Squirrel SQL Client

Lecture 195 Let’s Learn Some SQL

Lecture 196 Creating & Retrieving Records

Lecture 197 Database Functions

Lecture 198 The “UD” in “CRUD”

Lecture 199 Creating a New Database Project

Lecture 200 TDD for Saving a Person

Lecture 201 Writing the JDBC Code to Save a Person

Lecture 202 Tidying Up & Explaining Our Save Code

Lecture 203 Finding a Person By ID

Lecture 204 FindById: A Negative Case

Lecture 205 Deleting a Person

Lecture 206 Deleting Multiple People at Once

Lecture 207 Updating a Person

Lecture 208 Creating a Reusable CRUD Repository

Lecture 209 CRUD Repository: FindById

Lecture 210 CRUD Repository: Completing the Remaining Methods

Lecture 211 CRUD Repository: Implementing a Custom Annotation

Lecture 212 CRUD Repository: Allowing Multiple SQL Annotations

Lecture 213 CRUD Repository: Custom ID Annotation

Lecture 214 Loading Five Million People with PeopleRepository

Lecture 215 Speeding up the Queries with Indexes

Lecture 216 Creating an Address Table

Lecture 217 Saving One Address

Lecture 218 Saving a Person without an Address

Lecture 219 Fetching a Person with Their Address

Lecture 220 Fetching Address in One Go with Join Queries

Lecture 221 Joins with Missing Addresses

Lecture 222 Adding a Second Address Field

Lecture 223 Brief Word of Encouragement

Lecture 224 Adding Children

Lecture 225 Fetching Children in One Join

Lecture 226 Writing Code to Fetch Children in One Join

Lecture 227 Troubleshooting Techniques for Broken Tests

Lecture 228 Fixing FindAll for Join-Fetched Child Code

Lecture 229 Join Tables

Lecture 230 Optimizing with Caching

Lecture 231 Optimizing Prepared Statements

Lecture 232 Conclusion

Section 13: Intro to the Spring Framework

Lecture 233 Introduction

Lecture 234 Creating the PeopleDB-Web Project

Lecture 235 Implementing Web Hello World

Lecture 236 Web & HTTP Basics

Lecture 237 Displaying a Simple List of People

Lecture 238 Introducing a Bootstrap Table for People

Lecture 239 Formatting Dates & Salaries

Lecture 240 Introducing Spring Data

Lecture 241 Saving People

Lecture 242 UI & Database Tweaks

Lecture 243 Validating Data

Lecture 244 Deleting People

Lecture 245 Updating People

Lecture 246 Internationalization

Lecture 247 Uploading a File

Lecture 248 Saving Uploaded Files

Lecture 249 Retrieving Uploaded Files

Lecture 250 Handling Exceptions in UI

Lecture 251 Introducing a Service Layer for Coordination & Logic

Lecture 252 Coordinating Deletes with a Service

Lecture 253 Custom Query Methods

Lecture 254 Pagination

Lecture 255 Importing a CSV File

Lecture 256 Fixing Deletes & UI Loose Ends

Lecture 257 Items Not Covered Thoroughly

Lecture 258 Where to Go from Here

Lecture 259 Bonus Lecture: Check out my other courses

People with little to no experience programming (If you’re already proficient w/another language, watch preview videos to confirm the pacing is to your liking. The first half of course is paced for absolute beginners),People interested in starting a new career as a professional software developer,Students wanting to learn Java or the basics of modern computer programming,People interested in learning more about Object-Oriented Programming (OOP)

Course Information:

Udemy | English | 87h 51m | 83.28 GB
Created by: Terry Martin

You Can See More Courses in the Developer >> Greetings from

New Courses

Scroll to Top