Module 1 Study Guide

History
Java language, originally called the ‘Oak’, was developed by James Gosling
at Sun Microsystems, which is now a subsidiary of Oracle Corporation, and
released in 1995 as a core component of Sun Microsystems' Java platform.
It has derived much of its syntax from C and C++ but has a simpler object
model and fewer low-level facilities.

Java is a general-purpose, concurrent, class-based, object-oriented

language that is specifically designed to have as few implementation
dependencies as possible.
The Java source code files (files with .java extension) are compiled into a
format called bytecode (files with .class extension), which can be executed by a
Java interpreter.

It was intended for use in Sun’s project research to work on a programming

software to control electronic devices.
It was modified to take advantage of the World Wide Web. The
WebRunner, later named as HotJava, was the very first web browser created in
Java.
In 1995, the Netscape Navigator internet browser was also developed to
support Java.

Features of Java:
1. Simple, Object-oriented, and Familiar
Java can be programmed without extensive programmer
training while being attuned to current software practices.
The needs of distributed, client-server based systems coincide
with the encapsulated, message-passing paradigms of object-
based software.
It looks like C++ as far as possible results in it being a familiar
language, while removing the unnecessary complexities of C++.
2. Robust and Secure
It provides extensive compile-time checking, followed by a
second level of run-time checking
 Java technology is designed to operate in distributed
environments, which means that security is of paramount
importance
3. Architecture Neutral and Portable
Java technology is designed to support applications that will be
deployed into heterogeneous network environments.
To accommodate the diversity of operating environments, the
Java compiler product generates bytecode – an architecture
neutral intermediate format designed to transport code
efficiently to multiple hardware and software platforms. The
interpreted nature of Java technology solves both the binary
distribution problem and the version problem; the same Java
programming bytecodes will run on any platform.
4. High Perforrnance
The automatic garbage collector runs as a low priority
background thread, ensuring a high probability that memory is
available when required, leading to better performance.
5. Interpreted, Threaded, and Dynamic
The Java interpreter can execute the bytecodes directly on any
machine to which the interpreter and run-time system have
been ported.
Java technology’s multi-threading capability provides the
means to build applications with many concurrent threads of
activity. Multi-threading thus results in a high degree of
interactivity with end users.
While Java compiler is strict in its compile-time static checking,
the language and run-time system are dynamic in their linking
stages.

Java Editions:
J2SE: Java 2 Standard Edition
J2EE: Java 2 Enterprise Edition
J2ME: Java 2 Micro Edition

The Java Virtual Machine (JVM)

 Java is a portable language that could run on any platform. The language
was able to do this by generating intermediate code for a hypothetical
computer called a virtual machine.

The Java source code (.java file) is normally compiled to produce the
bytecode file (.class file) which is normally interpreted by the Java virtual
machine (JVM).

The J2SDK (JDK)

Java 2 Software Development Kit contains
• java – the loader for Java applications
• javac – the compiler
• javadoc – the documentation generator
• other tools

Steps in Creating a Java Application

1. Create the source code.
2. Compile the source code.
3. Run the program.

Steps 1 : Creating the source code

Create the source code using any text editor.
Save the file with a “.java” extension.
Example: HelloJava.java

Steps 2 : Compiling the source code

Compile the source code to create the byte code using javac tool from the
J2SDK.
Open an MS-DOS console, browse for the directory where you saved the
source code.
Type the command javac HelloJava.java and press ENTER.
Verify that the HelloJava.class has been created.

Steps 3 : Running the Program

To execute the program, type the command: java HelloJava and press
ENTER.
Exploring Netbeans IDE
• An Integrated Development Environment is a computer software to help
computer programmers develop software.
• The Leaders:
- NetBeans
- Microsoft Visual Studio
- Eclipse
• What does an IDE consist of:
- Source code Editor.
- Compiler and/or interpreter.
- Build- automation tools.
• Optional Tools:
- Debugger.
- Version control system.
- Various tools to simplify the construction of a GUI.
• Tools For Object Oriented Design:
- Object inspector.
- Class Browser.
- Class hierarchy diagram.

• IDE abstracts the configuration necessary to piece together various utilities

in one unit, which could ease the learning of a language, and increases
developer productivity.
• Most IDEs today have GUI modeling utilities that simplify the development
of UIs, which is critical for commercial software today.

• The History Of NetBeans

• It all started as a student project called Xelfi
• The Goal was to write a Delphi- like Java IDE in Java for the first time.
• The original plan was to develop network-enabled JavaBeans components,
hens the name. but coming out of the spec for enterprise changed the
plans.
• Sun decided it needs a more powerful Java development tool, and the rest
is history.
• A fast fully-featured Integrated Development Environment (IDE) with
support for Java.
• Compliant applications for accelerating development across all major OS
platforms.
• Provides an open source, high performance, modular, extensible, multi-
platform Java IDE for GUI, mobile tools, Web, and Desktop applications.
• Written in java and therefore runs on every operating system that supports
Java VM.

