Transcript Quiz About [Your topic]

Classes
CS 101-E
Chapter 4
Aaron Bloomfield
1
Announcements
 HWs are being renumbered
 J1, J2, etc., for Java programming assignments
 C1, C2, etc., for CodeLab assignments
 HW1 = J1, HW2 = C1, HW3 = C2, etc.
 HWs J2 and J3 assigned this Wednesday (6 Oct)
 J2 due next Thursday (14 Oct)
 J3 due following Thursday (21 Oct)
 HW J4 will be assigned 18 Oct, and due 29 Oct
 Some CodeLab HWs in there as well
 Second midterm on 27 Oct
 No labs this Sunday
 Can go to another lab with permission
 Lab quiz grades will be entered by the end of this week
2
Preparation
 Scene so far has been background material and experience
 Computing systems and problem solving
 Variables
 Types
 Input and output
 Expressions
 Assignments
 Objects
 Standard classes and methods
 Now: Experience what Java is really about
 Design and implement objects representing information
and physical world objects
3
Object-oriented programming
 Basis
 Create and manipulate objects with attributes
behaviors that the programmer can specify
and
 Mechanism
 Classes
 Benefits
 An information type is design and implemented once
 Reused as needed
 No need reanalysis and re-justification of the
representation
4
First class – ColoredRectangle
 Purpose
 Represent a colored rectangle in a window
 Introduce the basics of object design and implementation
5
Background
 JFrame
 Principal Java class for representing a titled, bordered
graphical window.
 Standard class
 Part of the swing library
import javax.swing.* ;
6
Some Java Swing components
7
Example
 Consider
JFrame w1 = new JFrame("Bigger");
JFrame w2 = new JFrame("Smaller");
w1.setSize(200, 125);
w2.setSize(150, 100);
w1.setVisible(true);
w2.setVisible(true);
200 pixels
125
pixels
150 pixels
100
pixels
8
// Purpose: Displays two different windows.
import javax.swing.*;
public class TwoWindows {
// main(): application entry point
public static void main (String[] args) {
JFrame w1 = new JFrame("Bigger");
JFrame w2 = new JFrame("Smaller");
w1.setSize(200, 125);
w2.setSize(150, 100);
w1.setVisible(true);
w2.setVisible(true);
}
}
Class ColoredRectangle – initial version
 Purpose
 Support the display of square window containing a blue
filled-in rectangle
 Window has side length of 200 pixels
 Rectangle is 40 pixels wide and 20 pixels high
 Upper left hand corner of rectangle is at (80, 90)
 Limitations are temporary
 Remember BMI.java preceded BMICalculator.java
 Lots of concepts to introduce
10
ColoredRectangle in action
 Consider
ColoredRectangle r1 = new ColoredRectangle();
ColoredRectangle r2 = new ColoredRectangle();
System.out.println("Enter when ready");
Scanner stdin = new Scanner (System.in);
stdin.nextLine();
r1.paint();
// draw the window associated with r1
r2.paint();
// draw the window associated with r2
ColoredRect angle object referenced by r1is being sent a message
r1.paint()
The messages inst ruct t he object s t o display t hemselves
r2.paint()
ColoredRect angle object referenced by r2 is being sent a message
11
// Purpose: Create two windows containing colored rectangles.
import java.util.*;
public class BoxFun {
//main(): application entry point
public static void main (String[] args) {
ColoredRectangle r1 = new ColoredRectangle();
ColoredRectangle r2 = new ColoredRectangle();
System.out.println("Enter when ready");
Scanner stdin = new Scanner (System.in);
stdin.nextLine();
r1.paint();
r2.paint();
}
}
// draw the window associated with r1
// draw the window associated with r2
ColoredRectangle.java outline
import javax.swing.*;
import java.awt.*;
public class ColoredRectangle {
// instance variables for holding object attributes
private
private
private
private
private
private
int width;
int height;
int x;
int y;
JFrame window;
Color color;
// ColoredRectangle(): default constructor
public ColoredRectangle() {
}
// ...
// paint(): display the rectangle in its window
public void paint() {
}
}
// ...
13
Instance variables and attributes
 Data field
 Java term for an object attribute
 Instance variable
 Symbolic name for a data field
 Usually has private access
 Assists in information hiding by encapsulating the
object’s attributes
 Default initialization
 Numeric instance variables initialized to 0
 Logical instance variables initialized to false
 Object instance variables initialized to null
