JAVA

Core Java

FUNDAMENTAL PROGRAMMING STRUCTURES

• Writing First Program, Compiling and Running
• First Java Project in Eclipse
• Dissecting the “Hello, World” Program
• Method Calls
• JShell
• Variables Names, Declarations and Conversions 1 2 3 4
• Constants
• Relational and Logical Operators
• Strings
• Concatenation
• Substrings
• String Comparison
• Converting Between Numbers and Strings
• The String API
• Code Points and Code Units
• Input and Output
• Reading Input
• Formatted Output
• Control Flow
• Branches
• Loops
• Breaking and Continuing
• Local Variable Scope
• Arrays and Array Lists
• Working with Arrays
• Array Construction
• Array Lists
• Wrapper Classes for Primitive Types
• The Enhanced for Loop
• Copying Arrays and Array Lists
• Array Algorithms
• Command-Line Arguments
• Multidimensional Arrays
• Functional Decomposition
• Declaring and Calling Static Methods
• Array Parameters and Return Values
• Variable Arguments

OBJECT-ORIENTED PROGRAMMING

• Working with Objects
• Accessor and Mutator Methods
• Object References
• Implementing Classes
• Instance Variables
• Method Headers
• Method Bodies
• Instance Method Invocations
• The this Reference
• Call by Value
• Object Construction
• Implementing Constructors
• Overloading
• Calling One Constructor from Another
• Default Initialization
• Instance Variable Initialization
• Final Instance Variables
• The Constructor with No Arguments
• Static Variables and Methods
• Static Variables
• Static Constants
• Static Initialization Blocks
• Static Methods
• Factory Methods
• Packages
• Package Declarations
• The jar Command
• The Class Path
• Package Access
• Importing Classes
• Static Imports
• Nested Classes
• Static Nested Classes
• Inner Classes
• Special Syntax Rules for Inner Classes
• Documentation Comments
• Comment Insertion
• Class Comments
• Method Comments
• Variable Comments
• General Comments
• Links
• Package, Module, and Overview Comments
• Comment Extraction

INTERFACES AND LAMBDA EXPRESSIONS

• Interfaces
• Declaring an Interface
• Implementing an Interface
• Converting to an Interface Type
• Casts and the instanceof Operator
• Extending Interfaces
• Implementing Multiple Interfaces
• Constants
• Static, Default, and Private Methods
• Static Methods
• Default Methods
• Resolving Default Method Confl icts
• Private Methods
• Examples of Interfaces
• The Comparable Interface
• The Comparator Interface
• The Runnable Interface
• User Interface Callbacks
• Lambda Expressions
• The Syntax of Lambda Expressions
• Functional Interfaces
• Method and Constructor References
• Method References
• Constructor References
• Processing Lambda Expressions
• Implementing Deferred Execution
• Choosing a Functional Interface
• Implementing Your Own Functional Interfaces
• Lambda Expressions and Variable Scope
• Scope of a Lambda Expression
• Accessing Variables from the Enclosing Scope
• Higher-Order Functions
• Methods that Return Functions
• Methods That Modify Functions
• Comparator Methods
• Local and Anonymous Classes
• Local Classes
• Anonymous Classes

INHERITANCE AND REFLECTION

• Extending a Class
• Super- and Subclasses
• Defi ning and Inheriting Subclass Methods
• Method Overriding
• Subclass Construction
• Superclass Assignments
• Casts
• Final Methods and Classes
• Abstract Methods and Classes
• Protected Access
• Anonymous Subclasses
• Inheritance and Default Methods
• Method Expressions with super
• Object: The Cosmic Superclass
• The toString Method
• The equals Method
• The hashCode Method
• Cloning Objects
• Enumerations
• Methods of Enumerations
• Constructors, Methods, and Fields
• Bodies of Instances
• Static Members
• Switching on an Enumeration
• Runtime Type Information and Resources
• The Class Class
• Loading Resources
• Class Loaders
• The Context Class Loader
• Service Loaders
• Reflection
• Enumerating Class Members
• Inspecting Objects
• Invoking Methods
• Constructing Objects
• JavaBeans
• Working with Arrays
• Proxies

EXCEPTIONS, ASSERTIONS, AND LOGGING

