From Wikibooks, the open-content textbooks collection

This is the print version of Java Programming You won't see this message or any elements not part of the book's content when you print or preview this page.

TABLE OF CONTENTS

Navigate Concurrent Programming topic:

• Threads and Runnables
• Basic Synchronization
• Client Server Programming
• Remote Method Invocation(RMI)
• Enterprise JavaBean Programming
• Jini-Java Spaces Programming Template:Java Programming/Streams

Template:Java Programming/Reflection

Applets

• Overview
• User Interface
  • Applying styles and adding content
  • Font
  • Button
  • Label
  • TextField
  • Layout
  • Panel
• Event Listeners
  • ActionListener
  • MouseListener
  • MouseMotionListener
• Analyzing User Input
• Graphics and Media
  • Drawing
  • Painting
  • Sound
• HTML ImplementationTemplate:Java Programming/JavaBeans

Libraries, Extensions, and Frameworks

• Math and Geometry
• Regular Expressions
• Security
• Input and Output
  • Logging
  • Database Connectivity
  • Zip and Other Archives
• XML
• Graphical User Interfaces
• Open Source
  • Struts
  • Spring framework

About This Book

Overview

Java Programming Print version

How to use this book

Java has gained a considerable foothold in the world of programming since its inception in 1995. Since then, the way people code has been gradually evolving into a more standardized manner, rendering Java programming as a pivotal first step into the realm of software code that is Object oriented programming.

In an effort to enable software enthusiasts to program in Java as their first language, this book finds itself a mission: to deliver as much information as is possible using Java as a primary programming language. Because of that this book can be considered as a reference book of Java and its related technologies. Hosting the book on Wikibooks means that this book will constantly be evolving into a more comprehensive text as time goes by.

Who Should Read This Book

This book is for programmers who wish to learn how to program with Java.

This book does not teach general programming constructs: we assume you know what variables are, what assignment is, etc. We also assume you know the basics of Object Oriented programming.

If you need to brush up on these topics, a suggested book is Computer programming which has a chapter on Object oriented programming.

Also there are many good commercial books that can be used to learn Java (see the external links). This book does not intend to replace them. Rather this book can be used to supplement them, during the learning of Java. It always helps the learning process to hear the same information in different ways, and this book represents one of the ways. And when the Java language is mastered, this book can be used as a reference. When you want to look something up quickly, instead of searching in a printed book, you can look it up in this book.

This book can also be used by advanced Java programmers either by contributing or using this book as a reference. Also there is an Advanced Topics section for advanced Java programmers.

How this book is evolving

Any Wikibooks user can edit or modify this book. With readily available information on the internet, this book is expected to include all aspects of the Java Programming language albeit it is taken into consideration that not everything is crammed into the book.

For Book Authors (Wikibookians)

If you would like to contribute to this book on Java Programming -- Welcome! We're glad to have you aboard. This section will provide some guidance for contributors so that we can work together most effectively.

Contributors

Please add your name here if you have contributed to this book.

• Sundar
• djb
• Ervinn
• rappo
• Malfist
• deva
• Arun Reginald
• Eswar Kishore
• Cooper Erik Clauson
• Shritam

History

How to use this book

Java Programming Print version

Java Overview

On 23 May 1995, John Gage, the director of the Science Office of the Sun Microsystems along with Marc Andreesen, co-founder and executive vice president at Netscape announced to an audience of SunWorld^TM that Java technology wasn't a myth and that it was a reality and that it was going to be incorporated into Netscape Navigator.^[1]

At the time the total number of people working on Java were less than 30 people.^[1] This team would shape the future in the next decade and no one had an idea as to what was in store. From being the mind of an unmanned vehicle on Mars to the operating environment on most of the consumer electronics, e.g., cable set-top boxes,VCR's, toasters, and also for personal data assistants (PDAs).^[2] Java has come a long way from its inception. Let's see how it all began.

The Green team

James Gosling, architect and designer of the compiler for the Java technology

Behind closed doors, a project was initiated in December of 1990, whose aim was to create a programming tool that could render obsolete the C and C++ programming languages. Engineer Patrick Naughton had become extremely frustrated with the state of Sun's C++ and C APIs (application programming interfaces) and tools. While he was considering to move towards NeXT, he was offered a chance to work on new technology and the "Stealth Project" was started, a secret nobody but he knew.

This Stealth Project was later named the "Green Project" when James Gosling and Mike Sheridan joined Patrick.^[1] Over the period of time that the Green Project teethed, the prospects of the project started becoming clearer to the engineers working on it. No longer was it's aim to create a new language far superior to the present ones, but it aimed to target the language to devices other than the computer.

Staffed at 13 people, they began work in a small office on Sand Hill Road in Menlo Park, California. This team would be called "Green Team" henceforth in time. The project they underwent was chartered by Sun Microsystems to anticipate and plan for the "next-wave" in computing. For the team, this meant at least one significant trend, that of the convergence of digitally controlled consumer devices and computers.^[1]

Reshaping thought

The team started thinking of replacing C++ with a better version, a faster version, a responsive version. But the one thing they hadn't thought of, as of yet, was that the language they were aiming for, had to be developed for an embedded system with limited resources. An embedded system is a computer system scaled to a minimalistic interface demanding only a few functions from its design. For such a system, C++ or any successor would seem too large as all the languages at the time demanded a larger footprint than what was desired. And, other than this, the language lacked some other important features as well. The team thus had to think in a different way to go about solving all these problems.

Co-founder of Sun Microsystems, Bill Joy, envisioned a language combining the power of Mesa and C in a paper he wrote for the engineers at Sun named Further. Gathering ideas, Gosling began work on enhancing C++ and named it "C++ ++ --", a pun on the evolutionary structure of the language's name. The ++ and -- meant, putting in and taking out stuff. He soon abandoned the name and called it Oak^[1] after the tree that stood outside his office.

Table 1: Who's who of the Java technology^[1]
Has worked for GT (Green Team), FP (FirstPerson) and JP (Java Products Group)

Name	GT	FP	JP	Details
Lisa Friendly		Yes	Yes	FirstPerson employee and member of the Java Products Group
John Gage				Science Office (Director), Sun Microsystems
James Gosling	Yes	Yes	Yes	Lead engineer and key architect of the Java technology
Bill Joy				Co-founder and VP, Sun Microsystems; Principal designer of the UC Berkeley, version of the UNIX® OS
Jonni Kanerva		Yes		Java Products Group employee, author of The Java FAQ1
Tim Lindholm		Yes	Yes	FirstPerson employee and member Java Products Group
Scott McNealy				Chairman, President, and CEO of Sun Microsystems
Patrick Naughton	Yes	Yes		Green Team member, FirstPerson co-founder
George Paolini				Corporate Marketing (Director), Sun's Java Software Division
Kim Polese		Yes		FirstPerson product marketing
Lisa Poulson				Original director of public relations for Java technology (Burson-Marsteller)
Wayne Rosing		Yes		FirstPerson President
Eric Schmidt				Former Sun Microsystems Chief Technology Officer
Mike Sheridan	Yes			Green Team member

The demise of an idea, birth of another

By now, the work on Oak had been significant but come the year 1993, people saw the demise of set-top boxes, interactive TV and the PDAs. A failure that completely ushered the inventors' thoughts to be reinvented. Only a miracle could make the project a success now. And such a miracle awaited anticipation.

National Center for Supercomputing Applications (NCSA) had just unveiled its new commercial web browser for the internet the previous year. The focus of the team, now diverted towards where they thought the "next-wave" of computing would be – the internet. The team then divulged into the realms of creating the same embeddable technology to be used in the web browser space calling it an applet – a small application. The team now needed a proper identity and they decided on naming the new technology they created Java ushering a new generation of products for the internet boom. A by-product of the project was a cartoon named "Duke" created by Joe Parlang which became its identity then.

Finally at the SunWorld^TM conference, Andreesen unveiled the new technology to the masses. Riding along with the explosion of interest and publicity in the Internet, Java quickly received widespread recognition and expectations grew for it to become the dominant software for browser and consumer applications.^[2]

Recent history

Initially Java was owned by Sun Microsystems, but later it was released to open source;^{[citation needed]} the term Java was a trademark of Sun Microsystems. Sun released the source code for its HotSpot Virtual Machine and compiler in November 2006, and the most of the source code of the class library in May 2007. Some parts were missing because they were owned by third parties, not by Sun Microsystems. The released parts were published under the terms of the GNU General Public License, a free software license.

Versions

Unlike C and C++, Java's growth is pretty recent. Here, we'd quickly go through the development paths that Java took with age.

Development of Java over the years. From version 1.0 to version 1.7, Java has displayed a steady growth.

Initial Release (versions 1.0 and 1.1)

Introduced in 1996 for the Solaris, Windows, Mac OS Classic and Linux, Java was initially released as the Java Development Kit 1.0 (JDK 1.0). This included the Java runtime (the virtual machine and the class libraries), and the development tools (e.g., the Javac compiler). Later, Sun also provided a runtime-only package, called the Java Runtime Environment (JRE). The first name stuck, however, so usually people refer to a particular version of Java by its JDK version (e.g., JDK 1.0).

Java 2 (version 1.2)

Introduced in 1998 as a quick fix to the former versions, version 1.2 was the start of a new beginning for Java. The JDKs of version 1.2 and later versions are often called Java 2 as well. For example, the official name of JDK 1.4 is The Java(TM) 2 Platform, Standard Edition version 1.4.

Major changes include:

• Rewrite the event handling (Add Event Listeners)
• Change Thread synchronizations
• Introduction of the JIT-Just in time compilers

Java 2 Extensions (versions 1.3 [2000] to 1.4.0 [2002])

The language as such has been stable since JDK 1.0; the class libraries that come with the JDK got larger and have changed in some parts. Extensions and architectures closely tied to the Java programming language include: J2EE, J2ME, JNDI, JSML, JDBC, JAIN, JDMK, Jini,ytryy Jiro, JXTA, JavaSpaces, JMI.

Tiger (version 1.5.0; Java SE 5)

Released in September 2004

Major changes include:

• Generics - Provides compile-time type safety for collections :and eliminates the drudgery of casting.
• Autoboxing/unboxing - Eliminates the drudgery of manual conversion between primitive types (such as int) and wrapper types (such as Integer).
• Enhanced for - Shorten the for loop with Collections use.
• Static imports - Lets you import all the static part of a class.
• Annotation/Metadata - Enabling tools to generate code and deployment descriptors from annotations in the source code. This leads to a "declarative" programming style where the programmer says what should be done and tools emit the code to do it. Annotations can be inspected through source parsing or by using the additional reflection APIs added in Java 5.
• JVM Improvements - Most of the run time library is now mapped into memory as a memory image, as opposed to being loaded from a series of class files. Large portion of the runtime libraries will now be shared among multiple JVM instances.

(from [1])

Mustang (version 1.6.0; Java SE 6)

Released on 11 December 2006.^[3]

What's New in Java SE 6:

• Web Services - First-class support for writing XML web service client applications.

• Scripting - You can now mix in JavaScript technology source code, useful for prototyping. Also useful when you have teams with a variety of skill sets. More advanced developers can plug in their own scripting engines and mix their favorite scripting language in with Java code as they see fit.

• Database - No more need to find and configure your own JDBC database when developing a database application! Developers will also get the updated JDBC 4.0, a well-used API with many important improvements, such as special support for XML as an SQL datatype and better integration of Binary Large OBjects (BLOBs) and Character Large OBjects (CLOBs) into the APIs.

• More Desktop APIs - GUI developers get a large number of new tricks to play like the ever popular yet newly incorporated SwingWorker utility to help you with threading in GUI apps, JTable sorting and filtering, and a new facility for quick splash screens to quiet impatient users.

• Monitoring and Management - The really big deal here is that you don't need do anything special to the startup to be able to attach on demand with any of the monitoring and management tools in the Java SE platform.

• Compiler Access - Really aimed at people who create tools for Java development and for frameworks like JavaServer Pages (JSP) or Personal Home Page construction kit (PHP) engines that need to generate a bunch of classes on demand, the compiler API opens up programmatic access to javac for in-process compilation of dynamically generated Java code. The compiler API is not directly intended for the everyday developer, but for those of you deafened by your screaming inner geek, roll up your sleeves and give it a try. And the rest of us will happily benefit from the tools and the improved Java frameworks that use this.

• Pluggable Annotations - ???

• Desktop Deployment - At long last, Java SE 6 unifies the Java Plug-in technology and Java WebStart engines, which just makes sense. Installation of the Java WebStart application got a much needed makeover.

• Security - Java SE 6 has simplified the job of its security administrators by providing various new ways to access platform-native security services, such as native Public Key Infrastructure (PKI) and cryptographic services on Microsoft Windows for secure authentication and communication, Java Generic Security Services (Java GSS) and Kerberos services for authentication, and access to LDAP servers for authenticating users.

• The -lities: Quality, Compatibility, Stability - Bug fixes ...

Dolphin (version 1.7.0; Java SE 7)

Anticipated for 2010

Citations

How to use this book

Java Programming Print version

Java Overview

The Java Platform

Java Overview

Java Programming Print version

Java Programming Environment

Points to ponder
The newer versions of Java, i.e., version 6.0 and 7.0 are being developed and are known by their code-names Mustang and Dolphin respectively.

You can test-ride their nightly builds, available online via the given links.

The Java platform is the name for a computing environment, or platform, from Sun Microsystems which can run applications developed using the Java programming language and set of development tools. In this case, the platform is not a specific hardware or operating system, but rather an execution engine called a virtual machine, and a set of standard libraries which provide common functionality.

The platform is properly called the Java 2 Platform (although the "2" is to be dropped [2]), and includes a Standard Edition or J2SE (now Java SE), an Enterprise Edition or J2EE (now Java EE), and a Micro Edition or J2ME (now Java ME). The current version of the Java 2 platform is alternatively specified as version 1.6 or version 6 (both refer to the same version). A good overview of the myriad of technologies that makes up the Java 2 Platform can be found on the JDK Documentation Page.

Java technologies

The Java platform consists of a wide array of technologies, each of which provides a distinct portion of the overall development or runtime environment. For example, end-users typically interface with the Java virtual machine and the standard set of class libraries. In addition, there are numerous ways for Java applications to be deployed, including being embedded into a web page. Lastly, developers who are creating applications for the platform use a set of development tools called the Java Development Kit.

Java Runtime Environment

A program targeting the Java platform needs two components to be present on its host: a Java virtual machine, and a set of class libraries providing any services on which it depends. Sun's distribution of their JVM and their implementation of the standard classes is known as the Java Runtime Environment (JRE).

Java Virtual Machine

The heart of the Java platform is the concept of a common "virtual" processor that executes Java bytecode programs. This bytecode is the same no matter what hardware or operating system the program is running under. The Java platform provides an interpreter called the Java virtual machine (JVM), which translates the Java bytecode into native processor instructions at run-time. This permits the same application to be run on any platform that has a virtual machine available.

Since JRE version 1.2, Sun's JVM implementation has also included a just-in-time compiler. Instead of interpreting the bytecode one instruction at a time, this converts the bytecode for a program into equivalent native machine code as the program is loaded into the virtual machine, allowing it to execute much faster at the cost of a small delay whenever new bytecode is loaded. This allows the JIT compiler to target a specific host platform and hardware, even potentially optimizing the output code in different ways based on observations of the program's behaviour.

