Learn Object Oriented Programming in Java

Explore array concepts in Java, including declaring and initializing arrays; compare for and enhanced for loops; learn command line arguments and use System.arraycopy with two dimensional and jagged arrays.

Explore how arrays in Java group homogeneous data with fixed size and immutable storage. Declare, instantiate, and initialize arrays, access elements by index, and understand default values and nulls.

Use array length to drive loops, replacing hardcoded sizes; apply traditional for loops and enhanced for loops to print elements and iterate forward or in reverse.

Compute the sum and average of quiz scores using traditional and enhanced for loops, casting to double for a floating-point result, and display the results.

Explore the array copy method to duplicate a source array into a larger destination, manage temp arrays, and apply an added referencing strategy while noting arrays are immutable.

Learn how to accept string values at runtime with command line arguments in Java. Pass to the main method, iterate with a for loop, and print each argument.

Explore computing the sum and average of quiz scores in Java by iterating an array of strings, converting values to integers, and printing the results.

Learn how Java implements multidimensional arrays as arrays of single-dimensional arrays, declare them with square brackets, instantiate rectangular matrices, and iterate while highlighting heap memory usage.

Learn to create a Java program that accepts two positive integers from the command line to generate and print a multiplication table using a two-dimensional array and nested loops.

Explore non rectangular arrays in Java by declaring jagged arrays with varying row sizes, initializing with different lengths, and printing using enhanced for loop and traditional for loop.

Master object oriented programming by using enhanced for loops, copying arrays with System.arraycopy, and reading command line inputs via main(String[] args), including multidimensional and non rectangular arrays.

Explore strings, string buffer, and string builder; compare these with string objects, learn commonly used string methods, and apply them to solve problems.

Explore how to instantiate string objects in Java using the new keyword, string constructors, or direct assignment, and compare values with equals versus memory addresses.

Explore Java string methods such as charAt, concat, endsWith, equals, isEmpty, length, replace, split, startsWith, substring, toLowerCase, toUpperCase, trim, valueOf, and toCharArray, and consult the API for string class.

Explore Java string handling by building a command line program that prints each input's length, the string itself, and classifies its last character as vowel, consonant, number, or symbol.

Explore a Java demo that checks whether a user-entered string is a palindrome by using a string, string buffer or builder, reversing, and comparing with the original.

Explore string handling in Java, including string index bounds and the reverse method for palindrome problems, and compare string buffer with string builder for mutability and thread safety.

Explore inheritance in Java, override methods with super, use all four access modifiers, and learn why constructors aren’t inherited; meet the Object class and methods like string, equals, and hashCode.

Explore inheritance in object oriented programming by extending a superclass to form a subclass, reusing its methods and variables, as shown with employee and manager and the extends keyword.

Explore Java access modifiers, including private, protected, public, and default; understand how accessibility is restricted to the same class, package, or subclass, and how top-level classes use public or default.

Explore how method overriding in Java lets a subclass extend a superclass method by matching name and arguments, ensuring compatible return type and accessibility, and adding department details.

Explore how the super keyword reduces redundancy in overridden methods by delegating to the superclass implementation before adding subclass details, and how it accesses attributes across the hierarchy in Java.

Explain how inheritance carries over methods and variables but not constructors, and show how constructors are chained using super and this, with the object class as the root.

Explore overloading constructors in Java, reuse constructors with this to reduce redundancy, and use super to invoke superclass constructors, illustrated by the employee and manager examples.

Understand how the object class serves as the root of all classes and that its equals, hashCode, and toString methods are inherited by all classes.

Explain how toString creates a string representation of an object, compare default hash-code output with a customized version, and show how IDEs can auto-generate a descriptive toString method.

Override the equals method to compare name and age, not object references. Override hashCode to ensure equal objects share the same hash code.

Explore Java object oriented programming by mastering inheritance, access modifiers, method overriding, and constructors, plus overloading and object methods like toString, equals, and hashCode, with polymorphism ahead.

Explore polymorphism and inheritance in Java, demonstrate heterogeneous arrays and virtual method invocation, learn object casting and the instance of operator correctly, and apply these concepts in a ticketing app.

Discover polymorphism in Java by using an Employee reference to hold Manager, Director, Engineer, or Secretary objects and creating heterogeneous arrays that mix subclasses under a common superclass.

