JAVA TUTORIALS

JAVA STATIC TUTORIAL

2011-10-16T00:36:00.000-04:00

REVISED: Sunday, March 3, 2013

CONTENTS
• I. JAVA STATIC TUTORIAL INTRODUCTION
• II. JAVA STATIC METHOD
• III. JAVA STATIC BINDING
• IV. JAVA STATIC IMPORT
• V. JAVA STATIC TUTORIAL REFERENCES

YOU WILL LEARN:
1. Static methods are methods that perform tasks without creating objects.
2. Static methods are designed for frequently used simple tasks.
3. How to create window dialog boxes.
4. An easy to read way of calling Math class methods.

I. JAVA STATIC TUTORIAL INTRODUCTION

Welcome to the “Java Static Tutorial.”

This tutorial has been prepared using Microsoft Windows, NetBeans IDE 7.0.1 and JDK 1.7.

If you find any errors or better ways of presenting the information please post them as tutorial comments.

II. JAVA STATIC METHOD

A static method is a method that performs a simple common task without creating an object. Arguments in the static method call supply the static method with any data required to complete its task. The “this” keyword can not be used in a static method.

A. STATIC METHOD DECLARATION

Placing the keyword static before the return type in the method’s declaration declares the method static. For example:

public static void main( String[] args ){

}
//end main

An instance of a class (an object) is not created when the static main method is called.

B. STATIC METHOD SYNTAX

The syntax for calling a static method is its class name followed by a dot separator (.) and the method name; for example:

ClassName.methodName( arguments );

The syntax for the static main method is a special case. The Java Virtual Machine (JVM) begins execution of an application with the static main method.

C. CLASS MATH

All Math class methods are static and they are called using the class name followed by a dot separator (.) and the method name “static method syntax.” For example:

package MathPackage;

public class MathClass {

public static void main( String[] args ) {

int x = 9;
int y = 3;

System.out.println( Math.sqrt( x ) );

System.out.println( Math.pow( x, y ) );

}
//end main

}
//end MathClass

As shown in the above program, no Math objects were created before calling either method Math.sqrt or Math.pow.

Class Math Example Output:

3.0
729.0

D. JOPTIONPANE EXAMPLE

Static methods were designed for frequently used simple tasks; for example, coding dialog boxes. The following program is an example of using the static method JOptionPane to create simple window dialog boxes.

package JOptionPanePackage;

import javax.swing.JOptionPane;

/*
Use
JOptionPane.showXxxDialog
when you only need simple
window dialog.
*/

public class JOptionPaneClass {

public static void main( String[] args ){

/*
JOptionPane.showInputDialog
uses a text field
to get a string from the user.
*/
double numerator =
Double.parseDouble(JOptionPane.showInputDialog
( "This program computes a QUOTIENT. \n\n QUOTIENT =" +
" (NUMERATOR / DENOMINATOR) \n\n 1. Type a NUMERATOR," +
" e.g., 999.999 \n 2. then Click OK to continue; \n 3. or, Click" +
" CANCEL to EXIT.\n\n" ));

double denominator =
Double.parseDouble(JOptionPane.showInputDialog
( "1. Type a DENOMINATOR, e.g., 3.3 \n 2. then" +
" Click OK to continue; \n 3. or, Click CANCEL to EXIT.\n " ));

double quotient =
(numerator / denominator);

/*
JOptionPane.showMessageDialog
displays a one-button dialog.
*/
JOptionPane.showMessageDialog
( null, "QUOTIENT equals: \n " +quotient,
"Click OK to Exit.", JOptionPane.PLAIN_MESSAGE );

}
//end main

}
//end class JOptionPaneClass

JOptionPaneClass Example Output:

The output assumes you type in 9 for the Numerator, and 3 for the Denominator, which gives you the 3.0 Quotient.

III. STATIC BINDING

Static binding refers to all static method calls being resolved by the JVM at compile time.

IV. STATIC IMPORT

Static import improves program readability and reduces coding time.

A. Import One Static Member:

Use the following syntax to import one static member of a class.

import static java.packageName.ClassName.staticMemberName;

For example:

package MathPackage;

import static java.lang.Math.sqrt;

public class MathClass {

public static void main( String[] args ) {

int x = 9;

System.out.println( sqrt( x ) );

}
//end main

}
//end MathClass

Import One Static Member Example Output:

3.0

B. Import All Static Members:

Use the following syntax to import all static members of a class.

import static java.packageName.ClassName.*;

Now you can call all Math class methods by name without writing Math in front of any Math method. For example:

package MathPackage;

import static java.lang.Math.*;

public class MathClass {

public static void main( String[] args ) {

int x = 2;
int y = 3;

System.out.println( pow( x, y) );

}
//end main

}
//end MathClass

Import All Static Members Example Output:

729.0

V. JAVA STATIC TUTORIAL REFERENCES

CS106A Computer Science I: Programming Methodology Lectures by Mehran Sahami, Associate Professor, Computer Science Department (450 Serra Mall, Stanford, CA: Stanford University, 2007).

Java How To Program Eighth Edition by Paul Deitel and Harvey Deitel (Upper Saddle River, N.J.: Pearson Education, Inc., 2010).

YOU HAVE LEARNED:
1. Static methods are methods that perform tasks without creating objects.
2. Static methods are designed for frequently used simple tasks.
3. How to create window dialog boxes.
4. An easy to read way of calling Math class methods.

Elcric Otto Circle

-->

-->

-->

How to Link to My Home Page

It will appear on your website as:
"Link to ELCRIC OTTO CIRCLE's Home Page"

JAVA JDK ECLIPSE FOR WINDOWS