This is not to say that one can truly compile Java code to its fullest extent (in order to reap the benefits of speedy native machine code). Yes, there are "compilers" available that will attempt this feat, but not all Java libraries have a machine code equivalent. For instance, the "reflect" library, which allows Java programmers to delve into instructions only available at runtime, is not well represented (if at all) by machine code.

Java was not the first virtual-machine-based platform, though it is by far the most successful and well-known. Previous uses for virtual machine technology primarily involved emulators to aid development for not-yet-developed hardware or operating systems, but the JVM was designed to be implemented entirely in software, while making it easy to efficiently port an implementation to hardware of all kinds.

Class libraries

In most modern operating systems, a large body of reusable code is provided to simplify the programmer's job. This code is typically provided as a set of dynamically loadable libraries that applications can call at runtime. Because the Java platform is not dependent on any specific operating system, applications cannot rely on any of the existing libraries. Instead, the Java platform provides a comprehensive set of standard class libraries, containing much of the same reusable functions commonly found in modern operating systems.

The Java class libraries serve three purposes within the Java platform. Like other standard code libraries, they provide the programmer with a well-known set of functions to perform common tasks, such as maintaining lists of items or performing complex string parsing. In addition, the class libraries provide an abstract interface to tasks that would normally depend heavily on the hardware and operating system. Tasks such as network access and file access are often heavily dependent on the native capabilities of the platform. The Java java.net and java.io libraries implement the required native code internally, then provide a standard interface for the Java applications to perform those tasks. Finally, some underlying platforms may not support all of the features a Java application expects. In these cases, the class libraries can either emulate those features using whatever is available, or provide a consistent way to check for the presence of a specific feature.

Languages

The word Java, by itself, usually refers to the Java programming language which was designed for use with the Java platform. Programming languages are typically outside of the scope of the phrase "platform". However, Sun does not encourage the use of any other languages with the platform, and lists the Java programming language as a core part of the Java 2 platform. The language and runtime are therefore commonly considered a single unit.

Nevertheless, third parties have produced a number of compilers which target the JVM. Some of these are for existing languages, while others are for extensions to the Java language itself. These include:

• Groovy
• Pizza
• GJ (Generic Java), which was incorporated into official Java as of Sun's version 1.5.
• NetREXX

Another option is to use a more interface approach like the Jython.

Similar Platforms

The success of Java and its write once, run anywhere concept has also led to other similar efforts. The most notable of these is the Microsoft .NET platform, which borrows many of the concepts and innovations of Java; in fact, it has an implementation of a Java-like language called Visual J# (formerly known as J++). (It is Java-like in that J# is not the Java language. Instead, J# contains non-standard extensions of the language.)

Later Microsoft stopped, withdrew its J# support, and created a new language called C#. C# is very similar to J# and Java, but not compatible with them. The differences between Java and C# can be read at w:Comparison of C Sharp and Java.

Java Programming Environment

The Java Platform

Java Programming Print version

Getting Started

To compile Java programs, you will need to download and install the Java Development Kit (JDK). This is available from Sun's website. Other hardware and operating system vendors also supply Java Development Kits for their platforms, although they may change the name of the kit. Sun produces JDKs for Windows, Linux, and Solaris.

There are numerous environments you can use to develop your Java programs. You can choose to write your programs in a text editor and then compile them using the command line, or you can use an integrated development environment (IDE). IDEs like NetBeans and Eclipse provide many useful functions such as syntax error checking, code completion, automatic compilation and debugging, which you may find useful, especially if this is your first foray into programming.

The Java Compiler

The JDK consists of a set of tools necessary to construct Java programs. The most notable tool in the JDK is the Java compiler, also known as javac.

javac compiles Java source files into executable Java class files. Source files are text files with a .java file name extension. You can create such files with a text editor, like Notepad, or an IDE. javac then compiles these files into loadable and executable class files, using the .class extension. For example, if you create a Java class org/wikibooks/util/PrintDate.java

package org.wikibooks.util;
import java.util.Date;
public class PrintDate 
{
    public static void main(String[] args) 
    {
        System.out.println(new Date());
    }
}

you can compile it by entering the following command in a command shell:

javac org/wikibooks/util/PrintDate.java

You would normally invoke this in a shell whose working directory is the root directory containing all of your source files resides. (The Java package statement, package org.wikibooks.util, corresponds to the directory structure org/wikibooks/util see Java packages.)

javac will create the file PrintDate.class in the same directory where the source file is located. If there are syntax errors, javac will print those to the shell. The PrintDate.class file contains the byte code, that will run under all hardware where the Java runtime is installed. Even if the PrintDate.class file was created in Windows operating system, you can copy this file to unix and it will be executed fine.

Usually there is more than one class file created and those files are packaged to a application_name.jar file to distribute to run in any hardware.

IDEs may manage this process automatically. For example, Eclipse contains its own Java compiler and thus does not use javac directly. It automatically compiles the Java source files when you save them. The use of IDE's such as Eclipse are beyond the scope of this module, however, so consult the IDE's tutorials and help to see how they provide a Java programming environment.

The bytecode

It should be clear from the above paragraph that the Java compiler compiles source code text files with the extension .java into executable code usually confined into a class file with the .class extension. Such code is called Bytecode.

In many languages prior to Java, the source code would generally compile into the machine-code for the particular machine the program was compiled upon. Therefore, if a program was compiled on an X86 machine, it would run only on an X86 machine and no other. Java, on the other hand, produces a bytecode - an intermediate binary form of code that is a portable representation of the Java class. Any Java Virtual Machine on any hardware/operating system platform can then execute this same bytecode. There are some restrictions to this portability. For example, a Java ME system cannot execute all programs compiled for the Java SE environment because Java ME is pared down to small devices. But in general, a Java SE program can run unmodified on any Java SE virtual machine.

The JIT compiler

Being compiled halfway through, it is the job of the Java Virtual Machine to compile the rest of the program to native code at the time of its execution making Java code follow the "Write Once, Run Anywhere" (WORA) policy. The compiler used to compile bytecode into machine-code at runtime is called the Just-In-Time or JIT compiler. Once a piece of code is compiled by the JVM to execution code, the code is used and re-used again and again, to speed up execution.

The Java Runtime Environment

The Java Runtime Environment, or JRE, is responsible for the execution of Java programs. The Sun JDK also includes the JRE. The JRE however can also be installed and used without installing the JDK which is useful if you wish to execute Java programs but not build them. The JRE helps load Java programs into the memory and executes them.

Main entry point

In Java programming, classes are used to define objects and entities that hold particular data. To execute a Java program, a special class is required to assist in loading the program into the computer's memory. Such a class contains a method with the following signature.

public static void main(String[] args) {...}

The class is hence said to have a main entry point defined and is usually called a Java program. The method described above as the main entry point is usually nicknamed the main method. Java classes without main methods are simply classes, although they may be part of a program.

Each Java class can have a main method, as opposed to C, and C++ where there can only be one, for the whole program. This feature is good in a sense that the main method can be implemented be a simple test, that is to do some testing on the class. So the program must define one class's main method to the entry point for the program.

Executing a command-line Java program

If a class which you compile with javac has a main entry point, you can execute the class by specifying the class name as an argument to the java program.

java org.wikibooks.util.PrintDate

