Beginning Java Objects: From Concepts to Code, 3rd Edition

https://reggaeportugal.com/rn84i20dw Table of Contents About the Author About the Technical Reviewer Preface Introduction Student Registration System (SRS) Case Study 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 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 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