handout #8
CSE142—Computer Programming I
Programming Assignment #3
due: Tuesday,
This assignment will give you practice with for
loops, value parameters, Java objects and graphics. You will be using a special class called DrawingPanel written by Stuart and his coauthor Marty Stepp and a class called Graphics that is part of the Java
class libraries. You will also refer to
various color constants from a class called Color that is also part of the
standard Java class libraries.
The assignment is divided into two parts. The first is meant to be a warm-up to get you
used to basic drawing operations. The
second part will allow you to practice drawing a complex figure with a
parameterized method. You will want to
look at handout #7 for an example of how to use these various classes to draw.
For this assignment you are limited to the
language features in chapters 1 through 3.
Remember that you are not to use more advanced features to solve the
problem. You can’t, for example, make
use of if/else statements to solve this task.
You will, however, use the DrawingPanel and
Graphics classes described at the end of chapter 3 as well as the color
constants from the Color class, as described in chapter 3.
Part 1: Drawing1.java (4 points)
This
part of the assignment is meant to give you some practice with the DrawingPanel and Graphics classes. You can either produce a specific output or
you can design your own output. If you
want to design your own, it must meet the following criteria:
·
The
DrawingPanel's size must be at least 100 x 100
pixels.
·
You
must draw at least one line, one rectangle, and one oval that are visible on
the screen.
·
You
must use at least three different visible colors in your figure.
This flexibility will allow you to be creative
and to draw any figure you like. After
the assignment is turned in, we may anonymously show off some of the figures
drawn by students for everyone to see.
If you don’t want to design your own output,
then you should meet the following criteria.
You are to construct a DrawingPanel with a
width of 400 and a height of 200. It
should have a green background and should have two solid black lines (one
horizontal and one vertical) that divide it into 4 equally sized quadrants.
In the upper-left and lower-right quadrants you
are to draw a red oval that has horizontal and vertical lines that divide it
into four equally sized parts. You
should draw the largest oval that doesn’t go outside the quadrant. The inside of the oval should be red
throughout and the lines should be black.
You do not have to draw an outline around the oval.
Below is a picture of what your drawing
panel should look like.
You are to to produce
either the figure above or one of your own design. Your class should be called
Drawing1.java. You can break this
program up into methods if you want to, but it’s okay in this case to simply
have all of the drawing commands appear in the main method.
Part 2:
Drawing2.java (16 points)
This
second part of the assignment will involve more complex computations with a figure
that has several levels of structure.
You are to produce the following image.
This image has several levels of structure. You will find that there is a basic subfigure
that occurs throughout, which is a square with concentric circles in it. The upper-left corner has exactly one such
subfigure that is 100 pixels wide and has 10 concentric circles. The concentric circles are enclosed in a
square and drawn in black against a green background. The panel also has three square grids that
are composed of multiple copies of this basic subfigure. The overall panel has a cyan background and
is 550 pixels wide and 450 pixels high.
The four figures on your drawing panel should have the following properties.
|
Description |
(x, y) position |
number of rows and columns |
size of each subfigure, in pixels |
number of concentric circles in each subfigure |
|
top-left figure |
(0, 0) |
single subfigure |
100 x 100 |
10 |
|
bottom-left figure |
(12, 155) |
8 x 8 |
30 x 30 |
5 |
|
top-right figure |
(305, 10) |
4 x 4 |
48 x 48 |
6 |
|
bottom-right figure |
(300, 225) |
3 x 3 |
70 x 70 |
7 |
You are required to have two particular static
methods that are described below. You will
not be using class constants for this assignment. Instead you will be exploring the use of
value parameters. This program does not
require a lot of lines of code, but the computations are not simple. You might very well find yourself overwhelmed
with the amount of detail you have to handle all at once. The techniques of decomposition and iterative
enhancement described in chapter 1 will help you in this situation.
Start with one piece of this problem. In particular, you should write a static
method that draws one square with concentric circles inside of it. That subfigure is repeated throughout this image,
so it makes sense to have a separate method for producing it. Start with the subfigure in the upper-left
part of the screen. It’s not in a grid
pattern, it’s just the subfigure itself (one set of concentric circles in a
square).
Your first version of this method could draw the
specific subfigure in the upper-left corner (always drawing it in that
position, always making it 100 pixels wide, always having 10 concentric
circles), but you’ll want to generalize this with the use of value
parameters. You should be able to call
it with different sizes, different locations and different numbers of
concentric circles.
The drawing commands we are using are defined in
terms of integers, which leaves open the possibility that things won’t divide
up evenly. You don’t have to worry about
this possibility. In particular, you may
assume that the subfigure size will always be a multiple of twice the number of
concentric circles you are supposed to draw (e.g., 10 circles in a figure 100
wide, 5 circles in a figure 30 wide, 6 circles in a figure 48 wide, 7 circles
in a figure 70 wide).
Once you have completed the static method that produces
one of these subfigures, write another static method that produces a square
grid of these subfigures. You will call
this method three different times to produce the three grids of the overall
image. Obviously it will have a lot of
parameters to be flexible enough to draw each of these three grids. The key point is that a single method can be used
that produces all three grids. For an
example of this, study the same program in handout #7. You will see that the second version
(Draw2.java) has .three different draw methods.
This is highly redundant. Look at
how the third version manages to use a single method with parameters to replace
these three methods. You are required to
have a similar method for drawing grids that is called three different times
rather than having three different grid-drawing methods.
In
grading, we will require these two static methods: one for a subfigure with
just one square and its concentric circles and one for producing a grid of such
figures that is called three different times to produce the three grids. We will expect you to use good style
(indentation, commenting, good variable names, etc.). Be sure to include a brief comment with each
method (e.g., explaining what the parameters represent). Your program should be stored in a file
called Drawing2.java
Remember that to run your files Drawing1.java
and Drawing2.java, you will have to download the file DrawingPanel.java
from the class web page (the class that Stuart and Marty wrote) and store it in
the same folder where you will be storing your classes. The DrawingPanel
file will be available under the “assignments” link from the class web
page. The standard Java classes
(Graphics and Color) are part of the java.awt
package, so you need to include the following line of code at the beginning of
your class file to access them:
import java.awt.*;
Turn in your two program files using electronic turnin. You do not
have to turn in DrawingPanel.java.