2011-09-23T14:14:00.000-04:00

REVISED: Sunday, March 3, 2013

CONTENTS:
I. JAVA JDK ECLIPSE FOR WINDOWS INTRODUCTION
II. DOWNLOADING JAVA JDK
III. INSTALLING JAVA JDK
IV. DOWNLOADING ECLIPSE
V. INSTALLING ECLIPSE
VI. WRITING YOUR FIRST JAVA PROGRAM

YOU WILL LEARN HOW TO:
1. DOWNLOAD JAVA JDK
2. INSTALL JAVA JDK
3. DOWNLOAD ECLIPSE
4. INSTALL ECLIPSE
5. START WRITING JAVA PROGRAMS

I. JAVA JDK ECLIPSE FOR WINDOWS INTRODUCTION

Welcome to the “JAVA JDK ECLIPSE TUTORIAL.”

II. DOWNLOADING JAVA JDK

Start your browser then go to the following website:

http://www.oracle.com/technetwork/java/javase/downloads/index.html

Select the appropriate JAVA Standard Edition (SE) for your computer operating system.

I selected the Windows JDK7 +Java EE Bundle which includes the Java Platform, Enterprise Edition 6 Java Software Development Kit (SDK) Update 3 and the Java Development Kit (JDK) 7.

You need the Java Development Kit (JDK). The JDK lets you write and compile JAVA programs. You also need the Java Runtime Environment (JRE). Depending on what you select, the JRE might be included with the JDK. If the option you select is shown with two column headings, JDK and JRE, you should download both separately.

While you are downloading the Java JDK and JRE, which are appropriate for your computer, I recommend accepting all the defaults, to ensure you have the Java compiler properly downloaded.

III. INSTALLING JAVA JDK

Perform the following steps:

A. From your Start menu click on "My Computer."

B. From "My Computer" click on C:\ your main hard drive.

C. From C:\ click on "Program Files."

D. From "Program Files" open the "Java folder."

E. From the "Java folder" open the folder with the name that includes jdk.

F. From the jdk folder open the bin folder.

G. From the bin folder right click on appletviewer.

H. From the appletviewer click on properties.

I. From properties copy the location path.

J Return to your Start menu and click on My Computer.

K. From My Computer right click on properties.

L. From properties click Advanced System Settings.

M. From Advanced System Settings click "Environment Variables."

N. From "Environment Variables" go to the top section named "New User Variables" and for "Variable name:" type "path"

O. From "Environment Variables" underneath "Variable name:" for "Variable value:" paste the location path you copied in Step 9.

P. From "Environment Variables" click OK and keep clicking OK on each window until you exit out and return to your desk top.

To test to see if everything works properly, from your desk top, click Start then click Run, type cmd, press Enter, and from the command line type javac then press Enter.

If everything works you will be in the java compiler and ready to code your first java program using Notepad or a similar text editor.

I do not recommend using a Notepad type text editor.

I recommend Eclipse.

IV. DOWNLOADING ECLIPSE

Start your browser then go to the following website:

http://www.eclipse.org/downloads/

From the Eclipse website click on downloads.

Download the Eclipse that fits your needs, I downloaded Eclipse Classic.

I recommend accepting all the defaults and you will have the Java Eclipse IDE downloaded.

V. INSTALLING ECLIPSE

The Eclipse download will be a zip file.

Use WinZip or a similar package to unzip and extract the download.

I recommend accepting all the extraction defaults.

A. From your Start menu click on "My Computer."

B. From My Computer click on C:\ your main hard drive.

C. From C:\ click on "Program Files."

D. From "Program Files" open the Eclipse folder.

E. Right click on the purple round Eclipse circle icon, the one with the three white horizontal lines and select "Create Shortcut."

F. Click and drag the shortcut to your desktop.

VI. WRITING YOUR FIRST JAVA PROGRAM

Click the Eclipse shortcut on your desktop. When Eclipse opens follow these steps:

A. Click File, then click New, then click "Java Project."

B. From the Project Name window, type is whatever name you prefer, and then press Finish.

C. You will be returned to the first Eclipse window.

D. On the left side of the window you will see the Project Name you entered. Click the icon to the left to the Project Name and the project will be expanded.

E. Click source the top option src, then click New, then click Class.

F. A new window will open requesting a class name. Type in whatever name you prefer then press Finish.

G. The next window will show the start of the class code. Eclipse will start the code for you. It will say public class {…}.

H. Copy and then paste the following code between the two {…}.

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

Look at the toolbar at the top of the window. Under Refactor you will see an arrow icon pointing to the right. When you move your cursor over the icon it will say Run and your class name. Click the run icon and your first Java program will run. If everything is working properly, in the bottom pane, it will print “Hello World!”

Congratulations! You will soon see Java is easy to learn and fun to use. Have fun!

YOU HAVE LEARNED HOW TO:
1. DOWNLOAD JAVA JDK
2. INSTALL JAVA JDK
3. DOWNLOAD ECLIPSE
4. INSTALL ECLIPSE
5. START WRITING JAVA PROGRAMS

Elcric Otto Circle

-->

-->

-->

How to Link to My Home Page

It will appear on your website as:
"Link to ELCRIC OTTO CIRCLE's Home Page"

JAVA CLASS DESIGN “E = MC^2” TUTORIAL

2011-09-20T11:15:00.001-04:00

REVISED: Sunday, March 3, 2013

CONTENTS:

I. INTRODUCTION

II. E=MC²

III. CLASS

IV. INSTANCE VARIABLES

V. CONSTRUCTORS

VI. INSTANTIATING AN OBJECT

VII. CONSTANTS

VIII. MAIN METHOD

