6 - Defining Classes - ECE Student Information

Defining Classes
As well as using predefined library classes in
Java programs, it is usual to define new classes
as well. The library classes model commonly
occurring situations, the new classes are used
for situations unique to a given program.
The basic syntax for defining a class in Java is:
class
[]
[]
[]
where isthenameoftheclass,a
legal Java identifier; is
one or more class and/or instance variable declarations;
is one or more
Constructors, and is one or more
class and/or instance method declarations.

Simple Classes:
The simplest sort of Java class contains only
instance variables. This sort of class is analogous
to the struct in C:
Complex.java
class Complex {
public
double r, // real part
public
i; // imaginary part
}
This defines a new type called “Complex”with
two publicly accessible data members, “r”and
“i”.
Note that the class definition occurs in a file
called “Complex.java”. This is mandatory for
public classes: each such class must be defined
in a file which has the same name as the class
(and filename extension “.java”.) Only one
public class definition is allowed per file.

Once the class is defined, it may be used in
other Java source files exactly like any other
class:
Declare and create a Complex value.
//
//
Complex a = new Complex();
Declare, create and initialise an array of 3
//
Complex values.
//
//
b = { new Complex(),
Complex[]
Complex(), new Complex() };
new
The instance variables of each Complex value
//
are accessible using the dot operator. Note that all
//
these fields have been initialised to 0.0 (doubles).
//
//
== " + a.r
System.out.println("a.r
+ " a.i == " + a.i);
(int j = 0; j < b.length; j++) {
for
= 1.0 + j;
b[j].r
b[j].i = -1.0 - j;
}
= b[0].r*b[1].r - b[0].i*b[1].i;
a.r
= b[0].r*b[1].i + b[0].i*b[1].r;
a.i

Methods:
The essential way in which Java improves on C
is by allowing Methods as well as data in
classes (C only allows data in structs.)
It would be convenient to allow the user to add
two Complex values without having to write
out the addition in component form. To do this
we write an “add” method and include it in the
class definition.
Complex.java
class Complex {
public
double r, i;
public
Complex add(Complex v) {
public
result = new Complex();
Complex
= r + v.r;
result.r
= i + v.i;
result.i
return result;
}
}

The Signature of the method
(name + number & types of arguments.)
The method is available
to all parts of a Java
program.
Createanew
object
to hold the sum.
x
e
l
p
m
o
C
{
v
)
x
l
e
m
p
C
o
d
(
a
d
x
l
e
m
p
C
o
i
c
b
l
p
u
)
;
x
(
l
e
m
p
C
o
w
n
e
=
l
t
s
u
r
e
x
l
e
m
p
C
o
”
“r
This is the
instance var
of the object
which owns
this method
(the “current
object.”)
r
;
v
.
+
r
=
.
r
l
t
s
u
r
e
i
;
v
.
+
i
=
.
i
l
t
s
u
r
e
;
l
t
s
u
r
e
r
n
t
u
r
e
}
The method returns a reference
to a object.
x
l
e
m
p
C
o

The method is now available for use with
Complexobjects.ItmaybeusedinotherJava
source files exactly like any other instance
method:
Declare Complex variables a & b.
//
//
a = new Complex(),
Complex
= new Complex();
b
= 2.0; a.i = 2.0; // a=2+j2
a.r
= 4.0; b.i = -3.0; // b=4− j3
b.r
Complex c = a.add(b); // c=a+b=6− j1
As many methods as desired may be added to
the class definition. This, for example, is multiplication:
Complex mul(Complex v) {
public
result = new Complex();
Complex
= r * v.r - i * v.i;
result.r
= i * v.r + r * v.i;
result.i
return result;
}

Signatures & Name Overloading:
A method in Java is identified by its Signature,
which is more than just its name. A Signature
comprises both the method name and the
number and types of arguments that the method
accepts.
The name of a method does not have to be
unique, several methods can share the same
name, as long as their signatures are distinct.
This is known as Name Overloading.
So Complex may have several different add
methods. E.g., we may wish to have an add
method which accepts a double as its argument
instead of a Complex object. The signature
of this method is:
“add(double)”.
Notice that neither the return type of this
method nor the names of its formal parameter(s)
are part of its signature.

