The Complete Selenium WebDriver with Java Course

Learn basic string operations in Java: create strings, concatenate with + or concat, assess length and indices, trim spaces, convert to upper or lower case, and check for emptiness.

Learn string comparison operations such as equals, equals ignore case, and compare to, and see how matches with regular expressions can aid testing by returning booleans or numeric results.

Explore string search operations in Java and Selenium, including contains, starts with, ends with, index of, and last index of, with index variations. Also learn a workaround to ignore case.

Master string slice operations in Java, including character retrieval by index, substring with begin and end indices, and reversing strings. Learn to split by a delimiter into an array.

Learn to use string replace and replace all to find and replace characters or words, including regular expression patterns, and remove special characters.

Learn how to convert integers to strings and to various bases—binary, hex, and octal—and back, using toString, toBinaryString, toHex, toOctal, and radix-based parsing in Java.

Learn how a class acts as a template for objects with variables and methods, and how to instantiate them using new and constructors to create multiple objects.

Demonstrates how to define an employee class with name, id, and salary, implement a 20% bonus calculation, and instantiate two employees in a main class to display bonuses.

Learn how to create and call Java methods, use arguments and return values, and share methods across classes using objects, including public void methods and integer returns.

Learn method overloading in Java by using the same method name with different argument types, numbers, or orders, and see how Java resolves the correct method.

Explore how public, default, and private access modifiers govern visibility within a class and across packages, with examples. Introduce protected access and its role in inheritance.

Understand constructors in Java, how they initialize object data, and how overloading, the this keyword, and default versus explicit constructors work, illustrated by a road toll example.

Explore data encapsulation in Java by hiding class fields with private access and exposing controlled access through getters and setters, ensuring maintainability and flexible code when names change.

Explore the static keyword and how static members belong to the class rather than any object, are shared across instances, and can be accessed directly via the class name.

Explains how the public static void main method acts as the entry point for Java programs, how the JVM provides the runtime environment, and how string args pass command-line parameters.

Develop and test a bank account class to demonstrate class and object concepts, using a constructor to initialize private fields and methods to deposit, withdraw, and display balance.

Explore the math class in the java.lang package and its static methods for min, max, pow, sqrt, cube root, pi, e, ceil, floor, round, and Math.random.

Explore the StringBuilder class in Java and learn how it enables mutable string concatenation, avoiding many temporary objects. Discover the append method and other methods like delete and reverse.

Discover how to manipulate strings in java using StringBuilder methods—insert, replace, delete, and reverse—with index-based examples and explanations of begin and end indices.

Explore using the Scanner class to capture user input in Java, including strings, integers, and doubles, via system.in and java.util import; reverse strings with a for loop and display results.

Learn to generate random numbers in Java using the Random class (java.util) and Math.random, with for loops and range tricks to produce values in 0–1000, 0–100, and 1000–10000.

Explore how to generate universally unique identifiers with the UUID class in Java, using randomUUID to produce 128-bit alphanumeric values and display ten examples.

Explore the var keyword in Java 10, learn how type inference works for primitive data types and objects, and understand when var can and cannot be used.

Discover how Java 10 introduces a garbage collector interface to simplify adding or removing garbage collectors and boost garbage collection performance in the JVM.

Discover Java 10 updates, including object heap allocation to user-specified memory devices for high-priority processes on multi-JVM servers, and a six-month release cadence. OpenJDK builds gain root certificates enabling TLS.

Explore class inheritance in Java, reuse parent features with extends, and apply is-a relationships through examples like polygon, triangle, and rectangle, using base, height, and area methods.

Explore method overriding in inheritance by comparing it with overloading, using animal, dog, and cat examples where subclasses override the parent method to print their identity.

Polymorphism in Java lets an object take multiple forms, as an Animal reference 'a' is instantiated as a Dog and then a Cat, enabling different behaviors.

Learn how the super keyword accesses the superclass to call methods and fields, demonstrated with class A and B, method overriding, and parent implementation calls.

Explore how the super keyword invokes the parent class constructor when a subclass initializes, including explicit one-argument constructors, no-argument defaults, and handling multiple super arguments.

Explore the protected access specifier in Java, showing how it acts like default within the same package but remains accessible to subclasses outside the package via inheritance.

Explore how abstraction hides implementation details in Java using abstract classes, abstract methods, and interfaces, with a multi-layer architecture exemplified by iOS and Android implementations.

