Java SE 11 Developer 1Z0-819 OCP Course - Part 1

Java is an object-oriented, statically typed, platform-independent language that compiles to byte code for the JVM, with dynamic programming capabilities, multithreading, distributed computing, and automatic garbage collection.

Explore Java primitive data types and string APIs by declaring and initializing variables, casting and promoting types, and manipulating strings with StringBuilder methods.

Explore Java primitive data types, their memory storage as non-reference values, and that the first five use two's complement while char is unsigned. Note wrappers and prep declaring primitive variables.

Explore declaring primitive data type variables and assigning literals in Java. Learn literal formats, suffixes, underscores, and separators, including binary, octal, hexadecimal, Unicode, and boolean rules.

Understand how Java assigns default values to static and instance primitives, while local variables require explicit initialization to avoid compile errors, with examples using if, switch, and loops.

Explore narrowing and widening of primitive data types in Java, including literals, range limits, and the role of casting when converting between byte, short, char, int, long, float, and double.

Master casting primitive data types in Java, exploring widening and narrowing conversions, preventing overflow and underflow, and handling truncation when converting floats to integers.

Explore unsigned integers and binary literals in Java, covering Java 8 unsigned int and long, overflow and parsing, and binary literal syntax with 0b notation, underscores, and L suffix.

Understand the scope of variables across class, instance, method, loop, and block levels, including local variables, parameters, and qualifiers like this, with constructors and class variables.

Examine method scope and loop variable scope by adding local variables like decadeString and age, analyzing i and j, and understanding shadowing and this-qualified references to avoid compile errors.

Explore how nested and local inner classes interact with local variable scope, including the outer class qualifier and the final or effectively final constraints on variables.

Learn how local variable type inference (LVTI) with var reduces code verbosity inside Java methods, with examples of valid and invalid uses, imports, and notes on lambda expressions.

Explain local variable type inference with var, how initialization determines the type and narrowing/widening rules, and why LVTI applies only to local and loop variables.

Explore how Java strings use the string pool and interning to share literals, contrast string creation with new, and illustrate immutability and the effects of concatenation.

Learn to create strings with literals and constructors, using offset and count to form substrings from char, byte, and int arrays, avoid runtime errors, and apply concatenation and StringBuilder.

Explore string concatenation in Java using the plus operator, including its behavior with nulls, primitives, and reference variables, toString usage, operator precedence, and compound assignment.

Explore manipulating strings through comparison, search, and transformation methods, with indices starting at zero and the ending index exclusive; learn equals, content equals, contains, split, substring, and strip.

Present a practical study of Java string text search methods: lastIndexOf, matches, and regionMatches, with inclusive/exclusive start and end offsets and case considerations; implement a TextSearch class and run examples.

Learn to manipulate Java strings using join, split, and replace methods, including StringJoiner, splitting by spaces or whitespace, and partial splitting to modify and parse text efficiently.

Explore Java string replacement and transformation techniques, including replace, replaceAll, replaceFirst, substring, and strip, and understand string immutability, start offset and end offset, and regex-based operations.

Explore advanced string manipulation in Java, including compareTo and compareToIgnoreCase behaviors, substring and valueOf vs constructor, and how replace methods affect String object creation, with exam-focused insights.

Master mutable string manipulation in Java with StringBuilder, covering constructors, capacity, and append/insert operations, and comparing it with String and StringBuffer for efficient large-scale text building.

Delve into uncommon StringBuilder concepts, such as trimToSize behavior and capacity changes, learn to clean with toString and strip, explore getChars with destination arrays and potential compile or runtime errors.

Master how expressions and statements form a Java program, use operators and parentheses to control precedence, and apply if, switch, and loop constructs with break and continue.

Explore java operators and precedence, covering unary, binary, and ternary forms, postfix and prefix increments/decrements, left-to-right evaluation, and right-to-left assignment rules, with examples of casting and promotion.

Explore unary operators in Java, including prefix and postfix increment and decrement, and related concepts like unary minus, unary plus, and bitwise and logical complements in code examples.

Explore Java binary operators, their precedence, and numeric promotion rules, covering multiplicative, additive, shift, relational, equality, and logical operators, plus assignment behavior.

Explore operators in Java, including multiplicative and additive precedence and modulus with integers and doubles. Show division by zero behavior (exceptions vs NaN) and demonstrate shift and short-circuiting logic samples.

Explore bitwise or and xor behavior on primitives, strings, and objects, then analyze assignment operators and the ternary operator’s three-operand syntax and evaluation.

Explore the uncommon concepts and behaviors of Java operators, including unary numeric promotion, increment/decrement rules, and left-to-right evaluation, with practical code examples.

Review Java decision constructs, focusing on if/else and switch statements. Explore pitfalls such as dangling else and assignment in if conditions.

Explore the Java switch statement, its supported types (byte, short, char, int, string, enum, wrappers), and how default, break, and fall-through behaviors work.

Explore uncommon switch statement scenarios in Java, including byte type constraints, case label validity, and how break, continue, and labeled loops affect flow and compiler errors.

