NRP : 05111740000115
Kelas: PBO-B
PR kali ini adalah menggambar pemandangan menggunakan BlueJ dengan melibatkan bangun 2 dimensi didalamnya seperti persegi, lingkaran, dan segitiga.
awalnya saya membuat kelas-kelas sebagai berikut
berikut adalah ulasan setiap class :
1.ini adalah class canvas
Canvas sebagai kertas atau media untuk menggambar
import javax.swing.*;
import java.awt.*;
import java.util.List;
import java.util.*;
/**
* Membuat canvas
*
* @author (Chaniyah Zulfa Mukhlishah)
*
* @version (3.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("brown"))
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);
}
}
}
import java.awt.*;
import java.awt.geom.*;
/**
* A circle that can be manipulated and that draws itself on a canvas.
*
* @author (Chaniyah Zulfa Mukhlishah)
* @version (3.1/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 = 0;
yPosition = 0;
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);
}
}
}
import java.awt.*;
/**
* A triangle that can be manipulated and that draws itself on a canvas.
*
* @author (Chaniyah Zulfa)
* @version (3.1/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 = 0;
yPosition = 0;
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);
}
}
}
import java.awt.*;
/**
* A square that can be manipulated and that draws itself on a canvas.
*
* @author (Chaniyah Zulfa Mukhlishah)
* @version (3.1/20180916)
*/
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 = 0;
yPosition = 0;
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);
}
}
}
import java.awt.*;
/**
* A rectangle that can be manipulated and that draws itself on a canvas.
*
* @author (Chaniyah Zulfa Mukhlishah)
* @version (3.1/20180916)
*/
public class Rectangles
{
private int aside;
private int bside;
private int centerx;
private int centery;
private boolean isVisible;
private String color;
public Rectangles()
{
aside = 100;
bside = 50;
centerx = 200;
centery = 200;
isVisible = true;
color = "magenta";
draw();
}
public void SetSide(int l, int s)
{
aside = l;
bside = s;
}
public void SetCenter(int x, int y)
{
centerx = x;
centery = y;
}
public double Circumference()
{
return 2*aside + 2*bside;
}
public double Area()
{
return aside * bside;
}
public void moveTo(int x, int y)
{
erase();
centerx = x;
centery = y;
draw();
}
public void makeVisible()
{
isVisible = true;
draw();
}
public void makeInvisible()
{
erase();
isVisible = false;
}
public void moveRight()
{
moveHorizontal(20);
}
public void moveLeft()
{
moveHorizontal(-20);
}
public void moveUp()
{
moveVertical(-20);
}
public void moveDown()
{
moveVertical(20);
}
public void moveHorizontal(int distance)
{
erase();
centerx += distance;
draw();
}
public void moveVertical(int distance)
{
erase();
centery += distance;
draw();
}
public void slowMoveHorizontal(int distance)
{
int delta;
if(distance < 0)
{
delta = -1;
distance = -distance;
}
else
{
delta = 1;
}
for(int i = 0; i < distance; i++)
{
centerx += delta;
draw();
}
}
public void slowMoveVertical(int distance)
{
int delta;
if(distance < 0)
{
delta = -1;
distance = -distance;
}
else
{
delta = 1;
}
for(int i = 0; i < distance; i++)
{
centery += delta;
draw();
}
}
public void changeSize(int newASide, int newBSide)
{
erase();
aside = newASide;
bside = newBSide;
draw();
}
public void changeColor(String newColor)
{
color = newColor;
draw();
}
private void draw()
{
if(isVisible)
{
Canvas canvasobj = Canvas.getCanvas();
canvasobj.draw(this, color, new Rectangle(centerx, centery, aside, bside));
canvasobj.wait(10);
}
}
private void erase()
{
if(isVisible)
{
Canvas canvasobj = Canvas.getCanvas();
canvasobj.erase(this);
}
}
}
picture untuk menampilkan seluruh gambar yang teah kita buat
/**
* I draw my picture here.
*
* @author (Chaniyah Zulfa Mukhlishah)
* @version (3.1/20180916)
*/
public class picture
{
private Circle sun,rock1,rock2,rock3,c1,c2,c3;
private Triangle mountain1,mountain2,tree1,tree2,tree3,street;
private Square s1,s2,s3;
private Rectangles stem,background,street1,street2,street3;
public picture()
{
}
public void draw()
{
sun = new Circle();
sun.changeSize(100);
sun.moveHorizontal(240);
sun.moveVertical(100);
sun.changeColor("yellow");
sun.makeVisible();
rock1 = new Circle();
rock1.changeSize(300);
rock1.moveHorizontal(380);
rock1.moveVertical(360);
rock1.changeColor("black");
rock1.makeVisible();
rock2 = new Circle();
rock2.changeSize(300);
rock2.moveHorizontal(460);
rock2.moveVertical(260);
rock2.changeColor("black");
rock2.makeVisible();
rock3 = new Circle();
rock3.changeSize(100);
rock3.moveHorizontal(540);
rock3.moveVertical(220);
rock3.changeColor("black");
rock3.makeVisible();
c1 = new Circle();
c1.changeSize(20);
c1.moveHorizontal(7);
c1.moveVertical(28);
c1.changeColor("black");
c1.makeVisible();
c2 = new Circle();
c2.changeSize(20);
c2.moveHorizontal(222);
c2.moveVertical(60);
c2.changeColor("black");
c2.makeVisible();
c3 = new Circle();
c3.changeSize(20);
c3.moveHorizontal(480);
c3.moveVertical(45);
c3.changeColor("black");
c3.makeVisible();
mountain1 = new Triangle();
mountain1.changeSize(200, 400);
mountain1.moveHorizontal(140);
mountain1.moveVertical(30);
mountain1.changeColor("red");
mountain1.makeVisible();
mountain2 = new Triangle();
mountain2.changeSize(200,400);
mountain2.moveHorizontal(420);
mountain2.moveVertical(30);
mountain2.changeColor("red");
mountain2.makeVisible();
tree1 = new Triangle();
tree1.changeSize(100, 100);
tree1.moveHorizontal(60);
tree1.moveVertical(280);
tree1.changeColor("brown");
tree1.makeVisible();
tree2 = new Triangle();
tree2.changeSize(100, 100);
tree2.moveHorizontal(60);
tree2.moveVertical(240);
tree2.changeColor("brown");
tree2.makeVisible();
tree3 = new Triangle();
tree3.changeSize(100, 100);
tree3.moveHorizontal(60);
tree3.moveVertical(200);
tree3.changeColor("brown");
tree3.makeVisible();
street = new Triangle();
street.changeSize(330, 300);
street.moveHorizontal(280);
street.moveVertical(220);
street.changeColor("black");
street.makeVisible();
s1 = new Square();
s1.changeSize(20);
s1.moveHorizontal(20);
s1.moveVertical(20);
s1.changeColor("black");
s1.makeVisible();
s2 = new Square();
s2.changeSize(20);
s2.moveHorizontal(230);
s2.moveVertical(50);
s2.changeColor("black");
s2.makeVisible();
s3 = new Square();
s3.changeSize(20);
s3.moveHorizontal(490);
s3.moveVertical(40);
s3.changeColor("black");
s3.makeVisible();
stem= new Rectangles();
stem.changeSize(40,150);
stem.moveHorizontal(100);
stem.moveVertical(600);
stem.changeColor("brown");
stem.makeVisible();
background = new Rectangles();
background.changeSize(400,300);
background.moveHorizontal(20);
background.moveVertical(20);
background.changeColor("magenta");
background.makeVisible();
street1 = new Rectangles();
street1.changeSize(20,20);
street1.moveHorizontal(300);
street1.moveVertical(250);
street1.changeColor("white");
street1.makeVisible();
street2 = new Rectangles();
street2.changeSize(20,20);
street2.moveHorizontal(300);
street2.moveVertical(260);
street2.changeColor("white");
street2.makeVisible();
street3 = new Rectangles();
street3.changeSize(20,20);
street3.moveHorizontal(300);
street3.moveVertical(270);
street3.changeColor("white");
street3.makeVisible();
}
}
Tidak ada komentar:
Posting Komentar