"Thinking in Java" (by Bruce Eckel)

is a revisited mirror (published with the agreement and the cooperation of the original author) of http://www.EckelObjects.com/javabook.html where you can download this free book in Acrobat (www.adobe.com) PDF format: Thinking in Java Rev. 9, August 16, 1997 TJAVA9.PDF (2678 kb). Downloading the PDF file from the original site is quite difficult. The TJAVA9.PDF Acrobat file, the tjava9W95.zip file (1557 kb --> a 4349 kb WORD file), the CodePackagertj9code.zip (122 kb --> 3 files, 1070 kb) and the CodePackager java source are mirrored on our site. A detailled description of all chapters and an important errata note are also available. This book has been written by Bruce Eckel (Bruce@EckelObjects.com), also author of "Thinking in C++".

---

1. Capitalize the first letter of class names. The first letter of fields, methods and objects (handles) should be lowercase. All identifiers should run their words together, and capitalize the first letter of all intermediate words. For example
   ThisIsAClassName
thisIsAMethodOrFieldName
   Capitalize all the letters of static final identifiers.
   Packages are a special case: they are all lowercase letters, even for intermediate words.
   (in appendix C (Java programming guidelines) of Thinking in Java, by Bruce Eckel)

2. For each class you create, consider including a main( ) that contains code to test that class. You don't need to remove the test code to use the class in a project, and if you make any changes you can easily re-run the tests.
   (in appendix C (Java programming guidelines) of Thinking in Java, by Bruce Eckel)

3. If your class requires any cleanup when the client programmer is finished with the object, place the cleanup code in a single, well defined method. In addition, place a boolean flag in the class to indicate whether the object has been cleaned up or not. In the finalize( ) method for the class, check to make sure the object has been cleaned up, and throw a class derived from RuntimeException if it hasn't, to indicate a programming error.
   (in appendix C (Java programming guidelines) of Thinking in Java, by Bruce Eckel)

4. When overriding finalize( ) during inheritance, remember to call super.finalize( ) (this is not necessary if Object is your immediate superclass). You should call super.finalize( ) as the last act of your overridden finalize( ) rather than the first, to ensure that base-class components are still valid if you need them.
   (in appendix C (Java programming guidelines) of Thinking in Java, by Bruce Eckel)

5. Constructors, exceptions, and finalize( ).
   You'll generally want to re-throw any exceptions that you catch in a constructor if it causes failure of the creation of that object, so the caller doesn't blindly continue, thinking that the object was created correctly.
   (in appendix C (Java programming guidelines) of Thinking in Java, by Bruce Eckel)