Explore iterative programming in Java by examining while, do-while, and for loops, including traditional and enhanced forms, with break, continue, and looping over arrays or command line arguments.

Explore nested loops, labels, and break and continue statements to control flow in Java for loops, including outer and inner labels and breaking out of nested loops.

Explore how Java arrays act as fixed-size containers for elements, from one-dimensional and two-dimensional forms to array of arrays, supporting duplicates and polymorphic storage via CharSequence, with zero-based indexing.

Master best practices for declaring and initializing arrays in Java, including one- and two-dimensional forms, the new operator, array initializers, size rules, and defaults.

Explore java arrays, access and modify elements, use the array length attribute, and print contents with java.util.Arrays.toString, while showing default values and shared references.

Master java.util.Arrays methods for sorting, searching, and transforming arrays, and view arrays as lists with the static factory. Compare arrays with Arrays.equals and Arrays.compare, and explore key List operations.

Explore Java array search methods, including binarySearch on sorted arrays and mismatch for prefix checks, and compare list search methods like contains, containsAll, and first and last index.

Explore editing data in Java arrays and fixed-size lists using the Arrays utility class, including fill, setAll, sort, parallelPrefix, and immutable lists via List.of and List.copyOf.

Explore Java data transformation with arrays and lists, using Arrays.copyOf and list operations like subList and toArray, plus Iterator and listIterator for forward and backward processing.

Master two dimensional arrays in Java by creating, printing, and initializing them, demonstrate shallow cloning of the first dimension, and achieve deep copies with manual elementwise copying using for loops.

Explore how Java arrays enforce datatype rules and demonstrate autoboxing and widening with int, long, and Integer. See why comparing different typed arrays requires Comparable.

Master immutable lists with list.copyOf and list.of, learn how subList and asList interact with the original list, and practice converting lists to arrays with toArray in Java.

Explore five methods for copying Java arrays, including clone, Arrays.copyOf, Arrays.copyOfRange, List.copyOf, and System.arraycopy, and understand shallow, mutable, and immutable copy behaviors.

Explore how Java objects implement instantiation and lifecycles, including creation, dereferencing, and garbage collection, and examine the structure of Java classes and object fields.

Learn how to declare and instantiate Java objects, use the new keyword and constructors, declare multiple objects of the same type, and apply rules for Object, String, and ArrayList.

Explain how Java allocates heap memory for objects, how references enable garbage collection, and how to observe GC with options like -Xlog:gc and -verbose:gc, including G1 and serial collectors.

Define a Java class structure by detailing the declaration and class body, including modifiers, type parameters, superclass, and implemented interfaces, with rules for public, abstract, final, static, and strictfp.

Explore advanced class declarations in java, including extends and implements, and understand the class body with instance and static initializers, constructors, and the importance of declaration order.

Examine how initializers, constructors, and instance variables execute in Java, revealing that initializer blocks run before constructors in declared order, and that static initializers control class loading.

Explore forward references and initialization nuances in Java SE 11, showing how initializer blocks, static and instance variables, and this and super calls affect object construction and compiler errors.

Explore static and instance fields, final and blank final variables, transient and volatile modifiers, and the default values of fields. Use the this keyword to access instance data in Java.

Compare static class fields and instance fields, and learn final field initialization with constructors and initializers, using examples from SuperClass and FinalFields.

Learn the core concepts of Java methods, including statements, parameters (varargs), return values, and how Java passes by value, with creating and invoking methods and constructors, overloading, and static usage.

Learn to declare methods and constructors with arguments and return values, covering modifiers, headers, varargs, throws, the method signature, and pass by value and pass by sharing.

Explore pass by value in Java methods with tests of primitives, strings, and string builders; observe hashCode behavior and review return-type rules and constructors, including implicit and explicit super calls.

Examine private constructors and the singleton pattern. Compare final classes with final methods, including how final prevents overriding and how toString interacts with abstract classes and Object.

Explore how to implement overloaded methods in Java, using multiple signatures for primitives and objects, and understand how the compiler selects the best match, including var args methods.

Discover how the JVM resolves overloaded methods across phases 1 to 3, including exact and more specific matches, widening, boxing, unboxing, and varargs, plus constructor overloading and chaining.

Explore uncommon overloaded method scenarios in Java, focusing on varargs, primitives, wrappers, and how the Java virtual machine resolves which method to invoke.

Explore how the static keyword applies to methods and fields, including initialization rules, static final fields, and accessing static elements through the class name.

Explore static class members in Java—initialization, static variables and methods, and nested static classes. See how a utility class supplies a static logger for a single, customizable logging point.

Explore encapsulation in Java by examining information hiding and bundling data and behaviour. Learn how access modifiers protect data and reduce coupling while keeping implementation changeable.

Explore Java access modifiers, including public, protected, default, and private, and how they control visibility across packages and subclasses through practical code examples.

Explore how access modifiers in Java, including public, private, protected, and default, behave in inheritance, including attribute hiding and overriding rules, with practical examples and common exam pitfalls.

