Java Tutorial – Input / Output

The code below is based on Java 1.6 – some syntax may differ for previous versions.

Receiving and sending data to and from an external source is something that you will likely have to do regularly as your programs develop. Java provides a number of classes and libraries to facilitate this process. In this tutorial we will concentrate on reading from and writing to external text files.

To send and receive data in Java, we use output and input ‘streams’. There are various resources within the Java language to interface with input and output streams in your programs, many of them suited to different types of programming tasks. This Java Tutorial will demonstrate a few of the more likely options for use within basic applications.

Java – Reading from a file

Create a new Java project in your IDE and add the following import statements at the top of your main class:

	//input/ output imports
import java.io.*;
import java.util.*;

These imports contain the classes that we will use for our I/O operations: the first of these classes will be FileReader and Scanner. In the first example, we will read the text from a text file into our program one line at a time. Enter the following code in your main method:

//try block in case of IO exceptions
try
{
		//create filereader, passing filename
	String filename = "sometext.txt";
	FileReader fr = new FileReader(filename);
		//pass filereader to scanner
	Scanner scan = new Scanner(fr);
		//loop through the file content
	while(scan.hasNextLine())//check that there is more
	{	System.out.println(scan.nextLine());	}
		//close the input stream
	scan.close();
	fr.close();
}
	//an exception has been thrown
catch(IOException ioe)
{
		//output the details
	System.out.println(ioe);
	ioe.printStackTrace();
}

The code has to be included in try/catch blocks because, when your program relies on external input, there is always a risk of unforeseen error, such as problems with the external file. Placing your code within the try block allows your program to continue functioning when these problems occur, and provides you with the ability to decide what should happen if the I/O processing goes wrong. This is the function of the catch block, so you should place here whatever you want the program to do on encountering such an error, as this is where the code will jump to when that happens.

Before compiling your program, you will need to create the file for reading. Open a text editor (such as notepad/ notepad++) and enter the following:

Outside of a book
A dog is a man's best friend
Inside of a dog
It's too dark to read

Save your file with the name ‘sometext.txt’ in the same directory within your workspace as the new project; for example, on Windows, if the project is called AProject and your workspace directory is C:\Workspace save the file in the C:\Workspace\AProject directory. If you look at the first line of code in the try block, you’ll see that the filename given is a relative URL, i.e. it does not have a drive listed as part of it; you can also use the class with an absolute URL if you need to.

NB: If you’re using Eclipse you can find out your workspace location by choosing Project > Properties.

Now compile and run the program, you should see the contents of the file written a line at a time to the output console. What’s happening here is that the program is opening an input stream (according to the filename given) with the FileReader. The Scanner then processes the data from the stream, and can do this in a variety of ways, reading a line, a number or a byte at a time. Although our program merely outputs the data read in, once it’s in your program you can do whatever you need to with it, for example by assigning it to variables.

To demonstrate the purpose of the try and catch blocks, change the filename in the code so that it doesn’t match the actual file (e.g. String filename = “bla.txt”;) and run your program again. You’ll see the effect of the exception being thrown in your output console – this is because the program couldn’t find the file specified. (Remember to change the filename back afterwards.)

Using the Scanner, as above, makes text processing easier if you’re reading chunks of the text, however you can use the FileReader itself to read the file in a character at a time if this suits your needs. Processing data through the FileReader in this way is a little more complex, as the contents of the file are in the form of individual characters, including the newlines and end of file:

	//create FileReader
FileReader fRead = new FileReader(filename);
	//keep track of whether end of file reached
boolean end = false;
	//loop through file characters
while(!end)
{
		//read the next character (as an int)
	int ch = fRead.read();
		//-1 represents the end of file
	if(ch==-1)
		end=true;
	else
	{
			//write the character out
		char chr = (char)ch;
		System.out.print(chr);
	}
}
	//close the stream
fRead.close();

Run the program, it should have the same effect as the previous code.

Writing to a file in Java

The process for writing to files is similar, again, try and catch blocks are required and this time an output stream is opened. However, if your program cannot find the file specified to write to in the relevant directory, it will create it. If the file does exist the below methods will replace its contents. The first method writes to an output file using the FileWriter class, which can write a specified section of a string (in this case it should write ‘defg’); enter the following in your try block:

//write out using FileWriter
FileWriter fw = new FileWriter("output1.txt");
	//write specified section of string
fw.write("abcdefghijkl", 3, 4);
fw.close();

Check your workspace project directory to see if the output1.txt has been created and written to.

The next example uses the PrintWriter class to write to the file; demonstrating two approaches to inserting newlines:

//write out using PrintWriter
PrintWriter pw = new PrintWriter("output2.txt");
	//using println to insert newline at end
pw.println("Some text I'd like to write to a file");
pw.println("And some more");
	//use print - insert newline explicitly (\r\n)
pw.print("Yet more I'd like to write to a file\r\n" +
		"And more again.");
pw.close();

Again, check the appropriate directory for the output2.txt file; it should contain 4 lines of text.

Your programs will likely involve a range of different approaches to Input/Output depending on their particular requirements, so it is worth spending a little time familiarising yourself with the various options that Java provides.

Java Tutorial – Sorting, Searching and Recursion

Once you start to use data structures in Java, you will inevitably encounter situations in which you need to sort or search through them. For the purposes of this beginners Java tutorial, we will use arrays to illustrate some basic sorting, searching and recursive algorithms.

An algorithm is a procedure, a series of steps that you define to solve a particular problem. In the examples below, our algorithms will be expressed in the Java code that we use in our programs.

Recursion

Some of the techniques we will be using rely on recursive processes, so let’s explore these first. A recursive method in your program is basically one that calls itself, i.e. within the method body, there will be a call to the method itself. Using recursive methods effectively can take a bit of practice, as your program can easily get caught in a loop, so you need to think the procedure in any such method through carefully.

To demonstrate a recursive function in action, let’s create a trivial example. Create a new Java project and enter the following in your main class, after the main method:

//recursive method
public static int doSomething(int someNumber)
{
		//check the value of the input parameter
	if(someNumber<=0)
		return someNumber;
	else
	{
			//decrement and call the method again
		someNumber--;
		System.out.println(someNumber);
		return(doSomething(someNumber));
	}
}

