Overview
This course 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 covers important topics
such as composition, inheritance, polymorphism, interfaces and exceptions, which are all key to creating
well-structured OO systems using Java. Then the course 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.
Audience
Environments using Java 5 or Java 6
Prerequisites
Programmers with some previous experience in working with Java and Object-Oriented
(OO) programming.
Course duration
5 Days
Course outline
1. 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
2. Class and Object
- Defining Classes
- The Class in Java
- Storing Data in Objects
- Behavior and Methods
- Pretty Pictures
- About Java Primitive Data Types
- Strings
- Working with Methods and Data
- Local Variables
- Overlooking Methods
- Encapsulation and Access Control
- Constructors
- Other Capabilities
3. Review – Flow of Control,String and Array
- Flow of Control
- The Comparison Operators
- The Logical Operators
- Statements
- Strings – Using and Classes
- Arrays – Types
4. Review – Packages
- Packages – Importing
- Resolving Naming Conflicts
- Creating a Package
- Finding Classes
- Organizing Files and Packages
5. Composition and Inheritance
- Composition
- Benefits/Problems of
- Composition
- Relationships
- Inheritance and Polymorphism
- Class Object
- Methods
- Abstract Classes
6. Interfaces
- Interface Types
- Definitions
- Implementing Extended Interfaces
- Interfaces are Abstract
- Multiple Interfaces
7. Exceptions
- Exception Hierarchy
- Handling Exceptions
- Program Flow with Exceptions
8. JDBC
- JDBC Basics
- JDBC Architecture and API
- Database Connections
- Issuing Statements and Processing Data
- Extracting Data from a ResultSet
- SQL -> Java Type Mappings
9. Collections and Generics
- Collections Framework
- Collection Interfaces
- Generics and Autoboxing
- Other Collection Types
- Creating and Using HashMap
- Iterator
- Inheritance with Generic Types
- Wildcard Parameter Types
10. Additional Language Features
- Assertions
- Type-Safe Enums (5.0)
- Advanced enum Features
- Annotations (5.0)
- The Issue
- Annotations – The Solution
11. I/O Streams
- Readers and Writers
- Filter Streams
- InputStreams and OutputStreams
- Converting between Streams and
- Readers/Writers
- New I/O (NIO) APIs
12. Nested / Inner Classes
- Why Use Inner Classes?
- Named Inner Classes
- Static Inner Classes
- Anonymous Inner Classes
13. Reflection
- The Class called Class
- Finding Fields, Methods and
- Constructors
- Accessing Fields, Invoking
- Methods
- Examining Arrays
14. Introduction to ant
- What is an ant?
- Installing and Running ant
- ant Basics
- Creating Build Files
15. Working with Paths and Resource Collections
- Paths
- Resource Collections
- PatternsSets
16. ant Tasks
- <javac> and <java> Tasks in Depth
- Creating Java Archives
- File Related Tasks
- Other Useful Tasks
17. ant Modularity
- Properties Files
- Modularizing Build Files
- Buildfile Imporing Another
- Build
18. JUnit Basics
- JUnit Overview
- Writing JUnit Tests
- Running the Tests
- The Result and Failure Classes
19. Organizing Tests with JUnit
- Fixtures and Suites
- <junit> ant task
20. Introduction to Logging & log4j
- Loggers, Levels, Appenders
- Configuring Logger Levels
- Working with Appenders
- Pattern Layouts
- Other Logging Frameworks