Understand the virtual method invocation to achieve polymorphism by invoking get details at runtime based on the object's actual type. Demonstrate with an array of employees, including managers and directors.

Explore polymorphic arguments in Java by implementing a find tax rate method that accepts any employee object, testing types with instanceof, and arranging if-else checks from director to employee.

Learn casting of objects and polymorphism in Java, including upward (implicit) and downward (explicit) casts, runtime class cast exception, and accessing subclass methods like play golf or call meeting.

Explore how inheritance and polymorphism shape animal behavior in a hierarchy with animal, mammal, and bird, overriding eat, breathe, sleep, and play while using instance of and casting for methods.

Explore object-oriented programming in java by building a Tickets R US app that uses inheritance, polymorphism, and static pricing to manage counter, web, and discounted tickets.

Build a Java object oriented ticketing system with a base ticket class and subclasses for counter, web, and discount tickets, featuring serial numbers, a static counter, and getPrice and toString.

Explore polymorphism, heterogeneous and homogeneous arrays, and virtual method invocation, then demonstrate polymorphic arguments, casting rules, and a tickets app demo using inheritance and type checks.

Explore static imports, wrapper classes, final and blank final variables, enums, and interfaces, then apply abstract concepts in a banking app while reviewing Java features like interfaces and lambda expressions.

Learn about static imports in Java to import static members, simplify code, choose between specific member imports or asterisk imports, and avoid ambiguity from conflicting static members.

Learn how primitive types map to their wrapper classes in java.lang, and master boxing, unboxing, and auto boxing concepts to enable object representations and nullability.

Explore how the final keyword constrains classes, methods, and variables in Java, preventing subclassing and overriding. Learn how final variables become constants, including blank final variables.

Explore how the enum keyword in Java defines a fixed set of named constants as enumerated types, replacing numeric constants with descriptive, type-safe values like Monday to Sunday.

Explore the abstract keyword in Java, showing how abstract classes and methods serve as templates that force subclasses to override key methods and prevent instantiation.

Understand Java interfaces as contracts between client code and implementations, with abstract methods to override. Learn that interfaces can extend multiple interfaces and are implemented by classes.

Explore how to define an account interface with deposit, withdraw, and get balance, and implement it in savings and checking classes.

Learn how default interface methods in Java 8 support scalable interfaces by providing method bodies, avoiding breaks for implementing classes, with examples like savings and checking accounts.

Explore static and default interface methods, with static methods called via the interface name and default methods accessed through objects, while public and default access modifiers are allowed.

Explore functional interfaces in Java, which have a single abstract method and carry the @FunctionalInterface annotation, using greeter and runnable examples to demonstrate how to override interface methods.

Learn how lambda expressions in Java implement functional interfaces concisely, with optional braces for multiple statements, parameter handling, and return values, plus the functional interface annotation.

Explore Java basics—imports, final, enums, inheritance, and abstract classes—and implement interfaces in a banking app. Learn Java 8 features like default and static interfaces, functional interfaces, and lambda expressions.

Explore the differences between errors and exceptions, and apply try, catch, and final blocks with the exception hierarchy and Alltop Closeable Interface to manage resources and assertions.

Learn how exceptions represent abnormal conditions in code, distinguish compile-time (checked) and runtime (unchecked) exceptions, and understand how handling them enables graceful exits, user-friendly messages, and data preservation.

Demonstrate how an uncaught exception travels up the call stack, how try catch blocks handle errors, and how finally and throws enable a graceful exit with clear error messages.

Learn how the finally block is an optional code block after try and catch that always executes, ensuring cleanup like closing database connections regardless of exceptions.

Explore the exception hierarchy from the root object class to throwable types, noting errors and exceptions and how exceptions are actionable. Distinguish unchecked (runtime) from checked exceptions in Java.

Learn how to arrange multiple catch blocks by exception hierarchy, using the most specific first, and leverage Java seven’s multi-catch to handle IO and illegal exceptions succinctly.

Explore parameterized try blocks in Java, showing how to handle io exceptions with try-catch and throws. See how auto closeable resources like buffered reader enable safe, graceful input processing.