Explore how Java interfaces define abstract methods and how classes implement them, including interface inheritance and multiple inheritance, while contrasting interfaces with abstract classes and noting static and default methods.

Discover how the final keyword in Java makes fields constants, prevents method overriding, and prohibits subclassing of final classes, with practical examples and naming conventions.

Learn arrays as collections of similar data types, with 0-based indexing and fixed length. Declare, initialize, access, update elements, and iterate using a conventional for loop, avoiding out-of-bounds errors.

Declare an array with a fixed size without initial values and observe default values, such as 0 for integers; later, assign values to specific elements, while the length stays fixed.

Explore the enhanced for loop for array iteration, with a multiplication table in an array and displaying its elements, and apply for-each to arrays, array lists, and linked lists.

Learn to reverse an integer array by swapping symmetric elements with a for loop using indices from start to mid, guided by a temporary variable.

Master 2-D arrays in Java as arrays of arrays, accessing and updating elements by index, determining row lengths, and iterating with nested loops.

Build a 2-D int array in Java to hold multiplication tables from 2 to 6 using nested loops. Fill with i*j using arr[i-2][j-1] and print each table on one line.

Create and iterate an array of objects to hold string, integer, double, and char values for flexible test data. Build a two-dimensional array of objects and print each row.

Explore ArrayList in Java, a dynamic array that implements the List interface. Learn to declare, add, get, set, remove, contains, sub list, size, isEmpty, toArray, and iterate.

Explore the structure of doubly linked lists, examining head and tail, previous and next pointers, and how the actual data sits between linked elements at noncontiguous, random locations.

Explore how LinkedList implements the list interface and differs from ArrayList, and master core operations: add, get, set, remove, clear, contains, indexOf, peek, and poll.

Compare ArrayList and LinkedList: ArrayList uses a dynamic array for fast index access; LinkedList uses a doubly linked list for easier insertions and deletions.

Use Java list iterator to traverse lists forward and backward with next, previous, hasNext, and hasPrevious, and modify elements with itr.remove and itr.set for nulls and odd-to-even updates.

Understand how Java sets disallow duplicates and do not guarantee insertion order, focusing on hash set operations (add, remove, contains, size) and unions, intersections, and converting to a list.

Explore linked hash set, an ordered variant of hash set that preserves insertion order, uses a doubly linked list, and supports add, remove, clear, contains, size, and list conversion.

Explore tree set, an important sorted set implementation that maintains elements in ascending order, unlike hash set; learn to create, add, and display names and numbers, and convert to list.

Explore iterating over sets using modified for loops and iterators, compare hash set and tree set behavior, and learn how to traverse without index access.

Explore hash map basics in Java by storing key-value pairs, using put and get to add and retrieve, check containsKey, and convert to keySet, values, and entrySet.

Explore TreeMap, which uses a red-black tree to sort entries by keys, and learn core operations like put, get, contains value, replace, and poll first or last entry.

Learn to iterate over a map by converting it to a set and using a for-each loop or an iterator, with integer keys and square-root values.

Discover the fundamentals of regular expressions in Java, including pattern creation, meta characters and quantifiers, and replacing non-digits or special characters with regex.

Explore quantifiers in regular expressions, using asterisk, plus, and question mark to repeat characters or blocks, and braces for exact or ranged counts, with grouping and the matches method.

Explore character classes in regular expressions, including \d, \w, \s, \D, and \W, and learn escaping and quantifiers with practical phone number and password examples from the Selenium course.

Learn how bracket expressions in regular expressions select one of several characters using square brackets, define ranges (A–Z, a–z, 0–9), apply negation with a caret, and use quantifiers for repetition.

Discover the or operator in regex by using the pipe symbol to pick one option from a group, with examples like ab, ac, ad, or xyz.

Explore the dot operator in regex, which matches any single character, and how dot plus asterisk forms greedy patterns like (.*) that match various strings.

Explore greedy and non-greedy regex matching in Java, using dot asterisk and quantifiers to capture text between x x and y y with Pattern and Matcher, counting matches.

Learn to build a RegEx pattern that represents four websites using grouping and the pipe symbol, and escape dots to treat them as literals in Java.

Develop a regex pattern to extract prices from a string, matching formats like 24.99$, 0.99$, and 12.09$, and use Java's Pattern and Matcher to print each match.

Master regular expressions to regularize number ranges, using patterns for 0–9, 0–99, 0–1000, 99–9999, and interview-ready ranges like 25–75 and 220–240.