Most Java courses teach you the features and syntax of the language.
This one tells you how to design and develop realistic OO applications in Java.
Writing good code in Java, is as much about understanding OO design, as the Java language syntax.
This course teaches you both.
You learn all the good techniques of OO programming, such as design objects to an
interface and decouple their roles.
As well as learning how to implement these objects in Java.
You will also be shown the underlying patterns of the
Java Development Kit (JDK) — a proven learning method for quickly understanding
the core mechanics of Java.
The course is extremely practical, developed and taught by consultants with many years'
experience in OO design.
When taught at your site, this modular course can be adapted to your situation and requirements.
Duration: 5 days
objectives
- understand the patterns behind the language
- write well-decoupled Object Oriented (OO) code, with correct use of Java interfaces
- use techniques for good OO design to make your applications:
- straightforward to understand
- easy to maintain
- able to adapt and extend to meet new requirements
- follow a clear development method geared towards OO language development
- create Java components that are reusable and configurable at deployment
target audience
The course is suitable for anyone. For onsite training of development teams with experience of
OO design and development in another language, such as C++, the course can be slimmed down.
The course is run using Java 1.1.
Introduction to Java
- what it achieves
- where it comes from
- interpreter and the classpath
- the Java Development Kit (JDK)
- Web and distributed systems
- objects and components
Introduction to objects
- objects in the world and in software
- encapsulation
- pluggability and extensibility
- object analysis and design
Language basics
- declarations, variables, values
- classes
- statements, expressions, methods
- packages
Programming with objects
- objects and fields
- references and encapsulation
- class diagrams
- methods and messages
- arrays and collections
- interfaces and inheritance
- decoupling
Models and code
- choosing classes and links; use-cases
- zooming in and out
- detail and high-level
- basic design sequence
- business models, scenarios
- collaborations ; decoupling
- associations and visibilities
- using patterns
Pluggable design
- designing collaborations
- contracts
- defining interfaces and goals
- abstract frameworks
- generics and delegation
- observers
- introduction to inner classes
- modelling component interfaces
- Java Beans
- build a simple Bean
Exceptions
- throwing, catching
- modelling
Abstract Windowing Toolkit
- The AWT package in detail
- The AWT event models
- Layout Managers
- The Toolkit class
- Creating custom components
Working with streams
- I/O stream manipulations
- file manipulations
- serialization and persistence
The development process
- short cycle development
- low-risk paths
- basic design sequence
- re-engineering
- reuse and component-based design
- process patterns
- deliverables and pragmatics
Please note, when taught at your site, this course is customizable. Modules can be adapted, removed, added from other courses, or even created.
