Exploring Java - Free Ebook

By Patrick Niemeyer & Joshua Peck

This ebook is about the Java language and programming environment. If you've been at all active on the Internet in the past year, you've heard a lot about Java. It's one of the most exciting developments in the history of the Internet, rivaling the creation of the World Wide Web. Java became the darling of the Internet programming community as soon as the alpha version was released. Immediately, thousands of people were writing Java applets to add to their Web pages. Interest in Java only grew with time, and support for Java in Netscape Navigator guaranteed it would be a permanent part of the Net scene.

What, then, is Java? Java is a language for network programming that was developed by Sun Microsystems. It's already in widespread use for creating animated Web pages. However, this is only the start. The Java language and environment are rich enough to support entirely new kinds of applications, like dynamically extensible browsers. There has been talk about new kinds of computer platforms (Java terminals or Java pads) that download all their software over the network. In the coming years, we'll see what Java is capable of doing; fancy Web pages are fun and interesting, but they certainly aren't the end of the story. If Java is successful (and that isn't a foregone conclusion), it could change the way we think about computing in fundamental ways.

This ebook sets out to give you a head start on a lot of Java fundamentals. Exploring Java attempts to live up to its name by mapping out the Java language, its class libraries, programming techniques, and idioms. We'll dig deep into interesting areas, and at least scratch the surface of the rest. Other titles in the O'Reilly & Associates Java series will pick up where we leave off and provide more comprehensive information on specific areas and applications of Java.

Whenever possible, we'll provide meaningful, realistic examples and avoid simply cataloging features. The examples are simple but hint at what can be done. We won't be developing the next great "killer Internet app" in these pages, but we hope to give you a starting point for many hours of experimentation and tinkering that will lead you to learn more on your own.

Read More/get this free ebook

Ebook - Java Fundamental Classes Reference

By Mark Grand and Jonathan Knudsen

This java ebook is a reference manual for the fundamental classes in the Java programming environment; it covers version 1.1 of the Java API. We've defined fundamental classes to mean those classes in the Java Development Kit (JDK) that every Java programmer is likely to need, minus the classes that comprise the Abstract Window Toolkit (AWT). (The classes in the AWT are covered by a companion volume, the Java AWT Reference, from O'Reilly & Associates.) Thus, this ebook covers the classes in the java.lang and java.io packages, among others, and is essential for the practicing Java programmer.

This is an exciting time in the development of Java. Version 1.1 introduces a massive amount of infrastructure that more than doubles the size of the core Java APIs. This new infrastructure provides many new facilities, such as:

• Java is now more dynamic. An expanded Class class, in conjunction with the new java.lang.reflect package, allows objects to access methods and variables of objects that they were not compiled with.
• There are classes in java.io that build on the new dynamic capabilities to provide the ability to read and write objects as streams of bytes.
• There is increased support for internationalization. The support includes a Locale class and classes to format and parse data in locale-specific ways. There is also support for loading external locale-specific resources, such as textual strings.
• The java.util.zip package provides the ability to read and write compressed files.
• The java.math package provides the ability to perform arithmetic operations to any degree of precision that is necessary.

There are also more ways to package and distribute Java programs. In addition to being able to build command-line based applications and applets that are hosted by browsers, we now have the Java Servelet API that allows Java programs to function as part of a web server. Furthermore, the nature of applets may be changing. Instead of waiting for large applet to be downloaded by a browser, we now have push technologies such as Marimba's Castanet that ensure that the most current version of an applet is already on our machine when we want to run it.

Many new uses for Java have appeared or are on the horizon. For example, NASA is using Java applets to monitor telemetry data, instead of building more large, dedicated hardware consoles. Cellular phone manufacturers have committed to making cellular phone models that support Java, so in the future we may see Java programs that run on cellular phones and allow us to check e-mail or view location maps. Many additional APIs are also on the way, from Sun and other companies. These APIs not only supply infrastructure, but also provide frameworks for building domain-specific applications, in such areas as electronic commerce and manufacturing.

This java ebook is about the classes that provide the most fundamental infrastructure for Java. As you use this book, we hope that you will share our enthusiasm for the richness of what is provided and the anticipation of what is yet to come.

Read More/get this free ebook

Java Fundamental Classes Reference (Java Series)

Java AWT Reference

By John Zukowski

The Abstract Window Tookit (AWT) provides the user interface for Java programs. Unless you want to construct your own GUI or use a crude text-only interface, the AWT provides the tools you will use to communicate with the user. Although we are beginning to see some other APIs for building user interfaces, like Netscape's IFC (Internet Foundation Classes), those alternative APIs will not be in widespread use for some time, and some will be platform specific. Likewise, we are beginning to see automated tools for building GUIs in Java; Sun's JavaBeans effort promises to make such tools much more widespread. (In fact, the biggest changes in Java 1.1 prepare the way for using the various AWT components as JavaBeans.) However, even with automated tools and JavaBeans in the future, an in-depth knowledge of AWT is essential for the practicing Java programmer.