• Exception Handling
• Throwing Exceptions
• The Exception Hierarchy
• Declaring Checked Exceptions
• Catching Exceptions
• The Try-with-Resources Statement
• The finally Clause
• Rethrowing and Chaining Exceptions
• Uncaught Exceptions and the Stack Trace
• The Objects.requireNonNull Method
• Assertions
• Using Assertions
• Enabling and Disabling Assertions
• Logging
• Using Loggers
• Loggers
• Logging Levels
• Other Logging Methods
• Logging Confi guration
• Log Handlers
• Filters and Formatters

COLLECTIONS

• An Overview of the Collections Framework
• Iterators
• Sets
• Maps
• Other Collections
• Properties
• Bit Sets
• Enumeration Sets and Maps
• Stacks, Queues, Deques, and Priority Queues
• Weak Hash Maps
• Views
• Small Collections
• Ranges
• Unmodifi able Views

STREAMS

• From Iterating to Stream Operations
• Stream Creation
• The filter, map, and flatMap Methods
• Extracting Substreams and Combining Streams
• Other Stream Transformations
• Simple Reductions
• The Optional Type
• How to Work with Optional Values
• How Not to Work with Optional Values
• Creating Optional Values
• Composing Optional Value Functions with flatMap
• Turning an Optional Into a Stream
• Collecting Results
• Collecting into Maps
• Grouping and Partitioning
• Downstream Collectors
• Reduction Operations
• Primitive Type Streams
• Parallel Streams

PROCESSING INPUT AND OUTPUT

• Input/Output Streams, Readers, and Writers
• Obtaining Streams
• Reading Bytes
• Writing Bytes
• Character Encodings
• Text Input
• Text Output
• Reading and Writing Binary Data
• Random-Access Files
• Memory-Mapped Files
• File Locking
• Paths, Files, and Directories
• Paths
• Creating Files and Directories
• Copying, Moving, and Deleting Files
• Visiting Directory Entries
• ZIP File Systems
• HTTP Connections
• The URLConnection and HttpURLConnection Classes
• The HTTP Client API
• Regular Expressions
• The Regular Expression Syntax
• Finding One Match
• Finding All Matches
• Groups
• Splitting along Delimiters
• Replacing Matches
• Flags
• Serialization
• The Serializable Interface
• Transient Instance Variables
• The readObject and writeObject Methods
• The readResolve and writeReplace Methods
• Versioning

CONCURRENT PROGRAMMING

• Concurrent Tasks
• Running Tasks
• Futures
• Asynchronous Computations
• Completable Futures
• Composing Completable Futures
• Long-Running Tasks in User-Interface Callbacks
• Thread Safety
• Visibility
• Race Conditions
• Strategies for Safe Concurrency
• Immutable Classes
• Parallel Algorithms
• Parallel Streams
• Parallel Array Operations
• Threadsafe Data Structures
• Concurrent Hash Maps
• Blocking Queues
• Other Threadsafe Data Structures
• Atomic Counters and Accumulators
• Locks and Conditions
• Locks
• The synchronized Keyword
• Waiting on Conditions
• Threads
• Starting a Thread
• Thread Interruption
• Thread-Local Variables
• Miscellaneous Thread Properties
• Processes
• Building a Process
• Running a Process
• Process Handles

THE DATE AND TIME API

• The Time Line
• Local Dates
• Date Adjusters
• Local Time
• Zoned Time
• Formatting and Parsing
• Interoperating with Legacy Code

Interfaces

• Exceptions
• Shell Scripting with Nashorn
• Executing Shell Commands
• String Interpolation
• Script Inputs

Highlights of the course

• Online, Classroom and On-Premise
• No prior programming experience required
• Suitable for beginners

Course Duration

• Normal: One Month (online and classroom)
• Accelerated: One Week (online and classroom)
• On Premise: 3-5 days

_____________________________________________________________________________

Advanced Java

The Java SE 8 Stream Library

• From Iterating to Stream Operations
• Stream Creation
• The filter, map, and flatMap Methods
• Extracting Substreams and Concatenating Streams
• Other Stream Transformations
• Simple Reductions
• The Optional Type
• How to Work with Optional Values
• How Not to Work with Optional Values
• Creating Optional Values
• Composing Optional Value Functions with flatMap
• Collecting Results
• Collecting into Maps
• Grouping and Partitioning
• Downstream Collectors
• Reduction Operations
• Primitive Type Streams
• Parallel Streams

GENERIC PROGRAMMING

