Mô tả

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 Expressions

    • Another 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 API

    • Another 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.

  • Optionals

    • Tony 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 API

    • Java 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 & SQL

    • One 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 Boot

    • The 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.

Bạn sẽ học được gì

Yêu cầu

Nội dung khoá học

13 sections

Getting Started with Java

11 lectures
Welcome to the World of Java
03:19
What is Java?
05:05
Installing JDK 21 + IntelliJ IDE on MacOS with SDKMan + Homebrew
15:56
Installing JDK 21 + IntelliJ IDE on Windows with Chocolatey
19:59
Legacy Lesson - Install JDK 17 on Windows
03:03
Legacy Lesson - Install JDK 17 on MacOS
04:12
Legacy Lesson - Installing a Java Editor (IntelliJ IDE)
05:43
Hello World: Our First Simple Application
09:16
Asking for Help
06:32
Coding Exercises for the Whole Course
06:24
Playing with Java Quickly & Easily
00:55

Classes, Object & Methods

16 lectures
Object Orientation
34:43
Class Basics
17:52
Variables & Data Types
18:50
var Variables
06:49
Simple Collections with Arrays
19:57
Methods
32:54
Varargs
11:24
Static Methods
09:03
Static Variables
06:27
Static Initializers
05:41
The Object Superclass
15:01
Member Visibility: Methods
33:11
Member Visibility: Fields
07:19
Constructors
22:50
Getters & Setters
22:45
Exercises
00:03

Working with Text

18 lectures
Intro
00:57
Creating Strings
17:08
Upper & Lower Casing
09:59
Strings: Blank or Empty?
05:38
Replacing Text Within Strings
06:29
Removing White Space - strip()
19:09
Getting Individual Characters of a String - charAt()
05:27
Comparing String for Alphabetical Order - compareTo()
09:35
Determining if Text is Contained in a String - contains()
03:17
String Concatenation - concat
29:15
Determining the Length of a String - length()
10:32
Getting Parts of a String - substring
20:36
Searching within a String - indexOf()
32:11
Splitting String Apart - split()
23:38
Beginning & Ending of Strings - startsWith() & endsWith()
08:24
Comparing Strings for Equality - contentEquals()
15:05
JDK 21 String Templates
11:04
Exercises
00:03

Regular Expressions

13 lectures
Intro to Regular Expressions
02:23
ABCs of Regular Expressions: Part One
13:07
ABCs of Regular Expressions: Part Two
34:23
Capture Groups: Part One
25:27
Capture Groups: Part Two
12:57
Named Capture Groups
13:03
Comments in Regular Expressions
11:25
Wrapping Up Phone Number Parsing
06:43
Additional Character Classes
19:53
Parsing a Real Text Document
40:13
Greedy Operators
15:31
Finding Multiple Matches
16:06
Exercises
00:03

Numbers

22 lectures
Introduction to Numbers
00:52
Bits and Bytes
09:03
Hexadecimal Numbers
09:32
Numeric Data Types
17:25
Bigger Numbers
11:32
Floating Point Numbers
19:40
Beyond Decimal
26:03
Simple Math Operations
37:26
Standard Math Functions
17:35
More on Random Numbers
07:01
Coding Exercise: Calculating the Area of a Circle
06:04
Coding Exercise: Calculating Centripetal Force
21:49
Comparing Numbers
05:51
Introducing BigDecimal
09:09
Using BigDecimal
12:30
More on BigDecimal & BigInteger
11:58
Coding Exercise: Calculating Compound Interest
31:12
Formatting Numbers
19:47
Customizing Number Formatters
13:03
Additional Ways to Format Numbers
14:24
Numeric Wrapper Classes
24:40
Exercises
00:03

Control Flow

