Thinking in Java

Thinking in Java

4.14 (1,752 ratings by Goodreads)
  • Mixed media product
By (author) 

List price: US$54.99

Currently unavailable

We can notify you when this item is back in stock

Add to wishlist

AbeBooks may have this title (opens in new window).

Try AbeBooks


Appropriate for intermediate to advanced courses in Java.In Thinking in Java, Third Edition, Bruce Eckel revises his widely-praised Java introduction to fully reflect the power of Java 2 Standard Edition, Version 1.4. This new edition of the book that won the 1999 Software Development Magazine Productivity Award adds thoroughly updated coverage of servlets, JSP, and EJB. As always, Eckel doesn't just show students what to do, but why. He introduces all the basics of objects as Java uses them; then walks carefully through the fundamentals of Java programming, including program flow, initialization and cleanup, implementation hiding, reusing classes and polymorphism. Using to-the-point examples, he introduces exception handling, Java I/O, run-time type identification, and passing and returning objects. Coverage also includes: database integration, transactions, security, Swing GUI development, Jini, JavaSpaces, and much more. Eckel presents Java one simple step at a time, carefully organizing his material so students can learn new concepts even in short study periods, and thoroughly digest each new idea and technique before moving on. All code examples are simple and short, enabling even beginners to understand every detail. All code examples are on the accompanying CD-ROM, along with electronic copies of the book in several formats, and the complete Thinking in C multimedia course, which introduces crucial concepts every beginning programmer must master before learning Java.
show more

Product details

  • Mixed media product | 1119 pages
  • 177.8 x 233.68 x 43.18mm | 1,632.92g
  • Pearson Education (US)
  • Prentice Hall
  • Upper Saddle River, United States
  • 3rd edition
  • 0131002872
  • 9780131002876

Table of contents

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. 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. Interchangeable objects with polymorphism. 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. You manipulate objects with references. You must create all the objects. You never need to destroy an object. Creating new data types: class. Methods, arguments, and return values. 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 & Cleanup. Guaranteed initialization with the constructor. Method overloading. Cleanup: finalization and garbage collection. Member initialization. Array initialization. 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. Combining composition and inheritance. Choosing composition vs. inheritance. protected. Incremental development. Upcasting. The final keyword. Initialization and class loading. Summary. Exercises.7. Polymorphism. Upcasting revisited. The twist. Abstract classes and methods. Constructors and polymorphism. Designing with inheritance. Summary. Exercises.8. Interfaces & Inner Classes. Interfaces. Inner classes. Why inner classes? Summary. Exercises.9. Error Handling with Exceptions. Basic exceptions. Catching an exception. Creating your own exceptions. The exception specification. Catching any exception. Standard Java exceptions. Performing cleanup with finally. 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. Summary. Exercises.11. Collections of Objects. Arrays. Introduction to containers. Container disadvantage: unknown type. Iterators. Container taxonomy. Collection functionality. List functionality. Set functionality. Map functionality. Holding references. Iterators revisited. Choosing an implementation. Sorting and searching Lists. Utilities. Unsupported operations. Java 1.0/1.1 containers. Summary. Exercises.12. The Java I/O System. The File class. Input and output. Adding attributes and useful interfaces. Readers & Writers. Off by itself: RandomAccessFile. Typical uses of I/O streams. File reading & writing utilities. Standard I/O. New I/O. Compression. Object serialization. Preferences. Regular expressions. Summary. Exercises.13. Concurrency. Motivation. Basic threads. Sharing limited resources. Improperly Thread states. Cooperation between threads. 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. Making a button. Capturing an event. Text areas. Controlling layout. The Swing event model. A catalog of Swing components. Packaging an applet into a JAR file. Signing applets. JNLP and Java Web Start. Programming techniques. Concurrency & Swing. Visual programming and JavaBeans. Summary. Exercises.15. Discovering Problems. Unit Testing. Improving reliability with assertions. Building with Ant. Logging. Debugging. Profiling and optimizing. Doclets. Summary. Exercises.16. Analysis and Design. Methodology. Phase 0: Make a plan. Phase 1: What are we making? Phase 2: How will we build it? Phase 3: Build the core. Phase 4: Iterate the use cases. Phase 5: Evolution. Plans pay off. Extreme Programming. Strategies for transition. Summary.A. Passing & Returning Objects. Passing references around. Making local copies. Controlling cloneability. Read-only classes 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.Index.
show more

About Bruce Eckel

BRUCE ECKEL is president of Mindview, Inc., which provides public and private training seminars, consulting, mentoring, and design reviews in Object-Oriented technology and Design Patterns. He is the author of Thinking in C++, Volume 2, and other books, has written over 150 articles, and has given lectures and seminars throughout the world for over 20 years. He has served as a voting member of the C++ Standards Committee. He holds a BS in Applied Physics and an MS in Computer Engineering.
show more

Rating details

1,752 ratings
4.14 out of 5 stars
5 43% (748)
4 36% (630)
3 16% (276)
2 4% (71)
1 2% (27)
Book ratings by Goodreads
Goodreads is the world's largest site for readers with over 50 million reviews. We're featuring millions of their reader ratings on our book pages to help you find your new favourite book. Close X