14
public class ColoredRectangle {
// instance variables for holding object attributes
private int width;
private int height;
private JFrame window;
private int x;
private int y;
private Color color;
// ColoredRectangle(): default constructor
public ColoredRectangle() {
window = new JFrame("Box Fun");
window.setSize(200, 200);
width = 40;
x = 80;
height = 20;
y = 90;
color = Color.BLUE;
window.setVisible(true);
}
// paint(): display the rectangle in its window
public void paint() {
Graphics g = window.getGraphics();
g.setColor(color);
g.fillRect(x, y, width, height);
}
}
ColoredRectangle default constructor
public class ColoredRectangle {
// instance variables to describe object attributes
...
// ColoredRectangle(): default constructor
public ColoredRectangle() {
...
}
...
}
The name of a const ruct or always mat ches t he
name of it s class
A const ruct or does not list it s ret urn t ype. A const ruct or
always ret urns a reference t o a new object of it s class
16
public class ColoredRectangle {
// instance variables for holding object attributes
private int width;
private int height;
private JFrame window;
private int x;
private int y;
private Color color;
// ColoredRectangle(): default constructor
public ColoredRectangle() {
window = new JFrame("Box Fun");
window.setSize(200, 200);
width = 40;
x = 80;
height = 20;
y = 90;
color = Color.BLUE;
window.setVisible(true);
}
// paint(): display the rectangle in its window
public void paint() {
Graphics g = window.getGraphics();
g.setColor(color);
g.fillRect(x, y, width, height);
}
}
Color constants