6. When you are creating a fixed-size collection of objects, transfer them to an array (especially if you're returning this collection from a method). This way you get the benefit of the array's compile-time type checking and the recipient of the array may not have to cast the objects in the array to use them.
   (in appendix C (Java programming guidelines) of Thinking in Java, by Bruce Eckel)

7. Choose interfaces over abstract classes. If you know something is going to be a base class, your first choice should be to make it an interface, and only if you're forced to have method definitions or member variables should you change to an abstract class.
   (in appendix C (Java programming guidelines) of Thinking in Java, by Bruce Eckel)

8. Inside constructors, do only what is necessary to set the object into the proper state. Actively avoid calling other methods (except for final methods) since those methods may be overridden to produce unexpected results during construction (see Chapter 7 for details).
   (in appendix C (Java programming guidelines) of Thinking in Java, by Bruce Eckel)

9. Choose composition first when creating new classes from existing classes. Only if inheritance is required by your design should it be used. If you use inheritance where composition will work, your designs will become needlessly complicated.
   (in appendix C (Java programming guidelines) of Thinking in Java, by Bruce Eckel)

10. Use inheritance to express differences in behavior, and member variables to express variations in state.
    (in appendix C (Java programming guidelines) of Thinking in Java, by Bruce Eckel)

11. To avoid a highly frustrating experience, make sure there's only one class of each name anywhere in your classpath. Otherwise the compiler can find the identically-named other class first, and report error messages that make no sense. If you suspect you are having a classpath problem, try looking for .class files with the same names at each of the starting points in your classpath.
    (in appendix C (Java programming guidelines) of Thinking in Java, by Bruce Eckel)

12. When using the event "adapters" in the new Java 1.1 AWT, there's a particularly easy pitfall you can encounter. If you override one of the adapter methods and you don't quite get the spelling right, you'll end up adding a new method rather than overriding an existing method. However, this is perfectly legal and so you won't get any error message from the compiler or run-time system – your code simply won't work correctly.
    (in appendix C (Java programming guidelines) of Thinking in Java, by Bruce Eckel)

    ---

13. introduction to objects (in Thinking in Java, by Bruce Eckel)

14. the progress of abstraction (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

15. an object has an interface (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

16. the hidden implementation (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

17. reusing the implementation (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

18. inheritance: reusing the interface (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

19. overriding base-class functionality (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

20. is-a vs. is-like-a relationships (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

21. interchangeable objects with polymorphism (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

22. dynamic binding (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

23. the abstract base class (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

24. object landscapes and lifetimes (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

25. containers and iterators (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

26. the singly-rooted hierarchy (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

27. container libraries and support for easy container use (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

28. the housekeeping dilemma: who should clean up? (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

29. exception handling: dealing with errors (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

30. multithreading (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

31. persistence (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

32. Java and the Internet (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

33. what is the Web? (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

34. client-side programming (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

35. a separate arena: applications (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

36. online documentation (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

37. summary: Java vs. C++? (in Thinking in Java - Chapter : introduction to objects - by Bruce Eckel)

    ---

38. everything is an object (in Thinking in Java, by Bruce Eckel)

39. you manipulate objects through handles (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

40. you must create all the objects (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

41. where storage lives (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

42. special case: primitive types (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

43. arrays in Java (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

44. you never have to destroy an object (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

45. scoping (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

46. scope of objects (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

47. creating new data types: class (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

48. fields and methods (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

49. methods, arguments, and return values (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

50. the argument list (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

51. building a Java program (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

52. name visibility (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

53. using other components (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

54. the "static" keyword (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

55. your first Java program (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

56. comments & embedded documentation (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

57. comment documentation (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

58. syntax (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

59. embedded HTML (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

60. @see: referring to other classes (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

61. class documentation tags (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

62. variable documentation tags (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

63. method documentation tags (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

64. documentation example (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

65. coding style (in Thinking in Java - Chapter : everything is an object - by Bruce Eckel)

    ---

66. controlling program flow (in Thinking in Java, by Bruce Eckel)

67. using Java operators (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

68. precedence (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

69. assignment (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

70. mathematical operators (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

71. auto increment and decrement (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

72. relational operators (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

73. logical operators (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

74. bitwise operators (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

75. shift operators (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

76. ternary if-else operator (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

77. the comma operator (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

78. String operator + (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

79. common pitfalls when using operators (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

80. casting operators (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

81. Java has no "sizeof" (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

82. precedence revisited (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

83. a compendium of operators (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

84. execution control (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

85. true and false (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

86. if-else (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

87. iteration (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

88. do-while (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

89. for (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

90. break and continue (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

91. switch (in Thinking in Java - Chapter : controlling program flow - by Bruce Eckel)

    ---

92. initialization & cleanup (in Thinking in Java, by Bruce Eckel)

93. guaranteed initialization with the constructor (in Thinking in Java - Chapter : initialization & cleanup - by Bruce Eckel)

94. method overloading (in Thinking in Java - Chapter : initialization & cleanup - by Bruce Eckel)

95. distinguishing overloaded methods (in Thinking in Java - Chapter : initialization & cleanup - by Bruce Eckel)

96. overloading on return values (in Thinking in Java - Chapter : initialization & cleanup - by Bruce Eckel)

97. default constructors (in Thinking in Java - Chapter : initialization & cleanup - by Bruce Eckel)

98. the this keyword (in Thinking in Java - Chapter : initialization & cleanup - by Bruce Eckel)

99. cleanup: finalization and garbage collection (in Thinking in Java - Chapter : initialization & cleanup - by Bruce Eckel)

100. what is finalize ( ) for? (in Thinking in Java - Chapter : initialization & cleanup - by Bruce Eckel)

101. you must perform cleanup (in Thinking in Java - Chapter : initialization & cleanup - by Bruce Eckel)

102. member initialization (in Thinking in Java - Chapter : initialization & cleanup - by Bruce Eckel)

103. specifying initialization (in Thinking in Java - Chapter : initialization & cleanup - by Bruce Eckel)

104. constructor initialization (in Thinking in Java - Chapter : initialization & cleanup - by Bruce Eckel)

105. array initialization (in Thinking in Java - Chapter : initialization & cleanup - by Bruce Eckel)

     ---

106. hiding the implementation (in Thinking in Java, by Bruce Eckel)

107. package: the library unit (in Thinking in Java - Chapter : hiding the implementation - by Bruce Eckel)

108. creating unique package names (in Thinking in Java - Chapter : hiding the implementation - by Bruce Eckel)

109. a custom tool library (in Thinking in Java - Chapter : hiding the implementation - by Bruce Eckel)

110. package caveat (in Thinking in Java - Chapter : hiding the implementation - by Bruce Eckel)

111. Java access specifiers (in Thinking in Java - Chapter : hiding the implementation - by Bruce Eckel)

112. "friendly" (in Thinking in Java - Chapter : hiding the implementation - by Bruce Eckel)

113. public: interface access (in Thinking in Java - Chapter : hiding the implementation - by Bruce Eckel)

114. private: you can't touch that! (in Thinking in Java - Chapter : hiding the implementation - by Bruce Eckel)

115. protected: "sort of private" (in Thinking in Java - Chapter : hiding the implementation - by Bruce Eckel)

116. interface & implementation (in Thinking in Java - Chapter : hiding the implementation - by Bruce Eckel)

117. class access (in Thinking in Java - Chapter : hiding the implementation - by Bruce Eckel)

     ---

118. reusing classes (in Thinking in Java, by Bruce Eckel)

119. composition syntax (in Thinking in Java - Chapter : reusing classes - by Bruce Eckel)

120. inheritance syntax (in Thinking in Java - Chapter : reusing classes - by Bruce Eckel)

121. initializing the base class (in Thinking in Java - Chapter : reusing classes - by Bruce Eckel)

122. combining composition & inheritance (in Thinking in Java - Chapter : reusing classes - by Bruce Eckel)

123. guaranteeing proper cleanup (in Thinking in Java - Chapter : reusing classes - by Bruce Eckel)

124. name hiding (in Thinking in Java - Chapter : reusing classes - by Bruce Eckel)

125. choosing composition vs. inheritance (in Thinking in Java - Chapter : reusing classes - by Bruce Eckel)

126. protected (in Thinking in Java - Chapter : reusing classes - by Bruce Eckel)

127. incremental development (in Thinking in Java - Chapter : reusing classes - by Bruce Eckel)

128. upcasting (in Thinking in Java - Chapter : reusing classes - by Bruce Eckel)

129. why "upcasting"? (in Thinking in Java - Chapter : reusing classes - by Bruce Eckel)

130. the final keyword (in Thinking in Java - Chapter : reusing classes - by Bruce Eckel)

131. final data (in Thinking in Java - Chapter : reusing classes - by Bruce Eckel)

132. final methods (in Thinking in Java - Chapter : reusing classes - by Bruce Eckel)

133. final classes (in Thinking in Java - Chapter : reusing classes - by Bruce Eckel)

134. final caution (in Thinking in Java - Chapter : reusing classes - by Bruce Eckel)

135. initialization & class loading (in Thinking in Java - Chapter : reusing classes - by Bruce Eckel)

136. initialization with inheritance (in Thinking in Java - Chapter : reusing classes - by Bruce Eckel)

     ---

137. polymorphism (in Thinking in Java, by Bruce Eckel)

138. upcasting (in Thinking in Java - Chapter : polymorphism - by Bruce Eckel)

139. why upcast? (in Thinking in Java - Chapter : polymorphism - by Bruce Eckel)

140. the twist (in Thinking in Java - Chapter : polymorphism - by Bruce Eckel)

141. method call binding (in Thinking in Java - Chapter : polymorphism - by Bruce Eckel)

142. producing the right behavior (in Thinking in Java - Chapter : polymorphism - by Bruce Eckel)

143. extensibility (in Thinking in Java - Chapter : polymorphism - by Bruce Eckel)

144. overriding vs. overloading (in Thinking in Java - Chapter : polymorphism - by Bruce Eckel)

145. abstract classes & methods (in Thinking in Java - Chapter : polymorphism - by Bruce Eckel)

146. interfaces (in Thinking in Java - Chapter : polymorphism - by Bruce Eckel)

147. "multiple inheritance" in Java (in Thinking in Java - Chapter : polymorphism - by Bruce Eckel)

148. extending an interface with inheritance (in