16 lectures
Intro to Control Flow
06:00
Conditionals with If/Else
27:20
Control Flow Inequalities
07:50
The Switch Statement
19:41
Switch Statement: New Features
22:38
While Loops: Part One
26:45
Switch Statement Pattern Matching in JDK 21
14:57
Legacy Lesson (see JDK 21 version) Switch Statement Pattern Matching JDK 17
11:16
While Loops: Part Two
22:03
Do/While Loops: Part One
32:13
Do/While Loops: Part Two
23:34
For Loops
26:18
A Simpler For Loop
09:39
The Enhanced For Loop
04:39
Applying Loops to Regex
06:20
Exercises
00:03

Testing Code

17 lectures
Intro to Testing
02:53
Setting Up
18:58
Our First Test
28:35
Writing the Second Test
23:32
Testing Edge Cases
12:18
Testing Annuity Calculation
19:21
Reimplementing the Guessing Game with TDD
19:50
Guessing Game TDD Part Two
37:22
Implementing Randomness
19:50
Testing for Randomness: A Deeper Explanation
25:25
Tracking the Number of Guesses
34:39
Handling More than Four Guesses
11:38
Wrapping up Testing
24:57
Reimplementing the Guessing Game User Interface
13:20
Debugging Code: Part One
35:45
Debugging Code: Part Two
17:04
Exercises
00:03

More OOP

33 lectures
Intro
01:31
Enums
31:00
Enum Ordinals
21:59
Enum Methods
20:56
Enum Fields
22:38
Enum ValueOf
12:21
The 'this' Keyword
12:53
Setup for More Advanced OOP Topics
13:17
Employee Salaries Continued
29:01
Completing Other Employee Cases
24:27
Introducing a Programmer Class
34:11
Implementing the Other Employee Classes
26:22
Introducing Interfaces
29:29
Revisiting Class Hierarchies
20:53
Completing the Employee Class Hierarchy
19:02
Dealing with the Null Case
07:34
Introducing Abstract Classes
22:15
Factory Methods
27:37
Nested Classes
09:48
Other Types of Nested Classes
17:43
Records
20:34
Lambdas Versus Anonymous Classes
18:42
Composition Versus Inheritance
24:53
Default Methods
21:58
Comparing Classes with 'instanceof'
19:21
Unnamed Patterns
11:52
OOP Recap
20:46
Exercises
00:03
Solutions & Explanations to Exercises 8.1
36:11
Solutions & Explanations to Exercises 8.2 - 8.3
42:04
Solutions & Explanations to Exercises 8.4 - 8.9
20:38
Solutions & Explanations to Exercises 8.10 - 8.19
20:04
Solutions & Explanations to Exercises 8.20 - 8.22
20:49

Collections

20 lectures
Intro to Collections
04:51
List Basics
22:27
Linked Lists
26:51
Looping with Iterators
20:32
Loose Ends of Lists
07:21
Additional List Methods
27:02
List.contains() & Object.equals()
43:50
Implementing Comparator to Sort Lists
31:04
Implementing Comparable to Sort Lists
38:10
Intro to Sets
19:53
Sets & Hashcode
22:45
LinkedHashSet
12:33
TreeSet
25:40
Intro to Maps
04:11
A Map Scenario
25:41
Using Map Implementations
29:46
Additional Map Methods
24:49
JDK 21 Collections Changes
08:06
Wrapping Up
03:55
Exercises
00:03

Streams & Lambdas

22 lectures
Intro to Streams & Lambdas
01:47
First Steps into Streams API
22:16
Streams Explained
11:09
Creating Streams
42:40
Summing with Streams
28:57
Sorting with Streams
25:09
Filtering with Streams
24:09
Additional Filtering Techniques
20:42
Flattening Streams of Streams
31:34
Alternatives to Filter
30:08
The Map Reduce Pattern
45:32
Intro to More Advanced Streams
23:45
Big Data Summing
46:06
Domain Models with Streams API
18:49
Grouping Records
24:15
Summing by Groups
22:17
Nested Groupings
29:00
Reducing with Collect
18:12
Partitioning vs Grouping
12:56
Functional Interfaces
11:44
Functional Methods of Collections
38:29
Exercises
00:03

