1 / 15

Scope And Lifetime

Scope And Lifetime . Material Borrowed from Nan Schaller. this. this is a final variable that holds a reference to the object in which it exists (i.e., this IS a reference to the current object) The type of this is the reference type of the object

Download Presentation

Scope And Lifetime

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Scope And Lifetime Material Borrowed from Nan Schaller Scope and Lifetime

  2. this • this is a final variable that holds a reference to the object in which it exists (i.e., this IS a reference to the current object) • The type of this is the reference type of the object • It is sometimes necessary to pass a reference to the current object as a parameter to another method. • this may also be used to refer to another constructor of the same class. Scope and Lifetime

  3. Example –thisas a reference type • Remember that when a class is constructed, the writer of the class has no way to know the name of any objects that will be declared of that class. • In some cases, we need a way to refer to the current object. • In addition, we might want to use a variable name, such as x and y in our Point class in a couple of different ways, such as instance variable names and in parameter lists … • Enter this Scope and Lifetime

  4. Example –thisas a reference type x y • We were very careful in our Point class to name the parameters of this Point constructor as nextX and nextY. • This was because we would otherwise have a problem writing the inside of the constructor, e.g., x = x; y = y; … // Instance Variables private double x; private double y; … public Point( double nextX, double nextY ) { x = nextX; y = nextY; numberOfPoints = numberOfPoints + 1; } … • x = x; • y = y; AARGH!!! Scope and Lifetime

  5. Example –thisas a reference type • Notice that this can help us! • It gives a way to refer to the instance variables for the current object. • In this case, this is the name of the current object! … // Instance Variables private double x; // X coordinate of the Point private double y; // Y coordinate of the Point … public Point( double x, double y ) { this.x = x; this.y = y; numberOfPoints = numberOfPoints + 1; } … Notice that the identifiers x and y are the nearest declared x and y! Scope and Lifetime

  6. Example –thisas a constructor • We may run into a similar issue when talking about constructors of a class. For example…. • The initial state of an object might involve providing initial values to a large number of variables representing the state of that object. • Sometimes, the only difference in what happens from one constructor to another affects a limited number of those variables. • It would be nice to be able only write the code once, especially as this limits the possibility of error while maintaining that code! • Therefore, it would be handy if we could invoke another constructor inside the same class. However, if we invoked it normally, we’d get more storage for the same object! … • Enter this Scope and Lifetime

  7. Example –thisas a constructor • In our original Point class we had three constructors which we wrote individually public Point( ) { x = 0.0; y = 0.0; numberOfPoints = numberOfPoints + 1; } public Point( double nextX, double nextY ) { x = nextX; y = nextY; numberOfPoints = numberOfPoints + 1; } public Point( Point otherPoint ) { x = otherPoint.x; y = otherPoint.y; numberOfPoints = numberOfPoints + 1; } Scope and Lifetime

  8. Example –thisas a constructor • Notice what we can do with this – particularly helpful if we have lot’s of stuff to do in the constructor! public Point( ) { this( 0.0, 0.0 ); } public Point( double nextX, double nextY ) { x = nextX; y = nextY; numberOfPoints = numberOfPoints + 1; } public Point( Point otherPoint ) { this( otherPoint.x, otherPoint.y ); // orthis( otherPoint.getX(), otherPoint.getY()); } • If you use to refer to another constructor, it must be the first statement in the constructor Note this alternative! Scope and Lifetime

  9. Scope and Lifetime • Scope • A variable’s scope is the region of a program within which the variable can be referred to by its simple name. • Scope determines when the system creates and destroys memory for the variable. • Questions to ask yourself about scope: • What variables are known where? • When does memory for each variable get allocated? • How long does the variable exist? • How do we have to name the variable to access it? • We’ve already been dealing with some aspects of scope • Talking about writing methods in “library” classes • The use of this • Declaring the counting variable in a for loop • Parameter passing examples Scope and Lifetime

  10. Instance/ class variable/ constant Scope Method parmeter Scope counter variable Scope Local variable Scope public class MyClass { … instance/class variable/constant declarations … public void aMethod ( method parameters ) { local variable declarations … for ( int counter; …) { … } …. } … } Scope and Lifetime

  11. Scope and Lifetime: Some General Rules • The same identifier may be used once within each scope • Thus, a class can contain more than one identifier with same name, e.g. • In different methods • As parameters • As local variables • As instance variables and parameters (=> the need for this!) • As instance variables and local variables (=> the need for this!) Scope and Lifetime

  12. Scope and Lifetime: Some General Rules • To know which variable is represented when using its simple name • Look within the closest enclosing scope first to see if that variable is declared there. • If not, look at the next closest enclosing scope • Etc. • When writing code, you may need to qualify a particular identifier to access it, e.g., • this.x, • otherPoint.x, The name before the point helps us uniquely identify which x we want to use. Scope and Lifetime

  13. Scope and Lifetime: Some General Rules • The memory for a variable is allocated when it is declared, e.g. • Memory is allocated for method parameters at the time the method is invoked • Local variables in methods are allocated when the method is invoked • Memory for counter variables declared in for loops is allocated when the for loop is executed. Scope and Lifetime

  14. Scope and Lifetime: Some General Rules • The lifetime of a variable is the duration of execution of the code in the scope it is in, e.g. • Memory is deallocated for method parameters when the execution of a method is complete • Memory is deallocated for local variables in methods when the execution of a method is complete • Memory is deallocated for counter variables declared in for loops when execution of the for loop has completed. Scope and Lifetime

  15. Scope Example • Very confusing example where a lot of things are named the same • http://www.cs.rit.edu/~ncs/Courses/cs1/Scope/ • Same example where with no duplicate names • http://www.cs.rit.edu/~ncs/Courses/cs1/Scope2/ Scope and Lifetime

More Related