quiz corrected.

FirstLab-Shapes/Canvas.java

@@ -0,0 +1,221 @@
+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 Kölling (mik)
+ *
+ * @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", 300, 300, 
+                    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 List<Object> objects;
+    private HashMap<Object, ShapeDescription> 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<Object>();
+        shapes = new HashMap<Object, ShapeDescription>();
+    }
+
+    /**
+     * 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);
+        }
+    }
+
+}

FirstLab-Shapes/Circle.java

@@ -0,0 +1,192 @@
+import java.awt.*;
+import java.awt.geom.*;
+
+/**
+ * A circle that can be manipulated and that draws itself on a canvas.
+ * 
+ * @author  Michael Kölling 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 default position with default color.
+     */
+    public Circle()
+    {
+        diameter = 30;
+        xPosition = 20;
+        yPosition = 60;
+        color = "blue";
+        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;
+    }
+
+    /**
+     * Move the circle a few pixels to the right.
+     */
+    public void moveRight()
+    {
+        moveHorizontal(20);
+    }
+
+    /**
+     * Move the circle a few pixels to the left.
+     */
+    public void moveLeft()
+    {
+        moveHorizontal(-20);
+    }
+
+    /**
+     * Move the circle a few pixels up.
+     */
+    public void moveUp()
+    {
+        moveVertical(-20);
+    }
+
+    /**
+     * Move the circle a few pixels down.
+     */
+    public void moveDown()
+    {
+        moveVertical(20);
+    }
+
+    /**
+     * Move the circle horizontally by 'distance' pixels.
+     */
+    public void moveHorizontal(int distance)
+    {
+        erase();
+        xPosition += distance;
+        draw();
+    }
+
+    /**
+     * Move the circle vertically by 'distance' pixels.
+     */
+    public void moveVertical(int distance)
+    {
+        erase();
+        yPosition += distance;
+        draw();
+    }
+
+    /**
+     * Slowly move the circle horizontally by 'distance' pixels.
+     */
+    public void slowMoveHorizontal(int distance)
+    {
+        int delta;
+
+        if(distance < 0) 
+        {
+            delta = -1;
+            distance = -distance;
+        }
+        else 
+        {
+            delta = 1;
+        }
+
+        for(int i = 0; i < distance; i++)
+        {
+            xPosition += delta;
+            draw();
+        }
+    }
+
+    /**
+     * Slowly move the circle vertically by 'distance' pixels.
+     */
+    public void slowMoveVertical(int distance)
+    {
+        int delta;
+
+        if(distance < 0) 
+        {
+            delta = -1;
+            distance = -distance;
+        }
+        else 
+        {
+            delta = 1;
+        }
+
+        for(int i = 0; i < distance; i++)
+        {
+            yPosition += delta;
+            draw();
+        }
+    }
+
+    /**
+     * Change the size to the new size (in pixels). Size must be >= 0.
+     */
+    public void changeSize(int newDiameter)
+    {
+        erase();
+        diameter = newDiameter;
+        draw();
+    }
+
+    /**
+     * Change the color. Valid colors are "red", "yellow", "blue", "green",
+     * "magenta" and "black".
+     */
+    public void changeColor(String newColor)
+    {
+        color = newColor;
+        draw();
+    }
+
+    /*
+     * 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);
+        }
+    }
+}

FirstLab-Shapes/PayDay/README.TXT

@@ -0,0 +1,12 @@
+------------------------------------------------------------------------
+This is the project README file. Here, you should describe your project.
+Tell the reader (someone who does not know anything about this project)
+all he/she needs to know. The comments should usually include at least:
+------------------------------------------------------------------------
+
+PROJECT TITLE:
+PURPOSE OF PROJECT:
+VERSION or DATE:
+HOW TO START THIS PROJECT:
+AUTHORS:
+USER INSTRUCTIONS:

FirstLab-Shapes/PayDay/package.bluej

@@ -0,0 +1,3 @@
+#BlueJ package file
+#Fri Oct 19 10:11:52 EDT 2018
+project.charset=UTF-8

FirstLab-Shapes/README.TXT

@@ -0,0 +1,12 @@
+------------------------------------------------------------------------
+This is the project README file. Here, you should describe your project.
+Tell the reader (someone who does not know anything about this project)
+all he/she needs to know. The comments should usually include at least:
+------------------------------------------------------------------------
+
+PROJECT TITLE:
+PURPOSE OF PROJECT:
+VERSION or DATE:
+HOW TO START THIS PROJECT:
+AUTHORS:
+USER INSTRUCTIONS:

FirstLab-Shapes/Square.java

@@ -0,0 +1,191 @@
+import java.awt.*;
+
+/**
+ * A square that can be manipulated and that draws itself on a canvas.
+ * 
+ * @author  Michael Kölling and David J. Barnes
+ * @version 1.0  (15 July 2000)
+ */
+
+public class Square
+{
+    private int size;
+    private int xPosition;
+    private int yPosition;
+    private String color;
+    private boolean isVisible;
+
+    /**
+     * Create a new square at default position with default color.
+     */
+    public Square()
+    {
+        size = 30;
+        xPosition = 60;
+        yPosition = 50;
+        color = "red";
+        isVisible = false;
+    }
+
+    /**
+     * Make this square visible. If it was already visible, do nothing.
+     */
+    public void makeVisible()
+    {
+        isVisible = true;
+        draw();
+    }
+
+    /**
+     * Make this square invisible. If it was already invisible, do nothing.
+     */
+    public void makeInvisible()
+    {
+        erase();
+        isVisible = false;
+    }
+
+    /**
+     * Move the square a few pixels to the right.
+     */
+    public void moveRight()
+    {
+        moveHorizontal(20);
+    }
+
+    /**
+     * Move the square a few pixels to the left.
+     */
+    public void moveLeft()
+    {
+        moveHorizontal(-20);
+    }
+
+    /**
+     * Move the square a few pixels up.
+     */
+    public void moveUp()
+    {
+        moveVertical(-20);
+    }
+
+    /**
+     * Move the square a few pixels down.
+     */
+    public void moveDown()
+    {
+        moveVertical(20);
+    }
+
+    /**
+     * Move the square horizontally by 'distance' pixels.
+     */
+    public void moveHorizontal(int distance)
+    {
+        erase();
+        xPosition += distance;
+        draw();
+    }
+
+    /**
+     * Move the square vertically by 'distance' pixels.
+     */
+    public void moveVertical(int distance)
+    {
+        erase();
+        yPosition += distance;
+        draw();
+    }
+
+    /**
+     * Slowly move the square horizontally by 'distance' pixels.
+     */
+    public void slowMoveHorizontal(int distance)
+    {
+        int delta;
+
+        if(distance < 0) 
+        {
+            delta = -1;
+            distance = -distance;
+        }
+        else 
+        {
+            delta = 1;
+        }
+
+        for(int i = 0; i < distance; i++)
+        {
+            xPosition += delta;
+            draw();
+        }
+    }
+
+    /**
+     * Slowly move the square vertically by 'distance' pixels.
+     */
+    public void slowMoveVertical(int distance)
+    {
+        int delta;
+
+        if(distance < 0) 
+        {
+            delta = -1;
+            distance = -distance;
+        }
+        else 
+        {
+            delta = 1;
+        }
+
+        for(int i = 0; i < distance; i++)
+        {
+            yPosition += delta;
+            draw();
+        }
+    }
+
+    /**
+     * Change the size to the new size (in pixels). Size must be >= 0.
+     */
+    public void changeSize(int newSize)
+    {
+        erase();
+        size = newSize;
+        draw();
+    }
+
+    /**
+     * Change the color. Valid colors are "red", "yellow", "blue", "green",
+     * "magenta" and "black".
+     */
+    public void changeColor(String newColor)
+    {
+        color = newColor;
+        draw();
+    }
+
+    /*
+     * Draw the square with current specifications on screen.
+     */
+    private void draw()
+    {
+        if(isVisible) {
+            Canvas canvas = Canvas.getCanvas();
+            canvas.draw(this, color,
+                    new Rectangle(xPosition, yPosition, size, size));
+            canvas.wait(10);
+        }
+    }
+
+    /*
+     * Erase the square on screen.
+     */
+    private void erase()
+    {
+        if(isVisible) {
+            Canvas canvas = Canvas.getCanvas();
+            canvas.erase(this);
+        }
+    }
+}

