course-deatils-thumbnail

J8 Java 8 Essentials

Course Code: 1041
|

Overview

Java is one of the most popular programming languages in the market that can be used in a wide range of disciplines such as, software development, like web development, mobile development, desktop application development, and embedded system development.

In this course, participants learn all about the best practices in writing valuable object-oriented code in Java 8. The course covers basic and advanced level skills, enabling learners to write programs with improved performance and great features to meet any client’s expectations. The course specifically focuses on RAD (Rapid Application Development), object-oriented concepts, and best programming practices.

Schedule Classes

Looking for more sessions of this class?
Trivera

Course Delivery

This course is available in the following formats:

Live Classroom
Duration: 5 days

Live Virtual Classroom
Duration: 5 days

What You'll learn

  • Fundamentals of Java, as well as its importance, uses, capabilities and limitations
  • Relationship between Java, OO programming and the Object Model
  • Java multi-threading and exception handling features
  • Using classes, inheritance and polymorphism
  • Applying collections, generics, autoboxing, and enumerations
  • Upgraded features and capabilities of Java
  • Working with the logging API and framework on the Java platform
  • Using the JDBC API to access databases
  • Using Java for networking and communication applications
  • Working with annotations
  • Working with the classes in an existing package
  • Outlining the options for GUI applications in Java
  • Accessing the Java tooling
  • The new Date API
  • Lambda Expressions
  • Streams
  • Collectors

Outline

  • Java Platforms
  • Lifecycle of a Java Program
  • Responsibilities of 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
  • 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
  • Overload 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
  • 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
  • Instance 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
  • Multidimensional 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 Superclass methods from subclass
  • The final keyword
  • Exercise: Salaries – Polyorphism
  • 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
  • Number class
  • Random numbers
  • Autoboxing/Unboxing
  • Date class
  • Exercise: Using Primitive Wrappers
  • Enumeration syntax
  • When to use enumerations
  • Using static imports
  • When to use static imports
  • Introduction to the new Date/Time API
  • LocalDate, LocalDateTime, etc.
  • Formatting dates
  • Working with time zones
  • Manipulate date/time values
  • Exercise: Agenda
  • Generics and subtyping
  • Bounded wildcards
  • Generic methods
  • Legacy calls to generics
  • When to use generics
  • 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 Expression 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
  • Finding elements in the stream
  • Numeric streams
  • Creating infinite streams
  • Sources for using streams
  • Exercise: Working with streams
  • Creating collections for 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 – explicit and flexible
  • Executor interfaces for thread management
  • Challenges for concurrent use of collections
  • Concurrent collections
  • Atomic variables to avoid synchronization
  • Exercise: Working with concurrent Java
  • Exercise: Sleeping threads
  • Exercise: Safe data access
  • Exercise: Producer/consumer
  • The file class
  • File utility methods
  • Java I/O mechanism
  • Subclasses accessing real data
  • Filter classes
  • New file IO – NIO
  • Overview of NIO
  • Exercise: Reading/Writing Byte Data
  • Exercise: Reading/Writing Character Data
  • Exercise: Reading/Writing Objects
  • Overview of Annotations
  • 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
View More

Prerequisites

There are no prerequisites for this course.

Who Should Attend

This training course is highly recommended for current and aspiring –

  • Programmers
  • Back end developers
  • Solution architect/specialist
  • Software engineers
  • Software developers
  • Full stack developers
  • Calypso developers
  • Fresh graduates
  • Web developers

Interested in this course? Let’s connect!