Overview
The Advanced Java 8 Programming training course is a comprehensive Java training for experienced developers keen to learn advanced programming APIs and techniques. The course explores the new features in Java 8 and discusses how to leverage them and apply them for improving application development and application performance, using sound coding techniques and best practices. The course is a skill-centric program with equal measures of hands-on lab exercises and lectures.
What You'll Learn
- Lifecycle of Java programs
- Class files and package classes
- Workbench and workspace
- Primitive and object references
- Methods
- Language statements
- Strings
- Sub-classes
- Fields and variables
- Arrays
- Inheritance and polymorphism
Curriculum
- Java platforms
- Lifecycle of a Java program
- Responsibilities of a JVM
- Documentation and code reuse
- Setting up environment
- Locating class files
- Compiling package classes
- Source and class files
- Java applications
- Exercise: Exploring ColorPicker and MemoryViewer
- Workbench and Workspace
- Views
- Editors
- Perspectives
- Projects
- Tutorial: Working with Eclipse Neon
- Classes in Java
- Class modifiers and types
- Class instance variables
- Primitives vs. object references
- Creating objects
- Exercise: Creating a simple class
- Passing parameters into methods
- Returning a value from a method
- Overloaded methods
- Constructors
- Optimizing constructor usage
- Exercise: Create a class with methods
- Operators
- Comparison and logical operators
- Looping
- Continue and break statements
- The Switch statement
- The For-Each () loop
- Exercise: Looping
- Strings
- String methods
- String equality
- StringBuffer
- StringBuilder
- Exercise: Fun with Strings
- Exercise: Using StringBuffers and StringBuilders
- Extending a class
- Casting
- The object class
- Default constructor
- Implicit constructor chaining
- Exercise: Creating subclasses
- Instances vs. local variables: Usage differences
- Data types
- Default values
- Block scoping rules
- Final and static fields
- Static methods
- Exercise: Field test
- Arrays
- Accessing the arrays
- Multi-dimensional arrays
- Copying arrays
- Variable arguments
- Exercise: Creating an array
- Class location of packages
- The Package keyword
- Importing classes
- Executing programs
- Java naming conventions
- Polymorphism: The subclasses
- Upcasting vs. downcasting
- Calling super-class methods from sub-class
- The Final keyword
- Exercise: Salaries – Polymorphism
- Separating capability from implementation
- Abstract classes
- Implementing an interface
- Abstract classes vs. interfaces
- Exercise: Mailable – Interfaces
- Exception architecture
- Handling multiple exceptions
- Automatic closure of resources
- Creating your own exceptions
- Throwing exceptions
- Checked vs. unchecked exceptions
- Exercise: Exceptions
- Wrapper classes
- The Number class
- Random numbers
- Auto-boxing/un-boxing
- The Date class
- Exercise: Using primitive wrappers
- Enumeration syntax
- When you should use enumerations
- Using static imports
- When you should use static imports
- Exercise: Enumeration
- Introducing the new Date/Time API
- LocalDate, LocalDateTime, etc.
- Formatting dates
- Working with time zones
- Manipulate date/time values
- Exercise: Agenda
- Generics and sub-typing
- Bounded wildcards
- Generic methods
- Legacy calls to generics
- When generics should be used
- Exercise: Shopping cart
- Characterizing collections
- Collection interface hierarchy
- Iterators
- The Set interface
- The List interface
- Queue interface
- Map interfaces
- Using the right collection
- Collections and multi-threading
- Exercise: Using HashTable and HashMap
- Exercise: Collections Poker
- Exercise: Writing a collection
- Functional vs OO programming
- Anonymous inner-classes
- Lambda expressions syntax
- Functional interfaces
- Method references
- Constructor references
- Processing collections of data
- The Stream interface
- Reduction and parallelism
- Filtering collection data
- Sorting collection data
- Map collection data
- Find elements in Stream
- Numeric Streams
- Create infinite Streams
- Sources for using Streams
- Exercise: Working with Streams
- Creating Collections from a Stream
- Group elements in the Stream
- Multi-level grouping of elements
- Partitioning Streams
- Exercise: Collecting
- Principles of multithreading
- Creating a Threaded Class
- Basic features of the Thread Class
- Thread scheduling
- Thread synchronization
- Exercise: Simple Thread Class
- Exercise: Simple Runnable Class
- Concurrent Locks are Explicit and Flexible
- Executor Interfaces Provide Thread Management
- Challenges for Concurrent Use of Collections
- Concurrent Collections
- Atomic Variables Avoid Synchronization
- Exercise: Working with Concurrent Java
- Exercise: Sleeping Threads
- Exercise: Safe Data Access
- Exercise: Producer/Consumer
- The File Class
- File Utility Methods
- The Java I/O mechanism
- Subclasses accessing real data
- Filter classes
- New File IO – NIO
- NIO overview
- Exercise: Reading/Writing Byte Data
- Exercise: Reading/Writing Character Data
- Exercise: Reading/Writing Objects
- Annotations Overview
- Working with Java Annotations
- Exercise: Annotations
- Exercise: Using Annotations
- Connecting to the Database
- Statement and PreparedStatement
- ResultSet
- Executing Inserts, Updates, and Deletes
- Controlling Transactions and Concurrency
- Tutorial: Setup The Derby Database
- Exercise: Reading Table Data
- Exercise: Using JdbcRowSet
- Exercise: Executing within a Transaction
Who should attend
The Advanced Java 8 programming course is highly recommended for –
- Programmers
- Back-end developers
- Solution architect/specialist
- Software engineers
- Software developers
- Full stack developers
- Web developers
Prerequisites
Participants need to have hands-on experience in programming using Java.