FirstLab-Shapes/Triangle.java

@@ -0,0 +1,195 @@
+import java.awt.*;
+
+/**
+ * A triangle that can be manipulated and that draws itself on a canvas.
+ * 
+ * @author  Michael Kölling and David J. Barnes
+ * @version 1.0  (15 July 2000)
+ */
+
+public class Triangle
+{
+    private int height;
+    private int width;
+    private int xPosition;
+    private int yPosition;
+    private String color;
+    private boolean isVisible;
+
+    /**
+     * Create a new triangle at default position with default color.
+     */
+    public Triangle()
+    {
+        height = 30;
+        width = 40;
+        xPosition = 50;
+        yPosition = 15;
+        color = "green";
+        isVisible = false;
+    }
+
+    /**
+     * Make this triangle visible. If it was already visible, do nothing.
+     */
+    public void makeVisible()
+    {
+        isVisible = true;
+        draw();
+    }
+
+    /**
+     * Make this triangle invisible. If it was already invisible, do nothing.
+     */
+    public void makeInvisible()
+    {
+        erase();
+        isVisible = false;
+    }
+
+    /**
+     * Move the triangle a few pixels to the right.
+     */
+    public void moveRight()
+    {
+        moveHorizontal(20);
+    }
+
+    /**
+     * Move the triangle a few pixels to the left.
+     */
+    public void moveLeft()
+    {
+        moveHorizontal(-20);
+    }
+
+    /**
+     * Move the triangle a few pixels up.
+     */
+    public void moveUp()
+    {
+        moveVertical(-20);
+    }
+
+    /**
+     * Move the triangle a few pixels down.
+     */
+    public void moveDown()
+    {
+        moveVertical(20);
+    }
+
+    /**
+     * Move the triangle horizontally by 'distance' pixels.
+     */
+    public void moveHorizontal(int distance)
+    {
+        erase();
+        xPosition += distance;
+        draw();
+    }
+
+    /**
+     * Move the triangle vertically by 'distance' pixels.
+     */
+    public void moveVertical(int distance)
+    {
+        erase();
+        yPosition += distance;
+        draw();
+    }
+
+    /**
+     * Slowly move the triangle horizontally by 'distance' pixels.
+     */
+    public void slowMoveHorizontal(int distance)
+    {
+        int delta;
+
+        if(distance < 0) 
+        {
+            delta = -1;
+            distance = -distance;
+        }
+        else 
+        {
+            delta = 1;
+        }
+
+        for(int i = 0; i < distance; i++)
+        {
+            xPosition += delta;
+            draw();
+        }
+    }
+
+    /**
+     * Slowly move the triangle vertically by 'distance' pixels.
+     */
+    public void slowMoveVertical(int distance)
+    {
+        int delta;
+
+        if(distance < 0) 
+        {
+            delta = -1;
+            distance = -distance;
+        }
+        else 
+        {
+            delta = 1;
+        }
+
+        for(int i = 0; i < distance; i++)
+        {
+            yPosition += delta;
+            draw();
+        }
+    }
+
+    /**
+     * Change the size to the new size (in pixels). Size must be >= 0.
+     */
+    public void changeSize(int newHeight, int newWidth)
+    {
+        erase();
+        height = newHeight;
+        width = newWidth;
+        draw();
+    }
+
+    /**
+     * Change the color. Valid colors are "red", "yellow", "blue", "green",
+     * "magenta" and "black".
+     */
+    public void changeColor(String newColor)
+    {
+        color = newColor;
+        draw();
+    }
+
+    /*
+     * Draw the triangle with current specifications on screen.
+     */
+    private void draw()
+    {
+        if(isVisible) {
+            Canvas canvas = Canvas.getCanvas();
+            int[] xpoints = { xPosition, xPosition + (width/2), xPosition - (width/2) };
+            int[] ypoints = { yPosition, yPosition + height, yPosition + height };
+            canvas.draw(this, color, new Polygon(xpoints, ypoints, 3));
+            canvas.wait(10);
+        }
+    }
+
+    /*
+     * Erase the triangle on screen.
+     */
+    private void erase()
+    {
+        if(isVisible) {
+            Canvas canvas = Canvas.getCanvas();
+            canvas.erase(this);
+        }
+    }
+}