Color.BLACK
Color.BLUE
Color.CYAN
Color.DARK_GRAY
Color.GRAY
Color.GREEN
Color.LIGHT_GRAY
Color.MAGENTA
Color.ORANGE
Color.PINK
Color.RED
Color.WHITE
Color.YELLOW
18
ColoredRectangle r = new ColoredRectangle();
r
ColorRectangle
The value of a
ColoredRectangle
variable is a
reference to a
ColoredRectangle
object
- width = 40
- height = 20
- x = 80
- y = 90
- window =
- color =
+ paint() :
String
- text
- ...
void
= "Box Fun"
+ length()
+ ...
Color
- color =
- ...
+ brighter() : Color
+ ...
: int
JFrame
- width = 200
- height = 200
- title =
- ...
+ setVisible(
+ ...
boolean
status)
: void
Another possible Constructor
public class ColoredRectangle {
// instance variables for holding object attributes
private int width = 40;
private int height = 80;
private JFrame window;
private int x = 80;
private int y = 90;
private Color color = Color.BLUE;
// ColoredRectangle(): default constructor
public ColoredRectangle() {
window = new JFrame("Box Fun");
window.setSize(200, 200);
window.setVisible(true);
}
20
public class ColoredRectangle {
// instance variables for holding object attributes
private int width;
private int height;
private JFrame window;
private int x;
private int y;
private Color color;
// ColoredRectangle(): default constructor
public ColoredRectangle() {
window = new JFrame("Box Fun");
window.setSize(200, 200);
width = 40;
x = 80;
height = 20;
y = 90;
color = Color.BLUE;
window.setVisible(true);
}
// paint(): display the rectangle in its window
public void paint() {
Graphics g = window.getGraphics();
g.setColor(color);
g.fillRect(x, y, width, height);
}
}
Graphical context
 Graphics
 Defined in java.awt.Graphics
 Represents the information for a rendering request
 Color
 Component
 Font
 …
 Provides methods
 Text drawing
 Line drawing
 Shape drawing
 Rectangles
 Ovals
 Polygons
22
Java coordinate system
X-Axis
Coordinat e (0.0)
Y-Axis
Coordinat e (80, 90)
Coordinat e (120, 110)
23
Method invocation
 Consider
r1.paint();
// display window associated with r1
r2.paint();
// display window associated with r2
 Observe
 When an instance method is being executed, the
attributes of the object associated with the invocation are
accessed and manipulated
 Important that you understand what object is being
manipulated
24
Method invocation
public class
ColoredRectangle
{
// instance variables to describe object attributes
...
// paint(): display the rectangle in its window
public void paint() {
window.setVisible( true );
Graphics g = window.getGraphics();
g.setColor(color);
g.fillRect(x, y, width, height);
}
...
}
The values of these instance
variables are also from the
ColoredRectangle object
Instance variable window references
the JFrame attribute of the object
that caused the invocation.
Typo in book: p.
149 claims paint()
is static; it’s not
25
The Ig Nobel Prizes
 Medicine
 Physics
 Public Health




Chemistry
Engineering
Literature
Psychology
 Economics
 Peace
 Biology
"The Effect of Country Music on Suicide.“
For explaining the dynamics of hula-hooping
Investigating the scientific validity of the
Five-Second Rule
The Coca-Cola Company of Great Britain
For the patent of the combover
The American Nudist Research Library
It’s easy to overlook things – even a man in
a gorilla suit.
The Vatican, for outsourcing prayers to India
The invention of karaoke, thereby providing
an entirely new way for people to learn to
tolerate each other
For showing that herrings apparently
26
communicate by farting
Wednesday, 6 October, 2004
Computing grades so far
HW J2 assigned today, due next Wednesday
Lab this week! Must be done by Sunday at 8:30
Sunday labs are cancelled due to fall break
 If you want, send me an e-mail and you can show up to
another lab session
 No office hours Friday
 Grades so far: use formula




grade 
hw1* 3  hw2 * 2.82  hw3 * 0.42  labquiz1 * 3.33  midterm1*10
19.57
 HISTORICALLY, the grade range has been:
 A: 90+, B: 80-89, C: 60-79, D/F: <60
27
Improving ColoredRectangle
 Analysis
 A ColoredRectangle object should
 Be able to have any color
 Be positionable anywhere within its window
 Have no restrictions on its width and height
 Accessible attributes
 Updateable attributes
28
Improving ColoredRectangle
 Additional constructions and behaviors
 Specific construction
 Construct a rectangle representation using supplied
values for its attributes
 Accessors
 Supply the values of the attributes
 Individual methods for providing the width, height, xcoordinate position, y-coordinate position, color, or
window of the associated rectangle
 Mutators
 Manage requests for changing attributes
 Ensure objects always have sensible values
 Individual methods for setting the width, height, xcoordinate position, y-coordinate position, color, or
29
window of the associated rectangle to a given value
A mutator method
 Definition
// setWidth(): width mutator
public void setWidth(int w) {
width = w;
}
 Usage
ColoredRectangle s = new ColoredRectangle();
s.setWidth(80);
Initial value of the formal parameter
comes from the actual parameter
Object to be manipulated
is the one referenced by s
public void setWidth ( int
...
}
w) {
Changes to the formal parameter
30
do not affect the actual parameter
Mutator setWidth() evaluation
ColoredRectangle s = new ColoredRectangle();
s .setWidth(80);
The invocation sends a message to the ColoredRectangle
referenced by s to modify its width attribute. To do so,
there is a temporary transfer of flow of control to
setWidth(). The value of the actual parameter is 80
public class ColoredRectangle {
...
/ / setWidth(): width mutator
public void
setWidth ( int
w) {
width = w;
}
...
}
For this invocation of method
setWidth(), w is initialized to
80. The object being referenced
within the method body is the
object referenced by s
Method setWidth() sets the instance variable width of its
ColoredRectangle. For this invocation, width is set to 80
and the ColoredRectangle is the one referenced by s
Method setWidth() is completed. Control is transferred back to
31
the statement that invoked setWidth()
A bit of humor…
32
Java parameter passing
 The value is copied to the method
 Any changes to the parameter are forgotten when the
method returns
33
Java parameter passing
 Consider the following code:
static void foobar (int y) {
y = 7;
}
formal parameter
public static void main (String[] args) {
int x = 5;
actual parameter
foobar (x);
System.out.println(x);
}
 What gets printed?
34
Java parameter passing
 Consider the following code:
static void foobar (String y) {
y = “7”;
}
formal parameter
public static void main (String[] args) {
String x = “5”;
actual parameter
foobar (x);
System.out.println(x);
}
 What gets printed?
35
Java parameter passing
 Consider the following code:
static void foobar (ColoredRectangle y) {
y.setWidth (10);
formal parameter
}
public static void main (String[] args) {
ColoredRectangle x = new ColoredRectangle();
foobar (x);
actual parameter
System.out.println(y.getWidth());
}
 What gets printed?
36
Java parameter passing
 Consider the following code:
static void foobar (ColoredRectangle y) {
y = new ColoredRectangle();
y.setWidth (10); formal parameter
}
public static void main (String[] args) {
ColoredRectangle x = new ColoredRectangle();
actual parameter
foobar (x);
System.out.println(y.getWidth());
}
 What gets printed?
37
Java parameter passing
 The value of the actual parameter gets copied to the formal
parameter
 This is called pass-by-value
 C/C++ is also pass-by-value
 Other languages have other parameter passing types
 Any changes to the formal parameter are forgotten when the
method returns
 However, if the parameter is a reference to an object, that
object can be modified
 Similar to how the object a final reference points to can be
modified
38
Subtleties
 Consider
ColoredRectangle r = new ColoredRectangle();
r.paint();
r.setWidth(80);
r.paint();
 What is the width is the rectangle on the screen after the
mutator executes?
39
Other mutators
public void setHeight(int h) {
height = h;
}
public void setX(int ulx) {
x = ulx;
}
public void setY(int uly) {
y = uly;
}
public void setWindow(JFrame f) {
window = f;
}
public void setColor(Color c) {
color = c;
}
40
41
Mutator usage
ColoredRectangle u = new ColoredRectangle();
ColoredRectangle v = new ColoredRectangle();
u.setHeight(100);
u.setColor(Color.PINK);
v.setX(25);
v.setY(50);
JFrame display = new JFrame("Fun");
v.setWindow(display);
Sends a message to v's ColoredRectangle to modify its window
attribute to display's JFrame
Sends a message to
u's ColoredRectangle
to modify its height
attribute to 100
Sends a message to u's ColoredRectangle to modify its color
attribute to pink
Sends a message to v's ColoredRectangle to modify its x-axis
position to 25
Sends a message to v's ColoredRectangle to modify its y-axis
position to 50
42
Accessors
 Properties
 Do not require parameters
 Each accessor execution produces a return value
 Return value is the value of the invocation
The method return type precedes the name of the method in the
method definition
public int getWidth() {
return width;
}
For method getWidth(), the return value is the value of the width
attribute for the ColoredRectangle associated with the invocation.
In invocation t.getWidth(), the return value is the value of the
instance variable width for the ColoredRectangle referenced by t
43
Accessor usage
ColoredRectangle t = new ColoredRectangle();
int w = t .getWidth();
Invocation sends a message to the ColoredRectangle
referenced by t to return the value of its width. To do so,
there is a temporary transfer of flow of control to getWidth()
public class ColoredRectangle {
...
Method getWidth() starts executing.
/ / getWidth(): accessor
For this invocation, the object being
public int getWidth ( ) {
referenced is the object referenced by t
return width ;
}
The return expression evaluates to 40 (the width
attribute of the ColoredRectangle object referenced by t )
...
}
Method completes by supplying its return value (40) to the invoking
statement. Also, invoking statement regains the flow of control.
From
44
there variable w is initialized with the return value of the invocatio
Specific construction
public ColoredRectangle(int w, int h, int ulx, int uly,
JFrame f, Color c) {
setWidth(w);
setHeight(h);
setX(ulx);
setY(uly);
setWindow(f);
setColor(c);
}
 Requires values for each of the attributes
JFrame display = new JFrame("Even more fun");
display.setSize(400, 400);
ColoredRectangle w = new ColoredRectangle(60, 80,
20, 20, display, Color.YELLOW); 45
Specific construction
public ColoredRectangle(int w, int h, int ulx, int uly,
JFrame f, Color c) {
setWidth(w);
setHeight(h);
setX(ulx);
setY(uly);
setWindow(f);
setColor(c);
}
 Advantages to using mutators
 Readability
 Less error prone
 Facilitates enhancements through localization
46
Seeing double
import java.awt.*;
public class SeeingDouble {
public static void main(String[] args) {
ColoredRectangle r = new ColoredRectangle();
System.out.println("Enter when ready");
Scanner stdin = new Scanner (System.in);
stdin.nextLine();
r.paint();
r.setY(50);
r.setColor(Color.RED);
r.paint();
}
}
47
Seeing double
48
An optical illusion
49
Casting
 We’ve seen casting before:
 double d = (double) 3;
 int x = (int) d;
 Aside: duplicating an object
 String s = “foo”;
 String t = s.clone();
 Causes an error: “inconvertible types”
 (Causes another error, but we will ignore that one)
 What caused this?
50
Casting, take 2
 .clone() returns an object of class Object (sic)
 More confusion: You can also have an object of class Class
 Thus, you can have an Object class and a Class object
 Got it?
 We know it’s a String (as it cloned a String)
 Thus, we need to tell Java it’s a String via casting
 Revised code:
 String s = “foo”;
 String t = (String) s.clone();
 Still causes that “other” error, but we are still willfully
51
ignoring it…
Casting, take 3
 That “other” error is because String does not have a .clone()
method
 Not all classes do!
 We just haven’t seen any classes that do have .clone() yet
 Check in the documentation if the object you want to copy
has a .clone() method
 A class that does: java.util.Vector
 Vector s = new Vector();
 Vector t = s.clone();
 Vector u = (Vector) s.clone();
Causes the “inconvertible
types” error
52
Casting, take 4
 What happens with the following code?
 Vector v = new Vector();
 String s = (String) v;
 Java will encounter a compile-time error
 “inconvertible types”
 What happens with the following code?
 Vector v = new Vector();
 String s = (String) v.clone();
 Java will encounter a RUN-time error
 ClassCastException
53