The major problem facing Java developers these days is that AWT is a moving target. Java 1.0.2 is being replaced by Java 1.1, with many significant new features. Java 1.1 was released on February 18, 1997, but it isn't clear how long it will take for 1.1 to be accepted in the market. The problem facing developers is not just learning about the new features and changes in Java 1.1, but also knowing when they can afford to use these new features in their code. In practice, this boils down to one question: when will Netscape Navigator support Java 1.1? Rumor has it that the answer is "as soon as possible"--and we all hope this rumor is correct. But given the realities of maintaining a very complex piece of software, and the fact that Netscape is currently in the beta process for Navigator 4.0, there's a possibility that "as soon as possible" and "soon" aren't the same thing. In other words, you should expect Java 1.0.2 to stick around for a while, especially since Web users won't all replace their browsers as soon as Navigator has 1.1 support.
This state of affairs raises obvious problems for my book. Nothing would have made me happier than to write a book that covered AWT 1.1 only. It would be significantly shorter, for one thing, and I wouldn't have to spend so much effort pointing out which features are present in which release. But that's not the current reality. For the time being, programmers still need to know about 1.0.2. Therefore, this book covers both releases thoroughly. There are many examples using 1.0.2; many more examples that require 1.1; and more examples showing you how to update 1.0.2 code to use 1.1's features.

Sun has done a good job of maintaining compatibility between versions: 1.0 code runs under Java 1.1, with very few exceptions. All of the 1.0 examples in this book have been tested under Java 1.1. However, Java 1.1--and particularly, AWT 1.1--offer many advantages over older releases. If nothing else, I hope this book convinces you that you should be looking forward to the day when you can forget about writing code for Java 1.0.2.

Read More/get this free ebook

Java Language Reference

By Mark Grand

This book is a reference manual for the Java programming language; it covers Version 1.1 of the Java language. It provides a complete description of all of the constructs in the language, so that programmers can write Java programs that function exactly as expected. This book is not meant to teach you the Java language, although you could probably use it for that purpose if you are already fluent in a number of other programming languages.

This is an exciting time in the development of Java. Version 1.1 is a huge new release that more than doubles the size of the core Java APIs. Fortunately, the Java language itself contains relatively few changes for Java 1.1. The new features of the language are significant, however, both in terms of the useful functionality and the elegance they add to the language. This book covers all of the new language constructs in Java 1.1. Here's a quick list of the new features:

• Inner classes, which include nested top-level classes and interfaces, member classes, local classes, and anonymous classes
• final local variables, method parameters, and catch clause parameters
• Instance initializers
• Blank finals, or final variable declarations that do not include initializers
• Class literals for obtaining Class objects
• Anonymous arrays, or arrays created and initialized without a variable initializer

Read More/get this free ebook

Ebook - Java in a Nut Shell

By David Flanagan

This handbook is a desktop quick reference for Java programmers; it covers version 1.1 of the Java language and API. It also includes introductory and tutorial material for other programmers who want to learn Java. It was written to sit faithfully by your keyboard for easy reference while you program. The wild success of the first edition has shown that this is exactly what Java programmers want, and I've retained the "no fluff" explanations and the to-the-point reference material in this second edition. I hope that new readers will find this book useful, and that old readers will find it even more useful than the last one!

Contents of This Book
This book is divided into five parts:

Part I: Introducing Java
This first part of the book introduces Java and Java programming, with a particular emphasis on helping C and C++ programmers make the transition to Java. If you are already familiar with Java 1.0 programming, you can skip the three chapters in this part.

Part II: Introducing Java 1.1
This second part of the book contains two chapters that introduce the new features of the Java 1.1 API and the new language features in Java 1.1.

Part III: Programming with the Java 1.1 API
This part contains example programs that demonstrate many of the new features of Java 1.1. You may find that these examples are a good starting point for your own programs, and you should feel free to adapt them for your own use. As explained below, this example section has changed a lot since the first edition of this book.

Part IV: Java Language Reference
This part of the book contains reference material that describes the syntax of the Java language and the tools provided with the Java Development Kit (JDK), among other things.

Part V: API Quick Reference
This part is a quick reference for the Java API; it forms the bulk of the book. Please be sure to read the How To Use This Quick Reference material, which appears at the beginning of the part. It explains how to get the most out of the reference material.

