Mind Mind Mind Point to Share Knowlege  
 
   
  Add New Map Add New Map About us About us Help Help Contact us Contact us  

Thinking in java

please flag with care:
best of
error
spam
 
2007-11-12No history Add My version 
download mind map 119406294.cdmm (mindmap file created by  ConceptDraw MINDMAP)

  
Thinking in java 
 
outline 
Thinking in java
  Preface
  Introduction
  1: Introduction to Objects
  2: Everything is an Object
  3: Controlling Program Flow
  4: Initialization & Cleanup
  5: Hiding the Implementation
  6: Reusing Classes
  7: Polymorphism
  8: Interfaces & Inner Classes
  9: Error Handling with Exceptions
  10: Detecting Types
  11: Collections of Objects
  12: The Java I/O System
  13: Concurrency
  14: Creating Windows & Applets
  15: Discovering Problems
  16: Analysis and Design
  A: Passing & Returning Objects
  B: Java Programming Guidelines
  C: Supplements
  D: Resources
 
 Preface
  Preface to the 3rd edition
  Java 2, JDK 1.4
 
 Introduction
  Prerequisites
  Learning Java
  Goals
  JDK HTML documentation
  Chapters
  Exercises
  The CD ROM
  Source code
  Coding standards
  Java versions
  Errors
  Note on the cover design
  Acknowledgements
 
 1: Introduction to Objects
  The progress of abstraction
  An object has an interface
  An object provides services
  The hidden implementation
  Reusing the implementation
  Inheritance: reusing the interface
  Is-a vs. is-like-a relationships
  Interchangeable objects with polymorphism
  Abstract base classes and interfaces
  Object creation, use & lifetimes
  Exception handling: dealing with errors
  Concurrency
  Persistence
  Java and the Internet
  Why Java succeeds
  Java vs. C++?
  Summary
 
 2: Everything is an Object
  Exercises
  You manipulate objects with references
  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
  Compiling and running
  Comments and embedded documentation
  Coding style
  Summary
 
 3: Controlling Program Flow
  Using Java operators
  Execution control
  Summary
  Exercises
 
 4: Initialization & Cleanup
  Guaranteed initialization with the constructor
  Method overloading
  Cleanup: finalization and garbage collection
  Member initialization
  Array initialization
  Multidimensional arrays
  Summary
  Exercises
 
 5: Hiding the Implementation
  package: the library unit
  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
  Guaranteeing proper cleanup
  Name hiding
  Choosing composition vs. inheritance
  protected
  Incremental development
  Upcasting
  Why “upcasting”?
  Composition vs. inheritance revisited
  The final keyword
  Final data
  Blank finals
  Final arguments
  Final methods
  final and private
  Final classes
  Final caution
  Initialization and class loading
  Initialization with inheritance
  Summary
  Exercises
 
 7: Polymorphism
  Upcasting revisited
  Forgetting the object type
  The twist
  Abstract classes and methods
  Constructors and polymorphism
  Designing with inheritance
  Pure inheritance vs. extension
  Downcasting and run-time type identification
  Summary
  Exercises
 
 8: Interfaces & Inner Classes
  Interfaces
  Inner classes
  Why inner classes?
  Closures & Callbacks
  Inner classes & control frameworks
  Summary
  Exercises
 
 9: Error Handling with Exceptions
  Basic exceptions
  Exception arguments
  Catching an exception
  The try block
  Exception handlers
  Termination vs. resumption
  Creating your own exceptions
  The exception specification
  Catching any exception
  Rethrowing an exception
  Exception chaining
  Standard Java exceptions
  The special case of RuntimeException
  Performing cleanup with finally
  What’s finally for?
  Pitfall: the lost exception
  Exception restrictions
  Constructors
  Exception matching
  Alternative approaches
  Exception guidelines
  Summary
  Exercises
 
 10: Detecting Types
  The need for RTTI
  RTTI syntax
  Reflection: run time class information
  A class method extractor
  Summary
  Exercises
 
 11: Collections of Objects
  Arrays
  Introduction to containers
  Printing containers
  Filling containers
  Container disadvantage: unknown type
  Sometimes it works anyway
  Making a type-conscious ArrayList
  Parameterized types
  Iterators
  Unintended recursion
  Container taxonomy
  Collection functionality
  List functionality
  Making a stack from a LinkedList
  Making a queue from a LinkedList
  Set functionality
  SortedSet
  Map functionality
  Holding references
  The WeakHashMap
  Iterators revisited
  Choosing an implementation
  Choosing between Lists
  Choosing between Sets
  Choosing between Maps
  Sorting and searching Lists
  Utilities
  Making a Collection or Map unmodifiable
  Synchronizing a Collection or Map
  Fail fast
  Unsupported operations
  Java 1.0/1.1 containers
  Summary
  Exercises
 
 12: The Java I/O System
  The File class
  A directory lister
  Anonymous inner classes
  Checking for and creating directories
  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
  Readers & Writers
  Sources and sinks of data
  Modifying stream behavior
  Unchanged Classes
  Off by itself: RandomAccessFile
  Typical uses of I/O streams
  File reading & writing utilities
  Standard I/O
  Reading from standard input
  Changing System.out to a PrintWriter
  Redirecting standard I/O
  New I/O
  Compression
  Simple compression with GZIP
  Multifile storage with Zip
  Java ARchives (JARs)
  Object serialization
  Preferences
  Regular expressions
  Summary
  Exercises
 
 13: Concurrency
  Motivation
  Basic threads
  Sharing limited resources
  Thread states
  Becoming blocked
  Cooperation between threads
  Wait and notify
  Using Pipes for I/O between threads
  More sophisticated cooperation
  Deadlock
  The proper way to stop
  Interrupting a blocked thread
  Thread groups
  Summary
  Exercises
 
 14: Creating Windows & Applets
  The basic applet
  Running applets from the command line
  A display framework
  Making a button
  Capturing an event
  Text areas
  Controlling layout
  The Swing event model
  Event and listener types
  Using listener adapters for simplicity
  Tracking multiple events
  A catalog of Swing components
  Packaging an applet into a JAR file
  Signing applets
  JNLP and Java Web Start
  Programming techniques
  Binding events dynamically
  Separating business logic from UI logic
  A canonical form
  Concurrency & Swing
  Runnable revisited
  Managing concurrency
  Visual programming and JavaBeans
  Summary
  Exercises
 
 15: Discovering Problems
  Unit Testing
  A Simple Testing Framework
  JUnit
  Improving reliability with assertions
  Assertion syntax
  Using Assertions for Design by Contract
  Check instructions
  Preconditions
  Postconditions
  Invariants
  Relaxing DBC
  Example: DBC + white-box unit testing
  Building with Ant
  Automate everything
  Problems with make
  Ant: the defacto standard
  Ant extensions
  Version control with CVS
  Daily builds
  Logging
  Logging Levels
  LogRecords
  Handlers
  Multiple Handlers
  Writing your own Handlers
  Filters
  Formatters
  Example: Sending email to report log messages
  Controlling Logging Levels through Namespaces
  Logging Practices for Large Projects
  Configuration files
  Rotating log files
  Suggested practices
  Summary
  Debugging
  Debugging with JDB
  Graphical debuggers
  Profiling and optimizing
  Tracking memory consumption
  Tracking CPU usage
  Coverage testing
  JVM Profiling Interface
  Using HPROF
  Thread performance
  Optimization guidelines
  Doclets
  Summary
  Exercises
 
 16: Analysis and Design
  Methodology
  Phase 0: Make a plan
  The mission statement
  Phase 1: What are we making?
  Phase 2: How will we build it?
  Five stages of object design
  Guidelines for object development
  Phase 3: Build the core
  Phase 4: Iterate the use cases
  Phase 5: Evolution
  Plans pay off
  Extreme Programming
  Write tests first
  Pair programming
  Strategies for transition
  Guidelines
  1. Training
  2. Low-risk project
  3. Model from success
  4. Use existing class libraries
  5. Don’t rewrite existing code in Java
  Management obstacles
  Startup costs
  Performance issues
  Common design errors
  Summary
 
 A: Passing & Returning Objects
  Passing references around
  Aliasing
  Making local copies
  Pass by value
  Cloning objects
  Adding cloneability to a class
  Using a trick with protected
  Implementing the Cloneable interface
  Successful cloning
  The effect of Object.clone( )
  Cloning a composed object
  A deep copy with ArrayList
  Deep copy via serialization
  Adding cloneability farther down a hierarchy
  Why this strange design?
  Controlling cloneability
  The copy constructor
  Why does it work in C++ and not Java?
  Read-only classes
  Creating read-only classes
  The drawback to immutability
  Immutable Strings
  Implicit constants
  Overloading ‘+’ and the StringBuffer
  The String and StringBuffer classes
  Strings are special
  Summary
  Exercises
 
 B: Java Programming Guidelines
  Design
  Implementation
 
 C: Supplements
  Foundations for Java seminar-on-CD
  Thinking in Java seminar
  Hands-On Java seminar-on-CD 3rd edition
  Designing Objects & Systems seminar
  Thinking in Enterprise Java
  The J2EE seminar
  Thinking in Patterns (with Java)
  Thinking in Patterns seminar
  Design consulting and reviews
 
 D: Resources
  Software
  Books
  Analysis & design
  Python
  My own list of books
 
 Why Java succeeds
  Systems are easier to express and understand
  Maximal leverage with libraries
  Error handling
  Programming in the large
 
 Java and the Internet
  What is the Web?
  Client/Server computing
  The Web as a giant server
  Client-side programming
  Plug-ins
  Scripting languages
  Java
  .NET and C#
  Security
  Internet vs. intranet
  Server-side programming
  Applications
 
 Object creation, use & lifetimes
  Collections and iterators
  The singly rooted hierarchy
  Downcasting vs. templates/generics
  Ensuring proper cleanup
  Garbage collectors vs. efficiency and flexibility
 
 Comments and embedded documentation
  Comment documentation
  Syntax
  Embedded HTML
  Some example tags
  @see: referring to other classes
  {@link package.class#member label}
  {@docRoot}
  {@inheritDoc}
  @version
  @author
  @since
  @param
  @return
  @throws
  @deprecated
  Documentation example
 
 Building a Java program
  Name visibility
  Using other components
  The static keyword
 
 You must create all the objects
  Where storage lives
  Special case: primitive types
  High-precision numbers
  Arrays in Java
 
 Using Java operators
  Precedence
  Assignment
  Aliasing during method calls
  Mathematical operators
  Regular expressions
  Unary minus and plus operators
  Auto increment and decrement
  Relational operators
  Testing object equivalence
  Logical operators
  Short-circuiting
  Bitwise operators
  Shift operators
  Ternary if-else operator
  The comma operator
  String operator +
  Common pitfalls when using operators
  Casting operators
  Literals
  Promotion
  Java has no “sizeof”
  Precedence revisited
  A compendium of operators
 
 Execution control
  true and false
  if-else
  return
  Iteration
  do-while
  for
  The comma operator
  break and continue
  The infamous “goto”
  switch
  Calculation details
 
 Method overloading
  Distinguishing overloaded methods
  Overloading with primitives
  Overloading on return values
  Default constructors
  The this keyword
  Calling constructors from constructors
  The meaning of static
 
 Cleanup: finalization and garbage collection
  What is finalize( ) for?
  You must perform cleanup
  The termination condition
  How a garbage collector works
 
 package: the library unit
  Creating unique package names
  Collisions
  A custom tool library
  Using imports to change behavior
  Package caveat
  Java access specifiers
  Package access
  public: interface access
  The default package
  private: you can’t touch that!
  protected: inheritance access
 
 Member initialization
  Specifying initialization
  Constructor initialization
  Order of initialization
  Static data initialization
  Explicitstaticinitialization
  Non-static instance initialization
 
 The twist
  Method-call binding
  Producing the right behavior
  Extensibility
  Pitfall: “overriding” private methods
 
 Constructors and polymorphism
  Order of constructor calls
  Inheritance and cleanup
  Behavior of polymorphic methods inside constructors
 
 Interfaces
  “Multiple inheritance” in Java
  Name collisions when combining interfaces
  Extending an interface with inheritance
  Grouping constants
  Initializing fields in interfaces
  Nesting interfaces
 
 Inner classes
  Inner classes and upcasting
  Inner classes in methods and scopes
  Anonymous inner classes
  The link to the outer class
  Nested classes
  Referring to the outer class object
  Reaching outward from a multiply-nested class
  Inheriting from inner classes
  Can inner classes be overridden?
  Local inner classes
  Inner class identifiers
 
 Alternative approaches
  History
  Perspectives
  Passing exceptions to the console
  Converting checked to unchecked exceptions
 
 The need for RTTI
  The Class object
  Class literals
  Checking before a cast
  Using class literals
  A dynamic instanceof
  instanceof vs. Class equivalence
 
 Arrays
  Arrays are first-class objects
  Containers of primitives
  Returning an array
  The Arrays class
  Filling an array
  Copying an array
  Comparing arrays
  Array element comparisons
  Sorting an array
  Searching a sorted array
  Array summary
 
 Map functionality
  SortedMap
  LinkedHashMap
  Hashing and hash codes
  Understanding hashCode( )
  HashMap performance factors
  Overriding hashCode( )
 
 Java 1.0/1.1 containers
  Vector & Enumeration
  Hashtable
  Stack
  BitSet
 
 Regular expressions
  Creating regular expressions
  Quantifiers
  CharSequence
  Pattern and Matcher
  find( )
  Groups
  start( ) and end( )
  Pattern flags
  split( )
  Replace operations
  reset( )
  Regular expressions and Java I/O
  Is StringTokenizer needed?
 
 Object serialization
  Finding the class
  Controlling serialization
  The transient keyword
  An alternative to Externalizable
  Versioning
  Using persistence
 
 New I/O
  Converting data
  Fetching primitives
  View buffers
  Endians
  Data manipulation with buffers
  Buffer details
  Memory-mapped files
  Performance
  File locking
  Locking portions of a mapped file
 
 Typical uses of I/O streams
  Input streams
  1. Buffered input file
  2. Input from memory
  3. Formatted memory input
  4. File output
  Output streams
  5. Storing and recovering data
  6. Reading and writing random access files
  Piped streams
 
 Basic threads
  Yielding
  Sleeping
  Priority
  Daemon threads
  Joining a thread
  Coding variations
  Creating responsive user interfaces
 
 Sharing limited resources
  Improperly accessing resources
  A resource testing framework
  Colliding over resources
  Resolving shared resource contention
  Synchronizing the EvenGenerator
  Atomic operations
  Fixing Semaphore
  Critical sections
 
 The basic applet
  Applet restrictions
  Applet advantages
  Application frameworks
  Running applets inside a Web browser
  Using Appletviewer
  Testing applets
 
 GridBagLayout
 
 Controlling layout
  BorderLayout
  FlowLayout
  GridLayout
  GridBagLayout
  Absolute positioning
  BoxLayout
  The best approach?
 
 A catalog of Swing components
  Buttons
  Button groups
  Icons
  Tool tips
  Text fields
  Borders
  JScrollPanes
  A mini-editor
  Check boxes
  Radio buttons
  Combo boxes (drop-down lists)
  List boxes
  Tabbed panes
  Message boxes
  Menus
  Pop-up menus
  Drawing
  Dialog Boxes
  File dialogs
  HTML on Swing components
  Sliders and progress bars
  Trees
  Tables
  Selecting Look & Feel
  The clipboard
 
 JavaBeans and synchronization
 
 Visual programming and JavaBeans
  What is a JavaBean?
  Extracting BeanInfo with the Introspector
  A more sophisticated Bean
  JavaBeans and synchronization
  Packaging a Bean
  More complex Bean support
  More to Beans