We provide course about Java SE Advanced Techniques (Course 2 for exam 1Z0-819). This course takes a deeper look into some of the advanced techniques and APIs available in contemporary Java, focusing specifically on Java 8 through Java 11.
Course description:
You’ll learn all about the new modular approach introduced in Java 9, as well as a thorough investigation of functional programming techniques via lambdas, functional interfaces, and streams. The course also covers important parts of the API including concurrency, data manipulation, and security.
What you will learn:
• Modular Java
• Functional programming techniques
• Effective concurrency
• Data access techniques
• Security
• Localization
Course outline:
Module 1 - Java Class Fundamentals:
• Final classes: Overview of inner classes: Regular inner classes: Method-local inner classes: Anonymous inner classes: Static nested classes: Enumerations.
Module 2 - Lambda expressions:
• What are lambda expressions: Formal syntax for lambda expressions: Lambda expression simple syntax: Lambda expressions that return a value: Lambda expressions with multiple arguments: Lambda expressions and scope: Common usage scenarios.
Module 3 - Method enhancements:
• Method references: Constructor references: Default methods: Static methods in interfaces
Module 4 - Functional interfaces:
• Function: UnaryOperator: BiFunction: BinaryOperator: Predicate: Consumer: Supplier: Additional new functional interfaces
Module 5 - Streams:
• Sequential vs. parallel streams: Immediate vs. terminal operations: Stream example: Lazy evaluation: A closer look at immediate and terminal operations: Primitive-specialized streams.
Module 6 - Modular Programming in Java:
• Getting started with Java modules: Using the modular JDK: Creating a modular application: Creating a multi-module app: Modularized JARs.
Module 7 - Going Further with Java Modules:
• Standalone applications: Services: The unnamed module: Automatic modules: Migration Strategies
Module 8 - Concurrency:
• Runnable and Callable classes: Java synchronization language features: Designing thread-safe classes: Recommendations for synchronizing resource access.
Module 9 - Additional Multithreading Issues:
• Using concurrent collections: Using synchronizers and locks: Thread pooling techniques: Using the executor framework: Using pooling effectively.
Module 10 - File Handling:
• Overview of working with files: Reading and writing text files: Reading and writing binary files: Serialization: Overview of NIO2: Basic operations: File visitors: Directory watching: File attributes.
Module 11 - Accessing Databases using JDBC:
• JDBC drivers and connections: Statements and results: Obtaining metadata: DataSources: Metadata: JDBC escape syntax: Transaction management: Additional techniques.
Module 12 - Annotations and Reflection:
• Understanding annotations: Using standard annotations: Defining custom annotations: Overview of reflection: Dynamic retrieval of information using reflection: Creating instances of extensibility objects.
Module 13 - Security:
• Security managers: Policy files: Sandboxing: Cryptographic random numbers.
Module 14 - Localization and Resource Bundles:
• Locales: Resource bundles: Locale-specific formatting and parsing
Instructor: Andy Olsen
Andy is a freelance consultant and instructor based in the UK, working mostly in the City of London and Oxford. Andy has been working with .NET since the Beta 1 days and has extensive experience in many facets of .NET development including WCF, WPF, WF, ASP.NET MVC Web development, and mobile applications. Andy has designed and written many Microsoft Official Curriculum courses in the last decade, and has been engaged as author and technical reviewer with Apress on some of their biggest selling books.
Target audience:
Anyone who wants course about Java SE Advanced Techniques (Course 2 for exam 1Z0-819)
Prerequisites:
• At least 6 months experience as a Java developer, or attendance of our Java SE Programming course
Language:
• The course is given in english