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

Explore advanced Java fundamentals aligned with the 1Z0-819 exam, covering final classes, nested and anonymous classes, and the enum type.

Explore the valid modifiers for the class, interface, and enum reference types, including access modifiers, abstract, static, final, and strictfp, and learn top-level constraints and common compiler errors.

Master the final modifier in class definitions by exploring final classes and final methods through practical Java examples, including overriding behavior and compiler errors in a hands-on IntelliJ project.

Explore the behavior of abstract classes versus final classes in Java by adding code to demonstrate instantiation, subclassing, and method overriding, including final methods and final classes.

Explore how abstract and final modifiers oppose each other, why final classes cannot be subclassed, and why final methods have bodies, with private constructors and the singleton pattern.

Explore how java defines nested classes, including static nested classes and inner classes, with examples of static and instance members, local and anonymous inner classes, and practical code scenarios.

Explain how static nested classes in Java cannot reference enclosing instance members, forcing access to instance members through nested class instance, while static members remain accessible in a static context.

Explains how to instantiate and use a non-static inner member class in a Java enclosing class, showing access through an enclosing instance, constructors, and inner methods.

Explore how to add a field to the enclosing class, access it via the inner class, resolve shadowing with EnclosingClass.this, and note enums and interfaces can't be in inner classes.

Explore local variable shadowing in inner member classes, compare static nested and inner classes, and learn how to instantiate and access enclosing class members.

Discover how local classes in Java are declared within a block or method, access enclosing class attributes including private ones, and use effectively final locals, with no static members.

Explore creating local classes inside static methods and anonymous inner classes, demonstrating how local classes can extend abstract classes and implement interfaces, while noting their limitations and syntax.

Explore how anonymous classes interact with abstract classes and interfaces, extend any class, and use local, inner, and static nested types to improve encapsulation, readability, and maintainability.

Learn how to create and use Java enums with days of the week, including constants, values and ordinal methods, and a switch example.

Explore enums as classes by adding fields, constructors, and methods to weekdays; see how different constructors populate attributes and how enum constants can invoke a method in main.

Explore how enum constants can have class bodies that define anonymous classes extending the enum, and see how abstract methods, overrides, and describe logic apply to Pinochle meld.

Explore effectively final local variables used by local and anonymous classes. Understand enum compilation, initialization order, and how enums implement interfaces in Java.

Learn advanced exception handling and assertions in Java SE 11, building on 1Z0-819 part 1 concepts. Use try-with-resources, custom exception classes, and assertions to test invariants and prepare for exam.

Compare legacy finally blocks with the Java SE 7 try-with-resources construct and show auto closable resources that close in reverse order.

Design and implement custom exception classes in Java by using constructors from Throwable, and differentiate checked versus unchecked exceptions to guide usage and handling.

Develop custom checked and unchecked exceptions in Java SE 11, implementing custom throwable and custom exception classes, and exploring catch/specifier, throws clauses, and exception chaining with stack traces.

Explore testing program invariants with Java assertions, including enabled and disabled modes, assertion forms with messages, overflow handling, and how assertions document assumptions.

Explore when to use Java assertions for internal, control-flow, precondition (non-public), postcondition, and class invariants; learn best practices, including avoiding public parameter checks and enabling -ea to test invariant logic.

Explore advanced assertion techniques and handling assertions in Java SE 11, including postconditions, else blocks, and using -ea and -da to enable or disable assertions by class or package.

Explore suppressed exceptions and advanced try-with-resources scenarios, inspecting close methods, nested resources, and capturing suppressed errors from Java 8 to 9.

Explore interfaces with a focus on default methods from JDK 8 and private methods from JDK 9, and master the rules governing interface members for the 10Z-819 exam.

Explore how default methods enable evolving interfaces in Java 8, with examples of a Defaultable interface, abstract methods, and defaultNotAbstractMethod, plus how superclass methods take precedence over interface defaults.

Examine how the JVM prioritizes default methods and resolves conflicts across interfaces, including using a specific interface's super method to select getGait. Note Java 9 introduced private interface methods.

Learn how private methods in Java interfaces (JDK 9) encapsulate reusable logic without exposing public nested classes. Compare this approach with default and static methods to simplify interface design.

Explore how default, private, and static interface methods interact, including static context calls, class and interface qualifiers, and the limits on invoking default or non-static methods.

Identify and resolve interface method conflicts with default methods, including prohibitions on overriding Object methods like toString, equals, and hashCode, and understand class versus interface method precedence.

Demonstrate interface method override rules, including private and static vs default methods, and mastery of method selection when multiple interfaces clash.

Explore generics and collections in Java, covering lists, linked lists, queues, sets and maps, and compare and sort elements with Comparator, Comparable, and the Collections class.

Explore primitive wrapper classes, autoboxing, and unboxing in Java, including how null wrappers cause exceptions and how valueOf replaces deprecated constructors.

Examine common methods of primitive wrappers in Java, including compare, valueOf, parse and equals, with code demonstrations and tests showing behavior for nulls, radix, and type-specific nuances.

