course-deatils-thumbnail

Introduction to programming, OO and Java 8 essentials

Course Code: 1213
|

$2495

Overview

The Introduction to programming, OO and Java 8 essentials is a five day course for participants keen to get started with their career in computer programming. The course introduces the participants to programming and Java and discusses the best practices for developing object-oriented programs with Java 8 by using efficient development practices. The course equips participants with foundation-level skills to help maximize performance using Java 8 capabilities for the purpose of rapid application development. The course emphasizes object-oriented concepts and best practices throughout the program to familiarize learners with the complete range of tools used for developing reusable applications.

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

  • The steps involved in the creation and deployment of computer programs
  • The fundamentals of OO programming
  • The advantages of OO in the present IT landscape
  • To work with objects, classes, and OO implementations
  • Basic concepts of OO such as encapsulation, inheritance, polymorphism, and abstraction
  • The core constructs shared by all programming languages
  • The core Java constructs supporting processing, as well as OO orientation
  • To use Java exception handling
  • Understand and use classes, inheritance and polymorphism
  • Understand and use collections, generics, autoboxing, and enumerations
  • Access the Java tooling offered with the programming environment during the course

Outline

  • What is a computer program?
  • Problem solving using programs
  • The spectrum of programming languages
  • Starting with requirements
  • Designing a program
  • Implementing the program
  • Converting source code to machine language
  • Executing machine language
  • Testing to requirements
  • Deploying to production
  • Exercise: Business use case – payroll
  • Design tools
  • Development tools
    • Code editors
    • Documentation
    • Compilers
    • Debuggers
  • Execution tools
    • Runtime environments
    • Interpreters
    • Libraries
  • Testing tools
  • Real-World Objects
  • Programming Objects
  • State and Functionality
  • Classes as a Template for Instances
  • Working with a Class
    • A Class Diagram
    • Implementing the Class
    • Compiling the Class
    • Executing the Class
  • Exercise: Modelling employees for payroll
  • Different languages, different syntax
  • Features of any program
    • Entry point
    • Instructions
    • Exit points
  • Why break a program apart?
  • Real-World Objects
  • Classes and Objects
  • Object Behavior
  • Methods and Messages
  • Classes in Java
  • Class Modifiers and Types
  • Class Instance Variables
  • Primitives vs. Object References
  • Creating Objects
  • Exercise: Create a Simple Class
  • Workbench and Workspace
  • Views
  • Editors
  • Perspectives
  • Projects
  • Tutorial: Working with Eclipse Neon
  • Setting up environment
  • Locating class files
  • Compiling package classes
  • Source and class files
  • Java applications
  • Exercise: Exploring ColorPicker and MomeoryViewer
  • Java platforms
  • Lifecycle of a Java program
  • Responsibilities of a JVM
  • Documentation and code reuse
  • Handling data
    • Variables and constants
    • Arrays, lists and queries
  • Handling functionality
    • Methods
    • Pre-defined functionality
  • Handling flow control
    • Decision structures
    • Repetition (loops)
  • Exercise: Implementing payroll
  • Encapsulation
  • Inheritance
  • Method Overriding
  • Polymorphism
  • 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
  • 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 Array
  • 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 – 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
  • Autoboxing/Unboxing
  • The Date Class
  • Exercise: Using Primitive Wrappers
  • Enumeration Syntax
  • When You Should Use Enumerations
  • Using Static Imports
  • When You Should Use Static Imports
  • Exercise: Enumerations
  • Characterizing Collections
  • Collection Interface Hierarchy
  • Iterators
  • The Set Interface
  • The List Interface
  • Queue Interface
  • Map Interfaces
  • Using the Right Collection
  • Collections and Multithreading
  • Exercise: Collections Poker
  • Generics and Subtyping
  • Bounded Wildcards
  • Generic Methods
  • Legacy Calls to Generics
  • When Generics Should Be Used
  • Exercise: Shopping Cart
  • StringJoiner
  • format
  • out.printf
  • The Formatter class
  • Using the formatting syntax
View More

Prerequisites

There are no prerequisites for this course.

Who Should Attend

Anyone who wants to have a basic understanding of object-oriented programming and developing Java applications would find this course useful.

Interested in this course? Let’s connect!