Read More/get this free ebook

Java In A Nutshell, 5th Edition

Java FAQ's - Core, Advanced, Enterprises, Miscellaneous

This java Faq site provides various java faq's in core java, advanced java, enterprises java and miscellaneous java programming techniques.

As on july 2007, this java faq and ebook site provides the following java materials for you.

Core Java

1. Language Fundamentals(147)
2. Virtual Machine(19)
3. Classes, Interfaces, & Pkgs(49)
4. Exceptions(09)
5. Applets(55)
6. Abstract Window Toolkit(70)
7. Events - JDK 1.1 and above(27)
8. Drawing(38)
9. Threads(21)
10. Input, Output(38)
11. Network(68)
12. Miscellaneous(28)

Advance Java FAQ

1. Servlets (12)
2. JDBC (38)
3. Swing (15)
4. RMI (30)
5. Java Beans(15)
6. Java IO (10)
7. Jini (09)
8. CORBA (04)
9. Browsers (07)

Read More/get this free ebook

Java Lecture Notes

This java lecture note is a good introductory level java ebook written by Elliotte Rusty Harold. This java materials are being taught by the author at the senior undergraduate and introductory graduate level for computer science majors, and is split into 13, two hour fifteen minute classes plus a final exam.

Following are the course content of this java ebook.

Week 1: Basic Java
Week 2: Procedural Java
Week 3: Introduction to java Objects
Week 4: More java Objects

Midterm
Week 5: Introducing java Applets
Week 6: Java Components
Week 7: Java Events
Week 8: Java LayoutManagers, Windows, and Dialogs
Week 9: Java Images and Menus
Week 10: Java I/O and Streams
Week 11: Java Threads
Week 12: Java Network Programming
Week 13: Cut and Paste, Printing, Future Directions
Week 14: Final Exam

Read More/get this free ebook

Java an Object First Approach - Free Ebook

This java ebook "Java An Object First Approach" provides a thorough introduction to the production of software artefacts, a process known as software development, using the programming language Java. The ebook is intended for use with readers or students starting their software development education and can also be used at a more advanced level as an Object-Oriented ebook. The author uses a spiral approach to present object-oriented concepts and techniques. The development of a class hierarchy is utilized, stressing a design, build, test cycle. An extensive case study at the conclusion of the book pulls the concepts together.

This java ebook is writen by Fintan Culwin. Following are the topics covered in this java book.

• Two Initial Applications
• An overview of Java classes
• The start of the Counters class hierarchy
• The completion of the Counters hierarchy
• The RoomMonitor class and MoneyRegister hierarchy
• The BasicMenu class
• The AdaptingMenu class
• Java Concurrent processes
• Java Keyboard input and formatted output
• The JulianDate Hierarchy
• Testing Software
• Java Streams
• Java Standard Iterative Data Structures
• Developer Supplied Data Structures.
• Dynamic and recursive data structures
• Java Graphical User Interfaces.

Read More/get this free ebook

A Guide to Java Programming - Bleeding at the Keyboard

"Bleeding at the Keyboard" is a very nice java ebook and a good java guide teaches you modern programming with java. This java ebook is written by Gregory Rawlins.

The following are the topics covered in this java book.

Setting the Stage: object, class, method, program, Java interpreter, inheritance, interface, design pattern.

Introducing the Players: class, variable, value, type, state, behavior, reference value, reference variable, message, statement, method, reference variable, reference value, class, method, and variable naming conventions, declaration statement, boolean variable, int variable, double variable, boolean value, int value, double value, true, false, scope, local variable, global variable,

Behind the Scenes: parameter, method execution, sending a message, type, return, new, assignment statement, operator, operand, main() method, dot operator, variable access, continuation line, comment, void, if, ".", "<=", "==", "/*", "*/", "//".

Character Study: type, value, reference value, reference variable, reference type, boolean type, int type, double type, Class type, null, state, behavior, operator, operand, remainder, expression, boolean expression, int expression, double expression, type casting, (int), (double), (boolean), "+", "-", "*", "/", "%", "&&", "", "!", "<", "<=", ">", ">=", "==", "!=".

Stage Direction: state, behavior, type, encapsulation, variable initialization, constructor, signature, constant naming convention, class variable, class method, if-else, this, import, private, public, final, static, main().

All Together Now: while, for, blocks, scope, increment operator, decrement operator, "++", "--", declaring variables in for loops, encapsulation, method overloading, method signature, String, string concatentation, operator overloading, arrays, array operator, "[]", packages, package access, package naming convention, package, the unnamed package.

It Takes All Types: subclass, superclass, extends, super(), overriding methods, overloading methods, class Object, the equals() method, the toString() method, String, protected, interface, interface naming convention, implements, abstract method, abstract class.