Learn how to override methods with checked exceptions in Java, using throws and subclass relationships, and ensure that only exceptions from the superclass declaration appear in the overridden method.

Create a custom exception in Java by extending java.lang.Exception for checked exceptions or java.lang.RuntimeException for unchecked ones, using throw, throws, and try-catch to handle errors.

Learn how the assert keyword tests programmer assumptions in Java, triggering an assertion error when false, and how to enable or disable assertions at runtime with VM options.

Explore the difference between errors and exceptions, including checked and unchecked types, and learn to handle them with try-catch, throws, finally, custom exceptions, asserts, and preview of collections and generics.

Java collections and generics: understand the collection interface, differences from arrays, and subinterfaces like set, list, and map, plus the iterator interface, sorting, and filtering in maps.

Explore the java.util collection interface, the root of the collection hierarchy, with list, set, and map interfaces, plus core operations like add, remove, contains, and differences with arrays.

Learn how sets in Java store unordered, unique elements using hash set and other implementations, where duplicates are rejected, nulls are allowed, and element order is not guaranteed.

Explore how Java lists preserve insertion order, allow duplicates, and support indexed additions with array list and other implementing classes, contrasted with sets and the Map interface.

The map interface stores unique keys paired with values, using HashMap implementations. Use keySet, values, and entrySet to access keys, values, and pairs, noting overwrites on duplicates.

Explore iterator and list iterator interfaces to traverse sets and lists, noting sets lack guaranteed order and lists support forward and backward iteration, with next, hasNext, previous, removal, and printing.

Explore the generics framework in Java, enabling type-safe collections with the diamond operator and compile-time checks to prevent class cast exceptions.

Explore building a user-defined object in Java, implement the Comparable interface and override compareTo, then sort with a TreeSet by name or by age in ascending or descending order.

Sort a list of objects using the comparable interface and collections.sort, with reverse order for ascending or descending results. Explore sorting by age or by name and printing the outcomes.

Sort a map in Java by implementing comparable and using a tree map, choosing sort by key or value, and printing entries via the entry set with getKey and getValue.

Learn how to filter a map by keys or values in java, using hash map and linked hash map to preserve insertion order, and store results in a separate collection.

Explore collection interfaces, compare set, list, and map with unique keys, order, and duplicates, and review iterators, generics, and overriding hashCode, equals, and toString.

Explore threads and thread objects, learn how to create, start, and query a running thread, and understand race conditions in multithreaded applications, using the synchronized keyword to manage concurrency.

Learn what threads are and how they let a program do multiple tasks at once, with examples like typing while saving and a multithreaded bouncing ball demonstration.

Create and start threads in Java by implementing Runnable or extending Thread, override run, and use start to enable multithreading; understand thread states, scheduler decisions, and thread naming.

Explore Java thread construction and management, including runnable and thread groups, priority, current thread, and methods like sleep and yield, with practical examples and race condition notes.

Explore race conditions and critical regions in concurrency using a bank account with deposits and withdrawals, showing how non-atomic updates corrupt balance and how the synchronized keyword ensures mutual exclusion.

Learn how object locks control access to code by requiring threads to acquire a lock before entering a synchronized block, blocking when unavailable and releasing it when the block ends.

Learn Java threading fundamentals shown in section nine: using runnable, start vs run, thread priorities, yield and sleep, race conditions, and synchronize blocks or methods to manage critical regions.

Explore regular expressions and learn about matching symbols, meta characters, repetitions, and escape characters; then build a validation code for addresses using the pattern class and the metric class.

Learn how regular expressions define search patterns to match, substitute, or extract text in Java. Use Pattern and Matcher, compile patterns, and test matches with examples of whitespace.

Explore common matching symbols in Java regular expressions, including the dot operator, caret and dollar anchors, character classes with square brackets, negation, ranges, and alternation, with sample code.

Explore regular expressions with meta characters and backslash escapes, digit and whitespace classes, repetition operators *, +, ?, and {min,max}, for precise matches.

Use regular expressions in java to validate a url by building an isValidURL method and precompiling a pattern. Test cases verify optional www and com, net, org endings.

Explore regular expressions in Java with pattern and matcher classes, metacharacters, repetition, and escaping with backslashes, and review core object-oriented topics like classes, encapsulation, inheritance, and collections.