Facundo Uferer
Java for Beginners
From basic algorithms to design patterns: master Java with professional best practices
Course roadmapThe recommended learning path: expand each module to see its lessons.
Lessons (25)
- Lesson 11
Basic Concepts and Your First Java Program
Understand the Java platform (JDK, JRE, JVM), WORA architecture, main method structure, and write your first interactive program.
- Lesson 22
Variables, Data Types, and Operators
Master primitive types, reference types, type casting, and operators in Java.
- Lesson 33
Control Flow and Loops
Learn to make decisions with conditionals and repeat tasks using loops in Java.
- Lesson 44
Arrays and String Handling in Java
Master single-dimensional arrays, matrices and jagged arrays, the java.util.Arrays utility class, the String memory model, the String Constant Pool, and StringBuilder.
- Lesson 55
Methods and Functions in Java
Understand code modularization, method signatures, return values, pass-by-value vs pass-by-reference, method overloading, and the Call Stack.
- Lesson 66
Algorithms: Specification, Verification, and Complexity
Learn to design, verify, and compare algorithms through contracts, tests, and time and space complexity analysis.
- Lesson 77
Object-Oriented Programming and its Four Pillars
Understand OOP paradigm, its advantages over procedural programming, and its 4 core pillars explained in Java with clear diagrams.
- Lesson 88
OOP Fundamentals: Classes, Objects, and Attributes
Master core practical OOP pillars in Java: class blueprints, instantiating objects with new, state, behavior, and the this reference.
- Lesson 99
Constructors, Access Modifiers, and Getters/Setters
Learn how to guarantee every object is born valid using constructors, overloading, and this(), then shield its internal state with encapsulation, access modifiers, and defensive copies.
- Lesson 1010
Arrays of Objects: Holding and Iterating Many Instances
Combine arrays with classes: create object arrays, avoid the NullPointerException from empty slots, iterate them, search, sort by hand with your own criterion, and manage capacity versus actual count.
- Lesson 1111
Inheritance, Polymorphism, and Method Overloading
Master inheritance with extends and super, overriding with @Override, the real difference between overloading and overriding, dynamic dispatch, and when composition beats inheritance.
- Lesson 1212
Abstract Classes, Interfaces, and Code Organization
Learn when to reach for an abstract class and when for an interface, implement several contracts at once, master namespaces and package organization in Java, and model association, aggregation, and composition.
- Lesson 1313
Exception Handling and Robustness
Understand the Throwable hierarchy, the difference between checked and unchecked, how an exception propagates up the stack, try-with-resources, custom exceptions, and the antipatterns to avoid.
- Lesson 1414
Java Collections and Generics (JCF)
Walk through the whole Java Collections Framework, understand why generics exist, learn how a HashMap works internally, and build the judgment to pick the right collection.
- Lesson 1515
Iterators, Ordering, and the equals/hashCode Contract
Understand what sits behind a for-each, why ConcurrentModificationException fires, how to sort with Comparable and Comparator, and why breaking the equals/hashCode contract makes your objects vanish.
- Lesson 1616
The List ADT: Static, Dynamic, and Linked
Understand what an Abstract Data Type is, why an array and a linked list solve the same problem with opposite costs, and build singly linked, doubly linked, and circular lists from scratch.
- Lesson 1717
The Stack and Queue ADTs: Linear Structures
Master LIFO and FIFO structures, implement them from scratch over nodes and arrays, understand the circular queue, and solve the classic balanced-brackets problem.
- Lesson 1818
The Tree ADT: Traversals and Binary Search Trees
Move from linear to hierarchical structures: tree vocabulary, the three depth-first traversals, level-order traversal with a queue, the BST, and why it degenerates.
- Lesson 1919
N-ary trees and vector-based representation
Model hierarchies with a variable number of children, transform them through first-child/next-sibling links, and store them with validated indices.
- Lesson 2020
Graphs: Matrix, Adjacency List, BFS, DFS, and Dijkstra
Model networks with graphs, choose between an adjacency matrix and an adjacency list, implement BFS and DFS with the right structure, and understand how Dijkstra finds the cheapest path.
- Lesson 2121
Files, Serialization, and JAR Packaging
Learn to persist data with the modern Files and Path API, understand the decorator pattern behind streams, serialize objects and their pitfalls, and package your app into an executable JAR.
- Lesson 2222
Concurrent Programming: Threads, Synchronization, and Pools
Master Java concurrency: thread lifecycle, shared memory synchronization, race conditions, ExecutorService, and Virtual Threads.
- Lesson 2323
Database Access with JDBC and Safe SQL
Connect your application to a relational database with JDBC, understand why PreparedStatement eliminates SQL injection, handle transactions with commit and rollback, and organize data access with the DAO pattern.
- Lesson 2424
Testing with JUnit and Your First Spring Boot App
Write unit tests with JUnit 5, understand the test pyramid and the AAA pattern, use mocks to isolate dependencies, and build a three-layer CRUD REST service with Spring Boot.
- Lesson 2525
Debugging, clean code, and refactoring
Learn to debug with breakpoints and watches, spot code smells in your Java code, and refactor it safely backed by JUnit tests.