Now call the new method within your main method:

int result = doSomething(10);
System.out.println("done: " + result);

All the program does is count down from the passed int value to zero. Experiment by changing the value of the int parameter passed to the method and observe what effect it has on the output printed to the console. The method manages to avoid getting stuck in a loop (caused by calling itself repeatedly) by having the conditional ‘if’ statement.

This simple recursive method has much the same effect as a loop, but, as you’ll see, recursion can be particularly useful when you have a complex problem that is best solved in stages, each stage taking you a step closer to the solution by simplifying it. A necessary ingredient for recursive methods then is that you specify explicitly how the method should behave with the simplest input, and then with each iteration, you work towards this simplest case. In the example above, the simplest case is when the int parameter is less than or equal to zero.

Try not to worry if this seems an odd practice at first, once you start using sorting methods the recursive approach will become clearer.

Sorting

The main reason for keeping a collection of data in sorted order is that it is far easier to find items within the data and therefore maintain it effectively. Keeping the data in sorted order does, however, involve a certain amount of processing, particularly when adding or deleting items.

When we say, for example, that an array is in sorted order, we mean that the items within the array are arranged according to some understood ordering system. Sometimes this is intuitive, for example if the array contains numbers, sorted order will naturally comprise numbers stored according to ascending (or sometimes descending) numerical value. Similarly, if the array contains String values, sorted order will generally mean alphabetical order.

However, there are cases when sorted order will be less clear – imagine you have created your own class declaration for use within your program, and you wish to store objects of your class in the array. You will have to decide then what constitutes sorted order for these objects. In order to do this you have to think about comparing two objects of the same class. When you compare two objects of the class, it must be that case that either one is ‘greater’ than the other, or they are ‘equal’. This is how your objects will be ordered, and to provide this in your own classes they will need to implement the Comparable interface, which means that your objects provide a compareTo method. Within this method you will need to decide how to measure the objects of your class against one another, for example, you might decide to use the value of some variable in the class.

Note: be careful when using the ‘equals’ method on your objects also, as the default equals method inherited from the Class Object, actually tests the object references, i.e. it tests to see whether the two variable names are pointing to the same object. If you plan to use the equals method, you would be best to provide your own implementation of the method, overriding the default for this reason.

For the purposes of this Java tutorial, we will stick to simple types in order to illustrate the algorithms required.

Selection Sort

Selection sort works by continually finding the next smallest item in the collection and placing it at the front. Create a new program and enter the following code in your main method to create an array with some arbitrary data in it:

	//array with unsorted int data
int [] myData = {3, 1, 9, 5, 7};

Now we will use selection sort to arrange the items in the array in ascending numerical order. The selection sort technique is as follows:

• Within the section of data that is yet to be sorted (initially the whole structure), find the smallest item
• Place this item at the first position (of the unsorted section), swapping it with any element that’s already there
• The unsorted section now contains one less item (the item just deemed smallest and therefore moved)
• Continue placing the smallest unsorted item in first position until all of the data has been sorted

Enter the following code after declaring the array and compile your program, observing its output:

	//loop through the array
for(int pos=0; pos<myData.length-1; pos++)
{
		/* find and keep track of the smallest
		 * element's position
		 * -start at pos and look through the rest
		 * (pos is at the start of the unsorted section)
		 */
	int minIndex = pos;

		//loop through the unsorted section
	for(int next=pos+1; next<myData.length; next++)
	{
		if(myData[minIndex]>myData[next])
			minIndex=next;
	}

		//swap the item if necessary
	if(minIndex!=pos)
	{
			//keep track of the value currently at pos
		int temp = myData[pos];
			//copy the new smallest value into pos
		myData[pos] = myData[minIndex];
			//copy the swapped value into minIndex
		myData[minIndex] = temp;
	}

		//print the array for demonstration
	for(int p : myData)
	{	System.out.print(p);	}
	System.out.println();
}

When you look at the program output, try to work through which items are being swapped with one another at each stage – experiment by changing the int values (or their order) in the array.

Merge Sort

A more efficient approach to sorting the contents of an array is Merge Sort, which uses a recursive algorithm. This rests on the idea that merging two already sorted arrays is a simpler problem than sorting all of the data in one unsorted array. The algorithm therefore sorts an unsorted array by continually dividing it into two parts and sorting each part, merging the results into a final sorted array.

Add the following method to your program (after the main method):

/* mergeSort method sorts the data in a section of
	 * the array passed
	 * -parameters are the array containing the data to
	 *  be sorted, a temporary array for use with the
	 *  processing, and integers representing the start
	 *  and end positions of what data is to be sorted
	 *  within the array
	 */
public static void mergeSort(int[] dataArray, int[] tempArray,
							int start, int end)
{
		//array has been sorted
	if(start==end)
		return;
		//work towards sorted array by breaking the problem down
	else
	{
			//divide the data into two
		int center = (start+end)/2;
			//call the method on the first half
		mergeSort(dataArray, tempArray, start, center);
			//second half
		mergeSort(dataArray, tempArray, center+1, end);

			//merge the two halves into one sorted half
		int firstIndex = start;
		int secondIndex = center+1;
		int thirdIndex = start;

			//loop through both halves
		while(thirdIndex<=end)
		{
				/* work through both halves
				 * inserting smallest item into
				 * the temp array each time
				 */
			if(secondIndex>end ||
			(firstIndex<=center &&
			dataArray[firstIndex]<=dataArray[secondIndex]))
			{
				tempArray[thirdIndex]=dataArray[firstIndex];
				thirdIndex++;
				firstIndex++;
			}
			else
			{
				tempArray[thirdIndex]=dataArray[secondIndex];
				thirdIndex++;
				secondIndex++;
			}
		}
			//copy the temp contents into the main array
		for(int i=start; i<=end; i++)
			dataArray[i]=tempArray[i];
	}
}

Each time the method reaches the point of merging two halves, each half has already been sorted, since the mergeSort method has been first called on them, and on their subsections before they come to be merged, and so on. The method therefore solves the problem by repeatedly simplifying it and solving the simpler problems in turn. Now call the new method from your main method:

	//array to sort
