CSC152 2006S, Class 18: Writing Your Own Template Classes (1)
Admin:
* No written hw for tomorrow!
* The reading is actually ready!
* Stupid story
* Today is lecture/discussion
* EC: Hitting Daniel Zamora with a bowling pin (IanBR)
* EC: Attending Con Brio concert
* EC: Giving blood (or attempting to do so)
Overview:
* Imperative vs. functional vs. oop
* Classes
* Fields
* Constructors
* Methods
Claims:
* Java is an object-oriented language
* Object-oriented programming involves designing objects
and having them communicate
* Encapsulation, Polymorphism, and Inheritance
* We have not yet done object-oriented programming!
Whoops! We've been doing *imperative* programming
* Looks like instructions in a cookbook
* Some basic knowledge (mix in a cookbook, add in a computer)
* Sequencing of those operations
* Loops
* Conditionals
* Subroutines
* Java supports imperative programming
* And imperative programming makes sense for lots of things
How do we design and specify objects?
* In Java, almost every object is specified with a template called a class
* A list of the data associated with the object
* A course listing at Grinnell has
int courseNumber
String department
String title
String description
Person professor
double numberOfCredits
Place meetingLocation
Time meetingTimeIncludingDate
boolean writingIntensive?
ListOfCourses prereqs
* A fraction has
long numerator
long denominator
thebar
* Or int or short or BigInteger
* A collection of instructions for building the things
* Fill in the fields
* For a fraction:
To build a fraction from two ints, n, and d intended to represent the numerator and dneominator, set the numerator to n and the denominator to d
To build a fraction from one int, i, that is equivalent to i, set the numerator to i and the denominator to 1.
To build a fraction from a decimal number, r
* Use some approximation method: Guess an approximation and refine
The guessing game begins:
Start with 1/2, that 0.5 TOO LARGE
Increase the denominator
Next we have 1/3, that's 0.33333333bar TOO LARGE
Increase the denominator
Next we have 1/4, that's 0.25 TOO LARGE
* One technique: find something too small and something
too large, and repeatedly take their average and see
whether it is too small or too large
* Stop when you're close enough.
* Methods: How the objects do things
* Observers - Get information from the object
For a course listing, what is the enrollment?
For a fraction, what is the decimal value?
* Mutators - Change the object
For a course listing, enroll a student
For a course listing, change the prof
Perhaps we don't mutate fractions
* Miscellaneous - Don't seem to get or change
How do we do all of this in Java?
public class NameOfClass
{
// +--------+--------------------------------------------------
// | Fields |
// +--------+
// Form: OPTIONAL-PROTECTION TYPE NAME;
// Refer to as "this.nameOfField";
// +--------------+--------------------------------------------
// | Constructors |
// +--------------+
// Form: OPTIONAL-PROTECTION NameOfClass(Parameters)
// OPTIONAL-THROWS
// {
// BODY
// } // NameOfClass(Parameters)
// +---------+-------------------------------------------------
// | Methods |
// +---------+
// FORM: LIke static methods, but without the keyword static.
// PROTECTION RETURN-TYPE NAME(PARAMETERS)
// OPTIONAL-THROWS-CLAUSE
// {
// BODY
// } // NAME(PARAMETERS)
} // class NameOfClass
*
public class Fraction
{
// +--------+--------------------------------------------------
// | Fields |
// +--------+
/**
* The numerator of the fraction (duh!). Can be negative,
* positive, or zero.
*/
long numerator;
/**
* The denominator of the fraction. Must be positive.
*/
long denominator;
// +--------------+--------------------------------------------
// | Constructors |
// +--------------+
public Fraction(long _numerator, long _denominator)
throws Exception
{
if (_denominator == 0) {
throw new Exception("Didn't your first grade teacher tell you that fractions cannot have 0 denominators?");
}
this.numerator = _numerator;
this.denominator = _denominator;
} // Fraction(long, long)
public Fraction(long i)
{
this.numerator = i;
this.denominator = 1;
} // Fraction(long)
public Fraction(double d)
{
this.numerator = 1;
this.denominator = 1;
// STUB!
} // Fraction(double)
// +---------+-------------------------------------------------
// | Methods |
// +---------+
public double toDecimal()
{
return ((double) this.numerator) / ((double) this.denominator);
} // toDecimal()
public Fraction add(Fraction addend)
{
long newNumerator = this.numerator * addend.denominator
+ this.denominator * addend.numerator;
long newDenominator = this.denominator * addend.denominator;
return new Fraction(newNumerator, newDenominator);
} // add(Fraction)
} // class NameOfClass
*
Once you have build your own class, it behaves like the already
described classes (e.g., java.lang.Integer)
Fraction f = new Fraction(1,3);
pen.println("1/3 = " + f.toDecimal());