Loose Ends

11 lectures
Exceptions
36:19
Checked Exceptions
19:09
Generics: Part One
30:19
Generics: Part Two
34:27
Optionals: Part One
31:01
Optionals: Part Two
42:23
Dates & Times: Intro
28:45
Dates & Times: Periods & Durations
08:02
Dates & Times: Time Zones
15:43
Dates & Times: Parsing & Formatting
31:42
Dates & Times: Temporal Adjustors & Immutability
12:59

Databases

43 lectures
Getting Started with Databases
12:25
Installing DBeaver SQL Client
09:16
Installing Squirrel SQL Client
14:52
Let's Learn Some SQL
20:42
Creating & Retrieving Records
20:54
Database Functions
12:28
The "UD" in "CRUD"
12:46
Creating a New Database Project
29:12
TDD for Saving a Person
19:21
Writing the JDBC Code to Save a Person
28:57
Tidying Up & Explaining Our Save Code
37:32
Creating a Custom Save Exception
08:31
Finding a Person By ID
41:32
FindById: A Negative Case
10:58
Deleting a Person
09:43
Deleting Multiple People at Once
18:48
Updating a Person
34:25
Creating a Reusable CRUD Repository
21:14
CRUD Repository: FindById
09:32
CRUD Repository: Completing the Remaining Methods
22:52
CRUD Repository: Implementing a Custom Annotation
31:41
CRUD Repository: Allowing Multiple SQL Annotations
38:32
CRUD Repository: Custom ID Annotation
28:53
Loading Five Million People with PeopleRepository
32:30
Speeding up the Queries with Indexes
22:50
Creating an Address Table
30:23
Saving One Address
39:39
Saving a Person without an Address
20:00
Fetching a Person with Their Address
20:08
Fetching Address in One Go with Join Queries
28:59
Joins with Missing Addresses
40:02
Adding a Second Address Field
41:29
Brief Word of Encouragement
04:14
Challenge: Adding a Spouse
04:37
Adding Children
28:52
Fetching Children in One Join
21:24
Writing Code to Fetch Children in One Join
32:40
Troubleshooting Techniques for Broken Tests
17:00
Fixing FindAll for Join-Fetched Child Code
29:04
Join Tables
13:56
Optimizing with Caching
27:11
Optimizing Prepared Statements
17:35
Conclusion
34:32

Intro to the Spring Framework

27 lectures
Introduction
09:31
Creating the PeopleDB-Web Project
14:50
Implementing Web Hello World
09:05
Web & HTTP Basics
22:03
Displaying a Simple List of People
22:52
Introducing a Bootstrap Table for People
25:19
Formatting Dates & Salaries
30:02
Introducing Spring Data
44:02
Saving People
42:16
UI & Database Tweaks
31:14
Validating Data
29:51
Deleting People
27:26
Updating People
37:58
Internationalization
39:59
Uploading a File
33:12
Saving Uploaded Files
38:13
Retrieving Uploaded Files
35:22
Handling Exceptions in UI
35:10
Introducing a Service Layer for Coordination & Logic
28:43
Coordinating Deletes with a Service
18:15
Custom Query Methods
17:20
Pagination
39:01
Importing a CSV File
37:43
Fixing Deletes & UI Loose Ends
26:18
Items Not Covered Thoroughly
35:11
Where to Go from Here
32:07
Bonus Lecture: Check out my other courses
00:22

Đánh giá của học viên

Chưa có đánh giá
Course Rating
5
0%
4
0%
3
0%
2
0%
1
0%

Bình luận khách hàng

Viết Bình Luận

Bạn đánh giá khoá học này thế nào?

image

Đăng ký get khoá học Udemy - Unica - Gitiho giá chỉ 50k!

Get khoá học giá rẻ ngay trước khi bị fix.