Intermediate Java 7 and OO Development

Course Description

Intermediate Java and OO Development is a fast paced, 5-day course suitable for programmers with some previous experience in working with Java and Object-Oriented (OO) programming. It includes a short review of basic Java concepts, and then moves on to a comprehensive coverage of more advanced topics in Java and OO programming to provide participants with a strong grounding in using Java in a sophisticated and productive manner. This course goes well beyond the basics of Java and OO programming and covers important topics such as composition, inheritance, polymorphism, interfaces and exceptions, which are all key to creating well-structured OO systems using Java. After coverage of these important areas, it moves on to more advanced topics such as JDBC (for database access), the Java Collections Framework - including the generics capabilities introduced in Java 5, Java I/O, assertions, inner classes, and the reflection API. Finally it covers useful tools for day-to-day programming such as ant, JUnit and various logging frameworks. This course covers far more than an introductory course, and provides participants with a comprehensive understanding of how to use Java`s advanced capabilities in a more sophisticated manner. It teaches a number of useful techniques that enhance productivity and good system design - which Java programmers may otherwise take years to absorb on their own.
5 days
Contact us for pricing
Contact us for dates
Contact us for dates

Prerequisites

Programmers with some previous experience in working with Java and Object-Oriented (OO) programming.

Getting Started

A Simple Applications Class
Compiling HelloWorld
Java Source and Java Bytecode
Life Cycle of a Java Program
Java Programs Insulated From Environment
Java is Dynamic – The Runtime Process

Class and Object

Defining Classes
The Class in Java
Storing Data in Objects
Behavior and Methods
Data Access and Return Values in Methods
Pretty Pictures
About Java Primitive Data Types
Strings
Working with Methods and Data
Local Variables
Overloading Methods
The toString() Method
Encapsulation: Black Boxes
Private/Public Access
Constructors
Other Capabilities
Static Members
Accessing Static Members
final Variables
Comparison
Null objects
Wrapper Classes

Review – Flow of Control, String and Array

Flow of Control
The Comparison Operators
The Logical Operators
Statements
Using Strings
Arrays – Types

Review – Packages

Packages
Importing
Resolving Naming Conflicts
Creating a Package
Access Control for Class Members
Finding Classes
Organizing Files and Packages
Class Path
What is JAR?

Composition and Inheritance

Composition
Delegation
Benefits/Issues with Composition
Relationships
Inheritance and Dealing with Complexity
Inheritance Hierarchy
Inheriting from the Superclass
Constructors and Inheritance
Overriding and Polymorphism
Changing Behavior
OO Concepts – Polymorphism
Access Control – protected Access
Class Object
Abstract Classes

Interfaces

Interface Types
Interface Definitions
Implementing Extended Interfaces
Interfaces are Abstract
Data Members in Interfaces
Multiple Interfaces

Exceptions

Exception Hierarchy
Handling Exceptions
Program Flow with Exceptions
Variable Scope
Throwing Exceptions with throw
User-Defined Exceptions
Multiple catch Blocks
Multicatch (Java 7)

Collections and Generics

Java Collections Framework
java.util Collection Interfaces
Collection Interfaces
List and ArrayList
Autoboxing
Summarizing Collection Features
Collections of Object
Other Collection Types
Using Sets
Map Interface
HashMap
Iterator
More about Generics
The Collections Class

Database Access with JDBC & JPA

What is JDBC?
JDBC Architecture
The Fundamental JDBC API
Common JDBC Types
Naming Databases with URLs
The Item Database Table
Introduction to JPA
JPA Architecture
Working with JPA
Entity Classes
The Event Class
The Persistence Unit & Entity Manager
The Persistence Unit
Accessing Entities
Working with Transactions
JPA Updates and Queries

Additional Language Features

Assertions
Type-Safe Enums
Advanced enum Features
Annotations
The Issue
Other Java Features
Scripting Language Integration
Monitoring and Management Tools (Java 6+)

I/O Streams

Character Streams
Class Reader and Writer
Filter Streams
Converting between Streams and Readers/Writers
Byte Stream Classes
Formatted Output
Format Specifier Modifiers
New I/O (NIO) APIs
NIO Features

Nested / Inner Classes

Why Use Inner Classes?
Types of Inner Classes
Anonymous Inner Classes
Static Inner Classes
Using Inner Classes

Reflection

The Class Class
Getting Class Instances
Inspecting with Reflection
Working with Constructor Objects
Invoking with Reflection

Introduction to ant

What is an ant?
Installing and Running ant
ant Basics
ant Buildfiles and Projects
ant Tasks
A Complete Buildfile
Running our Buildfile
How is ant Useful?
Working with Properties
Other Capabilities
Paths/ Patterns

maven Overview

About Maven
Acquiring / Installing Maven
Maven Concepts
The POM (Project Object Model)
Repositories
Using Maven
Common maven Commands
Creating Project Structure
Setting Java Version

JUnit

JUnit Overview
Writing & Running the Tests
What Is A Unit Test
The org.junit.Assert Class
Testing for exceptions
Result and Failure Classes

Organizing Tests with JUnit

Fixtures and Suites
ant task
Setting up Ant for Using

Introduction to Logging & log4j

Loggers, Levels, Appenders
Using Loggers
Log4j Appenders
Configuring Appenders & Loggers
Logger Hierarchy
Level Inheritance
Configuring Appenders
Layouts – Pattern & HTML
Other Details
Disabling Debugging and Performance
Apache Commons Logging
Recap
Tools Resources