Explore how access modifiers shape constructors across packages and inheritance, with LevelOneClass, LevelTwoClass, and LevelThreeClass, illustrating protected, package-private, and private constructors and super calls.

Encapsulate data with private fields and public getters and setters in JavaBeans to protect data and enable controlled access to properties; IDEs generate accessors, including boolean properties using is.

Highlight encapsulation pitfalls with reference variables and data integrity in a person bean. Demonstrate how copying address data with a new StringBuilder prevents shared state.

Explore how Java uses single inheritance to build subclasses from superclasses, enabling state and implementation reuse, and learn to apply abstract classes, polymorphism, and method overriding.

Explore creating and using subclasses and superclasses in Java with the extends keyword, is-a relationship, and how public, protected, and package-private members are inherited or overridden; constructors are not inherited.

Demonstrate inheritance through a dog subclass of animal, overriding toString and overwriting a static examineAnimal method while revealing how field hiding of chipDate can mislead access.

Examine how static members and variable hiding work in inheritance, showing how company and branch counters behave, and how overriding affects static versus instance methods and attributes.

Explore how abstract classes define common attributes and behavior, force subclass implementation of abstract methods, and illustrate concrete and automated vehicle examples to show inheritance and interface consistency.

Explore how abstract classes manage final methods while remaining extensible with abstract methods, analyze constructor behavior with private, protected, and super calls, and see how this leads to polymorphism.

Explore polymorphism in Java by revealing how vehicle subclasses override drive, park, and make noise, enabling a test method to operate on any Vehicle type and reveal overriding versus overloading.

Explore polymorphism in Java through overriding and overloading in a base and extended class, using super to extend behavior, and observing how parameter types and throws affect method compatibility.

Explore how overloaded and overridden baseMethod variants work in a polymorphic setup with MostBasicClass and an OverrideOverload subclass, including varargs, arrays, exceptions, and static versus instance considerations.

Explore how polymorphism enables casting between object and reference types in Java, illustrating down-casting and up-casting, compile-time checks, and runtime method resolution with dog, cat, and animal examples.

Explore polymorphism in Java by examining downcasting and upcasting, showing how incorrect casts compile but throw a class cast exception at runtime, and how the compiler can catch certain mistakes.

Explore advanced polymorphism by casting with arrays and generics in Java, showing how object arrays require downcasting, the risk of runtime ClassCastException, and using instance of for type checks.

Compare raw and typed ArrayLists to see how generics enforce type safety and prevent invalid inserts. Understand how type erasure affects casting and assignments for parameterized types.

Explore how interfaces describe shared behaviors and how classes implement them, and learn to create and implement interfaces, and use List and ArrayList, while understanding lambda expressions and abstract classes.

Master Java interfaces: create and implement interfaces, explore default, static, and private methods, and understand how interfaces enable polymorphism and multi-interface inheritance.

Explore interface casting and default methods in Java through hands-on examples, including upcasting, downcasting, and using Laughable, Joke, Story, and Farce.

Extend and implement interfaces and abstract classes to explore how adding methods affects implementing classes, including default methods, abstract methods, and method clashes from multiple inheritance.

Explore how class inheritance differs from interface inheritance in Java, including abstract classes, method conflicts, polymorphism, and when to use abstract classes versus interfaces.

Compare class inheritance and interface inheritance by implementing countMyInstances with abstract classes versus a Countable interface, demonstrating Dog, Cat, and Tree produce the same results while preserving business model integrity.

Explore declaring and using List and ArrayList in Java, including generics with the diamond operator, the List interface, and ArrayList as a resizable, unsynchronized implementation with type checks.

Explore array list methods such as equals, isEmpty, contains, indexOf, and lastIndexOf, and master data manipulation with add, remove, replaceAll, and retainAll, including List.of and List.copyOf for immutable lists.

Analyze the java arraylist toarray method across three cases: no parameter returns an object array; large or equal input copies elements with a null boundary; smaller input may throw ArrayStoreException.

Master advanced ArrayList techniques, including toArray for raw and generic lists. Learn key methods such as equals, isEmpty, contains, indexOf, lastIndexOf, subList, iterator, and listIterator.

Explore common ArrayList and List pitfalls, understand typed versus raw lists, and master add, set, addAll, and subList behaviors with BaseClass examples.

Explore how lambda expressions replace bulky anonymous inner classes, compare anonymous and local classes, and pass lambdas as parameters to functional interfaces that provide target types.

Explain lambda expression syntax: parameters, arrow, and body rules; cover single and multiple parameters, type inference with var, and expression versus block bodies, plus functional interfaces and method references.

Demonstrate single-parameter lambda expressions in Java by using the UnaryIntegerOperation functional interface to square, cube, and increment integers, and show how the compiler builds methods from the lambda bodies.

Learn to implement multiple-parameter lambda expressions in Java 11, using a binary calculator, IntUnaryOperator, and other java.util.function interfaces with var inference and applyAsInt.

Explore four java.util.function interfaces: consumer, predicate, supplier, and function, through lambda expressions and method references, and see how to use them with streams, sorting, and for-each patterns.