Final - Painter

import java.awt.Point;
import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionAdapter;
import javax.swing.JPanel;

public class PaintPanel extends JPanel
{
private int pointCount=0; //count number of points

//array of 10000 java.awet.Point references

private Point[] points=new Point[10000];

//set up GUI and register mouse event handler

public PaintPanel()
{
//handle frame mouse motion event

addMouseMotionListener(
new MouseMotionAdapter() //anonymous inner class
{
//store drag coordinates and repaint

public void mouseDragged(MouseEvent event)
{
if(pointCount {
points[pointCount]=event.getPoint(); //find point

pointCount++; //increment number of points in array

repaint(); // repaint JFrame

}//end if
}//end method mouseDragged
}//end anonymous inner class
);//end call to addMouseMotion Listener
}//end PaintPanel constructor

//draw ovals in a 4 by 4 bounding box at specified locations on window

public void paintComponent(Graphics g)

{
super.paintComponent(g); //clears drawing area

//draw all points in array

for (int i=0; i
g.fillOval(points[i].x, points[i].y,4,4);

}//end method paintComponent
}//end class PaintPanel

------------------------------------------------------------------------------------


import java.awt.BorderLayout;
import javax.swing.JFrame;
import javax.swing.JLabel;

public class Painter

{
public static void main(String[]args)
{
//create JFrame

JFrame application=new JFrame("A simple paint program");

PaintPanel paintPanel=new PaintPanel(); //create paint panel

application.add(paintPanel, BorderLayout.CENTER); //in center

//create a label and place it in SOUTH of border layout

application.add(new JLabel("Drag the mouse to draw"),BorderLayout.SOUTH);

application.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

application.setSize(400,200); //set frame size

application.setVisible(true); //display frame

}//end main
}//end class Painter

Wildcard Test

//wildcardTest.java

import java.util.ArrayList;

public class WildcardTest

{
public static void main(String[]args)

{
//create, initialize and output ArrayList of Integers, then display total of the elements

Integer[]integers = {1,2,3,4,5};

ArrayListintegerList=new ArrayList();

//insert elements in interger list

for (Integer element:integers)

integerList.add(element);

System.out.printf("integerList contains: %s\n", integerList);

System.out.printf("Total of the elements in integerList:%.0f\n\n", sum(integerList));

//create, initialize and output ArrayList of Doubles, then display total of the elements

Double[]doubles={1.1,3.3,5.5};

ArrayListdoubleList=new ArrayList();

//insert elements in doubleList

for (Double element:doubles)
doubleList.add(element);

System.out.printf("doubleList contains:%s\n", doubleList);

System.out.printf("Total of the elements in doubleList:%.1f\n\n", sum(doubleList));

//create, initialize and output ArrayList of numbers containing both integers and doubles, then display total of the elements

Number[]numbers={1,2.4,3,4.1}; //integers and doubles

ArrayListnumberList=new ArrayList();

//insert elements in numberList

for (Number element:numbers)
numberList.add(element);

System.out.printf("numberList contains:%s\n",numberList);
System.out.printf("Total of the elements in numberList:%.1f\n", sum (numberList));

}//end main

//total the elements; using a wildcard in the ArrayList parameter

public static double sum(ArrayListlist)

{
double total=0; //initialize total

//calculate sum

for (Number element:list)

total +=element.doubleValue();

return total;

}//end method sum
}//end class WildcardTest

Assignment 19 - Deck Of Cards

// Deck of Cards
//Card shuffling and dealing with collections method shuffle.

import java.util.List;
import java.util.Arrays;
import java.util.Collections;

//class to represent a Card in a deck of cards
class Card
{
public static enum Face { Ace, Deuce, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King };
public static enum Suit { Clubs, Diamonds, Hearts, Spades };

private final Face face; //face of card
private final Suit suit; //Suit of card

//two-argument constructor

public Card( Face cardFace, Suit cardSuit )
{
face = cardFace; //initialize face of card
suit = cardSuit; //initialize face of card
} //end two-argument card constructor

//return face of the card

public Face getFace()
{
return face;
} // end method getFace

//return suit of card

public Suit getSuit()
{
return suit;
} //end method getSuit

//return string representation of card

public String toString()
{
return String.format("%s of %s", face, suit );
} //end method toString
}//end class card

//class DeckofCards declaration

public class DeckOfCards
{
private List<> list; //declare List that will store cards

//set up deck of cards and shuffle
public DeckOfCards()
{
Card[] deck = new Card [ 52 ];
int count = 0; //number of cards

//populate deck with Card Objects

for ( Card.Suit suit : Card.Suit.values() )
{
for ( Card.Face face : Card.Face.values() )
{
deck[ count ] = new Card( face, suit );
++count;
} //end for
}//end for

list = Arrays.asList( deck ); // get list
Collections.shuffle( list ); //shuffle deck
} //end of DeckOfCards constructor

// output deck

public void printCards()
{
//display 52 cards in two colums

for ( int i = 0; i System.out.printf( "%-19s%s", list.get( i ),
( ( i+1 ) %4 == 0 ) ? "\n" : "");
} //end method print cards

public static void main( String[] args )
{
DeckOfCards cards = new DeckOfCards();
cards.printCards();
}//end main
}//end class DeckOfCards

Assignment 17: Slider Demo

/*
//Graphics problem
*/
import java.awt.Graphics;
import java.awt.Dimension;
import javax.swing.JPanel;

public class OvalPanel extends JPanel
{
private int diameter = 10;//default diameter of 10

//draw an oval of the specified diameter
public void paintComponent( Graphics g )
{
super.paintComponent( g );

g.fillOval( 10, 10, diameter, diameter ); //draw circle
}

//validate and set diameter
public void setDiameter( int newDiameter )
{
//if diameter invalid, default to 10
diameter = ( newDiameter >= 0 ? newDiameter : 10 );
repaint(); //repaint panel
}

//use by layout manager to determine preffered size
public Dimension getPreferredSize()
{
return new Dimension( 200, 200 );
}

//used by layout manager to determine minimum size
public Dimension getMinimumSize()
{
return getPreferredSize();
}
}


-----------------------------------------------------------------



/*
//SliderFrame
*/
import java.awt.BorderLayout;
import java.awt.Color;
import javax.swing.JFrame;
import javax.swing.JSlider;
import javax.swing.SwingConstants;
import javax.swing.event.ChangeListener;
import javax.swing.event.ChangeEvent;

public class SliderFrame extends JFrame
{
private JSlider diameterJSlider; // slider to select diameter
private OvalPanel myPanel; // panel to draw circle

//no argument constructor
public SliderFrame()
{
super( "Slider Demo" );

myPanel = new OvalPanel(); //create panel to draw circle
myPanel.setBackground( Color.YELLOW ); //set bacground to yellow

//set up JSlider to control diameter value
diameterJSlider = new JSlider( SwingConstants.HORIZONTAL, 0 , 200, 10 );
diameterJSlider.setMajorTickSpacing(10); //create tick every 10
diameterJSlider.setPaintTicks( true ); //paint ticks on slider

//register JSlider event listener
diameterJSlider.addChangeListener(

new ChangeListener() //anonymous inner circle
{
//handle change in slider value
public void stateChanged( ChangeEvent e )
{
myPanel.setDiameter( diameterJSlider.getValue() );
}
}
);

add( diameterJSlider, BorderLayout.SOUTH ); //add slider to frame
add( myPanel, BorderLayout.CENTER ); //add panel to frame
}
}

---------------------------------------------------------------------

/*
//main method
*/

import javax.swing.JFrame;

public class SliderDemo
{
public static void main( String args[] )
{
SliderFrame sliderFrame = new SliderFrame();
sliderFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
sliderFrame.setSize( 220, 270 ); //set frame size
sliderFrame.setVisible( true ); //display frame
}
}

Assignment 18 - Menu Test

// Fig. 22.5: MenuFrame.java
// Demostrating menus.

import java.awt.Color;
import java.awt.Font;
import java.awt.BorderLayout;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.event.ItemListener;
import java.awt.event.ItemEvent;
import javax.swing.JFrame;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JLabel;
import javax.swing.SwingConstants;
import javax.swing.ButtonGroup;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JMenuBar;

public class MenuFrame extends JFrame
{
private final Color colorValues[]=
{Color.BLACK, Color.BLUE, Color.RED, Color.GREEN};
private JRadioButtonMenuItem colorItems[]; //color menu items
private JRadioButtonMenuItem fonts[]; //font menu items
private JCheckBoxMenuItem styleItems[]; //font style menu items
private JLabel displayJLabel; //displays sample text
private ButtonGroup fontButtonGroup; //manages font menu items
private ButtonGroup colorButtonGroup; //manages color menu items
private int style; // used to create style for font

// no argument constructor set up GUI
public MenuFrame()
{
super("Using Menus");

JMenu fileMenu = new JMenu("File"); //create file menu
fileMenu.setMnemonic('F'); //set mnemonic to F

//create About... menu item
JMenuItem aboutItem = new JMenuItem("About...");
aboutItem.setMnemonic('A'); //set mnemonic to A
fileMenu.add( aboutItem ); //add about item to file menu
aboutItem.addActionListener(

new ActionListener() //anonuymous inner class
{
//displays message dialog when the user selects About...
public void actionPerformed(ActionEvent event)
{
JOptionPane.showMessageDialog(MenuFrame.this,
"This is an example\nof using menus",
"About",JOptionPane.PLAIN_MESSAGE);
}//end method actionPerformed
}//end anonymous inner class
);//end call to addActionListener

JMenuItem exitItem = new JMenuItem("Exit"); //create exit item
exitItem.setMnemonic('X'); //set mnemonic to x
fileMenu.add(exitItem); //add exit item to file menu
exitItem.addActionListener(

new ActionListener() //anonymous inner class
{
//terminate application when user clicks exitItem
public void actionPerformed(ActionEvent event)
{
System.exit(0); //exit application
}//end method actionPerformed
}//end anonymous inner class
);//end call to addActionListener

JMenuBar bar = new JMenuBar(); //create menu bar
setJMenuBar(bar); //add menu bar to application
bar.add(fileMenu); //add file menu to menu bar

JMenu formatMenu = new JMenu("Format"); //create format menu
formatMenu.setMnemonic('r'); //set mnemonic to r

//array listing string colors

String colors[]={"Black", "Blue", "Red", "Green"};

JMenu colorMenu = new JMenu("Color"); //create color menu
colorMenu.setMnemonic('C'); //set mnenonic to C

//create radio button menu items for colors
colorItems = new JRadioButtonMenuItem[ colors.length ];
colorButtonGroup = new ButtonGroup(); //manages colors
ItemHandler itemHandler = new ItemHandler(); //handler for colors

//create color radio button menu items
for (int count = 0; count{
colorItems[count] =
new JRadioButtonMenuItem( colors[ count ]); //create item
colorMenu.add(colorItems[count]); //add item to color menu
colorButtonGroup.add(colorItems[ count ]); //add to group
colorItems [ count ].addActionListener(itemHandler);
}//end for

colorItems[ 0 ].setSelected(true); //select first Color item

formatMenu.add(colorMenu); //add color menu to format menu
formatMenu.addSeparator(); //add separator in menu

//array listing font names
String fontNames[]={"Serif","Monospaced","SansSerif"};
JMenu fontMenu = new JMenu("Font"); //create font menu
fontMenu.setMnemonic('n'); //set mnemonic to n

//create radio button menu items for font names
fonts = new JRadioButtonMenuItem[ fontNames.length];
fontButtonGroup = new ButtonGroup(); //manages font names

//create Font radio button menu items
for (int count = 0; count{
fonts[ count ] = new JRadioButtonMenuItem(fontNames[count]);
fontMenu.add(fonts[count]); //add font to font menu
fontButtonGroup.add(fonts[count]); //add to button group
fonts[count].addActionListener(itemHandler); //add handler
}//end for

fonts[ 0 ].setSelected(true); //select first Font menu item
fontMenu.addSeparator(); //add separator bar to font menu

String styleNames[]={"Bold","Italic"}; //names of styles
styleItems = new JCheckBoxMenuItem[ styleNames.length];
StyleHandler styleHandler = new StyleHandler(); //style handler

//create style checkbox menu items
for (int count =0; count{
styleItems[count]=
new JCheckBoxMenuItem(styleNames[count]); //for style
fontMenu.add(styleItems[count]); //add to font menu
styleItems[count].addItemListener(styleHandler); //handler
}//end for

formatMenu.add(fontMenu); //add font menu to format menu
bar.add(formatMenu); //add format menu to menu bar

// set up label to display text

displayJLabel = new JLabel("Sample Text", SwingConstants.CENTER);
displayJLabel.setForeground(colorValues[0]);
displayJLabel.setFont( new Font("Serif", Font.PLAIN,72));

getContentPane().setBackground(Color.CYAN); //set background
add(displayJLabel,BorderLayout.CENTER); //add displayJLabel
}//end MenuFrame Constructor

//inner class to handle action events from menu items

private class ItemHandler implements ActionListener
{
//process color and font selections
public void actionPerformed(ActionEvent event)
{
//process color selection
for (int count =0; count {
if (colorItems[count].isSelected())
{
displayJLabel.setForeground(colorValues[ count]);
break;
}//end if
}//end for

//process font selection

for (int count =0; count{
if (event.getSource()==fonts[count])
{
displayJLabel.setFont(
new Font(fonts[count].getText(), style,72));
}//end if
}//end for

repaint(); //redraw application
}//end method actionPerformed
}//end class ItemHandler

// inner class to handle item events from chech box menu items
private class StyleHandler implements ItemListener
{
//process font style selections
public void itemStateChanged(ItemEvent e)
{
style = 0; //initialize style

//check for bold selection
if (styleItems[1].isSelected())
style +=Font.BOLD; //add bold to style

//check for italic selection
if (styleItems[1].isSelected())
style +=Font.ITALIC; //add italic to style

displayJLabel.setFont(
new Font(displayJLabel.getFont().getName(),style,72));
repaint(); //redraw application
}//end method itemStateChanged
}//end class StyleHandler
}//end class MenuFrame

------------------------------------------------------------------------------

//Fig 22.65 MenuTest.java
//Testing MenuFrame.

import javax.swing.JFrame;

public class MenuTest
{
public static void main(String args[])

{
MenuFrame menuFrame = new MenuFrame(); //create MenuFrame
menuFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
menuFrame.setSize(500, 200); //set frame size
menuFrame.setVisible(true); //display frame
}//end main
}//end class MenuTest

MIDTERM - InsertionSortTest

/*

Insertion Sort Midterm
*/

import java.util.Random;


public class InsertionSort
{
private int[] data; //array of values
private static Random generator = new Random();

//create array of given size to fill
public InsertionSort( int size )
{
data = new int[size]; //create space for arrays

//fill arrays with random numbers 10-99
for( int i = 0; i < size; i++ )
data[i] = 10 + generator.nextInt(90);
}

//sort array using insertion sort
public void sort()
{
int insert; //temp; variable to hold element to insert

//loop over data.length - elements
for( int next = 1; next < data.length; next++ )
{
//sort value in current element
insert = data[next];

//initialize location to place element
int moveItem = next;

//search for place to put current element
while( moveItem > 0 && data[moveItem - 1] > insert )
{
//shift element right one slot
data[moveItem] = data[moveItem - 1];
moveItem--;
}

data[moveItem] = insert; //place inserted element
printPass( next, moveItem ); //output pass of algorithm
}
}

//print a pass of the algorithm
public void printPass( int pass, int index )
{
System.out.print( String.format( "after pass %2d: ", pass ) );

//output elements till swapped item
for( int i = index + 1; i < data.length; i++ )
System.out.print( data[i] + " ");

System.out.print( "\n " ); //for allignment

//indicate amount of array that is sorted
for( int i = 0; i <= pass; i++ )
System.out.print( "-- " );
System.out.println( "\n" ); //add endline
}

//method to output values in array
public String toString()
{
StringBuilder temporary = new StringBuilder();

//iterate through array
for ( int element : data )
temporary.append( element + " " );


temporary.append( "\n" ); //add endline character
return temporary.toString();
}
}

---------------------------------------------------------------------------------

/*

main function MIDTERM
*/
public class InsertionSortTest
{
public static void main( String[] args )
{
//create object to perform insertion sort
InsertionSort sortArray = new InsertionSort( 10 );

System.out.println( "Unsorted array: " );
System.out.println( sortArray ); //print unsorted array

sortArray.sort();

System.out.println( "Sorted array: " );
System.out.println( sortArray ); //print sorted array
}
}

Assignment 14 - Merge Sort Test

/*

Merge Sort

*/

import java.util.Random;

public class MergeSort
{
private int[] data; //array of values
private static Random generator = new Random();

//create array of given size and fill with random integers
public MergeSort( int size )
{
data = new int[size]; //create space for array

//fill array with random ints range 10-99
for( int i = 0; i < size; i++ )
data[i] = 10 + generator.nextInt( 90 );
}

//calls recursive split method to begin merge sorting
public void sort()
{
sortArray( 0, data.length - 1); //split entire array
}

//splits array, sort subarrays and merges subarrays into sorted array
private void sortArray( int low, int high )
{
//test case: size of array equals 1
if( ( high - low ) >= 1 ) //if not base case
{
int middle1 = (low + high )/2; //calculate middle of array
int middle2 = middle1 + 1; //calculate next element over

//output split step
System.out.println( "split: " + subarray( low, high ) );
System.out.println( " " + subarray( low, middle1 ) );
System.out.println( " " + subarray( middle2, high ) );

//split array in half; sort each half of array
sortArray( low, middle1 ); //first half of array
sortArray( middle2, high ); //second half of array

//merge 2 sorted arrays after split calls return
merge( low, middle1, middle2, high );
}
}

//merge 2 sorted subarrays into one sorted sub array
private void merge( int left, int middle1, int middle2, int right )
{
int leftIndex = left; //index into left subarray
int rightIndex = middle2; //index into right subarray
int combinedIndex = left; //index into temp. work array
int[] combined = new int[data.length]; //working array

//output 2 subarrays before merging
System.out.println( "merge: " + subarray( left, middle1 ) );
System.out.println( " " + subarray( middle2, right ) );

//merge arrays until reaching end of either
while( leftIndex <= middle1 && rightIndex <= right )
{
//place smaller of 2 current elements into result
//and move to next space in arrays
if( data[leftIndex] <= data[rightIndex] )
combined[combinedIndex++] = data[leftIndex++];
else
combined[combinedIndex++] = data[rightIndex++];
}

//if array is empty
if( leftIndex == middle2 )
//copy in rest of right array
while( rightIndex <= right )
combined[combinedIndex++] = data[rightIndex++];
else
//copy in rest of left array
while( leftIndex <= middle1 )
combined[combinedIndex++] = data[leftIndex++];

//copy values back into original array
for( int i = left; i <= right; i++ )
data[i] = combined[i];

//output merged array
System.out.println(" " + subarray( left, right ) );
System.out.println();

}

//method to output certain values in array
public String subarray( int low, int high )
{
StringBuilder temporary = new StringBuilder();

//output spaces for alignment
for( int i = 0; i < low; i++ )
temporary.append( "" );

//output elements left in array
for( int i = low; i <= high; i++ )
temporary.append( "" + data[i] );

return temporary.toString();
}

//method to output values in array
public String toString()
{
return subarray( 0, data.length - 1 );
}
}


--------------------------------------------------------------------------



/*

main function

*/

public class MergeSortTest
{
public static void main( String[] args )
{
//create object to perform merge sort
MergeSort sortArray = new MergeSort(10);

//print unsorted array
System.out.println( "Unsorted: " + sortArray + "\n" );

sortArray.sort(); //sort array

//print sorted array
System.out.println( "Sorted: " + sortArray );
}
}

Assignment 13 - Insertion Sort Test

/*
Assignment 13
Insertion Sort
*/

import java.util.Random;


public class InsertionSort
{
private int[] data; //array of values
private static Random generator = new Random();

//create array of given size to fill
public InsertionSort( int size )
{
data = new int[size]; //create space for arrays

//fill arrays with random numbers 10-99
for( int i = 0; i < size; i++ )
data[i] = 10 + generator.nextInt(90);
}

//sort array using insertion sort
public void sort()
{
int insert; //temp; variable to hold element to insert

//loop over data.length - elements
for( int next = 1; next < data.length; next++ )
{
//sort value in current element
insert = data[next];

//initialize location to palce element
int moveItem = next;

//search for place to put current element
while( moveItem > 0 && data[moveItem - 1] > insert )
{
//shift element right one slot
data[moveItem] = data[moveItem - 1];
moveItem--;
}

data[moveItem] = insert; //place inserted element
printPass( next, moveItem ); //output pass of algorithm
}
}

//print a pass of the algorithm
public void printPass( int pass, int index )
{
System.out.print( String.format( "after pass %2d: ", pass ) );

//output elements till swapped item
for( int i = index + 1; i < data.length; i++ )
System.out.print( data[i] + " ");

System.out.print( "\n " ); //for allignment

//indicate amount of array that is sorted
for( int i = 0; i <= pass; i++ )
System.out.print( "-- " );
System.out.println( "\n" ); //add endline
}

//method to output values in array
public String toString()
{
StringBuilder temporary = new StringBuilder();

//iterate through array
for ( int element : data )
temporary.append( element + " " );


temporary.append( "\n" ); //add endline character
return temporary.toString();
}
}


---------------------------------------------------------------------------------


/*
Assignment 13
main function
*/
public class InsertionSortTest
{
public static void main( String[] args )
{
//create object to preform insertion sort
InsertionSort sortArray = new InsertionSort( 10 );

System.out.println( "Unsorted array: " );
System.out.println( sortArray ); //print unsorted array

sortArray.sort();

System.out.println( "Sorted array: " );
System.out.println( sortArray ); //print sorted array
}
}

Assignment 12 - Selection Sort Test

/*
Selection Sort Algorithm
*/

import java.util.Random;

public class SelectionSort

{
private int[] data; //array of value
private static Random generator = new Random();

//create array if given size and fill w/ random int

public SelectionSort( int size )
{
data = new int[size]; //create space for array

//fill array with random int 10-99

for(int i = 0; i < size; i++ )
data[i] = 10 + generator.nextInt( 90 );
}

//sort array using slection sort

public void sort()
{
int smallest; //index of smallest element

//loop over data length -1
for(int i = 0; i < data.length - 1; i++)
{
smallest = i; //first index of remaining array

//loops to find index of smallest element

for( int index = i + 1; index < data.length; index++)
if(data[index] < data[smallest])
smallest = index;

swap( i, smallest); //swap smallest elements into position
printPass( i + 1, smallest );
}
}

//helper method to swap values in two elements

public void swap( int first, int second )
{
int temporary = data[first]; // store first in temporary
data[first] = data[second]; // replace first with second
data[second] = temporary; // put temporary in second
}

//print a pass of algorigthm

public void printPass( int pass, int index )
{
System.out.print( String.format( "after pass %2d; ", pass) );

//output elements till selectem item

for (int i = 0; i < index; i++)
System.out.print( data[i] + "");

System.out.print( "\n "); //for alignment

//indicate amount of array that is sorted

for( int j = 0; j < pass; j++ )
System.out.println("\n"); //add endline
}

//method to output balues in array

public String toString()
{
StringBuilder temporary = new StringBuilder();

//iterate through array

for( int element : data)
temporary.append( element + " " );

temporary.append("\n");
return temporary.toString();
}
}


-------------------------------------------------------------------


/*
main function
*/

public class SelectionSortTest
{
public static void main( String[] args )
{

//create object to perform selection sort

SelectionSort sortArray = new SelectionSort(10);

System.out.println( "Unsorted array:" );
System.out.println( sortArray ); //print unsorted array

sortArray.sort(); //sort array

System.out.println( "Sorted Array:" );
System.out.println( sortArray ); //print sorted array
}
}

Towers of Hanoi

/* Towers of Hanoi */

public class TowersOfHanoi
{
private int numDisks; //number of disks to move

public TowersOfHanoi( int disks )
{
numDisks = disks;
}

//recursively more disks between towers
public void solveTowers(int disks, int sourcePeg, int destinationPeg, int tempPeg)
{

//base case -- only one disk to move

if( disks == 1)
{
System.out.printf("\n%d --> %d",sourcePeg, destinationPeg);
return;
}

//recursion step -- move (disk -1) disk from sourcePeg
//to tempPEg using destinationPeg

solveTowers(disks-1,sourcePeg,tempPeg,destinationPeg);

//move last disk from sourcePeg to destinationPeg

System.out.printf("\n%d --> %d", sourcePeg, destinationPeg);

//move (disk-1) disk from tempPeg to destinationPeg

solveTowers( disks - 1, tempPeg, destinationPeg, sourcePeg);
}
}

--------------------------------------------------------------------


/* Main function to be run */

public class TowersOfHanoiTest

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

int startPeg = 1; // value 1 used to indicate startPeg in output
int endPeg = 3; // value 3 usedto indicate endPeg in output
int tempPeg = 2; // value 2 used to indicate tempPeg output
int totalDisks = 3; // number of disks

TowersOfHanoi towersOfHanoi = new TowersOfHanoi(totalDisks);

//initial nonrecursive call: move all disks

towersOfHanoi.solveTowers(totalDisks, startPeg, endPeg, tempPeg);
}
}