If you're an experienced OO developer (coming from a C# or C++ background, etc.) who needs to transition to programming in Java, this fast-paced, hands-on course will get you there quickly. In this lab-intensive class, you'll quickly be immersed in working with the latest Java 11 programming techniques, using best practices for writing solid, robust (and well-written!) modern object-oriented applications. In addition to learning excellent, current coding skills in Java, you'll explore the new improved features for better performance and new capabilities for addressing rapid application development that Java 11 brings to the table. This course includes several key aspects that were introduced in Java 9, Java 10, and Java 11 including the Java Modular System, Local Variable Type Inference, and several API updates. This course also includes a Quick Look at what’s next in Java – Java 12, Java 13, Java 14 and beyond.

starstarstarstarstar_outline

* Actual course outline may vary depending on offering center. Contact your sales representative for more information.

Learning Objectives

Working in a hands-on learning environment, guided by our expert team, attendees will learn to:
Understand not only the fundamentals of the Java language, but also its importance, uses, strengths and weaknesses
Understand the basics of the Java language and how it relates to OO programming and the Object Model
Learn to use Java exception handling features
Work with the Modular system (Project Jigsaw)
Understand and use classes, inheritance and polymorphism
Understand and use collections, generics, autoboxing, and enumerations
Process large amount of data using Lambda expressions and the Stream API
Abstract, static and private methods in interfaces
Take advantage of the Java tooling that is available with the programming environment being used in the class
Specific Java 11 features covered: Using the Local Variable Type in Lambda expressions; Updates made to the String AP
Time Permitting: Quick look ahead – Java 12, Java 13, Java 14 and Beyond

1

  • The Java Platform

  • Java Platforms
    Lifecycle of a Java Program
    Responsibilities of JVM
    Documentation and Code Reuse
2

  • Using the JDK

  • Setting Up Environment
    Locating Class Files
    Compiling Package Classes
    Source and Class Files
    Java Applications
3

  • The Eclipse Paradigm

  • Workbench and Workspace
    Views
    Editors
    Perspectives
    Projects
4

  • Writing a Simple Class

  • Classes in Java
    Class Modifiers and Types
    Class Instance Variables
    Primitives vs. Object References
    Creating Objects
5

  • Adding Methods to the Class

  • Passing Parameters into Methods
    Returning a Value from a Method
    Overloaded Methods
    Constructors
    Optimizing Constructor Usage
6

  • Language Statements

  • Operators
    Comparison and Logical Operators
    Looping
    Continue and Break Statements
    The switch Statement
    The for-each() Loop
7

  • Using Strings

  • Create an instance of the String class
    Test if two strings are equal
    Get the length of a string Parse a string for its token components
    Perform a case-insensitive equality test
    Build up a string using StringBuffer
    Contrast String, StringBuffer, and StringBuilder
8

  • Specializing in a Subclass

  • Extending a Class
    Casting
    The Object Class
    Default Constructor
    Implicit Constructor Chaining
9

  • Fields and Variables

  • Instance vs. Local Variables:
    Usage Differences
    Data Types
    Default Values
    Block Scoping Rules
    Final and Static Fields
    Static Methods
10

  • Using Arrays

  • Arrays
    Accessing the Array
    Multidimensional Arrays
    Copying Arrays
    Variable Arguments
11

  • Local-Variable Type Inference

  • Type inference
    Infering Types of Local Variables
    The var Reserved Type name
    Benefits of Using var
    Backward Compatibility
12

  • Java Packages and Visibility

  • Class Location of Packages
    The Package Keyword
    Importing Classes
    Executing Programs
    Visibility in the Modular System
    Java Naming Conventions
13

  • Inheritance and Polymorphism

  • Polymorphism: The Subclasses
    Upcasting vs. Downcasting
    Calling Superclass Methods from Subclass
    The final Keyword
14

  • Interfaces and Abstract Classes

  • Separating Capability from Implementation
    Abstract Classes
    Implementing an Interface
    Abstract Classes vs. Interfaces
15

  • Introduction to Exception Handling

  • Exception Architecture
    Throwing Exceptions
    Checked vs. Unchecked Exceptions
16

  • Exceptions

  • Handling Multiple Exceptions
    Automatic Closure of Resources
    Creating Your Own Exceptions
17

  • Utility Classes

  • Wrapper Classes
    Autoboxing/Unboxing
    Enumeration Syntax
    Using Static imports
18

  • Introduction to Generics

  • Generics and Subtyping
    Bounded Wildcards
    Generic Methods
    Legacy Calls to Generics
    When Generics Should Be Used
19

  • Lambda Expressions and Functional Interface

  • Lambda Expression Syntax
    Functional Interfaces
    Type Inference in Java 8
    Method references
20

  • Collections

  • Characterizing Collections
    Collection Interface Hierarchy
    The Set, List and Queue Interfaces
    Map Interfaces
21

  • Using Collections

  • Collection Sorting
    Comparators
    Using the Right Collection
    Lambda expressions in Collections
22

  • Streams

  • 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
23

  • Collectors

  • Creating Collections from a Stream
    Group elements in the Stream
    Multi-level grouping of elements
    Partitioning Streams
24

  • Introduction to the Module System

  • Introduce Project Jigsaw
    Classpath and Encapsulation
    The JDK internal APIs
    Java 9 Platform modules
    Defining application modules
    Define module dependencies
    Implicit dependencies
    Implied Readability
    Exporting packages
25

  • Java Date/Time

  • The Date and Calendar classes
    Introduce the new Date/Time API
    LocalDate, LocalDateTime, etc.
    Formatting Dates
    Working with time zones
    Manipulate date/time values
26

  • Java 12 and beyond

  • Provide an overview of changes since Java 11
    Introduce Preview Features
    Records (Java 14)
    Switch Expressions (Java 12, Java 13, Java 14)
    Text Blocks (Java 13, Java 14)
    Helpful NullPointerExceptions (Java 14)
    Pattern Matching for instanceof (Java 14)

Audience

This is an introductory-level Java programming course, designed for experienced developers who wish to get up and running with Java, or who need to reinforce sound Java coding practices, immediately.

Language

English

Prerequisites

Attendees should have a working knowledge of developing OO software applications (coming from C++, C# or other OO programming backgrounds).

$2,395

Length: 4.0 days (32 hours)

Level:

Not Your Location? Change

Course Schedule:

Schedule select
04
Dec
Monday
10:00 AM ET -
6:00 PM ET
Filling Fast
Available
Loading...