IX. METHODS

X. EXAMPLE PROGRAM

XI. REFERENCES

YOU WILL LEARN:
1. Instance variables.
2. Access modifiers.
3. Constructors.
4. Instantiating an object.
5. Constants.
6. How to use the main() method.
7. Methods.

I. INTRODUCTION

Welcome to Java Class Design E=MC².

This tutorial was prepared using Microsoft Windows, NetBeans IDE 7.0.1 and JDK 1.7.

If you find any errors or better ways of presenting the information please post them as tutorial comments.

II. E=MC²

The “Java ‘Energy Equals Mass Times the Speed of Light Squared’ Tutorial” title was selected to introduce the reader to the Java methods used to demonstrate key points discussed in the tutorial.

In order to create tutorial discussion examples we will write a Java program to compute, “Energy equals mass times the speed of light squared.” Our discussion examples will include a Java energy class and an object of that class, and of course instance variables and methods for computations and printouts.

III. CLASS

Our Java source code begins in the following order: first, a package declaration; second, an import declaration; and third, a class declaration.

The “EEqualsMCSquaredPackage” will be used to contain our class “EEqualsMCSquaredClass.” Java uses packages to group classes in order to make libraries.

We start with the package declaration as shown below:

Classes are organized into packages; therefore, if you want to reuse an existing class, instead of copying the class into your program you import the package containing the class.

package EEqualsMCSquaredPackage;

We will need to square the speed of light; therefore, we import “java.lang.Math.*” in order to make the tutorial coding easier to read.

Static import of math class methods enable calling each Math class method by name without writing Math in front of the Math method.
*/

import static java.lang.Math.*;

Our class declaration starts with the “public” access modifier keyword; therefore, it can be accessed from anywhere.

Next the class declaration has the keyword “class” followed by the class’s name “EEqualsMCSquaredClass.”

Immediately following the class name is a set of open and closed braces “{ }” which will enclose the body of the class.

Class declaration.

public class EEqualsMCSquaredClass {

}
/*
End class EEqualsMCSquaredClass.
*/

IV. INSTANCE VARIABLES

Local variables are declared and used within a method and when the method terminates the local variables are lost.

An object has attributes (instance variables also called data fields or class declaration variables) that are declared when their class is declared and are used within its class. Each object has its own copy of the instance variables. When an object is created Java automatically calls a constructor which initializes the objects instance variables. The life of the object’s copy of its instance variables is the life of the object.

The instance variables for the example program are as follows:

Class declaration.