What's in a Name?: subtype, supertype, this, this(), super, super(), "([type name])", instanceof, reference casting, upcast, downcast.

Think Like an Object: encapsulation, final method, final class, private constructor.

Let the Games Begin: threads, Runnable, sleep(), exceptions, try, catch, Graphics, Component, paint().

Read More/get this free ebook

Java Version- How to Think Like a Computer Scientist - Fourth Edition

This is a very nice java programming ebook and you can think like a java scientist.

By Allen B. Downey

This is the fourth edition of a book I started writing in 1999, when I was teaching at Colby College. I had taught an introductory computer science class using the Java programming language, but I had not found a textbook I was happy with. For one thing, they were all too big! There was no way my students would read 800 pages of dense, technical material, even if I wanted them to. And I didn't want them to. Most of the material was too specific---details about Java and its libraries that would be obsolete by the end of the semester, and that obscured the material I really wanted to get to.

The other problem I found was that the introduction to object oriented programming was too abrupt. Many students who were otherwise doing well just hit a wall when we got to objects, whether we did it at the beginning, middle or end.

So I started writing. I wrote a chapter a day for 13 days, and on the 14th day I edited. Then I sent it to be photocopied and bound. When I handed it out on the first day of class, I told the students that they would be expected to read one chapter a week. In other words, they would read it seven times slower than I wrote it.

Read More/get this free ebook

A Gentle Introduction to Java Programming

by Andrew Cumming

This is an interactive java programming tutorial. You can run java programs and can verify the output of the programs. This java training covers the following topics in detail.

• Flags

In which draw colourful pictures using powerful java programming features.

• World Factbook I

In which we look at the countries of the world one at a time. We practice "if"

• Function

In which we calculate values

• Boxes

In which we practice conditions with two numbers

• World Factbook II

In which we use a loop to examine the CIA's World Factbook

• Strings

In which we manipulate and test strings.

• World Factbook II

In which we use an accumulating variable to count and sum.

• Using the documentation

In which we examine fonts.

• World Factbook III

In which we use the TreeMap Class.

• Bricks

In which we use for loops.

• Quilts

In which we practice a functional style of programming with immutable objects.

Reference: how to...

• Hello World

Some short, trival programs.

• Data types

Creating variables of different types. Converting between variable types.

• Control structures

We control program flow with while, for, foreach, if, return, break and other constructs

• Tests

We look at the different ways to test conditions.

• In-built function

We can use many functions provided by the core language. String and number functions primarily.

• In-built data structures

We can make use of arrays, hash tables and dates.

• Input and output

We explore the options for reading and writing data to files and to databases.

• Graphics

Drawing lines, polygons, strings and other shapes.

• Graphic User Interface

Buttons, text boxes that users can see and control.

• Programming techniques

Accumulating variables, recursion, function composition.

Read More/Start Java Training

Essentials of the Java Programming Language, Part 1

By Monica Pawlan

If you are new to programming in the Java language, have some experience with other languages, and are familiar with things like displaying text or graphics or performing simple calculations, this tutorial could be for you. It walks through how to use the Java 2 Platform software to create and run three common types of programs written for the Java platform—applications, applets, and servlets.

You will learn how applications, applets, and servlets are similar and different, how to build a basic user interface that handles simple end user input, how to read data from and write data to files and databases, and how to send and receive data over the network. This tutorial is not comprehensive, but instead takes you on a straight and uncomplicated path through the more common programming features available in the Java platform.

A Word About the Java Platform
The Java platform consists of the Java application programming interfaces (APIs) and the Java virtual machine (JVM).

Java APIs are libraries of compiled code that you can use in your programs. They let you add ready-made and customizable functionality to save you programming time.

The simple program in this lesson uses a Java API to print a line of text to the console. The console printing capability is provided in the API ready for you to use; you supply the text to be printed.

Java programs are run (or interpreted) by another program called the Java VM. If you are familiar with Visual Basic or another interpreted language, this concept is probably familiar to you. Rather than running directly on the native operating system, the program is interpreted by the Java VM for the native operating system. This means that any computer system with the Java VM installed can run Java programs regardless of the computer system on which the applications were originally developed.

For example, a Java program developed on a Personal Computer (PC) with the Windows NT operating system should run equally well without modification on a Sun Ultra workstation with the Solaris operating system, and vice versa.

Read More/get this free ebook

Java Au Naturel - Guide to Object Oriented Design - Java 2 with Swing

by Dr. William C. Jones, Jr.

