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.
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
Curriculum
- 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?
- 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
- Java platforms
- Lifecycle of a Java program
- Responsibilities of a JVM
- Documentation and code reuse
- Setting up environment
- Locating class files
- Compiling package classes
- Source and class files
- Java applications
- Exercise: Exploring ColorPicker and MomeoryViewer
- Workbench and Workspace
- Views
- Editors
- Perspectives
- Projects
- Tutorial: Working with Eclipse Neon
- Classes in Java
- Class Modifiers and Types
- Class Instance Variables
- Primitives vs. Object References
- Creating Objects
- Exercise: Create a Simple Class
- Real-World Objects
- Classes and Objects
- Object Behavior
- Methods and Messages
- 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
- StringJoiner
- format
- out.printf
- The Formatter class
- Using the formatting syntax
- Generics and Subtyping
- Bounded Wildcards
- Generic Methods
- Legacy Calls to Generics
- When Generics Should Be Used
- 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 Multithreading
- Exercise: Collections Poker
Who should attend
Anyone who wants to have a basic understanding of object-oriented programming and developing Java applications would find this course useful.
Prerequisites
There are no prerequisites for this course.
