Object Life Cycle

You create an object from a class by using:

the new operator, and
a constructor

Instance variables and methods can be

accessed by:
qualified names
objectReference.variableName
that refers to the current object
objectReference.methodName(argumentList)

Note : this is a Java language keyword

1

Object Life Cycle (Contd)

The Garbage Collector automatically cleans
up unused objects
an object is unused if the program holds no more
references to it.

In some situations, you may want to run the

garbage collection explicitly by calling the gc
method in the java.lang.System class.
You can explicitly drop a reference by setting the
variable holding the reference to null.
2

Creating Classes

Creating Classes -Class Declaration

Creating Classes -Class Declaration

Minimum needed
AccessLevel

Indicates the access level for this class

Class
nameOfClass

Declares a class with a name

nameOfClass should be a valid identifier

{
ClassBody
}

Class Declaration
Access Level
By default, a class can be used only by
other classes in the same package.
Look in Creating and Using Packages for
information about how to use modifiers to
limit access to your classes and how it
affects your access to other classes.
6

Class Body
The class body contains all of the code that
provides for the life cycle of the objects created
from it:
constructors for initializing new objects,
declarations for the member attributes that provide
the state of the class and its objects,
Member methods to implement the behavior of the
class and its objects

Variables and methods collectively are called

members.
7

Object state
The idea of "state" is that an object has
characteristics that it keeps as long as it
exists. The characteristics may change in
value during the lifetime of the object.
The state of an object is held in its
instance variables (not class variables, not
in the parameters of methods, nor in the
local variables of methods.)
8

Object state example

class mpgTester
{
public static void main ( String[] args )
{
Car myCar = new Car( 12000, 12340, 12.3 );
. . . . . .
}
}

The state of the object is set to:

startMiles = 12000
endMiles = 12340
gallons = 12.3
The object referenced by myCar holds these values as long as it exists.
9

Class Body -- Constructors

Constructors are not methods. Nor are they members.
All Java classes have constructors that are used to initialize a new
object of that type.
A constructor has the same name as the class.
Java supports name overloading for constructors so that a class
can have any number of constructors, all of which have the same
name.
The compiler differentiates these constructors based on the
number of parameters in the list and their types.
Typically, a constructor uses its arguments to initialize the new
object's state. When creating an object, choose the constructor
whose arguments best reflect how you want to initialize the new
object.
10

Class Body -- Constructors

The default constructor is automatically provided by the
runtime system for any class that contains no constructors:
But it doesn't do anything. So, if you want to perform some
initialization, you will have to write some constructors for your
class.

The body of a constructor is like the body of a method; that

is, it contains local variable declarations, loops, and other
statements.

You can specify what other objects can create instances of

your class by using an access level in the constructors'
declaration
11

Class Body-Declaring Member Variables

(minimum needed)
AccessLevel

Indicates the access level for this

variable

static

Declares a class member

final

Indicates that it constant

type name

The type and the name of the

variable
12

Creating Classes-Class Body

(Declaring Member Variables)
accessLevel
Lets you control which other classes have
access to a member variable by using one of
four access levels: public, protected, package,
and private. You control access to methods in
the same way.

final
Indicates that the value of this member cannot
change.
13

Creating Classes-Class Body

(Declaring Member Variables)
Instance variables: When you declare a member variable
in a class you declare an instance variable.
Every time you create an instance of a class, the runtime
system creates one copy of each class's instance variables
for the instance.
You can access an object's instance variables only from an
object.

Static or Class variables:

Class variables are declared using the static modifier.

The runtime system allocates class variables once per class

All instances share the same copy of the class's class
variables.
You can access class variables through an instance or
through the class itself.
14

Static variables
Example
public class StaticExample
public static int x;
public int y;

e2

e1