Software development with an object-oriented approach is the fundamental subject of this book. Java is a programming language used to create the animations you see when you browse the web. Of all the programming languages whose use is wide-spread, Java is the best for learning and doing object-oriented software development. That is why Java is used in this computer science book.

Chapter One explains the details of compiling and executing a program. It introduces much of the vocabulary you need. It establishes the framework for Java programs. And it gives an overview of the book with a look at other contexts where objects are used to perform useful tasks. This is a foretaste of what is to come, so you are not expected to fully understand at this point everything it mentions.

Chapter Two introduces a quite different software context. The software provided to you defines objects that control the basic physical actions of electronic equipment. Your job is to develop additional software that puts these basic actions together in combinations that perform tasks that the purchaser of the electronic equipment finds useful. You learn to use inheritance in this new context. Then you see how to have objects select between two courses of action depending on the circumstances. You also learn a simple method of diagramming the relationships among classes of objects. It is a widely used technique that is part of the Unified Modeling Language (UML). The UML is the industry standard for modeling software.

Chapter Three shows you how to teach objects to repeat a sequence of actions many times until a task is accomplished. This ability leads to more complex programs, so we discuss a reliable process for developing the logic to solve a problem and translate it into a Java program. This is the one chapter that does not introduce a new major context for developing software.

Chapter Four switches to the context of game-playing programs. In this context, you learn how to build objects "from scratch", specifying what they know as well as what they can do. By this time you can write interesting and useful programs using only the standard library of objects that comes with every Java installation. The game-playing software interacts with the outside world through the keyboard and screen rather than via signals to and from electronic equipment or to a drawing surface.

Chapter Five completes the presentation of basic language features you need for working with objects in your programs. At this point you can construct a complete string-based simulation of the electronic equipment you worked with in earlier chapters. A case study on networks lets you see the interaction of all of the object-oriented concepts and most of the language features applied in another context. The situation that the networking material describes is key to many important real-life problems. The analysis and solution of some of these problems can be quite complex; it is the subject of more advanced courses in computer science. But the discussion here is quite elementary.

Chapter Six expands your arsenal of basic types of values to include characters and numbers with decimal points (heretofore you only had the whole-number and true-false kinds of values). It also gives you a full set of methods for dealing with strings of characters. These language features are introduced in the context of software to schedule work orders at a car repair shop using the Model/View/Controller approach and several kinds of objects at once.

Chapter Seven gives you the tools you need to work with large masses of data. This is in the context of software to handle a database of people working for a particular company. A re-implementation of a simulation of the electronic-equipment software from Chapters Two and Three helps you solidify your understanding of the key concept of arrays.

The first seven chapters present the features of Java most frequently used in this book, together with a moderate number of examples. Many of the concepts, especially the various uses of arrays, cannot be learned well enough without a great deal of practice. The remaining eleven chapters give you that practice. Their primary purpose is to (a) improve your understanding of principles and techniques of software design and development, and (b) reinforce the concepts in the basic first seven chapters.

Each of the next twelve chapters presents a different software design and development situation. The emphasis is on techniques for creating quality software...

Read More/get this free ebook

Introduction to Programming Using Java, Fifth Edition

By David J. Eck

Introduction to Programming Using Java is a free introductory computer programming textbook that uses Java as the language of instruction. It is suitable for use in an introductory programming course and for people who are trying to learn programming on their own. There are no prerequisites beyond a general familiarity with the ideas of computers and programs. There is enough material for a full year of college-level programming. Chapters 1 through 7 can be used as a textbook in a one-semester college-level course or in a year-long high school course.

This version of the book covers "Java 5.0", and many of the examples use features that were not present in earlier versions of Java. (Sometimes, you will see this version of Java referred to as Java 1.5 instead of Java 5.0.) Note that Java applets appear throughout the pages of this book. Many of those applets will be non-functional in Web browsers that do not support Java 5.0.

The home web site for this book is http://math.hws.edu/javanotes/. The page at that address contains links for downloading a copy of the web site and for downloading a PDF version of the book.

In style, this is a textbook rather than a tutorial. That is, it concentrates on explaining concepts rather than giving step-by-step how-to-do-it guides. I have tried to use a conversational writing style that might be closer to classroom lecture than to a typical textbook. You'll find programming exercises at the end of most chapters, and you will find a detailed solution for each exercise, with the sort of discussion that I would give if I presented the solution in class. I strongly advise that you read the exercise solutions if you want to get the most out of this book. This is certainly not a Java reference book, and it is not even close to a comprehensive survey of all the features of Java. It is not written as a quick introduction to Java for people who already know another programming language. Instead, it is directed mainly towards people who are learning programming for the first time, and it is as much about general programming concepts as it is about Java in particular. I believe that Introduction to Programming using Java is fully competitive with the conventionally published, printed programming textbooks that are available on the market. (Well, all right, I'll confess that I think it's better.)

