Java 8 - Beyond the Basics

Java types and variables, including string, char, byte, short, int, long, float, double, and boolean, and format output with placeholders like %s, %d, %f, and %b.

Explore basic Java classes and constructors using runner and swimmer, including default and explicit constructors, and a performSport method that outputs running or swimming.

Explore how to implement methods in Java with runner and swimmer classes that use mutators and accessors for race IDs, along with a static utilities equals method to compare objects.

Review conditional operators in Java by implementing if/else and optional else-if, performing null checks and equals-based comparisons in runner and swimmer classes.

Explore switch and ternary operators in Java 8 beyond the basics, with hands-on demonstrations in Eclipse, including menu-driven switch cases, defaults, and breaks using runner and swimmer examples.

Explore the three common Java loops—while, do-while, and for—and see how each controls iteration with a menu-driven example using runner and swimmer objects.

Explore basic data structures using arrays and array lists to manage runner and swimmer objects, including loading, adding, iterating, and printing them in a driver program.

Package utilities into a jar from the utilities package for reuse across projects, then import the jar via build path and verify noSafeEquals works as a static method.

Learn basic unit testing with JUnit 4 in Eclipse, using setup and teardown around each test to verify a swimmer class’s getters, setters, constructors, and toString.

Explore basic terminology of java inheritance, including upcasting and downcasting, superclasses and subclasses, method overriding and overloading, extends and implements, abstract classes, polymorphism, and instance of.

Explore how the Object class underpins all objects and how overriding to string creates readable output by showing the class and name via an Animal example.

Extend the animal class by creating dog and cat subclasses, using extends and super to set name and breed, and override toString to include service status and declawed flag.

Explore extending a base animal class with subclasses dog and cat, overriding toString, and using super constructors and accessors to manage name, breed, and service animal status.

Leverage polymorphism to store dogs, cats, and animals in one array, use enhanced for loops and instance checks, and cast to access is a service animal and is de-clawed.

Plan the race system by defining race participant and person interfaces, outlining methods for racer IDs, names, and ages, and presenting runner, swimmer, and Byker classes implementing both.

Introduces Java interfaces as contracts defining methods to implement, like get racer ID and set racer ID. Shows how interfaces enable polymorphism using implementing classes such as runner and Byker.

Learn to create and implement the race participant interface in Java 8 and implement a runner class with racer ID and perform race activity.

Explore implementing multiple interfaces in Java by adding a person interface with get and set name and age, and updating runner to implement it along with race participant, with tests.

Introduce an abstract class athlete that implements the interfaces and serves as a base for runner, swimmer, and biker, consolidating common properties and enabling abstract testing with a factory pattern.

Create an abstract athlete class to consolidate common code from runner, swimmer, and biker, enforce abstract perform race activity, and have subclasses extend the athlete while adding a shoe brand.

Extend the abstract athlete class to include biker and swimmer, adding a uses clips boolean with getters, setters, tests, and toString updates.

Learn to test the abstract athlete using a factory pattern to share common properties across runner, swimmer, and biker tests, with JUnit setup and abstract test design.

Discover how to extend testing of the abstract athlete, using common properties and a superclass approach to verify constructors, get/set methods, and string representations across runner, swimmer, and Byker tests.

Create an infinite skills race manager with a polymorphic race system using an abstract athlete class and a race interface, enabling adding, removing, and listing runners, bikers, and swimmers.

Explore the basics of Java exceptions, including checked versus unchecked types, common examples like IO exception and runtime exception, and using try-catch-finally to handle errors.

Explore unchecked exceptions and handle bad user input at runtime with a try catch block, including number format and arithmetic exceptions and the role of finally.

Explore checked exceptions and how to handle them in file operations, using try-catch blocks and finally to close resources, and understand the difference from unchecked exceptions.

Learn how to write and use custom exceptions in Java, creating unchecked and checked variants, implementing constructors, messages, and handling them with try-catch blocks.

Explore advanced try catch finally configurations, including nested blocks and multiple exceptions, and learn how code traces through divisions, throws, and finally blocks in Eclipse IDE.

Learn to unit test exceptions by implementing an athlete injured exception in a race manager, throwing it during perform race activity when injured, and validating input with illegal argument exceptions.

Explore how string builder optimizes string construction in Java, compare plus operator and string format, and understand when to use string builder in loops and string buffer for thread safety.

Explore parsing strings with the split operation in Java 8, using a pipe-delimited colors string and a space-delimited players string to create random player color pairs while validating equal lengths.

Explore how to use the string tokenizer in Java to parse color and player strings, tokenize with pipes and spaces, count tokens, and iteratively build random color combinations in Eclipse.

Explore string operations in java 8, including charAt, indexOf, length, contains, equals, replace, substring, and case-insensitive comparisons, with hands-on practice in the eclipse project.

Explore the basics of regular expressions in Java, using the matches method to validate input like phone numbers and passwords, and using split for simple string operations.

Apply the strategy pattern to a race manager to search athletes by partial name, id, or type. Build interchangeable algorithms with an athlete finder interface and return all matching athletes.

Learn to read and write text files in Java using scanner and file writer, handling input/output paths and a racer data workflow.

Read and write plain text files in Java using BufferedReader and BufferedWriter, wrapping FileReader and FileWriter, while handling IO exceptions with try-catch and finally.

Learn to load and save the infinite skills race data from a file using a data string method, parsing lines by pipe and semicolon to reconstruct runner, biker, and swimmer.

Learn to load and save racers from a flat text file using the infinite skills race manager. Create the race first, then parse data and update the racers list.

Master binary streams in Java by reading and writing files at the byte level using file input/output streams, readers, and buffers, including a simple byte-shift encryption demo.

Learn to use Java random access files to read and write with seek and length, storing credit card numbers (long) and balances (double) and overwriting records by position.

