Lecture 11 : Classes and Inheritance II

Controlling Access to Members of a Class

One of the benefits of classes is that classes can protect their member variables and methods from access by other objects.
You'd like to be able to protect variables and methods at the language level and disallow access by objects of another type. example, in our BankAccount example. You don't want user to change the name. And saving can only be changed through withdraw method and deposit method. So both name and saving are declared private .
In Java, you can use access specifiers to protect both a class's variables and its methods when you declare them.

Lets look at private and public

Private

The most restrictive access level is private.
A private member is accessible only to the class in which it is defined.

To declare a private member, use the private keyword in its declaration. The following class contains one private member variable and one private method:

class Alpha {
    private int iamprivate;
    private void privateMethod() {
        System.out.println("privateMethod");
    }
}

Objects of other types cannot inspect or modify the


iamprivate

variable and can't invoke

privateMethod.

For example, the Beta class defined here:

class Beta {
    void accessMethod() {
        Alpha a = new Alpha();
        a.iamprivate = 10;      // illegal
        a.privateMethod();      // illegal
    }
}

Beta class cannot access the iamprivate variable or invoke privateMethod on an object of type


Alpha

because Beta is not of type Alpha .

You will get compiler error message

Beta.java:9: Variable iamprivate in class Alpha not 
accessible from class Beta.
        a.iamprivate = 10;     // illegal
         ^
1 error

and

Beta.java:12: No method matching privateMethod()
found in class Alpha.
        a.privateMethod();         // illegal
1 error

The following code is legal

class Alpha {
    private int iamprivate;
    boolean isEqualTo(Alpha anotherAlpha) {
        if (this.iamprivate == anotherAlpha.iamprivate)
            return true;
        else
            return false;
    } 
}

Objects of the same type have access to one another's private members. This is because access restrictions apply at the class or type level (all instances of a class) rather than at the object level (this particular instance of a class).

public

Any class has access to a class's public members.

example

public class Alpha {
   public int iampublic;
   public void publicMethod() {
       System.out.println("publicMethod");
   }
}

and


public class Beta {
    void accessMethod() {
       Alpha a = new Alpha();
       a.iampublic = 10;       // legal
       a.publicMethod();       // legal
    }
}

Understanding Instance and Class Members

When you declare a member variable such as aFloat inMyClass:
```
class MyClass {
    float aFloat;
}
```
you declare an instance variable.
You can access an object's instance variables from an object.
Instance variables are in contrast to class variables (which you declare using the static modifier). The runtime system allocates class variables once per class regardless of the number of instances created of that class.
Methods are similar: Your classes can have instance methods and class methods.
Use plain English, instance members are belong to the object. Class members are belong to the whole class.

Example:

You want to create a Student class with an instance variable name
In addition to it, you want to have an integer to record the number of students you created. What is the output of the program?

public class Student {
   private String name;
   private int numOfStudents;
   public Student(String name) {
       this.name = name;
       // increase the number of students by 1
       numOfStudents++;
   }
   public String getName() {
       return name;
   }
   public int getNumOfStudents() {
       return numOfStudents;
   }
   
   public static void main(String[] args) {
       Student Amy, Ben, Charles;
       Amy = new Student("Amy");
       Ben = new Student("Ben");
       Charles = new Student("Charles");
       System.out.println(Charles.getNumOfStudents());
   }
}

Output

The output of the program is 1! Not the 3 we expected.
In our program, numOfStudents is assigned to be 0 implicitly since we don't explicitly assign the value to it.
Every time you create a new Student, all its variables will initiate according to the constructor, so the variable
numOfStudents is 0++ = 1 after you create the object.

We should change the lines

private int numOfStudents;
public int getNumOfStudents();

private static int numOfStudents; 
public static int getNumOfStudents();

After the change numOfStudents is a class memeber and


getNumOfStudents()

is a class method.

New program

The output of the program is 3.

public class Student {
    private String name;
    private static int numOfStudents;
    public Student(String name) {
	this.name = name;
	// increase the number of students by 1
	numOfStudents++;
    }
    public String getName() {
	return name;
    }
    public static int getNumOfStudents() {
	return numOfStudents;
    }
    
    public static void main(String[] args) {
        Student Amy, Ben, Charles;
	Amy = new Student("Amy");
	Ben = new Student("Ben");
	Charles = new Student("Charles");
	System.out.println(Student.getNumOfStudents());
    }
}

`static`

You can, when declaring a member varible (method) , specify that the variable (method) is a class variable(method) rather than an instance variable (method).
To specify that a member variable is a class variable, use the static keyword.
example private static int numOfStudents; and public static int getNumOfStudents()
The system creates a single copy of a class variable the first time it encounters the class in which the variable is defined.
Example: numOfStudents only initiate once. The variable( method) are shared by all the objects of the same class.
The class variables (methods) are belong to the class and the public members can be accessed by
classname.variable
classname.method(argruments)
Example : Students.getNumOfStudents() .
It can also accessed through the object.
Example : We can change the above code by charles.getNumOfStudents().

Initializing Instance and Class Members

You can use static initializers and instance initializers to provide initial values for class and instance members when you declare them in a class:
```
class Classroom {
    static final int MAX_CAPACITY = 10;
    boolean full = false;
}
```
Sometimes, it even works when creating arrays and objects.

One more example for using static

public class MyMath {
    // define a constant PI
    public static final double PI = 3.14;
    public static double areaOfCircle(double radius) {
	return PI*radius*radius;
    }
}

Here is the test program

public class MyMathTest {
    public static void main(String[] args) {
	double radius = 5;
        System.out.println("PI is " + MyMath.PI);
	System.out.println("The area of circle with radius = " + radius +  
                           " is "  + MyMath.areaOfCircle(radius));
    }
}