• Generic Classes
• Generic Methods
• Type Bounds
• Type Variance and Wildcards
• Subtype Wildcards
• Supertype Wildcards
• Wildcards with Type Variables
• Unbounded Wildcards
• Wildcard Capture
• Generics in the Java Virtual Machine
• Type Erasure
• Cast Insertion
• Bridge Methods
• Restrictions on Generics
• No Primitive Type Arguments
• At Runtime, All Types Are Raw
• You Cannot Instantiate Type Variables
• You Cannot Construct Arrays of Parameterized Types
• Class Type Variables Are Not Valid in Static Contexts
• Methods May Not Clash after Erasure
• Exceptions and Generics
• Refl ection and Generics
• The Class Class
• Generic Type Information in the Virtual Machine

 Input and Output

• Input/Output Streams
• Reading and Writing Bytes
• The Complete Stream Zoo
• Combining Input/Output Stream Filters
• Text Input and Output
• How to Write Text Output
• How to Read Text Input
• Saving Objects in Text Format
• Character Encodings
• Reading and Writing Binary Data
• The DataInput and DataOutput interfaces
• Random-Access Files
• ZIP Archives
• Object Input/Output Streams and Serialization
• Saving and Loading Serializable Objects
• Understanding the Object Serialization File Format
• Modifying the Default Serialization Mechanism
• Serializing Singletons and Typesafe Enumerations
• Versioning
• Using Serialization for Cloning
• Working with Files
• Paths
• Reading and Writing Files
• Creating Files and Directories
• Copying, Moving, and Deleting Files
• Getting File Information
• Visiting Directory Entries
• Using Directory Streams
• ZIP File Systems
• Memory-Mapped Files
• Memory-Mapped File Performance
• The Buffer Data Structure
• File Locking
• Regular Expressions

ANNOTATIONS

• Using Annotations
• Annotation Elements
• Multiple and Repeated Annotations
• Annotating Declarations
• Annotating Type Uses
• Making Receivers Explicit
• Defi ning Annotations
• Standard Annotations
• Annotations for Compilation
• Annotations for Managing Resources
• Meta-Annotations
• Processing Annotations at Runtime
• Source-Level Annotation Processing
• Annotation Processors
• The Language Model API
• Using Annotations to Generate Source Code

INTERNATIONALIZATION

• Locales
• Specifying a Locale
• The Default Locale
• Display Names
• Number Formats
• Currencies
• Date and Time Formatting
• Collation and Normalization
• Message Formatting
• Resource Bundles
• Organizing Resource Bundles
• Bundle Classes
• Character Encodings
• Preferences

COMPILING AND SCRIPTING

• The Compiler API
• Invoking the Compiler
• Launching a Compilation Task
• Reading Source Files from Memory
• Writing Byte Codes to Memory
• Capturing Diagnostics
• The Scripting API
• Getting a Scripting Engine
• Bindings
• Redirecting Input and Output
• Calling Scripting Functions and Methods
• Compiling a Script
• The Nashorn Scripting Engine
• Running Nashorn from the Command Line
• Invoking Getters, Setters, and Overloaded Methods
• Constructing Java Objects
• Strings in JavaScript and Java
• Numbers
• Working with Arrays
• Lists and Maps
• Lambdas
• Extending Java Classes and Implementing Java

THE JAVA PLATFORM MODULE SYSTEM

• The Module Concept
• Naming Modules
• The Modular “Hello, World!” Program
• Requiring Modules
• Exporting Packages
• Modules and Refl ective Access
• Modular JARs
• Automatic Modules and the Unnamed Module
• Command-Line Flags for Migration
• Transitive and Static Requirements
• Qualifi ed Exporting and Opening
• Service Loading
• Tools for Working with Modules

 XML

• Introducing XML
• The Structure of an XML Document
• Parsing an XML Document
• Validating XML Documents
• Document Type Definitions
• XML Schema
• A Practical Example
• Locating Information with XPath
• Using Namespaces
• Streaming Parsers
• Using the SAX Parser
• Using the StAX Parser
• Generating XML Documents
• Documents without Namespaces
• Documents with Namespaces
• Writing Documents
• An Example: Generating an SVG File
• Writing an XML Document with StAX
• XSL Transformations

 Networking