FirstLab-Shapes/package.bluej

@@ -0,0 +1,68 @@
+#BlueJ package file
+dependency1.from=Circle
+dependency1.to=Canvas
+dependency1.type=UsesDependency
+dependency2.from=Square
+dependency2.to=Canvas
+dependency2.type=UsesDependency
+dependency3.from=Triangle
+dependency3.to=Canvas
+dependency3.type=UsesDependency
+editor.fx.0.height=0
+editor.fx.0.width=0
+editor.fx.0.x=0
+editor.fx.0.y=0
+objectbench.height=88
+objectbench.width=776
+package.divider.horizontal=0.6
+package.divider.vertical=0.8496835443037974
+package.editor.height=530
+package.editor.width=674
+package.editor.x=216
+package.editor.y=460
+package.frame.height=690
+package.frame.width=800
+package.numDependencies=3
+package.numTargets=5
+package.showExtends=true
+package.showUses=true
+project.charset=UTF-8
+readme.height=58
+readme.name=@README
+readme.width=47
+readme.x=10
+readme.y=10
+target1.height=50
+target1.name=Circle
+target1.showInterface=false
+target1.type=ClassTarget
+target1.width=80
+target1.x=390
+target1.y=0
+target2.height=62
+target2.name=PayDay
+target2.type=PackageTarget
+target2.width=80
+target2.x=10
+target2.y=130
+target3.height=50
+target3.name=Canvas
+target3.showInterface=false
+target3.type=ClassTarget
+target3.width=80
+target3.x=70
+target3.y=10
+target4.height=50
+target4.name=Triangle
+target4.showInterface=false
+target4.type=ClassTarget
+target4.width=80
+target4.x=160
+target4.y=70
+target5.height=50
+target5.name=Square
+target5.showInterface=false
+target5.type=ClassTarget
+target5.width=80
+target5.x=70
+target5.y=70

