Introduction
Java 7 is Oracle's latest release of the popular Java language and platform. Beginning Java 7 guides you through this language and a huge assortment of platform APIs via its 12 chapters and 4 appendixes.
Note
Java was created by Sun Microsystems, which was later bought out by Oracle.
Chapter 1 (Getting Started with Java) introduces you to Java and begins to cover the Java language by focusing on fundamental concepts such as comments, identifiers, variables, expressions, and statements.
Chapter 2 (Discovering Classes and Objects) continues to explore this language by presenting all of its features for working with classes and objects. You learn about features related to class declaration and object creation, encapsulation, information hiding, inheritance, polymorphism, interfaces, and garbage collection.
Chapter 3 (Exploring Advanced Language Features) focuses on the more advanced language features related to nested classes, packages, static imports, exceptions, assertions, annotations, generics, and enums. Subsequent chapters introduce you to the few features not covered in Chapters 1 through 3.
Chapter 4 (Touring Language APIs) largely moves away from covering language features (although it does introduce class literals and strictfp) while focusing on language-oriented APIs. You learn about Math, StrictMath, Package, Primitive Type Wrapper Classes, Reference, Reflection, String, StringBuffer and StringBuilder, Threading, BigDecimal, and Biglnteger in this chapter.
Chapter 5 (Collecting Objects) begins to explore Java's utility APIs by focusing largely on the Collections Framework. However, it also discusses legacy collection-oriented APIs and how to create your own collections.
Chapter 6 (Touring Additional Utility APIs) continues to focus on utility APIs by presenting the concurrency utilities along with the Objects and Random classes.
Chapter 7 (Creating and Enriching Graphical User Interfaces) moves you away from the command-line user interfaces that appear in previous chapters and toward graphical user interfaces. You first learn about the Abstract Window Toolkit foundation and then explore the Java Foundation Classes in terms of Swing and Java 2D. (Appendix C introduces you to Accessibility and Drag and Drop.)
Chapter 8 (Interacting with Filesystems) explores filesystem-oriented I/O in terms of the File, RandomAccessFile, stream, and writer/reader classes. (New I/O is covered in Appendix C.)
Chapter 9 (Interacting with Networks and Databases) introduces you to Java's network APIs (e.g., sockets). It also introduces you to the JDBC API for interacting with databases.
Chapter 10 (Parsing, Creating, and Transforming XML Documents) dives into Java's XML support by first presenting an introduction to XML (including DTDs and schemas). It next explores the SAX, DOM, StAX, XPath, and XSLT APIs; and even briefly touches on the Validation API. While exploring XPath, you encounter namespace contexts, extension functions and function resolvers, and variables and variable resolvers.
Chapter 11 (Working with Web Services) introduces you to Java's support for SOAP-based and RESTful web services. Besides providing you with the basics of these web service categories, Chapter 11 presents some advanced topics, such as working with the SAAJ API to communicate with a SOAP-based web service without having to rely on JAX-WS. You'll appreciate having learned about XML in Chapter 10 before diving into this chapter.
Chapter 12 (Java 7 Meets Android) helps you put to use some of the knowledge you've gathered in previous chapters by showing you how to use Java to write an Android app's source code. This chapter introduces you to Android, discusses its architecture, shows you how to install necessary tools, and develops a simple app.
As well as creating these twelve chapters, I've created four appendices:
Appendix A (Solutions to Exercises) presents the solutions to the programming exercises that appear near the end of Chapters 1 through 12.
Appendix B (Scripting API and Dynamically Typed Language Support) introduces you to Java's Scripting API along with the support for dynamically typed languages that's new in Java 7.
Appendix C (Odds and Ends) introduces you to additional APIs and architecture topics: Accessibility, ByteArrayOutputStream and ByteArrayInputStream, classloaders, Console, Desktop, Drag and Drop, Dynamic Layout, Extension Mechanism and ServiceLoader, File Partition-Space, File Permissions, Formatter, Image I/O, Internationalization, Java Native Interface, NetworkInterface and InterfaceAddress, New I/O (including NIO.2), PipedOutputStream and PipedInputStream, Preferences, Scanner, Security, Smart Card, Splash Screen, StreamTokenizer, StringTokenizer, SwingWorker, System Tray, Timer and TimerTask, Tools and the Compiler API, Translucent and Shaped Windows, and XML Digital Signature.
Appendix D (Applications Gallery) presents a gallery of significant applications that demonstrate various aspects of Java and gives you an opportunity to have more fun with this technology.
Unfortunately, there are limits to how much knowledge can be crammed into a print book. For this reason, Appendixes A, B, C, and D are not included in this book's pages-adding these appendixes would have exceeded the Print-On-Demand (http://en.wikipedia.org/wiki/Print_on_demand) limit of 1,000 pages cover to cover. Instead, these appendixes are freely distributed as PDF files. Appendixes A and B are bundled with the book's associated code file at the Apress website (http://www.apress.com/9781430239093). Appendixes C and D are bundled with their respective code files on my TutorTutor website (http://tutortutor.ca/cgi-bin/makepage.cgi?/books/bj7).
Appendixes C and D are "living documents" in that I'll occasionally add new material to them. When I first encountered Java, I fell in love with this technology and dreamed about writing a book that explored the entire language and all standard edition APIs. Perhaps I would be the first person to do so.
There are various obstacles to achieving this goal. For one thing, it's not easy to organize a vast amount of content, and Java keeps getting bigger with each new release, so there's always more to write about.
Another obstacle is that it's not possible to adequately cover everything within the limits of a 1,000-page book. And then there are the time constraints, which make it impossible to complete everything in just a few months.
Proper organization is essential to creating a book that satisfies both Java beginners and more seasoned Java developers. Regrettably, lack of proper organization in my former Learn Java for Android Development book resulted in something that isn't beginner friendly (this has been pointed out on numerous occasions). For example, the second chapter mixes coverage of basic features (e.g., expressions and statements) with objects and classes, and this approach is too confusing for the novice. Beginning Java 7 s coverage of the Java language is better organized.
It's not possible to cover everything within 1,000 pages, which is the upper limit for a Print-On-Demand book. For this reason, I've designed Appendixes C and D to be "living" extensions to the book. They make it possible for me to complete my coverage of the entire Java 7 Standard Edition. I might even cover Java 8's new features in a separate area of Appendix C.
I spent nearly six months writing Beginning Java 7. Given the vast scope of this project, that's a very small amount of time. It will take me many more months to complete my tour of Java 7 Standard Edition; I'll occasionally post updated Appendixes C and D on my website that take you even deeper into this technology.
If you've previously purchased a copy of Learn Java for Android Development, you'll probably be shocked to discover that I've plagiarized much of my own content. I did so to speed Beginning Java 7s development, which contains much material beyond what appeared in my former book (e.g., Swing and web services). Beginning Java 7 would have taken many more months to complete if I didn't leverage its predecessor. (If I thought that Learn Java for Android Development was crap, and I don't, I never would have used it as the basis for this new book.)
Don't get the idea that Beginning Java 7 is a rehash of Learn Java for Android Development-it's not. In those portions of Beginning Java 7 where I've stolen heavily from its predecessor, there typically are numerous changes and additions. For example, I've rewritten parts of the exceptions and generics content that appear in Chapter 3; I did so to introduce new Java 7 features and to provide better coverage of difficult topics. Also, Chapter 5 introduces navigable sets and navigable maps, which is something that I couldn't discuss in Learn Java for Android Development because these features were introduced in Java 6. (I wrote Learn Java for Android Development to teach the Java language and APIs to prepare the reader for Android-Android apps are written in Java. However, Android doesn't support language features and APIs beyond Java 5.)
Beginning Java 7 goes far beyond Learn Java for Android Development in that it also discusses user interface APIs (e.g., Abstract Window Toolkit, Swing, and Java 2D) and web services (JAX-WS and RESTful). As well as new content, you'll also find many new examples (e.g., a chat server) and new exercises (e.g., create a networked Blackjack game with a graphical user interface).
At the end of Chapter 10 in Learn Java for Android Development, I rashly promised to write the following free chapters:
Chapter 11: Performing I/O Redux
Chapter 12: Parsing and Creating XML Documents
Chapter 13: Accessing Networks
Chapter 14: Accessing Databases
Chapter 15: Working with Security
Chapter 16: Odds and Ends
I originally intended to write these chapters and add them to Learn Java for Android Development. However, I ran out of time and would probably have also run into the Print-On-Demand limit that I previously mentioned.
Given beginner-oriented organizational difficulties with Learn Java for Android Development, I decided to not write these chapters in that book's context. Instead, I pursued Beginning Java 7 in a new (and hopefully better organized) attempt to cover all of Java, and to attempt to create a book that broadly appeals to Java beginners and veterans alike.
Although I won't write the aforementioned six free chapters as described in Learn Java for Android Development (I can't keep the entire promise anyway because I've integrated Chapters 12, 13, and 14 into Beginning Java 7 as Chapters 9 and 10), the other three chapters (11, 15, and 16) are merged into Appendix C, which is free. As time passes, additional chapters will appear in that appendix; and so I will finally keep my promise, but in a different way.
I don't discuss code conventions for writing source code in this book. Instead, I've adopted my own conventions, and try to apply them consistently throughout the book. If you're interested in what Oracle has to say about Java code conventions, check out the "Code Conventions for the Java Programming Language" document at http://www.oracle.com/technetwork/java/codeconv-138413.html.
jilguera