What Can Java Technology Do?
The general-purpose, high-level Java programming language is a powerful software platform.
Every full implementation of the Java platform gives you the following features:
Development Tools: The development tools provide everything you'll need for compiling, running, monitoring, debugging,
and documenting your applications. As a new developer, the main tools you'll be using are the javac compiler, the java launcher, and the javadoc documentation tool.
Application Programming Interface (API): The API provides the core functionality of the Java programming language.
It offers a wide array of useful classes ready for use in your own applications.
It spans everything from basic objects, to networking and security, to XML generation and database access, and more.
The core API is very large; to get an overview of what it contains, consult the Java SE Development Kit 6 (JDKTM 6) documentation.
Deployment Technologies: The JDK software provides standard
mechanisms such as the Java Web
Start software and Java Plug-In software for deploying your applications to end users.
User Interface Toolkits: The Swing and Java 2D toolkits make it
possible to create sophisticated Graphical User Interfaces (GUIs).
Integration Libraries: Integration libraries such as the Java IDL API, JDBCTM API, Java Naming and
Directory InterfaceTM ("J.N.D.I.") API, Java RMI, and Java Remote Method Invocation over Internet Inter-ORB Protocol Technology (Java RMI-IIOP
Technology) enable database access and manipulation of remote
objects.
How Will Java Technology Change My Life?
We can't promise you fame, fortune, or even a job if you learn the Java programming
language. Still, it is likely to make your programs better and requires less effort than other languages.
We believe that Java technology will help you do the following:
Get started
quickly: Although the Java programming language is a powerful object-
oriented language, it's easy to learn, especially for programmers already familiar with C
or C++.
Write less code: Comparisons
of program metrics (class counts, method counts, and so on) suggest that a
program written in the Java programming language can
be four times
smaller than the same program written in C++.
Write better code: The Java programming
language encourages good coding practices, and automatic garbage collection helps you avoid memory leaks. Its
object orientation, its JavaBeansTM component architecture,
and its wide-ranging, easily extendible API let you reuse existing, tested code and introduce
fewer bugs.
Develop programs more quickly: The Java
programming language is simpler than C++, and as such, your development time could be
up to twice as fast when writing in it.
Your programs will also require fewer lines of code.
Avoid platform dependencies: You can keep
your program portable by avoiding the use of libraries written in other languages.
Write once, run anywhere:
Because applications written in the Java programming language are compiled into machine-independent
bytecodes, they run consistently on any Java
platform.
Distribute software more easily: With Java Web Start software, users will be
able to launch your applications with a single click of the mouse. An automatic
version check at startup ensures that users are always up to date with the
latest version of your software. If an update is available, the Java Web Start software
will automatically update their installation.
The Java Programming Language
The Java programming language is a high-level language that
can be characterized by all of the following buzzwords:
Simple
Architecture neutral
Object oriented
Portable
Distributed
High performance
Multithreaded
Robust
Dynamic
Secure
Each of the preceding buzzwords is explained in The Java Language Environment , a white paper written by James Gosling and Henry McGilton.
In the Java programming language, all source code is first written in plain text files ending with the .java extension. Those source files are then
compiled into .class files by the javac
compiler. A .class file does not contain code that is native to your processor; it instead contains
bytecodes — the machine language of the Java Virtual Machine1 (Java VM).
The java launcher tool then runs your application with an instance of the Java
Virtual Machine.
An overview of the software development
process.
Because the Java VM is available on many different operating systems, the
same .class files are capable of running on Microsoft Windows, the Solaris TM Operating System
(Solaris OS), Linux, or Mac OS. Some virtual machines, such as the Java HotSpot virtual machine, perform additional steps at runtime to
give your application a performance boost. This include various tasks such as finding performance bottlenecks and
recompiling (to native code) frequently used sections of code.
Through the Java VM, the same application is capable of running on multiple platforms.
The Java Platform
A platform is the hardware or software environment in which a program runs.
We've already mentioned some of the most popular platforms like Microsoft Windows, Linux, Solaris OS, and Mac OS. Most
platforms can be described as a combination of the operating system and underlying hardware. The Java platform
differs from most other platforms in that it's a software-only platform that runs on top of other hardware-based platforms.
The Java platform
has two components:
The Java Virtual Machine
The Java Application Programming
Interface (API)
You've already been introduced to the Java Virtual Machine; it's the base for the Java platform and is ported
onto various hardware-based platforms.
The API is a large collection of ready-made software
components that provide many useful capabilities. It is grouped into libraries of related classes and interfaces; these
libraries are known as packages. The next section, What Can Java Technology Do? highlights some of the functionality
provided by the API.
The API and Java Virtual Machine insulate the program from the underlying hardware.
As a platform-
independent environment, the Java platform can be a bit slower than native
code. However, advances in compiler
and virtual machine technologies are bringing performance close to that of native code without
threatening portability.
"Hello World!" for the NetBeans IDE
It's time to write your first
application! These detailed instructions are for users of the NetBeans
IDE. The NetBeans IDE runs on the Java
platform, which means that you can use it
with any operating system for which there
is a JDK 6 available. These operating systems
include Microsoft Windows, Solaris OS, Linux, and
Mac OS X.
A Checklist
Creating Your
First Application
Create an IDE Project
Add
JDK 6 to the Platform List
(if necessary)
Add Code to the Generated
Source File
Compile the Source File
Run
the Program
Continuing the Tutorial with
the NetBeans IDE
--------------------------------------------------------------------------------
A Checklist
To write your
first program, you'll need:
The Java
SE Development Kit 6 (JDK 6)
For
Microsoft Windows, Solaris OS, and Linux: http://java.sun.com/javase/6/download.jsp
For
Mac OS X: http://connect.apple.com
The NetBeans IDE
For all platforms: http://www.netbeans.info/downloads/index.php
--------------------------------------------------------------------------------
Creating Your First Application
Your
first application, HelloWorldApp, will simply display the greeting "Hello World!".
To create this program, you will:
Create an
IDE project
When you create an IDE project, you create
an environment in which to build and
run your applications. Using IDE projects eliminates
configuration
issues normally associated with developing on
the command line. You can
build or run your application by choosing a single menu item within the
IDE.
Add code to the generated source
file
A source file contains code, written in
the Java programming language, that you and other programmers can
understand. As part of creating an IDE
project, a skeleton source file will
be automatically generated. You will then modify the source
file to add the "Hello World!" message.
Compile
the source file into a .class file
The
IDE invokes the Java programming language compiler
(javac), which takes your source file and translates its
text into instructions that the Java virtual
machine can understand. The instructions contained within this file
are known as bytecodes.
Run the program
The IDE invokes the Java application launcher tool (java), which uses the
Java virtual machine to run your application.
top
--------------------------------------------------------------------------------
Create an IDE Project
To create an IDE project:
Launch the NetBeans IDE.
On Microsoft Windows systems, you can
use the NetBeans IDE item in the Start menu.
On Solaris OS and Linux systems, you
execute the IDE launcher script by navigating to the IDE's bin directory
and typing ./netbeans.
On Mac OS X systems,
click the NetBeans IDE application icon.
In the NetBeans IDE, choose
File | New Project.
In the New Project wizard,
expand the General category and select Java
Application as
shown in the following figure:
In
the Name and Location
page of the wizard, do the
following (as shown in
the figure below):
In the Project Name
field, type Hello
World App.
In the Create Main
Class field, type helloworldapp.HelloWorldApp.
Leave the Set
as Main Project checkbox selected.
Click Finish.
The project is created and opened in the IDE. You should see the following
components:
The Projects window, which contains
a tree view of the components of
the project, including source files, libraries that
your code depends on, and so on.
The Source Editor window with a
file called HelloWorldApp open.
The Navigator window, which you can use to quickly
navigate between elements within the selected class.
Add Code
to the Generated Source File
When
you created this project, you left the Create Main Class checkbox
selected in the New Project wizard. The IDE has
therefore created a skeleton class for you. You
can add the "Hello World!" message
to the skeleton code by replacing the line:
// TODO code application logic here
with the line:
System.out.println("Hello World!"); // Display the string.
Optionally, you
can replace these four lines of generated code:
/**
*
* @author
*/
with
these lines:
/**
* The HelloWorldApp class implements an application that
* simply prints "Hello World!" to standard output.
*/
These
four lines are a code comment
and do not affect how the program
runs. Later sections of this tutorial explain the use
and format of code
comments.
Save your changes by choosing File | Save.
The file should look something like the
following:
/*
* HelloWorldApp.java
*
* Created on February 5, 2006, 6:43 PM
*
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/
package helloworldapp;
/**
* The HelloWorldApp class implements an application that
* simply prints "Hello World!" to standard output.
*/
public class HelloWorldApp {
/** Creates a new instance of HelloWorldApp */
public HelloWorldApp() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
System.out.println("Hello World!"); // Display the string.Continuing the Tutorial with the NetBeans IDEThe next few pages of the tutorial will explain the code in this simple application. After that, the lessons go deeper into core language features and provide many more examples. Although the rest of the tutorial does not give specific instructions about using the NetBeans IDE, you can easily use the IDE to write and run the sample code. The following are some tips on using the IDE and explanations of some IDE behavior that you are likely to see:Once you have created a project in theIDE, you can add files to the projectusing the New File wizard. Choose File |New File, and then select a template in the wizard, such as the Empty Java File template.You can compile and run an individual file (as opposed to a whole project) using the IDE's Compile File (F9) and Run File (Shift-F6)commands. If you use the Run Main Project command, the IDE will run the file that the IDE associates as the main class of the main project. Therefore, if you create an additional class in your HelloWorldApp projectand then try to run that file with the Run Main Project command, the IDE will run the HelloWorldApp file instead.You might want to create separate IDE projects for sample applications that include more than one source file.As you are typing in the IDE, a code completion box might periodically appear.You can either ignore the code completion box and keep typing, or you can select one of the suggested expressions. If you would prefer not to have the code completion boxautomatically appear, you can turn off the feature. Choose Tools | Options, click the Editor tab, and clearthe Auto Popup Completion Window checkbox.If you try to rename the node for a sourcefile in the Projects window, the IDE promptsyou with the Rename dialog box to lead you through the options of renaming the class and the updating of code that refers to that class. Click Next to display the Refactoring window, which contains a tree view of changes to be made. Then click Do Refactoring to apply the changes. This sequence of clicks might seem unnecessary ifyou have just a single class in your project, but it is very useful when your changes affect other parts of your code in larger projects.For a more thorough guide to the features of the NetBeans IDE,see the NetBeans IDE Docs and Support page or explore the documentation available from the IDE's Help menu.