public class EEqualsMCSquaredClass {

private double M;
/*
Mass of atoms.
*/

private double E;
/*
Energy released.
*/

private double SD;
/*
Sticks of dynamite equivalent to E.
*/

The access modifiers: “public,” “private, “protected” and the default modifier (no modifier) control access to a class’s instance variables. The “private” instance variables can only be accessed by a “public” method from inside their class. The “public” instance variables can be accessed from anywhere in the application. The access to “protected” instance variables is between the access of “public” and “private.” You have to be in the same package to access “protected” instance variables from inside their class.

V. CONSTRUCTORS

As previously mentioned above, each object has its own copy of the instance variables. When an object is created Java automatically calls a constructor which initializes the objects instance variables. The life of the object’s copy of its instance variables is the life of the object.

The instance variable constructors for the example program are as follows:

Object created no arguments passed in default constructor executed.
*/

public EEqualsMCSquaredClass( ){

super();

System.out.println( "\n **************************************************** \n" );

System.out.println( " OBJECT CREATED\n" );

System.out.println( " NO ARGUMENTS PASSED IN\n" );

System.out.println( " DEFAULT CONSTRUCTOR EXECUTED!\n" );

System.out.println( " **************************************************** \n" );

}

/*
Object created three arguments passed in and they match constructor parameters by type and number.
*/

public EEqualsMCSquaredClass( double m, double e, double sd ){

M = m;

E = e;

SD = sd;

System.out.println( "\n **************************************************** \n" );

System.out.println( " OBJECT CREATED\n" );

System.out.println( " THREE ARGUMENTS PASSED IN\n" );

System.out.println( " AND THEY MATCH CONSTRUCTOR PARAMETERS BY TYPE AND NUMBER\n" );

System.out.println( " CONSTRUCTOR EXECUTED!\n" );

System.out.println( " M = " + M + "\n" );

System.out.println( " E = " + E + "\n" );

System.out.println( " SD = " + SD + "\n" );

System.out.println( " **************************************************** \n" );

}

The constructor declaration is the control in the sense that the constructor’s parameters in the constructor declaration have to match the arguments passed in to the constructor by number and type to execute the constructor.

All constructors are located within the class and outside of the class methods.

Every class has at least one constructor. If you declare a default constructor, Java will not create a default constructor for you. The first line inside a default constructor must be a call to the super class constructor “super();” or “this” but not both.

A constructor method:

A. Can be used to assign initial values to an object’s instance variables.

B. Does not have any return type.

C. Has the same name as the class it is in.

D. Has the same access modifier as the class it is in.

E. Can be overloaded.

F. The “this” keyword can be used to ensure an object accesses its own attributes (instance variables also called data fields or class declaration variables).

VI. INSTANTIATING AN OBJECT

(So far we have presented the tutorial in the same order as the example program’s code. However, “constructors” and “instantiating an object” go hand in hand; therefore, to make it easier to explain things we will jump ahead. However, the “instantiating an object” code is located where it is in the example program because the M, E, SD local variable arguments we need to pass to the constructor have not been coded until then.)

When a new object of a class is created a constructor for that class is called automatically to initialize the attributes (instance variables also called data fields or class declaration variables) of the new object.

We start our object declaration with “EEqualsMCSquaredClass” the class name. Next we declare the name of our object, which in the example program is “E1.” Then we type the assignment symbol “=” followed by the keyword “new.” We end the object declaration with the class name “EEqualsMCSquaredClass” followed by an open and closed parenthesis “( M, E, SD )” containing the “arguments” we are passing to the constructor and a statement ending semicolon “;.”

For example:

Creates a new EEqualsMCSquaredClass class object named E1 passes three arguments to the constructor.
*/

EEqualsMCSquaredClass E1 = new EEqualsMCSquaredClass( M, E, SD );

The arguments passed from the instantiating an object code must match the constructor’s parameters by number and type; however, they do not have to have the same name.

VII. CONSTANTS

Within the class body, after the constructors, we declare two constants: “C” the speed of light in meters per second, and “D” the Joules of energy in one stick of dynamite. For example:

C = speed of light, measured in meters per second (mps).
*/

public static final double C = 299792458;

D = Joules of energy in one stick of dynamite.
*/

public static final double D = 2100000;

The declaration of “C” starts with the “public” access modifier keyword. Placing the keyword “static” before the return type in the declaration declares the variable static which means “C” is a class variable common to all objects of the class. The keyword “final” means the class variable “C” is a constant. Also, “final” is used to ensure “C,” the speed of light, is not modifiable by assignment.

We follow the same steps to declare “D.”

VIII. MAIN METHOD

The method main begins the execution of the application and is shown as follows:

main() method begins execution of Java application.
*/

public static void main( String[] args ){

}
/*
End main.
*/

The main method declares the local variables and makes the method calls.

A. LOCAL VARIABLES

The following local variables are declared and used within the main method; and, when the main method terminates the local variables are lost.

The type of the function call must match the return type of the method being called.

Each function’s arguments passed to a method must match the number and type of the called method’s parameters.

M = the total mass of hydrogen atoms, measured in kilograms (kg), in one kg of pure water.
*/

double M = .111;

Computes j of energy released equals kg of atom mass times the mps of light squared.

double E = setEnergyReleased( M, C );

Computes equivalent sticks of dynamite.
*/

double SD = setSticksOfDynamite( E, D );

B. METHOD CALLS

The arguments passed to the methods must match the called method’s parameters by number and type.

Notice in the examples below we are using the new object we created, named E1, to call methods. We are doing this to pass the appropriate attributes of E1 to the method as arguments. If we created multiple objects, each object we created would have its own unique attributes.

Calls method using new object and prints kg of atom mass.
*/

E1.one( M );

Calls method using new object and prints mps of light.
*/

E1.two( C );

Calls method using new object and prints j of energy released and prints equivalent sticks of dynamite.
*/

E1.three( E, SD );

IX. METHODS

As shown below, the method’s parameters control the number and type of arguments passed to the method from the calling function.

Each method’s type must be the type returned by the method. The function calling the method must have the same type as the type returned by the method.

Computes j of energy released equals kg of atom mass times the mps of light squared.
*/

public static double setEnergyReleased( double M, double C ) {

return ( M * pow( C, 2 ) );

}
/*
End getEnergyReleased method.
*/

Computes equivalent sticks of dynamite.
*/

public static double setSticksOfDynamite( double E, double D ) {

return ( E / D );

}
/*
End getSticksOfDynamite method.
*/

/*
Prints kg of atom mass.
*/

public void one( double M ) {

System.out.println( "Given that:\n" );

System.out.println( "1. One kilogram (kg) of pure water contains a mass of " );

System.out.println(" M = " + M + " kg of hydrogen atoms.\n" );

}
/*
End method one.
*/

/*
Prints mps of light.
*/

public void two( double C ) {

System.out.println( "2. And, C = the speed of light which is approximately" );

System.out.println( " " + C + " meters per second (mps).\n");

}
/*
End method two.
*/

Prints j of energy released prints equivalent sticks of dynamite.
*/

public void three( double E, double SD ) {

System.out.println( "3. Then, using the equation E = M ( C * C )" );

System.out.println( " the energy which could be released from one kilogram of pure water," );

System.out.println( " excluding the energy released by the oxygen atoms therein, is approximately" );

System.out.println( " " + E + " Joules (j).\n" );

System.out.println( " A stick of dynamite contains roughly 2.1E6 Joules of energy.\n" );

System.out.println( " Therefore, the energy released equals approximately " + SD + " sticks of dynamite!\n" );

System.out.println( " **************************************************** \n\n" );

}
/*
End method three.
*/

X. EXAMPLE PROGRAM SOURCE CODE

The example program is as follows:

Classes are organized into packages; therefore, if you want to reuse an existing class, instead of copying the class into your program you import the package containing the class.
*/

package EEqualsMCSquaredPackage;

Static import of math class methods enable calling each Math class method by name without writing Math in front of the Math method.
*/

import static java.lang.Math.*;

Class declaration.

public class EEqualsMCSquaredClass {

private double M;
/*
Mass of atoms.
*/

private double E;
/*
Energy released.
*/

private double SD;
/*
Sticks of dynamite equivalent to E.
*/

Object created no arguments passed in default constructor executed.
*/

public EEqualsMCSquaredClass( ){

super();

System.out.println( "\n **************************************************** \n" );

System.out.println( " OBJECT CREATED\n" );

System.out.println( " NO ARGUMENTS PASSED IN\n" );

System.out.println( " DEFAULT CONSTRUCTOR EXECUTED!\n" );

System.out.println( " **************************************************** \n" );

}

Object created three arguments passed in and they match constructor parameters by type and number.
*/

public EEqualsMCSquaredClass( double m, double e, double sd ){

M = m;

E = e;

SD = sd;

System.out.println( "\n **************************************************** \n" );

System.out.println( " OBJECT CREATED\n" );

System.out.println( " THREE ARGUMENTS PASSED IN\n" );

System.out.println( " AND THEY MATCH CONSTRUCTOR PARAMETERS BY TYPE AND NUMBER\n" );

System.out.println( " CONSTRUCTOR EXECUTED!\n" );

System.out.println( " M = " + M + "\n" );

System.out.println( " E = " + E + "\n" );

System.out.println( " SD = " + SD + "\n" );

System.out.println( " **************************************************** \n" );

}

C = speed of light, measured in meters per second (mps).
*/

public static final double C = 299792458;

D = Joules of energy in one stick of dynamite.
*/

public static final double D = 2100000;

Main method begins execution of Java application.
*/

public static void main(String[] args) {

M = the total mass of hydrogen atoms, measured in kilograms (kg), in one kg of pure water. */

double M = .111;

Computes j of energy released equals kg of atom mass times the mps of light squared.
*/

double E = setEnergyReleased( M, C );

Computes equivalent sticks of dynamite.
*/

double SD = setSticksOfDynamite( E, D );

Creates a new EEqualsMCSquaredClass class object named E1 passes three arguments to the constructor.
*/

EEqualsMCSquaredClass E1 = new EEqualsMCSquaredClass( M, E, SD );

Calls method using new object and prints kg of atom mass.
*/

E1.one( M );

Calls method using new object and prints mps of light.
*/

E1.two( C );

Calls method using new object and prints j of energy released and prints equivalent sticks of dynamite.
*/

E1.three( E, SD );

}
/*
End main.
*/

Computes j of energy released equals kg of atom mass times the mps of light squared.
*/

public static double setEnergyReleased( double M, double C ) {

return ( M * pow( C, 2 ) );

}
/*
End getEnergyReleased method.
*/

/*

Computes equivalent sticks of dynamite.
*/

public static double setSticksOfDynamite( double E, double D ) {

return ( E / D );

}
/*
End getSticksOfDynamite method.
*/

/*
Prints kg of atom mass.
*/

public void one( double M ) {

System.out.println( "Given that:\n" );

System.out.println( "1. One kilogram (kg) of pure water contains a mass of " );

System.out.println(" M = " + M + " kg of hydrogen atoms.\n" );

}
/*
End method one.
*/

/*
Prints mps of light.
*/

public void two( double C ) {

System.out.println( "2. And, C = the speed of light which is approximately" );

System.out.println( " " + C + " meters per second (mps).\n");

}
/*
End method two.
*/

Prints j of energy released prints equivalent sticks of dynamite.
*/

public void three( double E, double SD ) {

System.out.println( "3. Then, using the equation E = M ( C * C )" );

System.out.println( " the energy which could be released from one kilogram of pure water," );

System.out.println( " excluding the energy released by the oxygen atoms therein, is approximately" );

System.out.println( " " + E + " Joules (j).\n" );

System.out.println( " A stick of dynamite contains roughly 2.1E6 Joules of energy.\n" );

}
/*
End method three.
*/

}
/*
End class EEqualsMCSquaredClass.
*/

Example Program Output:

************************************

OBJECT CREATED

THREE ARGUMENTS PASSED IN

AND THEY MATCH CONSTRUCTOR PARAMETERS BY TYPE AND NUMBER

CONSTRUCTOR EXECUTED!

M = 0.111

E = 9.976182483978676E15

SD = 4.750563087608893E9

*************************

Given that:

1. One kilogram (kg) of pure water contains a mass of
M = 0.111 kg of hydrogen atoms.

2. And, C = the speed of light which is approximately
2.99792458E8 meters per second (mps).

3. Then, using the equation E = MC²
the energy which could be released from one kilogram of pure water,
excluding the energy released by the oxygen atoms therein, is approximately
9.976182483978676E15 Joules (j).

A stick of dynamite contains roughly 2.1E6 Joules of energy.

Therefore, the energy released equals approximately
4.750563087608893E9 sticks of dynamite!
************************************

XI. REFERENCES

CS106A Computer Science I: Programming Methodology Lectures by Mehran Sahami, Associate Professor, Computer Science Department (450 Serra Mall, Stanford, CA: Stanford University, 2007).

Java How To Program Eighth Edition by Paul Deitel and Harvey Deitel (Upper Saddle River, N.J.: Pearson Education, Inc., 2010).

YOU HAVE LEARNED:

1. Instance variables.

2. Access modifiers.

3. Constructors.

4. Instantiating an object.

5. Constants.

6. How to use the main() method.

7. Methods.

Elcric Otto Circle

-->

-->

-->

How to Link to My Home Page

It will appear on your website as:
"Link to ELCRIC OTTO CIRCLE's Home Page"

JAVA ECLIPSE DEBUGGER

2011-09-19T16:39:00.004-04:00

REVISED: Sunday, March 3, 2013

CONTENTS:

I. WORKSPACE

II. PROJECT

III. JAVA PACKAGE

IV. CLASS

V. ECLIPSE SDK SOURCE EDITOR

VI. ECLIPSE DEBUGGER

VII. DEBUGGING EXAMPLE PROGRAM ANALYSIS

VIII. DEBUGGING EXAMPLE PROGRAM SOURCE CODE

IX. REFERENCES

YOU WILL LEARN HOW TO:

1. Create a Java Project.

2. Create a Java Package.

3. Create a Java Class.

4. Use the Eclipse Source Editor.

5. Use the Eclipse Debugger.

I. WORKSPACE

Start Eclipse.

From the Java Eclipse SDK left click File and select Switch Workspace. This option shows you the path to your workspace location.

On my computer my Java workspace location is as follows:

C:\Eclipse Workspace

II. PROJECT

The Java project contains source code and related files for building a java program.

Perform the following steps to create a project using the Eclipse New Project Wizard:

A. From the Java Eclipse SDK click File.

B. From File select New.

C. From New select Project.

D. From the New Java Project wizard, at “Project name” type in your project name then accept the other defaults on this window by pressing Next. The example program Project name is frakal.

E. From the New Java Project wizard next window accept the default options by pressing Finish. Eclipse will create your project and return you to the Java - Eclipse SDK.

III. JAVA PACKAGE

A Java Package contains related class files and allows you to use short-cut class names.

Perform the following steps to create a package:

A. From the Java Eclipse SDK Package tab window select the appropriate project folder where you want the Package created, right click the project folder and select New.

B. From New select Package to launch the Eclipse New Java Package Wizard.

C. From the New Java Package Wizard, at package “Name” type the package name. The example program package name is frakal.

D. From the New Java Package Wizard click Finish. The package will be created and you will be returned to the Java - Eclipse SDK.

IV. CLASS

A class is a blueprint for creating objects.

Perform the following steps to create a class:

A. From the Java Eclipse SDK Package tab window select the appropriate package in the src folder, right click the package, and select New.

B. From New select Class to launch the Eclipse New Java Class Wizard.

C. From the Eclipse New Java Class Wizard, at “Name” type in a class name. The example program class name is frakal.

D. From the Eclipse New Java Class Wizard accept the default settings by selecting Finish. The class will be created and you will be returned to the Java Eclipse SDK.

V. ECLIPSE SDK SOURCE EDITOR

A. Java Eclipse SDK Editor Window Font

If you want to change the Java Eclipse SDK Editor Window font to make the text easier to read perform the following steps:

1. From the Java Eclipse SDK Editor Window, left click Window.

2. From Window left click Preferences.

3. From Preferences left click General.

4. From General left click Appearance.

5. From Appearance left click Colors and Fonts.

6. From Colors and Fonts left click Java Editor Text Font.

7. From Java Editor Text Font left click the Edit button.

8. From Java Editor Text Font select the font you prefer, for example 12 point and bold to make it easier to see.

9. From Java Editor Text Font left click OK.

10. From Java Editor Text Font left click Apply.

11. From Java Editor Text Font left click OK and you will be returned to the Java Eclipse SDK Editor Window.

You can repeat these steps at any time and adjust the font to whatever size you need to make it easy to read the source code.

B. Java Eclipse SDK Editor Window Size

To give you more space, double left click on the tab at the top left of the Editor Window where your class appears, and the Editor Window will expand to full screen to give you more screen work area room.

C. Editor Line Numbers

Perform the following steps if you would like to have source code line numbers:

1. From the Java Eclipse SDK Editor Window left click Window.

2. From Window left click Preferences.

3. From Preferences left click General.

4. From General left click Editors.

5. From Editors left click Text Editors.

6. From Text Editors left click the box that says Show Line Numbers.

7. From Text Editors left click Apply.

8. From Text Editors left click OK and you will be returned to the Java Eclipse SDK Editor Window.

At this point your Java Eclipse SDK Editor Window should contain something similar to the following based on the names you selected:

package frakal;

public class frakal {

}

Notice the first line is the “package statement” ending with a semicolon.

The third line is the “class statement.” The body of the class is placed between the two left and right curly braces ({ }).

When you are debugging lots of line numbers, from the Debug perspective, you can left click Navigate, and left click “Go to Line ” to obtain the "Go to Line" pop up window. From the "Go to Line" pop up window enter the line number you want to go to, left click OK and you will go to that line number.

Copy the example program. Then paste the example program into the body of the frakal class you created on the blank line between the two left and right curly braces ({ }).

package frakal;

public class frakal {

}

VI. ECLIPSE DEBUGGER

A. Break Point

From the Java Eclipse SDK Editor Window double left click in the grey shaded margin to the left of a line number and you will see the Debugger Break Point circle icon appear. The icon is a toggle which can be turned on and off by double left clicking.

A break point suspends the thread execution of the source code, before the line containing the break point is executed.

B. Debug

After you set your break point run debug.

You will discover there are several ways to enter Debug and of course you can use whatever method you prefer. For example, from the Java Eclipse SDK Editor Window you can enter Debug by doing one of the following:

1. Left click Window, then left click Open Perspective, and then left click Debug.

2. Left click Debug on the tool bar at the far right of the top of your screen.

3. Press F11.

C. Java Eclipse SDK Debug Perspective

The Java Eclipse SDK Debug Perspective has several tab windows, each of which has buttons. Hovering your mouse pointer over a button will reveal to you the purpose of that button.

1. Debug shows the call stack and status of all current threads, including any threads that have already run to completion, and the line of code the debugger is currently executing.

The following buttons for moving around within the program are on the far right of the title bar of the Debug view tab:

a. Step Into, F5, is used to Step Into a method and stop at the first line of executable code inside that method.

Normally you only want to step into methods in your own classes and not into the third-party packages or standard Java packages. In order to accomplish this left click Window, left click Preferences, left click Java, left click Debug, left click Step Filtering, left click Select All, left click Apply, and left click OK.

b. Step Over, F6, executes the current line of code and stops at the next line.

c. Step Return, F7, executes everything within a method entered by using Step Into and then returns to the next line following the line which contained the method we previously stepped into.

d. Resume, F8, will resume execution of the program until it meets the next breakpoint.

Another way of moving around within the program is to right click on the line you want the program to run to, then select Run To Line or use Ctrl+r. The program will run to the line you selected and stop.

2. Java Editor (Source Code Window)

The Java Editor shows the Java source code. When Debug executes the program pauses at the first executable line on or after the breakpoint.

3. Console

Console shows the programs console output.

4. Tasks

The Tasks view displays the list of to-do items, or tasks that you have added manually.

5. Variables

Variables shows the current variables and their values.

6. Breakpoints

Breakpoints lists all the breakpoints. You can either disable or enable the breakpoints by checking or un-checking the check mark next to each label.

7. Outline

Outline lists an outline of the current source file.

8. LogCat

The LogCat messages give you the full breakdown of what caused the error, including the line number.

If you X out of (close) a perspective tab window and you want to see it again, left click Window, then left click Show View, then left click the perspective tab window you closed and Eclipse will show it again.

For example, when you first enter the debug perspective, you will not be able to view the perspective tab window Expressions tab until you left click Window, then left click Show View, then left click Expressions. You can use the Expressions tab to have the Debugger evaluate and keep track of expressions.

Another tab window you will not be able to initially view is the Display tab. To view the Display tab left click Window, then left click Show View, then left click Display. The Display View displays the result of evaluating an expression in the context of the current stack frame.

When you want to exit the debugger, refer to the top of the Java Eclipse SDK Debug tab window tool bar, and left click the red button. Then left click Window, left click Open Perspective, and left click Java to return to the Java Eclipse SDK Editor Window.

VII. DEBUGGING EXAMPLE PROGRAM ANALYSIS

The example program is a "fractal." I think fractals are fantastic. I deliberately included this fractal as an example program in order to give you a more challenging opportunity to practice debugging. Complex ideas involve lots of user created methods and lots of open source utility methods. I will cover enough in this section of the tutorial to get you started. If you have not previously looked at open source utility methods this will be an eye opener for you. If you have problems post them as comments and I will reply to your comments.

A. Break Points

Go to the main method and set a break point at the following line:

new fraktal(args);

The break point should be on line 124. After you have the break point set, from the main tool bar left click Debug and the program will run and pause at the line of code where you set the break point. The debugger has paused the program at the break point before executing “new fractal(args);”.

B. Step Into

From the Break Point, left click Step Into and you will enter the fractal(args) method for debugging. When you left click Step Into the debugger will Step Into a method and stop at the first line of executable code inside that method. In this case it has stopped at the following line of code:

super("Mandelbrot set fractal");

C. Step Return

Left click Step Return and you will return to the next line following the line which contained the method we previously stepped into. Our main method only contains one method. Therefore, when you left click Step Return the program creates the “Mandelbrot Set Fractal” and returns to the right curly brace which ends the body of the main method as shown below.

}

