Classes and Methods
26-Jul-16
Objects have behaviors

In old style programming, you had:



data, which was completely passive
functions, which could manipulate any data
In O-O programming, an object contains both data
and methods that manipulate that data


An object is active, not passive; it does things
An object is responsible for its own data



It can protect that data (by marking it private)
It can expose that data to other objects (by not marking it, or by
marking it public)
Data should not be exposed without good reason
2
Objects have state

An object contains data



The data represent the state of the object
Data can also describe the relationship of the object to other
objects
Example: a checkingAccount might have



A balance (the internal state of the account)
An owner (some object representing a person)
An accountNumber (used as an ID number)
3
Example: a “Rabbit” object

You could create an object representing a rabbit

It would have data:




How hungry it is
How healthy it is
Where it is
And methods:

eat, run, dig, hide
4
Classes



A class describes a set of objects
The objects are called instances of the class
A class describes:




Fields that hold the data for each object
Constructors that tell how to create a new object of this
class
Methods that describe the actions the object can
perform
In addition, a class can have data and methods of
its own (not part of the objects)


For example, it can keep a count of the number of
objects it has created
Such data and methods are called static
5
Defining a class



Here is the simplest syntax for defining a class:
class ClassName {
// the fields (variables) of the object
// the constructors for the object
// the methods of the object
}
You can put public, protected, or private before the word
class
Things in a class can be in any order (I recommend the
above order)
6
Defining fields



An object’s data is stored in fields (also called
instance variables)
The fields describe the state of the object
Fields are defined with ordinary variable declarations:
String name;
Double health;
int age = 0;
7
Defining constructors

A constructor is code to create an object




You can do other work in a constructor, but you shouldn’t
The syntax for a constructor is:
ClassName(parameters) {
…code…
}
The ClassName has to be the same as the class that
the constructor occurs in
The parameters are a comma-separated list of
variable declarations
8
Parameters





We usually need to give information to constructors and
to methods
A parameter is a variable used to hold the incoming
information
A parameter must have a name and a type
You supply values for the parameters when you use the
constructor or method
The parameter name is only meaningful within the
constructor or method in which it occurs
9
Example constructor
public class Person {
String name;
int age;
boolean male;
Constructor
Person (String aName, boolean isMale) {
name = aName;
male = isMale;
Parameters
}
}
10
Example use of a constructor

The constructor looks like:



You can construct a new Person like this:



Person (String aName, boolean isMale) {…}
aName and isMale are called formal parameters
The formal parameters are used to receive values
Person john = new Person("John Smith", true);
"John Smith" and true are called actual parameters
The actual parameters are used to give values to the formal
parameters
You must have the same number of actual parameters
as formal parameters, in the same order, and they must
have the same types
11
A problem with names

It would be nice if we could say:

public class Person {
String name;
boolean male;
Person (String name, boolean male) {
name = name ;
}
}
male = male ;
12
A problem with names

And have it mean:

public class Person {
String name;
boolean male;
Person (String name, boolean male) {
name = name ;
}
}
male = male ;
13
A problem with names

But this is what it would really mean:

public class Person {
String name;
boolean male;
Person (String name, boolean male) {
name = name ;
}
}
male = male ;
14
this to the rescue

A parameter may have the same name as an
instance variable



