Transcript objects and constructors

More about Java Classes
Writing your own Java Classes
More about constructors and
creating objects
Java Objects



We can define our own types using the
Java keyword class
Your understanding and use of
Classes/objects is fundamental to
getting to grips with Java
It is also the biggest climb on the
learning curve - so be patient
What are Java Classes?



Classes are templates
They encapsulate data (variables) and
behaviour (methods)
Variables can either be primitive (int,
char etc) or reference types (String etc)
Classes and Objects –
there is a difference





An object is an occurrence (or instance) of a
Class
The Class describes the blueprint or template
An object is made from a class
For an Employee class, each employee would
be an object with the data and method
structure of the class
Although the structure is the same for all
objects built from this class, the values held
within the data can be different
How to Create objects
from a class?
The new keyword is used to create an
instance of a class - an object reference
Employee JonWestlake = new Employee( );
 new is the ONLY way to create objects**
See examples
Employee1.java - a single class with one object
Employee2.java - a single class with two objects
Employee3.java - a single class with many
objects

What does that new
statement mean?
Employee JonWestlake = new Employee( );


Declares a “reference variable” of type
Employee
So JonWestlake does have a memory location
but no “pointer” to an object yet - essentially
a null object
Breakdown of new statement

Right hand side
= new Employee( );


Creates an object of the Employee class
We could have done the statements in two
stages;
Employee JonWestlake;
JonWestlake = new Employee( );
What is an object reference?

Think of a reference as a name for an object
- JonWestlake is the name of a an Employee
object
Employee JonWestlake = new Employee( );

reference names can be meaningful as in this
case or as we can see with the Employee
application
Object references

It is legal for two references (or more) to refer
to the same object e.g. in the Employee example
we might wish to refer to the object via some
initials as well
Employee JonWestlake = new Employee( );
Employee jcw = JonWestlake;

jcw refers to the same Employee as JonWestlake
What does new do? - memory




new takes the memory it needs to create an
object from a special memory pool that Java
controls automatically, called the heap
All class objects in Java come from the heap
Java allocates enough memory to hold the
object
Java allocates memory for objects when the
object is created, not at application start up
What does new do? - constructor



Java initialises any instance variables to
default values - default constructor
Java makes calls to any constructors that
exist for that class
So, what is a constructor?
Content of Constructors





Constructors are a “special” method used to
initialise an object created for a class
The name is the same as the class, so starts
with a capital letter
Constructor can do anything a normal
method can do**
No return type - not even void
The constructor does not contain a return
statement
Content of Constructor

Like any method a constructor can include
arguments. These arguments indicate to the
constructor how to set up the initial values for
the data fields of an object
See Employee2 for example
What happens if we don’t use
a Constructor?



Every class has a single default constructor
with no parameters
The default constructor takes no arguments
and does nothing other than initialize all
object variables to their zero or null state
As soon as the developer defines a
constructor then the default constructor is no
longer used
What should a Constructor do?




Creating objects to a valid starting state
according to content of the constructor and
arguments passed into the constructor
they are usually used to simply initialize
variables within the object to some starting
value
or they could be used to add objects to a
linked list
or increment an object count…
What should the Constructor do?


We advise you not to place instance
style functionality within the constructor
Use the constructor to initialize an
instance - keeps it simple and
maintainable!
Overloading the Constructor




A class is free to have more than one
constructor
The constructors must have different
argument signatures
Often one “root” constructor has all the
program logic for construction
Other constructors set a few defaults
and then call the root constructor
Example Overloaded Constructor
Item(String itemDesc)
{ Item(itemDesc, 0);
}
Item(String itemDesc, int itemWght)
{ description = itemDesc;
weight = itemWght;
}
new operator for Item class

The first example of the constructor sets the item
weight to 0 and passes this information on to the
full constructor
Item defaultItem = new Item(“General Stock”);

Alternatively, you could call the second
constructor directly
Item specifyItem = new Item(“Widgets”, 50);
Overloading Constructors - Tips



Place all the initialisation code in a root
constructor
Root constructor is usually the constructor
with the most parameters
define “convenience” constructors with fewer
parameters - these constructors call the root
constructor using default values for the
parameters which the user has not provided
See Employee5.java example
Using a test to drive
the choice of constructor


We can ask the user something
Based on the user input, we can test the
input and select the constructor appropriate
to the input
See VideoEx1.java or Employee5.java
Invoking one
Constructor from another




One constructor can invoke another
constructor of the same class using the this
keyword
this - a special (pseudo) variable
pseudo means the value is changed by the
system not the developer
a reference to the object within which a
constructor is executing
useful as it enables messages to “this” the
current object to be performed - see
VideoEx2.java
Running the Constructor


Constructors do not have an explicit
keyword to mark them as such and they
cannot be called like a normal method
see Employee1, Employee2 and
Employee3
Where to position the constructor?



Position the constructor either before the
main method (if there is one for the class) or
after the main method
see the examples
Each constructor is defined separately i.e. not
nested
Constructor access modifiers



The access modifiers are exactly the same as
for classes - public or nothing**
Modifier must be public if classes outside of
the current package need to be able to use
the object being defined - design issue
if public is not used then constructor is only
available within the package to which the
class belongs - for our work this is usually the
case
Destructors!



There is NO destructor in Java
In C++ a destructor is used to return
memory to heap of available memory
Java manages memory automatically
via the constructor and automatically
returns memory when objects are
abandoned
Summary


We have looked further at classes
 We have investigated the role of the constructor
Practical – get the examples running and write
your own versions!