Intermediate Java 7 and OO Development

Request more details:

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.
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
<junit> ant task
Setting up Ant for Using <junit>
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