Explore advanced wrapper class methods and operator interactions in Java, including value retrieval, parsing, equals behavior, compare methods, autoboxing limits, and system property lookups.

Discover how generics enable type abstraction in Java by using generic classes and methods with type parameters, and learn how wildcards provide flexible use for different types.

Explore creating and using generic classes, understand type parameters, type arguments, and the diamond operator, and learn about type inference, raw types, and compile-time errors.

Explore restrictions on generic classes, including not extending Throwable, static type-parameter usage, and invalid type arguments. Learn how upper bounds like T extends Exception guide safe generics.

Explore bounded and unbounded generics, upper bounds with number and comparable, and how type erasure translates generic code into bytecode, highlighting common compile errors and design considerations.

Master generic methods by declaring method-level type parameters, exploring their scope, and learning to invoke them with explicit arguments or type inference in static and non-static contexts.

Explore combining generic class type parameters with generic methods to enforce type relationships, using upper-bounded and unbounded parameters, and apply to constructors and methods with lists and comparable types.

Learn how Java generics wildcards enable unbounded, upper-bounded, and lower-bounded type arguments, with practical guidance on where they work and where they cannot be used.

Explore practical use cases and limitations of generics wildcards in Java, including upper and lower bounds, unbounded wildcards, and the effects of type erasure on compilation.

Explore inheritance with generics and type parameters, clarifying why a generic list of integers is not a subtype of a list of numbers. Learn how wildcards enable safe cross-type use.

Explore advanced generic concepts by examining hiding type parameters and erasure, constructor overloading, and diamond notation in a generics-heavy example, highlighting standard naming conventions and type inference.

Explore the Java collections framework core interfaces, including list, map, set, queue, and deque, and understand their ordering, duplicates and null handling, and access methods.

Explore the collection interface methods and set implementations, including contains, isEmpty, contains all, add all, remove all, retain all, and clear, and examine HashSet, TreeSet, and LinkedHashSet.

Examine hashset, treeset, and linkedhashset by running tests that add, remove, and check elements, including nulls and duplicates, and compare ordering and equality across implementations.

Investigate null handling and set behavior, including equality with nulls, comparing HashSet and LinkedHashSet with and without nulls, and explore TreeSet's navigable methods: lower, floor, higher, and ceiling.

Explore the list interface in Java collections, its ordered, zero-based index access, support for duplicates and nulls, and key operations like add, get, set, and subList.

Explore practical and advanced usage of the list interface with array lists, covering add, addAll, set, indexOf, lastIndexOf, subList, reverse order, and immutable lists via copyOf and of.

Explore Java queues and deques, explain first-in, first-out and double-ended access, and review core methods such as add, offer, element, peek, remove, poll, push, and pop.

Master the map interface in Java collections, handling keys and values, nulls, and common operations like compute, merge, replaceAll, and computeIfAbsent/Present across HashMap, TreeMap, and LinkedHashMap.

Master advanced map operations in Java, including merge semantics, replaceAll, and compute-based updates. Leverage Map.of, Map.ofEntries, Map.copyOf, and entrySet, keySet, values views, while managing immutable versus mutable maps.

Explore uncommon scenarios in the collections framework by examining views backed by source collections, including subList behavior with arrays and ArrayList, and how modifications may trigger an UnsupportedOperationException.

Explore comparable and comparator interfaces to define natural and custom sorting in Java, using compareTo, TreeSet, and key-extractor comparators to sort by various criteria.

Sort lists and arrays with reverseorder and naturalorder, and use a last-name comparator to order by surname. Handle nulls with nullsFirst or nullsLast and build comparators via the comparing method.

Explore the java.util.Collections methods for data manipulation and creating unmodifiable or singleton collections. See examples of sort, shuffle, min, max, and copy operations, and how immutable lists trigger an exception.

Explore how tree set sorts by natural ordering with comparable or by a constructor-parsed comparator, such as sorting by id ascending or value descending.

Explore wrappers and generics, showing how primitive literals autoboxed to wrappers, why lists with raw types break type safety, and how upper and lower bounds affect adding elements.

Explores generics and wild cards, demonstrating upper and lower bounds in a generic container and how extends and super affect add/get operations and compiler behavior.

Explore functional interfaces and lambda expressions in Java SE 11, including compact lambdas, statement lambdas, SAM concept, and local variables for lambda parameters.

Explore functional interfaces in Java: one abstract method, how to use lambdas and anonymous classes, and the impact of default methods and inheritance on functional behavior.

Explore how to create and use lambda expressions in Java, leveraging functional interfaces, lambda syntax, parameters, the arrow notation, and scope rules with practical examples.

Explore functional interfaces and lambda use by examining Functionable with three abstract methods and a default method in Confuseable, noting how extends Comparator influences functional interface status.

Explore the core functional interfaces in the java.util.function package, including Consumer, Function, Operator, Predicate, and Supplier. Learn their methods accept, apply, test, and get, and how they support exam objectives.