LoopFun.java

@@ -8,7 +8,13 @@ public class LoopFun
        * @return the factorial of the number
        */
       public int factorial(int number){
-          return -1;
+         int factorial = 1; 
+         
+        for ( int i = 1; i <= number; i++) {
+            
+             factorial = i * factorial;
+            
+            } return factorial;
       }
 
       /**
@@ -18,8 +24,19 @@ public class LoopFun
        * @param phrase
        * @return Upper case string of the first letter of each word
        */
+      //get first letter of each word in string
+      //turn letter into upper case
+      //returen acronym
       public String acronym(String phrase) {
-          return null;
+          StringBuilder acronym = new StringBuilder();
+          acronym.append(phrase.charAt(0));
+          
+          for (int i = 0; i < phrase.length(); i++) {
+              if(Character.isWhitespace(phrase.charAt(i))) {
+                  acronym.append(phrase.charAt(i + 1));
+                }
+            }
+          return acronym.toString().toUpperCase();
       }
 
       /**
@@ -35,6 +52,23 @@ public class LoopFun
        * @return the encrypted string by shifting each character by three character
        */
       public String encrypt(String word) {
-          return null;
+          String alpha = "abcdefghijklmnopqrstuvwxyz";
+          
+          StringBuilder encryptedWord = new StringBuilder();
+          
+          for (int  i= 0; i < word.length(); i++) {
+              char letter = word.charAt(i);
+              int index = 0;
+              
+              if (alpha.indexOf(letter + 3) == -1) {
+                  index = ((alpha.indexOf(letter) -26) + 3);
+                  
+                }else {
+                    index = alpha.indexOf(letter + 3);
+                }
+              encryptedWord.append(alpha.charAt(index));
+            }
+          
+          return encryptedWord.toString();
       }
 }

