CSC153 2004S, Class 31: Classes, Objects, and Such
Admin:
* Where are the noisy side?
* Should we let Luis Zuleta Benavides stay?
* Only if he's involved.
Overview:
* Classes and objects.
* Fields, methods, and constructors.
* Designing a Rational class.
* Defining classes.
* Defining fields, methods, and constructors.
Reminder:
* Classes provide "templates" for objects
* A book class tells us what characteristics books have
* Four parts to the template:
* The fields, which describe the characteristics/attributes
* May differ between different objects in the same class
* The constructors, which describe how to build a new one
* The methods, which describe how objects operate
* Code is shared between objects
* The destructors (Hmmm ... Sam can't count): Can do some cleanup,
if necessary
* Because Java does memory management for you, you rarely need to write destructors
* Memory management is similar (in the abstract) to Scheme: Anything reachable is not garbage; anything else is garbage. Because the langauge controls the pointers, it can rearrange things to "compact" memory.
When designing a class, you should think about:
* What capabilities we need
* What input we might use to create a new object
* What fields we need
Rational numbers: Ratio of two integers, the second of which is positive.
What should you be able to do with rational numbers?
* Extract the numerator;
int getNumerator()
* Extract the denominator;
int getDenominator()
* Approximate inexactly
double toDouble()
* Provide a way to write them as a string
String toString()
* Mathematics with them (add, subtract, multiply, divide)
Rational add(Rational r1, Rational r2) [Separate from the object]
Rational add(Rational r1); [Must be part of the object] <-- Most Java programmers
void incrementSelf(Rational r1); [Must be part of the object]
* Change them? NO
void setNumerator(int newNumerator)
void setDenominator(int newDenominator)
* Advantages (compared with creating new ones):
* Faster
* "Funner"
* Prettier
* Disadvantages (compared with creating new ones):
* Values shouldn't change mid-stream
* Depends on your expected application: If you are going to use the rational numbers in writing formulae, you probably shouldn't change them. If you are
* Encapsulation suggests that you shouldn't think globally about every change you make
* Sam gets really upset when things that don't change naturally change
From what should you be able to create rational numbers?
* ...
What information might you use to create a new rational number?
* Numerator and denominator
* Numerator only (expected denominator of 1)
* Real/double, figure out numerator and denominator
* As string (parse it)
* Design problem:
Rational rat = new Rational(10,2);
System.out.println(rat.getNumerator()); -> 10 5 10
* Do we simplify automatically?
* Easier
* "Correct"
* More efficient for addition, subtraction, etc.
* Do we have a separate simplify method? YES
* Abuse the class
* Doing operations that depend on identical denominator
* Makes the mutators more confusing
* When we add, subtract, multiply, divide two rational numbers, is the result automatically simplified?
* Yes