There are several approaches to teaching Java. One approach uses graphical user interface programming from the very beginning. Some people believe that object oriented programming should also be emphasized from the very beginning. This is not the approach that I take. The approach that I favor starts with the more basic building blocks of programming and builds from there. After an introductory chapter, I cover procedural programming in Chapters 2, 3, and 4. Object-oriented programming is introduced in Chapter 5. Chapters 6 covers the closely related topic of event-oriented programming and graphical user interfaces. Arrays are covered in Chapter 7. Chapter 8 marks a turning point in the book, moving beyond the fundamental ideas of programming to cover more advanced topics. Chapter 8 is mostly about writing robust and correct programs, but it also has a section on parallel processing and threads. Chapters 9 and 10 cover recursion and data structures, including the Java Collection Framework. Chapter 11 is about files and networking. Finally, Chapter 12 returns to the topic of graphical user interface programming to cover some of Java's more advanced capabilities.

Major changes have been made in the fifth edition. Perhaps the most significant change is the use of parameterized types in the chapter on generic programming. Parameterized types -- Java's version of templates -- were the most eagerly anticipated new feature in Java 5.0.

Other new features in Java 5.0 are also covered. Enumerated types are introduced, although they are not covered in their full complexity. The "for-each" loop is covered and is used extensively. Formatted output is also used extensively, and the Scanner class is covered (though not until Chapter 11). Static import is covered briefly, as are variable arity methods...........

Read More/get this free ebook

Introduction to Computer Science using Java

By Bradley Kjell

These notes cover most of a beginning course in computer science using Java. They assume no background in programming. They are written to supplement a textbook or to be used alone. They provide discussion and simple examples of the important topics in programming. You can learn quite a lot about Java by going through these notes (and by running and playing with the programs, as discussed in chapter 7.) But to get a thorough grounding in the language you should also study a text book and write many programs on your own. Try to do one or two of the suggested programming exercises per chapter.

For maximum benefit, go though these notes interactively, thinking about and answering the question at the bottom of each page. There are about 15 pages per chapter. If you spend about 3 minutes per page each chapter will take about 45 minutes; much more, if you copy and run some of the programs. If you are a beginning programmer, plan on spending more than a month with this.