MathUtilities.java

@@ -12,7 +12,8 @@ public class MathUtilities{
    * @param num2 second number
    * @return the sum of the two numbers
    */
-  
+  //add number one and two together
+  // return the sum
   
   public int add(int num1, int num2){
       
@@ -40,7 +41,7 @@ public class MathUtilities{
    */
   public double half(int number) {
       //if either number is a double the int will be converted into a double
-     d = (number/2); 
+ double d = (number/2.00); 
       
       return d;
   }
@@ -56,8 +57,8 @@ public class MathUtilities{
       
           
           
-      if ( number % 2 == 0); return false;
-      
+      if (number % 2 == 0){ return false;
+        }
      else return true;
     
   }

StringUtilities.java

@@ -4,28 +4,37 @@ public class StringUtilities {
    public Character getMiddleCharacter(String word){
        //get the middle of the string
        
-        if (str.length() <= 2) {
-            
-         return str;
-      }
-      int beginIndex = (str.length() - 1) / 2;
-      
-      int endIndex = beginIndex + 2 - (str.length() % 2);
-      
-      return str.substring(beginIndex, endIndex);
-   }
+     
+        
+           return word.charAt(word.length()/2); 
+        
        
- 
+      
       
  }
    
-   public String removeCharacter(String value, char charToRemove){
+    
+ 
+    public String removeCharacter(String value, char charToRemove){
        
+    String r = "";
+    
+    for (int i = 0; i < value.length(); i++) {
+        
+      if (value.charAt(i) != charToRemove)
+        r += value.charAt(i);
+    }
+    return r;
        
-     return null;  
+       
+ 
    }
    
-   public String getLastWord(String value) {
-       return null;
+
+    public String getLastWord(String value) {
+       String lastWord = value.substring(value.lastIndexOf(" ") + 1);
+       return lastWord; 
    }
+   
 }
+

package.bluej

@@ -1,25 +1,25 @@
 #BlueJ package file
-dependency1.from=StringUtilitiesTest
-dependency1.to=StringUtilities
+dependency1.from=LoopFunTest
+dependency1.to=LoopFun
 dependency1.type=UsesDependency
-dependency2.from=LoopFunTest
-dependency2.to=LoopFun
+dependency2.from=MathUtilitiesTest
+dependency2.to=MathUtilities
 dependency2.type=UsesDependency
-dependency3.from=MathUtilitiesTest
-dependency3.to=MathUtilities
+dependency3.from=StringUtilitiesTest
+dependency3.to=StringUtilities
 dependency3.type=UsesDependency
-editor.fx.0.height=722
-editor.fx.0.width=876
-editor.fx.0.x=-293
-editor.fx.0.y=-996
+editor.fx.0.height=418
+editor.fx.0.width=800
+editor.fx.0.x=480
+editor.fx.0.y=365
 objectbench.height=163
 objectbench.width=669
 package.divider.horizontal=0.6
 package.divider.vertical=0.7635605006954103
 package.editor.height=542
 package.editor.width=567
-package.editor.x=593
-package.editor.y=-1057
+package.editor.x=587
+package.editor.y=23
 package.frame.height=777
 package.frame.width=693
 package.numDependencies=3