James Thornton

Web jamesthornton.com

Internet Business Consultant

Home	Blog	Bio	Projects	Contact	Latest Blog (new site): How to Get to Genius

Thinking in Java, 3rd ed. Revision 4.0 [ Viewing Hints ] [ Book Home Page ] [ Free Newsletter ] [ Seminars ] [ Seminars on CD ROM ] [ Consulting ] Thinking in Java, 3rd ed. Revision 4.0 - Contents Thinking in Java, 3rd ed. Revision 4.0 - Title Page Bruce Eckel’s Hands-On Java Seminar Multimedia CD: 3rd Edition follows this book It’s like coming to the seminar! Available at www.BruceEckel.com 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 Collections and iterators The singly rooted hierarchy Downcasting vs. templates/generics Ensuring proper cleanup Garbage collectors vs. efficiency and flexibility Exception handling: dealing with errors Concurrency Persistence 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 Why Java succeeds Systems are easier to express and understand Maximal leverage with libraries Error handling Programming in the large Java vs. C++? Summary 2: Everything is an Object You manipulate objects with references You must create all the objects Where storage lives Special case: primitive types High-precision numbers Arrays in Java 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 Name visibility Using other components The static keyword Your first Java program Compiling and running 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 Coding style Summary Exercises 3: Controlling Program Flow 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 Summary Exercises 4: Initialization & Cleanup Guaranteed initialization with the constructor 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 Member initialization Specifying initialization Constructor initialization Order of initialization Static data initialization Explicit static initialization Non-static instance initialization Array initialization Multidimensional arrays Summary Exercises 5: Hiding the Implementation 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 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 Method-call binding Producing the right behavior Extensibility Pitfall: “overriding” private methods Abstract classes and methods Constructors and polymorphism Order of constructor calls Inheritance and cleanup Behavior of polymorphic methods inside constructors Designing with inheritance Pure inheritance vs. extension Downcasting and run-time type identification Summary Exercises 8: Interfaces & Inner Classes 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 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 History Perspectives Passing exceptions to the console Converting checked to unchecked exceptions Exception guidelines Summary Exercises 10: Detecting Types The need for RTTI The Class object Class literals Checking before a cast Using class literals A dynamic instanceof instanceof vs. Class equivalence RTTI syntax Reflection: run time class information A class method extractor Summary Exercises 11: Collections of Objects 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 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 SortedMap LinkedHashMap Hashing and hash codes Understanding hashCode( ) HashMap performance factors Overriding hashCode( ) 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 Vector & Enumeration Hashtable Stack BitSet 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 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 File reading & writing utilities Standard I/O Reading from standard input Changing System.out to a PrintWriter Redirecting standard I/O 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 Compression Simple compression with GZIP Multifile storage with Zip Java ARchives (JARs) Object serialization Finding the class Controlling serialization The transient keyword An alternative to Externalizable Versioning Using persistence Preferences 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? Summary Exercises 13: Concurrency Motivation 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 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 Applet restrictions Applet advantages Application frameworks Running applets inside a Web browser Using Appletviewer Testing applets Running applets from the command line A display framework Making a button Capturing an event Text areas Controlling layout BorderLayout FlowLayout GridLayout GridBagLayout Absolute positioning BoxLayout The best approach? The Swing event model Event and listener types Using listener adapters for simplicity Tracking multiple events 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 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 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 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 Index Bruce Eckel’s Hands-On Java Seminar Multimedia CD: 3rd Edition follows this book It’s like coming to the seminar! Available at www.BruceEckel.com

---

James Thornton,<jamesjamesthornton.com> Services: Online Marketing Companies

Electric Speed: Software Programming