An introduction to object-oriented programming

by Timothy Budd

Hardcover, 1997

Status

Available

Call number

005.1

Library's review

Indeholder "Preface", " Obtaining the Source", " Assumed Background", " Preface to First Edition", " Acknowledgements", "1. Thinking Object Oriented", " 1.1. Why is Object-Oriented Programming Popular?", " 1.2. Language and Thought", " 1.2.1. Eskimos and Snow", " 1.2.2. An Example from Computer

Languages", " 1.2.3. Church's Conjecture and the Sapir-Whorf Hypothesis", " 1.3. A New Paradigm", " 1.4. A Way of Viewing the World", " 1.4.1. Agents, Responsibility, Messages and Methods", " 1.4.2. Responsibilities", " 1.4.3. Classes and Instances", " 1.4.4. Class Hierarchies - Inheritance", " 1.4.5. Method Binding, Overriding and Exceptions", " 1.4.6. Summary of Object-Oriented Concepts", " 1.5. Computation as Simulation", " 1.5.1. The Power of Metaphor", " 1.5.2. Avoiding Infinite Regress", " 1.6. Coping with Complexity", " 1.6.1. The Nonlinear Behavior of Complexity", " 1.6.2. Abstraction Mechanisms", " 1.7. Reusable Software", " 1.8. Summary", "2. Object-Oriented Design", " 2.1. Responsibility Implies Noninterference", " 2.2. Programming in the Small and Programming in the Large", " 2.3. Why Begin with Behavior ?", " 2.4. A Case Study in Responsibility-Driven Design", " 2.4.1. The Interactive Intelligent Kitchen Helper", " 2.4.2. Working Through Scenarios", " 2.4.3. Identification of Components", " 2.5. CRC Cards - Recording Responsibility", " 2.5.1. Give Components a Physical Representation", " 2.5.2. The What - Who Cycle", " 2.5.3. Documentation", " 2.6. Components and Behavior", " 2.6.1. Postponing Decisions", " 2.6.2. Preparing for Change", " 2.6.3. Continuing the Scenario", " 2.6.4. Interaction Diagrams", " 2.7. Software Components", " 2.7.1. Behavior and State", " 2.7.2. Instances and Classes", " 2.7.3. Coupling and Cohesion", " 2.7.4. Interface and Implementation - Parnas' Principles", " 2.8. Formalize the Interface", " 2.8.1. Coming up with Names", " 2.9. Design the Representation for Components", " 2.10. Implementing Components", " 2.11. Integration of Components", " 2.12. Maintenance and Evolution", "3. Classes and Methods", " 3.1. Encapsulation", " 3.2. Varieties of Classes", " 3.3. Example: A Playing Card", " 3.4. Interface and Implementation", " 3.5. Classes and Methods", " 3.5.1. Classes and Methods in Object Pascal", " 3.5.2. Classes and Methods in Smalltalk", " 3.5.3. Classes and Methods in Objective-C", " 3.5.4. Classes and Methods in C++", " 3.5.5. Classes and Methods in Java", "4. Messages, Instances and Initialization", " 4.1. Message-Passing Syntax", " 4.1.1. Message Passing Syntax in Object Pascal", " 4.1.2. Message Passing Syntax in C++", " 4.1.3. Message Passing Syntax in Java", " 4.1.4. Message Passing Syntax in Smalltalk", " 4.1.5. Message Passing Syntax in Objective-C", " 4.2. Issues in Creation and Initialization", " 4.2.1. Stack Versus Heap Storage Allocation", " 4.2.2. Memory Recovery", " 4.2.3. Pointers", " 4.2.4. Immutable Creation", " 4.3. Mechanisms for Creation and Initialization", " 4.4. Creation and Initialization in C++", " 4.4.1. Creation and Initialization in Java", " 4.4.2. Creation and Initialization in Objective-C", " 4.4.3. Creation and Initialization in Object Pascal", " 4.4.4. Creation and Initialization in Smalltalk", "5. A Case Study: The Eight Queens Puzzle", " 5.1. The Eight Queens Puzzle", " 5.1.1. Creating Objects that Find their Own Solution", " 5.2. Using Generators", " 5.2.1. Initialization", " 5.2.2. Finding A Solution", " 5.2.3. Advancing to Next Position", " 5.3. The Eight Queens Puzzle in Each Language", " 5.3.1. The Eight Queens Puzzle in Object Pascal", " 5.3.2. The Eight Queens Puzzle in C++", " 5.3.3. The Eight Queens Puzzle in Java", " 5.3.4. The Eight Queens Puzzle in Objective-C", " 5.3.5. The Eight Queens Puzzle in Smalltalk", "6. A Case Study: A Billiards Game", " 6.1. The Elements of Billiards", " 6.2. Graphical Objects", " 6.2.1. The Wall Graphical Object", " 6.2.2. The Hole Graphical Object", " 6.2.3. The Ball Graphical Object", " 6.3. The Main Program", " 6.4. Using Inheritance", "7. Inheritance", " 7.1. An Intuitive Description of Inheritance", " 7.2. Subclass, Subtype, and Substitutability", " 7.2.1. Subtypes and Strong Typing", " 7.3. Forms of Inheritance", " 7.3.1. Subclassing for Specialization (Subtyping)", " 7.3.2. Subclassing for Specification", " 7.3.3. Subclassing for Construction", " 7.3.4. Subclassing for Generalization", " 7.3.5. Subclassing for Extension", " 7.3.6. Subclassing for Limitation", " 7.3.7. Subclassing for Variance", " 7.3.8. Subclassing for Combination", " 7.3.9. Summary of the Forms of Inheritance", " 7.4. Inheritance in Various Languages", " 7.4.1. Inheritance in Object Pascal", " 7.4.2. Inheritance in Smalltalk", " 7.4.3. Inheritance in Objective-C", " 7.4.4. Inheritance in C++", " 7.4.5. Inheritance in Java", " 7.5. The Benefits of Inheritance", " 7.5.1. Software Reusability", " 7.5.2. Code Sharing", " 7.5.3. Consistency of Interface", " 7.5.4. Software Components", " 7.5.5. Rapid Prototyping", " 7.5.6. Polymorphism and Frameworks", " 7.5.7. Information Hiding", " 7.6. The Costs of Inheritance", " 7.6.1. Execution Speed", " 7.6.2. Program Size", " 7.6.3. Message-Passing Overhead", " 7.6.4. Program Complexity", "8. A Case Study: Solitaire", " 8.1. The class Card", " 8.2. The Game", " 8.3. Card Piles - Inheritance in Action", " 8.3.1. The Suit Piles", " 8.3.2. The Deck pile", " 8.3.3. The Discard Pile", " 8.3.4. The Tableau Piles", " 8.4. Playing the Polymorphic Game", " 8.5. Building a More Complete Game", "9. Mechanisms for Software Reuse", " 9.1. Inheritance and Substitutability", " 9.1.1. The is-a rule and the has-a rule", " 9.2. Composition and Inheritance Described", " 9.2.1. Using Composition", " 9.2.2. Using Inheritance", " 9.2.3. Private Inheritance in C++", " 9.3. Composition and Inheritance Contrasted", " 9.4. When Will Widespread Software Reuse Become a Reality?", "10. Subclasses and Subtypes", " 10.1. Issues in Binding and Message Lookup", " 10.1.1. Method Binding", " 10.1.2. The Reverse Polymorphism Problem", " 10.2. Binding in Programming Languages", " 10.2.1. Binding and Message Lookup in Object Pascal", " 10.2.2. Binding and Message Lookup in Smalltalk", " 10.2.3. Binding and Message Lookup in Objective-C", " 10.2.4. Binding and Message Lookup in C++", " 10.2.5. Binding and Message Lookup in Java", " 10.3. Merits of Static versus Dynamic Binding", "11. Replacement and Refinement", " 11.1. Adding, Replacing and Refining", " 11.1.1. American and Scandinavian Semantics", " 11.2. Replacement", " 11.2.1. Replacement Versus the Principle of Substitutability", " 11.2.2. Notating Replacement", " 11.3. Replacement in Various Languages", " 11.3.1. Replacement in C++", " 11.3.2. Replacement in Object Pascal", " 11.3.3. Replacement in Smalltalk and Objective-C", " 11.3.4. Replacement in Java", " 11.4. Refinement", " 11.4.1. Refinement in Simula and Beta", " 11.4.2. Wrappers in CLOS", " 11.5. Refinement in Various Languages", " 11.5.1. Refinement in Object Pascal", " 11.5.2. Refinement in C++", " 11.5.3. Refinement in Smalltalk, Java and Objective-C", "12. Implications of Inheritance", " 12.1. Memory Layout", " 12.1.1. Minimum Static Space Allocation", " 12.1.2. Maximum Static Space Allocation", " 12.1.3. Dynamic Memory Allocation", " 12.2. Assignment", " 12.2.1. Assignment in C++", " 12.2.2. Assignment in Object Pascal and Java", " 12.2.3. Assignment in Smalltalk", " 12.2.4. Assignment in Objective-C", " 12.3. Equality", " 12.3.1. Covariance and Contravariance", " 12.3.2. Equality in Objective-C, Java and Object Pascal", " 12.3.3. Equality in Smalltalk", " 12.3.4. Equality in C++", " 12.4. Type Conversion", "13. Multiple Inheritance", " 13.1. Incomparable Complex Numbers", " 13.2. Walking Menus", " 13.3. Name Ambiguity", " 13.3.1. Inheritance from Common Ancestors", " 13.4. Multiple Inheritance in C++", " 13.5. Multiple Inheritance in Java", "14. Polymorphism", " 14.1. Polymorphism in Programming Languages", " 14.1.1. Polymorphic Functions in Dynamically Typed Languages", " 14.1.2. Low Level and High Level Abstractions", " 14.2. Varieties of Polymorphism", " 14.3. Polymorphic Variables", " 14.4. Overloading", " 14.4.1. Overloading Names in Real Life", " 14.4.2. Overloading and Coercion", " 14.4.3. Overloading Does Not Imply Similarity", " 14.4.4. Parametric Overloading", " 14.5. Overriding", " 14.5.1. Overriding in Class Magnitude", " 14.6. Deferred Methods", " 14.7. Pure Polymorphism", " 14.8. Generics and Templates", " 14.9. Polymorphism in the Various Languages", " 14.9.1. Polymorphism in C++", " 14.9.2. Polymorphism in Java", " 14.9.3. Polymorphism in Object Pascal", " 14.9.4. Polymorphism in Objective-C", " 14.9.5. Polymorphism in Smalltalk", " 14.10. Efficiency and Polymorphism", "15. A Case Study: Container Classes", " 15.1. Using Conventional Techniques", " 15.2. Containers in Dynamically Typed Languages", " 15.3. Containers in Strongly Typed Languages", " 15.4. Hiding the Cast Using Subclassing", " 15.5. Parameterized Classes", "16. A Case Study: The Standard Template Library", " 16.1. Iterators", " 16.2. Function Objects", " 16.3. Example Program - An Inventory System", " 16.4. Example Program - Graphs", " 16.5. Example Program - A Concordance", " 16.6. The Future of Object-Oriented Programming", "17. Visibility and Dependency", " 17.1. Coupling and Cohesion", " 17.1.1. Varieties of Coupling", " 17.1.2. Varieties of Cohesion", " 17.1.3. Coupling and Cohesion in Object Oriented Systems", " 17.1.4. The Law of Demeter", " 17.1.5. Class Level versus Object Level Visibility", " 17.1.6. Active Values", " 17.2. Subclass Clients and User Clients", " 17.3. Control Of Access and Visibility", " 17.3.1. Visibility in Smalltalk", " 17.3.2. Visibility in Object Pascal", " 17.3.3. Visibility in C++", " 17.3.4. Visibility in Java", " 17.3.5. Visibility in Objective-C", "18. Patterns and Frameworks", " 18.1. Software Frameworks", " 18.1.1. The Java API", " 18.1.2. A Simulation Framework", " 18.2. Design Patterns", " 18.2.1. The Intermediary Pattern", " 18.2.2. Traversal Patterns", " 18.2.3. The Double Dispatching Pattern", " 18.2.4. Classifying Design Patterns", "19. A Case Study: The Little Application Framework", " 19.1. Components of a Graphical User Interface", " 19.2. Event Driven Execution", " 19.3. Using Inheritance to Customize a Framework", " 19.4. Classes in the LAF", " 19.5. The class application", " 19.5.1. The class button", " 19.5.2. The Classes menu and menuItem", " 19.6. Summary", "20. A Second Look at Classes", " 20.1. Classes as Types", " 20.1.1. How Inheritance Complicates the View of Types", " 20.1.2. Inheritance and Storage", " 20.2. Classes as Objects", " 20.2.1. Object Creation Factories", " 20.2.2. Class Class", " 20.2.3. Subclasses and Instances", " 20.2.4. Metaclasses and Class Methods", " 20.2.5. Object Initialization", " 20.2.6. Posing in Objective-C", " 20.3. Class Data", " 20.3.1. Class Variables in Smalltalk", " 20.3.2. Class Variables in C++", " 20.3.3. Class Variables in Java", " 20.3.4. Class Variables in Objective-C", " 20.4. Are Classes Necessary?", " 20.4.1. What is Knowledge?", " 20.4.2. Delegation", "21. Implementation", " 21.1. Interpreter and Compilers", " 21.2. Compilers", " 21.2.1. The Slicing Problem", " 21.2.2. Matching Methods to Messages", " 21.2.3. Virtual Method Tables", " 21.2.4. Name Encoding", " 21.2.5. Dispatch Tables", " 21.3. Interpreters", " Further Reading ", "A. Source for Eight Queens Puzzle", " A.1. Eight Queens in Apple Object Pascal", " A.2. Eight Queens in C++", " A.3. Eight Queens in Java", " A.3.1. HTML File for Java Application", " A.4. Eight Queens in Objective-C", " A.5. Eight Queens in Smalltalk", "B. Source for Billiards Game", " B.1. The Version Without Inheritance", " B.2. Using Inheritance", "C. Source for Solitare Game", "Glossary".

Lidt om objekt-orienterede sprog og programmering. Bogen spreder sig lidt rigeligt.

Show Less

Genres

Technology

Nonfiction

Publication

Reading, MA : Addison-Wesley, 1997.

Description

This is a general introduction to object-oriented programming, written specifically for the academic market. Principles are covered in a language-independent manner and illustrated by examples from six different languages, including C++ and Java. The book covers advanced topics, including design patterns, application frameworks and the techniques used in the implementation of object-oriented languages.