Programmer-defined classes Part 3. A class for representing Fractions public class Fraction { private int numerator; private int denominator; public Fraction(int.

Slides:



Advertisements
Similar presentations
Introduction to OOP with Java 4th Ed, C. Thomas Wu
Advertisements

©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. Chapter Four Defining Your Own Classes.
Programmer-defined classes Part 2. Topics Returning objects from methods The this keyword Overloading methods Class methods Packaging classes Javadoc.
Abstract Data Type Fraction Example
Composition CMSC 202. Code Reuse Effective software development relies on reusing existing code. Code reuse must be more than just copying code and changing.
AU/MITM/1.6 By Mohammed A. Saleh 1. Arguments passed by reference  Until now, in all the functions we have seen, the arguments passed to the functions.
Operator Overloading Programming in C++ Fall 2008 Dr. David A. Gaitros
©The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 4 th Ed Chapter Chapter 4 Defining Your Own Classes.
©The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 4 th Ed Chapter Chapter 7 More on Defining Classes Overloading.
1 CS2200 Software Development Lecture 27: More Testing A. O’Riordan, 2008 K. Brown,
1 Chapter 4 Language Fundamentals. 2 Identifiers Program parts such as packages, classes, and class members have names, which are formally known as identifiers.
June 1, 2000 Object Oriented Programming in Java (95-707) Java Language Basics 1 Lecture 3 Object Oriented Programming in Java Language Basics Classes,
©The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 4 th Ed Chapter Chapter 7 More on Defining Classes Overloading.
©The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 4 th Ed Chapter Chapter 7 Defining Your Own Classes Part 2.
1 Classes, Encapsulation, Methods and Constructors Class definitions Scope of Data –Instance data –Local data The this Reference Encapsulation and Java.
Classes with multiple methods Part 1. Review of classes & objects Early on, we learned that objects are the basic working units in object-oriented programs.
Chapter 7- 1 Chapter 7 Defining Your Own Classes Part 2.
Fundamental Programming Structures in Java: Comments, Data Types, Variables, Assignments, Operators.
Applying OO Concepts Using Java. In this class, we will cover: Overriding a method Overloading a method Constructors Mutator and accessor methods The.
©The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 4 th Ed Chapter Chapter 7 Defining Your Own Classes Part 2.
Chapter 6—Objects and Classes The Art and Science of An Introduction to Computer Science ERIC S. ROBERTS Java Objects and Classes C H A P T E R 6 To beautify.
COSC 1P03 Data Structures and Abstraction 4.1 Abstract Data Types The advantage of a bad memory is that one enjoys several times the same good things for.
© The McGraw-Hill Companies, 2006 Chapter 4 Implementing methods.
4.1 Instance Variables, Constructors, and Methods.
Programming in Java Unit 2. Class and variable declaration A class is best thought of as a template from which objects are created. You can create many.
CSE 1302 Lecture 7 Object Oriented Programming Review Richard Gesick.
Introduction to Programming David Goldschmidt, Ph.D. Computer Science The College of Saint Rose Java Fundamentals (Comments, Variables, etc.)
Hello.java Program Output 1 public class Hello { 2 public static void main( String [] args ) 3 { 4 System.out.println( “Hello!" ); 5 } // end method main.
Class Example - Rationals Rational numbers are represented by the ratio of two integers, a numerator and a denominator, e.g., 2/3. This is opposed to irrational.
Object Based Programming Chapter 8. 2 In This Chapter We will learn about classes Garbage Collection Data Abstraction and encapsulation.
An Object-Oriented Approach to Programming Logic and Design Fourth Edition Chapter 6 Using Methods.
Methods in Java. Program Modules in Java  Java programs are written by combining new methods and classes with predefined methods in the Java Application.
Dr. Salah Hammami KSU-CCIS-CS Ahmad Al-Rjoub CSC 113 King Saud University College of Computer and Information Sciences Department of Computer Science Ahmad.
ADTs and C++ Classes Classes and Members Constructors The header file and the implementation file Classes and Parameters Operator Overloading.
CMP-MX21: Lecture 4 Selections Steve Hordley. Overview 1. The if-else selection in JAVA 2. More useful JAVA operators 4. Other selection constructs in.
Topic 1 Object Oriented Programming. 1-2 Objectives To review the concepts and terminology of object-oriented programming To discuss some features of.
COMPUTER PROGRAMMING. Functions’ review What is a function? A function is a group of statements that is executed when it is called from some point of.
Chapter 6 Introduction to Defining Classes. Objectives: Design and implement a simple class from user requirements. Organize a program in terms of a view.
Session 7 Methods Strings Constructors this Inheritance.
CS0007: Introduction to Computer Programming Classes: Documentation, Method Overloading, Scope, Packages, and “Finding the Classes”
COP INTERMEDIATE JAVA Designing Classes. Class Template or blueprint for creating objects. Their definition includes the list of properties (fields)
©The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 4 th Ed Chapter Chapter 7 Defining Your Own Classes Part 2 (adapted.
Java Class Structure. Class Structure package declaration import statements class declaration class (static) variable declarations* instance variable.
Operator Overloading Week 5.
By Mr. Muhammad Pervez Akhtar
Chapter 5 Classes and Methods II Lecture Slides to Accompany An Introduction to Computer Science Using Java (2nd Edition) by S.N. Kamin, D. Mickunas, E.
Chapter 11: Advanced Inheritance Concepts. Objectives Create and use abstract classes Use dynamic method binding Create arrays of subclass objects Use.
Classes, Interfaces and Packages
DCS 2133 Object Oriented Programming Defining Your Own Classes Part 2.
©The McGraw-Hill Companies, Inc. Permission required for reproduction or display. Chapter Chapter 7 Defining Your Own Classes Part 2.
In this class, we will cover: Overriding a method Overloading a method Constructors Mutator and accessor methods The import statement and using prewritten.
Chapter 4: More Object Concepts. Objectives Understand blocks and scope Overload a method Avoid ambiguity Create and call constructors with parameters.
5.1 Basics of defining and using classes A review of class and object definitions A class is a template or blueprint for an object A class defines.
Chapter 3: Classes and Objects Java Programming FROM THE BEGINNING Copyright © 2000 W. W. Norton & Company. All rights reserved. 1 Chapter 3 Classes and.
Functions Skill Area 314 Part B. Lecture Overview Functions Function Prototypes Function Definitions Local Variables Global Variables Default Parameters.
Chapter 7- Defining Your Own Classes Part 2 : Objectives After you have read and studied this chapter, you should be able to –Describe how objects are.
Lecture 3: More Java Basics Michael Hsu CSULA. Recall From Lecture Two  Write a basic program in Java  The process of writing, compiling, and running.
More About Objects and Methods
User-Written Functions
More Sophisticated Behavior
Java Primer 1: Types, Classes and Operators
Chapter 4: Writing Classes
User-Defined Functions
Statements, Comments & Simple Arithmetic
Defining Your Own Classes
Fraction Abstract Data Type
More About Objects and Methods
Applying OO Concepts Using Java
Classes, Objects and Methods
Presentation transcript:

Programmer-defined classes Part 3

A class for representing Fractions public class Fraction { private int numerator; private int denominator; public Fraction(int num, int denom) { setNumerator(num); setDenominator(denom); } public int getDenominator( ) { return denominator; } public int getNumerator( ) { return numerator; }

public void setDenominator(int denom) { if (denom == 0) { //Fatal error System.err.println("Fatal Error"); System.exit(1); } denominator = denom; } public void setNumerator(int num) { numerator = num; } public String toString( ) { return getNumerator() + "/" + getDenominator(); } } // … continued from previous slide

Additional methods for Fraction The basic set of methods defined thus far give us ways to construct, set values, and print out (via the toString method) Fraction objects A richer set of methods would give us functionality comparable to the other numeric types (int, double, etc.) The next slide illustrates a method for simplifying a Fraction; rather than having it alter the calling object, we’ll make it return a new Fraction object The methods that add, subtract, multiply and divide Fractions should return Fraction results – so they will also be object-returning methods

The simplify() method (with helper method gcd()) public Fraction simplify( ) { int num = getNumerator(); int denom = getDenominator(); int gcd = gcd(num, denom); Fraction simp = new Fraction (num/gcd, denom/gcd); return simp; } private static int gcd (int m, int n) { int r; while (true) { r = n%m; if (r == 0) break; n=m; m=r; } return m; }

Arithmetic algorithms for Fractions The next several slides illustrate arithmetic methods for our Fraction class, based on the following formulae: –Addition: a/b + c/d = (ad + cb)/bd –Subtraction: a/b – c/d = (ad – cb)/bd –Multiplication: a/b * c/d = ac/bd –Division: a/b / c/d = ad/bc We will define four Fraction-returning methods: plus, minus, times, and dividedBy

Calling the arithmetic methods Client code that uses Fraction objects might include instructions like these: Fraction f1, f2, f3; … f3 = f1.plus(f2); f2 = f3.times(f1); f1 = f2.minus(f3); f3 = f1.dividedBy(f2);

Java’s keyword this Each of our arithmetic methods corresponds to a binary arithmetic operation Binary operations take two operands; they will be represented in our methods by the calling object and the argument We will need to access the numerator and denominator of both objects to perform the arithmetic operations We can use the keyword this to access data components of the calling object

The plus method public Fraction plus (Fraction f) { int n1, n2, d1, d2; // numerators & denominators of the 2 Fractions Fraction sum; // result to be returned n1 = this.numerator;// numerator of calling object n2 = f.numerator;// numerator of argument d1 = this.denominator;// from calling object d2 = f.denominator;// from argument sum = new Fraction(n1*d2 + n2*d1, d1*d2); return sum; }

Optional use of this In the previous example, the use of keyword this was actually optional The next couple of slides illustrate the implementation of arithmetic Fraction methods without using this

The minus method public Fraction minus (Fraction f) { int n1, n2, d1, d2; // numerators & denominators of the 2 Fractions Fraction difference; // result to be returned n1 = numerator; // numerator of calling object n2 = f.numerator;// numerator of argument d1 = denominator;// from calling object d2 = f.denominator;// from argument difference = new Fraction(n1*d2 - n2*d1, d1*d2); return difference; }

The times method public Fraction times (Fraction f) { int n1, n2, d1, d2; // numerators & denominators of the 2 Fractions Fraction product; // result to be returned n1 = getNumerator(); // numerator of calling object n2 = f.getNumerator(); // numerator of argument d1 = getDenominator(); // from calling object d2 = f.getDenominator(); // from argument product = new Fraction(n1*n2, d1*d2); return product; }

To this or not to this? As the last two slides illustrate, the use of keyword this to represent the calling object is optional In fact, it’s only optional from our point of view; if we don’t insert it (as was the case in the plus method), the compiler will insert it for us; so in fact, all three methods use this, whether implicitly or explicitly

Another use of this: avoiding scope clashes You may recall that a local variable with the same name as a variable with wider scope will hide the more “famous” variable within its local block You can use the keyword this to avoid such a scope clash For example, we could have written the set methods like this: void setNumerator (int numerator) { this.numerator = numerator; }

Method overloading The term overloading refers to the use of a program symbol (usually an identifier) to mean more than one thing Although Java doesn’t support programmer- defined operator overloading (as C++ does), we can still use the operator + to illustrate the point: –it means addition –it also means concatenation –context determines which meaning applies

Method overloading Methods can be overloaded, as follows: –they can have the same name –their parameter lists must differ in some significant way: type(s) of argument(s) number of arguments –they can represent completely different algorithms

Example: plus method We have already defined method plus, which produces the sum of the calling object and another Fraction (the argument to the method) To make our Fraction class more versatile, we can overload this method so that it can be used to add a calling Fraction object and an int argument, as illustrated on the next slide

Overloaded plus method public Fraction plus (int num) { Fraction sum = new Fraction (num, 1); sum = sum.plus(this); return sum; } In this instance, the overloaded method incorporates a call to the original method. The compiler distinguishes between the two methods by examining each method’s parameter list. Since the message embedded in the overloaded method is using a Fraction argument (this), the compiler looks for a method named plus with a Fraction parameter, which is easily distinguished from the int parameter in the new method.

Using the plus method Client programmers can now call plus using either a Fraction or int argument, as in the examples below: Fraction f1 = new Fraction (2,3), f2 = new Fraction (3,4); f1 = f1.plus(5); f2 = f1.plus(f2.plus(6)); We can overload the other arithmetic methods in a similar fashion

Overloading constructors Although all the classes we have looked at so far have included a single constructor, it is quite common to have multiple constructors for an object Since a constructor always has the same name as its class, then multiple constructors must by definition be overloaded methods

Additional constructors for Fraction class // default constructor (requires no arguments) public Fraction () { numerator = 1; denominator = 1; } // copy constructor – creates a duplicate object of its argument public Fraction (Fraction f) { numerator = f.numerator; denominator = f.denominator; } // constructor with int argument – creates num/1 public Fraction (int num) { numerator = num; denominator = 1; }

Examples of calls to Fraction constructors Fraction f1 = new Fraction (2, 3); // calls original constructor because there are // two int arguments Fraction f2 = new Fraction(); // calls default constructor; creates object with // numerator & denominator both equal to 1 Fraction f3 = new Fraction(5); // calls constructor with single int parameter; // creates object with data value 5/1 Fraction f4 = new Fraction(f1); // calls copy constructor; creates object identical to f1

Alternate definitions for constructors Another use for keyword this is in the definition of multiple constructors. Consider the definition of the original constructor: public Fraction (int n, int d) { setNumerator (n); setDenominator (d); } Since this constructor already exists, we can use it to define additional constructors. For example: public Fraction () { this (1, 1); } This is a different way to define the default constructor

Class methods As we have previously seen, methods declared with the static keyword are class methods rather than instance methods –class methods are not part of any object –class methods exist independent of any object –all objects of a class share a single copy of any class method The private helper method gcd is an example of a static method

Method gcd private static int gcd (int m, int n) { int r; while (true) { r = n%m; if (r == 0) break; n=m; m=r; } return m; } The method is declared private because it only exists as a helper method for the simplify method; it isn’t supposed to be available to client programmers. It is declared static because it is unnecessary to include a new copy of this method for every Fraction object.

A method for comparing two Fractions Strategy: pass two Fraction objects to the method, which returns an int value, as follows: o0 if the Fractions are equal o1 if the first argument is greater than the second o-1 if the first argument is less than the second Since neither object is the calling object, it makes sense to make this a static method, since then no calling object is necessary Another private helper method, toDouble, is used to accomplish the task

The compareTo method public static int compareTo (Fraction f1, Fraction f2) { double x = f1.toDouble(); double y = f2.toDouble(); int result; if (x > y) result = 1; else if (x < y) result = -1; else result = 0; return result; } private double toDouble() { double result; result = (double)numerator / denominator; return result; }

Notes on class methods Class methods can only access class variables and constants, and cannot call instance methods of the same class (except by declaring objects and having them call the methods) Instance methods can call all other methods of the same class (without declaring new objects)

Organizing Classes into a Package For a class A to use class B, their bytecode files must be located in the same directory. This is not practical if we want to reuse programmer-defined classes in many different programs

Organizing Classes into a Package The correct way to reuse programmer- defined classes from many different programs is to place reusable classes in a package. A package is a Java class library.

Creating a Package 1. Include the statement package myutil; as the first statement of the source file for the Fraction class. 2. The class declaration must include the visibility modifier public as public class Fraction {... } The following steps illustrate the process of creating a package named myutil that includes the Fraction class.

Creating a Package 3. Create a folder named myutil, the same name as the package name. In Java, the package must have a one-to-one correspondence with the folder. 4. Place the modified Fraction class into the myutil folder and compile it. 5. Modify the CLASSPATH environment variable to include the folder that contains the myutil folder.

Using Javadoc Comments Many of the programmer-defined classes we design are intended to be used by other programmers. It is, therefore, very important to provide meaningful documentation to the client programmers so they can understand how to use our classes correctly.

Using Javadoc Comments By adding javadoc comments to the classes we design, we can provide a consistent style of documenting the classes. Once the javadoc comments are added to a class, we can generate HTML files for documentation by using the javadoc command.

javadoc for Fraction This is a portion of the HTML documentation for the Fraction class shown in a browser. This HTML file is produced by processing the javadoc comments in the source file of the Fraction class.

javadoc Tags The javadoc comments begins with /** and ends with */ Special information such as the authors, parameters, return values, and others are indicated by etc

Example: javadoc Source... /** * Returns the sum of this Fraction * and the parameter frac. The sum * returned is NOT simplified. * frac the Fraction to add to this * Fraction * the sum of this and frac */ public Fraction add(Fraction frac) {... }... this javadoc will produce

Example: javadoc Output