I hope you like the fractal, I think it is very pretty. Close the “Mandelbrot Set Fractal” and left click the red terminate button in the Debug view title bar.

From the Java editor source code window set a second break point at the first for statement below the main method on the following line.

for (int i = 0; i < 50; i++)

Then from the top tool bar left click Run, then left click Debug and the program will run and pause at the line of code where you set the first break point.

From the Break Point, left click Step Into and you will enter the fractal(args) method for debugging.

D. Step Over

Now that we are in the fractal(args) method we can walk through the lines of code in the method by left clicking Step Over. Each time we left click Step Over, the debugger executes the current line of code and stops at the next line as shown below.

setSize(800, 800);

E. Resume

When we left click Resume or press F8 the Eclipse Debugger will resume execution of the program until it meets the next breakpoint. Therefore, when we left click Resume we arrive at our second break point.

Left clicking Step Over places us inside the for loop.

The for loop has 50 iterations. If we want to continue using Step Over and we prefer not left clicking Step Over 50 times, we can go to the Variables tab, find the variable i which increments the for loop, and change the value of i in the Value column. Then we can continue left clicking Step Over.

F. Watch

In the for loop there are variables whose value changes you might want to watch. To do so left click on the variable, then right click and select Watch. The variable you selected for watching will appear in the Expressions tab window where you can watch them change as you Step Over statements.

