Transcript Access

Access
26-Jul-16
Overview

Questions covered in this talk:




How do we access fields and methods?
Why have access restrictions?
What can have access restrictions?
How do we provide or restrict access?
Instance and class variables

You can declare variables within a class




These variables are called instance variables, or fields
Every object of that class has its own copy of those fields
The fields describe something about the object
You can also declare static variables within a class



There is only one of each static variable
A static variable is also called a class variable
The static variable describes something about the class as
a whole
Method variables

You can declare variables within a method or within a
constructor




These are called method variables, not fields
Method variables are basically used for computation
Method variables are strictly temporary, and are used only
within that method
When a method returns (completes), all its variables are
discarded
Example: a “Rabbit” class

class Rabbit {
static int population;
double hunger;
double fear;
double courage = 0.75;
// class variable (counts Rabbits)
//instance variable
// instance variable
// instance variable

void eat() {
double temp;
// method variable
temp = courage * hunger;
if (temp > fear) {
System.out.println(“Eating!”);
hunger = hunger - 1;
}
}
}
Statements



You can declare variables inside a class or inside a
method or a constructor
You can put statements (executable code) only within
methods and constructors, not inside a class
Declarations with initializations are still declarations,
not statements
Statements must be in methods
(or in constructors)
class Rabbit {
double hunger;
// OK--declaration
double fear = 5.0; // OK--still a declaration
hunger = 5.0;
// illegal--assignment statement
Rabbit ( ) {
hunger = 5.0;
// OK—statement in a constructor
}
void eat ( ) {
hunger = hunger - 1; // OK—statement in a method
}
}
Access from inside a class


Inside a class, you can access other fields and methods
inside the class just by naming them
Example:
class Person {
int age;
void birthday( ) { age = age + 1; }
void growOlder( ) { birthday( ); }
}

Equivalently, you can use the keyword this:
void birthday( ) { this.age = this.age + 1; }
void growOlder( ) { this.birthday( ); }
Accessing from outside a class, 1

Outside a class (from some other class) you access
instance variables and methods by




Naming the object you want to talk to
Putting a dot
Naming the variable or method
Example:
// if NOT in class Person, say:
if (john.age < 75) john.birthday();

Inside the class, the keyword this means “this object”:

if (this.age < 75) this.birthday(); // "this" may mean john
Accessing from outside a class, 2

Outside a class (from some other class) you access
class variables and methods by




Naming the class you want to talk to
Putting a dot
Naming the variable or method
Examples:
Person.population = Person.population + 1;
x = Math.abs(y);
Responsibility

In Java, objects are considered to be active



They have behaviors
They are responsible for their own data
Data (variables) must be kept consistent


Example: population should never be negative
In order for a class or object to be responsible for its
own data, it must keep control of that data
Loss of control


Suppose a Rabbit object, bugsBunny, has a
variable named hunger
Inside the class, this method is fine:
void eat ( ) {
hunger = hunger - 1;
}

From outside the class, the following is legal:


bugsBunny.hunger = bugsBunny.hunger - 1;
But should we be allowed to “reach inside” a rabbit?
The class needs to protect itself from errors in other classes
(and from malicious behavior)
private variables and methods

If you declare a variable or method to be private,
that variable or method can only be accessed from
within the class



private methods also make sense, e.g. digest()
If you declare a variable or method to be public, then
any code anywhere can access it
Typically, a class or object has both


Methods for use by the rest of the program
Methods and variables that it alone should control
Levels of access


private -- access only from within the class
“package” -- access from within the class, or from
any class in the same directory (“folder”)



This is the default; there is no package keyword
protected -- access from within the class, or from
within any subclass, or from any other class in the
same directory
public -- access from anywhere at all
Levels of access, II

To make a variable or method visible





Only within this class: private
From this class and its subclasses: not possible
From this class and its subclasses, and any other class in
this directory: “package” (default)
From this subclass and its subclasses, and any other
classes in this directory: protected
From anywhere: public
Getters and setters

One way to control access is via getters and setters:
class Rabbit {
private double hunger;
// getter
public double getHunger() {
return hunger;
}
// setter
public void setHunger(double hunger) {
this.hunger = hunger;
}

This seems silly, but it’s much safer and more flexible
Immutable objects

Suppose a Planet has a mass, and you want to be able to
see its mass but not change it:
class Planet {
private long mass;
// Constructor
Planet(long mass) {
this.mass = mass;
}
//getter
long getMass() {
return mass;
}
// Notice there is no setter!
}
The End