Section outline

  • Collapse Expand

    General

    Collapse all Expand all

    • girl fighting against AI with jiu-jitsu

    • Jiu‑Jitsu – Java

      Java Jiu‑Jitsu: Use Structure as Leverage. Control Complexity. Win Against AI.
      Training teens to build real software systems — not just small scripts.

      ✅ Start here (free)

      Start at Lesson 1 and train forward in short, clear micro‑presentations. Java is not “quick hacks” — it’s leverage through structure.

      1. Begin Lesson 1: Enter the Dojo: Why Java Still Wins
      2. Train the slides (one concept per screen)
      3. (Paid members) Take the drill quiz / challenge and record your score
      4. Repeat daily — belt by belt

      Goal: become the kind of developer who can handle big systems — the kind AI can’t easily replace with shallow, repetitive code.

      👨‍👩‍👧 Why this course matters (for parents)

      AI will replace repetitive, shallow coding first. Your teen wins by learning structured software development: clean logic, strong design, testing, and real-world engineering discipline.

      Java is used in serious systems (enterprise software, large applications, backend services), and Jiu‑Jitsu is the art of leverage: you don’t win by brute force — you win by structure, control, and technique.

      Parent benefit: your teen builds skills that transfer into real jobs: problem-solving, engineering thinking, and the ability to work inside large codebases. Paid membership adds measurable progress (scores + belt exams).

      🔥 For teens (win with leverage)

      Most people “code” by copying snippets. AI can do that faster than them. Your advantage is to become someone who understands systems: structure, design, debugging, testing, and control.

      • Short missions (bite‑size training, not long boring lectures)
      • Belts that prove you’re leveling up
      • Retakes allowed (best score counts — improve without fear)
      • Real power: OOP, collections, streams, concurrency — the skills behind real software

      Challenge: earn White Belt (setup + first control) and build momentum. If you like this dojo, send it to a friend who wants to win too.

      🧠 What your teen will learn (high value targets)
      • Java 17 + IntelliJ setup (modern Java workflow)
      • Core syntax: variables, types, expressions, conditionals, loops
      • Methods + overloading (reusable thinking)
      • OOP: classes, encapsulation, constructors, inheritance, polymorphism
      • Data: arrays, lists, sets, maps, enums
      • Modern Java: generics, lambdas, streams, optionals
      • Professional topics: immutability, I/O, regex, concurrency
      • Real-world systems: databases, networking
      • Survival skills: debugging + unit testing
      🥋 Belt map (Jiu‑Jitsu ranks)
      • White Belt — Lessons 1–3: Setup & First Control
      • Yellow Belt — Lessons 4–9: Fundamentals
      • Orange Belt — Lessons 10–12: OOP Foundations
      • Green Belt — Lessons 13–14: Leverage & Design
      • Blue Belt — Lessons 15–16: Data Handling
      • Brown Belt — Lessons 17–22: Professional Java
      • Black Belt — Lessons 23–28: Systems Builder

      Belts are proof of progress. Parents get visibility. Teens get momentum.

      🏷️ Free vs Dojo Membership (paid)

      Free (Guest Training)

      • Access the free lesson content (training slides / micro‑presentations)
      • See the curriculum and belt map
      • Try sample drills (optional)

      Dojo Membership (Paid)

      • Full access to all drills, quizzes, and belt tests
      • Belt tracking and certificates
      • Parent progress tracking (scores + activity history)

      Founders / Inauguration Price: $5 per course for 30 days (about the price of a coffee). This is the launch price while the dojo is expanding — as more belts, exams, and courses are added, the price will rise.

      Optional later: “Master Check‑Ins” for motivation/accountability (not technical Q&A).

      📚 Curriculum (Training Forms)
      1. Enter the Dojo: Why Java Still Wins
      2. Gear Up: Install Java 17 + IntelliJ
      3. Hello World + Errors
      4. Variables, Types, and Precision
      5. Operators, Expressions, and Clean Code
      6. Conditionals that Don’t Lie
      7. Switch + Loops + Real Flow
      8. Input, Parsing, and Exceptions
      9. Methods + Overloading
      10. Classes, Objects, and Encapsulation
      11. Constructors, Records, and Modern Objects
      12. Inheritance + Overriding + java.lang.Object
      13. Composition (HAS-A) and Real Modeling
      14. Polymorphism in Action
      15. Arrays + 2D Arrays
      16. Lists, Iterators, Autoboxing, Enums
      17. Abstraction + Interfaces
      18. Generics + Comparators
      19. Lambdas + Method References
      20. Collections: Sets + Maps at Scale
      21. Streams + Optionals
      22. Immutability + final + Defensive Coding
      23. Regex + File I/O + Serialization
      24. Concurrency and Multithreading
      25. Databases (JDBC + JPA Concepts)
      26. Networking (TCP/UDP/HTTP/WebSockets)
      27. Debugging + Unit Testing (JUnit)
      28. Optional: JavaFX UI + Modules (JPMS)

      Disclaimer: This course provides education and training and cannot guarantee a specific job outcome.

      ✅ Belt Test Rules (read before testing)

      Passing score: 80%
      Retries: Unlimited
      Score policy: Best score counts

      How belts are earned

      1. Training Drills (Lesson Quizzes / Challenges) — short quizzes after lessons
      2. Belt Test (Rank Exam) — a larger exam covering the belt section

      Eligibility

      You must complete the drills for the lessons in that belt section to unlock the belt test.

      Integrity (important)

      • This is You vs AI: no AI tools or outside help during belt tests.
      • Drills are for learning; belt tests are for proof.
      • Parents are encouraged to be present or nearby during belt tests.

      Disclaimer: Belts and certificates recognize course progress and assessment performance. They do not guarantee a job outcome.

  • Collapse Expand

    Lesson 1: Enter the Dojo – Why Java Still Wins

    Overview: Lesson 1 inspires students by highlighting Java’s origins, key strengths, and enduring relevance. Teens and parents learn why Java remains a champion in the programming world (even against newer languages and AI). This lesson sets a motivational tone: prepare to win against AI in the job war by mastering Java! It is broken into micro-topics that fit into short slide decks.

    • Micro-Topic 1: The Legend of Java (Origins & Purpose)

      Goal: Understand where Java came from and its original design goals (platform independence and reliability).

    • WB L1 1 The Legend of Java FREE v3 SCORM package

    • Micro-Topic 2: Java’s Secret Weapons – How Java Works (WORA, JVM, and More)

      Goal: Explain the key features that give Java its enduring edge: the Java Virtual Machine, bytecode, and robust programming features (OOP, memory management, etc.).

    • WB L1 2 Javas Secret Weapons FREE SCORM package

    • Micro-Topic 3: Java in the Modern World – Undefeated Champion

      Goal: Showcase where Java is used today and why it’s still one of the most popular languages in 2025. Students gain perspective on Java’s real-world applications and job market strength.

    • WB L1 3 Java in the Modern World FREE SCORM package

    • Micro-Topic 4: Java vs. The New Kids – Endurance and Evolution

      Goal: Compare Java to newer languages and technologies, highlighting Java’s strengths (performance, scalability, backward compatibility) and how it continues to thrive alongside “hot” new languages. Reinforce that experience with Java is a long-term asset.

    • WB L1 4 Java vs New Kids FREE SCORM package

    • Micro-Topic 5: Your Java Journey – White Belt to Black Belt

      Goal: Motivate and outline the learning path. Emphasize that mastering Java is an empowering journey that will give learners a competitive edge. Set expectations for the course and beyond (white belt is just the beginning).

    • WB L1 5 Your Java Journey FREE SCORM package
  • Collapse Expand

    Lesson 2: Gear Up – Install Java 17 + IntelliJ

    Overview: Lesson 2 is all about setting up the development environment. We ensure students (and parents) install Java 17 and IntelliJ IDEA properly, but also teach them how to compile and run Java without an IDE. The tone stays encouraging but instructional – by the end of this lesson, their “gear” (tools) will be ready for battle. We emphasize that after this, the focus will be on coding, and the IDE is just a helpful optional weapon, not a crutch.

    • Micro-Topic 1: Tools of the Trade – JDK, JRE, and IDE Explained

      Goal: Clarify the essential tools needed to write and run Java programs. Students learn what the JDK is, how it differs from a JRE, and the role of an IDE like IntelliJ. This demystifies the setup.

    • WB L2 1 Tools of the Trade FREE SCORM package

    • Micro-Topic 2: Installing JDK 17 – Your Java Power Source

      Goal: Walk through installing Java 17 (JDK) on the student’s machine. Ensure they can verify the installation (javac and java working). Emphasize that Java 17 is the foundation for all coding exercises.

    • WB L2 2 Installing JDK 17 FREE SCORM package

    • Micro-Topic 3: Installing IntelliJ IDEA – Your Coding Dojo

      Goal: Guide students through downloading and installing IntelliJ IDEA (Community Edition). Emphasize using the free Community Edition and basic initial setup. By the end, they can launch IntelliJ.

    • WB L2 3 Installing IntelliJ IDEA FREE SCORM package

    • Micro-Topic 4: First Project – Hello World in IntelliJ

      Goal: Create a simple “Hello World” project in IntelliJ IDEA to verify that the IDE and JDK are configured correctly. The student will run their first Java program through IntelliJ.

    • WB L2 4 Hello World in IntelliJ FREE SCORM package

    • Micro-Topic 5: No IDE? No Problem! – Compiling and Running Java from the Command Line

      Goal: Teach how to compile and run a Java program using just a text editor and command prompt/terminal. This reinforces what the IDE is doing behind the scenes and proves that students aren’t dependent on IntelliJ. After this, they’ll understand the Java toolchain more deeply.

    • WB L2 5 No IDE No Problem FREE SCORM package

    • Micro-Topic 6: Choosing Your Weapon – IDE vs. Plain Editor (Flexibility)

      Goal: Reinforce that after Lesson 2, students can choose any development approach. IntelliJ is recommended for convenience, but they are not locked in. Emphasize flexibility and that the skills are universal.

    • WB L2 6 Choosing Your Weapon FREE SCORM package
  • Collapse Expand

    Lesson 3: Hello World + Errors – Your First Fight

    Overview: Lesson 3 is the true start of hands-on Java programming. Students write the classic “Hello World” and learn the basic structure of a Java program. More importantly, they learn to face and overcome errors – both compilation errors and runtime errors. The tone is encouraging: errors are like an opponent’s punches; with training, you learn to dodge and counter them. By the end, students won’t fear errors but see them as guidance.

    • Micro-Topic 1: Anatomy of a Java Program – Classes, Methods, and Braces

      Goal: Explain the structure of a basic Java program. Students learn about the class definition, the main method signature, and how curly braces {} define code blocks. This is the skeleton they will use for every program.

    • WB L3 1 Anatomy of a Java Program FREE SCORM package

    • Micro-Topic 2: Writing Your First Program – Hello, World!

      Goal: Guide through writing a simple “Hello, World!” program (again, but now focusing on each part of writing it themselves). Demonstrate how to run it (in IntelliJ or command line), and that it prints output. It reinforces the structure from micro-topic 1 with a concrete example.

    • WB L3 2 Writing Your First Program FREE SCORM package

    • Micro-Topic 3: Understanding the Code – Breaking Down Hello World

      Goal: Delve a bit deeper into what each part of the Hello World code does, but in beginner-friendly terms. Clarify any points of confusion (like “public static void”) at a superficial level and promise deeper coverage later. Ensure the student conceptually knows which part is the class, which is the method, which is the statement, etc.

    • WB L3 3 Understanding the Code FREE SCORM package

    • Micro-Topic 4: Java Syntax Essentials – Common Mistakes (Case, Semicolons, Braces)

      Goal: Highlight the most common syntax mistakes beginners make and how to avoid/fix them: missing semicolons, mismatched braces, wrong case in identifiers, and similar pitfalls. Train them to carefully pay attention to these “small” things that are very important in Java.

    • WB L3 4 Java Syntax Essentials FREE SCORM package

    • Micro-Topic 5: Embracing Errors – Reading and Debugging Basic Errors

      Goal: Teach students how to interpret error messages and debug simple issues. Emphasize that errors are normal and how to systematically fix them (check line numbers, the message, likely causes, etc.). Build confidence that they can overcome errors rather than feeling defeated.

    • WB L3 5 Embracing Errors FREE SCORM package

    • Micro-Topic 6: Common Errors in Hello World – Examples and Solutions

      Goal: Show a few concrete examples of mistakes in a Hello World program and walk through solving them. This ties together micro-topics 3, 4, 5 by demonstrating the debugging thought process. It builds confidence that they can fix issues on their own.

    • WB L3 6 Common Hello World Errors FREE SCORM package
  • Collapse Expand

    Lesson 4: Variables, Types, and Precision

  • Collapse Expand

    Lesson 5: Operators, Expressions, and Clean Code

    • Micro-Topic 5.1: Arithmetic Operators and Expressions

    • yb l5 mt5 1 free content SCORM package

    • Micro-Topic 5.2: Operator Precedence and Grouping

    • yb l5 mt5 2 free content SCORM package

    • Micro-Topic 5.3: Assignment and Compound Operators

    • yb l5 mt5 3 free content SCORM package

    • Micro-Topic 5.4: Increment and Decrement Operations

    • yb l5 mt5 4 free content SCORM package

    • Micro-Topic 5.5: Comparison and Logical Operators

    • yb l5 mt5 5 free content SCORM package

    • Micro-Topic 5.6: Clean Code Practices (Naming, Style, Clarity)

    • yb l5 mt5 6 free content SCORM package
  • Collapse Expand

    Lesson 6: Conditionals that Don’t Lie

    • Micro-Topic 6.1: Basic if Statements and Boolean Conditions

    • yb l6 mt6 1 free content SCORM package

    • Micro-Topic 6.2: Two-Way Decisions: if-else

    • yb l6 mt6 2 free content SCORM package

    • Micro-Topic 6.3: Multi-Branch Decisions: the if-else-if Ladder

    • yb l6 mt6 3 free content SCORM package

    • Micro-Topic 6.4: Combining Conditions with Boolean Logic

    • yb l6 mt6 4 free content SCORM package

    • Micro-Topic 6.5: Nested if Statements and Else Scope

    • yb l6 mt6 5 free content SCORM package

    • Micro-Topic 6.6: Common Conditional Mistakes to Avoid

    • yb l6 mt6 6 free content SCORM package

    • Micro-Topic 6.7: Writing Clear and Effective Conditional Expressions

    • yb l6 mt6 7 free content SCORM package
  • Collapse Expand

    Lesson 7: Switch + Loops + Real Flow

    • YB07_01 – The switch Statement: Multi-way Decisions

      Learning Goal: Understand how to use Java’s switch statement to branch program flow in multiple directions based on a single value.

    • YB07 01 FREE switch multiway SCORM12 SCORM package

    • YB07_02 – Using switch Effectively: break, default, and Fall-Through

      Learning Goal: Understand how to properly use break in switch cases to control flow, the role of the default case, and what fall-through behavior means.

    • YB07 02 FREE switch break fallthrough SCORM12 SCORM package

    • YB07_03 – Loops Introduction: Repeating Actions in Code

      Learning Goal: Grasp the concept of loops and why they are needed – to repeat a set of instructions multiple times without writing them out repeatedly.

    • YB07 03 FREE loops intro SCORM12 SCORM package

    • YB07_04 – The while Loop: Repeating with Pre-Check

      Learning Goal: Learn how to use the while loop to repeat actions as long as a condition remains true, and understand its characteristics (pre-check loop, may execute zero times).

    • YB07 04 FREE while precheck SCORM12 SCORM package

    • YB07_05 – The do-while Loop: At Least One Iteration

      Learning Goal: Understand the do-while loop, which checks its condition after executing, ensuring the loop body runs at least once.

    • YB07 05 FREE do while one iteration SCORM12 SCORM package

    • YB07_06 – The for Loop: Definite Iteration Made Easy

      Learning Goal: Learn how to use the for loop for situations where the number of iterations is known or can be defined, and understand its structure (initialization, condition, update).

    • YB07 06 FREE for loop definite iteration SCORM12 SCORM package

    • YB07_07 – Loop Control: break and continue

      Learning Goal: Learn how to control loop execution using break (to exit a loop early) and continue (to skip the rest of the current iteration), and understand their effects especially in nested loops.

    • YB07 07 FREE break continue SCORM12 SCORM package

    • YB07_08 – Real Flow Example: Combining Loops and Conditions

      Learning Goal: Apply switch and loops together in a practical scenario, demonstrating real program flow control (e.g. a simple menu-driven program or repetitive task with conditional logic).

    • YB07 08 FREE real flow menu SCORM12 SCORM package
  • Collapse Expand

    Lesson 8: Input, Parsing, and Exceptions

    • YB08_01: Reading User Input with Scanner

      Learning Goal: Understand how to use the Scanner class to read different types of user input (text and numbers) from the console.

    • YB08 01 FREE scanner input SCORM12 SCORM package

    • YB08_02: Parsing Strings to Numbers

      Learning Goal: Learn how to convert a textual input (string) into numeric data types (int, double, etc.) using parsing methods, and understand what happens when conversion fails.

    • YB08 02 FREE parsing strings numbers SCORM12 SCORM package

    • YB08_03: Handling Invalid Input and Input Validation

      Learning Goal: Develop strategies to deal with situations where user input is not in the expected format, to prevent program crashes and prompt the user for correct data.

    • YB08 03 FREE input validation SCORM12 SCORM package

    • YB08_04: Understanding Exceptions in Java

      Learning Goal: Grasp what exceptions are, why they occur, and how they affect the flow of a program.

    • YB08 04 FREE exceptions basics SCORM12 SCORM package

    • YB08_05: Handling Exceptions with try...catch

      Learning Goal: Learn how to use try and catch blocks to handle exceptions and prevent program crashes, allowing your program to recover or exit gracefully when errors occur.

    • YB08 05 FREE try catch SCORM12 SCORM package

    • YB08_06: The finally Block and Guaranteed Cleanup

      Learning Goal: Use the finally block to execute important cleanup code regardless of whether an exception occurs or not.

    • YB08 06 FREE finally cleanup SCORM12 SCORM package

    • YB08_07: Common Exception Types and Causes

      Learning Goal: Recognize some common exceptions in Java and understand the typical causes of each, so you can identify errors quickly and know how to address them.

    • YB08 07 FREE common exception types SCORM12 SCORM package

    • YB08_08: Checked vs Unchecked Exceptions, and Throwing Exceptions

      Learning Goal: Understand the difference between checked and unchecked exceptions in Java, and learn how to declare exceptions in method signatures or throw exceptions in your own code.

    • YB08 08 FREE checked unchecked throw SCORM12 SCORM package
  • Collapse Expand

    Lesson 9: Methods + Overloading

    Welcome to Yellow Belt – Lesson 9: Methods + Overloading in the Jiu-Jitsu Java course. In this lesson, you will deepen your understanding of Java methods – how to define them, call them, and even give them multiple forms (overloading) for added flexibility. By the end, you’ll write cleaner, smarter code with these powerful techniques. Prepare to use these skills like a coding champion! 🥋💻

    • YB09_01: The Power of Methods – Why Use Them?

      Learning Goal: Understand what methods are in Java and why they are essential for writing reusable, organized code.

    • YB09 01 FREE methods why SCORM12 SCORM package

    • YB09_02: Defining a Method in Java

      Learning Goal: Learn how to declare (define) a method in Java, including specifying its return type, name, and parameters.

    • YB09 02 FREE defining method SCORM12 SCORM package

    • YB09_03: Calling Methods and Passing Arguments

      Learning Goal: Understand how to invoke (call) methods in Java and how arguments are passed into methods.

    • YB09 03 FREE calling methods arguments SCORM12 SCORM package

    • YB09_04: Return Values and void Methods

      Learning Goal: Learn how methods return values in Java, how to use the return statement, and understand what a void method is.

    • YB09 04 FREE return values SCORM12 SCORM package

    • YB09_05: Method Overloading – Same Name, Different Parameters

      Learning Goal: Understand what method overloading is and how to create overloaded methods to handle different types or numbers of inputs.

    • YB09 05 FREE method overloading SCORM12 SCORM package

    • YB09_06: Rules and Best Practices for Method Overloading

      Learning Goal: Learn the rules that govern method overloading in Java (what is allowed and what isn’t), and understand best practices to use overloading effectively without confusion.

    • YB09 06 FREE overloading rules best practices SCORM12 SCORM package

    • YB09_07: Mastering Methods – Tips, Pitfalls, and Wrap-Up

      Learning Goal: Consolidate understanding of methods and overloading with best practice tips, and be aware of common mistakes to avoid as you apply these concepts.

    • YB09 07 FREE mastering methods wrapup SCORM12 SCORM package
  • Collapse Expand

    Lesson 10: Classes, Objects, and Encapsulation

    • Micro-Topic 10.1: Class vs Object – Blueprints and Instances

    • orange belt 10 1 free SCORM package

    • Micro-Topic 10.2: Defining a Class – Fields and Methods

    • orange belt 10 2 free SCORM package

    • Micro-Topic 10.3: Creating and Using Objects – Instantiation & Method Calls

    • orange belt 10 3 free SCORM package

    • Micro-Topic 10.4: Encapsulation – Bundling Data with Methods

    • orange belt 10 4 free SCORM package

    • Micro-Topic 10.5: Access Modifiers – Controlling Visibility

    • orange belt 10 5 free SCORM package

    • Micro-Topic 10.6: Getters and Setters – Encapsulation in Practice

    • orange belt 10 6 free SCORM package
  • Collapse Expand

    Lesson 11: Constructors, Records, and Modern Objects

    • Micro-Topic 11.1: Constructors – Object Initialization

    • orange belt 11 1 free SCORM package

    • Micro-Topic 11.2: Constructor Overloading – Multiple Ways to Build Objects

    • orange belt 11 2 free SCORM package

    • Micro-Topic 11.3: The this Keyword – Referring to the Current Object

    • orange belt 11 3 free SCORM package

    • Micro-Topic 11.4: Object Lifecycle – Garbage Collection and Memory

    • orange belt 11 4 free SCORM package

    • Micro-Topic 11.5: Java Records – Modern Data Classes

    • orange belt 11 5 free SCORM package

    • Micro-Topic 11.6: Records vs Classes – Differences and Best Practices

    • orange belt 11 6 free SCORM package
  • Collapse Expand

    Lesson 12: Inheritance, Overriding, and Object Class

    • Micro-Topic 12.1: Inheritance Basics – Extending Classes

    • orange belt 12 1 free SCORM package

    • Micro-Topic 12.2: Using Inheritance in Java – Superclass and Subclass Mechanics

    • orange belt 12 2 free SCORM package

    • Micro-Topic 12.3: Method Overriding – Replacing Superclass Behavior

    • orange belt 12 3 free SCORM package

    • Micro-Topic 12.4: Overriding vs Overloading – Don’t Mix Them Up

    • orange belt 12 4 free SCORM package

    • Micro-Topic 12.5: Polymorphism – One Interface, Many Implementations

    • orange belt 12 5 free SCORM package

    • Micro-Topic 12.6: The Ultimate Superclass – java.lang.Object

    • orange belt 12 6 free SCORM package
  • Collapse Expand

    Lesson 13: Composition (HAS-A) and Real Modeling

    • Micro-Topic 13.1: HAS-A vs IS-A – Composition vs Inheritance

      Learning Goal: Distinguish between composition (HAS-A relationships) and inheritance (IS-A relationships) and know when each is appropriate.

    • green belt 13 1 free SCORM package

    • Micro-Topic 13.2: Implementing Composition in Java

      Learning Goal: Learn how to implement a HAS-A relationship in Java classes and use object references as members.

    • green belt 13 2 free SCORM package

    • Micro-Topic 13.3: Real-World Modeling with Composition

      Learning Goal: Apply composition to model real-world objects and scenarios in code, mirroring true relationships (part-whole) rather than forcing inheritance.

    • green belt 13 3 free SCORM package

    • Micro-Topic 13.4: When to Favor Composition Over Inheritance

      Learning Goal: Understand the benefits of composition and why it’s often preferred for flexibility and maintainability.

    • green belt 13 4 free SCORM package

    • Micro-Topic 13.5: Case Study – Modeling a Car with Composition

      Learning Goal: Demonstrate how to apply composition in a practical example by designing a class with multiple components.

    • green belt 13 5 free SCORM package
  • Collapse Expand

    Lesson 14: Polymorphism in Action

    • Micro-Topic 14.1: Polymorphism Basics – “One Interface, Many Forms”

      Learning Goal: Grasp the fundamental concept of polymorphism and what it means for one interface to have multiple implementations.

    • green belt 14 1 free SCORM package

    • Micro-Topic 14.2: Overriding Methods – The Engine of Runtime Polymorphism

      Learning Goal: Understand how method overriding enables polymorphism, and how Java decides which method implementation to execute at runtime.

    • green belt 14 2 free FIX2 SCORM package

    • Micro-Topic 14.3: Polymorphism in Action – Examples and Scenarios

      Learning Goal: See concrete examples of polymorphic behavior in code and understand how to implement and recognize polymorphism in practical situations.

    • green belt 14 3 free FIX1 SCORM package

    • Micro-Topic 14.4: Benefits of Polymorphism – Flexible and Extensible Code

      Learning Goal: Appreciate how polymorphism contributes to cleaner, more extensible code design, helping in scenarios like maintaining and scaling projects (and staying ahead of AI by writing robust, adaptable code!).

    • green belt 14 4 free FIX1 SCORM package

    • Micro-Topic 14.5: Overloading vs Overriding – Polymorphism’s Scope

      Learning Goal: Clarify the difference between method overloading and method overriding, and understand that true polymorphism in Java is about overriding (runtime), not overloading.

    • green belt 14 5 free FIX2 SCORM package
  • Collapse Expand

    Lesson 15: Arrays and 2D Arrays

  • Collapse Expand

    Lesson 16: Lists, Iterators, Autoboxing, Enums

  • Collapse Expand

    Lesson 17: Abstraction and Interfaces

    In Lesson 17, we tackle abstraction (making classes and methods abstract) and interfaces (Java’s blueprint for multiple inheritance workaround). You’ll learn to design flexible code using abstract classes and interfaces, and know when to use which. Ready to kick complexity in the face? 🥋

    • Microtopic 17.1: What is Abstraction in Java?

    • BB P1 L17 MT17 1 FREE SCORM package

    • Microtopic 17.2: Abstract Methods and Abstract Class Rules

    • BB P1 L17 MT17 2 FREE v2 1770378464 SCORM package

    • Microtopic 17.3: Interfaces – Java’s 100% Abstract Types

    • BB P1 L17 MT17 3 FREE SCORM package

    • Microtopic 17.4: Implementing Interfaces vs. Extending Classes

    • BB P1 L17 MT17 4 FREE SCORM package
  • Collapse Expand

    Lesson 18: Generics and Comparators

    Lesson 18 arms you with Generics (making your code flexible and type-safe) and Comparators (custom sorting strategies). Generics ensure you can outsmart AI (and the compiler) by catching type errors early and writing reusable code, while Comparators let you order objects however you see fit. Let’s sharpen those skills!

    • Microtopic 18.1: Why Generics? Type Safety and Reusability

    • BB P1 L18 MT18 1 FREE SCORM package

    • Microtopic 18.2: Creating and Using Generic Classes

    • BB P1 L18 MT18 2 FREE v2 1770562478 SCORM package

    • Microtopic 18.3: Comparable vs Comparator – Sorting Strategies

    • BB P1 L18 MT18 3 FREE SCORM package

    • Microtopic 18.4: Writing and Using Comparators

    • BB P1 L18 MT18 4 FREE SCORM package
  • Collapse Expand

    Lesson 19: Lambdas and Method References

    Lesson 19 will empower you with modern Java features: Lambdas (inline functions) and Method References (shorthand for calling methods). These let you write cleaner, more expressive code – a crucial skill to stay ahead of AI by writing code that’s both powerful and concise. Let’s flex those functional muscles!

    • Microtopic 19.1: Intro to Lambdas – Passing Behavior

    • BB P1 L19 MT19 1 FREE v2 FIX SCORM package

    • Microtopic 19.2: Functional Interfaces – The Backbone of Lambdas

    • BB P1 L19 MT19 2 FREE SCORM package

    • Microtopic 19.3: Lambda Syntax and Variations

    • BB P1 L19 MT19 3 FREE SCORM package

    • Microtopic 19.4: Using Lambdas in Practice (Collections and Threads)

    • BB P1 L19 MT19 4 FREE SCORM package

    • Microtopic 19.5: Method References – Shorter Lambdas

    • BB P1 L19 MT19 5 FREE SCORM package
  • Collapse Expand

    Lesson 20: Collections: Sets and Maps at Scale

    • Micro-topic BB2_L20_M1 — Set/Map identity: equals, hashCode, and “what counts as the same”

      Goal: You can predict when duplicates will be blocked (or sneaking in), and you can design keys/elements that won’t break collections later.

    • BB2 L20 M1 FREE SCORM package

    • Micro-topic BB2_L20_M2 — HashMap/HashSet at scale: performance, resizing, and “why it got slow”

      Goal: You can choose capacity strategy, explain resizing, and avoid performance traps that destroy big programs.

    • BB2 L20 M2 FREE SCORM package

    • Micro-topic BB2_L20_M3 — Ordered vs sorted: LinkedHashMap, TreeMap, and choosing the right weapon

      Goal: You can choose the right collection when order matters—and explain the tradeoffs cleanly.

    • BB2 L20 M3 FREE SCORM package

    • Micro-topic BB2_L20_M4 — Map update patterns: counting, grouping, caching without “check-then-act” bugs

      Goal: You can update maps cleanly (and safely) without fragile multi-step logic.