Understanding object-oriented programming with Java - Info and Reading Options

"Understanding object-oriented programming with Java" Table Of Contents:

• 1- Preface
• 2- Understanding the Object-Oriented Worldview
• 3- Object-Oriented Thinking
• 4- A Way of Viewing the World
• 5- Agents and Communities
• 6- Messages and Methods
• 7- Responsibilities
• 8- Classes and Instances
• 9- Class Hierarchies: Inheritance
• 10- Method Binding, Overriding, and Exceptions
• 11- Summary of Object-Oriented Concepts
• 12- Computation as Simulation
• 13- The Power of Metaphor
• 14- Chapter Summary
• 15- Further Reading
• 16- Study Questions
• 17- Exercises
• 18- A Brief History of Object-Oriented Programming
• 19- The History of Java
• 20- Client-Side Computing
• 21- Bytecode Interpreters and Just-In-Time Compilers
• 22- Security Issues
• 23- Specialization of Interfaces
• 24- The White Paper Description
• 25- Java Is Simple
• 26- Java Is Object-Oriented
• 27- Java Is Network Savvy
• 28- Java Is Interpreted
• 29- Java Is Robust
• 30- Java Is Secure
• 31- Java Is Architecture Neutral
• 32- Java Is Portable
• 33- Java Is High-Performance
• 34- Java Is Multithreaded
• 35- Java Is Dynamic
• 36- Chapter Summary
• 37- Study Questions
• 38- Exercises
• 39- Object-Oriented Design
• 40- Responsibility Implies Noninterference
• 41- Programming in the Small and in the Large
• 42- Why Begin with Behavior?
• 43- A Case Study in RDD
• 44- The Interactive Intelligent Kitchen Helper
• 45- Working With Components
• 46- Identification of Components
• 47- CRC Cards—Recording Responsibility
• 48- Giving Components a Physical Representation
• 49- The What/Who Cycle
• 50- Documentation
• 51- Components and Behavior
• 52- Postponing Decisions
• 53- Preparing for Change
• 54- Continuing the Scenario
• 55- Interaction Diagrams
• 56- Software Components
• 57- Behavior and State
• 58- Instances and Classes
• 59- Coupling and Cohesion
• 60- Interface and Implementation: Parnas's Principles
• 61- Formalizing the Interface
• 62- Coming Up with Names
• 63- Designing the Representation
• 64- Implementing Components
• 65- Integration of Components
• 66- Maintenance and Evolution
• 67- Chapter Summary
• 68- Study Questions
• 69- Exercises
• 70- Understanding Paradigms
• 71- A Paradigm
• 72- Program Structure
• 73- The Connection to the Java World
• 74- Types
• 75- Access Modifiers
• 76- Lifetime Modifiers
• 77- Chapter Summary
• 78- Cross References
• 79- Study Questions
• 80- Exercises
• 81- Ball Worlds
• 82- Data Fields
• 83- Constructors
• 84- Constructing the Application
• 85- Inheritance
• 86- The Java Graphics Model
• 87- The Class Ball
• 88- Multiple Objects of the Same Class
• 89- Chapter Summary
• 90- Cross References
• 91- Study Questions
• 92- Exercises
• 93- A Cannon Game
• 94- The Simple Cannon Game
• 95- Balls That Respond to Gravity
• 96- Integers and ints
• 97- Adding User Interaction
• 98- Inner Classes
• 99- Interfaces
• 100- The Java Event Model
• 101- Window Layout
• 102- Chapter Summary
• 103- Cross References
• 104- Study Questions
• 105- Exercises
• 106- Pinball Game Construction Kit
• 107- First Version of Game
• 108- Collection Classes
• 109- Mouse Listeners
• 110- Multiple Threads of Execution
• 111- Exception Handling
• 112- Adding Targets: Inheritance and Interfaces
• 113- The Pinball Target Interface
• 114- Adding a Label to Our Pinball Game
• 115- Pinball Game Construction Kit: Mouse Events Reconsidered
• 116- Chapter Summary
• 117- Cross References
• 118- Study Questions
• 119- Exercises
• 120- Understanding Inheritance
• 121- Understanding Inheritance
• 122- An Intuitive Description of Inheritance
• 123- The Base Class Object
• 124- Subclass, Subtype, and Substitutability
• 125- Forms of Inheritance
• 126- Inheritance for Specialization
• 127- Inheritance for Specification
• 128- Inheritance for Construction
• 129- Inheritance for Extension
• 130- Inheritance for Limitation
• 131- Inheritance for Combination
• 132- Summary of the Forms of Inheritance
• 133- Modifiers and Inheritance
• 134- Programming as a Multiperson Activity
• 135- The Benefits of Inheritance
• 136- Software Reusability
• 137- Increased Reliability
• 138- Code Sharing
• 139- Consistency of Interface
• 140- Software Components
• 141- Rapid Prototyping
• 142- Polymorphism and Frameworks
• 143- Information Hiding
• 144- The Costs of Inheritance
• 145- Execution Speed
• 146- Program Size
• 147- Message-Passing Overhead
• 148- Program Complexity
• 149- Chapter Summary
• 150- Study Questions
• 151- Exercises
• 152- A Case Study: Solitaire
• 153- The Class Card
• 154- The Game
• 155- Card Piles—Inheritance in Action
• 156- The Suit Piles
• 157- The Deck Pile
• 158- The Discard Pile
• 159- The Tableau Piles
• 160- The Application Class
• 161- Playing the Polymorphic Game
• 162- Building a More Complete Game
• 163- Chapter Summary
• 164- Study Questions
• 165- Exercises
• 166- Mechanisms for Software Reuse
• 167- Substitutability
• 168- The Is-a Rule and the Has-a Rule
• 169- Inheritance of Code and Inheritance of Behavior
• 170- Composition and Inheritance Described
• 171- Using Composition
• 172- Using Inheritance
• 173- Composition and Inheritance Contrasted
• 174- Combining Inheritance and Composition
• 175- Novel Forms of Software Reuse
• 176- Dynamic Composition
• 177- Inheritance of Inner Classes
• 178- Unnamed Classes
• 179- Chapter Summary
• 180- Study Questions
• 181- Exercises
• 182- Implications of Inheritance
• 183- The Polymorphic Variable
• 184- Memory Layout
• 185- An Alternative Technique
• 186- Assignment
• 187- Clones
• 188- Parameters as a Form of Assignment
• 189- Equality Test
• 190- Garbage Collection
• 191- Chapter Summary
• 192- Study Questions
• 193- Exercises
• 194- Understanding Polymorphism
• 195- Polymorphism
• 196- Varieties of Polymorphism
• 197- Polymorphic Variables
• 198- Overloading
• 199- Overloading Messages in Real Life
• 200- Overloading and Coercion
• 201- Overloading from Separate Classes
• 202- Parametric Overloading
• 203- Overriding
• 204- Replacement and Refinement
• 205- Abstract Methods
• 206- Pure Polymorphism
• 207- Efficiency and Polymorphism
• 208- Chapter Summary
• 209- Further Reading
• 210- Study Questions
• 211- Exercises
• 212- The AWT
• 213- The AWT Class Hierarchy
• 214- The Layout Manager
• 215- Layout Manager Types
• 216- User Interface Components
• 217- Labels
• 218- Button
• 219- Canvas
• 220- Scroll Bars
• 221- Text Components
• 222- Checkbox
• 223- Checkbox Groups, Choices, and Lists
• 224- Panels
• 225- ScrollPane
• 226- Case Study: A Color Display
• 227- Dialogs
• 228- Example Program for Dialogs
• 229- The Menu Bar
• 230- A Quit Menu Facility
• 231- Chapter Summary
• 232- Study Questions
• 233- Exercises
• 234- Input and Output Streams
• 235- Streams versus Readers and Writers
• 236- Input Streams
• 237- Physical Input Streams
• 238- Virtual Input Streams
• 239- Stream Tokenizer
• 240- Output Streams
• 241- Object Serialization
• 242- Piped Input and Output
• 243- Readers and Writers
• 244- Chapter Summary
• 245- Study Questions
• 246- Exercises
• 247- Design Patterns
• 248- Adapter
• 249- Composite
• 250- Strategy
• 251- Observer
• 252- Flyweight
• 253- Abstract Factory
• 254- Factory Method
• 255- Iterator
• 256- Decorator (Filter or Wrapper)
• 257- Proxy
• 258- Bridge
• 259- Chapter Summary
• 260- Further Reading
• 261- Study Questions
• 262- Exercise
• 263- Understanding the Java World
• 264- Exception Handling
• 265- Information Transmitted to the Catch Block
• 266- Catching Multiple Errors
• 267- The Finally Clause
• 268- Termination or Resumptive Models
• 269- Exceptions Thrown in the Standard Library
• 270- Throwing Exceptions
• 271- Passing On Exceptions
• 272- Chapter Summary
• 273- Study Questions
• 274- Exercises
• 275- Utility Classes
• 276- Point
• 277- Dimension
• 278- Date
• 279- After the Epoch
• 280- Math
• 281- Random
• 282- Toolkit
• 283- System
• 284- Strings and Related Classes
• 285- Operations on Strings
• 286- String Buffers
• 287- String Tokenizers
• 288- Parsing String Values
• 289- Chapter Summary
• 290- Study Questions
• 291- Understanding Graphics
• 292- Color
• 293- Rectangles
• 294- Rectangle Sample Program
• 295- Fonts
• 296- Font Metrics
• 297- Font Example Program
• 298- Images
• 299- Animation
• 300- Graphics Contexts
• 301- A Simple Painting Program
• 302- Chapter Summary
• 303- Study Questions
• 304- Exercises
• 305- Collection Classes
• 306- Element Types and Primitive Value Wrappers
• 307- Enumerators
• 308- The Array
• 309- The Vector Collection
• 310- Using a Vector as an Array
• 311- Using a Vector as a Stack
• 312- Using a Vector as a Queue
• 313- Using a Vector as a Set
• 314- Using a Vector as a List
• 315- The Stack Collection
• 316- The BitSet Collection
• 317- Example Program: Prime Sieve
• 318- The Dictionary Interface and the Hashtable Collection
• 319- Example Program: A Concordance
• 320- Properties
• 321- Why Are There No Ordered Collections?
• 322- Building Your Own Containers
• 323- Chapter Summary
• 324- Study Questions
• 325- Exercises
• 326- Multiple Threads of Execution
• 327- Creating Threads
• 328- Synchronizing Threads
• 329- Case Study: A Tetris Game
• 330- The Tetris Game Class
• 331- The PieceMover Thread
• 332- The Game Piece Class
• 333- Chapter Summary
• 334- Cross References
• 335- Study Questions
• 336- Exercises
• 337- Applets and Web Programming
• 338- Applets and HTML
• 339- Security Issues
• 340- Applets and Applications
• 341- Obtaining Resources Using an Applet
• 342- Universal Resource Locators
• 343- Loading a New Web Page
• 344- Combining Applications and Applets
• 345- Chapter Summary
• 346- Study Questions
• 347- Exercises
• 348- Network Programming
• 349- Addresses, Ports, and Sockets
• 350- A Simple Client/Server Program
• 351- Multiple Clients
• 352- Transmitting Objects over a Network
• 353- Providing More Complexity
• 354- Chapter Summary
• 355- Study Questions
• 356- Exercises
• 357- What's New in 1.2
• 358- Collection Classes
• 359- Swing User Interface Components
• 360- Improvements to the Graphics Library
• 361- Internationalization
• 362- Java Beans
• 363- Sound
• 364- Databases
• 365- Remote Method Invocation
• 366- Servlets
• 367- Chapter Summary
• 368- Further Reading
• 369- Java Syntax
• 370- Program Structure
• 371- Import Declaration
• 372- Class Declaration
• 373- Interface Declaration
• 374- Method Declaration
• 375- Constructors
• 376- Data Field Declaration
• 377- Statements
• 378- Declaration Statement
• 379- Assignment Statement
• 380- Procedure Calls
• 381- If Statement
• 382- Switch Statement
• 383- While Statement
• 384- For Statement
• 385- Return Statement
• 386- Throw Statement
• 387- Try Statement
• 388- Expressions
• 389- Literal
• 390- Variable
• 391- Data Field and Method Access
• 392- Operators
• 393- Object Creation
• 394- Arrays
• 395- Packages in the Java API
• 396- Glossary
• 397- Bibliography
• 398- Index

Read “Understanding object-oriented programming with Java”:

Read “Understanding object-oriented programming with Java” by choosing from the options below.