The name always refers to the parameter
The keyword this refers to the current object
Putting this in front of a name means that the
name is a field of this object (it isn't a parameter)
15
A problem with names—solved!

Here is how we do what we want:

public class Person {
String name;
boolean male;
Person (String name, boolean male) {
this.name = name ;
}
}
this.male = male ;
16
A typical use of this



If you write a constructor with parameters…
…and the parameters are used to set fields that
have the same meaning…
…then use the same names!
Person (String name, boolean male) {
this.name = name ;
this.male = male ;
}
 In fact, this is the recommended way to do it
17
Defining a method

A method has the syntax:
return-type method-name ( parameters ) {
method-variables
code
}

Example:
boolean isAdult( ) {
int magicAge = 21;
return age >= magicAge;
}
18
Returning a result from a method

If a method is to return a result, it must specify the type
of the result
boolean isAdult ( …


You must use a return statement to exit the method
with a result of the correct type:
return age >= magicAge;
This is for methods only (constructors automatically
return a result of the correct type)
19
Returning no result from a method

The keyword void is used to indicate that a
method doesn’t return a value
void printAge( ) {
System.out.println(name + " is " + age +
" years old.");
return;
}
 The keyword return is not required in a void
method
 The method will return automatically when it reaches
the end of the method (the final closing brace)
20
Sending messages

We send a message to an object by:




Naming the object
Naming the method we want to use
Providing any needed actual parameters
Example:


if (john.isAdult ()) {
john.printAge();
}
john.isAdult() returns a value (subsequently used by the if
statement)
john.printAge() does not return a value
21
Putting it all together
class Person {
// methods
String getName() {
return name;
}
// fields
String name;
int age;
// constructor
Person(String name) {
this.name = name;
age = 0;
}
void birthday() {
age = age + 1;
System.out.println(
"Happy birthday!");
}
}
22
Using our new class
Person john;
john = new Person("John Smith");
System.out.print (john.getName());
System.out.println(" is having a birthday!");
john.birthday();
 Of course, this code must also be inside a class!
23
null

If you declare a variable to have a given object type, for example,



...and if you have not yet assigned a value to it, for example, with



Person john;
String name;
john = new Person();
String name = “John Smith";
...then the value of the variable is null
null is a legal value, but there isn’t much you can do with it



It’s an error to refer to its fields, because it has none
It’s an error to send a message to it, because it has no methods
The error you will see is NullPointerException
24
Classes form a hierarchy


Classes are arranged is a treelike hierarchy
There is one class at the top, or root, of the hierarchy,
named Object



In computer science we draw trees upside-down, with the root
at the top
Every class except Object has one “parent” class, or
superclass
Each class is a subclass of its superclass
25
What is the class hierarchy for?

Classes inherit from their superclasses

A class has not only its own fields and methods, but also:




Every field described in any class above it
Every method described in any class above it
Classes do not inherit constructors, however
Hence, a class may contain much more information
than is obvious from the class description
26
Example of inheritance

Example:
class Employee extends Person {
double hourlyWage;
}

void pay(double hoursWorked) {
System.out.println("Pay to the order of: " +
name + " $" +
hoursWorked * hourlyWage);
}
An Employee has a name, an age, an hourlyWage,
and birthday and pay methods.
27
Class variables and methods

A class describes the variables and methods
belonging to objects of that class


A class may also have its own variables and
methods


These are called instance variables and instance methods
These are called class variables and class methods
Class variables and class methods are denoted by
the keyword static

C programmers: same word as in C, different meaning
28
Why have class variables and methods?

Sometimes you want to keep information about the
class itself



Sometimes you want to do something relevant to the
class as a whole


Example: Class Person might have a class variable
population that counts people
This would not be appropriate data to keep in each Person!
For example, find the average age of a population
Sometimes you don’t have any objects

For example, you want to start up a program
29
Example use of a class variable
class Person {
// fields
String name;
int age;
static int population;
// constructor
Person(String name) {
this.name = name;
age = 0;
population =
population + 1;
}
// methods
String getName() {
return name;
}
void birthday() {
age = age + 1;
System.out.println(
"Happy birthday!");
}
}
30
Vocabulary I





class – a description of a set of objects
object – a member of a class
instance – same as “object”
field – data belong to an object or a class
variable – a name used to refer to a data object



instance variable – a variable belonging to an object
class variable, static variable – a variable belonging to the
class as a whole
method variable – a temporary variable used in a method
31
Vocabulary II

method – a block of code that can be used by other parts
of the program



instance method – a method belonging to an object
class method, static method – a method belonging to the class
as a whole
constructor – a block of code used to create an object
32
Vocabulary III

parameter – a piece of information given to a method or
to a constructor



actual parameter – the value that is passed to the method or
constructor
formal parameter – the name used by the method or
constructor to refer to that value
return value – the value (if any) returned by a method
33
Vocabulary IV






hierarchy – a treelike arrangement of classes
root – the topmost thing in a tree
Object – the root of the class hierarchy
subclass – a class that is beneath another in the
class hierarchy
superclass – a class that is above another in the
class hierarchy
inherit – to have the same data and methods as a
superclass
34
The End
“Don't ask for the information you need to do the
work; ask the object that has the information to do the
work for you.”
--Allen Holub
35