• Connecting to a Server
• Using Telnet
• Connecting to a Server with Java
• Socket Timeouts
• Internet Addresses
• Implementing Servers
• Server Sockets
• Serving Multiple Clients
• Half-Close
• Interruptible Sockets
• Getting Web Data
• URLs and URIs
• Using a URLConnection to Retrieve Information
• Posting Form Data
• Sending E-Mail

 Database Programming

• The Design of JDBC
• JDBC Driver Types
• Typical Uses of JDBC
• The Structured Query Language
• JDBC Configuration
• Database URLs
• Driver JAR Files
• Starting the Database
• Registering the Driver Class
• Connecting to the Database
• Working with JDBC Statements
• Executing SQL Statements
• Managing Connections, Statements, and Result Sets
• Analyzing SQL Exceptions
• Populating a Database
• Query Execution
• Prepared Statements
• Reading and Writing LOBs
• SQL Escapes
• Multiple Results
• Retrieving Autogenerated Keys
• Scrollable and Updatable Result Sets
• Scrollable Result Sets
• Updatable Result Sets
• Row Sets
• Constructing Row Sets
• Cached Row Sets
• Metadata
• Transactions
• Programming Transactions with JDBC
• Save Points
• Batch Updates
• Advanced SQL Types
• Connection Management in Web and Enterprise Applications

 The Date and Time API

• The Time Line
• Local Dates
• Date Adjusters
• Local Time
• Zoned Time
• Formatting and Parsing
• Interoperating with Legacy Code

 Internationalization

• Locales
• Number Formats
• Currencies
• Date and Time
• Collation and Normalization
• Message Formatting
• Formatting Numbers and Dates
• Choice Formats
• Text Input and Output
• Text Files
• Line Endings
• The Console
• Log Files
• The UTF-8 Byte Order Mark
• Character Encoding of Source Files
• Resource Bundles
• Locating Resource Bundles
• Property Files
• Bundle Classes
• A Complete Example

 Scripting, Compiling, and Annotation Processing

• Scripting for the Java Platform
• Getting a Scripting Engine
• Script Evaluation and Bindings
• Redirecting Input and Output
• Calling Scripting Functions and Methods
• Compiling a Script
• An Example: Scripting GUI Events
• The Compiler API
• Compiling the Easy Way
• Using Compilation Tasks
• An Example: Dynamic Java Code Generation
• Using Annotations
• An Introduction into Annotations
• An Example: Annotating Event Handlers
• Annotation Syntax
• Annotation Interfaces
• Annotations
• Annotating Declarations
• Annotating Type Uses
• Annotating this
• Standard Annotations
• Annotations for Compilation
• Annotations for Managing Resources
• Meta-Annotations
• Source-Level Annotation Processing
• Annotation Processors
• The Language Model API
• Using Annotations to Generate Source Code
• Bytecode Engineering
• Modifying Class Files
• Modifying Bytecodes at Load Time

 Security

• Class Loaders
• The Class Loading Process
• The Class Loader Hierarchy
• Using Class Loaders as Namespaces
• Writing Your Own Class Loader
• Bytecode Verification
• Security Managers and Permissions
• Permission Checking
• Java Platform Security
• Security Policy Files
• Custom Permissions
• Implementation of a Permission Class
• User Authentication
• The JAAS Framework
• JAAS Login Modules
• Digital Signatures
• Message Digests
• Message Signing
• Verifying a Signature
• The Authentication Problem
• Certificate Signing
• Certificate Requests
• Code Signing
• Encryption
• Symmetric Ciphers
• Key Generation
• Cipher Streams
• Public Key Ciphers

 Native Methods

• Calling a C Function from a Java Program
• Numeric Parameters and Return Values
• String Parameters
• Accessing Fields
• Accessing Instance Fields
• Accessing Static Fields
• Encoding Signatures
• Calling Java Methods
• Instance Methods
• Static Methods
• Constructors
• Alternative Method Invocations
• Accessing Array Elements
• Handling Errors
• Using the Invocation API
• A Complete Example: Accessing the Windows Registry
• Overview of the Windows Registry
• A Java Platform Interface for Accessing the Registry
• Implementation of Registry Access Functions as Native Methods

Highlights of the course

• Online, Classroom and On-Premise
• Knowledge of core Java is must
• Suitable for students and programmers

Course Duration

• Normal: One Month (online and classroom)
• Accelerated: One Week (online and classroom)
• On Premise: 3-5 days (accelerated)