Beginning Java Objects: From Concepts to Code

Table of Contents
About the Author
About the Technical Reviewer
Preface
Introduction
Student Registration System (SRS) Case Study
Part I: The ABCs of Objects
	Chapter 1: Abstraction and Modeling
		Simplification Through Abstraction
		Generalization Through Abstraction
			Organizing Abstractions into Classification Hierarchies
			Abstraction as the Basis for Software Development
		Reuse of Abstractions
		Inherent Challenges
			What Does It Take to Be a Successful Object Modeler?
		Summary
	Chapter 2: Some Java Basics
		Java Is Architecture Neutral
		Anatomy of a Simple Java Program
			Comments
				Traditional Comments
				End-of-Line Comments
				Java Documentation Comments
			The Class Declaration
			The main Method
		Setting Up a Simple Java Development Environment
		The Mechanics of Java
			Compiling Java Source Code into Bytecode
			Executing Bytecode
		Primitive Types
		Variables
			Variable Naming Conventions
		Variable Initialization
		The String Type
		Case Sensitivity
		Java Expressions
			Arithmetic Operators
			Relational and Logical Operators
			Evaluating Expressions and Operator Precedence
			The Type of an Expression
		Automatic Type Conversions and Explicit Casting
		Loops and Other Flow Control Structures
			if Statements
			switch Statements
			for Statements
			while Statements
			Jump Statements
		Block-Structured Languages and the Scope of a Variable
		Printing to the Console Window
			print vs. println
			Escape Sequences
		Elements of Java Style
			Proper Use of Indentation
			Use Comments Wisely
			Placement of Braces
			Descriptive Variable Names
		Summary
	Chapter 3: Objects and Classes
		Software at Its Simplest
			Functional Decomposition
			The Object-Oriented Approach
		What Is an Object?
			State/Data/Attributes
			Behavior/Operations/Methods
		What Is a Class?
			A Note Regarding Naming Conventions
			Declaring a Class, Java Style
		Instantiation
		Encapsulation
		User-Defined Types and Reference Variables
			Naming Conventions for Reference Variables
		Instantiating Objects: A Closer Look
			Garbage Collection
		Objects As Attributes
			A Compilation “Trick”: “Stubbing Out” Classes
			Composition
			The Advantages of References As Attributes
		Three Distinguishing Features of an Object-Oriented Programming Language
		Summary
	Chapter 4: Object Interactions
		Events Drive Object Collaboration
		Declaring Methods
			Method Headers
			Method Naming Conventions
			Passing Arguments to Methods
			Method Return Types
			An Analogy
			Method Bodies
			Features May Be Declared in Any Order
			return Statements
		Methods Implement Business Rules
		Objects As the Context for Method Invocation
			Java Expressions, Revisited
			Capturing the Value Returned by a Method
			Method Signatures
			Choosing Descriptive Method Names
		Method Overloading
		Message Passing Between Objects
		Delegation
		Obtaining Handles on Objects
		Objects As Clients and Suppliers
		Information Hiding/Accessibility
			Public Accessibility
			Private Accessibility
			Publicizing Services
			Method Headers, Revisited
			Accessing the Features of a Class from Within Its Own Methods
		Accessing Private Features from Client Code
			Declaring Accessor Methods
			Recommended “Get”/“Set” Method Headers
			IDE-Generated Get/Set Methods
			The “Persistence” of Attribute Values
			Using Accessor Methods from Client Code
		The Power of Encapsulation Plus Information Hiding
			Preventing Unauthorized Access to Encapsulated Data
			Helping Ensure Data Integrity
			Limiting “Ripple Effects” When Private Features Change
			Using Accessor Methods from Within a Class’s Own Methods
		Exceptions to the Public/Private Rule
		Constructors
			Default Constructors
			Writing Our Own Explicit Constructors
			Passing Arguments to Constructors
			Replacing the Default Parameterless Constructor
			More Elaborate Constructors
			Overloading Constructors
			An Important Caveat Regarding the Default Constructor
			Using the “this” Keyword to Facilitate Constructor Reuse
		Software at Its Simplest, Revisited
		Summary
	Chapter 5: Relationships Between Objects
		Associations and Links
			Multiplicity
				One-to-One (1:1)
				One-to-Many (1:m)
				Many-to-Many (m:m)
			Multiplicity and Links
		Aggregation and Composition
		Inheritance
			Responding to Shifting Requirements with a New Abstraction
			(Inappropriate) Approach #1: Modify the Student Class
			(Inappropriate) Approach #2: “Clone” the Student Class to Create a GraduateStudent Class
			The Proper Approach (#3): Taking Advantage of Inheritance
			The “is a” Nature of Inheritance
			The Benefits of Inheritance
			Class Hierarchies
			The Object Class
			Is Inheritance Really a Relationship?
			Avoiding “Ripple Effects” in a Class Hierarchy
			Rules for Deriving Classes: The “Do’s”
			Overriding
			Reusing Superclass Behaviors: The “super” Keyword
			Rules for Deriving Classes: The “Don’ts”
			Private Features and Inheritance
			Inheritance and Constructors
				Constructors Are Not Inherited
				super(...) for Constructor Reuse
				Replacing the Default Parameterless Constructor
			A Few Words About Multiple Inheritance
		Three Distinguishing Features of an OOPL, Revisited
		Summary
	Chapter 6: Collections of Objects
		What Are Collections?
			Collections Are Defined by Classes and Must Be Instantiated
			Collections Organize References to Other Objects
			Collections Are Encapsulated
		Three Generic Types of Collection
			Ordered Lists
			Dictionaries
			Sets
		Arrays As Simple Collections
			Declaring and Instantiating Arrays
			Accessing Individual Array Elements
			Initializing Array Contents
			Manipulating Arrays of Objects
		A More Sophisticated Type of Collection: The ArrayList Class
			Using the ArrayList Class: An Example
			Import Directives and Packages
			The Namespace of a Class
			User-Defined Packages and the Default Package
			Generics
			ArrayList Features
			Iterating Through ArrayLists
			Copying the Contents of an ArrayList into an Array
		The HashMap Collection Class
		The TreeMap Class
		The Same Object Can Be Simultaneously Referenced by Multiple Collections
		Inventing Our Own Collection Types
			Approach #1: Designing a New Collection Class from  Scratch
			Approach #2: Extending a Predefined Collection Class (MyIntCollection)
				Wrapper Classes for Primitive Types
				Reusing a Base Class Constructor
				Overriding the add Method
				Putting MyIntCollection to Work
			Approach #3: Encapsulating a Standard Collection (MyIntCollection2)
				Putting MyIntCollection2 to Work
			Trade-Offs of Approach #2 vs. Approach #3
		Collections As Method Return Types
		Collections of Derived Types
		Revisiting Our Student Class Design
			The courseLoad Attribute of Student
			The transcript Attribute of Student
			The transcript Attribute, Take 2
			Our Completed Student Data Structure
		Summary
	Chapter 7: Some Final Object Concepts
		Polymorphism
			Polymorphism Simplifies Code Maintenance
		Three Distinguishing Features of an Object-Oriented Programming Language
			The Benefits of User-Defined Types
			The Benefits of Inheritance
			The Benefits of Polymorphism
		Abstract Classes
			Implementing Abstract Methods
			Abstract Classes and Instantiation
			Declaring Reference Variables of Abstract Types
			An Interesting Twist on Polymorphism
		Interfaces
			Implementing Interfaces
			Another Form of the “Is A” Relationship
			Interfaces and Casting
			Implementing Multiple Interfaces
			Interfaces and Casting, Revisited
			Interfaces and Instantiation
			Interfaces and Polymorphism
			The Importance of Interfaces
				Example #1
				Example #2
		Static Features
			Static Variables
			A Design Improvement: Burying Implementation Details
			Static Methods
			Restrictions on Static Methods
			Utility Classes
			The final Keyword
				Public Static Final Variables and Interfaces
			Custom Utility Classes
		Summary
Part II: Object Modeling 101
	Chapter 8: The Object Modeling Process in a Nutshell
		The “Big Picture” Goal of Object Modeling
			Modeling Methodology = Process + Notation + Tool
		My Recommended Object Modeling Process, in a Nutshell
			Thoughts Regarding Object Modeling Software Tools
				Advantages of Using CASE Tools
					Ease of Use
					Added Information Content
					Automated Code Generation
					Project Management Aids
				Some Drawbacks of Using CASE Tools
			A Reminder
		Summary
	Chapter 9: Formalizing Requirements Through Use Cases
		What Are Use Cases?
			Functional vs. Technical Requirements
			Involving the Users
		Actors
			Identifying Actors and Determining Their Roles
			Diagramming a System and Its Actors
		Specifying Use Cases
		Matching Up Use Cases with Actors
		To Diagram or Not to Diagram?
		Summary
	Chapter 10: Modeling the Static/Data Aspects of the System
		Identifying Appropriate Classes
			Noun Phrase Analysis
			Refining the Candidate Class List
			Revisiting the Use Cases
		Producing a Data Dictionary
		Determining Associations Between Classes
			Association Matrices
		Identifying Attributes
		UML Notation: Modeling the Static Aspects of an Abstraction
			Classes, Attributes, and Operations
			Relationships Between Classes
				Associations
				Aggregation
				Inheritance
			Reflecting Multiplicity
		Object/Instance Diagrams
		Associations As Attributes
		Information “Flows” Along an Association “Pipeline”
		“Mixing and Matching” Relationship Notations
		Association Classes
		Our “Completed” Student Registration System Class Diagram
		Metadata
		Summary
	Chapter 11: Modeling the Dynamic/Behavioral Aspects of the System
		How Behavior Affects State
			Events
				An Object May Change Its State
				An Object May Direct an Event (Message) Toward Another Object
				An Object May Return a Value
				An Object May Interact with the External Boundaries of Its System
				An Object May Seemingly Ignore an Event
		Scenarios
			Scenario #1 for the “Register for a Course” Use Case
			Scenario #2 for the “Register for a Course” Use Case
		Sequence Diagrams
			Determining Objects and External Actors for Scenario #1
			Preparing the Sequence Diagram
		Using Sequence Diagrams to Determine Methods
		Communication Diagrams
		Revised SRS Class Diagram
		Summary
	Chapter 12: Wrapping Up Our Modeling Efforts
		Testing the Model
		Revisiting Requirements
		Reusing Models: A Word About Design Patterns
		Summary
Part III: Translating an Object Blueprint into Java Code
	Chapter 13: A Few More Java Details
		Java-Specific Terminology
		Java Archive (jar) Files
			Creating Jar Files
			Inspecting the Contents of a Jar File
			Using the Bytecode Contained Within a Jar File
			Extracting Contents from Jar Files
			“Jarring” Entire Directory Hierarchies
		Javadoc Comments
		The Object Nature of Strings
			Operations on Strings
			Strings Are Immutable
			The StringBuffer Class
			The StringTokenizer Class
			Instantiating Strings and the String Literal Pool
			Testing the Equality of Strings
		Message Chains
		Object Self-Referencing with “this”
		Java Exception Handling
			The Mechanics of Exception Handling
				The try Block
				The catch Block
				The finally Block
			Catching Exceptions
			Interpreting Exception Stack Traces
			The Exception Class Hierarchy
			Catching the Generic Exception Type
			Compiler Enforcement of Exception Handling
			Taking Advantage of the Exception That We’ve Caught
			Nesting of Try/Catch Blocks
			User-Defined Exception Types
			Throwing Multiple Types of Exception
		Enum(eration)s
		Providing Input to Command-Line-Driven Programs
			Accepting Command-Line Arguments: The args Array
			Introducing Custom Command-Line Flags to Control a Program’s Behavior
			Accepting Keyboard Input: The Scanner Class
			Using Wrapper Classes for Input Conversion
		Features of the Object Class
			Determining the Class That an Object Belongs To
			Testing the Equality of Objects
			Overriding the equals Method
			Overriding the toString Method
			Static Initializers
		Variable Initialization, Revisited
			Variable Arguments (varargs)
		Summary
	Chapter 14: Transforming the Model into Java Code
		Suggestions for Getting the Maximum Value from This Chapter
		The SRS Class Diagram Revisited
			The Person Class (Specifying Abstract Classes)
				Attributes of Person
				Person Constructors
				Person Accessor Methods
				toString()
				display()
			The Student Class (Reuse Through Inheritance, Extending Abstract Classes, Delegation)
				Attributes of Student
				Student Constructors
				Student Accessor Methods
				display()
				toString()
				displayCourseSchedule()
				addSection()
				dropSection()
				isEnrolledIn()
				isCurrentlyEnrolledInSimilar()
				getEnrolledSections()
				printTranscript()
			The Professor Class (Bidirectionality of Relationships)
				Professor Attributes
				agreeToTeach()
				displayTeachingAssignments()
			The Course Class (Reflexive Relationships, Unidirectional Relationships)
				Course Attributes
				Course Methods
				hasPrerequisites()
				getPrerequisites()
				scheduleSection()
			The Section Class (Representing Association Classes, Public Static Final Attributes, Enums)
				Section Attributes
				The Use of an Enum(eration) Type
				enroll()
				drop()
				postGrade()
				getGrade()
				confirmSeatAvailability()
			Delegation Revisited
			The ScheduleOfClasses Class
				ScheduleOfClasses Attributes
				addSection()
				findSection()
				isEmpty()
			The TranscriptEntry Association Class (Static Methods)
				TranscriptEntry Attributes
				TranscriptEntry Constructor
				validateGrade(), passingGrade()
			The Transcript Class
				Transcript Attributes
				verifyCompletion()
			The SRS Driver Program
				Public Static Attributes
				The main Method
		Summary
	Chapter 15: Building a Three-Tier User Driven Application
		A Three-Tier Architecture
			What Does the Controller Do?
		Building a Persistence/Data Tier
		Building a Web-Based Presentation Layer
		Example Controller Logic
		The Importance of Model–Data Layer–View Separation
		Summary
		Further Reading
Appendix A: Alternative Case Studies
	Case Study #1: Prescription Tracking System
		Background
		Simplifying Assumptions
	Case Study #2: Conference Room Reservation System
		Background
		Goals for the System
	Case Study #3: Blue Skies Airline Reservation System
		Background
		Other Simplifying Assumptions
Index