Download Object-Oriented Programming: Classes, Inheritance, and Interfaces and more Assignments Data Structures and Algorithms in PDF only on Docsity!
06- 1
Object-Oriented Programming:
Classes, Inheritance, and Interfaces
Reading: Downey: Chapter 13; Carrano: p. 126- Problem Set: Assignment #2 due Friday, Feburary 23 Wellesley College CS Lecture 06 Thursday, February 15 Handout # 06- 2
Object-Oriented Programming (OOP)
- In OOP, computations are described in terms of collections
of stateful objects that communicate by passing messages
to one other.
- Objects are like actors in a play; the programmer is the
playwright & director.
- A class specifies the behavior (variables and methods) of a
collection of objects = the instances of the class.
- Related classes can be organized into inheritance
hierarchies, which allow one class to extend and/or override
the variables and methods of other classes.
- OOP is one of several programming paradigms. Others
include imperative programming, function-oriented
programming, logic programming. CS251 Programming
Languages covers these.
- IMHO, OOP is overhyped – function-oriented programming
with state (as embodied in Scheme & OCAML) does
everything OOP can do plus much, much more! Take CS
to See The Light.
06- 3 The Anatomy of a Java Class
A Java class can contain 5 kinds of declarations:
- 2 kinds of variable declarations:
- an instance variable for every instance of the class
- a class (static) variable in exactly one place (the class
itself)
- 3 kinds of method declarations.
- A constructor method specifies how to create a new
instance. Via this , it can refer to all (including private)
instance variables of the new instance that are declared
in the method’s class.
- An instance method specifies how an instance (the
receiver = this ) responds to a message. It can also refer
to all of the receiver’s instance variables that are
declared in the method’s class. Note that the receiver is
really just an argument with a special name ( this ).
- A class method is a receiverless message that
corresponds to functions/procedures in other languages.
It cannot refer to this , since there is no receiver.
06- 4 Class Example: A Counter Class import java.util.*; // imports Vector public class Counter { // Instance variables: protected int count; private int id; // Class variable: private static Vector all = new Vector(); // Constructor method: public Counter () { all.add(this); this.id = all.size() // Here and below, can punt “this.” this.count = 0; displayCounters(); } // Instance methods: public void inc () { this.count++; displayCounters();} public String toString () { return "[" + this.id + “ of “ + all.size()
- ":" + this.count + "]"; } // Class methods: public static void displayCounters() { for (int i = 0; i < all.size(); i++) { System.out.print(all.get(i) + “; “); } System.out.println(); } public static void main (String [] args) { Counter a = new Counter(); a.inc(); Counter b = new Counter(); a.inc(); b.inc(); a.inc(); } }
06- 7 Inheritance: A Resettable Counter
Object
Counter
Resettable
Counter
public Object(); public boolean equals (Object x); // this = x public String toString(); // string rep. of pointer public Counter (); public void inc (); // increments count public String toString(); // Overrides Object’s definition public ResettableCounter(); public void reset (); // resets count to 0 superclasses subclasses 06- 8 Inheritance: Resettable Counter Code public class ResettableCounter extends Counter { public void reset() { count = 0; // Won’t work if count is declared private in Counter! displayCounters(); } public static void main (String [] args) { ResettableCounter a = new ResettableCounter(); // [1 of 1:0]; a.inc(); // [1 of 1:1]; Counter b = new Counter(); // [1 of 2:1]; [2 of 2:0]; a.inc(); // [1 of 2:2]; [2 of 2:0]; b.inc(); // [1 of 2:2]; [2 of 2:1]; a.reset(); // [1 of 2:0]; [2 of 2:1]; a.inc(); // [1 of 2:1]; [2 of 2:1]; } } // The following is implicitly declared: public ResettableCounter() { super(); }
06- 9 Inheritance: An Inittable Counter
Object
Counter
Resettable
Counter
public Object(); public boolean equals (Object x); // this = x public String toString(); // string rep. of pointer public Counter (); public void inc (); // increments count public String toString(); // overrides Object’s definition public ResettableCounter(); public void reset (); // resets count to 0 superclasses subclasses
Inittable
Counter
public InittableCounter(); public InittableCounter(int init); // initializes count to init 06- 10 Inheritance: Inittable Counter Code public class InittableCounter extends ResettableCounter { public InittableCounter (int init) { super(); // Call nullary Counter constructor; count = init; displayCounters(); } public InittableCounter () { this(0); } public static void main (String [] args) { InittableCounter a = new InittableCounter(17); // [1 of 1:0]; // [1 of 1:17]; a.inc(); // [1 of 1:18]; InittableCounter b = new InittableCounter(); // [1 of 2:18]; [2 of 2:0]; // [1 of 2:18]; [2 of 2:0]; a.inc(); // [1 of 2:19]; [2 of 2:0]; b.inc(); // [1 of 2:19]; [2 of 2:1]; a.reset(); // [1 of 2:0]; [2 of 2:1]; a.inc(); // [1 of 2:1]; [2 of 2:1]; } }
06- 13 Inheritance: An Equatable Counter
Object
Counter
Resettable
Counter
public Object(); public boolean equals (Object x); // this = x public String toString(); // string rep. of pointer public Counter (); public void inc (); // increments count public String toString(); // overrides Object’s definition public ResettableCounter(); public void reset (); // resets count to 0 superclasses subclasses
Inittable
Counter
public InittableCounter(); public InittableCounter(int init); // initializes count to init
Equatable
Counter
public EquatableCounter(); public boolean equals (Object x); // this.count = x.count 06- 14 Inheritance: EquatableCounter Code
public class EquatableCounter extends InittableCounter {
public boolean equals (Object x) {
if (! (x instanceof Counter)) {
return false;
} else {
Counter c = (Counter) x; // Downcast will succeed
return this.count == c.count;
e.equals(c) → true // asymmetric! e.equals(c2) → true e.equals(c3) → true e.equals(r) → true c.inc(); e.inc(); e.equals(c) → true e.equals(c2) → false e.equals(c3) → true e.equals(r) → false Counter c = new Counter(); Counter c2 = new Counter(); Counter c3 = c; Counter r = new ResettableCounter(); Counter e = new EquatableCounter(); c.equals(c2) → false c.equals(c3) → true c.equals(r) → false c.equals(e) → false
06- 15 Two Implementations of Immutable Points public class IPointVars { private int x, y; // Represent coords with two int variables. public IPointVars (int x, int y) {this.x = x; this.y = y;} public int getX() { return x; } public int getY() { return y; } public String toString() { return "(" + getX() + "," + getY() + ")"; } } public class IPointArray { private int[] ints = new int[2]; // Represent coords with two-slot array. public IPointArray (int x, int y) {ints[0] = x; ints[1] = y;} public int getX() { return ints[0]; } public int getY() { return ints[1]; } public String toString() { return "(" + getX() + "," + getY() + ")"; } } 06- 16 Manipulating Immutable Points public static int sumCoordsVars (IPointVars p) { return p.getX() + p.getY(); } public static int sumCoordsArray (IPointArray p) { return p.getX() + p.getY(); } The sumCoord methods are the same modulo the point type. Can we define a single sumCoords() method that works on instances of both classes? Yes! By using (1) an interface or (2) an abstract class.
