- An instance variable
begins to exists
when it is
created by the
new
operation
Example:
- Before the
new BankAccount()
operation, the
instance variables
accNum,
name and
balance
does not exist:
- After the
new BankAccount()
operation, the
instance variables
accNum,
name and
balance
begins to exist:
- Before the
new BankAccount()
operation, the
instance variables
accNum,
name and
balance
does not exist:
- When will
an instance variable
cease to exist:
- Fact:
- An instance variable will be accessible as long as some object reference variable contains the address of that object
Example:
- We can access the
instance variables
accNum,
name and
balance
through the
object reference variable stu1
because it contains
the address of that
BankAccount object
- Consequence:
- An instance variable will be INaccessible when NO object reference variable contains the address of that object
Example:
- We can
make the
instance variables
accNum,
name and
balance
become
INaccessible
by updating the
address value stored inside
the
object reference variable stu1:
- When will a
instance variable
cease to exist:
- When instance variables
of an object
becomes
inaccessible
(because no object reference variable in the
Java program contain
its (starting) address), then:
- These instance variables --- for practical purposes --- have ceased to exist
- The accurate answer to the
question is:
- These
instance variables
will cease to exist
after the
garbage collection procedure
has completed execution
(See below for details)
- These
instance variables
will cease to exist
after the
garbage collection procedure
has completed execution
- When instance variables
of an object
becomes
inaccessible
(because no object reference variable in the
Java program contain
its (starting) address), then:
- Fact:
- Gargbage:
- Garbage =
variables
(that occupy some reserved memory cells)
that are
inaccessible
to the running program
These memory cells remain reserved until a complicated process is used to find them and mark them as unreserved
(It's a complicated matter to find "garbage")
- Garbage =
variables
(that occupy some reserved memory cells)
that are
inaccessible
to the running program
- Garbage collection:
- Garbage collection =
the process of
finding all
variables that have become
garbage
and
unreserve their
memory cells.
The program used to perform the garbage collection process is called the garbage collector
It can take a long time for the garbage collector to complete.
- Garbage collection =
the process of
finding all
variables that have become
garbage
and
unreserve their
memory cells.
- For practical reasons, the Java programming system will only run the Garbage collector procedure when the amount of available memory drop below a certain threshold
- The accessibility of
instance variables are
controlled by
access modifiers
(just like class variables)
- We will cover this topic more thoroughly
in a later webpage
See: click here
- Here we will give a brief overview for completeness sake.
- We will cover this topic more thoroughly
in a later webpage
- Commonly used access modifiers:
- public =
the instance variable can be
accessed by
statements in a method inside
any class
- private = the instance variable can be accessed by statements in a method inside the same class
- public =
the instance variable can be
accessed by
statements in a method inside
any class
- Less commonly used access modifiers:
(for completeness sake only....)
- protected =
the instance variable can be
accessed by
statements in a method inside
the same class and
any
derived classes
(You need to know the inheritance concept to understand a derived classes )
- default (no access modifier) =
the instance variable can be
accessed by
statements in a method inside the
same package
(You need to know how to define packages in Java to fully understand this concept....)
- protected =
the instance variable can be
accessed by
statements in a method inside
the same class and
any
derived classes
- How to identify
the 4 different kinds
of variables in Java:
- Class variables
public static class SomeClassName { public static double a; // Class variable // Outside every method // WITH keyword "static" ... }Lifetime and scope:
- Exist from the start to the
end of
a running program
- Can be access anywhere using
ClassName.VariableName
Shart hand name (VariableName only) may be shadowed by a local/parameter variable with identical name.
- Exist from the start to the
end of
a running program
- Instance variables
public static class SomeClassName { public double a; // Instance variable // Outside every method // WITHOUT keyword "static" ... }Lifetime and scope:
- Starts to exist
after creation
by a new operation
Ceases to exist (for practical purposes) when it cannot be accessed through object reference variables
- Can be accessed as long as an object reference variables inside the scope refers to the object containing the instance variable
- Starts to exist
after creation
by a new operation
- Local variables
public static class SomeClassName { public static void main(String[] args) { double a; // Local variable // Inside a method ... } }Lifetime and scope:
- Starts to exist
after the point of definition
while
the method is running
Ceases to exist at the end of the enclosing scope
(Look for { .... } to determine the enclosing scope)
- Can be accessed after its definition inside the enclosing scope
- Starts to exist
after the point of definition
while
the method is running
- Parameter variables
(between the brackets of a method definition)
public static class SomeClassName { public static void main(String[] args) { ... } }Lifetime and scope:
- Exist from the start to the
end of
the method while the
method is running
- Can be access anywhere inside the method body
- Exist from the start to the
end of
the method while the
method is running
- Class variables