Complex add(Complex v) {
public
result = new Complex();
Complex
= r + v.r;
result.r
= i + v.i;
result.i
return result;
}
Complex add(double real) {
public
result = new Complex();
Complex
= r + real;
result.r
= i;
result.i
return result;
}
Sometimes we refer to the signature of a
method as its entire “first line”.
public Complex add(double real)
This is useful when we want to specify what a
method should “look like” to the outside world,
but the names of the arguments (formal parameters)
are not really relevant, and the return
type of the method isn’t, strictly speaking, part
of the signature.

If a class contains overloaded methods the Java
compiler decides which one to call by looking
at the types and number of parameters in a
message.
a = new Complex(),
Complex
= new Complex();
b
= 2.0; a.i = 2.0; // a=2+j2
a.r
= 4.0; b.i = -3.0; // b=4− j3
b.r
In this example call add(Complex) because the
//
add message has a single Complex parameter.
//
Complex c = a.add(b); // c=a+b=6− j1
Whereas in this one call add(double) because
//
this add message has a single double parameter.
//
Complex d = b.add(2.0); // d=6− j3
In this case we also call add(double) because
//
this add message has a single float parameter,
//
which may be promoted (via an implicit cast) to
//
type double but not to type Complex.
//
a = a.add(10.0F); // a=12+j2

Note that the complier attempts to get the
“closest match” it can between signatures and
message parameters. Hence, if we have a
method with signature “add(float)”, as well
as one with signature “add(double)”, Java
will use the former as the method called by a
message like “a.add(10.0F)”, rather than the
latter.
The “this” reference:
Used within an instance method, the keyword
“this” is a reference to the Current Object (the
object the method belongs to). It is used in
three ways in instance methods:
1. In return statements where it is desired to
return a reference to the current object.
2. To disambiguate references to the current
object’s instance variables where these
have been “hidden” by a method’s local
variables or formal parameters.
3. From a Constructor, this is used to call a
constructor with a different argument list.

Returning a reference to the current
object:
The “add” methods described so far create new
Complex objects to hold the results of the addition.
We may wish to write a version add of
which modifies the current object instead
(“addOn”). It would be natural in these circumstancestowanttoreturnareferencetothecurrent
object. This is the purpose of “return the
this” idiom.
Complex addOn(Complex b) {
public
+= b.r; // Modify the
r
i += b.i;
// Current Object.
return this;
}
Two ways to achieve the same result. Add b to a,
//
modifying a in the process, and put a reference to
//
the result of the addition in c as well.
//
c = a.addOn(b); // Version 1,
c = a = a.add(b); // Version 2, less efficient.

Disambiguating references to the current
object’s instance variables:
What happens if a local variable or a formal
parameter in a method shares a name with an
instance variable of the class
class Complex {
public
double r, i;
public
Complex add(double r) {
public
result = new Complex();
Complex
= r + r;
result.r
= i;
result.i
return result;
}
}
All uses of “r” within the method refer to the
most recently declared “r”, i.e., the formal
parameter. The instance variable “r”isHidden
or Aliased by the formal parameter. The same
thing happens if “r” is a local variable.

