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, 2nd ed. Revision 12 - Contents Thinking in Java, 2nd ed. Revision 12 - Title Page Preface Preface to the 2nd edition Java 2 The CD ROM 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 Internet contributors 1: Introduction to Objects The progress of abstraction An object has an interface 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 landscapes and lifetimes Collections and iterators The singly rooted hierarchy Collection libraries and support for easy collection use Downcasting vs. templates/generics The housekeeping dilemma: who should clean up? Garbage collectors vs. efficiency and flexibility Exception handling: dealing with errors Multithreading 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 ActiveX Security Internet vs. intranet Server-side programming A separate arena: applications Analysis and design 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 Why Java succeeds Systems are easier to express and understand Maximal leverage with libraries Error handling Programming in the large 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 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 @see: referring to other classes Class documentation tags @version @author @since Variable documentation tags Method documentation tags @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 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 death 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 “Friendly” public: interface access The default package private: you can’t touch that! protected: “sort of friendly” 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 Order of garbage collection 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 Overriding vs. overloading Abstract classes and methods Constructors and polymorphism Order of constructor calls Inheritance and finalize( ) 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 static inner classes Referring to the outer class object Reaching outward from a multiply-nested class Inheriting from inner classes Can inner classes be overridden? Inner class identifiers Why inner classes? Closures & Callbacks Inner classes & control frameworks Summary Exercises 9: Holding Your 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 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 10: 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 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 Exception guidelines Summary Exercises 11: 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 A bug?A bug? Piped streams Standard I/O Reading from standard input Changing System.out to a PrintWriter Redirecting standard I/O 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 Tokenizing input StreamTokenizer StringTokenizer Checking capitalization style Summary Exercises 12: Run-time Type Identification 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 13: 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 Using the Windows Explorer 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 Programming techniques Binding events dynamically Separating business logic from UI logic A canonical form 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 Summary Exercises 14: Multiple Threads Responsive user interfaces Inheriting from Thread Threading for a responsive interface Combining the thread with the main class Making many threads Daemon threads Sharing limited resources Improperly accessing resources How Java shares resources Synchronizing the counters Synchronized efficiency JavaBeans revisited Blocking Becoming blocked Sleeping Suspending and resuming Wait and notify Blocking on I/O Testing Deadlock The deprecation of stop( ), suspend( ), resume( ), and destroy( ) in Java 2 Priorities Reading and setting priorities Thread groups Controlling thread groups Runnable revisited Too many threads Summary Exercises 15: Distributed Computing Network programming Identifying a machine Servers and clients Testing programs without a network Port: a unique place within the machine Sockets A simple server and client Serving multiple clients Datagrams Using URLs from within an applet Reading a file from the server More to networking Java Database Connectivity (JDBC) Getting the example to work Step 1: Find the JDBC Driver Step 2: Configure the database Step 3: Test the configuration Step 4: Generate your SQL query Step 5: Modify and paste in your query A GUI version of the lookup program Why the JDBC API seems so complex A more sophisticated example Servlets The basic servlet Servlets and multithreading Handling sessions with servlets The Cookie class The Session class Running the servlet examples Java Server Pages Implicit objects JSP directives JSP scripting elements Extracting fields and values JSP page attributes and scope Manipulating sessions in JSP Creating and modifying cookies JSP summary RMI (Remote Method Invocation) Remote interfaces Implementing the remote interface Setting up the registry Creating stubs and skeletons Using the remote object CORBA CORBA fundamentals CORBA Interface Definition Language (IDL) The naming service An example Writing the IDL source Creating stubs and skeletons Implementing the server and the client Some CORBA services Activating the name service process Activating the server and the client Java Applets and CORBA CORBA vs. RMI Enterprise JavaBeans JavaBeans vs. EJBs The EJB specification EJB components EJB Container & Server Java Naming and Directory Interface (JNDI) Java Transaction API/Java Transaction Service (JTA/JTS) CORBA and RMI/IIOP The pieces of an EJB component Enterprise Bean Home interface Remote interface Deployment descriptor EJB-Jar file EJB operation Types of EJBs Session Beans Entity Beans Developing an EJB EJB summary Jini: distributed services Jini in context What is Jini? How Jini works The discovery process The join process The lookup process Separation of interface and implementation Abstracting distributed systems Summary Exercises 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 further 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: The Java Native Interface (JNI) Calling a native method The header file generator: javah Name mangling and function signatures Implementing your DLL Accessing JNI functions: the JNIEnv argument Accessing Java Strings Passing and using Java objects JNI and Java exceptions JNI and threading Using a preexisting code base Additional information C: Java Programming Guidelines Design Implementation D: Resources Software Books Analysis & design Python My own list of books Index

---

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

Electric Speed: Online Marketing Company