TUGAS RUMAH PEMROGRAMAN BERORIENTASI OBJEK

MEMBUAT PEMANDANGAN DENGAN BLUE J


Karina Soraya P
05111740000003
PBO - B



  • Canvas
 import javax.swing.*;   
  import java.awt.*;   
  import java.util.List;   
  import java.util.*;   
  /**   
  * Membuat canvas  
  *   
  * @author (Karina Soraya P)   
  *   
  * @version (6.1/20180916)   
  */   
  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", 1000, 800, 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 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 if(colorString.equals("light brown"))   
     graphic.setColor(new Color(153,102,0));   
    else if(colorString.equals("brown"))   
     graphic.setColor(new Color(102,51,0));   
    else if(colorString.equals("grey"))   
     graphic.setColor(new Color(190,190,190));   
    else if(colorString.equals("light blue"))   
     graphic.setColor(new Color(0,191,255));   
    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);   
    }   
   }   
  }   
  • Picture
 /**   
  * Membuat Pemandangan secara keseluruhan   
  *   
  *    
  *    
  * @author (Karina Soraya P)  
  * @version (6.2/20180916)   
  */   
  public class Picture   
  {   
   private Box wall;   
   private Box door;   
   private Box window;   
   private Triangle roof;   
   private Circle sun;    
   private Box ground;   
   private Box road;   
   private Circle cloud;   
   private Triangle mountain;  
   /**   
   * Constructor for objects of class Picture   
   */   
   public Picture()   
   {   
    // nothing to do... instance variables are automatically set to null   
   }   
   /**   
   * Draw this picture.   
   */   
   public void draw()   
   {   
    ground = new Box();   
    ground.changeColor("green");   
    ground.moveHorizontal(-200);   
    ground.moveVertical(390);   
    ground.changeWidth(1600);   
    ground.changeHeight(1200);   
    ground.makeVisible();   
    sun = new Circle();   
    sun.changeColor("yellow");   
    sun.moveHorizontal(300);   
    sun.moveVertical(120);   
    sun.changeSize(250);   
    sun.makeVisible();   
    mountain = new Triangle();  
    mountain.changeColor("blue");  
    mountain.moveHorizontal(160);   
    mountain.moveVertical(70);   
    mountain.changeSize(400, 700);    
    mountain.makeVisible();   
    mountain = new Triangle();  
    mountain.changeColor("blue");  
    mountain.moveHorizontal(650);   
    mountain.moveVertical(70);   
    mountain.changeSize(400, 700);    
    mountain.makeVisible();   
    wall = new Box();   
    wall.changeColor("yellow");   
    wall.moveVertical(400);   
    wall.moveHorizontal(500);   
    wall.changeWidth(300);   
    wall.changeHeight(200);   
    wall.makeVisible();   
    window = new Box();   
    window.changeColor("black");   
    window.moveHorizontal(716);   
    window.moveVertical(500);   
    window.changeWidth(45);   
    window.changeHeight(35);   
    window.makeVisible();   
    window = new Box();   
    window.changeColor("black");   
    window.moveHorizontal(610);   
    window.moveVertical(500);   
    window.changeWidth(45);   
    window.changeHeight(35);   
    window.makeVisible();   
    door = new Box();   
    door.changeColor("brown");   
    door.moveHorizontal(526);   
    door.moveVertical(500);   
    door.changeWidth(50);   
    door.changeHeight(100);   
    door.makeVisible();   
    road = new Box();   
    road.changeColor("grey");   
    road.moveHorizontal(380);   
    road.moveVertical(435);   
    road.changeWidth(80);   
    road.changeHeight(300);   
    road.makeVisible();   
    roof = new Triangle();    
    roof.changeColor("brown");   
    roof.changeSize(100, 400);   
    roof.moveHorizontal(660);   
    roof.moveVertical(350);   
    roof.makeVisible();    
    cloud = new Circle();   
    cloud.changeColor("light blue");   
    cloud.moveHorizontal(100);   
    cloud.moveVertical(0);   
    cloud.changeSize(45);   
    cloud.makeVisible();   
    cloud = new Circle();   
    cloud.changeColor("light blue");   
    cloud.moveHorizontal(0);   
    cloud.moveVertical(0);   
    cloud.changeSize(45);   
    cloud.makeVisible();   
    cloud = new Circle();   
    cloud.changeColor("light blue");   
    cloud.moveHorizontal(30);   
    cloud.moveVertical(-20);   
    cloud.changeSize(80);   
    cloud.makeVisible();    
    cloud = new Circle();   
    cloud.changeColor("light blue");   
    cloud.moveHorizontal(720);   
    cloud.moveVertical(0);   
    cloud.changeSize(45);   
    cloud.makeVisible();   
    cloud = new Circle();   
    cloud.changeColor("light blue");   
    cloud.moveHorizontal(815);   
    cloud.moveVertical(0);   
    cloud.changeSize(45);   
    cloud.makeVisible();   
    cloud = new Circle();   
    cloud.changeColor("light blue");   
    cloud.moveHorizontal(750);   
    cloud.moveVertical(-20);   
    cloud.changeSize(80);   
    cloud.makeVisible();   
   }   
  }   
  • Circle
 import java.awt.*;   
  import java.awt.geom.*;   
  /**   
  * A circle that can be manipulated and that draws itself on a canvas.   
  *    
  * @author (Karina Soraya P)   
  * @version (6.4/20180916)   
  */   
  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);   
       }   
    }   
  }   
  • Box
 import java.awt.*;   
  /**   
  * A Box that can be manipulated and that draws itself on a canvas.   
  *    
  * @author (Karina Soraya P)   
  * @version (6.3/20180916)   
  */   
  public class Box   
  {   
   private int width;   
   private int height;   
   private int xPosition;   
   private int yPosition;   
   private String color;   
   private boolean isVisible;   
   /**   
   * Create a new Box at default position with default color.   
   */   
   public Box()   
   {   
    width = 30;   
    height = 30;   
    xPosition = 60;   
    yPosition = 50;   
    color = "red";   
    isVisible = false;   
   }   
   /**   
   * Make this Box visible. If it was already visible, do nothing.   
   */   
   public void makeVisible()   
   {   
    isVisible = true;   
    draw();   
   }   
   /**   
   * Make this Box invisible. If it was already invisible, do nothing.   
   */   
   public void makeInvisible()   
   {   
    erase();   
    isVisible = false;   
   }   
   /**   
   * Move the Box a few pixels to the right.   
   */   
   public void moveRight()   
   {   
    moveHorizontal(20);   
   }   
   /**   
   * Move the Box a few pixels to the left.   
   */   
   public void moveLeft()   
   {   
    moveHorizontal(-20);   
   }   
   /**   
   * Move the Box a few pixels up.   
   */   
   public void moveUp()   
   {   
    moveVertical(-20);   
   }   
   /**   
   * Move the Box a few pixels down.   
   */   
   public void moveDown()   
   {   
    moveVertical(20);   
   }   
   /**   
   * Move the Box horizontally by 'distance' pixels.   
   */   
   public void moveHorizontal(int distance)   
   {   
    erase();   
    xPosition += distance;   
    draw();   
   }   
   /**   
   * Move the Box vertically by 'distance' pixels.   
   */   
   public void moveVertical(int distance)   
   {   
    erase();   
    yPosition += distance;   
    draw();   
   }   
   /**   
   * Slowly move the Box 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 Box 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 width to the new width (in pixels). Width must be >= 0.   
   */   
   public void changeWidth(int newWidth)   
   {   
    erase();   
    width = newWidth;   
    draw();   
   }   
   /**   
   * Change the height to the new height (in pixels). Height must be >= 0.   
   */   
   public void changeHeight(int newHeight)   
   {   
    erase();   
    height = newHeight;   
    draw();   
   }   
   /**   
   * Change the color. Valid colors are "red", "yellow", "blue", "green",   
   * "magenta" and "black".   
   */   
   public void changeColor(String newColor)   
   {   
    color = newColor;   
    draw();   
   }   
   /*   
   * Draw the Box with current specifications on screen.   
   */   
   private void draw()   
   {   
    if(isVisible) {   
     Canvas canvas = Canvas.getCanvas();   
     canvas.draw(this, color, new Rectangle(xPosition, yPosition, width, height));   
     canvas.wait(10);   
    }   
   }   
   /*   
   * Erase the Box on screen.   
   */   
   private void erase()   
   {   
    if(isVisible) {   
         Canvas canvas = Canvas.getCanvas();   
         canvas.erase(this);   
       }   
    }   
  }   
  • Triangle
 import java.awt.*;   
  /**   
  * A triangle that can be manipulated and that draws itself on a canvas.   
  *    
  * @author (Karina Soraya P)   
  * @version (6.6/20180916)    
  */   
  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);   
    }   
   }   
  }   
  • Hasil

Komentar

Posting Komentar

Postingan Populer