Introduction to Java 11 / 13 for Developers New to OO Programming

Introduction to Java 11 / 13 for Developers New to OO Programming is a five-day, comprehensive, hands-on introduction to Java training course geared for developers who have prior working knowledge of object-oriented programming languages such as C# or C++. Throughout the course, students learn the best practices for writing great object-oriented programs in Java 11, using sound development techniques, new improved features for better performance and new capabilities for addressing rapid application development.

Retail Price: $2,495.00

Next Date: Request Date

Course Days: 5


Request a Date

Request Custom Course


Learning Objectives 

Our engaging instructors and mentors are highly experienced practitioners who bring years of current "on-the-job" experience into every classroom. 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
  • Discover the use of enterprise APIs live CDI and JPA

 

Specific Java 11 features that are covered in the course include:

  • Using the Local Variable Type in Lambda expressions
  • Updates made to the String API

 

 

Audience & Pre-Requisites

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. Attendees should have a working knowledge of developing OO software applications.

 

Take Instead: We offer other courses that provide different levels of knowledge or focus:

  • For a four day, compressed introductory course: TT2104-J113 Fast Track to Core Java 11/13 Programming (4 days)
  • For Developers without prior OO experience: TT2120-J113 Java 11 / 13 and OO Programming Essentials for Developers New to OO (such C, COBOL, etc.) (5 days)
  • For Non-developers / new to coding: Either the TTCODE101-J Introduction to Programming & Coding | Java Basics for Non-Developers (5 days) or TT2000 Introduction to Programming, OO Essentials and Basic Java (5 days)

 

Take After: Our core Java training courses provide students with a solid foundation for continued learning based on role, goals, or their areas of specialty. Our object oriented, Java developer learning paths offer a wide variety of follow-on courses such as:

  • TT2200-J113 Next Level Java | Intermediate Java 11 / 13 Programming
  • Continued Java training: JEE Foundation, Spring, Microservices, RXJava, REST, Services, Tuning, Patterns & more
  • TDD / Test Driven Development, JUnit / Unit Testing, Agile development training
  • Secure Java Coding / Java Security and secure application development training
  • Mobile developer / Android training
  • Please contact us for recommended next steps tailored to your longer-term education, project, role or development objectives.

Outline

Session: Java: A First Look

Lesson: The Java Platform

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

Lesson: Using the JDK

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

Lab: Exploring MemoryViewer

Lab: Exploring ColorPicker

Lesson: The Eclipse Paradigm

  • Workbench and Workspace
  • Views & Editors
  • Perspectives
  • Projects

Tutorial: Setup Projects in Eclipse

 

Session: Getting Started with Java

Lesson: Writing a Simple Class

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

Lab: Create a Simple Class

Lesson: Adding Methods to the Class

  • Passing Parameters Into Methods
  • Returning a Value From a Method
  • Overloaded Methods
  • Constructors
  • Optimizing Constructor Usage

Lab: Create a Class with Methods

 

Session: Essential Java Programming

Lesson: Language Statements

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

Lab: Looping

Lab: Language Statements

Lesson: 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
  • Removing whitespaces and the isBlank method (Java 11)

Lab: Fun with Strings

Lab: Using StringBuffers and StringBuilders

Lesson: Specializing in a Subclass

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

Lab: Creating Subclasses

Lesson: Fields and Variables

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

Lab: Field Test

Lesson: Using Arrays

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

Lab: Creating an Array

Lesson: Local-Variable Type Inference

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

Lab: Using Local-Variable Type Inference

Lesson: Java Packages and Visibility

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

 

Session: Object Oriented Development

Lesson: Inheritance and Polymorphism

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

Lab: Salaries - Polymorphism

Lesson: Interfaces and Abstract Classes

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

Lab: Mailable - Interfaces

 

Session: Exception Handling

Lesson: Introduction to exception handling

  • Exception Architecture
  • Throwing Exceptions
  • Checked vs. Unchecked Exceptions

Lab: Exceptions

Lesson: Exceptions

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

Lab: Exceptional

 

Session: Java Developer's Toolbox

Lesson: Utility Classes

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

Lab: Using Primitive Wrappers

Lab: Enumerations

Session: Advanced Java Programming

Lesson: Introduction to Generics

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

Lab: DynamicArray

Lab: Adding Generics to Dynamic Array

Lesson: Lambda Expressions and Functional Interface

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

Lab: Using Lambda

 

Session: Working with Collections

Lesson: Collections

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

Lab: Create a simple Game using Collections

Lesson: Using Collections

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

Lab: Comparators

Lab: Using Collections

 

Session: Stream API

Lesson: 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

Lab: Working with Streams

Lesson: Collectors

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

Lab: Collecting

 

Session: The Java Module System

Lesson: 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

Lab: Defining Modules

 

Session: Accessing Resources

Lesson: Java Data Access JDBC API

  • Connecting to the Database
  • Statement and PreparedStatement
  • ResultSet
  • Executing Inserts, Updates, and Deletes
  • Controlling Transactions and Concurrency

Lab: Intro to JDBC

Lesson: Introduction to Annotations

  • Annotations Overview
  • Working with Java Annotations

Lab: Using Annotations

Lesson: Introduction to CDI

  • Context Dependency Injection (CDI)
  • The @Inject Annotation
  • The @Default Annotation
  • The @Alternative Annotation
  • The @Named Annotation

Lab: Introduction to CDI

Lab: Adding CDI Qualifiers

Lesson: Overview of JPA

  • Introduce the Java Persistence API (JPA)
  • Benefits of Using an ORM framework
  • Hibernate and JPA

Lab: Introduction to JPA

Additional Topics: Time Permitting

Lesson: 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

Lab: Agenda



Sorry! It looks like we haven’t updated our dates for the class you selected yet. There’s a quick way to find out. Contact us at 502.265.3057 or email info@training4it.com


Request a Date