Explore unary operator and binary operator in java.util.function through lambda examples, highlighting their extension of Function and BiFunction and their compose and then methods, including maxBy and minBy with comparator.

Explore the built-in java.util.function predicate interface for boolean-valued tests, including the test method, generic typing, short-circuiting with and/or chaining, and utilities like isEqual and not.

Explore the Function and BiFunction interfaces, using lambdas to transform data, chain operations with compose and andThen, and compare generic and non-generic forms across UnaryOperator, BinaryOperator, and Predicate.

Explore specialized primitive interfaces for double and int in Java, including DoubleUnaryOperator and IntUnaryOperator. Learn how methods like applyAsDouble and getAsInt differ from their generic counterparts.

Explore built-in interfaces such as Consumer, BiFunction, Predicate, Supplier, and UnaryOperator, using lambdas and method references. Learn about overloading ambiguities, casting, and how to choose appropriate functional interfaces in Java.

Explore andThen and compose default methods across functional interfaces in Java, focusing on Function and UnaryOperator, and Consumer, BiFunction, and BinaryOperator; learn lazy invocation, re-assignment, and method chaining.

Explore how Java streams act like a query language for data in collections, chaining filters, sorts, and transforms into a pipeline that ends with collect.

Explore the java.util.stream.Stream interface, creating streams (including primitive streams) and forming pipelines with intermediate and terminal operations such as forEach, collect, and limit.

Learn how Java stream pipelines work, with sources and terminal operations, lazy intermediate operations, stateless and stateful forms, and short-circuiting on infinite streams.

Explore how lambda expressions and method references integrate with Java streams, mapping functional interfaces to stream methods like map, reduce, filter, and takeWhile. Learn about signature rules and practical examples.

Explore four types of method references—static, instance on an object, instance on an arbitrary object, and constructor references—and learn how to use them with streams and functional interfaces, including common mistakes like signature mismatches.

Demystify the stream builder, its mutability and life cycle, and how proper typing and compile-time checks prevent runtime errors like class cast and illegal state in builder vs stream.

Explore Stream.concat, a lazily concatenated stream merging two input streams, preserving order or parallelism, with close handlers and per-source intermediate operations, plus common errors such as illegal state.

Explore lambda operations on streams, including map, flatMap, reduce, and collectors like groupBy and partitioningBy, powered by interfaces such as BinaryOperator and Predicate.

Explore stream element manipulation in Java SE 11 with peek for debugging and map for transforming data, noting how terminal operations trigger execution.

Explore mapToDouble, mapToInt, and mapToLong for primitive streams, compare them with map, and uncover flatMap's one-to-many transformations, plus using peek to inspect the pipeline.

Explore how the java.util.Optional class handles null and not applicable values, using empty, of, and ofNullable to wrap GPA cases and avoid null pointers.

Explore optional class methods such as ifPresent, orElse, orElseGet, and orElseThrow, illustrated with GPA examples and stream terminal methods findAny, findFirst, anyMatch, allMatch, and nonMatch.

Explore how stream terminal operations such as findAny, findFirst, anyMatch, allMatch, and noneMatch search stream data, handle empty streams with Optional, and contrast with filter, including short-circuiting and real-world examples.

Master stream reduction operations in Java, including count, max, min, sum, and average, with Optional handling and orElse for empty results. Learn to safely apply these reductions to finite streams.

Learn to perform reductions on IntStream, LongStream, and DoubleStream using reduce with BinaryOperator, compute sum, min, max, and average, and use range, rangeClosed, and summaryStatistics.

Sort streams using the no-arg or comparator-based sort, applying natural order, lambdas, or method references to sort by last name or first name.

Discover how Java streams use collectors for collect and reduce operations, transforming data into lists, maps, and other containers, with grouping, partitioning, and averaging.

Use collectors.groupingBy and partitioningBy to compute counts and averages by state and type. Create multi-attribute keys, nested maps, and sorted outputs with tree maps in streams.

Explore how Collectors.groupingBy and Collectors.toMap differ in Java streams, showing one-to-many versus one-to-one mappings, and how duplicates are handled via equals, hashCode, and distinct.

Explore sorting stream results with TreeMap in groupingBy and toMap overloads using TreeMap::new and a supplier, plus flatMap for flattening lists of pets into a type-based map, and Collectors.toList.

Explore migrating pre-Java 9 code to the module system, top-down migration, splitting a Java SE 8 app into modules, and using jdeps to resolve dependencies on classpath and modulepath.

Migrate Java applications to modules by leveraging the modular JDK, classpath, and module path interoperability, and using bottom up or top down approaches to convert jars to modular jars.

Learn to build a pre-module Java application with core, entity, service, and api modules, migrate to a modular design, and package jars with a manifest for classpath and modulepath.

Master the top-down java module migration by converting legacy sample.core to a sample.api module, enabling automatic modules, adding module-info.java and dependencies, and running on the module path.

Use jdeps to analyze jar dependencies and module path before migration to Java 11, highlighting illegal internal APIs, split packages, and dependency cycles.