Table of Contents

By CodeGuru Staff

March 1, 2001

Bruce Eckel’s Thinking in Java

Contents | Prev |
Next

Dedication
Foreword
Introduction
- Prerequisites
- Learning Java
- Goals
- Online documentation
- Chapters
- Exercises
- Multimedia CD ROM
- Source code
- - Coding standards
- Java versions
- Seminars and mentoring
- Errors
- Note on the cover design
- Acknowledgements
1: Introduction to objects
- The progress of abstraction
- An object has an interface
- The hidden implementation
- Reusing the implementation
- Inheritance: reusing the interface
- - Overriding base-class functionality
  - Is-a vs. is-like-a relationships
- Interchangeable objects with polymorphism
- - Dynamic binding
  - Abstract base classes and interfaces
- Object landscapes and lifetimes
- Exception handling: dealing with errors
- Multithreading
- Persistence
- Java and the Internet
- Analysis and Design
- Java vs. C++?
2: Everything is an object
- You manipulate objects with handles
- You must create all the objects
- You never need to destroy an object
- - Scoping
  - Scope of objects
- Creating new data types: class
- - Fields and methods
  - - Default values for primitive members
- Methods, arguments and return values
- - The argument list
- Building a Java program
- Your first Java program
- Comments and embedded documentation
- Coding style
- Summary
- Exercises
3: Controlling program flow
- Using Java operators
- Execution control
- Summary
- Exercises
4: Initialization and cleanup
- Guaranteed initialization with the constructor
- Method overloading
- Cleanup: finalization and garbage collection
- - What is finalize( ) for?
  - You must perform cleanup
- Member initialization
- Array initialization
- - Multidimensional arrays
- Summary
- Exercises
5: Hiding the implementation
- package: the library unit
- Java access specifiers
- Interface and implementation
- Class access
- Summary
- Exercises
6: Reusing classes
- Composition syntax
- Inheritance syntax
- - Initializing the base class
  - - Constructors with arguments
    - Catching base constructor exceptions
- Combining composition and inheritance
- Choosing composition vs. inheritance
- protected
- Incremental development
- Upcasting
- - Why “upcasting”?
  - - Composition vs. inheritance revisited
- The final keyword
- Initialization and class loading
- - Initialization with inheritance
- Summary
- Exercises
7: Polymorphism
- Upcasting
- - Why upcast?
- The twist
- Overriding vs. overloading
- Abstract classes and methods
- Interfaces
- Inner classes
- Constructors and polymorphism
- Designing with inheritance
- - Pure inheritance vs. extension
  - Downcasting and run-time type identification
- Summary
- Exercises
8: Holding your objects
- Arrays
- Collections
- - Disadvantage: unknown type
- Enumerators (iterators)
- Types of collections
- Sorting
- The generic collection library
- The new collections
- Summary
- Exercises
9: Error handling with exceptions
- Basic exceptions
- - Exception arguments
- Catching an exception
- Standard Java exceptions
- - The special case of RuntimeException
- Creating your own exceptions
- Exception restrictions
- Performing cleanup with finally
- - What’s finally for?
  - Pitfall: the lost exception
- Constructors
- Exception matching
- - Exception guidelines
- Summary
- Exercises
10: The Java IO system
- Input and output
- - Types of InputStream
  - Types of OutputStream
- Adding attributes and useful interfaces
- - Reading from an InputStream with FilterInputStream
  - Writing to an OutputStream with FilterOutputStream
- Off by itself: RandomAccessFile
- The File class
- Typical uses of IO streams
- StreamTokenizer
- - StringTokenizer
- Java 1.1 IO streams
- Compression
- Object serialization
- Summary
- Exercises
11: Run-time type identification
- The need for RTTI
- RTTI syntax
- Reflection: run-time class information
- - A class method extractor
- Summary
- Exercises
12: Passing and returning objects
- Passing handles around
- - Aliasing
- Making local copies
- Controlling cloneability
- - The copy-constructor
  - - Why does it work in C++ and not Java?
- Read-only classes
- Summary
- Exercises
13: Creating windows and applets
- Why use the AWT?
- The basic applet
- - Testing applets
  - A more graphical example
  - Demonstrating the framework methods
- Making a button
- Capturing an event
- Text fields
- Text areas
- Labels
- Check boxes
- Radio buttons
- Drop-down lists
- List boxes
- - handleEvent( )
- Controlling layout
- - FlowLayout
  - BorderLayout
  - GridLayout
  - CardLayout
  - - Combining layouts
  - GridBagLayout
- Alternatives to action
- Applet restrictions
- - Applet advantages
- Windowed applications
- - Menus
  - Dialog boxes
  - - File dialogs
- The new AWT
- - The new event model
  - Event and listener types
  - - Using listener adapters for simplicity
  - Making windows and applets with the Java 1.1 AWT
  - - Making the window listener an anonymous class
    - Packaging the applet into a JAR file
  - Revisiting the earlier examples
  - Binding events dynamically
  - Separating business logic from UI logic
  - Recommended coding approaches
- Java 1.1 UI APIs
- - Desktop colors
  - Printing
  - The clipboard
- Visual programming and Beans
- - What is a Bean?
  - Extracting BeanInfo with the Introspector
  - A more sophisticated Bean
  - Packaging a Bean
  - More complex Bean support
  - More to Beans
- Introduction to Swing
- - Benefits of Swing
  - Easy conversion
  - A display framework
  - Tool tips
  - Borders
  - Buttons
  - Button groups
  - Icons
  - Menus
  - Popup menus
  - List boxes and combo boxes
  - Sliders and progress bars
  - Trees
  - Tables
  - Tabbed Panes
  - The Swing message box
  - More to Swing
- Summary
- Exercises
14: Multiple threads
- Responsive user interfaces
- Sharing limited resources
- Blocking
- Priorities
- - Thread groups
  - - Controlling thread groups
- Runnable revisited
- - Too many threads
- Summary
- Exercises
15: Network programming
- Identifying a machine
- Sockets
- - A simple server and client
- Serving multiple clients
- Datagrams
- A Web application
- Connecting Java to CGI
- Connecting to databases with JDBC
- Remote methods
- Summary
- Exercises
16: Design patterns
- The pattern concept
- - The singleton
  - Classifying patterns
- The observer pattern
- Simulating the trash recycler
- Improving the design
- Abstracting usage
- Multiple dispatching
- - Implementing the double dispatch
- The “visitor” pattern
- - More coupling?
- RTTI considered harmful?
- Summary
- Exercises
17: Projects
- Text processing
- A method lookup tool
- Complexity theory
- Summary
- Exercises
A: Using non-Java code
- The Java Native Interface
- The Microsoft way
- J/Direct
- Raw Native Interface (RNI)
- - RNI Summary
- Java/COM integration
- CORBA
- Summary
B: Comparing C++ and Java
C: Java programming guidelines
D: Performance
- Basic approach
- Locating the bottleneck
- Speedup techniques
- References
E: A bit about garbage collection
F: Recommended reading
Index

Contents | Prev |
Next

More by Author

Previous article

F: Recommended reading

Next article

Visual Studio Tags Support

News & Trends

Must Read