Course Description
Overview
In this course, students will learn composition, inheritance, polymorphism, interfaces and exceptions, which are all key to creating well-structured OO systems using Java.
Who Should AttendThis is a fast paced course suitable for programmers with some previous experience in working with Java and Object-Oriented (OO) programming (equivalent to taking our Gentle Java course). Agenda
Outline
Lesson 1: Review - Getting Started
Writing and Running Java programs
Setting up and Using the Development Environment
Lesson 2: Review - Class and Object
Creating classes with fields and methods
Encapsulation and access protection
Constructors
Other Capabilities (Static Members, null, final, Wrapper Classes
Lesson 3: Review - Control Flow, String and Array
Flow of Control
Strings
Arrays
Lesson 4: Review - Packages
Using packages to organize code
Using import
Creating Packages
Package Organization and Classpath
Lesson 5: Composition to Deal with Complexity
Using Composition to Deal With Complexity
Composition/HAS-A, Delegation
Using Inheritance and Polymorphism to share commonality
IS-A, extends, Inheriting Features, Overriding Methods, Using Polymorphism
Class Object
Abstract Classes
Lesson 6: Interfaces
Programming by Contract
Using Interfaces to Define Types
Interfaces and Polymorphism
Lesson 7: Exceptions and Error Handling
Exceptions
Exception Hierarchy
try and catch
Handling Exceptions
Program Flow with Exceptions
Finally
Lesson 8: JDBC
JDBC basics
JDBC Architecture
Using JDBC drivers & DriverManager
Class Connection and connecting to a database
Class Statement and executing SQL statements
Other statement types
Driver types
Lesson 9: Collections and Generics
The Collections Framework
Collection Interfaces
Collection, Set, List, Map, Iterator
Generics (Java 5)
Processing Items With an Iterator
for-each Loop (Java 5)
Using ArrayList
Using HashMap
More About Generics (Inheritance, Wildcards, Assignment
Lesson 10: Additional Java Features
Assertions
Type-safe Enums
Annotations
Lesson 11: I/O Streams
Readers and Writers
Filter Streams
InputStreams and OutputStreams
Converting Between Streams and Readers/Writers
New I/O (NIO) APIs
Lesson 12: Inner Classes
Why Use Inner Classes?
Named Inner Classes
Static Inner Classes
Anonymous Inner Classes
Lesson 13: Reflection
The class called Class
Finding Fields, Methods, and Constructors
Accessing Fields, Invoking Methods
Examining Arrays
Lesson 14: Introduction to ant
ant Overview, Installing and Running ant
Buildfiles, Projects, Targets, Tasks, Properties
Creating Build Files
Lesson 15: Working with Paths and Resource Collections
Paths(e.g. CLASSPATH, PATH)
Resource Collections - FileSets, DirSets, Files, PatternSets
Other Resource Collections and Selectors
Lesson 16: ant Tasks
Overview of ant Tasks
javac and java Tasks in Depth
Creating Java Archives
File Related Tasks, Other Useful Tasks
Lesson 17: ant Modularity
Properties Files
The ant Task and SubProjects
The import Task For Importing Buildfiles
Lesson 18: JUnit Basics
JUnit Overview, Test Driven Development
Tests and Assertions
Working With Exceptions
Lesson 19: Organizing Test with JUnit
Writing Fixtures - @Before, @After
Test Suites, and Other Capabilities
Mock Objects
Lesson 20: Introduction to Logging and log4j
Logging Overview
log4j Overview
Loggers, Appenders, Layouts
Configuring and Using log4j
Logger Hierarchy and Logging Levels
Working With Appenders
Using PatternLayout
- Other Logging Frameworks (Java Logging, Apache Commons Logging)