How to get around this problem and access the
instance variable Use the “this” reference
with the dot operator:
class Complex {
public
double r, i;
public
Complex add(double r) {
public
result = new Complex();
Complex
= this.r + r;
result.r
= i;
result.i
}
.
return result;
The use of “this” & the dot operator is
always legal when accessing instance variables
(e.g., “result.i = i” is actually shorthand for
“result.i = this.i”), but is only necessary
when an ambiguity would otherwise occur.

Constructors:
An Object Constructor is a special method
which Java will call automatically when a new
instance of the class containing that constructor
is created.
Constructors are used to help to build new
objects. Java will first allocate memory for the
object’s variables and will then call the appropriate
constructor to initialise these variables to
desired values.
A constructor looks like a method, but has a
special name. The name of a constructor is
always the same as the name of its class.
A class can have as many constructors as its
designer thinks fit. All the constructors of a
class must have unique signatures. As all the
constructors in a class share the same name,
this means that they must have distinct argument
lists.

class Complex {
public
double r, i;
public
Constructor without arguments (default
//
constructor). Set both the real and imaginary
//
components of the Complex value to 0.0.
//
Complex() {
public
= i = 0.0;
r
}
Constructor taking 2 arguments, the real and
//
imaginary components of a Complex number.
//
Complex(double r, double i) {
public
= r; this.i = i;
this.r
}
Constructor taking a single argument, the real
//
part of a Complex number. The imaginary
//
component is set to zero.
//
Complex(double real) {
public
= real; i = 0.0;
r
}
.

Note that the constructors have no return type,
not even void. It is not possible to call a constructor
explicitly, so there is no point in specifying
what type a call should return.
The sort of constructor that the system will
invoke is determined by the argument list
passed to the new statement when an object is
created:
Complex a, b, c;
Empty argument list to “new Complex” statement,
//
system will use default constructor, a=0+j0.
//
a = new Complex();
Two arguments to “new Complex” statement,
//
system will use 2-argument constructor, b=2+j2.
//
b = new Complex(2.0, 2.0);
Single argument to “new Complex” statement,
//
system will use 1-arg constructor, c= −4+j0.
//
c = new Complex(-4.0);

All but the most trivial classes should include a
constructor.
If a class does not have any constructors, the
system will automatically create a default constructor
for the class. This constructor will
invoke the default constructor of the object’s
superclass.
“This” used in Constructors:
It may sometimes be useful to have one constructor
call another. For example, we might
observe that using the default constructor to
create a Complex object is the same as using
the 2-argument constructor with argument list
(0, 0). Similarly, using the 1-argument constructor
with value x is the same as using the 2-
argument constructor with argument list (x, 0).
Hence, both the default and the 1-argument
constructor might achieve their ends by calling
the 2-argument constructor. But directly calling
a constructor is, in general, not possible.

Fortunately, the designers of Java have anticipated
this problem, and provide a special syntax
to allow one constructor to call another,
using the “this” reference:
class Complex {
public
double r, i;
public
Constructor taking 2 arguments, the real and
//
imaginary components of a Complex number.
//
Complex(double r, double i) {
public
= r; this.i = i;
this.r
}
// Default constructor.
Complex() { this(0.0, 0.0); }
public
Single argument constructor.
//
Complex(double r) {
public
0.0);
this(r,
}
Useful when a lot of very similar processing is
needed by a number of related constructors.

Formal & Actual Parameter Lists:
The list of arguments in a method declaration is
called the Formal Parameter List of the
method. The list of arguments in a message to
an object is called the Actual Parameter List of
the method call.
Formal parameter list of method.
Complex add(double real) {
public
new Complex(r + real, i);
return
}
Message to object a contains the actual parameter
//
list of the method call, in this case the double
//
// value increment.
c = a.add(increment);
Actual parameter list of method call

When calling a method, Java first copies the
values in the actual parameter list of the call
into the “slots” in the formal parameter list of
the method, then it executes the method’s code.
real: 24
.
increment: 24
slot for formal parameter
of method “add”
value stored in “increment”
copied into “real”before
“add” starts running.
storage space for double
variable “increment”
memory
This means that if a formal parameter of a
method is a primitive type, changes made to the
formal parameter within the method will not
affect the value of the actual parameter passed
to the method, because it is the copy which gets
modified (“Pass by Value”).

But if the argument to a method is any sort of
object, then it is the reference to that object that
gets copied into the slot in the formal parameter
list, not the object itself. Hence, any alteration
made to the object in the method causes a
global alteration to the state of the object.
v: 0x346278
.
b: 0x346278
slot for formal parameter “v”
of method “add”
value stored in “b”
copied into “v”before
“add” starts running.
storage space for reference
variable “b”
memory
Storage space for object
referenced by “b”and“v”is
at memory location 0x346278.
Calling method “add(Complex v)” with
message “a.add(b).” The variable b and the
formal parameter v are reference types.
(“Pass by Reference”).

Methods and Arrays:
Methods may be defined to return arrays as
well as scalars:
double[] getRealandImag() {
public
elements = new double[2];
double[]
= r; elements[1] = i;
elements[0]
elements;
return
}
An equivalent definition is:
double getRealandImag()[] {
public
elements = { r, i };
double[]
return elements;
}
Here the method getRealandImag creates and returns a
2-element double array which contains the real and
imaginary components of the Complex object to which
the method belongs.
Note the two equivalent forms for declaring that the
method returns an array. The former is preferred.

Because arrays are objects, hence pass by reference,
we can also pass an array as a parameter
to a method and have the method change its
contents:
void getRealandImag(
public
elements) {
double[]
elements[0] = r; elements[1] = i;
}
Note that the array “elements” must exist
before the method is called (and be big enough
to hold the result).
elts = new double[2];
double[]
c = new Complex(-2.0, 5.4);
Complex
c == "
System.out.println("Before:
elts[0] + ", " + elts[1]);
+
c.getRealandImag(elts);
c == "
System.out.println("After:
+ elts[0] + ", " + elts[1]);

Viewing the value of an object, the
“toString” method:
It is good practice for all classes to define a
“toString” instance method with the following
“signature”:
When sent as a message to an object, “to-
String” should return a String representation
of the object’s current value.
String toString()
c(3.0, -4.8);
Complex
s = c.toString();
String
System.out.println(s);
What makes toString interesting is that the
Java language will automatically call it if it
sees an attempt to concatenate a String object
with a non-String.
Java overloads the “+” operator to perform
string concatenation when one of its elements
is a String.

System.out.println("c == " + c);
Concatenation of String "c == " with Complex
object c.Callc.toString() to convert c.
Here is an implementation of toString for
Complex. It builds the character representation
of the object in a StringBuffer first, then
converts this to a String, which it returns:
String toString() {
public
s
StringBuffer
= new StringBuffer(20);
s.append(r);
( i != 0.0 ) {
if
( i < 0.0 ) s.append(" -");
if
s.append(" +");
else
j");
s.append("
s.append(Math.abs(i));
}
s.toString();
return
}
Complex c prints as “3.0 - j4.8”.

Data Abstraction & Information
Hiding
Onewaytouseclassesisasawayofimplementing
Abstract Data Types (ADTs). The
Complex type developed earlier is a sort of
ADT, we have Complex objects and methods
for manipulating these objects. However, it is
not a pure ADT, because the user of a Complex
object can directly manipulate the data it
encapsulates (i.e., the instance variables of the
type.)
This is not regarded as the best way to design
an Abstract Data Type because it commits us to
a particular way of representing a Complex
object internally, (in terms of its Cartesian
components.) However, this is just one way of
representing a Complex object, we might
instead prefer to use polar components (magnitude
and angle), for some purposes. The problem
with our current implementation is that,
once it has been released for use, we can no

longer make this change, we are committed to
one particular form of internal representation.
In a pure ADT the user is denied access to any
internal implementation details (Information
Hiding.) Instead, we present an Application
Programming Interface (API) to the user.
User Accesses
ADT
via
API
Application
Programming
ADT
Kernel
(private
variables &
methods)
Interface
(Public Methods)
This interface acts as a “buffer” between the
user of an ADT object and its internal implementation
details. The user is only allowed to

manipulate an ADT object by calling methods
defined in its API. Any other methods and data
belonging to the object are hidden, and only
accessible indirectly.
(N.B., many of the Java library classes give you
access to instance variables, but normally restrict
you to read-only access, i.e., you are not allowed
to assign to an instance variable. This is usually
regarded as acceptable in ADT design.)
Hence, the API of an abstract data type provides
a Controlled and Documented way for
the user of that ADT to employ ADT objects.
The user is limited to using the ADT in predefined
ways allowed by its designer: “Restricted
Access.”
Advantages of the API approach to ADT
design:
• Decoupling of interface & implementation.
• Access control over ADT data.

Decoupling of Interface and Implementation:
A well designed application programming
interface is a “Contract” between the designer
of an abstract data type and its users. The
designer knows that the users of the type can
only access it via its API. Hence, the designer
is free to change the implementation of the
ADT at any time, without affecting any userlevel
software that employs that ADT.
If the API is kept the same during revisions of
the implementation, the user won’t even know
that anything has changed (except that the
ADT might become faster, or more efficient),
its logical behaviour will remain constant.
The designer guarantees that the ADT will
behave as advertised in its API, but reserves
the right to implement the ADT in the most
appropriate fashion. The interface and implementation
have been Decoupled.

a
w
r
d
h
current-
Balance
t
C
Access Control over ADT data:
Consider an ADT which models a bank
account. It contains an instance variable “currentBalance”.
It would be highly inappropriate
if the users of the bank account object had
the freedom to access this instance variable
directly.
C ash
e d p
o
s
i
a
s
i
t
w
h
Instead, the designer “wraps” an API around
currentBalance so that its value can only be
changed via well controlled “depositCash”
and “withdrawCash.” The former
methods:
method only allows positive amounts of cash to

e deposited in the account, and the latter only
allows withdrawals of positive amounts of cash
less than or equal to currentBalance.
Here we have implemented an Access Control
system on the ADT. The user can only get at
the instance variable currentBalance through
methods which restrict the sorts of operations
that are legal on this variable.
The “private” keyword, protecting
class data:
class Complex {
public
double r, i;
private .
}
By declaring a variable “private”inaclass,
we are saying that the only methods which are
allowed to access (read or write) the variable

are methods belonging to this class. Asfaras
all other methods in the program are concerned,
the variable is invisible.
Accessor and Mutator methods, accessing
class data:
class BankBalance {
public
double currentBalance;
private
BankBalance() {
public
= 0.0;
currentBalance
}
Accessor method, find current balance in acc.
//
double getBalance() {
public
return currentBalance;
}
Mutator method, deposit an amount, c, of cash.
//
void depositCash(double c) {
public
( c > 0.0 )
if
+= c;
currentBalance
}
.

class Complex {
public
double r, i;
private
public Complex() { r = i = 0.0; }
Complex(double r, double i) {
public
= r; this.i = i;
this.r
}
Accessor methods.
//
double getReal() {
public
return r;
}
double getImag() {
public
i;
return
}
double getMag() {
public
Math.sqrt(r*r + i*i);
return
}
See the java.lang.Math documentation for
//
information on atan2.
//
double getAngle() {
public
Math.atan2(i, r);
return
}

Mutator methods.
//
Complex setRealandImag(
public
r, double i) {
double
= r; this.i = i;
this.r
return this;
}
Complex setMagandAngle(
public
m, double a) {
double
= m * Math.cos(a);
this.r
= m * Math.sin(a);
this.i
this;
return
}
// Rest of class definition here.
.
// End class Complex.
}
In this version of class Complex the user cannot
tell (without reading the source code) what sort
of internal representation is being used, Cartesian
or polar. If the class designer were to
decide to change the internal representation of
this class, the user wouldn’t notice the change.
In fact, programs written to use this class
would not even need to be recompiled.

Developing Classes
This is a four-step process:
1. Define the problem (problem statement).
2. Define the API for the ADT.
3. Decide on an appropriate internal data representation.
4. Implement the methods.
As an example we will present the design of a
Matrix class.
Define the problem:
Thefirstthingtodoistodecideclearlywhatit
is that the ADT models. This should be written
out as a succinct statement:
Design a Matrix ADT which implements
simple matrix arithmetic, viz., addition,
subtraction and multiplication of matrices.
All indices should be 1 rather than 0-based.

Define the API:
The API is the view that the user will have of
the new ADT. It is important to try to get everything
needed in here. Note that this definition
is made before we know how the ADT will be
implemented:
Methods:
add(Matrix b)
Matrix
Add a matrix, b, to the current matrix, cm, assuming
they are the same size. The result will be returned
in a new matrix, neither cm nor b being changed. If cm
and b are not the same size, generate an error message
and halt.
sub(Matrix b)
Matrix
Similar to add, except that b is subtracted from cm.
Matrix mul(Matrix b)
Multiply cm by b, returning the result in a new
matrix. Cm and b remain unchanged. If cm and b do
not conform (i.e., if the number of columns in cm is
not the same as the number of rows in b), generate an
error message and halt.

Constructor:
r, int c)
Matrix(int
Make a new Matrix object with r rows and c columns.
The elements of the Matrix will all be doubles,
and will be initialised to zeroes. If either r or c is negative
or zero, generate an error message and halt.
Accessor & Mutator methods:
getRows()
int
Return the number of rows in the current Matrix.
getCols()
int
Return the number of columns in the current Matrix.
getElt(int r, int c)
double
Return the value of location (r, c) in the current
Matrix. If either r or c is outside the bounds of the current
Matrix, generate an error message and halt. Note
that indices in the Matrix are 1-based, so that the first
element is at location (1, 1), not (0, 0).
setElt(int r, int c,
Matrix
val)
double
Set location (r, c) in the current Matrix to value val.
If either r or c is outside the bounds of the current
Matrix, generate an error message and halt. Note that
indices in the Matrix are 1-based, as in getElt. This
method returns a reference to the modified Matrix.

Utility method:
toString()
String
Generate a printable representation of the current
Matrix object and return it. The current object is not
modified by this method.
Decide on an internal data representation:
We decide to use a 2-d array of double values,
with rows × columns elements in it. Each
Matrix object will also have to keep track of
how big it is:
class Matrix {
public
double[][] elts;
private
private int rows, columns;
Implement the methods:
The “add” and “sub” methods are very similar.
In particular, they both need to check that the
matrices being added are of the same size.

Matrix add(Matrix b) {
public
checkSize(b);
res = new Matrix(rows,
Matrix
columns);
(int r = 0; r < rows; r++)
for
(int c = 0; c < columns; c++)
for
= elts[r][c] +
res.elts[r][c]
b.elts[r][c];
return res;
}
Matrix sub(Matrix b) {
public
checkSize(b);
res = new Matrix(rows,
Matrix
columns);
(int r = 0; r < rows; r++)
for
(int c = 0; c < columns; c++)
for
= elts[r][c] -
res.elts[r][c]
b.elts[r][c];
return res;
}
Both of these methods need a way to check that
the current matrix and the argument to the
method have the same number of rows and columns.
This job has been abstracted into method
“checkSize.” But checkSize is an operation

which is private to the class, a user of the class
should not be able to call it directly. We can
make checkSize inaccessible to outside users
by declaring it with the private keyword:
void checkSize(Matrix b) {
private
( rows != b.rows ||
if
!= b.columns )
columns
mismatch");
fatalError("Add/sub:
}
This is now a method which can only be
accessed from within Matrix. It provides a
service to the publicly accessible methods of
the class.
“fatalError” is another example of a private
utility method. If called, it prints a message to
the error stream and stops the program.
void fatalError(String s) {
private
System.err.println(
fatal error: " + s);
"Matrix:
System.exit(0);
}

The method “mul” performs the multiplication
operation between matrices. This method has
little commonality with others, in particular, its
test to see if the two matrices can be multiplied
(i.e., that they “conform”), is unlike the size
checks for addition and subtraction. Instead,
the method must check to see if the number of
columns in the multiplicand (the current
object) is the same as the number of rows in the
multiplier (the argument to the method.)
Matrix mul(Matrix b) {
public
( columns != b.rows )
if
fatalError("Nonconforming matrices");
res = new Matrix(rows,
Matrix
b.columns);
(int r = 0; r < res.rows; r++) {
for
(int c = 0; c < res.columns; c++) {
for
acc = 0.0;
double
(int i = 0; i < columns; i++)
for
+= elts[r][i] * b.elts[i][c];
acc
= acc;
res.elts[r][c]
}
}
res;
return
}

The accessor methods “getRows” and “get-
Cols” are straightforward. Their only purpose
is to protect the inner workings of the class
from modification by the user (which would be
possible if the instance variables “rows”and
“columns” weremadepublic.)
int getRows() {
public
rows;
return
}
int getCols() {
public
columns;
return
}
(There is a way to allow “read-only” access to
the instance variables rows and columns, but
we won’t use it here.)
The accessor methods “getElt” and “setElt”
are quite similar to one another. Both need to
check that their indices are within bounds, and
both need to convert the 1-based Matrix indices
which are passed as parameters to them, to
0-based indices suitable for accessing the

“elts” array where the elements of the Matrix
are stored.
double getElt(int r, int c) {
public
= checkRowIndex(r);
r
= checkColumnIndex(c);
c
elts[r][c];
return
}
Matrix setElt(int r, int c,
public
val) {
double
= checkRowIndex(r);
r
= checkColumnIndex(c);
c
= val;
elts[r][c]
this;
return
}
The utility methods are “checkRowIndex”and
“checkRowIndex.” As well as checking that
their indices are within the appropriate ranges,
these methods perform the 1-based to 0-based
index conversion. Here is “checkRowIndex”:
int checkRowIndex(int r) {
private
( r < 1 || r > rows )
if
index " + r
fatalError("Row
" out of range");
+
return r - 1;
}

Finally there is the “toString” method, whose
job it is to generate a printable representation
of a Matrix. We choose to print a Matrix in
the following, single-line, form:
-4.2], [0.0, 1.0], [0.7, 4.5]]
[[2.0,
(Thisisa3x2Matrix.)Hereisthecode:
String toString() {
public
buf = new StringBuffer(80);
StringBuffer
(int r = 0; r < rows; r++ ) {
for
== 0 "[" : ", "));
buf.append((r
(int c = 0; c < columns; c++) {
for
== 0 "[" : ", "));
buf.append((c
buf.append(elts[r][c]);
}
buf.append("]");
}
buf.append("]");
return buf.toString();
}
As with the toString method from class Complex,
weuseaStringBuffer to accumulate
the result, because it can grow in size as
needed, and later turn it into a String.80isan
initial guess at how big the buffer should be.

Constructor. This class has no default
//
constructor.
//
= new double[rows][columns];
elts
else
Here is the whole class definition for Matrix:
Matrix.java
class Matrix {
public
Instance variables. Data elements are
//
stored in a 2-d array with rows x columns
//
elements.
//
double[][] elts;
private
int rows, columns;
private
Matrix(int r, int c) {
public
= r;
rows
= c;
columns
( rows > 0 && columns > 0 )
if
fatalError("Constructor " + r + ", " + c);
}
// Accessor methods.
Accessor method, get the number of rows in the
//
Matrix.
//
int getRows() {
public
rows;
return
}
Accessor method, get the number of columns in
//
the Matrix.
//
int getCols() {
public
columns;
return
}

= checkRowIndex(r);
r
= checkColumnIndex(c);
c
(int c = 0; c < columns; c++)
for
= elts[r][c] - b.elts[r][c];
res.elts[r][c]
Matrix.java continued:
Accessor method, get an element of the Matrix.
//
double getElt(int r, int c) {
public
return elts[r][c];
}
Mutator method, set an element of the Matrix.
//
Matrix setElt(int r, int c, double val) {
public
= checkRowIndex(r);
r
= checkColumnIndex(c);
c
= val;
elts[r][c]
this;
return
}
add method. Add a Matrix passed as an argument
//
to the current Matrix object and return a new
//
result Matrix.
//
Matrix add(Matrix b) {
public
checkSize(b);
res = new Matrix(rows, columns);
Matrix
(int r = 0; r < rows; r++)
for
(int c = 0; c < columns; c++)
for
= elts[r][c] + b.elts[r][c];
res.elts[r][c]
res;
return
}
sub method. Very similar in structure to add,
//
but performs subtraction.
//
Matrix sub(Matrix b) {
public
checkSize(b);
res = new Matrix(rows, columns);
Matrix
(int r = 0; r < rows; r++)
for
return res;
}

eturn a new result Matrix.
//
Matrix mul(Matrix b) {
public
toString method. Generate a String object which
//
represents the current Matrix object.
//
(int c = 0; c < columns; c++) {
for
"[" : ", "));
buf.append((c==0
Matrix.java continued:
mul method. Multiply the current Matrix object by
//
a Matrix passed as an argument to the method and
//
( columns != b.rows )
if
do not conform");
fatalError("Matrices
Matrix res = new Matrix(rows, b.columns);
(int r = 0; r < res.rows; r++) {
for
(int c = 0; c < res.columns; c++) {
for
acc = 0.0;
double
(int i = 0; i < columns; i++)
for
+= elts[r][i] * b.elts[i][c];
acc
= acc;
res.elts[r][c]
}
}
res;
return
}
String toString() {
public
buf = new StringBuffer(80);
StringBuffer
(int r = 0; r < rows; r++ ) {
for
"[" : ", "));
buf.append((r==0
buf.append(elts[r][c]);
}
buf.append("]");
}
buf.append("]");
return buf.toString();
}

fatalError prints an error message (which it
//
receives as an argument) to the standard error
//
fatal error: "
System.err.println("Matrix:
errorMessage);
+
int checkRowIndex(int r) {
private
( r < 1 || r > rows )
if
Matrix.java continued:
// Private methods, unique to this class.
stream, then halts the program. This is not an
//
ideal way to handle errors, it would be better
//
to use Java’s exception mechanism.
//
void fatalError(String errorMessage) {
private
System.exit(0);
}
checkSize checks to see if its argument (a Matrix)
//
has the same number of rows and columns as the
//
current Matrix object. Needed for addition and
//
subtraction.
//
void checkSize(Matrix b) {
private
( rows != b.rows || columns != b.columns )
if
fatalError("Add/sub: size mismatch");
}
checkRowIndex checks that its argument is a valid
//
row index (i.e., 1

then performs 1- to 0-based index conversion and
//
returns a 0-based index.
//
Matrix.java continued:
checkColumnIndex checks that its argument is a
//
valid column index (i.e., 1

") = " + a.getElt(r, c)
+
" ");
+
+ b = " + a.add(b));
System.out.println("a
- b = " + a.sub(b));
System.out.println("a
Matrix.java continued:
main method contined from previous page.
//
is now: " + a);
System.out.println("a
System.out.println("b is now: " + b);
elements of a & b");
System.out.println("Accessing
(r = 1; r