int[] someData = {4, 3, 7, 6, 2, 8, 5, 9, 1};
	//extra helper array
int[] extraArray = new int[someData.length];
	//call the mergesort method on the whole array
mergeSort(someData, extraArray, 0, someData.length-1);

	//print the sorted array for testing
for(int pr : someData)
{ System.out.print(pr); }

Again, experiment by changing the values in the input array and observing the program output.

It can be difficult to get into the ‘recursive’ way of thinking and certainly requires practice, but once you do you will tend to find that you identify problems that could benefit from a recursive solution fairly quickly. It can help when writing a recursive method if you start from the simplest case, then take care of the steps that work towards it each time the method executes (rather than starting from the most complex input, which is the first one to be executed, and can therefore seem an intuitive starting point).

Searching

You will often face the task of finding a particular element in a data structure for one reason or another. If your array data is unsorted, the only way to do this is to look through each of the elements in turn. This is known as linear search – enter the following code in your main method:

//collection of arbitrary strings
String[] myStrings = {"potato", "carrot", "turnip",
		"onion", "leek", "courgette", "aubergine"};
	//find the index of 'leek'
int foundIndex=-1;
	//loop through the array
for(int veg=0; veg
	//binary search method
public static int binarySearch(String[] theData, String wanted)
{
		//-1 means item not found
	int foundIndex=-1;

		//keep track of both ends of searchable area
	int top = theData.length-1;
	int bottom = 0;

		//loop through, dividing searchable area each time
	while(bottom<=top)
	{
			//look at middle element
		int middle = (top+bottom)/2;

			//compare middle element to item searched for
		int comp = theData[middle].compareTo(wanted);

			//middle is item searched for
		if(comp==0)
			return middle;

			/* if middle element is greater,
			 * wanted element must be in lower half
			 * and vice-versa, so we reduce the
			 * searchable area accordingly
			 */

		else if(comp>0) //middle is greater
			top=middle-1;
		else //middle is lesser
			bottom=middle+1;

	}
		//finished searching
	return foundIndex;
}

Now call the method within your main method:

//array of sorted strings
String[] sortedStrings = {"aubergine", "carrot", "courgette",
		"leek", "onion", "potato", "turnip"};

	//call the method - returns -1 if item not found
int searchResult = binarySearch(sortedStrings, "potato");

System.out.println("found at index: "+searchResult);

Experiment with the code by searching for different elements in the array – you can also check how many iterations of the loop are required each time by including a System.out.print statement within the while loop in your binarySearch method. It is generally a good practice to include such ‘trace statements’ in your code, to check exactly what is happening at any stage in the program; it can be particularly helpful when debugging larger programs.

Although many of Java’s built-in datatypes provide sorting and searching methods, it can help with the efficiency of your own programs to think about the algorithms involved. Also, when you come to define your own data types, you may need to implement such methods yourself. There are numerous approaches to sorting and searching in Java, the examples above being only an introduction.

Java Tutorial – Database Programming

This tutorial assumes knowledge of basic database concepts and MySQL.

In this Java tutorial you will learn how to connect to a MySQL database.

Connecting to a database will likely be a common task as your Java projects progress. In this JAVA tutorial, we will use the Java Database Connectivity API (Application Programming Interface) – JDBC to deliver our data.

The JDBC libraries provide the means to connect your programs to a database and perform any operations upon the data that you require. To start using JDBC you need:

• the JDK (which you may already have installed)
• a JBDC driver, which depends on the Database Management System you are using for your data.

Once you have installed a driver compatible with the DBMS for your data source, create a new Java project in your IDE. Enter the following import statement at the top of your Main Class:

	//import required for database operations
import java.sql.*;

Now enter your main method (this code is for MySQL databases, with notes where alterations are required for other systems):

public static void main(String[] args)
{
		//try block for sql exceptions
	try
	{
			//create driver - ALTER TO SUIT YOUR DRIVER/ DBMS
		Class.forName("com.mysql.jdbc.Driver").newInstance(); 

			//database connection code - ENTER YOUR DETAILS
		String username = "yourname";
		String password = "yourpwd";

			//URL - ALTER TO CONNECT TO YOUR DATABASE
		String dbURL = "jdbc:mysql://somedomain.com/database?user="
			+ username + "&password=" + password;

			//create the connection - ALTER FOR YOUR DBMS
		java.sql.Connection myConnection =
			DriverManager.getConnection(dbURL);

			//create statement handle for executing queries
		Statement stat = myConnection.createStatement();

	}
	catch( Exception E )
	{ System.out.println( E.getMessage() );	}
}

If exception handling is as yet unfamiliar to you, the try and catch blocks provide your program with the ability to continue when unexpected input is received, for example when communicating with data sources. There is always a possibility of unforeseen error when your code relies on external input, in which case the code may ‘throw an exception’. You simply put the code that will potentially cause an exception to be thrown inside the try block, and the response to any exceptions inside the catch. If an input error (or in this case an sql error) occurs, the code will immediately jump to the catch block – all we do in this case is write the details of the error out to the console.

Your code is now ready to execute some queries on the data – to do so, enter code such as the following example at the end of (inside) the try block:

//query to select all of the data from a table
String selectQuery = "Select * from MyTable";
	//get the results
ResultSet results = stat.executeQuery(selectQuery);
	//output the results
while (results.next())
{
		//example - column is called 'firstname'
	System.out.println("first name: " +
		results.getString("firstname"));
}

You can use the statement handle (the ‘stat’ variable in the code above) to execute other SQL statements on your data, such as updates and inserts. For updates, use the syntax:

//example update statement
String updateStatement =
	"Update MyTable set SomeColumn=192 where OtherColumn=12";
	//int return indicates success or failure
int updateSuccess = stat.executeUpdate(updateStatement);
System.out.println("success? "+updateSuccess);

For inserts the syntax is the same:

//example insert statement
String insertStatement =
	"Insert into MyTable (col1, col2, col3)
	values (12, 'bla', 127)";
	//int return indicates success or failure
int insertSuccess = stat.executeUpdate(insertStatement);
System.out.println("success? "+insertSuccess);

You can also use the Result Set to get information about metadata:

	//get the metadata from a ResultSet
ResultSetMetaData mData = results.getMetaData();

The ResultSetMetaData object provides methods to ascertain details of the data such as table names within the database, column names within tables etc.

Once you’ve carried out whichever operations you need on your data, you should then close the connection:

results.close();
stat.close();
myConnection.close();

The JDBC API is widely used within Java applications due to the fact that it is standard and can be used for many relational database systems. While some of the details within the above code may need to be slightly altered for your chosen DBMS, the overall structure of your database connectivity code will remain the same.

Beginners Java Tutorial – Introducing Inheritance

Programming can inevitably be a time-consuming and laborious process; for this reason programmers always look for ways to improve efficiency, such as the re-use of existing code. The structure of the Java language facilitates the practice of re-using code in a number of ways. One of these is Inheritance, which can have a profound effect on the way that you design your projects as a whole.

The basic principle in Inheritance is that you can create a Class that re-uses the code in an already existing Class by extending (inheriting from) it. The new Class inherits all of the features of the original Class, and is free to either add additional features or alter the features it has inherited, such as the way in which a method is implemented.

When a Class inherits from another Class, it is said to ‘extend’ it. The original Class is referred to as the Superclass, the inheriting Class being the Subclass. All Classes in the Java language ultimately extend the Class Object, although you do not state this explicitly in your Class declarations. This is why any Class that you create will naturally provide the methods outlined in the Object Class, such as toString(), even when you didn’t declare those methods in your Class declaration.

Let’s create a simple example – in your IDE create a new Java project and Main Class (leave the main method empty for now). Create a second Class called MySuperClass and enter the following code:

/**A Superclass ..
 */
public class MySuperClass {

	//instance variables

	/**an int */
	private int someInt;
	/**a String */
	private String someString;

	/**
	 * Constructor function
	 * @param intValue
	 * @param stringValue
	 */
	public MySuperClass(int intValue, String stringValue)
	{
		someInt=intValue;
		someString=stringValue;
	}

	/**
	 * Method outputs an arbitrary string
	 */
	public void aGreatMethod()
	{
		System.out.println("This really is a great method");
	}
}

Now create another Class called MySubClass and enter the following:

/**
 * MySubClass inherits from MySuperClass
 * and provides one additional method
 *
 * - This class will provide methods and
 *   variables present in the SuperClass
 *   although they are not declared here
 */
public class MySubClass extends MySuperClass {

	/**
	 * Constructor function conforms to the
	 * superclass constructor
	 * @param subIntValue
	 * @param subStringValue
	 */
	public MySubClass(int subIntValue, String subStringValue)
	{
			/* call the superclass constructor
			 * which expects an int and a string
			 */
		super(subIntValue, subStringValue);
	}

	/**
	 * Additional method provided in MySubClass
	 */
	public void anotherMethod()
	{
		System.out.println("This method is pretty good");
	}
}

Now, return to your Main class and enter the following as your main method:

public static void main(String[] args)
{
		//create an instance of the subclass
	MySubClass mySub = new MySubClass(99, "blah");
		//call the subclass' own method
	mySub.anotherMethod();
		//call the inherited method
	mySub.aGreatMethod();

}

When you run the program you should see the following written to standard output:

This method is pretty good
This really is a great method

As you can see from the above code, all you need to do to extend a Class is to use the syntax ‘extends’ in your Class declaration and ‘super()’ in your constructor method to call the constructor for the Superclass. As well as extending your own classes (as above) you can extend Classes that already exist, either within the language itself or within any external libraries that you happen to be using.

One common reason for using inheritance is to provide Classes that ‘specialise’ in some way. For example, you might have a program in which you want to represent the different sets of users of an application. These users might have some things in common but some differences – instead of having several distinct Classes in which you use sections of similar code, you could create a Superclass (e.g. User) and have several Subclasses inheriting from it. Your Superclass would provide all of the characteristics that the users have in common, while each Subclass can focus on what distinguishes it from the others.

Additional guidelines for using Inheritance:

• Each Subclass can only have one Superclass, although a Superclass can have many Subclasses.
• You can provide an alternative implementation for any method that you inherit from a Superclass by ‘overriding’ it – to do this you simply provide the method within your Class declaration and, providing the method signature is the same (same method name, parameter types/ number, and return type), your implementation will be the one that is called on objects of your Class.

Advanced Java topics relating to this Java tutorial are Polymorphism, Interfaces and Abstract Classes.

Beginners Java Tutorial – Building  User Interfaces

The Java language features a range of resources for building user interfaces. In this tutorial, we will use Swing and AWT to build a simple Graphical User Interface. The Swing libraries provide the graphical elements and AWT allows you to respond to user interaction.

Open your chosen IDE and create a new project. Create a Main Class (with your main method in it, but leave it empty for now) and a second Class, called MyGUI. In this Class, enter the following (don’t be alarmed if some of the syntax is unfamiliar, explanation follows):

/**
 * MyGUI User Interface Class
 */

//imports for graphics and user interaction
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

/**
 * MyGUI class represents a graphical user interface
 * @author Your Name
 */
public class MyGUI extends JFrame implements ActionListener {

	/**
	 * Constructor function creates and displays
	 * the basic elements in the GUI
	 */
	public MyGUI()
	{
			//constructor code ...

	}

	/**
	 * actionPerformed will determine how the program
	 * responds to user interaction
	 */
	public void actionPerformed(ActionEvent e)
	{
			//event code ...

	}
}

Let’s look at the individual code elements:

• The import statements allow us to use the Swing and AWT libraries for building our interface
• In the line:
  • ‘extends JFrame’ relies on the notion of Inheritance, but don’t worry if you haven’t come across it before, at this stage you can simply treat the line as a formula that you use for any user interface Class.
    The Class inherits from the Class JFrame, meaning JFrame is its superclass.
  • ‘implements ActionListener’ has to do with Java Interface declarations – again, if this is unfamiliar to you don’t worry, just use this code whenever you need to respond to user interaction.
    The Class implements the ActionListener interface, meaning that it must provide the methods outlined in that Interface declaration.

public class MyGUI extends JFrame implements
ActionListener

• The method actionPerformed(ActionEvent e) must be provided whenever ActionListener is being implemented – this is where the code responding to user interaction will go. More on this follows.

Now we will add some ‘widgets’ to our GUI, to do this we need to create an instance variable for each, and constructor code to display them.

The first thing to do within the constructor is specify the window properties, such as size, location etc. Then, we need to create Panels to hold our widgets. The default layout for a JFrame GUI is called ‘Border Layout’; this means that items can bee added in positions North, South, East, West and Center. However, you can change the layout, as we will in one section below, in this case to Grid Layout, in which you can have a specified number of rows and columns. When you do this, items are given consecutive positions left to right/ top to bottom as you add them to the GUI (first being leftmost/topmost). The widgets themselves need to be instantiated within the constructor also, as you can see below. Our GUI will have a button, a checkbox and two radio buttons – enter the code:

/**
 * MyGUI User Interface Class
 */

//imports for graphics and user interaction
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

/**
 * MyGUI class represents a graphical user interface
 * @author Your Name
 */
public class MyGUI extends JFrame implements ActionListener {

		//instance variables - elements in the GUI
	private JButton myButton;
	private JRadioButton firstRadio, secondRadio;
	private JCheckBox myCheck;

	/**
	 * Constructor function creates and displays
	 * the basic elements in the GUI
	 */
	public MyGUI()
	{
			//set the window properties
		setTitle("My GUI");
		setSize(200, 200);
		setLocation(100, 100);

			//create Panels
		JPanel northPanel = new JPanel();
		JPanel centerPanel = new JPanel();
		JPanel southPanel = new JPanel();
		add(northPanel, "North");
		add(centerPanel, "Center");
		add(southPanel, "South");

			//create widgets
		myButton = new JButton("a button");
		firstRadio = new JRadioButton("pick me");
		secondRadio = new JRadioButton("or me");
		myCheck = new JCheckBox("check me");

			//add widgets to the GUI - button
		northPanel.add(myButton);

			//create grid layout for centre (radio buttons)
		GridLayout myGrid = new GridLayout(1, 2);//1 row, 2 cols
		centerPanel.setLayout(myGrid);
		centerPanel.add(firstRadio);
		centerPanel.add(secondRadio);
			//create button group - only one may be selected
		ButtonGroup myGroup = new ButtonGroup();
		myGroup.add(firstRadio);
		myGroup.add(secondRadio);

			//add checkbox
		southPanel.add(myCheck);

			//make the GUI visible
		setVisible(true);
	}

	/**
	 * actionPerformed will determine how the program
	 * responds to user interaction
	 */
	public void actionPerformed(ActionEvent e)
	{
			//event code ...

	}
}

Try not to be intimidated by the amount of code, creating user interfaces can be long-winded but really is simple to program. Now, return to your main method and enter the following:

	//create an instance of the MyGUI class
MyGUI myGui = new MyGUI();

Run your program, it should look something like this:

You’ll notice that although you can interact with the buttons etc, nothing actually happens when you do so – let’s add code to detect this interaction. At the end of your MyGUI constructor code (before setVisible) add the following:

	//listen for user interaction
myButton.addActionListener(this);
firstRadio.addActionListener(this);
secondRadio.addActionListener(this);
myCheck.addActionListener(this);

Now, whenever someone interacts with your buttons, the actionPerformed method will be called, passing information about the ‘event’ in the ActionEvent parameter. In the actionPerformed method, we therefore need to decide how to respond:

/**
 * actionPerformed will determine how the program
 * responds to user interaction
 */
public void actionPerformed(ActionEvent e)
{
		//which component had an event?
	if(e.getSource()==myButton)
	{
			//the button
		System.out.println("Someone pressed the button!");
	}
	else if(e.getSource()==firstRadio)
	{
			//first radio button
		System.out.println("first");
	}
	else if(e.getSource()==secondRadio)
	{
			//second radio
		System.out.println("second");
	}
	else
	{
			//must be checkbox
		boolean selected = myCheck.isSelected();
		System.out.println((selected ? "checked" : "unchecked"));
	}

}

Run the program and see what happens when you interact with the buttons now, you should see results printed to the output console.

You never call the actionPerformed method explicitly in your own code, it is called automatically when events are detected on any component you have added and ActionListener to. Obviously your real applications will have more sophisticated ways of responding to events, but this overview should indicate the basic pattern that you can adopt to create user interfaces in Java. The Swing library contains numerous resources you can experiment with such as TextAreas/Fields, ComboBoxes and more.

As your programs grow in size and complexity, organisation and documentation will become more important. Applications developed in Java must be well-constructed and documented in order to function within the Object Oriented design model. Under this model, applications comprise a set of components interacting with one another – for this to be possible, the elements within must be clearly defined and explained. Even when you develop your own smaller projects, you will find that spending a little time and thought on these choices will save you a lot of headaches in the long run.

There are a series of simple measures that can contribute to a well-organised project, for example, the simple act of using plenty of whitespace and indentation in your code instantly makes it more readable, while this sounds boring and very uneventful .

Dividing up Requirements

It can be tempting, when starting a project, to sit down and immediately produce code, but resisting this urge can make life a lot easier. Once you have a set of requirements for your application, it can be extremely helpful to work out a ‘high-level’ plan before you start to write any code. For example: split the requirements into related sections, then use these to decide what your packages and classes will be. Even if you find that your implementation causes you to alter this initial plan, it provides a much more coherent starting point.

There are various modelling tools that can help this process, such as UML (Unified Modelling Language) – however, even if you decide not to choose such a formal approach, the simple act of splitting the requirements into groups can help you to visualise how you are going to solve the problems at hand.

Java Naming Conventions

It is well worth spending a few moments during coding to decide on appropriate names for variables, methods, classes and packages. In addition to the fact that this makes your work much more amenable to being used in other applications, it also makes your own development process easier. When you look back at a piece of code that you wrote some time before but have forgotten the details of, meaningful variable and method names will help you to understand it far quicker than if you have to read and process each line of code in your head! Although it may seem cumbersome at times, using whole words in your names can make your code much more readable.

For the same reason, observing the standard naming conventions for the language is always a good idea. In Java, this includes the following:

• variables should start lowercase, with uppercase letters indicating words within, e.g. myNumber, costPerPortion.
• method names should indicate (normally using verbs) what the method does, e.g. getCost, displayNames.
  • methods used to get and set values should use the conventions getValue (e.g. getCost) and setValue (e.g. setCost) respectively.

Comments and Documents

Regardless of whether you are working on your own or as part of a team, the inclusion of informative comments in your code will always help the development along. The Java language features a variety of different types of comment:

Single line comments are used for short pieces of information throughout your code:

	//print each name in the array
for(int i=0; i

Multiline comments are used for more lengthy explanations, particularly if your code features a complex algorithm:

	/*  This algorithm does the following:
		-first it does this
		-then it does this
		-and so on
	*/
for(int i=0; i

Javadoc

Java has its own system of documentation that is effectively built-in to the language. You can use Javadoc to automatically generate html documentation for your projects, and all you need to do is include Javadoc comments in your code:

/**
Method calculates total cost from individual cost
... more explanation ...
@param someNumber -int value representing individual cost
@return totalCost -int value representing total cost
*/
public int getTotalCost(int someNumber)
{
	//method code calculations..

	return totalCost;
}

Javadoc generates html based on such comments, which contain special tags such as @param and @return – if you include these the Javadoc will display this information in a standardised way. You should include Javadoc comments immediately before Class declarations, instance variable declarations, methods and constructors. The Java API is an example of Javadoc that you can view.

This Java tutorial is intended for people in the early stages of beginning Java programming.

When you compile and run a Java program, the JVM executes whatever is within the main method. These instructions are carried out sequentially unless dictated otherwise by the code itself, for example by using control structures, calling methods or creating Objects. This tutorial introduces basic control structures and method invocation in Java.

When you start programming in any language, it can seem intuitive to think of a program as a series of instructions that are executed in a linear fashion. However, when building applications, you will structure your code in a number of different ways.

For example, if your application allows user interaction, whatever code is executed will depend on what the user does at any point. Whenever your programs use external input, whether from user interaction or e.g. where content comes from a database, you need to tailor the behaviour of your code to suit the particular input that it receives.

Conditionals

Imagine you have an application in which a series of products are being displayed, the product details being pulled from a database. Your display will look messy if the product names are longer than 20 characters so you decide to display only the first 20, cropping the remaining letters off. In your IDE, create a new Java project and enter the following in your main method:

//main method
public static void main(String[] args)
{
		//product name - would have come from database
	String productName = "Deluxe Man-Size Tissues";
		//name as it will be displayed
	String displayName = "";
		//conditional statement
	if(productName.length()>20)
		displayName = productName.substring(0, 20);
	else
		displayName = productName;
		//test the result
	System.out.println(displayName);

}

In this trivial example, the product name is ‘hard-coded’ into the program but imagine that when you sit down to write the program, you have no idea what String value will be in that variable. Look at the conditional statement and think about what happens at runtime. If the variable name is indeed longer than 20 chars, only the code under the ‘if’ will execute, with the ‘else’ being ignored. If the name is 20 chars or less, only the ‘else’ executes, with the ‘if’ ignored. The statement within the ‘if’ brackets (‘productName.length()>20′) is a test which, when carried out, returns a true or false value – if true the instructions carry out the ‘if’, if false they jump to ‘else’. When you run the program, it should output “Deluxe Man-Size Tiss” – experiment by changing the productName variable.

Loops in Java

Another basic way to introduce a control structure to your code is by using loops. You will often find when programming that you need to carry out repetitive processing – you can reduce the amount of code that you actually need to write by using ‘while’ or ‘for’ loops.

Imagine you have an array of products whose names you want to display – enter and run the following code:

//product array
String[] products = {"Hats", "Shoes", "Ties"};
	//print each to standard output
for(int i=0; i

The code within this loop will execute as many times as there are elements in the array. What happens when the instructions reach the loop:

• The first time the loop is carried out, the value 0 is assigned to the i variable.
• The test i<products.length is carried out, returning a true or false value.
  • If the test returns true
    • the content of the loop (printing out the value at position i in the array) is carried out
    • i++ is executed (i is incremented to keep track of how many times the loop has executed)
    • the loop is then re-entered – the test carried out again to see if i is still less than the length of the array
  • If the test returns false, the loop is abandoned and whatever code lies after it is executed.

A while loop can be used to the same effect:

int j=0;
while(j

Methods

You will often find that you are carrying out the same processing in more than one place within your program, for example, imagine you have several arrays that you wish to display the contents of in the same way – you can define your own methods to do this. In your project, enter the following:

//class declaration
public class MyClass
{
		//main method
	public static void main(String[] args)
	{
			//product array
		String[] products = {"Hats", "Shoes", "Ties"};
			//call the method, passing it the product array
		int elems = printElements(products);
			//test the result
		System.out.println(elems + " printed");
	}

		//method prints the elements in a given array
	public static int printElements(String[] elements)
	{
		for(int e=0; e

When creating your own methods like this, you have to decide what the type and number of parameters are, what the return type is (int in this case, void if there is none), as well as the content and name of the method (try to make this meaningful but concise if possible).

You can then call the method passing it any other String array and it will perform the same action with it – try it by creating a second array with different length and content.

Java – Datatypes and Variables

Beginners Java Tutorial on Datatypes and Variables, ideal for the novice who is just starting to learn programming in JAVA

In order to program effectively in Java, you need to understand a little about the different datatypes in the language. A variable in Java can essentially be one of two things: a primitive type or an Object reference. To create efficient programs, you need to think about which types to use, as this will have a direct effect on performance.

The Java language is ‘strongly typed’, which means that when you declare a variable, you have to specify the type:

int myNum = 1;
String myString = "hello";
Object myObject = new Object();

The advantage to this is that you have a degree of control over the underlying implementation (and therefore efficiency) of your projects. To make informed choices about datatypes, let’s look at the ways in which they are represented in memory.

Primitives

The Primitive types in Java are int, char, boolean, byte, double, float, long and short. Primitive type variables can be given a value when you declare them, and the values are stored in stack memory:

int myNum = 1;
//in this case the value 1 is stored on the stack

In contrast, reference types are stored in heap memory, with only the Object reference on the stack (more on this below). You don’t need to understand the details of how your variables are stored in the computer’s hardware to program efficiently, as there are simple practices that will minimise the amount of memory that you use. In general, primitive types use less memory than Objects.

When it comes to choosing between primitive types, you should also try to minimise memory usage, e.g. for integer arithmetic: an int uses up less memory than a long; for floating point: a float uses less than a double – naturally there is a trade-off involved in this choice, since the larger types offer a greater range of possible values.

Note: The primitive types also have associated Wrapper classes (e.g. Integer). As well as storing the value (of e.g. an int), variables of these types can have methods called on them. However, being of the reference type, they occupy space in heap memory, and as such you should avoid using them unless you have specific reasons for using their associated methods.

Reference Types

When you create an Object, the JVM allocates a section of heap memory for it, with the Object reference stored on the stack. In this example:

Object myObject = new Object();

your myObject variable is essentially a pointer to a location in memory. The data etc contained within your Object is stored at this location. Given that this happens every time you create an Object, you can imagine that the amount of memory used up by your programs will quickly accumulate. However, there are more simple measures you can take to minimise this.

Garbage Collection

The JVM uses ‘garbage collection’ to free up areas of memory that are no longer being used. A location used by an Object in your program will be considered a candidate for garbage collection, if there are no longer any Object references pointing to it. For this reason, you need to think about where you declare variables, and for how much of the processing they need to remain available.

For example, if you consider the following trivial example:

//print the string backwards if it's at least 10 chars
String myString = "blahdeblahdeblah";
String backString = "";
if(myString.length()>=10)
{
	for(int i=myString.length()-1; i>=0; i--)
	{
		backString += myString.charAt(i);
	}
	System.out.println(backString);
}

Providing you don’t need the backString variable further down in your program, it is better to declare it inside the ‘if’ statement:

//print the string backwards if it's at least 10 chars
String myString = "blahdeblahdeblah";
if(myString.length()>=10)
{
	String backString = "";
	for(int i=myString.length()-1; i>=0; i--)
	{
		backString += myString.charAt(i);
	}
	System.out.println(backString);
}

The backString variable is now ‘local’ to the conditional ‘if’ statement; once that statement has finished executing, the variable is no longer needed and is therefore garbage. In the first example, the variable had greater ‘scope’, and remained available longer than necessary, using up memory. You can also use this principle of ‘localising’ variables with the primitive types.

Note: The syntax for some reference types such as String and Array can be confusing at first – although these look the same as primitive types in that you can assign a value to them as you declare them (rather than using the keyword ‘new’, as with most other classes), they are Objects and occupy memory as such.

Next Java Tutorial – Methods and Control Structures

Java Tutorial - Objects and Classes

This Java tutorial assumes some very basic Java knowledge, e.g. method syntax.

Objects are the key to building robust and efficient Java applications. When developing a large or complex system, developers begin the design process by dividing up the various project requirements into application components. These are ultimately represented by Objects within the application, and are implemented in code by Class declarations. While it might be difficult to perceive the advantages to this technique while you’re learning (and working on small projects), if you adopt the right practices at this stage, you will develop the skills required for professional Java development.

Creating Objects

In your Java IDE, create a new Project called MyFirstObject, with Main Class MyFirstObject (if you’re using Netbeans myfirstobject.MyFirstObject with myfirstobject as the package name). Inside your MyFirstObject Class enter the following:

//class declaration
public class MyFirstObject
{
//main method
public static void main(String[] args)
	{
//code here will be executed when the program is run
	}
}

Using Objects is a way of dividing up responsibility for the different parts of an application. You can do this in a variety of ways: for example, you can carry out some of your program’s tasks within separate methods, calling these from the main part of your code. Using Objects is similar to this, but each Object requires a Class declaration, which you create in a separate .java file.

The Objects that you may have already used, such as those representing Java datatypes String, Array etc also have their own Class declarations – these are built into the Java language itself, and although you can’t see the code, you can see an overview as part of the Java API (Application Programming Interface). The Objects that you define yourself will function in the same way – let’s create a simple example.

In your project, create a new Class called MyHelper, entering the following:

	//class declaration
public class MyHelper {

		//instance variable
	private int helperNum;

		//constructor method
	public MyHelper()
	{
		helperNum=1;
	}

		//public method
	public int getNumber()
	{
		return helperNum;
	}
}

The above code is a simple Class declaration specifying the properties that any Object of the MyHelper Class will have – next we will create an ‘instance’ of the MyHelper Class within our Main Class, but first let’s look at the Class declaration.

Instance Variables

Instance variables represent any data that should be stored in every instance of your Object, meaning that every time you create a MyHelper Object it will contain a helperNum integer variable. Instance variables should always be private, so that their value cannot be changed except within the Class declaration itself – more on this later.

Constructor method

You can see that the constructor method looks the same as any other method, except that it doesn’t have a return type specified – this is because the constructor method is called when an Object of the Class is created (using the keyword ‘new’), and what it returns is – an Object of the Class. The constructor method should always have the same name as the Class. Within the constructor method, you carry out ‘initialisation’, meaning that you assign a value to your instance variables – when the constructor method has executed, none of your instance variables should be left without a value, as this can make your program unpredictable.

Public Method

The declaration contains one public method, ‘getNumber’, which can be called on any Object of the Class. Although the example may seem trivial, it is common to have methods which either set or return the value of an instance variable.

The reason for such methods relates to your instance variables being private. The basic principle underlying Object Oriented development is that your Objects have a ‘well-defined’ interface – this means that all access to the data contained within a Class should be through its methods. If the instance variables were public, external code would be free to change their values directly, which can be dangerous, since external code may not be aware of the implementation details for the Class. If you restrict all access to your instance variables, to the public methods in a Class, you can carry out any checks etc there to ensure that your data is not assigned invalid values.

Using your Class

Now go back to your Main Class and enter the following inside your main method:

//code here will be executed when the program is run
//create a MyHelper object
MyHelper mh = new MyHelper();
//call a method on it, assign the result to a variable
int num = mh.getNumber();
//write the variable out for testing
System.out.println(num);

Compile and run your program and you should see the number 1 written to standard output. You create an Object of your Class, and call methods on it, in exactly the same way as any other Object. From your main method, you can call any methods on the MyHelper Object that are declared as public inside the Class.

A Class may also have private methods that are for use within the Class only. For example, one of your public Class methods may involve complex or repetitive processing that you decide to separate out into its own method, calling this from the public method – in this case the separate method should be declared as private, as this method relates to the implementation of the Class itself, which external code should not have access to.

Object principles

If you’re new to Object Oriented development in general, it can help to think in terms of ‘black boxes’. One of the principles that makes Java suited to developing large projects, is the idea that any application developed in Java can in turn be used by anyone else as a component in another application. Many open source projects use Java, with people sharing resources that they have developed in the language.

For this approach to be feasible, it must not be necessary for someone using a component to have to understand all of the implementation details within it. So long as there is a ‘well-defined’ interface, you should be able to make use of external Java libraries and resources while knowing nothing about what goes on inside them – in the same way that you can use a String or Array without having to understand how it is implemented in the underlying code. In this approach, you can think of Objects as ‘black boxes’ – code external to the Class should be able to make use of it without having to be aware of the inner code. When you develop your own Objects, you should adopt the same principle – even if you’re developing an application single-handed, this approach makes for programs that are faster to build and easier to debug.

More on Classes

As a final note, you should be aware that you can have more than one constructor method in a Class, each one taking different parameters. In this case whichever method is called is dictated by what parameters are passed when an Object of the Class is created. To demonstrate, add a second constructor to your Class, beneath the existing one:

	//class declaration
public class MyHelper {

//instance variable
	private int helperNum;

//constructor method
	public MyHelper()
	{
		helperNum=1;
	}
//second constructor - takes a parameter
	public MyHelper(int value)
	{
		helperNum=value;
	}

//public method
	public int getNumber()
	{
		return helperNum;
	}
}

Now add the following in your main method, after the existing code:

	//create an object passing int parameter
MyHelper mh2 = new MyHelper(2);
int num2 = mh2.getNumber();
System.out.println(num2);

When you run your program, this time it should output 1 and then 2 for the new Object. Whichever constructor matches the type and number of parameters passed is the one that’s called during Object creation.

When using Objects in your programs, you should try to decide what the various Classes will be at the outset, by dividing up the different requirements that your project has, and assigning responsibility for these to your set of Objects.

Next Java Tutorial – Datatypes .

Beginners Java Tutorial – Part 1

The Java language is currently one of the most widely used programming platforms, and can be used to build both desktop and Web applications. Java is used to develop with the Object Oriented technique, in which applications are characterised as a set of interacting ‘objects’, the objects being modules of code. This Java tutorial assumes no prior knowledge and aims to teach the basic fundamentals of Java Programming.

To start programming with Java, you will need:

• The Java Runtime Environment (JRE) installed on your computer.
• A Java IDE (Integrated Development Environment) such as Eclipse or Netbeans.

Using an IDE will make your Java projects straightforward to manage and develop, and is therefore strongly recommended.

Java compilation

When you write code in a programming language, the compiler for the language generally translates your code into machine code for a particular system. This is code that can be run directly by the hardware of a computer with a specific operating system, architecture etc. The situation is slightly different with Java. When you create and compile your Java code, the end result is code that runs on the Java Virtual Machine, not code that runs directly on any actual machine. When the application is actually run, the JVM translates it into machine code for the specific computer it’s running on.

The process is as follows: when you write Java programs, your code is contained in .java files; when you compile and run these programs, .class files are generated – these contain bytecode, which runs on the JVM. The JVM code is then translated into machine code for the host machine. This means that when you create your Java applications, your compiled code can run on any operating system with Java installed, as it’s only translated into machine code when it’s actually run – this is one of the main advantages to using Java.

It isn’t necessary that you understand these concepts to get started with Java so don’t worry too much if it all seems confusing at this stage – it’ll begin to make more sense as you start to write programs.

Your first program

Once you’ve chosen and installed an IDE for Java, you’ll need to familiarise yourself with its interface; you may also need to perform setup tasks such as choosing a workspace location – see the instructions for your particular IDE. Within your chosen IDE, you’ll need to create a new project each time you want to start a new Java program. Each project will contain at least one package, with the package(s) containing your source .java files.

Different IDEs provide different levels of assistance, for example, when you create a new project/ class in Eclipse or Netbeans, the environment automatically creates a default package for your code.

Each .java file in the project will generally represent a ‘class’ in your application, grouping together related code. Each of these ‘class declarations’ provides a blueprint for a type of Object in your application. Again, the notion of Object will become clearer as your Java skills progress.

Every project will contain at least one class: the ‘Main’ class. When your Java application is compiled and run, the first code that is executed is the code inside the ‘main method’ – this code will be inside your Main class. Create a new Project in your IDE and name it MyFirstJava. If you’re using Netbeans choose Create Main class, entering myfirstjava.MyFirstJava as the name. If you’re using Eclipse create a new class inside your project and name it MyFirstJava. Select your MyFirstJava class and enter the following code (your IDE may have filled some of it in for you):

//class declaration
public class MyFirstJava
{
//main method
	public static void main(String[] args)
	{
//code to be executed at runtime
		System.out.println("Well Hello There");
	}
}

Note: If you’ve programmed with scripting languages before, you can think of methods as functions.

If you compile and run the program you should see the phrase written to the standard output console (this should be visible within your IDE interface). All that the code does is write a message out, as this is all that’s contained within the main method.

You really don’t need to understand all of what’s going on here, in fact it’s easier when you’re starting out to just treat it as a formula that works; you’ll understand the details later. Each time you create a new Java program just follow this pattern and enter your code within the main method to start with, and the rest will soon follow. Next Java tutorial – Objects and Classes .