public StaticExample (int a, int b) {

x = a;
y = b;
}
public void incr() {
x++;
y++;
e1 object
}
allocation
}
public static void main (String
args[]) {
StaticExample e1 = new
StaticExample(5, 10);
StaticExample e2 = new
StaticExample(12, 7);
e1.incr();

10

e2 object
allocation

12
Class
allocation
15

Example
public class Bicycle{
private
private
private
private

int cadence;
int speed;
int id;
static int numberOfBicycles = 0;

public Bicycle (int startCadence, int startSpeed){

cadence = startCadence;
speed = startSpeed;
// increment number of Bicycles and assign ID number
id = ++numberOfBicycles;
}
public static void main( String args[]) {
Bicycle b1 = new Bicycle (12, 15);
Bicycle b2 = new Bicycle (10, 25);
System.out.println(total bicycles:+
Bicycle.numberOfBicycles );
}
}
16

Class Body-Declaring Methods

17

Class Body-Declaring Methods

(minimum needed)
AccessLevel

Indicates the access level for this

method

static

Declares a method as a class

method

returnType
methodName

The return type and the method

name

(paramlist)

The list of arguments

Throws
exceptions

The exceptions thrown by this

method (to be discussed in chapter 5)
18

Creating Classes Class Body

Declaring Methods
accessLevel
As with member variables, you control which
other classes have access to a method using
one of four access levels: public, protected,
package, and private

19

Creating Classes Class Body

Declaring Methods
Your classes can have instance methods and class methods.
Instance methods operate on the current object's instance
variables but also have access to the class variables.
Class methods cannot access the instance variables declared
within the class (unless they create a new object and access
them through the object).
Also, class methods can be invoked on the class, you don't
need an instance to call a class method.
Their implementation is independent on the state of the object
20

Packages
A package is a collection of related
classes and interfaces providing access
protection and namespace management:
Help know where to find groups of related
classes and interfaces.
Avoid conflict with class names in other
packages, because the package creates a
new namespace.
21

Packages
How to create a package?
// only comment can be here
package world;
public class HelloWorld {
public String sayHello() {
return Hello World;
}
}
Note: packages should map to file system, for package world you should
create directory world that contains HelloWorld class definition
22

PackagesUsing Package Members

1. Declare the fully-qualified class name.
world.HelloWorld helloWorld =
new world.HelloWorld();

2. Use an "import" keyword:

import world.*;
HelloWorld hello = new HelloWorld();
// don't have to explicitly specify
// world.HelloWorld anymore

Note: You might have to set your class path so that the
compiler and the interpreter can find the source and
class files for your classes and interfaces

23

PackagesDisambiguating a Name
If a member in one package shares the same name with a member in
another package and both packages are imported, you must refer to
each member by its qualified name.
For exmaple lets define the following
package graphics;
public class Rectangle { . . . }
The java.awt package also contains a Rectangle class. If both graphics
and java.awt have been imported, the following is ambiguous:
Rectangle rect;
In such a situation, you have to be more specific and use the member's
qualified name to indicate exactly which Rectangle class you want:
graphics.Rectangle rect; or
Java.awt.Rectangle rect;
24

Creating Classes Class Body

(Controlling access to members of a Class )
Specifier

Class Subclass Package

private

protected

public

Package(1)

World

(1) you dont explicitly set a members access level to one of the other levels25

Access Control -- Private

Private:
The most restrictive access level is private. A private
member is accessible only to the class in which it is
defined
This includes variables that contain information that if
accessed by an outsider could put the object in an
inconsistent state
But objects of the same type have access to one
another's private members

26

Access Control -- Private

class Alpha {
private int iamprivate;
private void privateMethod() {
System.out.println("privateMethod");
}
}
class Beta {
void accessMethod() {
Alpha a = new Alpha();
a.iamprivate = 10; // illegal
a.privateMethod(); // illegal
}
}
27

Access Control--Protected
Protected
allows the class itself, subclasses and all classes in
the same package to access the members.
Use the protected access level when it's appropriate
for a class's subclasses to have access to the
member, but not unrelated classes.
Protected members are like family secrets--you don't
mind if the whole family knows, and even a few
trusted friends but you wouldn't want any outsiders to
know.
28

Access Control--Protected
package Greek;
public class Alpha {
protected int iamprotected;
protected void protectedMethod() {
System.out.println("protectedMethod");
}
}
class Gamma {
void accessMethod() {
Alpha a = new Alpha();
a.iamprotected = 10;
// legal
a.protectedMethod();
// legal
}
}
29

Access Control--Protected
package greek;
public class Alpha {
protected int iamprotected;
protected void protectedMethod() {
System.out.println("protectedMethod");
}
}
package roman;
import greek.Alpha; //needed only to find
//the symbol Alpha
class Gamma extends Alpha {
void accessMethod() {
Alpha a = new Alpha();
a.iamprotected = 10;
// legal
a.protectedMethod();
// legal
}
}

30

Access Control -- Public

Public
Any class, in any package, has access to a
class's public members.
Declare public members only if such access
cannot produce undesirable results if an
outsider uses them.
There are no personal or family secrets here;
this is for stuff you don't mind anybody else
knowing.
31

Access Control -- Public

package Greek;
public class Alpha {
public int iampublic;
public void publicMethod() {
System.out.println("publicMethod");
}
}
package Roman;
import Greek.*;
class Beta {
void accessMethod() {
Alpha a = new Alpha();
a.iampublic = 10;
a.publicMethod();
}
}

// legal
// legal
32

Access Control -- Package

Package
The package access level is what you get if you don't
explicitly set a member's access to one of the other
levels.
This access level allows classes in the same package
as your class to access the members.
This level of access assumes that classes in the
same package are trusted friends. This level of trust is
like that which you extend to your closest friends but
wouldn't trust even to your family.
33

Access Control -- Package

package Greek;
class Alpha {
int iampackage; //package access level by default
void packageMethod() {
System.out.println("packageMethod");
}
}
package Greek;
class Beta {
void accessMethod() {
Alpha a = new Alpha();
a.iampackage = 10;
// legal
a.packageMethod();
// legal
}
}

34

Access Control -- Package

package Greek;
class Alpha {
int iampackage; //package access level by default
void packageMethod() {
System.out.println("packageMethod");
}
}
package Roman;
import Greek.Alpha;
class Beta {
void accessMethod() {
Alpha a = new Alpha();
a.iampackage = 10;
// illegal
a.packageMethod();
// illegal
}
}

35

Access Control -- Package

package Greek;
class Alpha {
int iampackage; //package access level by default
void packageMethod() {
System.out.println("packageMethod");
}
}
package Roman;
import Greek.Alpha;
class Beta extends Alpha{
void accessMethod() {
Alpha a = new Alpha();
a.iampackage = 10;
// illegal
a.packageMethod();
// illegal
}
}

36

References on the Web

http://java.sun.com/docs/books/tutorial/java/int
erpack/packages.html

http://java.sun.com/docs/books/tutorial/java/jav
aOO/classes.html

http://java.sun.com/docs/books/tutorial/java/jav
aOO/classvars.html
37