These notes assume that you have the Java Development Kit (JDK) version 1.1 or later from Sun (http://www.javasoft.com) and a simple text editor such as NotePad. For more about these notes check the frequently asked questions.

Read More/get this free ebook

Thinking in Java, 3rd ed. Revision 4.0

By Bruce Eckel

The releases of the Java JDK are numbered 1.0, 1.1, 1.2, 1.3, and for this book, 1.4. Although these version numbers are still in the “ones,” the standard way to refer to any version of the language that is JDK 1.2 or greater is to call it “Java 2.” This indicates the very significant changes between “old Java”—which had many warts that I complained about in the first edition of this book—and this more modern and improved version of the language, which has far fewer warts and many additions and nice designs.

This book is written for Java 2, in particular JDK 1.4 (much of the code will not compile with earlier versions, and the build system will complain and stop if you try). I have the great luxury of getting rid of all the old stuff and writing to only the new, improved language, because the old information still exists in the earlier editions, on the Web, and on the CD ROM. Also, because anyone can freely download the JDK from java.sun.com, it means that by writing to JDK 1.4, I’m not imposing a financial hardship on anyone by forcing them to upgrade.

Previous versions of Java were slow in coming out for Linux (see www.Linux.org), but that seems to have been fixed, and new versions are released for Linux at the same time as for other platforms—now even the Macintosh is starting to keep up with more recent versions of Java. Linux is a very important development in conjunction with Java, because it is quickly becoming the most important server platform out there—fast, reliable, robust, secure, well-maintained, and free, it’s a true revolution in the history of computing (I don’t think we’ve ever seen all of those features in any tool before). And Java has found a very important niche in server-side programming in the form of Servlets and JavaServer Pages (JSPs), technologies that are huge improvements over the traditional Common Gateway Interface (CGI) programming (these and related topics are covered in Thinking in Enterprise Java).

Read More/get this free ebook

1000 Java Tips

By Alexandre Patchine

One thousand Java Tips is 856 pages of A4 format of Java tips, advises and solutions from real daily Java experience. Quite often updated (330, 500, 850 and finally 1000 Java Tips), this e-book becomes more and more useful for Java developers with 2-6 years experience in this area. Questions are not from simple usual FAQs. They are especially good for those who look for Java job interview questions: both for those who hire and who look for Java jobs.

1000 java tips e-book will help you to understand java much better and be well prepared for your java certification examination. This e-book is made of questions and answers.

Read More/get this free ebook

JDiff - An HTML Report of API Differences

JDiff is a Javadoc doclet which generates an HTML report of all the packages, classes, constructors, methods, and fields which have been removed, added or changed in any way, including their documentation, when two APIs are compared. This is very useful for describing exactly what has changed between two releases of a product. Only the API (Application Programming Interface) of each version is compared. It does not compare what the source code does when executed.

JDiff is a Javadoc doclet which emits an HTML report of all the packages, classes, methods, and so on, which are different (the "diff" part) when two Java APIs are compared. Great for reporting what has changed between two releases of your product.

Download JDiff

Sample Output

• Comparing J2SE1.4.2 and J2SE1.5.0b1. Report (KB, gzip'd tar) Download
• Comparing J2SE1.4.0 and J2SE1.4.1. Report (13KB, gzip'd tar) Download
• Comparing J2SE1.4.0 and J2SE1.4.1 including documentation and statistics. Report (528KB, gzip'd tar) Download
• Comparing J2SE1.3.1 and J2SE1.4. Report (456KB, gzip'd tar) Download
• Comparing J2SE1.3.1 and J2SE1.4 including documentation and statistics. Report (2.9MB, gzip'd tar) Download

Java API Specifications

Here are the API specifications for key Java technologies and platforms, including Java 2 Platform, Standard Edition (J2SE), J2SE optional packages, Java 2 Platform, Enterprise Edition (J2EE), Java 2 Platform, Micro Edition (J2ME), XML, and others.

Below is a list of technologies that have API specifications:

Standard Edition

• Java SE 6
• J2SE 1.5.0
• J2SE 1.4.2
• J2SE 1.3.1

Enterprise Edition

• Java EE 5
• J2EE 1.4
• J2EE 1.3
• J2EE 1.2.1

Micro Edition

• J2ME

Javacard

• Javacard

Java Web Services

• Java Web Services

XML

• XML

Other Technologies

• Java 3D
• Java Advanced Imaging (JAI)
• JavaBeans Activation Framework
• Java Communications
• JavaMail
• Java Media Framework (JMF)
• Java Speech
• Real-Time Specification for Java (RTSJ)
• Other Technologies

Read More/get this free ebook

The Java Course

By by Allen B. Downey

This edition of the eBook "Java Course" is based on the well-known book by Allen B. Downey, "How to Think Like a Computer Scientist". The main reason for rearranging the original material was to provide the book not only as a printable copy (i.e. as a PDF file) but also as an indexed and easy-to-navigate electronic book which is available both online and offline. In addition, we focused on enhancing the accessibility of the texts by improving the index, by splitting the chapters into managable (and readable) parts, and by adding lots of "see also" hints and cross links.

Finally, we decided to publish this eBook as an MS Windows HTML Help file offering the same navigation structure as the Web-based version. We hope that this service makes it easier for many beginners to learn how to program under Java.

Contents

• The way of the program
• What is a programming language?
• What is a program?
• What is debugging?
• Formal and natural languages
• The first program
• Java Variables and types
• More printingVariables
• Assignment
• Printing variables
• Keywords
• Operators
• Order of operations
• Operators for Strings
• Composition
• Java Methods
• Floating-point
• Converting from double to int
• Math methods
• Composition
• Adding new methods
• Classes and methods
• Programs with multiple methods
• Methods with results
• Java Conditionals, graphics and recursion
• The modulus operator
• Conditional execution
• Alternative execution
• Chained conditionals
• Nested conditionals
• The return statement
• Type conversion
• Slates and Graphics objects
• Invoking methods on a Graphics object
• Coordinates
• A lame Mickey Mouse
• Other drawing commands
• Recursion
• fractal Mickey Mouse
• Stack diagrams for recursive methods
• Convention and divine law
• Fruitful Java methods
• Return values
• Program development
• Composition
• Overloading
• Boolean expressions
• Logical operators
• Boolean methods
• More recursion
• Leap of faith
• One more example
• Java Iteration
• Multiple assignment
• Iteration
• The while statement
• Tables
• Two-dimensional tables
• Encapsulation and generalization
• Methods
• More encapsulation
• Local variables
• More generalization
• Java Strings and things
• Invoking methods on objects
• LengthTraversal
• Run-time errors
• Reading documentation
• The indexOf method
• Looping and counting
• Increment and decrement operators
• Character arithmetic
• Strings are immutable
• Strings are incomparable
• Java Interesting objects
• What's interesting?
• Packages
• Point objects
• Instance variables
• Objects as parameters
• Rectangles
• Objects as return types
• Objects are mutableAliasingnull
• Garbage collection
• Objects and primitives
• Create your own Java objects
• Class definitions and object types
• Time
• Constructors
• More constructors
• Creating a new object
• Printing an object
• Operations on objects
• Pure functions
• Modifiers
• Fill-in methods
• Which is best?
• Incremental development vs. planning
• Generalization
• Algorithms
• Arrays
• Arrays of Objects
• Objects of Arrays
• Object-oriented programming
• Linked lists
• Stacks
• Queues and Priority Queues
• Trees
• HeapTable
• Appendix
• Index

Read More/get this free ebook

JDK 1.4 Tutorial

The JDK 1.4 release of the Java programming language from Sun Microsystems represents a substantial step in Java’s progress. Some of the new features are packages that have been in use for some time but have not yet been part of the core Java platform; other features are completely new.

Whatever their origin, these features extend Java’s capabilities, encapsulating complex functionality behind simple abstractions. Some of the features help integrate Java further into the host operating system, providing direct access to services that had previously only been accessible to native code.

This book is decidedly code-centric. The central feature of each chapter is a program or set of programs that demonstrate the subject of the chapter within a complete, real-world program. Although each chapter starts with an overview of its topic and outlines the main classes and methods of the crucial packages, it does not duplicate information that can easily be found in the Java documentation.

Thus, this book should be considered a by-example companion to the comprehensive documentation. As you peruse the chapter descriptions that follow, you may notice that this book does not rigorously cover all topics. I consider a number of topics too broad to be covered in any useful way in a book of this kind; such topics generally need their own book. These include CORBA (including the new Portable Object Adapter (POA) Object Request Broker (ORB)), XML, the Java Cryptography Extension (JCE), and the Java Authentication and Authorization Service (JAAS).

At the time this book was being prepared, it did not seem possible to acquire a driver that supported enough JDBC 3.0 features to make testing possible. Rather than write from a position of ignorance, and include possibly spurious code listings, I decided not to include a chapter on this important topic.

Sadly, the Generics (parameterized types) feature was, in the end, not included with JDK 1.4 as originally promised. This controversial addition to the language looks like it will be included in JDK 1.5 for sure, and you can download an early-access version of it from Sun. However, since it requires a change to the compiler, it can’t really be said to be a part of JDK 1.4 and so is not discussed in this book.

Read More/get this free ebook

Sun Java Tutorials

The Java Tutorials are practical guides for programmers who want to use the Java programming language to create applications. They include hundreds of complete, working examples, and dozens of lessons. Groups of related lessons are organized into "trails".

• Getting Started — An introduction to Java technology and lessons on installing Java development software and using it to create a simple program.
• Learning the Java Language — Lessons describing the essential concepts and features of the Java Programming Language.
• Essential Java Classes — Lessons on exceptions, basic input/output, concurrency, regular expressions, and the platform environment.
• Collections — Lessons on using and extending the Java Collections Framework.
• Swing — An introduction to the Swing GUI toolkit, with an overview of features and a visual catalog of components. See below for a more comprehensive tutorial on Swing.
• Deployment — How to package applications and applets using JAR files, and deploy them using Java Web Start and Java Plug-in.
• Preparation for Java Programming Language Certification — List of available training and tutorial resources.

Specialized Trails and Lessons

These trails and lessons are only available as web pages.

• Custom Networking — An introduction to the Java platform's powerful networking features.
• The Extension Mechanism — How to make custom APIs available to all applications running on the Java platform.
• Full-Screen Exclusive Mode API — How to write applications that more fully utilize the user's graphics hardware.
• Generics — An enhancement to the type system that supports operations on objects of various types while providing compile-time type safety. Note that this lesson is for advanced users. The Java Language trail contains a Generics lesson that is suitable for beginners.
• Internationalization — An introduction to designing software so that it can be easily be adapted (localized) to various languages and regions.
• JavaBeans — The Java platform's component technology.
• JDBC Database Access — Introduces an API for connectivity between the Java applications and a wide range of databases and a data sources.
• JMX— Java Management Extensions provides a standard way of managing resources such as applications, devices, and services.
• JNDI— Java Naming and Directory Interface enables accessing the Naming and Directory Service such as DNS and LDAP.
• RMI — The Remote Method Invocation API allows allows an object to invoke methods of an object running on another Java Virtual Machine.
• Reflection — An API that represents ("reflects") the classes, interfaces, and objects in the current Java Virtual Machine.
• Security — Java platform features that help protect applications from malicious software.
• Sound — An API for playing sound data from applications.
• 2D Graphics — How to display and print 2D graphics in applications.

Read More/get this free ebook