NetBeans Features
• Environment: easily configured user interface and a modular architecture
extensible with additional plugins.
• Project System: support for multiple source roots, easy management of
libraries, easily ported to other environments, all based on Apache Ant.
• Web Development: Web Application project type, Supports the J2EE 1.3
and 1.4 standards with web application build support based on Apache Ant.
• Enterprise Java Beans (EJB) Development: easy to create and deploy and
import java beans.
• Web Services Development: wizards for creating web services and web
services clients, providing the basic (java/wsdl) code needed, and easy to
use testing tools of existing web services.
• Java 2 Platform, Micro Edition (J2ME) MIDP development: visual design
editor with end-to-end support for enterprise applications.
• Code Editor: Syntax highlighting for Java, XML, HTML, CSS, JSP and IDL, full
support of new JDK 1.5 features, live parsing/error marking, popup javadoc,
code completion, and fast class importing.
• Refactoring: renaming, changing and moving of various objects, field
encapsulation and usage finding.
• Award Winning Debugger: Language independent debugger core, variable
modification and watches, various breakpoints and “Fix and Continue”
mechanism.
• GUI Builder: fully WYSIWYG designer with "Test Form" feature, extensible
Component Palette pre-installed Swing and AWT components, showing a
components tree and properties, automatic code generation and full
JavaBeans support.
• Version control Support: supports command lined vcs, supplying merging
and diff tools and containing a built- in CVS client.
• XML: XML, DTD and CSS Text Editor and XML Productivity Tools Wizards to
help user generate codes.

NetBeans Extras
• NetBeans Profiler: provides information about the runtime behavior of
applications. Allows developers to monitor the thread state, CPU
performance, and memory usage of their applications. makes it easy to
track down performance problems and memory leaks.
• NetBeans Platform: provides the services common to almost all large
desktop applications such as: window, menu, settings management and
storage, file access and more.
• NetBeans Mobility Pack: used to write, test, and debug applications for the
Java Micro Edition platform (J2ME) technology-enabled mobile devices. It
integrates support for the Mobile Information Device Profile (MIDP) 2.0,
the Connected, Limited Device Configuration (CLDC) 1.1.
• The mobility pack allows for the unique “On-Phone” debugging mode.

NetBeans Matisse
• The Goal: to take the best features from OSX and VS designers and allow
the same possibilities for Java Programmers.
• In order to reach that goal there was a need to develop a new layout
manager to support all the needed functionalities.
• Matisse provides a simple and intuitive layout of GUIs without having to
understand the complexities of Swing layout managers.
• As you drag and drop components into a form, the IDE automatically
suggests alignment, spacing, and resizing constraints.
• By simply right clicking a UI Object you can add an event handler with a
method waiting to be implemented without knowing too much about the
surrounding of this object. (watch example clip in the site)

NetBeans Matisse - Advantages

• For the first time, there’s an intelligent way to build GUI for Java (unlike
eclipse), that can actually compete with the Visual Studio Gui builder.
• Supports internationalization, and industrial look-and-feel rules, which is
very important for large scale application meant to be spread world wide.
• Builds also GUI web applications, HTML, JSP, etc
• No built-in support for Drag-n-Drop or double-click events.
• Matisse’s code is protected so customizing is not very easy and not always
possible.
• Not all applications are easily built. For instance, an MDI Project is not that
trivial to build

Installation
• Installing JDK: in order to install NetBeans you need to first install JDK. You
can easily find an installation in Sun’s web site.
• NetBeans installation: you can find the installations kits for all the versions
in the NetBeans home page.
• Installation steps: you can watch a movie describing the installation step by
step in the.

• Quick Start Guide

• Starting up a project
• Creating and editing java source code
• Compiling and running a project
• Testing and debugging a project

Starting Up A Project
• When creating a new project, NetBeans already includes all the needed
packages for compiling and testing. It also outlines the sources by the right
logical directories and creates the files that are mandatory. For instance, if
you create a new java application you must implement a main class and so
it’s automatically created.

Editing and Refactoring

• When editing a code you can see the difference between the old version
and the new version when using the Code Completion tool.
• You can use “Find Usage” tool when working on a project to predict the
changes you will need to make.
• You can use refactoring to easily change places of things without going
through all the code to change it.

Building and Running

• No makefile or manual creation of an Ant file needed (by default). A simple
instruction saying which class to run and what to build will suffice.
Netbeans will create the Ant file automatically.
• While Building you can also generate the javadoc very easily.

Testing
• JUnit Tests: you simply choose the class you want to test and in the tools
menu choose “create JUnit Test”. After filling the arguments NetBeans
automatically creates a test class inheriting from TestCase with the default
methods to implement and puts everything under the Test package.

Debugging
• NetBeans has two modes, run mode and debug mode.
• The debug mode is very easy to use.
• You can use the local variables window and watch window to follow the
progress of the program.

Compiling and Running the Program

Because of the IDE's Compile on Save feature, you do not have to manually
compile your project in order to run it in the IDE.
When you save a Java source file, the IDE automatically compiles it.
The Compile on Save feature can be turned off in the Project Properties
window.
Right-click your project, select Properties. In the Properties window, choose
the Compiling tab.
The Compile on Save checkbox is right at the top.
Note that in the Project Properties window you can configure numerous
settings for your project: project libraries, packaging, building, running, etc.
To run the program:
Choose Run > Run Project.
Press F6/Shift+F6.
Click the run button from toolbar.
Click the play button from output window.
The next figure shows what you should now see.