Data Attribute Scope and Visibility

CIS-260 Home http://www.c-jump.com/bcc/

Data Attribute Scope and Visibility

Data Attribute Scope and Visibility
Attribute Visibility
Local Attributes
Method scope and attribute names
Object Attributes
Number class example
Class-level Attributes

1. Data Attribute Scope and Visibility

Recall that class is a blueprint of an object.
Therefore, multiple instances of an object of the same class can be instantiated.
Each instance occupies its own memory
Each instance has its own identity.
However, we also might need memory that is shared by all objects.

2. Attribute Visibility

State of an object is determined by current values stored in the data attributes
The attributes can have the following levels of visibility:
- Local attributes
- Object attributes
- Class attributes
Scope of an attribute is visibility combined with the type of memory allocation of the attribute.

3. Local Attributes

Local attributes are invisible outside of the scope of an operation.
Scope of operation is defined by execution entering /exiting the operation.
Lifetime of local attribute is limited to the duration of a call.

In Java and C++ scope is delineated by pairs of matching curly braces: { }


// Java code:
 public class Number {
    public void method1() {
        int count;
    }
    public void method2() {
    }
}

4. Method scope and attribute names

Consider:


public class Number {
    public void method1() {
        int count;
    }
    public void method2() {
        int count;
    }
}

The code in this example is legal and correct.
Actual names of integer variables inside method1 and method2 are unimportant, because the same thread of execution can enter either of methods, but not both at the same time.
- Note: the above is true if method1 invokes method2 or vice versa.

5. Object Attributes

Some attributes should be shared by all operations of our object. For example,


public class Number {
    // available to all methods:
    private int count;
    public void method1() {
        count = 1;
    }
    public void method2() {
        count = 2;
    }
}

Here, attribute count is declared within the scope of the Number class.
This means that now attribute count and both methods are declared in the same scope, at the class level.
Consequently, both methods will have access to the count attribute.
Each Number object will have its own copy of the count attribute.
Both methods are modifying the same attribute in memory by setting count to a specific value.

6. Number class example

Instantiate some Numbers:


    Number number1 = new Number();
    Number number2 = new Number();
    Number number3 = new Number();

At this point we have 3 separate copies of the count attribute, because each object allocates its own recourses:
```
    number11.method1();
    number12.method2();
    number13.method1();
```

7. Class-level Attributes

It is possible to take attributes outside of instance scope.

This is done by declaring attributes static:


public class Number {
    private static int count;
    public void method1() {
    }
}

In this arrangement each instance of the Number object will share a single copy of the count attribute.