Programs that run right the first time are no fun. Happiness is using your debugger! May you always be happy and have programs with lots of bugs to debug!

VIII. JAVA ECLIPSE DEBUGGER EXAMPLE PROGRAM SOURCE CODE

/*
Java Eclipse Debugger Tutorial
*/

package fraktal;

import javax.swing.*;
/*
JPanel
*/

import java.awt.*;
/*
Graphics
*/

import java.awt.image.*;

import java.awt.event.*;

public class fraktal extends JFrame implements MouseListener

{

BufferedImage fractal;

WritableRaster raster;

Calculator calc;

int mouse_x, mouse_y;

double x;

double y;

double width;

double height;

public void mouseClicked(MouseEvent e) { }

public void mouseEntered(MouseEvent e) { }

public void mouseExited (MouseEvent e) { }

public void mousePressed(MouseEvent e)

{

mouse_x = e.getX( );

mouse_y = e.getY( );

}

public void mouseReleased(MouseEvent e)

{

double tmpx = translateX(mouse_x);

double tmpy = translateY(mouse_y);

double tmp = translateX(e.getX( ));

x = tmpx;

y = tmpy;

width = Math.abs(tmp - tmpx);

height = 0.75 * width;

while (!calc.isDone( ))

{

try { Thread.sleep(1000);

} catch (InterruptedException ex) { }

}

calc = new Calculator(800, 800, raster, this);

calc.setInsets(x, y, width, height);

calc.start( );

}

public double translateX(int ix)

{

return x + (((double) ix) / 800) * width;

}

public double translateY(int iy)

{

return y + (((double) iy) / 800) * height;

}

public fraktal (String args[ ])

{

super("Mandelbrot Set Fractal");

setSize(800, 800);

setLocationRelativeTo(null);

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

setResizable(false);

Component graphics = new Component( )

{

public void paint(Graphics g)

{

g.drawImage(fractal, 0, 0, null);

}

};

graphics.addMouseListener(this);

getContentPane( ).add(graphics);

fractal = new BufferedImage(800, 800, BufferedImage.TYPE_INT_RGB);

raster = fractal.getRaster( );

System.out.println("Raster top left corner: " + raster.getMinX( ) + "," + raster.getMinY( ));

System.out.println("Raster size: " + raster.getWidth( ) + "," + raster.getHeight( ));

setVisible(true);

calc = new Calculator(800, 800, raster, this);

x = -1.5;

y = -1;

width = 2;

height = 0.75 * width;

if (args.length == 0)

{

calc.setInsets(-1.5, -1, 2, 0.75 * 2);

}

if (args.length == 3)

{

x = Double.parseDouble(args[0]);

y = Double.parseDouble(args[1]);

width = Double.parseDouble(args[2]);

height = 0.75 * width;

calc.setInsets(x, y, width, height);

}

System.out.println("Rectangle calculation: ("+x+","+y+") to (" + (x + width) + "," + (y + height)+")");

calc.start( );

}

/*
Main Method
*/

public static void main(String args[ ])

{

new fraktal(args);

}

class Calculator extends Thread

{

WritableRaster raster;

int sizex;

int sizey;

double startx;

double starty;

double width;

double height;

double z;

double zi;

int[ ] black;

int[ ] red;

Object[ ] colors;

JFrame parent;

boolean done;

public Calculator(int sx, int sy, WritableRaster r, JFrame p)

{

parent = p;

raster = r;

sizex = sx;

sizey = sy;

z = 0;

zi = 0;

black = new int[3];

black[0] = 0;

black[1] = 0;

black[2] = 0;

red = new int[3];

red[0] = 255;

red[1] = 0;

red[2] = 0;

done = true;

colors = new Object[200];

int c = 255;

for (int i = 0; i < 50; i++)

{

int[ ] color = new int[3];

color[0] = 0;

color[1] = 255 - c;

color[2] = c;

colors[i] = color;

c -= 5;

}

c = 255;

for (int i = 50; i < 100; i++)

{

int[ ] color = new int[3];
color[0] = 255 - c;

color[1] = 255;

color[2] = 0;

colors[i] = color;

c -= 5;
}

c = 255;

for (int i = 100; i < 150;
i++)

{

int[ ] color = new int[3];
color[0] = c;

color[1] = c;

color[2] = 255 - c;

colors[i] = color;

c -= 5;

}

c = 255;

for (int i = 150 ; i < 200 ; i++)

{

int[ ] color = new int[3];
color[0] = 255 - c;

color[1] = 0;

color[2] = 255;

colors[i] = color;

c -= 5;

}

public void setInsets(double sx, double sy, double w, double h)

{

startx = sx;

starty = sy;

width = w;

height = h;

}

public static double comp_mult_real(double a, double b, double c, double d)

{

return (a * c) - (b * d);

}

public static double comp_mult_imag(double a, double b, double c, double d)

{

return (a * d) + (b * c);

}

public int mandelbrotTest(double a, double bi)

{

double atmp;

double btmp;

int number = 0;

double z = 0;

double zi = 0;

while ( (number != 200) && (comp_magnitude(z, zi) < 2))

{

number++;

atmp = comp_mult_real(z, zi, z, zi);

btmp = comp_mult_imag(z, zi, z, zi);

z = atmp;

zi = btmp;

z += a;

zi += bi;

}

if (number == 200)

{

return -1;
}

else

{

return number;
}

}

public boolean isDone( )

{

return done;
}

public static double comp_magnitude(double a, double b)

{

return Math.sqrt( a * a + b * b);

}

public void run( )

{

double dx = width / sizex;

double dy = height / sizey;

double z = startx;

double zi = starty;

done = false;

System.out.println("Mandelbrot set fractal calculation is in progress.");

for (int x = 0; x < sizex; x++)

{

zi = starty;

int it;

for (int y = 0; y < sizey; y++)

{

if ((it = mandelbrotTest(z, zi)) != -1)

{

/*
Within Mandelbrot set.
*/

raster.setPixel(x, y, (int[ ]) colors[it]);

}

else

{

/*
Not within Mandelbrot set.
*/

raster.setPixel(x, y, black);

}

zi += dy;

}

if ( (x%5) == 0)

{

parent.repaint( );

}

z += dx;

}

done = true;

System.out.println("Mandelbrot set fractal calculation has completed!");

}

}

EXAMPLE OUTPUT:

Raster top left corner: 0,0
Raster size: 800,800

Rectangle calculation: (-1.5,-1.0) to (0.5,0.5)
Mandelbrot set fractal calculation is in progress.
Mandelbrot set fractal calculation has completed!

IX. REFERENCE

Java How To Program Eighth Edition by Paul Deitel and Harvey Deitel (Upper Saddle River, N.J.: Pearson Education, Inc., 2010).

YOU HAVE LEARNED HOW TO:

1. Create a Java Project.

2. Create a Java Package.

3. Create a Java Class.

4. Use the Eclipse Source Editor.

5. Use the Eclipse Debugger.

Elcric Otto Circle

-->

-->

-->

How to Link to My Home Page

It will appear on your website as:
"Link to ELCRIC OTTO CIRCLE's Home Page"