Object Oriented Programming using Java

This book aims to instil the reader with an understanding of the Object Oriented approach to programming and aims to develop some practical skills along the way. These practical skills will be developed by small exercises that the reader will be invited to undertake and the feedback that will be provided.

The concepts that will be explained and skills developed are in common use among programmers using many modern object oriented languages and are thus transferrable from one language to another. However for practical purposes these concepts are explored and demonstrated using the Java programming language.

While the Java programming language is used to highlight and demonstrate the application of fundamental object oriented principles and modelling techniques this book is not an introduction to Java programming. The reader will be expected to have an understanding of basic programming concepts and their implementation in Java (inc. the use of loops, selection statements, performing calculations, arrays, data types and a basic understanding of file handling).

This text is designed not as a theoretical textbook but as a learning tool to aid in understanding theoretical concepts and learning the practical skills required to implement these. To this end each chapter will incorporate small exercises with solutions and feedback provided.

At the end of the book one larger case study will be described – this will be used to illustrate the application of the techniques explored in the earlier chapters. This case study will culminate in the development of a complete Java program that can be downloaded with this book.

1. An Introduction to Object Orientated Programming
   1. A Brief History of Computing
   2. Different Programming Paradigms
   3. Why use the Object Orientation Paradigm?
   4. Object Oriented Principles
   5. What Exactly is Object Oriented Programming?
   6. The Benefits of the Object Oriented Programming Approach
   7. Summary
2. The Unified Modelling Language (UML)
   1. An Introduction to UML
   2. UML Class diagrams
   3. UML Syntax
   4. UML Package Diagrams
   5. UML Object Diagrams
   6. UML Sequence Diagrams
   7. Summary
3. Inheritance and Method Overriding
   1. Object Families
   2. Generalisation and Specialisation
   3. Inheritance
   4. Implementing Inheritance in Java
   5. Constructors
   6. Constructor Rules
   7. Access Control
   8. Abstract Classes
   9. Overriding Methods
   10. The ‘Object’ Class
   11. Overriding toString() defined in ‘Object’
   12. Summary
4. Object Roles and the Importance of Polymorphism
   1. Class Types
   2. Substitutability
   3. Polymorphism
   4. Extensibility
   5. Interfaces
   6. Extensibility Again
   7. Distinguishing Subclasses
   8. Summary
5. Overloading
   1. Overloading
   2. Overloading To Aid Flexibility
   3. Summary
6. Object Oriented Software Analysis and Design
   1. Requirements Analysis
   2. The Problem
   3. Listing Nouns and Verbs
   4. Identifying Things Outside The Scope of The System
   5. Identifying Synonyms
   6. Identifying Potential Classes
   7. Identifying Potential Attributes
   8. Identifying Potential Methods
   9. Identifying Common Characteristics
   10. Refining Our Design using CRC Cards
   11. Elaborating Classes
   12. Summary
7. The Collections Framework
   1. An Introduction to Collections
   2. Collection Interfaces
   3. Old and New Collections
   4. Lists
   5. Sets
   6. Maps
   7. Collection Implementations
   8. Overview of the Collections Framework
   9. An Example Using Un-typed Collections
   10. An Example Using Typed Collections
   11. A Note About Sets
   12. Summary
8. Java Development Tools
   1. Software Implementation
   2. The JRE
   3. Java Programs
   4. The JDK
   5. Eclipse
   6. Eclipse Architecture
   7. Eclipse Features
   8. NetBeans
   9. Developing Graphical Interfaces Using NetBeans
   10. Applying Layout Managers Using NetBeans
   11. Adding Action Listeners
   12. The Javadoc Tool
   13. Summary
9. Creating And Using Exceptions
   1. Understanding the Importance of Exceptions
   2. Kinds of Exception
   3. Extending the Exception Class
   4. Throwing Exceptions
   5. Catching Exceptions
   6. Summary
10. Agile Programming
    1. Agile Approaches
    2. Refactoring
    3. Examples of Refactoring
    4. Support for Refactoring
    5. Unit Testing
    6. Automated Unit Testing
    7. Regression Testing
    8. JUnit
    9. Examples of Assertions
    10. Several Test Examples
    11. Running Tests
    12. Test Driven Development (TDD)
    13. TDD Cycles
    14. Claims for TDD
    15. Summary
11. Case Study
    1. The Problem
    2. Preliminary Analysis
    3. Further Analysis
    4. Documenting the design using UML
    5. Prototyping the Interface
    6. Revising the Design to Accommodate Changing Requirements
    7. Packaging the Classes
    8. Programming the Message Classes
    9. Programming the Client Classes
    10. Creating and Handling UnknownClientException
    11. Programming the Main classes
    12. Programming the Interface
    13. Using Test Driven Development and Extending the System
    14. Generating Javadoc
    15. Running the System and Potential Compiler Warnings
    16. The Finished System…
    17. Summary

Click here to see the files.