Explore how the Serializable interface converts objects to binary streams or byte arrays for storage, transmission, cloning, and cross-JVM portability, with rules for serializable classes.

Serialize serializable credit card objects to a binary state file in Java, using an array list and object streams to load, save, and restore data.

Save and restore the entire race state by making objects serializable and using file output streams and object input streams; handle IO and class cast exceptions.

Discover how to work with a database in Java using App Harbor's free MySQL add-on, compare cloud and local options, and set up a race manager dev app.

Download and install the org.json and MySQL Connector/J jars, configure a json style file with the database name, username, and password, then integrate these jars into your project setup.

Load the MySQL jdbc jars, configure the project to connect to the database, and implement a db manager with a server connector to manage connections, table schemas, and queries.

Learn table operations in Java 8, including creating, dropping, listing, and verifying athlete and athlete type tables, using a sequel server connector and prepared statements.

Insert data into a database by adding athlete types and athletes, handle type IDs, prevent duplicates, and list athletes through race manager and show database operations.

Update athlete data in a race manager database by modifying name and age via racer id, with limited validation, and review changes through a printout.

Delete athlete records in a Java 8 app by racer id using a delete statement, with prepared statements for updates and deletes, and verify removal by listing remaining records.

Load athletes from the database into race manager with a server connector and prepared statements to populate the athlete list from the result set, categorizing by type (runner, biker, swimmer).

Explore building a simple graphical user interface window in Java using Swing, creating a JFrame with labels and text fields.

Learn to add a JPanel to a JFrame by creating a panel, using a blue line border from the border factory, then adding it to the frame's content pane.

Learn to create and configure JLabel and JTextField components in a simple GUI, including setting text, columns, and adding them to a panel.

Learn to use simple input and message dialogs with JOptionPane to obtain a name from the user and display it back, updating a text field in a GUI panel.

Wire JButton with an anonymous action listener to respond to presses, prompting for a name and updating the button text, then implement a reusable action listener for multiple buttons.

Explore key Java GUI layout managers, including border, box, card, flow, and grid layouts, by building a simple GUI with panels, buttons, and a combo box to toggle cards.

Use JDesktopPane and JInternalFrame to manage multiple internal frames inside a single application, with a menu bar and exit option, and learn to pack and toggle frames.

Install window builder pro for eclipse by following the download and installation steps. Then explore the swing components such as J frame and J panel for a live demonstration.

Learn to use window builder to create Java GUI with JFrame, absolute layout, menus, and event handlers, practicing hands-on design and code integration.

Explore a graphical user interface race manager in Java 8 that loads racers from flat text or system state and supports adding, updating, deleting, and listing racers via internal frames.

Master generic programming by using type parameters to create interchangeable, reusable methods and classes with compile-time type checking for containers, databases, and crud operations.

Write a single generic swap method that works with strings, boxed integers, and custom objects like animals. Note that primitives can't be used directly in generics, and print items generically.

Explore how to write generic classes in Java 8 by building data containers with type parameters and multiple types, and implement a best data container using an object array.

Learn how bounded type parameters constrain generics in Java, using extends and interfaces like comparable, along with wildcards to enable safe comparisons and flexible type checks.

Explore bounded type parameters in classes and methods by building a best data container with generic max and min methods using Comparable bounds and wildcard super, demonstrated with animals.

Explore the array list as a generic class using type E, with methods like add, addAll, contains, and remove. Show how iterators and a managed array enable efficient iteration.

Learn how iteration uses iterable and iterator interfaces to access and remove elements across diverse containers. The approach unifies traversal across arrays, linked lists, and other storage structures.

Explore how to make a best data container iterable with a private iterator, enabling access to all elements and use in enhanced for loops, while noting non-thread safety.

Explore a simple single linked list built from data links with a dummy header, showing inserts and removes via next pointers without array shifting, not production-ready.

Explore the collection interface in Java 8 and its iterable data structures like array list and linked list, plus core methods such as add, clear, contains, remove, and retain all.

Explore the list interface and the list iterator, enabling index-based operations and bidirectional iteration with add, remove, and set to maintain order.

Examine Java's linked list as a generic iterable collection implementing list and abstract list, with operations for adding, clearing, cloning, contains, accessing first/last, index-based access, iterators, and converting to array.

Explore the Java linked list with generics by building integers, strings, and animal lists; insert at indices and end, search, remove, and iterate with standard, descending, and list iterators.

Examine the Java Vector class, a growable, synchronized list with capacity management. Compare with ArrayList and learn list operations and insertion costs in multi-threaded environments.

Explore working with the vector in Java, including creating an integer vector, using add and get, inspecting capacity growth as elements are added, and using ensureCapacity to predefine size.

Explore the Java stack: a generic, last-in-first-out structure built on vector, with push, pop, peek and empty operations; note the call stack and stack overflow.

Explore working with the Java stack in code, using push and pop on integer, string, and animal stacks; learn to reverse stacks and clone originals.

Explore the Java queue interface, its first-in, first-out behavior, and common operations like offer, add, poll, and peek, with implementations such as priority queue and array deque.

Explore Java queue implementations, including priority queue, priority blocking queue, and array deque, to store integers and demonstrate fifo order with offer, add, pull, and no such element exceptions.

Explore how the Java dictionary evolved into the map, with generics for keys and values. Examine map implementations, interfaces, and methods like get, put, remove, size, and key set.

Discover how the Java hash map, a generic key-value collection, extends abstract map and supports creating, sizing, merging, retrieving values, and Java 8 lambda methods like forEach, replaceAll, and compute.

Create and manipulate a Java hash map, add entries with put, retrieve with get and a default value, iterate keysets and values, and modify with remove, replace, and contains checks.