This will run the main method in the PrintDate class in the org.wikibooks.util package. (Packages provide a convenient way to provide namespaces and organization of Java classes. We'll use org.wikibooks.util as a parent package in this module. More on packages.)

Your program will begin execution in the shell window. Inputs and outputs will be gathered from and to your shell window. On a Windows platform, you can use a DOS command window as the command shell program for the execution of Java programs. The JRE is normally called java because the java program is the most widely used program to execute Java programs.

Executing a Graphical User Interface Java program

On the Windows platform, there is an alternate JRE executable called javaw.exe or javaw which runs Java programs as a Windows native application - that is, with no console for standard input or output.

javaw org.wikibooks.util.ViewDate

Rather than executing in the console, the Java program would be executed in a separate Windows native process. This is typically done for Java applications which create their own graphical user interface (GUI) windows. The above-mentioned org.wikibooks.util.PrintDate program, which prints output to the standard output stream, is not appropriate for use with javaw as there is no console output. Instead, org.wikibooks.util.ViewDate would be a program which creates its own windows to display the date.

As with java, IDE's also manage the execution of Java programs in slightly different ways. They may provide shortcuts for running programs and windows for capturing the output.

On UNIX/Linux this does not matter. If the program is launched graphically (by file association in a file manager) a console is not shown. GUI programs will have the titlebars following the look and feel of your desktop (KDE, GNOME, Fluxbox, XFCE) theme.

Other JDK tools

Apart from the tools specified above in detail, the JDK has matured over the years and has included in itself several other tools. Where some of these tools are no longer used, others offer a far greater deal of capability to the Java Development Kit. Below is a list of some of the tools available for the JDK.

The apt tool

In Java 1.5 (alias Java 5.0) Sun added a mechanism called annotations. Annotations allow to add meta-data to Java source code, and even provide mechanisms to carry that meta-data forth into a compiled class files.

Also starting with Java 1.5 Sun added the apt tool to the JDK. apt works on Java source code. It is an annotation processing tool which digs through source code, finds annotation statements in the source code and executes actions if it finds known annotations. The most common task is to generate some particular source code.

The actions apt performs when finding annotations in the source code are not hard-coded into apt. Instead, one has to code particular annotation handlers (in Java). These handlers are called annotation processors.

The most difficult thing with apt is that Sun decided to use a whole set of new terminology. apt can simply be seen as a source code preprocessor framework, and annotation processors are typically just code generators.

See also: [http://java.sun.com/j2se/1.5.0/docs/guide/apt/GettingStarted.html Getting Started with the Annotation Processing Tool (apt)]

The appletviewer tool

Java applets require a particular environment to execute. Typically, this environment is provided by a browser with a Java plug-in, and a web server serving the applet. However, during development and testing of an applet it might be more convenient to start an applet without the need to fiddle with a browser and a web server. In such a case, Sun's appletviewer from the JDK can be used to run an applet.

The javah tool

A Java class can call native, or non-Java, code that has been prepared to be called from Java. The details and procedures are specified in the JNI (Java Native Interface). Commonly, native code is written in C (or C++). The JDK tool javah helps to write the necessary C code, by generating C header files and C stub code.

The extcheck tool

extcheck also appeared first with Java 1.5. It can be used prior to the installation of a Java extension into the JDK or JRE environment. It checks if a particular Jar file conflicts with an already installed extension.

Security Tools

The JDK comes with a large number of tools related to the security features of Java. Usage of these tools first requires study of the particular security mechanisms.

The tools are:

keytool

To manage keys and certificates

jarsigner

To generate and verify digital signatures of JARs (Java ARchives)

policytool

To edit policy files

kinit

To obtain Kerberos v5 tickets

klist

To manage Kerberos credential cache and key table

ktab

To manage entries in a key table

The native2ascii tool

native2ascii is an important, though underappreciated, tool for writing properties files -- files containing configuration data -- or resource bundles -- files containing language translations of text.

Such files can contain only ASCII and Latin-1 characters, but international programmers need a full range of character sets. Text using these characters can appear in properties files and resource bundles only if the non-ASCII and non-Latin-^1 characters are converted into Unicode escape sequences (\uXXXX notation).

The task of writing such escape sequences is handled by native2ascii. You can write the international text in an editor using the appropriate character encoding, then use native2ascii to generate the necessary ASCII text with embedded Unicode escape sequences. Despite the name, native2ascii can also convert from ASCII to native, so it is useful for converting an existing properties file or resource bundle back to some other encoding.

native2ascii makes most sense when integrated into a build system to automate the conversion.

RMI Tools

This section is a stub. You can help Wikibooks by expanding it.

Java IDL and RMI-IIOP Tools

This section is a stub. You can help Wikibooks by expanding it.

Deployment & Web Start Tools

This section is a stub. You can help Wikibooks by expanding it.

Browser Plug-In Tools

This section is a stub. You can help Wikibooks by expanding it.

Monitoring and Management Tools / Troubleshooting Tools

With Java 1.5 a set of monitoring and management tools have been added to the JDK, in addition to a set of troubleshooting tools.

The monitoring and management tools are intended for monitoring and managing the virtual machine and the execution environment. They allow, for example, monitoring memory usage during the execution of a Java program.

The troubleshooting tools provide rather esoteric insight into aspects of the virtual machine. (Interestingly, the Java debugger is not categorized as a troubleshooting tool.)

All the monitoring and management and troubleshooting tools are currently marked as "experimental" (which does not affect jdb). So they might disappear in future JDKs.

The Jar tool

Jar is short for Java archive. It is a tool for creating Java archives or jar files - a file with .jar as the extension. A Java archive is a collection of compiled Java classes and other resources which those classes may require (such as text files, configuration files, images) at runtime. Internally, a jar file is really a .zip file.

The jdb tool

Jdb is short for Java debugger. The Java debugger is a command-line console that provides a debugging environment for Java programs. Although you can use this command line console, IDE's normally provide easier to use debugging environments.

The Javadoc tool

As programs grow large and complex, programmers need ways to track changes and to understand the code better at each step of its evolution. For decades, programmer have been employing the use of special programming constructs called comments - regions that help declare user definitions for a code snippet within the source code. But comments are prone to be verbose and incomprehensible, let alone be difficult to read in applications having hundreds of lines of code.

Java provides the user with a way to easily publish documentation about the code using a special commenting system and the javadoc tool. The javadoc tool generates documentation about the w:application programming interface (API) of a set of user-created Java classes. javadoc reads source file comments from the .java source files and generates HTML documents that are easier to read and understand without looking at the code itself.

The javap tool

Where Javadoc provide a detailed view into the API and documentation of a Java class, the javap tool prints information regarding members (constructors, methods and variables) in a class. In other words, it lists the class' API and/or the compiled instructions of the class. javap is a formatting disassembler for Java bytecode.

See other tools for all the tools that are bundled with Sun's JDK.

Installation

Getting Started

Java Programming Print version

Compiling programs

To formally begin programming in Java, you would need to obtain the Java software necessary and install it on your system. This section will help you set up any system with the latest Java software.

Obtaining Java software

For now, a text editor should be the least of your worries. What matters the most is to get your hands on the two main components required for Java programming: the compiler and the JVM. The compiler comes bundled with other useful programs for you to use. This bundle of programs is called the Java Development Kit (or JDK). On the other hand, the JVM also comes bundled with exciting up-to-date features called the Java Runtime Environment (or JRE). For more in-depth detail, read the section on the Java Platform. Unlike most other computer programming environments, the complete Java platform (both JDK and JRE) is free to download from Sun Microsystem's website - http://java.sun.com/javase/downloads/index.jsp

Clicking on website link above, you would be taken to a download page giving you an option to download the various components needed for Java programming. If you feel you don't have enough space for both the software to be installed on your system (which is highly unlikely) you should, in that case, opt only for the JDK as that is the only component necessary to build a complete Java program. The JDK comes with its very own JRE. With that said, once the software is downloaded and installed on the system, we can begin with the rest.

Setting up the environment

Once you have Java installed on your system, we just need to worry about writing the actual code. This is done using a text editor - Notepad or WordPad would do. But these editors can only provide you with a limited ability to write text and save files. You need to make your editor do lots of other stuff as well, like compiling the code for you, showing you how the code works and telling you off when you write wrong code. A text editor that can do all that is called an integrated development environment (in short IDE). There are a dozen IDEs to choose from and the good news is - most of them are free to download and install. Some IDEs worth mentioning are:

1. Eclipse: This is a powerful IDE that supports Java and many other programming languages like C/C++, PHP and Python. It is open source and free to download, install and use. Since Eclipse is open source, it has a strong user base and you can find a lot of people online who can tell you how to work the IDE.
2. NetBeans: Like Eclipse, NetBeans is also an integrated development environment that support various languages other than Java but the plus point for this IDE is that it is built by the people who made the Java language. And it is free, too!

External Links

• Sun's website
• Java.Net JDK repository

Compilation

Installing Java on Your Computer

Java Programming Print version

Running Java programs

We have already discussed compilation basics . Here's a recap of the concepts we'd seen earlier and some additional details.

Compiling to bytecode

In Java, programs are not compiled into executable files; they are compiled into Bytecode (as discussed earlier), which the JVM then executes at runtime. Java source code is compiled into bytecode when we use the javac compiler. The bytecode gets saved on the disk with the file extension .class. When the program is to be run, the bytecode is converted, using the Just-In-Time(JIT) compiler. The result is machine code which is then fed to the memory and is executed.

So Java has two step compilation:

• Step one to create byte-code
• Step two to create machine level code

The Java classes/Byte Codes are compiled to machine code and loaded into memory by the JVM when needed the first time. This is different than other languages like C/C++ where the whole program had to be compiled to machine code and linked to create an executable file, before the program could start.

JIT compilers compile byte-code once and the compiled machine code are re-used again and again, to speed up execution. Early Java compilers compiled the byte-code to machine code each time it was used, but more modern compilers cache this machine code for reuse on the machine. Even then, java's JIT compiling was still faster than an "interpreter-language", where code is compiled from high level language, instead of from byte-code each time it was used.

Automatic Compilation of Dependent Classes

In Java, if you have used any reference to any other java object, then the class for that object will be automatically compiled, if that was not compiled already. These automatic compilations are nested, and this continues until all classes are compiled that are needed to run the program. It is usually enough to compile only the high level class, since all the dependent classes will be automatically compiled.

javac ... MainClass.java

However, you can't rely on this feature if your program is using reflection to create objects, or you are compiling for servlets or a "jar" package. In these cases you should list these classes for explicit compilation.

javac ... MainClass.java, ServletOne.java, ...

The best way is to use a build tool to build your application. The build tool would check all the needed dependencies and compile only the needed class for the build. The Ant tool is the best and the most popular build tool currently available. Using Ant you would build your application from the command line by typing:

ant build.xml

The xml file contains all the information needed to build the application.

Note: In rare cases, your code may appear to compile correctly but the program behaves as if you were using an old copy of the source code (or otherwise reports errors during runtime.) When this occurrs, you may need to clean your compilation folder by either deleting the class files or using the Clean command from the IDE.

The next most popular way to build applications are using an IDE. IDE stands for Integrated Development Environment, examples of which are listed below.

Packages and Subdirectories

Each Java top level class belongs to a package (covered in the chapter about Packages). This may be declared in a package statement at the beginning of the file; if that is missing, the class belongs to the unnamed package.

For compilation, the file must be in the right directory structure. A file containing a class in the unnamed package must be in the current-root directory; if the class belongs to a package, it must be in a directory with the same name as the package.

The convention is that package names and directory names corresponding to the package consist of only lower case letters.

Examples

Top level package

A class with this package declaration

package example;

has to be in a directory named

example

Subpackages

A class with this package declaration

package org.wikibooks.en;

has to be in a directory named

en

which has to be a sub-directory of

wikibooks

which in turn has to be a sub-directory of

org

resulting in

org/wikibooks/en

Filename Case

The Java source file name must be the same as the public class name, the file contains. There can be only one public class defined per file. The Java class name is case sensitive, as is the source file name.

The naming convention for the class name is for it to start with a capital letter.

Compiler Options

Debugging and Symbolic Information

Additional Tools

IDEs

This section contains a little about the different IDEs available and their strengths and weaknesses.

JBuilder

JBuilder is a IDE with proprietary source code, sold by Borland. One of the advantages in integration with together, a modeling tool.

JCreator

There's info at: http://www.apcomputerscience.com/ide/jcreator/index.htm

Eclipse

Eclipse is a free IDE, plus a developer tool framework that can be extended for a particular development need. IBM was behind this free software development and it replaced IBM Visual Age tool. The idea was to create a standard look and feel that can be extended. The extendibility has distinguished Eclipse from other IDE tools. Eclipse also meant to compete with Microsoft Visual Studio tools. Microsoft tools give a standard way of developing code in the Microsoft world. Eclipse gives a similar standard way of developing code in the Java world, with big success so far. With the online error checking only, coding can be speed up by at least 50%(coding does not include programming).

The goal for Eclipse are twofold:

• Give a standard IDE for developing code
• Give a starting point, and the same look and feel for all other more sophisticated tools build on Eclipse

IBM's WSAD, and later IBM Rational Software Development Platform are built on Eclipse.

Standard Eclipse features:

• Standard window management (perspectives, views, browsers, explorers, ...)
• As you type error checking (immediate error indications, ...)
• As you type help window (type ., or <ctrl> space, ...)
• Automatic build (changed source code automatically compiled, ...)
• Built in debugger (full featured GUI debugger)
• Source code generation (getters and setters, ...)
• Searches (for implementation, for references, ...)
• Code refactoring (global reference update, ...)
• Plug-in-based architecture (be able to build tools that integrate seamlessly with the environment and other tools)
• ...

For more information see;

• [Eclipse ].
• [Plugincentral]

NetBeans

The NetBeans IDE is a free, open-source Integrated Development Environment for software developers. The IDE runs on many platforms including Windows, Linux, Solaris, and the MacOS. It is easy to install and use straight out of the box. The NetBeans IDE provides developers with all the tools they need to create professional cross-platform desktop, enterprise, web and mobile applications.

More info can be found at http://www.netbeans.org/products/ide/

BlueJ

BlueJ is an IDE that includes templates and will compile and run the applications for you. BlueJ is often used by classes because it is not necessary to set classpaths. BlueJ has it's own sets of Library's and you can add your own under preferences. That sets the classpath for all compilations that come out of it to include those you have added and the BlueJ libraries.

BlueJ offers an interesting GUI for the creation of packages and programs. Classes are represented as boxes with arrows running between them to represent inheritance/implementation or if one is constructed in another. BlueJ adds all those classes (the project) into the classpath at compile time.
BlueJ Homesite

Kawa

Kawa was developed by Tek-Tools. It is basically a Java editor which does not include wizards, and GUI tools. It is best suited to experienced Java programmers in small and midsized development teams.

The latest version is 4.0, you can download it. For more info. see Kawa from tek-tools. See a javaworld article

It looks that there is no new development for Kawa.

Ant

Ant is a build management tool designed to replace MAKE as the tool for automated builds of large Java applications. Like Java, and unlike MAKE, Ant is designed to be platform independent.

Building a Java application requires certain tasks to be performed. Those tasks may include not only to compile the code, but also to copy code, to package the code to Jar, to create EJBs, to run automated tests, to ftp the code to remote site, and so on. For some tasks a condition can be assigned, for example a compile only changed code, or do the task if that was not already done so. Tasks dependency can also be specified, that will make sure that the order of executions of the tasks are in the right order. For example compile the code before package them to jar, the package-to-jar task depend on the compilation task.

The tasks and their dependencies are defined in a "build.xml" file. The Ant program will parse it and do whatever it describes. The Ant tool is much more powerful than the MAKE tool. Because of the java codes are spread out in the file system according the java package(name space), the use a MAKE tool feels very awkward.

Also the Ant tool is written in Java and can be extended, so if there is a task you'd like to be done during the build, and the task is not in the pre-defined tasks list, you can write it yourself. It is very easy to hook your ant task code to the other tasks, you code only needs to be in the classpath, and the Ant tool will load it during runtime. Your ant task code has to follow the Ant framework, that's all.

A wikibook on ant usage is available at Programming:Apache Ant. The Ant project website : [ant.apache.org]

The JIT compiler

The standard JIT compiler runs on demand. When a method is called repeatedly, the JIT compiler analyzes the bytecode and produces highly efficient machine code, which runs very fast. The JIT compiler is smart enough to recognize when the code has already been compiled, so as the application runs, compilation happens only as needed. As Java applications run, they tend to become faster and faster, because the JIT can perform runtime profiling and optimization to the code to meet the execution environment. Methods or code blocks which do not run often receive less optimization; those which run often (so called hotspots) receive more profiling and optimization.

Template:Java Programming Nav

Execution

Compiling programs

Java Programming Print version

Developing the first Java program

There are various ways Java code can be executed. A complex Java application are usually using third party APIs or services. In this section we list the most popular way a piece of Java code may be packed together and/or executed.

JSE code execution

Java language first edition came out in the client-server era. Thick clients were developed with rich GUI interfaces. Java first edition, JSE(Java Standard Edition) had/has the following in its belt:

• GUI capabilities (AWT, Swing)
• Network computing capabilities (RMI)
• Multi-tasking capabilities (Threads)

With JSE the following Java code executions are possible:

Figure 1: Stand alone execution

Stand alone Java application 

(Figure 1) Stand alone application refers to a Java program where both the user interface and business modules are running on the same computer. The application may or may not use a database to persist data. The user interface could be either AWT or Swing.

The application would start with a main() method of a Class. The application stops when the main() method exits, or if an exception is thrown from the application to the JVM. Classes are loaded to memory and compiled as needed, either from the file system or from a *.jar file, by the JVM.

Invocation of Java programs distributed in this manner requires usage of the command line. Once the user has all the class files, he needs to launch the application by the following command line (where Main is the name of the class containing the main() method.)

       java Main

Java 'jar' class libraries 

Utility classes, framework classes, and/or third party classes are usually packaged and distributed in Java ' *.jar' files. These 'jar' files need to be put in the CLASSPATH of the java program from which these classes are going to be used.

If a jar file is executable, it can be run from the command line:

       java -jar Application.jar

Figure 2: Applet Execution

Java Applet code 

(Figure 2) Java Applets are Java code referenced from HTML pages, by the <APPLET> tag. The Java code is downloaded from a server and running in the client browser JVM. Java has built in support to render applets in the browser window.

Sophisticated GUI clients were found hard to develop mostly because of the download time, incompatibilities between browser's JVM, and its communication requirements back to the server. Applets are rarely used today, and are most commonly used as small separate graphic-like animation applets. The popularity of Java declined when Microsoft withdrew its Java support from Internet Explorer default configuration, however, the plugin is still available as a free download from java.com.

More information can be found about applets at the Applet Chapter, in this book. Also, Wikipedia has an article about Java Applets.

Client Server applications 

The client server applications consist of a front-end, and a back-end part, both running on a separate computer. The idea is that the business logic would be on the back-end part of the program, which would be reused by all the clients. Here the challenge is to achieve a separation between front-end user interface code, and the back-end business logic code.

The communication between the front-end and the back-end can be achieved by two ways.

• One way is to define a data communication protocol between the two tiers. The back-end part would listen for an incoming request. Based on the protocol it interprets the request and sends back the result in data form.
• The other way is to use Java Remote Invocation(RMI). With the use of RMI, a remote object can be created and used by the client. In this case Java objects are transmitted across the network.

More information can be found about client-server programming, with sample code, at the Client Server Chapter in this book.

Web Applications 

For applications needed by lots of client installations, the client-server model did not work. Maintaining and upgrading the hundreds or thousands of clients caused a problem. It was not practical. The solution to this problem was to create a unified, standard client, for all applications, and that is the Browser.

Having a standard client, it makes sense to create a unified, standard back-end service as well, and that is the Application Server.

Web Application is an application that is running in the Application Server, and it can be accessed and used by the Browser client.

There are three main area of interest in Web Applications, those are:

• The Web Browser. This is the container of rendering HTML text, and running client scripts
• The HTTP protocol. Text data are sent back and forth between Browser and the Server
• The Web server to serve static content, Application server to serve dynamic content and host EJBs.

Wikipedia also has an article about Web application.

J2EE code execution

As the focus was shifting from reaching GUI clients to thin client applications, with Java version 2, Sun introduced J2EE(Java 2 Extended Edition). J2EE added :

• Components Base Architecture, (Servlet,JSP,EJB Containers)

With J2EE the following Java component executions are possible:

Figure 3: Servlet Execution

Java Servlet code 

(Figure 3) Java got its popularity with server side programming, more specifically with J2EE servlets. Servlets are running in a simple J2EE framework to handle client HTTP requests. They are meant to replace CGI programming for web pages rendering dynamic content.

The servlet is running in a so called servlet-container/web container. The servlet's responsibility is to:

• Handle the request by doing the business logic computation,
• Connecting to a database if needed,
• Create HTML to present to the user through the browser

The HTML output represents both the presention logic and the results of the business computations. This represents a huge problem, and there is no real application relying only on servlets to handle the presention part of the responsibility. There are two main solutions to this:

• Use a template tool (Store the presentation part in an HTML file, marking the areas that need to be replaced after business logic computations).
• Use JSP (See next section)

Wikipedia also has an article about Servlets.

Figure 4: Jsp Execution

Java Server Pages (JSP) code 

(Figure 4) JSP is an HTML file with embedded Java code inside. The first time the JSP is accessed, the JSP is converted to a Java Servlet. This servlet outputs HTML which has inside the result of the business logic computation. There are special JSP tags that helps to add data dynamically to the HTML. Also JSP technology allows to create custom tags.

Using the JSP technology correctly, business logic computations should not be in the embedded Java part of the JSP. JSP should be used to render the presentation of the static and dynamic data. Depending on the complexity of the data, 100% separation is not easy to achieve. Using custom tags, however may help to get closer to 100%. This is advocated also in MVC architecture(see below).

Figure 5: EJB Execution

EJB code 

(Figure 5) In the 1990s, with the client server computing, a trend started, that is to move away from Mainfraim computing. That resulted in many small separate applications in a Company/Enterprise. Many times the same data was used in different applications. A new philosophy, "Enterprise Computing", was created to address these issues. The idea was to create components that can be reused throughout the Enterprise. The Enterprise Java Beans (EJBs) were supposed to address this.

An EJB is an application component that runs in an EJB container. The client accesses the EJB modules through the container, never directly. The container manages the life cycle of the EJB modules, and handles all the issues that arise from network/enterpise computing. Some of those are security/access control, object pooling, transaction management, ... .

EJBs have the same problems as any reusable code: they need to be generic enough to be able to be reused and the changes or maintenance of EJBs can affect existing clients. Many times EJBs are used unnecessarily when they are not really needed. An EJB should be designed as a separate application in the enterprise, fulfilling one function.

Figure 6: MVC Execution

Combine J2EE components to create an MVC architecture 

This leads us to the three layers/tiers as shown in (Figure 6).

In modern web applications, with lots of static data and nice graphics, how the data is presented to the user became very important and usually needs the help of a graphic artist.

To help programmers and graphic artists to work together, the separation between data, code, and how it is presented became crucial.

• The view (User Interface Logic) contains the logic that is necessary to construct the presentation. This could be handled by JSP technology.
• The servlet acts as the controller and contains the logic that is necessary to process user events and to select an appropriate response.
• The business logic (model) actually accomplishes the goal of the interaction. This might be a query or an update to a database. This could be handled by EJB technology.

For more information about MVC, please see MVC.

JINI

After J2EE Sun had a vision about the next step of network computing. That is JINI. The main idea is that in a network environment, there would be many independent services and consumers. JINI would allow these services/consumers to interact dynamically with each other in a robust way. The basic features of JINI are:

• No user intervention is needed when services are brought on or offline. (In contrast to EJBs where the client program has to know the server and port number where the EJB is deployed, in JINI the client is supposed to find, to discover, the service in the network.)
• Self healing by adapting when services(consumers of services) come and go. (Services periodically need to renew a lease to indicate that they are still available.)
• Consumers of JINI services do not need prior knowledge of the service's implementation. The implementation is downloaded dynamically and run on the consumer JVM, without configuration and user intervention. (For example, the end user may be presented with a slightly different user interface depending upon which service is being used at the time. The implementation of the user interface code would be provided by the service being used.)

A minimal JINI network environment consists of:

• One or more services
• A lookup-service keeping a list of registered services
• One or more consumers

JINI is not widely used at the current writing (2006). There are two possible reasons for it. One is JINI a bit complicated to understand and to set it up. The other reason is that Microsoft pulled out from Java, which caused the industry to turn to the use of proprietary solutions.

First Java Program

Running Java programs

Java Programming Print version

Understanding a Java Program

Hello World

Generally when you first start programming in any language, you'll start with the traditional Hello World example. That said, let's start building your first Java program. You guessed it, it's Hello World! Before starting this exercise, make sure you know how to compile and run Java programs.

Open your IDE and write the following text. Pay close attention to capitalization, as Java is case sensitive.

public class HelloWorld {	
   public static void main(String[] args) {	
      System.out.println("Hello, world!");	
  }
}

Save it as HelloWorld.java. Again, make sure that the filename is the same case as the class name. Compile and run it:

javac HelloWorld.java
java HelloWorld

Your computer should display

Hello, world!

Line-by-line Analysis

The first line of the class,

public class HelloWorld {

declares a Java class named HelloWorld. This class is declared public - it is available to any other class. The next line,

public static void main(String[] args) {

begins a Java method named main. The main method is where Java will start executing the program. args is a method parameter which will contain the command line arguments used to run the program. The method must be both public and static for the program to run correctly. For more information on modifiers such as public and static, see Access Modifiers.

The

System.out.println("Hello, world!");

statement sends the text Hello, world! to the console (with a line terminator). The final two braces mark the end of the main method and the end of the class.

Modifying the Program

Now, we will modify this program to print the first command line argument, if there is one, along with the greeting. For example, if you invoke the program as

java HelloWorld wikibooks

it will print

Hello, wikibooks!

Go back to the program, and modify it to read

public class HelloWorld {	
   public static void main(String[] args) {	
      String who;
      if (args.length > 0) {
         who = args[0];
      } else {
         who = "World";
      }
      System.out.println("Hello, " + who + "!");	
  }
}

Run it again. It should display

Hello, wikibooks!

or, if you do not pass a command line parameter, it will simply print

Hello, World!

Wikipedia has a hello world sample for each type of java code, for more information see w:Java (programming language)#Hello World

Common Problems

If the program does not work as you expect, check the following common errors.

• Are you sure all words are spelled correctly and with the exact case as shown?
• Are there semicolons and brackets in the appropriate spot?
• Are you missing a quote? Usually, modern IDEs would try coloring the entire source as a quote in this case.
• Are you launching the javac or java correctly? Javac requires the full filename with the .java extension, while java requires the class name itself.

The Next Step

Now that you have seen the classic Hello, World program in Java, let's move on to a more realistic example which highlights the object oriented nature of Java. Visit Understanding a Java Program which presents key Java language features along with a more complete explanation of the syntax and structure of a basic Java program.

Understanding a Java Program

Developing the first Java program

Java Programming Print version

Language fundamentals

This article presents a small Java program which can be run from the console. It computes the distance between two points on a plane. You need not understand the structure and meaning of the program just yet; we will get to that soon. Also, because the program is intended as a simple introduction, it has some room for improvement, and later in the module we will show some of these improvements. But let's not get too far ahead of ourselves!

The Distance Class: Intent, Source, and Use

This class is named Distance, so using your favorite editor or Java IDE, first create a file named Distance.java, then copy the source below and paste it into the file and save the file.

 public class Distance
 {
   private java.awt.Point point0, point1;
 
   public Distance(int x0, int y0, int x1, int y1)
   {
     point0 = new java.awt.Point(x0, y0);
     point1 = new java.awt.Point(x1, y1);
   }
 
   public void printDistance()
   {
     System.out.println("Distance between " + point0 + " and " + point1 
                     + " is " + point0.distance(point1));
   }
 
   public static void main(String[] args)
   {
     Distance dist = new Distance(
              intValue(args[0]), intValue(args[1]),
              intValue(args[2]), intValue(args[3]));
     dist.printDistance();
   }
 
   private static int intValue(String data)
   {
     return Integer.parseInt(data);
   }
 }

At this point, you may wish to review the source to see how much you might be able to understand. While perhaps not being the most literate of programming languages, someone with understanding of other procedural languages such as C, or other OO languages such as C++ or C#, will be able to understand most if not all of the sample program.

Once you save the file, compile the program:

javac Distance.java

(If the javac command fails, review the Java installation instructions.)

To run the program, you supply it with the x and y coordinates of two points on a plane. (For this version of Distance, only integer points are supported.) The command sequence is

java Distance x0 y0 x1 y1

to compute the distance between the points (x₀, y₀) and (x₁, y₁)

For example, the command

java Distance 0 3 4 0

will compute the distance between the points (0,3) and (4,0) and print the following:

Distance between java.awt.Point[x=0,y=3] and java.awt.Point[x=4,y=0] is 5.0

The command

java Distance -4 5 11 19

will compute the distance between the points (-4,5) and (11,19):

Distance between java.awt.Point[x=-4,y=5] and java.awt.Point[x=11,y=19] is 20.518284528683193

We'll explain this strange looking output, and also show how to improve it, later.

Detailed Program Structure and Overview

As promised, we will now provide a detailed description of this Java program. We will discuss the syntax and structure of the program and the meaning of that structure.

Introduction to Java Syntax

The syntax of a Java class is the characters and symbols and their structure used to code the class using Unicode characters. A fuller treatment of the syntax elements of Java may be found at Syntax. We will provide here only enough description of the syntax to grasp the above program.

Java programs consist of a sequence of tokens. There are different kinds of tokens. For example, there are word tokens such as class and public which represent keywords - special words with reserved meaning in Java. Other words (non keywords such as Distance, point0, x1, and printDistance) are identifiers. Identifiers have many different uses in Java but primarily they are used as names. Java also has tokens to represent numbers, such as 1 and 3; these are known as literals. String literals, such as "Distance between ", consist of zero or more characters embedded in double quotes, and operators such as + and = are used to express basic computation such as addition or String concatenation or assignment. There are also left and right braces ({ and }) which enclose blocks. The body of a class is one such block. Some tokens are punctuation, such as periods . and commas , and semicolons ;. You use whitespace such as spaces, tabs, and newlines, to separate tokens. For example, whitespace is required between keywords and identifiers: publicstatic is a single identifier with twelve characters, not two Java keywords.

Declarations and Definitions

Sequences of tokens are used to construct the next building blocks of Java classes: declarations and definitions. A class declaration provides the name and visibility of a class. For our example,

public class Distance

is the class declaration. It consists (in this case) of two keywords, public and class followed by the identifier Distance.

This means that we are defining a class named Distance. Other classes, or in our case, the command line, can refer to the class by this name. The public keyword is an access modifier which declares that this class and its members may be accessed from other classes. The class keyword, obviously, identifies this declaration as a class. Java also allows declarations of interfaces and (as of Java 5) annotations.

The class declaration is then followed by a block (surrounded by curly braces) which provides the class's definition. The definition is the implementation of the class - the declaration and definitions of the class's members. This class contains exactly six members, which we will explain in turn.

1. Two field declarations, named point0 and point1
2. A constructor declaration
3. Three method declarations

Example: Instance Fields

The declaration

private java.awt.Point point0, point1;

declares two instance fields. Instance fields represent named values that are allocated whenever an instance of the class is constructed. When a Java program creates a Distance instance, that instance will contain space for point0 and point1. When another Distance object is created, it will contain space for its own point0 and point1 values. The value of point0 in the first Distance object can vary independently of the value of point0 in the second Distance object.

This declaration consists of:

1. The private access modifier, which means these instance fields are not visible to other classes.
2. The type of the instance fields. In this case, the type is java.awt.Point. This is the class Point in the java.awt package.
3. The names of the instance fields in a comma separated list.

These two fields could also have been declared with two separate but more verbose declarations,

private java.awt.Point point0;
private java.awt.Point point1;

Since the types of these fields is a reference type (i.e. a field that refers to or can hold a reference to an object value), Java will implicitly initialize the values of point0 and point1 to null when a Distance instance is created. The null value means that a reference value does not refer to an object. The special Java literal, null is used to represent the null value in a program. While you can explicitly assign null values in a declaration, as in

private java.awt.Point point0 = null;
private java.awt.Point point1 = null;

it is not necessary and most programmers omit such default assignments.

Example: Constructor

A constructor is a special method in a class which is used to construct an instance of the class. The constructor can perform initialization for the object, beyond that which the Java VM does automatically. For example, Java will automatically initialize the fields point0 and point1 to null.

Below is the constructor for this class. It consists of five parts:

1. The optional access modifier(s). In this case, the constructor is declared public
2. The constructor name, which must match the class name exactly: Distance in this case.
3. The constructor parameters. The parameter list is required. Even if a constructor does not have any parameters, you must specify the empty list (). The parameter list declares the type and name of each of the method's parameters.
4. An optional throws clause which declares the exceptions that the constructor may throw. This constructor does not declare any exceptions.
5. The constructor body, which is a Java block (enclosed in {}). This constructor's body contains two statements.

  public Distance(int x0, int y0, int x1, int y1)
  {
     point0 = new java.awt.Point(x0, y0);
     point1 = new java.awt.Point(x1, y1);
  }

This constructor accepts four parameters, named x0, y0, x1 and y1. Each parameter requires a parameter type declaration, which in this example is int for all four parameters. Java integer values are signed, 32 bit twos complement integers. The parameters in the parameter list are separated by commas.

The two assignments in this constructor use Java's new operator to allocate two java.awt.Point objects. The first allocates an object representing the first point, (x0, y0), and assigns it to the point0 instance variable (replacing the null value that the instance variable was initialized to). The second statement allocates a second java.awt.Point instance with (x1, y1) and assigns it to the point1 instance variable.

This is the constructor for the Distance class. Distance implicitly extends from java.lang.Object. Java inserts a call to the super constructor as the first executable statement of the constructor if there is not one explicitly coded. The above constructor body is equivalent to the following body with the explicit super constructor call:

  {
     super();
     point0 = new java.awt.Point(x0, y0);
     point1 = new java.awt.Point(x1, y1);
  }

While it is true that this class could be implemented in other ways, such as simply storing the coordinates of the two points and computing the distance as , this class instead uses the existing java.awt.Point class. This choice matches the abstract definition of this class: to print the distance between two points on the plane. We take advantage of existing behavior already implemented in the Java platform rather than implementing it again. We will see later how to make the program more flexible without adding much complexity, because we choose to use object abstractions here. However, the key point is that this class uses information hiding. That is, how the class stores its state or how it computes the distance is hidden. We can change this implementation without altering how clients use and invoke the class.

Example: Methods

Methods are the third and most important type of class member. This class contains three methods in which the behavior of the Distance class is defined: printDistance(), main(), and intValue()

The printDistance() method

The printDistance() method prints the distance between the two points to the standard output (normally the console).

  public void printDistance()
  {
     System.out.println("Distance between " + point0
                        + " and " + point1
                        + " is " + point0.distance(point1));   }
  }

This instance method executes within the context of an implicit Distance object. The instance field references, point0 and point1, refer to instance fields of that implicit object. You can also use the special variable this to explicitly reference the current object. Within an instance method, Java binds the name this to the object on which the method is executing, and the type of this is that of the current class. The body of the printDistance method could also be coded as

     System.out.println("Distance between " + this.point0
                        + " and " + this.point1
                        + " is " + this.point0.distance(this.point1));   }

to make the instance field references more explicit.

This method both computes the distance and prints it in one statement. The distance is computed with point0.distance(point1); distance() is an instance method of the java.awt.Point class (of which point0 and point1 are instances. The method operates on point0 (binding this to the object that point0 refers to during the execution of the method) and accepting another Point as a parameter. (Actually, it is slightly more complicated than that, but we'll explain later.) The result of the distance() method is a double precision floating point number.

This method uses the syntax

"Distance between " + this.point0
+ " and " + this.point1
+ " is " + this.point0.distance(this.point1)

to construct a String to pass to the System.out.println(). This expression is a series of String concatenation methods which concatenates Strings or the String representation of primitive types (such as doubles) or objects, and returns a long string. For example, the result of this expression for the points (0,3) and (4,0) is the String

"Distance between java.awt.Point[x=0,y=3] and java.awt.Point[x=4,y=0] is 5.0"

which the method then prints to System.out.

In order to print, we invoke the println(). This is an instance method from java.io.PrintStream, which is the type of the static field out in the class java.lang.System. The Java VM binds System.out to the standard output stream when it starts a program.

The main() method

The main() method is the main entry point which Java invokes when you start a Java program from the command line. The command

java Distance 0 3 4 0

instructs Java to locate the Distance class, put the four command line arguments into an array of String values, then pass those arguments the public static main(String[]) method of the class. (We will introduce arrays shortly.) Any Java class that you want to invoke from the command line or desktop shortcut must have a main method with this signature.

  public static void main(String[] args)
  {
     Distance dist = new Distance(
           intValue(args[0]), intValue(args[1]),
           intValue(args[2]), intValue(args[3]));
     dist.printDistance();
  }

The main() method invokes the final method, intValue(), four times. The intValue() takes a single string parameter and returns the integer value represented in the string. For example, intValue("3") will return the integer 3.

The intValue() method

The intValue() method delegates its job to the Integer.parseInt() method. The main method could have called Integer.parseInt() directly; the intValue() method simply makes the main() method slightly more readable.

  private static int intValue(String data)
  {
     return Integer.parseInt(data);
  } 

This method is private since, like the fields point0 and point1, it is part of the internal implementation of the class and is not part of the external programming interface of the Distance class.

Static vs. Instance Methods

Both the main() and intValue() methods are static methods. The static keyword tells the compiler to create a single memory space associated with the class. Each individual object instantiated has its own private state variables and methods but use the same static methods and members common to the single class object created by the compiler when the first class object is instantiated or created. This means that the method executes in a static or non-object context - there is no implicit separate instance available when the static methods run from various objects, and the special variable this is not available. As such, static methods cannot access instance methods or instance fields (such as printDistance()) or point0) directly. The main() method can only invoke the instance method printDistance() method via an instance reference such as dist.

Data Types

Most declarations have a data type. Java has several categories of data types: reference types, primitive types, array types, and a special type, void.

Reference Types

A reference type is a Java data type which is defined by a Java class or interface. Reference types derive this name because such values refer to an object or contain a reference to an object. The idea is similar to pointers in other languages like C.

Java represents sequences of character data, or String, with the reference type java.lang.String which is most commonly referred to as String. String literals, such as "Distance between " are constants whose type is String.

This program uses three separate reference types:

1. java.lang.String (or simply String)
2. Distance
3. java.awt.Point

For more information see chapter : Java Programming/Classes, Objects and Types.

Primitive Types

In addition to object or reference types, Java supports primitive types. The primitive types are used to represent Boolean, character, and numeric values. This program uses only one primitive type explicitly, int, which represents 32 bit signed integer values. The program also implicitly uses double, which is the return type of the distance() method of java.awt.Point. double values are 64 bit IEEE floating point values. The main() method uses integer values 0, 1, 2, and 3 to access elements of the command line arguments. The Distance() constructor's four parameters also have the type int. Also, the intValue() method has a return type of int. This means a call to that method, such as intValue(args[0]), is an expression of type int. This helps explain why the main method cannot call

new Distance(args[0], args[1], args[2], args[3]) // this is an error

Since the type of the args array element is String, and our constructor's parameters must be int, such a call would result in an error because Java cannot automatically convert values of type String into int values.

Java's primitive types are boolean, byte, char, short, int, long, float and double, each of which are also Java language keywords.

Array Types

Java supports arrays, which are aggregate types which have a fixed element type (which can be any Java type) and an integral size. This program uses only one array, String[] args. This indicates that args has an array type and that the element type is String. The Java VM constructs and initializes the array that is passed to the main method. See arrays for more details on how to create arrays and access their size.

The elements of arrays are accessed with integer indices. The first element of an array is always element 0. This program accesses the first four elements of the args array explicitly with the indices 0, 1, 2, and 3. (This program does not perform any input validation, such as verifying that the user passed at least four arguments to the program. We will fix that later.)

void

void is not a type in Java; it represents the absence of a type. Methods which do not return values are declared as void methods.

This class defines two void methods:

public static void main(String[] args) { ... }
public void printDistance()  { ... }

Syntax

Flow control

Java Programming Print version

Keywords

A Wikibookian has nominated this page for cleanup because: Section may be introduced too early, and seems to be constructed semi-randomly. You can help make it better. Please review any relevant discussion.

A Wikibookian suggests that Transwiki:Java syntax be merged into this book or chapter. Discuss whether or not this merger should happen on the discussion page.

Java derives much of its syntax from the C programming language: basic assignment statement syntax, expressions, control flow statements and blocks, etc. will be very familiar to C programmers.

Unicode 

Java source code are built by Unicode characters.

Tokens 

Java programs consist of a sequence of different kinds of tokens. For example, there are word tokens such as class and public which are keywords.

Keywords 

Those are special words with reserved meaning in Java. Those words can not be used by the programers to name identifiers.

Identifiers 

Other words (non keywords) are identifiers. Identifiers have many different uses in Java but primarily they are used as names, class names, method names, and variable names... .

literals 

Java also has tokens to represent numbers, such as 1 and 3; these are known as literals.

String literals, such as "http://en.wikibooks.org/Java_Programming", consist of zero or more characters embedded in double quotes.

Operators 

And operators such as + and = are used to express basic computation such as addition or String concatenation or assignment.

Blocks 

There are also left and right braces ({ and }) which enclose blocks. The body of a class is one such block.

Statements 

A Block contains one or more Java statement(s), separated by semicolons. A statement is the smallest building block of Java.

Separators 

Some tokens are punctuation, such as periods . and commas , and semicolons ;.

whitespace 

You use whitespace such as spaces, tabs, and newlines, to separate tokens. For example, whitespace is required between keywords and identifiers: publicstatic is a single identifier with twelve characters, not two Java keywords.

Comments 

Comments are not part of the executing code. Comments are used to document the code.

Unicode

Most Java program text consists of ASCII characters, but any Unicode character can be used as part of identifier names, in comments, and in character and string literals. Unicode escape sequences may also be used to express a Unicode character.

For example, π (which is the Greek Lowercase Letter pi) is a valid Java identifier.

double π = Math.PI;

and in a string literal

String pi = "π";

π may also be represented in Java as the Unicode escape sequence \u03C0. Thus, the following is a valid, but not very readable, declaration and assignment:

double \u03C0 = Math.PI;

The following demonstrate the use of Unicode escape sequences in other Java syntax:

 // Declare Strings pi and quote which contain \u03C0 and \u0027 respectively:
 String pi = "\u03C0";
 String quote = "\u0027";

Note that a Unicode escape sequence functions just like any other character in the source code. E.g., \u0022 (double quote, ") needs to be quoted in a string just like ".

 // Declare Strings doubleQuote1 and doubleQuote2 which both contain " (double quote):
 String doubleQuote1 = "\"";
 String doubleQuote2 = "\\u0022"; // "\u0022" doesn't work since """ doesn't work.

See Unicode escape sequences for full details.

Literals

Java Literals are syntactic representations of boolean, character, numeric, or string data. Literals provide a means of expressing specific values in your program. For example, in the following statement, an integer variable named count is declared and assigned an integer value. The literal 0 represents, natually enough, the value zero.

int count = 0;

The following method call passes a String literal "int count = 0;" the boolean literal true and the special null value null to the method parse():

List items = parse("int count = 0;", true, null);

• Boolean Literals
• Numeric Literals
  • Character Literals
  • Integer Literals
  • Floating Point Literals
• String Literals
• null

Blocks

Java has a concept called block that is enclosed between the { and } characters, called curly braces. A block executed as a single statetement, and can be used where a single statetement is accepted.

After a block is executed all local variables defined inside the block is discarded, go out of scope.

{
...
 // -- This is a block ---
}

Blocks can be nested:

{
...
  {
     // -- This is a nested block ---
  }
}

Whitespaces

Whitespace in Java is used to separate the tokens in a Java source file. Whitespace is required in some places, such as between access modifiers, type names and Identifiers, and is used to improve readability elsewhere.

Wherever whitespace is required in Java, one or more whitespace characters may be used. Wherever whitespace is optional in Java, zero or more whitespace characters may be used.

Java whitespace consists of the

• space character ' ' (0x20),
• the tab character (hex 0x09),
• the form feed character (hex 0x0c),
• the line separators characters newline (hex 0x0a) or carriage return (hex 0x0d) characters.

Line separators are special whitespace characters in that they also terminate line comments, whereas normal whitespace does not.

Other Unicode space characters, including vertical tab, are not allowed as whitespace in Java.

Required Whitespace

Below is the declaration of an abstract method taken from a Java class

public abstract Distance distanceTo(Destination dest);

Whitespace is required between public and abstract, between abstract and Distance, between Distance and distanceTo, and between Destination and dest.

However, the following is not legal:

publicabstractDistance distanceTo(Destination dest);

because whitespace is required between keywords and identifiers. The following is lexically valid

publicabstractDistance distanceTo(Destination dest);

but means something completely different: it declares a method which has the return type publicabstractDistance It is unlikely that this type exists, so the above would result in a semantic error.

Indentation

Java ignores all whitespace in front of a statement. As this, these two code snippets are identical for the compiler:

public static void main(String[] args) {
    printMessage();
}

void printMessage() {
    System.out.println("Hello World!");
}

public static void main(String[] args) {
printMessage();
}

void printMessage() {
System.out.println("Hello World!");
}

However, the first one's style (with whitespace) is preferred, as the readability is higher. (The method body is easier to distinguish from the head, even at a higher reading speed.)

Flow control

Java Programming Print version

Keywords

Statements

Language Fundamentals

Java Programming Print version

Identifiers, literals and expressions

Now, that we have the Java platform on our systems and have run the first program successfully, we are geared towards understanding how programs are actually made. As we have already discussed. A program is a set of instructions – very simple tasks provided to a computer. These instructions are called statements in Java. Statements can be anything from a single line of code to a complex mathematical equation. This section helps you understand what statements are and how they work.

What exactly are statements?

Statements are a single instruction in a program – a single unit of code. Consider the following line:

Listing 1.1: A simple assignment statement.

int age = 24;

This line is a simple instruction that tells the system to initialize a variable and set its value as 24. Within that simple definition, we talked about initialization of a variable and setting its value. This all might sound a bit too technical, but it will make sense as you read ahead.

Where do you find statements

Java, in the same style as C and C++, places statements within functions (or methods). The function in turn is placed within a class declaration. If the above statement was the only one in the program, it would look similar to this:

public class MyProgram
{
    public static void main (String[] args)
    {
        int age = 24; 
    }
}

The class declaration and function declaration will be described in the upcoming chapters.

Variables

Christmases are usually exciting, birthdays too. And the one thing that makes them exciting are: you get presents. Think of a present you've ever gotten. A tiny (or big, if you lucky) box with your name on it. Now think of variables as something similar. They are tiny little boxes in the computer's memory that save something within themselves. This something within them is called a value.

Data types

Take a look at the code in Listing 1.1. Here the variable we have just created is age. The word int tells us what is inside the age variable. int actually stands for integer – a number. On the right to this variable is the value of the variable which is the number 24. Just like int, we can use byte, short, long, double, float, boolean, char or String. All these tell us what type of data is within a variable. These are hence called data types.

We explored the statement in Listing 1.1, where the variable held an integer within in. Let's put another type of data within it. Let's say, the number 10.5. The code would look something like this:

Listing 1.2: Putting a number with decimal point inside an integer variable.

int age = 10.5;

This is actually wrong. By definition (if you have been awake throughout your mathematics lectures) you'd know that integers are whole numbers: 0, 1, 2, all the way up to infinity. Anything with a decimal point is not an integer, hence the statement by virtue of it is wrong.

What would make it right is when you assign a certain type to the variable that would accept numbers with decimal points – numbers with decimal points are called floating points.

Whole numbers and floating point numbers

The data types that one can use for whole numbers are byte, short, int and long but when it comes to floating point numbers, we use float or double. Now that we know that, we can modify the code in Listing 1.2 as:

Listing 1.3: The correct way to assign a type to floating point variables

double age = 10.5;

Why not float, you say? Well, there are several reasons why not. 10.5 can be anything – a float or a double but by a certain rule, it is given a certain type. This can be explained further by looking at the table below.

byte b = 123;

short s = 12345;

int i = 1234567;

long l = 1234567890L;

float f = 123.4567f;

double d = 1234.56789;

The above table only list the number data types. We will look at the others as we go on. So, did you notice why we used a double in listing 1.3, and not a float? The answer is pretty simple. If we'd used a float, we would have to append the number with a f as a suffix, so 10.5 should be 10.5f as in:

Listing 1.4: The correct way to define floating point numbers of type float.

float age = 10.5f;

Assignment statements

Up until now, we've assumed the creation of variables as a single statement. In essence, we assign a value to those variables, and that's just what it is called. When you assign a value to a variable in a statement, that statement is called an assignment statement. Did you notice one more thing? The semicolon (;). It's at the end of each statement. A clear indicator that a line of code is a statement is its termination with an ending semicolon. If one was to write multiple statements, it is usually done on each separate line ending with a semicolon. Consider the example below:

Listing 1.5: Multiple assignment statements.

int a = 10;
int b = 20;
int c = 30;

You do not necessarily have to use a new line to write each statement. Just like English, you can begin writing the next statement where you ended the first one as depicted below:

Listing 1.6: Multiple assignment statement on the same line.

int a = 10; int b = 20; int c = 30;

However, the only problem with writing such code is, it's very difficult to read it back. It doesn't look that intimidating at first, but one you've got a significant amount of code, it's usually better to organize it in a way that makes sense. It would look more complex and incomprehensible written as it is in Listing 1.6.

Now that we have looked into the anatomy of a simple assignment statement, we can look back at what we've achieved. We know that...

• A statement is a unit of code in programming.
• If we are assigning a variable a value, the statement is called an assignment statement.
• An assignment statement include three parts: a data type, variable name (also called an identifier) and the value of a variable. We will look more into the nature of identifiers and values in the section titled Identifiers, literals and expressions later.

Now, before we more on to the next topic, you need to try and understand what the code below does.

Listing 1.7: Multiple assignment statements with expressions

int firstNumber = 10;
int secondNumber = 20;
int result = firstNumber + secondNumber;

The first two statements are pretty much similar to those in Listing 1.5 but with different variable names. The third however is a bit interesting. We've already talked of variables as being similar to gift boxes. Think of your computer's memory as a shelf where you put all those boxes. Whenever you need a box (or variable), you call its identifier (that's the name of the variable). So calling the variable identifier firstNumber gives you the number 10, calling secondNumber would give you 20 hence when you add the two up, the answer should be 30. That's what the value of the last variable result would be. The part of the third statement where you add the numbers, i.e., firstNumber + secondNumber is called an expression and the expression is what decides what the value is to be. If it's just a plain value, nothing fancy, then it's called a literal.

With the information you have just attained, you can actually write a decent Java program that can sum up values. To learn more, continue reading.

Classes, Objects and Types

Primitive Types

Java Programming Print version

Arrays

Objects and Classes

An object is composed of members and methods. The members, also called data members, characteristics, attributes, or properties, describe the object. The methods generally describe the actions associated with a particular object. Think of an object as a noun, its members as adjectives describing that noun, and its methods as the verbs that can be performed by or on that noun.

For example, a sports car is an object. Some of its members might be its height, weight, acceleration, and speed. An object's members just hold data about that object. Some of the methods of the sports car could be "drive", "park", "race", etc. The methods really don't mean much unless associated with the sports car, and the same goes for the members.

The blueprint that lets us build our sports car object is called a class. A class doesn't tell us how fast our sports car goes, or what color it is, but it does tell us that our sports car will have a member representing speed and color, and that they will be say, a number and a word (or hex color code), respectively. The class also lays out the methods for us, telling the car how to park and drive, but these methods can't take any action with just the blueprint - they need an object to have an effect.

In Java, a class is located in a file similar to its own name. If you want to have a class called SportsCar, its source file needs to be SportsCar.java. The class is created by placing the following in the source file:

public class SportsCar
{
   /* Insert your code here */
}

The class doesn't do anything yet, as you will need to add methods and member variables first.

Instantiation and Constructors

In order to get from class to object, we "build" our object by instantiation. Instantiation simply means to create an instance of a class. Instance and object are very similar terms and are sometimes interchangeable, but remember that an instance refers to a specific object, which was created from a class.

This instantiation is brought about by one of the class's methods, called a constructor. As its name implies, a constructor builds the object based on the blueprint. Behind the scenes, this means that computer memory is being allocated for the instance, and values are being assigned to the data members.

In general there are four constructor types: default, non-default, copy, and cloning.

A default constructor will build the most basic instance. Generally, this means assigning all the members values like null, zero, or an empty string. Nothing would stop you, however, from your default sports car color from being red, but this is generally bad programming style. Another programmer would be confused if your basic car came out red instead of say, colorless.

A non-default constructor is designed to create an object instance with prescribed values for most, if not all, of the object's members. The car is red, goes from 0-60 in 12 seconds, tops out at 190mph, etc.

A copy constructor is not included in the Java language, however one can easily create a constructor that do the same as a copy constructor. It's important to understand what it is. As the name implies, a copy constructor creates a new instance to be a duplicate of an already existing one. In Java, this can be also accomplished by creating the instance with the default constructor, and then using the assignment operator to equivocate them. This is not possible in all languages though, so just keep the terminology under your belt.

Java has the concepts of cloning object, and the end results are similar to copy constructor. Cloning an object is faster than creation with the new keyword, because all the object memory is copied at once to destination cloned object. This is possible by implementing the Cloneable interface, which allows the method Object.clone() to perform a field-by-field copy.

Type

When an object is created, a reference to the object is also created. The object can not be accessed directly in Java, only through this object reference. This object reference has a type assigned to it. We need this type when passing the object reference to a method as a parameter. Java does strong type checking.

Type is basically a list of features/operations, that can be performed through that object reference. The object reference type basically is a contract that guarantees that those operations will be there at run time.

When a car is created, it comes with a list of features/operations listed in the user manual that guarantees that those will be there when the car is used.

When you create an object from a class by default its type is the same as its class. It means that all the features/operations the class defined are there and available, and can be used. See below:

(new ClassName()).operations();

You can assign this to a variable having the same type as the class:

ClassName objRefVariable = new ClassName();
objRefVariable.operations();

You can assign the created object reference to the class super class, or to an interface the class implements:

SuperClass objectRef = new ClassName();   // features/operations list are defined by the SuperClass class
..
Interface inter = new ClassName();  // features/operations list are defined by the interface

In the car analogy, the created car may have different Type of drivers. We create separate user manuals for them, Average user manual, Power user manual, Child user manual, or Handicapped user manual. Each type of user manual describes only those features/operations appropriate for the type of driver. The Power driver may have additional gears to switch to higher speeds, that are not available to other type of users...

When the car key is passed from an adult to a child we replacing the user manuals, that is called Type Casting.

In Java, casts can occur in three ways:

• up casting: going up in the inheritance tree, until we reach the Object
• up casting: to an interface the class implements
• down casting: until we reach the class the object was created from

Type and Type Casting will be covered in more details later at 'Java Programming/Types' module.

Multiple classes in a Java file

Normally, a Java file can have one and only one public Java class. However, a given file can contain additional non-public classes.

public class OuterClass
{
    ...
}
class AdditionalClass
{
    ...
}

Because they have the "package (default)" access specifier, the 'AdditionalClass' can be accessed only in the same package.

These "additional" classes compile to separate ".class" bytecode files when compiled, just as if they were in separate source files. However, including multiple classes in one file may increase the difficulty in examining the structure of a given application.

External links

• Constructors, interactive Java Lesson

Packages

Java Package / Name Space

Usually a Java application is built by many developers and it is common that third party modules/classes are integrated. The end product can easily contain hundreds of classes. Class name collision is likely to happen. To avoid this a Java class can be put in a "name space". This "name space" in Java is called the package.

The Java package needs to be unique across Vendors to avoid name collisions. For that reason Vendors usually use their domain name in reverse order. That is guaranteed to be unique. For example a company called 'Your Company Inc.', would use a package name something like this: com.yourcompany.yourapplicationname.yourmodule.YourClass.

To put a class in a package, the package keyword is used at the top of each class file. For Example,

package com.yourcompany.yourapplication.yourmodule;

When we want to reference a Java class that is defined outside of the current package name space, we have to specify which package name space that class is in. So we could reference that class with something like com.yourcompany.yourapplication.yourmodule.YourClass . To avoid having to type in the package name each time when we want to reference an outside class, we can declare which package the class belongs to by using the import Java keyword at the top of the file. For Example,

import com.yourcompany.yourapplication.yourmodule.YourClass;

Then we can refer to that class by just using the class name YourClass .

In rare cases it can happen that you need to reference two classes having the same name in different packages. In those cases, you can not use the import keyword for both classes. One of them needs to be referenced by typing in the whole package name. For Example,

package com.mycompany.myapplication.mymodule;
...
import com.yourcompany.yourapplication.youmodule.SameClassName;
...
SameClassName yourObjectRef = new SameClassName();
com.hercompany.herapplication.hermodule.SameClassName herObjectRef = 
   new com.hercompany.herapplication.hermodule.SameClassName();

The Java package has one more interesting characteristic; the package name corresponds where the actual file is stored on the file system. And that is actually how the compiler and the class loader find the Java files on the file system. For example, the class com.yourcompany.yourapplication.yourmodule.YourClass, is stored on the file system in the corresponding directory : com/yourcompany/yourapplication/yourmodule/YourClass. Because of this, package names should be lowercase, since in some operating systems the directory names are not case sensitive.

Wildcard imports

It is possible to import an entire package, using an asterisk:

import javax.swing.*;

While it may be seem convenient, it may cause problems if you make a typographical error. For example, if you use the above import to use JFrame, but then type JFraim frame=new JFraim();, the Java compiler will report an error similar to "Cannot find symbol: JFraim". Even though it seems as if it was imported, the compiler is giving the error report at the first mention of JFraim, which is half-way through your code, instead of the point where you imported JFrame along with everything else in javax.swing.

If you change this to import javax.swing.JFraim; the error will be at the import instead of within your code.

Furthermore, if you import javax.swing.*; and import java.util.*;, and javax.swing.Queue is later added in a future version of Java, your code that uses Queue (java.util) will fail to compile. This particular example is fairly unlikely, but if you are working with non-Sun libraries, it may be more likely to happen.

Importing packages from .jar files

If you are importing library packages or classes that reside in a .jar file, you must ensure that the file is in the current classpath (both at compile- and execution-time). Apart from this requirement, importing these packages and classes is the same as if they were in their full, expanded, directory structure.

Example:

To compile and run a class from a project's top directory (that contains the two directories /source and /libraries) you could use the following command:

javac -classpath libraries/lib.jar source/MainClass.java

And then to run it, similarly:

java -classpath libraries/lib.jar source/MainClass

(The above is simplified, and demands that MainClass be in the default package, or a package called 'source', which isn't very desirable.)

Class Loading / Name Space

A fully qualified class name 

consist of the package name plus the class name.

For example, the fully qualified class name of HashMap is java.util.HashMap.

Sometime is can happen that two class has the same name, but it can not have on the same package, otherwise it would be the same class.

It can be said that the two class with the same name is in different name space. In the above example, the HashMap class is in the java.util name space.

Let be two Customer class with different name space (in different package).

• com.bluecompany.Customer
• com.redcompany.Customer

When we need to use both class in the same program file, we can use the import keyword only for one of the class. For the other we need to use the fully qualified name.

The runtime identity of a class in Java 2 

is defined by the fully qualified class name and its defining class loader. This means that the same class, loaded by two different class loaders, is seen by the Virtual Machine as two completely different types.

Nested Classes

In Java you can define a class inside an other class.

A class can be nested:

• inside another class,
• or inside a method

Nest a class inside a class

When a class is declared inside another class, the nested class' access modifier can be public, private or package(default).

public class OuterClass
{
   private String outerInstanceVar;

   public class InnerClass
   {
      public void printVars()
      {
         System.out.println( "Print Outer Class Instance Var.:" + outerInstanceVar);
      }
   } 
}

The inner class has access to the enclosing class instance's variables and methods, even private ones, as seen above. This makes it very different from the nested class in C++, which are equivalent to the "static" inner classes, see below.

An inner object has a reference to the outer object. The nested object can only be created with a reference to the 'outer' object. See below.

public void testInner()
{
    ...
    OuterClass outer = new OuterClass();
    OuterClass.InnerClass inner = outer.new OuterClass.InnerClass();	
    ...
}

(When in a non-static method of the outer class, you can directly use new InnerClass(), since the class instance is implied to be this.)

You can directly access the reference to the outer object from within an inner class with the syntax OuterClass.this; although this is usually unnecessary because you already have access to its fields and methods.

Inner classes compile to separate ".class" bytecode files, usually with the name of the enclosing class, followed by a "$", followed by the name of the inner class. So for example, the above inner class would typically be compiled to a file named "OuterClass$InnerClass.class".

Static inner class

An inner class can be declared static. A static inner class has no enclosing instance, and therefore cannot access instance variables and methods of the outer class. You do not specify an instance when creating a static inner class. This is equivalent to the inner classes in C++.

Nest a class inside a method

These inner classes, also called local classes, cannot have access modifiers, like local variables, since the class is 'private' to the method. The inner class can be only abstract or final.

public class OuterClass
{
   public void method()
   {
      class InnerClass
      {
 
      } 
   }
}

In addition to instance variables of the enclosing class, local classes can also access local variables of the enclosing method, but only ones that are declared final. This is because the local class instance might outlive the invocation of the method, and so needs its own copy of the variable. To avoid problems with having two different copies of a mutable variable with the same name in the same scope, it is required to be final, so it cannot be changed.

Anonymous Classes

In Java a class definition and its instantiation can be combined into a single step. By doing that the class does not require a name. Those classes are called anonymous classes. An anonymous class can be defined and instantiated in contexts where a reference can be used, and it is a nested class to an existing class. Anonymous class is a special case of the local class to a method, above; and hence they also can use final local variables of the enclosing method.

Anonymous classes are most useful to subclass and upcast to an 'Adapter Class' or to an interface.

public interface ActionListener
{
    public void click();
}
...
ActionListener clk = new ActionListener() 
    {
        public void click()
        {
            // --- implementation of the click event ---
            ...
            return;
        }
    };

In the above example the class that implements the ActionListener is anonymous. The class is defined where it is instantiated.

The above code is harder to read than if the class explicitly defined, so why use it? If many implementations are needed for an interface and those classes are used only in one particular place, using anonymous class makes sense.

The following example uses anonymous class to implement an action listener.

import java.awt.*;
import java.awt.event.*;
import java.io.Serializable;
class MyApp implements Serializable
{
   BigObjectThatShouldNotBeSerializedWithAButton bigOne;
   Button aButton = new Button(); 
   MyApp()
   {
       aButton.addActionListener( new ActionListener()
           {
               public void actionPerformed(ActionEvent e)
               {
                   System.out.println("Hello There");
               }
           }
       );
   }
}

The following example does the same thing, but it names the class that implements the action listener.

import java.awt.*;
import java.awt.event.*;
import java.io.Serializable;
class MyApp implements Serializable
{
   BigObjectThatShouldNotBeSerializedWithAButton bigOne;
   Button aButton = new Button();
   // --- Nested class to implement the action listener ---
   class MyActionListener implements ActionListener
   {
       public void actionPerformed(ActionEvent e)
       {
           System.out.println("Hello There");
       }
   }
   MyApp()
   {
       aButton.addActionListener( new MyActionListener() );
   }
}

Using anonymous classes is especially preferable when you intend to use many different classes that each implement the same Interface.

Access Modifiers

Access modifiers

You surely would have noticed by now, the words public, protected and private at the beginning of class's method declarations used in this book. These keywords are called the access modifiers in the Java language syntax, and can be defined as...

.. keywords that help set the visibility and accessibility of a class, its member variables, and methods.

The following table shows what Access Modifiers are appropriate for classes, nested classes, member variables, and methods:

Points to ponder
Note that Interface method visibility is public by default. You do not need to specify the access modifier it will default to public. For clarity it is considered a good practice to put the public keyword.

The same way all member variables defined in the Interface by default will become static final once inherited in a class.

If a class has public visibility, the class can be referenced by anywhere in the program. If a class has package visibility, the class can be referenced only in the package where the class is defined. If a class has private visibility, (it can happen only if the class is defined nested in an other class) the class can be accessed only in the outer class.

If a variable is defined in a public class and it has public visibility, the variable can be reference anywhere in the application through the class it is defined in. If a variable has package visibility, the variable can be referenced only in the same package through the class it is defined in. If a variable has private visibility, the variable can be accessed only in the class it is defined in.

If a method is defined in a public class and it has public visibility, the method can be called anywhere in the application through the class it is defined in. If a method has package visibility, the method can be called only in the same package through the class it is defined in. If a method has private visibility, the method can be called only in the class it is defined in.

Methods

Method Definition

Method is an operation on a particular object. An object is an instance of a class. When we define a class we define its member variables and its methods. For each method we need to give a name, we need to define its input parameters and we need to define its return type. We also need to set its visibility(private, package, or public). If the method throws an Exception, that needs to be declared as well. The syntax of method definition is:

class MyClass
{
 ...
    public ReturnType methodName( ParemOneType param1, ParamTwoType param2 ) throws ExceptionName
    {
      ReturnType retType;
      ...
      return retType;
    }
 ...
}

We can declare that the method does not return anything using the void java keyword. For example:

private void methodName( String param1, String param2 )
{
 ...
  return;
}

When the method returns nothing, the return keyword at the end of the method is optional. The return keyword can be used anywhere in the method, when the executation flow reach the return keyword, the method execution is stopped and the execution flow returns to the caller method.

Method Overloading

For the same class we can define two methods with the same name. However the parameter types and/or the number of parameters must be different for those two methods. In the java terminology, this is called method overloading. It is useful to use method overloading when we need to do something different based on a parameter type. For example we may have the operation : runAroundThe. We can define two methods with the same name, but different input parameter type:

public void runAroundThe( Building block )
{
  ...
}
public void runAroundThe( Park park )
{
  ...
}

Related terminology is the method signature. In java the method signature contains method name and the input parameter types. The java compiler takes the signature for each method and makes sure that each method signature is unique for a class. For example the following two method definitions are valid:

public void logIt( String param, Error err )
{
  ...
}
public void logIt( Error err, String param )
{
  ...
}

Because the type order is different. If both input parameters were type String, that would be a problem again since the compiler would not be able to distinguish between the two:

public void logIt( String param, String err )
{
  ...
}
public void logIt( String err, String param )
{
  ...
}
 

The compiler would give and error for the following method definitions as well:

public void logIt( String param )
{
  ...
}
public String logIt( String param )
{
  String retType;
  ...
  return retValue;
}

Note, the return type is not part of the unique signature. Why not? The reason is that a method can be called without assigning its return value to a variable. This feature came from C and C++. So for the call:

{
  logIt( msg );
}

the compiler would not know which method to call.

Method Overriding

Obviously a method signature has to be unique inside a class. The same method signature can be defined in different classes. If we define a method that exist in the super class then we override the super class method. The terminology for this is method overriding. This is different from method overloading. Method overloading happens with methods with the same name different signature. Method overriding happens with same name, same signature between inherited classes.

The return type can cause the same problem we saw above. When we override a super class method the return type also must be the same. In fact if that is not the same, the compiler will give you an error.

Method overriding is related dynamic linking, or runtime binding. In order to the Method Overriding to work, the method call that is going to be called can not determined at compilation time. It will be decided at runtime, and will be looked up in a table.

{
1  MyClass obj = new SubOfMyClass();
2
3  MyClass obj = new MyClass();
4 
5  obj.myMethod(); // -- During compilation, it is not known what reference the 'obj' has, MyClass or SubOfMyClass 
}

In the above example 'obj' reference has the type MyClass on both line 1 and line 3. However the 'obj' reference points two different objects. On line 1 it references SubOfMyClass object, on line 3 it references MyClass object. So on line 5 which method will be called, method define in MyClass, or the method that defined in its subclasses. Because the 'obj' reference can point to object and all its sub object, and that will be known only at runtime, a table needs to be kept with all the possible method address to be called.

Also another rule is that when you do an override, the visibility of the new method that overrides the super class method can not be reduced. The visibility can increased, however. So if the super class method visibility is public, the override method can not be package, or private.

In the case of the exception the override method may throw can be the same as the super class or it can be one of that exception inherited class. So the common rule is that the override method must be throw the same exception or its any of its subclasses.

NOTE: A common mistake to think that if we can override methods, we could also override member variables. This is not the case, as member variables are not overriden.

{
1  MyClass obj = new SubOfMyClass();
2
3  MyClass obj = new MyClass();
4 
5  String var = obj.myMemberVar;  // -- The myMemberVar is defined in the MyClass object 
}

In the above example, it does not count what object the 'obj' reference points to, because it was declared MyClass type on both line 1 and line 3, the variable in the MyClass object will be referenced. In real examples we rarely use public variables, but if you do keep in mind that Java does not support variable overriding.

Parameter Passing

We can pass in all the primitive data types or any object references to a method. An object cannot be passed to a method, only its references. All parameters (those are primitive types and object references) are passed by value. In other words if you change the passed in parameter values inside the method, that will have no effect on the original variable that was passed in. When you pass in an object reference to a method and then you change that inside the method, that will have no effect on the original object reference. However if you modify the object itself, that will stay after the method returns. Think about the object reference as a pointer to an object. If you change the object the reference points at, that will be permanent. For example:

1 {
2   int var1 = 10;
3   int var2 = 20;
4   ...
5   myMethod( var1, var2 );
6   ...
7   System.out.println( "var1="+var1 +"var2="+var2 );  // -- The variable values did not change
8 }
9 ...
10 void myMethod( int var1, int var2 )
11 { 
12    ...
13    var1 = 0;
14    var2 = 0;
15    ...
16 }

On line 7 the value of var1 is 10 and the value of var2 is 20. When the variables were passed in to the methods their values were copied. This is called passing the paramater by value. In java we do not represent an object directly, we represent an object throught an object reference. You can think of an object reference as a variable having the address of the object. So the object reference passed in by value, but the object itself is not. For example:

1 { 
2   MyObjOne obj = new MyObjOne();
3   obj.setName("Christin");
4   ...
5   myMethod( obj );
6   String name = obj.getName();  // --- The name attribute was changed to 'Susan' inside the method
7 }
8 void myMethod( MyObjOne obj )
9 {
10    obj.setName("Susan");
11 ...
12   obj = new MyObjOne();
13   obj.setName("Sonya");
14 ...
15 }

On line 2, we created an object, on line 3 we set its name property to 'Christin'. On line 5 we called the myMethod( obj ). Inside the method, we changed the name to 'Susan' through the passed in object reference. So that change will stay. Note however that after we reassigned the obj reference to a new object, that is no effect whatsoever on the passed in object.

Return Parameter

A method may or may not return a value. If the method does not return a value we use the void java keyword. Same as the parameter passing, the method can return a primitive type or an object reference. So a method can return only one value. What if you want to return more than one value from a method. You can always pass in an object reference to the method, and let the method modify the object properties. The modified values can be considered as an output value from the method. However better option, and cleaner if you create an Object array inside the method, assign the return values and return the array to the caller. You could have a problem however, if you want to mix primitive data types and object references as the output values from the method. There is a better approach. Defines special return object with the needed return values. Create that object inside the method, assign the values and return the reference to this object. This special object is "bound" to this method and used only for returning values, so do not use a public class. The best way is to use a nested class, see example below:

public class MyObject
{
  ...
 
  /** Nested object is for return values from 'getPersonInfoById' method */
  public static class  ReturnObj 
  {
      private int    age;
      private String name;

      public void setAge( int val )
      {
          this.age = val;
      }
      public int getAge()
      {
          return age;
      }

      public void setName( String val )
      {
          name = val;
      }
      public String getName()
      {
          return name;
      }
  } // --- End of nested class defination ---

  /** Method using the nested class to return values */
  public ReturnObj getPersonInfoById( int ID ) 
  {
     int    age;
     String name;
   ...
     // --- Get the name and age based on the ID from the database --- 
   ...
     ReturnObj ret = new ReturnObj();
     ret.setAge( age );
     ret.setName( name );

   return ret;
  } 
}

In the above example the 'getPersonInfoById' method returns an object reference that contains both values the name and age. See below how you may use that object:

{
 ...
   MyObject obj = new MyObject();
   MyObject.ReturnObj person = obj.getPersonInfoById( 102 );

   System.out.println( "Person Name=" + person.getName() );
   System.out.println( "Person Age =" + person.getAge() );
 ...
}

Special method, the Constructor

There is a special method for each class that will be executed each time an object is created from that class. That is the Constructor . Constructor does not have a return value and its name is the same as the class name. The Constructor can be overloaded; you can define more than one constructor with different parameters. For example:

public class MyClass
{
  private String memberVar;
  /**
   * MyClass Constructor, there is no input parameter  
   */
  public MyClass()
  {
     ...
  }
  /**
   * MyClass Constructor, there is one input parameter  
   */
  public MyClass( String param1 )
  {
     memberVar = param1;
     ...
  }
}

In the above example we defined two constructors, one with no input parameter, and one with one input parameter. You may ask which constructor will be called. Its depends how the object is created with the new keyword. See below:

{ 
   ...
   MyClass obj1 = new MyClass();              // The constructor with no input parameter will be called
   MyClass obj2 = new MyClass("Init Value");  // The constructor with one input param. will be called
   ...
 }

In the above example we created two objects from the same class, or we can also say that obj1 and obj2 both have the same type. The difference between the two is that in the first one the memberVar field is not initialized, in the second one that is initialized to 'Init Value'. obj1, and obj2 contains the reference to the object. Each class must have a constructor. If we do not define one, the compiler will create a default so called empty constructor automatically.

public class MyClass
{
  /**
   * MyClass Empty Constructor  
   */
  public MyClass()
  { 
  }
}

The Constructor is called automatically when an object is created with the new keyword. A constructor may also be called from an other constructor, see below:

public class MyClass
{
  private String memberVar;
  /**
   * MyClass Constructor, there is no input parameter  
   */
  public MyClass()
  {
     MyClass("Default Value");
  }
  /**
   * MyClass Constructor, there is one input parameter  
   */
  public MyClass( String param1 )
  {
     memberVar = param1;
     ...
  }
}

In the above example, the constructor with no input parameter calls the other constructor with the default initial value. This gives an option to the user, to create the object with the default value or create the object with a specified value.

Static Method

We defined method above as an operation on an object. Static Methods are defined inside a class, but they are not an operation on an object. No object needs to be created to execute a Static Method, they are simply global functions, with input parameters and a return value.

public class MyObject
{
   static public String myStaticMethod()
   {
      ...
     return("I am a Static Method");
   }

 }

Static Methods can be referenced anywhere prefixed by the class name. See below:

{
...
   // --- Call myStaticMethod  ---
   System.out.println( "Output from the myStaticMethod:" + MyObject.myStaticMethod() );
...
}

You can write a non object oriented program by using only Static Methods in java. Because java evolved from the C programming language, Static Method is a left over from a non object oriented language.

You write Static Method the same way as normal method, the only difference is that you can not reference any member variables and any object methods. Static Methods can reference only Static variables and call only other Static Methods. However you can create an object an use it inside a Static Method.

public class MyObject
{
   public String memberVar;

   static private String memberStaticVar;

   static public String myStaticMethod()
   {
     memberVar = "Value"; -->  ERROR Cannot reference member var.

     memberStaticVar = "Value";  // --- This is okay, static vars. can be used

     // --- Create an object ---
     MyObject obj = new MyObject();
     obj.memberVar = "Value";  // --- This is okay since an object is created --
      ...
     return("I am a Static Method");
   }    
 }

External links

• Abstract methods, interactive Java Lesson

Primitive Types

Statements

Java Programming Print version

String

Types in Java define the allowed data values and the operations that may be performed on those values. Each expression, field, method parameter, local variable, and method return values, have an associated type. The syntax template for a field declaration in Java is

[Modifiers] Type FieldName ['=' Expression];

Method, method parameter, and local variables have similar syntax: optional modifiers, a required type, and the name of the value being declared.

In java, there are three different kind of Types, those are:

• Primitive Type
• Object Reference Type
• An array type

About Java Types

Java is strongly typed in that all expressions and declarations have types (either declared or inferred) and the language only allows programs which adhere to the type constraints. You cannot write a statement or expression in Java which directly invokes an operation on a value that is not allowed by that value's type, nor can you perform assignments that violate the type system: you cannot assign a String value to an integer typed variable. This helps achieve a high level of type safety in Java. Most type errors are caught and detected by the Java compiler. However, some type errors can still occur at runtime because Java supports a cast operation which is a way of changing the type of one expression to another. However, Java performs run time type checking when doing such casts, so an incorrect type cast will cause a runtime exception rather than succeeding silently and allowing data corruption.

Java is also known as a hybrid language. While supporting object oriented (OO) programming, Java is not a pure OO language like Smalltalk or Ruby. Instead, Java offers both object types and primitive types. Primitive types are used for boolean, character, and numeric values and operations. This allows relatively good performance when manipulating numeric data, at the expense of flexibility. For example, you cannot subclass the primitive types and add new operations to them.

Examples of Types

Below are two examples of Java types and a brief description of the allowed values and operations for these types. Additional details on each are available in other modules.

Example: int

The primitive type int represents a signed 32 bit integer value. The allowed data values for int are the integers between -2147483648 to 2147483647 inclusive.

The set of operations that may be performed on int values includes integer arithmetic such as +, -, *, /, %, comparison operations (==, !=, <, >, <=, >=), assignments (=, ++, --, +=, -=), bit-wise operations such as logical and, logical or, logical xor, negation (&, |, ^, ~), bit shift operations (<<, >>, >>>), conversions to other numeric types and promotion to other integer types.

For example, to declare a private integer instance field named length, one would use the declaration

private int length;

Example: String

You use class and interface definition in Java to define new types. Class and interface types are associated with object references also sometime refered to as Reference types. An object reference has two main attributes:

• Its type associated with a class or an interface
• A java object it references, that is created by instantiating a class

The String class is one such example. String values are a sequence of 0 or more Unicode characters. The null reference is another valid value for a String expression.

The operations on a String reference variable are those available for all reference types, such as comparison operations ==, != and assignment =.

The allowed operations on String object, however are the set of methods in the java.lang.String class, which includes length(), toString(), toLowerCase(), toUpperCase(), compareTo(String anotherString) and more... .

In addition, String objects also inherit the set of operations from the base class that String extends from, which is java.lang.Object. These operations include methods such as equals(), hashCode(), wait(), notifyAll(), and getClass().

private String name = "Marry Brown";

In the above example the name object reference's attributes are:

• Type is : String
• The referenced object is also : String

Both the java.lang.String class methods and java.lang.Object class methods are available for the object reference name.

private Object name = "Marry Brown";

In the above example the name object reference's attributes are:

• Type is : Object
• The referenced object is : String

Only the java.lang.Object class methods are available for the object reference name.

Array Types

Arrays in Java are represented as a built-in Array object. As with object types, they behave as a reference but have a few differences allowing them to allow easy access to sub elements.

When one declares an array, the data type is changed to include square brackets. (While you can instead place these square brackets next to the variable name, this is not recommended.) To create an array, you will need to use the new operator to have it create the Array with the specified number of elements:

 /* Declares an array named data, and has it assigned to an array with 25 elements. */
 private int[] data = new int[25];

Arrays are described in more detail in the Arrays section.

Primitive Data Types

The Java primitive data types contain pure values, no operations. It is basically data types similar to what other non-object-oriented languages have.

There are arrays of primitive types in Java; but because they are not objects, primitive values can not be put in a collection.

For this reason object wrappers are defined in JDK 'java.lang.*' package for all the primitive types.

The types short, int, long, float, and double are usually used in arithmetic operations; byte and char can also be used, but less commonly.

The character type char is used for text processing. The type byte is commonly used in binary file input output operations.

String objects representing literal character strings in Java, in the java.lang.* package. java.lang.String is not a primitive type, but instead is a special class built into the Java language. For further info, see String.

Data Conversion (Casting)

Data conversion (casting) can happen between two primitive types. There are two kinds:

• Implicit : casting operation is not required; the magnitude of the numeric value is always preserved. However, precision may be lost when converting from integer to floating point types
• Explicit : casting operation required; the magnitude of the numeric value may not be preserved

Example for implicit casting:

int  i = 65;
long l = i;  // --- int is converted to long, casting is not needed

Example for explicit casting:

long l = 656666L;
int  i = (int) l; // --- long is converted to int, casting is needed

The following table shows the conversions between primitive types, it shows the casting operation for explicit conversions:

Autoboxing/unboxing

Autoboxing/unboxing  

Autoboxing and unboxing, language features since Java 1.5, make the programmer's life much easier when it comes to working with the primitive wrapper types. Consider this code fragment:

int age = 23; 
Integer ageObject = new Integer(age);

Primitive wrapper objects were Java's way of allowing one to treat primitive data types as though they were objects. Consequently, one was expected to 'wrap' one's primitive data type with the corresponding primitive wrapper object, as shown above.

Autoboxing 

Since Java 1.5, one may write as below and the compiler will automatically create the wrap object. The extra step of wrapping the primitive is no longer required. It has been 'automatically boxed up' on your behalf.

Points to ponder
Keep in mind that the compiler still creates the missing wrapper code, so one doesn't really gain anything performance-wise. Consider this feature a programmer convenience, not a performance booster.

int age = 23; 
Integer ageObject = age;

Unboxing 

Uses the same process in reverse. Study the following code for a moment. The if statement requires a boolean primitive value, yet it was given a Boolean wrapper object. No problem! Java 1.5 will automatically 'unbox' this.

Boolean canMove = new Boolean(true); 

if ( canMove )
{ 
  System.out.println( "This code is legal in Java 1.5" );  
}

Types

Statements

Java Programming Print version

String

Types in Java define the allowed data values and the operations that may be performed on those values. Each expression, field, method parameter, local variable, and method return values, have an associated type. The syntax template for a field declaration in Java is

[Modifiers] Type FieldName ['=' Expression];

Method, method parameter, and local variables have similar syntax: optional modifiers, a required type, and the name of the value being declared.

In java, there are three different kind of Types, those are:

• Primitive Type
• Object Reference Type
• An array type

About Java Types

Java is strongly typed in that all expressions and declarations have types (either declared or inferred) and the language only allows programs which adhere to the type constraints. You cannot write a statement or expression in Java which directly invokes an operation on a value that is not allowed by that value's type, nor can you perform assignments that violate the type system: you cannot assign a String value to an integer typed variable. This helps achieve a high level of type safety in Java. Most type errors are caught and detected by the Java compiler. However, some type errors can still occur at runtime because Java supports a cast operation which is a way of changing the type of one expression to another. However, Java performs run time type checking when doing such casts, so an incorrect type cast will cause a runtime exception rather than succeeding silently and allowing data corruption.

Java is also known as a hybrid language. While supporting object oriented (OO) programming, Java is not a pure OO language like Smalltalk or Ruby. Instead, Java offers both object types and primitive types. Primitive types are used for boolean, character, and numeric values and operations. This allows relatively good performance when manipulating numeric data, at the expense of flexibility. For example, you cannot subclass the primitive types and add new operations to them.

Examples of Types

Below are two examples of Java types and a brief description of the allowed values and operations for these types. Additional details on each are available in other modules.

Example: int

The primitive type int represents a signed 32 bit integer value. The allowed data values for int are the integers between -2147483648 to 2147483647 inclusive.

The set of operations that may be performed on int values includes integer arithmetic such as +, -, *, /, %, comparison operations (==, !=, <, >, <=, >=), assignments (=, ++, --, +=, -=), bit-wise operations such as logical and, logical or, logical xor, negation (&, |, ^, ~), bit shift operations (<<, >>, >>>), conversions to other numeric types and promotion to other integer types.

For example, to declare a private integer instance field named length, one would use the declaration

private int length;

Example: String

You use class and interface definition in Java to define new types. Class and interface types are associated with object references also sometime refered to as Reference types. An object reference has two main attributes:

• Its type associated with a class or an interface
• A java object it references, that is created by instantiating a class

The String class is one such example. String values are a sequence of 0 or more Unicode characters. The null reference is another valid value for a String expression.

The operations on a String reference variable are those available for all reference types, such as comparison operations ==, != and assignment =.

The allowed operations on String object, however are the set of methods in the java.lang.String class, which includes length(), toString(), toLowerCase(), toUpperCase(), compareTo(String anotherString) and more... .

In addition, String objects also inherit the set of operations from the base class that String extends from, which is java.lang.Object. These operations include methods such as equals(), hashCode(), wait(), notifyAll(), and getClass().

private String name = "Marry Brown";

In the above example the name object reference's attributes are:

• Type is : String
• The referenced object is also : String

Both the java.lang.String class methods and java.lang.Object class methods are available for the object reference name.

private Object name = "Marry Brown";

In the above example the name object reference's attributes are:

• Type is : Object
• The referenced object is : String

Only the java.lang.Object class methods are available for the object reference name.

Array Types

Arrays in Java are represented as a built-in Array object. As with object types, they behave as a reference but have a few differences allowing them to allow easy access to sub elements.

When one declares an array, the data type is changed to include square brackets. (While you can instead place these square brackets next to the variable name, this is not recommended.) To create an array, you will need to use the new operator to have it create the Array with the specified number of elements:

 /* Declares an array named data, and has it assigned to an array with 25 elements. */
 private int[] data = new int[25];

Arrays are described in more detail in the Arrays section.

Primitive Data Types

The Java primitive data types contain pure values, no operations. It is basically data types similar to what other non-object-oriented languages have.

There are arrays of primitive types in Java; but because they are not objects, primitive values can not be put in a collection.

For this reason object wrappers are defined in JDK 'java.lang.*' package for all the primitive types.

The types short, int, long, float, and double are usually used in arithmetic operations; byte and char can also be used, but less commonly.

The character type char is used for text processing. The type byte is commonly used in binary file input output operations.

String objects representing literal character strings in Java, in the java.lang.* package. java.lang.String is not a primitive type, but instead is a special class built into the Java language. For further info, see String.

Data Conversion (Casting)

Data conversion (casting) can happen between two primitive types. There are two kinds:

• Implicit : casting operation is not required; the magnitude of the numeric value is always preserved. However, precision may be lost when converting from integer to floating point types
• Explicit : casting operation required; the magnitude of the numeric value may not be preserved

Example for implicit casting:

int  i = 65;
long l = i;  // --- int is converted to long, casting is not needed

Example for explicit casting:

long l = 656666L;
int  i = (int) l; // --- long is converted to int, casting is needed

The following table shows the conversions between primitive types, it shows the casting operation for explicit conversions:

Autoboxing/unboxing

Autoboxing/unboxing  

Autoboxing and unboxing, language features since Java 1.5, make the programmer's life much easier when it comes to working with the primitive wrapper types. Consider this code fragment:

int age = 23; 
Integer ageObject = new Integer(age);

Primitive wrapper objects were Java's way of allowing one to treat primitive data types as though they were objects. Consequently, one was expected to 'wrap' one's primitive data type with the corresponding primitive wrapper object, as shown above.

Autoboxing 

Since Java 1.5, one may write as below and the compiler will automatically create the wrap object. The extra step of wrapping the primitive is no longer required. It has been 'automatically boxed up' on your behalf.

Points to ponder
Keep in mind that the compiler still creates the missing wrapper code, so one doesn't really gain anything performance-wise. Consider this feature a programmer convenience, not a performance booster.

int age = 23; 
Integer ageObject = age;

Unboxing 

Uses the same process in reverse. Study the following code for a moment. The if statement requires a boolean primitive value, yet it was given a Boolean wrapper object. No problem! Java 1.5 will automatically 'unbox' this.

Boolean canMove = new Boolean(true); 

if ( canMove )
{ 
  System.out.println( "This code is legal in Java 1.5" );  
}

java.lang.String

Types

Java Programming String

Classes, Objects and Types

java.lang.String

String is a special class built into the Java language defined in the java.lang package.

The String class represents character strings. String literals in Java programs, such as "abc", are implemented as instances of this class. Strings are immutable; that is, they cannot be modified once created.

For example:

String str = "This is string literal";

On the right hand side a String object is created represented by the string literal. Its object reference is assigned to the str variable.

The Java language provides special support for the string concatenation operator ( + ), and for conversion of other objects to strings. For example:

String str = "First part" + " second part";
// --- Is the same as:
String str = "First part second part";

Integers will also be converted to String after the ( + ) operator:

String str = "Age=" + 25;

Each Java object has the String toString() inherited from the Object class. This method provides a way to convert objects into Strings. Most classes override the default behavior to provide more specific (and more useful) data in the returned String.

The String class provides a nice set of methods for string manipulation. Since String objects are immutable, all methods return a new String object. For example:

   name = name.trim();

The trim() method returns a copy of the string with leading and trailing whitespace removed. Note that the following would do nothing useful:

   name.trim();   // wrong!

This would create a new trimmed string and then throw it away. Study the String class and its methods carefully. Strings are ubiquitous in Java; it will serve you well to know how to manipulate them skillfully.

Using StringBuffer/StringBuilder to concatenate strings

Remember that String objects are immutable objects. Once a String is created, it can not be modified, takes up memory until garbage collected. Be careful of writing a method like this :

public String convertToString( Collection coll )
{
   String str = "";
   Iterator iter = coll.iterator();
   while ( iter.hasNext() ) // loops through every element in coll
   {
      String oneElem = (String) iter.next();
      str = str + oneElem + " ";
   }
  return str;
}

On the ( + ) operation a new String object is created at each iteration. Suppose coll contains the elements ["Foo", "Bar", "Bam", "Baz"]. The method creates five Strings ("", "Foo ", "Foo Bar ", "Foo Bar Bam ", and "Foo Bar Bam Baz") even though only last one is actually useful.

Instead use StringBuffer, as shown below, where only one StringBuilder object is created:

To avoid unnecessary memory use like this, use the StringBuffer or StringBuilder class. They provide similar functionality to Strings, but store their data in a mutable way. Also because object creation is time consuming, using StringBuffer or StringBuilder produces much faster code.

public String convertToString( Collection coll )
{
   StringBuilder buf = new StringBuilder();
   Iterator iter = coll.iterator();
   while ( iter.hasNext() ) // loops through every element in coll
   {
      String oneElem = (String) iter.next();
      buf.append( oneElem );
      buf.append( " " );
   }
  return buf.toString();
}

StringBuilder was introduced in Java 5. Unlike StringBuffer, StringBuilder isn't thread safe, so you can't use it in more than one thread (see the chapter on Concurrency). However, because it doesn't have to worry about synchronization, StringBuilders are faster.

Comparing Strings

Comparing strings is not as easy as it may first seem. We cannot just use a simple equality statement such as:

   if(myString == "Hello World!")       //Can't Use this.
   {
       System.out.println("Match Found");
   }

To test for equality, use the equals(Object) method inherited by every class and defined by String to return true if and only if the object passed in is a String containing the exact same data.

String greeting = "Hello World!";
if(greeting.equals("Hello World!")) { //true
    // ...
}

if(greeting.equals("hello world!")) { //false
    // ...
}

To order String objects, use the compareTo() method, which can be accessed wherever we use a String datatype. Let's take a look at an example:

   String myString = "Hello World!";
   ...
   if(myString.compareTo("Hello World!") == 0 )
   {
       System.out.println("Match Found");
   }

This snippet of code is comparing the String variable myString to "Hello World". The compareTo method returns a negative, zero, or positive number if the parameter is less than, equal to, or greater than the object on which it is called. If myString was to be different, even in the slightest manner we will get a value above or below 0 depending on the exact difference. The result is negative if this String object lexicographically precedes the argument string. The result is a positive integer if this String object lexicographically follows the argument string. Take a look at the Java API for more details.

Splitting a String

Sometimes it is useful to split a string into separate strings, based on a regular expression. (For more information on regular expressions, see Regex.) The String class has a split() method, since Java 1.4, that will return a String array.

See the following example:

String person = "Brown, John:100 Yonge Street, Toronto:(416)777-9999";
...
String [] personData = person.split( ":" );
...
String name    = personData[0];
String address = personData[1];
String phone   = personData[2];

An other usefull application could be to 'split' the String text based on the 'new line' character, so you could process the text line by line.

Creating substrings

It may also be sometimes useful to create substrings, or strings using the order of letters from an existing string. This can be done in two methods.

The first method involves creating a substring out of the characters of a string from a given index to the end.

For example:

String str    = "coffee";
String substr = str.substring(3);

In this example, substr would return "fee". As previously discussed, the index of the first character in a string is 0. By counting from there, it is apparent that the character in index 3 is the second "f" in "coffee". This is known as the beginIndex. All characters from the beginIndex until the end of the string will be copied into the new substring.

The second method involves a user-defined beginIndex and endIndex. For example:

String str = "supporting";
String substr = str.substring(3,7);

The string returned by substr would be "port". Please note that the endIndex is not inclusive. This means that the last character will be of the index endIndex-1. Therefore, in this example, every character from index 3 to index 6, inclusive, was copied into the substring.

Note: "Substring" is considered to be one word. This is why the method name does not seem to follow the common syntax of Java. It is easy to mistake the method substr() for subStr() (which does not exist and would return with a syntax error on compilation). Just remember that this style only applies to methods or other elements that are made up of more than one word.

Modifying String cases

The String Class also allows for the modification of cases. The two methods that make this possible are toLowerCase() and toUpperCase(). These methods are useful, for example, in the typical programming classroom assignment of evaluating whether or not a string is a palindrome.

String a = "WIKIBOOKS";
String b = "wikipedia";

In this example, a call to a.toLowerCase() would return a result of "wikibooks", and b.toUpperCase() would return "WIKIPEDIA".

See also

• Java API: java.lang.String
• Java API: java.lang.StringBuffer
• Java API: java.lang.StringBuilder
• Java Programming/API/java.lang.StringBuffer
• Java Programming/API/java.lang.StringBuilder

Arrays

Classes, Objects and Types

Java Programming Print version

Flow control

Intro to Arrays

An array is similar to a table of data, keyed by number. In Java an array is an object like all other objects. Look at the following program:

import java.util.*;
 
public class ArrayExample {
	static Scanner input = new Scanner(System.in);
 
	public static void main(String[] args) {
		int numNames = getInt("Number of names?");
		String[] names = new String[numNames];
		for (int i = 0; i < names.length; i++) {
			names[i] = getString("Enter name #" + i);
		}
		for (int i = 0; i < names.length; ++i) {
			System.out.println(names[i]);
		}
	}
 
	public static int getInt(String prompt) {
		System.out.print(prompt + " ");
		int integer = input.nextInt();
		input.nextLine(); // Get rid of this line
                // so that getString won't read it
		return integer;
	}
 
	public static String getString(String prompt) {
		System.out.print(prompt + " ");
		return input.nextLine();
	}
}

Copy the code and compile it. The program will ask you to enter some names then reprints the names in order. It demonstrates three major aspects of arrays: how to define an array, how to set data, and how to access it. The code String[] names = new String[numNames]; tells Java to create an array of size numNames that will store Strings. To set data, use names[x] = data where x is the index to access. Note that all Java arrays start at 0 and go to (array size - 1). Thus, if you dimension an array to size 10, the highest index is 9.

Array Fundamentals

• To create an array, use the syntax DataType[] variable = new DataType[ArraySize]. Alternatively, if you know the data beforehand, you can write DataType[] variable = {item 1, item 2,...item n}
  • All elements of the array will be automatically initialized with the default value for that datatype. This is false for boolean's, 0 for all numeric primitive types, and null for all reference types. So for example, the previous note created an array of DataType references, all of which are initialized to null.
• To access an item, use the syntax variable[i] where i is the index
• To set an item, use the syntax variable[i] = data
• To find the length of an array, use the syntax variable.length

Two-Dimensional Arrays

A two dimensional array is represented by an array of an array. Because an array is also an object, like any other object having the Object as the super class, it can be used to create an array where the element of the array is also an array. In this way an array with any number of dimensions can be created. Here are examples of two dimensional arrays with initializer blocks:

String [][] twoDimArray = { {"00", "01", "02", "03", "04"},
                            {"10", "11", "12", "13", "14"},
                            {"20", "21", "22", "23", "23"} };
...
int [][] twoDimIntArray =  { {00, 01, 02, 03, 04},
                             {10, 11, 12, 13, 14},
                             {20, 21, 22, 23, 24} };

Note that the above "twoDimArray" is equivalent to the following more verbose code:

String [][] twoDimArray = new String[3][];
for (int i = 0; i < twoDimArray.length; i++) {
    twoDimArray[i] = new String[5];
    for (int j = 0; j < twoDimArray[i].length; j++)
        twoDimArray[i][j] = "" + i + j;
}

In the above example we defined an array which has three elements, each element contains an array having 5 elements. We could create the array having the 5 elements first and use that one in the initialize block.

String [] oneDimArray = {"00", "01", "02", "03", "04"};
String [][] twoDimArray = { oneDimArray ,
                            {"10", "11", "12", "13", "14"},
                            {"20", "21", "22", "23", "24"} };

Since they are arrays of array references, these multi-dimensional arrays can be "jagged" (i.e. subarrays can have different lenghts), or the subarray reference can even be null. Consider

String [][] weirdTwoDimArray = { {"10", "11", "12"},
                            null,
                            {"20", "21", "22", "23", "24"} };

Multidimensional Array

Going further any number of dimensional array can be defined.

<elementType>[][]...[] <arrayName>
or
<elementType><arrayName>[][]...[]

Data and Variables

A variable in Java can store two kinds of variables:

• Java primitive type values
• a reference to a Java object

Java's primitive types are

• integers (whole numbers, declared as byte, short, int, or long; only int need be of interest to a beginner)
• floating-point numbers (decimal numbers, declared as float or double; only float need be of interest at first)
• characters (declared as char, representing one character like 'A' or ',')
• boolean (holding only true or false as values)

In addition, the Java language has special features for its String class, and strings can be treated very much like primitives for many purposes.

As in most languages, a variable is declared to be a particular type of data; the syntax for a declaration is:

variabletype variablename;

To store a value in a variable, a program statement like

variablename = data;

And can reference the variable (and use the data stored in it) by its name.

For example, to create an int primitive type value, named yr that stores 2007;

int yr = 2007;

To access the data in yr, use the variable in place of the number.

System.out.println(yr);

Produces