Question

import javax.swing.*; import java.awt.*; import java.util.List; import java.util.*; /** * Canvas is a class to allow for simple graphical drawing on a canvas. * This is a modification of the general purpose Canvas, specially made for * the BlueJ "shapes" example. * * @author: Bruce Quig * @author: Michael Kolling (mik) * Minor changes to canvas dimensions by William Smith 6/4/2012 * * @version: 1.6 (shapes) */ public class Canvas { // Note: The implementation of this class (specifically the handling of // shape identity and colors) is slightly more complex than necessary. This // is done on purpose to keep the interface and instance fields of the // shape objects in this project clean and simple for educational purposes. private static Canvas canvasSingleton; /** * Factory method to get the canvas singleton object. */ public static Canvas getCanvas() { if(canvasSingleton == null) { canvasSingleton = new Canvas("BlueJ Shapes Demo", 400, 200, Color.white); } canvasSingleton.setVisible(true); return canvasSingleton; } // ----- instance part ----- private JFrame frame; private CanvasPane canvas; private Graphics2D graphic; private Color backgroundColour; private Image canvasImage; private ArrayList objects; private HashMap shapes; /** * Create a Canvas. * @param title title to appear in Canvas Frame * @param width the desired width for the canvas * @param height the desired height for the canvas * @param bgClour the desired background colour of the canvas */ private Canvas(String title, int width, int height, Color bgColour) { frame = new JFrame(); canvas = new CanvasPane(); frame.setContentPane(canvas); frame.setTitle(title); canvas.setPreferredSize(new Dimension(width, height)); backgroundColour = bgColour; frame.pack(); objects = new ArrayList(); shapes = new HashMap(); } /** * Set the canvas visibility and brings canvas to the front of screen * when made visible. This method can also be used to bring an already * visible canvas to the front of other windows. * @param visible boolean value representing the desired visibility of * the canvas (true or false) */ public void setVisible(boolean visible) { if(graphic == null) { // first time: instantiate the offscreen image and fill it with // the background colour Dimension size = canvas.getSize(); canvasImage = canvas.createImage(size.width, size.height); graphic = (Graphics2D)canvasImage.getGraphics(); graphic.setColor(backgroundColour); graphic.fillRect(0, 0, size.width, size.height); graphic.setColor(Color.black); } frame.setVisible(visible); } /** * Draw a given shape onto the canvas. * @param referenceObject an object to define identity for this shape * @param color the color of the shape * @param shape the shape object to be drawn on the canvas */ // Note: this is a slightly backwards way of maintaining the shape // objects. It is carefully designed to keep the visible shape interfaces // in this project clean and simple for educational purposes. public void draw(Object referenceObject, String color, Shape shape) { objects.remove(referenceObject); // just in case it was already there objects.add(referenceObject); // add at the end shapes.put(referenceObject, new ShapeDescription(shape, color)); redraw(); } /** * Erase a given shape's from the screen. * @param referenceObject the shape object to be erased */ public void erase(Object referenceObject) { objects.remove(referenceObject); // just in case it was already there shapes.remove(referenceObject); redraw(); } /** * Set the foreground colour of the Canvas. * @param newColour the new colour for the foreground of the Canvas */ public void setForegroundColor(String colorString) { if(colorString.equals("red")) graphic.setColor(Color.red); else if(colorString.equals("black")) graphic.setColor(Color.black); else if(colorString.equals("blue")) graphic.setColor(Color.blue); else if(colorString.equals("yellow")) graphic.setColor(Color.yellow); else if(colorString.equals("green")) graphic.setColor(Color.green); else if(colorString.equals("magenta")) graphic.setColor(Color.magenta); else if(colorString.equals("white")) graphic.setColor(Color.white); else graphic.setColor(Color.black); } /** * Wait for a specified number of milliseconds before finishing. * This provides an easy way to specify a small delay which can be * used when producing animations. * @param milliseconds the number */ public void wait(int milliseconds) { try { Thread.sleep(milliseconds); } catch (Exception e) { // ignoring exception at the moment } } /** * Redraw ell shapes currently on the Canvas. */ private void redraw() { erase(); for(Iterator i=objects.iterator(); i.hasNext(); ) { ((ShapeDescription)shapes.get(i.next())).draw(graphic); } canvas.repaint(); } /** * Erase the whole canvas. (Does not repaint.) */ private void erase() { Color original = graphic.getColor(); graphic.setColor(backgroundColour); Dimension size = canvas.getSize(); graphic.fill(new Rectangle(0, 0, size.width, size.height)); graphic.setColor(original); } /************************************************************************ * Inner class CanvasPane - the actual canvas component contained in the * Canvas frame. This is essentially a JPanel with added capability to * refresh the image drawn on it. */ private class CanvasPane extends JPanel { public void paint(Graphics g) { g.drawImage(canvasImage, 0, 0, null); } } /************************************************************************ * Inner class CanvasPane - the actual canvas component contained in the * Canvas frame. This is essentially a JPanel with added capability to * refresh the image drawn on it. */ private class ShapeDescription { private Shape shape; private String colorString; public ShapeDescription(Shape shape, String color) { this.shape = shape; colorString = color; } public void draw(Graphics2D graphic) { setForegroundColor(colorString); graphic.fill(shape); } } } import java.awt.*; import java.awt.geom.*; /** * A circle that can be manipulated and that draws itself on a canvas. * * @author Michael Kolling and David J. Barnes * @version 1.0 (15 July 2000) */ public class Circle { private int diameter; private int xPosition; private int yPosition; private String color; private boolean isVisible; /** * Create a new circle at given position with given diameter and default color. */ public Circle(int diameter, int xPosition, int yPosition, String color) { this.diameter = diameter; this.xPosition = xPosition; this.yPosition = yPosition; this.color = color; isVisible = false; } /** * Make this circle visible. If it was already visible, do nothing. */ public void makeVisible() { isVisible = true; draw(); } /** * Make this circle invisible. If it was already invisible, do nothing. */ public void makeInvisible() { erase(); isVisible = false; } /* * Draw the circle with current specifications on screen. */ private void draw() { if(isVisible) { Canvas canvas = Canvas.getCanvas(); canvas.draw(this, color, new Ellipse2D.Double(xPosition, yPosition, diameter, diameter)); canvas.wait(10); } } /* * Erase the circle on screen. */ private void erase() { if(isVisible) { Canvas canvas = Canvas.getCanvas(); canvas.erase(this); } } } /** * Demonstrates a two-dimensional array. * * @author Derek Green * @version November 6, 06 * modified by William Smith 6/7/2012 */ public class TestTwoDimArray { private final int rows = 10; private final int cols = 20; private final int diameter = 20; /* Add a two-dimensional Circle array field to hold your circles. */ /** * Creates an empty 2-dimensional Circle array. */ /* Write a constructor method that initializes the array. The first dimension should be given size rows, and the second dimension should be given size cols. */ /** * Fill the array with circles. */ /* Write a method called "fillArray" that fills the entire array with blue circles. Give all circles the same diameter using the field defined above. Circles in the same row should have the same yPosition. Circles in the same column should have the same xPosition. The yPosition for row 0 should be 0. The yPosition for row 1 should be diameter. The yPosition for row 2 should be 2*diameter... Continue this pattern for all rows. Use a similar pattern to set the xPosition of each circle in a given column. If you do this correctly, no circle will overlap another circle. Once you get this working, then fix your code so that it does not add circles to positions in the array that are already occupied by a circle. You can tell whether a position is empty by checking if it contains null. */ /** * Add a random number of circles (between 1 and rows * cols). * Only need one loop here; */ /* Write a method called "addSomeCircles" that tries to add a random number of red circles to the array in a random fashion. The number of circles it tries to add should be between 1 and rows*cols, inclusive. For each circle choose a random row number and a random column number. The x and y positions of the circle should follow the plan used in the "fillArray" method. If the array has no circle at that position, add one, otherwise move on. Your method should return the number of collisions you had while adding circles. Remember, an empty element in the array will be equal (i.e., ==) to null. */ /** * Add a single circle at (row,col). * Make sure you account for arrays having positions from 0 to n and test for entering an invalid position */ /* Write a method called "addSingleCircle" that takes an integer parameter for the row and an integer parameter for the column. If the coordinates specify a valid position in the array, and the array has no circle at that position, then add a green one, otherwise do nothing. The x and y position of the circle should follow the plan used in the "fillArray" method. */ /** * Makes all circles in the array visible. */ /* Write a method called "makeAllCirclesVisible" that makes all circles in the array visible. */ /** * Makes all circles in the array invisible. */ /* Write a method called "makeAllCirclesInvisible" that makes all circles in the array invisible. */ /** * Remove all circles from the array. */ /* Write a method called "emptyArray" that removes all circles from the array (i.e. make them all null.) (Don't forget to make them all invisible first.) */ } please finish coding!

Answer 1

CODE::::

import java.awt.*;
import java.awt.geom.Ellipse2D;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Random;
import javax.swing.JFrame;
import javax.swing.JPanel;
/** * Canvas is a class to allow for simple graphical drawing on a canvas. * This is a modification of the general purpose Canvas, specially made for * the BlueJ "shapes" example. * * @author: Bruce Quig * @author: Michael Kolling (mik) * Minor changes to canvas dimensions by William Smith 6/4/2012 * * @version: 1.6 (shapes) */
public class Canvas
{ // Note: The implementation of this class (specifically the handling of // shape identity and colors) is slightly more complex than necessary. This // is done on purpose to keep the interface and instance fields of the
// shape objects in this project clean and simple for educational purposes.
private static Canvas canvasSingleton;
/** * Factory method to get the canvas singleton object. */
public static Canvas getCanvas() {
if(canvasSingleton == null) {
canvasSingleton = new Canvas("BlueJ Shapes Demo", 400, 200, Color.white);
}
canvasSingleton.setVisible(true);
return canvasSingleton;
}

// ----- instance part -----
private JFrame frame;
private CanvasPane canvas;
private Graphics2D graphic;
private Color backgroundColour;
private Image canvasImage;
private ArrayList objects;
private HashMap shapes;
/** * Create a Canvas. * @param title title to appear in Canvas Frame * @param width the desired width for the canvas * @param height the desired height for the canvas * @param bgClour the desired background colour of the canvas */
private Canvas(String title, int width, int height, Color bgColour) {
frame = new JFrame();
canvas = new CanvasPane();
frame.setContentPane(canvas);
frame.setTitle(title);
canvas.setPreferredSize(new Dimension(width, height));
backgroundColour = bgColour;
frame.pack();
objects = new ArrayList();
shapes = new HashMap();
}
/** * Set the canvas visibility and brings canvas to the front of screen * when made visible. This method can also be used to bring an already * visible canvas to the front of other windows. * @param visible boolean value representing the desired visibility of * the canvas (true or false) */
public void setVisible(boolean visible) {
if(graphic == null) { // first time: instantiate the offscreen image and fill it with // the background colour
Dimension size = canvas.getSize();
canvasImage = canvas.createImage(size.width, size.height);
graphic = (Graphics2D)canvasImage.getGraphics();
graphic.setColor(backgroundColour);
graphic.fillRect(0, 0, size.width, size.height);
graphic.setColor(Color.black);
}
frame.setVisible(visible);
}
/** * Draw a given shape onto the canvas. * @param referenceObject an object to define identity for this shape * @param color the color of the shape * @param shape the shape object to be drawn on the canvas */ // Note: this is a slightly backwards way of maintaining the shape // objects. It is carefully designed to keep the visible shape interfaces // in this project clean and simple for educational purposes.
public void draw(Object referenceObject, String color, Shape shape) {
objects.remove(referenceObject);
// just in case it was already there objects.add(referenceObject); // add at the end
shapes.put(referenceObject, new ShapeDescription(shape, color));
redraw();
} /** * Erase a given shape's from the screen. * @param referenceObject the shape object to be erased */
public void erase(Object referenceObject) {
objects.remove(referenceObject);
// just in case it was already there
shapes.remove(referenceObject);
redraw();
} /** * Set the foreground colour of the Canvas. * @param newColour the new colour for the foreground of the Canvas */
public void setForegroundColor(String colorString) {
if(colorString.equals("red")) graphic.setColor(Color.red);
else if(colorString.equals("black")) graphic.setColor(Color.black);
else if(colorString.equals("blue")) graphic.setColor(Color.blue);
else if(colorString.equals("yellow")) graphic.setColor(Color.yellow);
else if(colorString.equals("green")) graphic.setColor(Color.green);
else if(colorString.equals("magenta")) graphic.setColor(Color.magenta);
else if(colorString.equals("white")) graphic.setColor(Color.white);
else graphic.setColor(Color.black);
} /** * Wait for a specified number of milliseconds before finishing. * This provides an easy way to specify a small delay which can be * used when producing animations. * @param milliseconds the number */
public void wait(int milliseconds) {
try { Thread.sleep(milliseconds);
} catch (Exception e) { // ignoring exception at the moment
} } /** * Redraw ell shapes currently on the Canvas. */
private void redraw() {
erase();
for(Iterator i=objects.iterator(); i.hasNext(); ) {
((ShapeDescription)shapes.get(i.next())).draw(graphic);
}
canvas.repaint();
} /** * Erase the whole canvas. (Does not repaint.) */
private void erase() {
Color original = graphic.getColor();
graphic.setColor(backgroundColour);
Dimension size = canvas.getSize();
graphic.fill(new Rectangle(0, 0, size.width, size.height));
graphic.setColor(original);
} /************************************************************************ * Inner class CanvasPane - the actual canvas component contained in the * Canvas frame. This is essentially a JPanel with added capability to * refresh the image drawn on it. */
private class CanvasPane extends JPanel {
public void paint(Graphics g) {
g.drawImage(canvasImage, 0, 0, null);
}
} /************************************************************************ * Inner class CanvasPane - the actual canvas component contained in the * Canvas frame. This is essentially a JPanel with added capability to * refresh the image drawn on it. */
private class ShapeDescription {
private Shape shape;
private String colorString;
public ShapeDescription(Shape shape, String color) {
this.shape = shape; colorString = color;
} public void draw(Graphics2D graphic) {
setForegroundColor(colorString); graphic.fill(shape);
} }
}

/** * A circle that can be manipulated and that draws itself on a canvas. * * @author Michael Kolling and David J. Barnes * @version 1.0 (15 July 2000) */
class Circle {
private int diameter;
private int xPosition;
private int yPosition;
private String color;
private boolean isVisible;
/** * Create a new circle at given position with given diameter and default color. */
public Circle(int diameter, int xPosition, int yPosition, String color) {
this.diameter = diameter;
this.xPosition = xPosition;
this.yPosition = yPosition;
this.color = color;
isVisible = false;
} /** * Make this circle visible. If it was already visible, do nothing. */
public void makeVisible() {
isVisible = true; draw();
} /** * Make this circle invisible. If it was already invisible, do nothing. */
public void makeInvisible() {
erase(); isVisible = false;
} /* * Draw the circle with current specifications on screen. */
private void draw() {
if(isVisible) {
Canvas canvas = Canvas.getCanvas();
canvas.draw(this, color, new Ellipse2D.Double(xPosition, yPosition, diameter, diameter));
canvas.wait(10);
}
} /* * Erase the circle on screen. */
  
private void erase() {
if(isVisible) {
Canvas canvas = Canvas.getCanvas();
canvas.erase(this);
}
}
}

/** * Demonstrates a two-dimensional array. * * @author Derek Green * @version November 6, 06 * modified by William Smith 6/7/2012 */

class TestTwoDimArray {
private final int rows = 10;
private final int cols = 20;
private final int diameter = 20;
  
/* Add a two-dimensional Circle array field to hold your circles. */
/** * Creates an empty 2-dimensional Circle array. */
Circle c1[][];
/* Write a constructor method that initializes the array. The first dimension should be given size rows, and the second dimension should be given size cols. */
public TestTwoDimArray()
{
c1=new Circle[rows][cols];
}
/** * Fill the array with circles. */
/* Write a method called "fillArray" that fills the entire array with blue circles.
Give all circles the same diameter using the field defined above. circles in the same row should have the same yPosition.
Circles in the same column should have the same xPosition. The yPosition for row 0 should be 0.
The yPosition for row 1 should be diameter. The yPosition for row 2 should be 2*diameter...
Continue this pattern for all rows. Use a similar pattern to set the xPosition of each circle in a given column.
If you do this correctly, no circle will overlap another circle.
Once you get this working, then fix your code so that it does not add circles to positions in the array that are
already occupied by a circle. You can tell whether a position is empty by checking if it contains null. */
public void fillArray()
{
int xpos,ypos;
for(int i=0;i<rows;i++)
{
for(int j=0;j<cols;j++)
{
xpos=j*diameter;
ypos=i*diameter;
c1[i][j]=new Circle(diameter,xpos,ypos,"Blue");
}
  
}
}
/** * Add a random number of circles (between 1 and rows * cols). * Only need one loop here; */

/* Write a method called "addSomeCircles" that tries to add a random number of red circles to the array in a random fashion.
The number of circles it tries to add should be between 1 and rows*cols, inclusive.
For each circle choose a random row number and a random column number.
The x and y positions of the circle should follow the plan used in the "fillArray" method.
If the array has no circle at that position, add one, otherwise move on. Your method should return the number of collisions
you had while adding circles. Remember, an empty element in the array will be equal (i.e., ==) to null. */
public int addSomeCircles()
{
int noColl=0;
Random rand=new Random();
for(int i=0;i<rows*cols;i++)
{
int row=rand.nextInt(rows);
int col=rand.nextInt(cols);
if(c1[row][col]!=null)
c1[row][col]=new Circle(diameter,col*diameter,row*diameter,"Red");
else
noColl++;
}
return noColl;
}
/** * Add a single circle at (row,col). * Make sure you account for arrays having positions from 0 to n and test for entering an invalid position */
/* Write a method called "addSingleCircle" that takes an integer parameter for the row and an integer parameter for the column.
If the coordinatesspecify a valid position in the array, and the array has no circle at that position, then add a green one,
otherwise do nothing.
The x and y position of the circle should follow the plan used in the "fillArray" method. */
public void addSingleCircle(int row,int col)
{
if(row<rows && col<cols && c1[row][col]!=null)
{
c1[row][col]=new Circle(diameter,col*diameter,row*diameter,"Green");
}
}
/** * Makes all circles in the array visible. */
/* Write a method called "makeAllCirclesVisible" that makes all circles in the array visible. */
public void makeAllCirclesVisible()
{
for(int i=0;i<rows;i++)
{
for(int j=0;j<cols;j++)
{
c1[i][j].makeVisible();
}
}
}
/** * Makes all circles in the array invisible. */
/* Write a method called "makeAllCirclesInvisible" that makes all circles in the array invisible. */
public void makeAllCirclesInvisible()
{
for(int i=0;i<rows;i++)
{
for(int j=0;j<cols;j++)
{
c1[i][j].makeInvisible();
}
}
}
/** * Remove all circles from the array. */
/* Write a method called "emptyArray" that removes all circles from the array (i.e. make them all null.)
(Don't forget to make them all invisible first.) */
public void emptyArray()
{
makeAllCirclesInvisible();
for(int i=0;i<rows;i++)
{
for(int j=0;j<cols;j++)
{
c1[i][j]=null;
}
}
}

}