MT311 (Oct 2007) Java Application Development Variables – binding, type, and scope Expression Tutorial 6

Tutor Information Edmund Chiu (Group 2) Please begin your subject with [MT311] Webpage:

Part I Variable Attributes

Variables There are six attributes of variables – Name – Address – Value – Type – Lifetime – Scope

Variable Name The issues affecting your choices of names – Maximum length of a name: Short names reduce readability Example: access_level is better than acclvl – Connector characters: You may use _ in names to increase readability in some language. You may also use different case if the language is case-sensitive. Example: access_level, accessLevel is better than accesslevel – Case sensitivity: If Edge and edge are different variables, it is easy to be confused – Reserved words / keywords: Too many reserved words makes the program hard to write

Advantages and Disadvantages of No Reserved Word If there is no reserved words for very common keyword (e.g. IF), it will be very difficult to understand a program if the keyword is used as a variable. If there is no reserved words, – programmer does not have the problem in using an identifier that has been reserved – when a language is extended, the new reserved words may have been used in old program. The existing code may no longer valid.

Variable Name Limit in Different Languages

Address The location of memory space for a variable, sometimes called l-value The time when this address is fixed is called the address binding time, which may be – load time, during the program is loaded into the memory – run time, when a specific statement is executed

Type Type specifies the range of possible values of a variable Primitive data types are defined when the language is designed. User defined types are defined by users when a program is written.

Value Value of a variable is the contents of the memory address associated with the variable (r-value) Some languages do not check whether the value stored in a variable is within the valid range – it sacrifices the reliability for the efficiency

Lifetime and Scope The lifetime of a variable begins when memory space is allocated to the variable The lifetime ends when the space becomes unavailable The scope of a variable is the range of statements in which the variable can be referenced

Example of Lifetime and Scope abc in class A starts its lifetime when the class is created and ends when it is destoryed Scope of abc in class A is all statements. In methodB, if abc of classA is referenced, we use this.abc abc in methodB starts its lifetime when the method is invoked and ends when it is returned Scope of abc in methodB is the statements in methodB only class A { int abc; // main... public void methodA(int a) { abc = a; } public void mehtodB(int a) { int abc = a;... }... }

Part II Type Binding and Type Checking

Binding Binding refers to the association between: – an attribute and an entity association of type to a variable – type binding association of address to a variable – address/storage binding – an operation and a symbol (association of meaning to a symbol)

Binding Time Binding time can happen at any of the following time – Language design time E.g., meaning of operation is defined when the language is designed – Language implementation time E.g., different compiler may have different implementation of a type such as different range – Compile time type of a variable is usually bound when the program is compiled – Link time the relative address of a function is bound when the program is linked in C. – Load time the absolute address of a function is bound when the program is loaded

Binding Time (cont'd) – Run time Local variables in a function are usually bound during the function is invoked In general, we can have two types of bindings – Static binding binding occurs before run time and remains unchanged throughout the program execution – Dynamic binding binding occurs during run time and may be changed during program is executed

Static Type Bindings In many programming languages like C, Pascal, Fortran and Cobol mainly uses static type binding – The data type of a variable is defined using either explicit declaration or implicit declaration – The compiler will bind the data type to a variable when the declaration statement is read – The data type will not be changed throughout the whole program execution An advantage of static type binding is that the type of a variable is known at compile time and thus the compiler can detect errors due to incompatible types

Dynamic Type Binding Some other languages like APL and SNOBOL4 use dynamic type binding – the data type of a variable is determined at run time by the interpreter – the data type of the variable can be changed during the execution of the program Advantage – Generic subroutines can be written – the same subroutine can support different data type Disadvantage – type checking mechanism of static type binding cannot be used – this makes the running cost very high

Storage Bindings and Variable Lifetime The lifetime of a variable is the time during the variable is bound to a specific memory location – It begins when the memory location is allocated to the variable and ends when the memory location is deallocated Four categories of variables can be distinguished according to their lifetime – Static variables – Stack dynamic variables – Explicit Heap dynamic variables – Implicit Heap dynamic variables

Static Variables They are bound to specific memory spaces when they are loaded into the memory before the program execution begins They remain bound to the same memory location until program execution ends In Java, all static attributes of a class are static variables Static variables are efficient and accessible throughout the whole program However, it reduces the flexibility and cannot be used for recursive subroutines. It also takes up the storage in the memory and makes it not sharable for other usage

Stack-Dynamic Variables They are bound to storage at run time when their declaration statement are elaborated (reached) The memory for stack-dynamic variables is allocated from the run-time stack Type is statically bound to the variable In Java, local variables of primitive types are stack dynamic Stack-dynamic variables support recursive subroutine and helps in reusing the delloacted memory spaces

Explicit Heap-Dynamic Variables The storage is allocated and deallocated by using system functions in a program – C uses alloc/malloc and delete – Java uses "new" keyword (no explicit deallocation, done by garbage collection) – The memory is usually allocated from the heap – The variables are usually called pointer/reference In Java, object variables are explicit heap-dynamic variables Explicit heap-dynamic variables are usually used for dynamic structure, but pointers and references are usually more difficult to use. The cost of allocation/deallocation is also a consideration

Implicit Heap-Dynamic Variables The storage, type and values are all bound at runtime only when the variables are assigned values. Implicit heap-dynamic variables give the highest degree of flexibility The runtime overhead of maintaining all dynamic attributes are very high. The error detection (e.g. type checking) by compiler is difficult if not impossible

Type Checking Type checking is the activity of ensuring the operands of an/a operator/function are of compatible types – Type error will occurs is inappropriate type is used in a parameter of a function where type checking has not been done for the parameter. If a language has only static type binding, the type checking process can nearly be done by the compiler (static type checking) Dynamic type checking is much more expensive and complicated – Example: C++ union requires dynamic type checking

Strong Typing A language is strongly typed if all type errors is always detected, either in compile time or at run time – C, C++, FORTRAN and COBOL are NOT strongly typed – Java, Pascal and Ada are nearly strongly typed Some languages will convert one or all operands to a different type to make them compatible in an operation. We call this conversion a coercion – Too few coercion may make the language less flexible – Too many coercion make it hard for the compiler to detect programming errors and weakens the purpose of having a strongly typed language

Type Compatibility Different languages have their rules to decide which data types are mutually compatible Two fundamental rules for type compatibility – Name type compatibility Two variables are of the same type only if they are declared with the same type name. – Structure type compatibility Two variables are of the same type if they are of the same structure.

Example of Type Compatibility If using name type compatibility, only A and B are of same type If using structure type compatibility, all three variables are of the same type type arraytype1 = array [1..10] of integer; arraytype2 = array [1..10] of integer; var A,B: arraytype1; C: arraytype2;

Comparison of Type Compatibility

Type Compatibility (cont'd) Few programming languages use strict name or structure type compatibility. – Pascal use a slight variation of name type compatibility called declaration equivalence – a programmer may define if a type is equivalent to another type – C uses a variation of structure type compatibility – name type compatibility is used for union and struct types – Ada uses a variation of name type compatibility but provides subtypes (compatible with parent type) and derived types (not compatible with parent type).

Scope Scope of a variable is the range of the statements in which the variable can be referenced – In static scoping, the compiler determine the scope of each variable by inspecting the program – In dynamic scoping, the scope of variables can only be determined at runtime. The calling sequence of the subprogram will affect the scope of a variable.

Part III Variable Scope and Lifetime

Static Scope In static-scoped languages with nested subprograms, a reference to a variable is found in this way: – Local variable will be searched first – If the variable is not found, we search the program that defines the subprogram (static parent) – If the variable is still not found, we continue to the program that defines that program (static ancestor) until the outermost program is searched – Example (see next page): sub1 is the static parent of sub2 and big is the static ancestor of sub2 – Y is not declared in sub2, y of sub1 will be used in sub2 In C and Java, – We needed to find the local and global/instance variables only in C/Java – Variables in blocks are local to the block itself.

Scope Example procedure Big; var y : integer; procedure sub1; var x, y : integer; procedure sub2; var x : integer; begin x := 1; y := 2; end begin... end begin... end

Dynamic Scope When using dynamic scoping, the reference to the variables are determined by the calling sequence of the subprograms – Assume the in Big, we call Sub2, y in Sub2 is then referring to the y in Big instead of that of Sub1 because it is Big who call Sub2 – If there are no y in Big, we will need to see if the program that call Big provides integer y – Thus, when using dynamic scoping, there is a chance that we are referring a different variable even we are calling the same subprogram

Disadvantages of Dynamic Scoping Dynamic scoping is less reliable because all local variables of the calling subprogram are visible from the called program. That makes information hiding impossible The compiler cannot check type compatibility because it does not know where a non-local variable is declared Referencing non-local variables is more expensive The program is more difficult to read because the identity of a non-local variable is difficult to trace by just reading the program source code

Scope and Lifetime Scope and lifetime are not always related – Static variables in C and C++ is statically bound to the scope of the function but their lifetime extends over the entire execution of the program – A variables scope is also not extended to the called subprogram but the lifetime of the variable extends over the time during the subprogram is executed and will be accessed again after the subprogram ends its execution

Referencing Environments The referencing environment is just the other side of mirror of the scope concept – We look from the point of view of a program statement and lists out the collection of all variables that are visible in the statement – Variables that are defined in both caller and called subprogram will have the variables in the caller program temporarily hidden

Example in Referencing Environment (Static Scope) procedure Ex is A, B : Integer;... procedure Sub1 is X, Y : Integer; begin { Sub1 } POINT 1 end; procedure Sub2 is X : Integer;... procedure Sub3 is X : Integer; begin { Sub 3 } POINT 2 end; begin { Sub 2 } POINT 3 end; begin { Ex } POINT 4 end. If static scoping is used, the referencing environments are – At point 1: x and y of Sub1, A and B of Ex – At point 2: x of Sub3 (X of Sub2 is hidden), A and B of Ex – At point 3: X of Sub2, A and B of Ex – At point 4: A and B of Ex

Example in Referencing Environment (Dynamic Scope) void sub1() { int a, b;... // POINT 1 } // end of sub 1 void sub2() { int b, c;... // POINT 2 sub1(); } // end of sub 2 void main() { int c, d;... // POINT 3 sub2(); } // end of sub3 If dynamic scoping is used, the referencing environments are – At point 1: a and b of sub1, c of sub2, d of main c of main and b of sub2 are hidden – At point 2: b and c of sub2, d of main c of main is hidden – At point 3: c and d of main

Part IV Data Types

Primitive Data Types Nearly all programming languages provide a set of primitive data types – This is the building block of user-defined data types The common primitive data types – Numeric types includes integers, floating point numbers, and sometimes decimal types – Boolean types – usually one byte instead of one bit for efficient access – Character types C is a special language that the differences among these types are very vague – No boolean type and integer and character types are interchangeable – Flexible (writability ) but type checking mechanism is defected (reliability )

Character String Types When designing a String type, we need to consider: – Should a String be array of characters or a primitive data type? – Should strings have static or dynamic length? Dynamic length strings require more complex storage – the storage for a string will grow and shrink dynamically Limited dynamic strings do not need runtime descriptor – What operations are allowed for a String?

Character String Types in Common Languages C/C++ uses char arrays (limited dynamic length) to store character strings – An end of string character (\0) is placed at the end of the String – operations are provided through a standard library Java supports String through the String class (constant strings) and StringBuffer class (changeable strings, like array of characters) Fortran 95 treats strings as a primitive data type – Assignment, relational, catenation and substring operations are available

User-Defined Ordinal Types Enumeration type (C/Pascal) – Increase readability and reliability (if the enumeration type limits the value stored in the variable) – All possible values (named constants) are provided in the definition – In C, these enumeration constants are implicitly assigned the integer values, or explicitly assigned other values – variables accepting such type will then accepts any integer value Subrange type (Pascal/Ada) – A contiguous subsequence of an ordinal type – Subrange types require the compiler to generate range- checking code for every assignment to a variable

Array Types Issues in arrays – Array indexes (subscripts) if enumerated types are used in subscripts, it is more readable and reliable Also, if the index range is checked implicitly (e.g., in Java), it will also be more reliable – Subscript range bound Lower bound of range in C-based languages are 0. Some other languages fixed it at 1. – Initialization at storage allocation – increase writability – Multi-dimension array – rectangular/jagged – Array with no subscript bounds (unconstrained array) useful in defining methods, but not used in C (pointer access)

Array Categories Static Array – Subscript range is statically bound – Storage allocation is static (done before runtime) Fixed Stack-Dynamic Array – Subscript range is statically bound – Storage allocation is done at declaration elaboration time – More space efficient than static array Stack-Dynamic Array – Subscript range is dynamically bound and storage allocation is dynamic done during runtime – However, once the range and storage are bound, they remain fixed during the lifetime of the variable

Array Categories Fixed Heap-Dynamic Array – Similar to fixed stack-dynamic, but range is dynamically bound – Like stack-dynamic array, range and storage are fixed once bound Heap-Dynamic Array – Binding of both subscript ranges and storage allocation is dynamic and can be changed freely during the arrays lifetime

Addresses of Array Elements The address to reference an array element in a one- dimensional array – Address(arr[k]) = address(arr[0]) + k * element_size In a multi-dimensional array, the storage is actually done in a one-dimensional way – Different formula will be used for row major order and column major order array – For row major order address(arr[i,j]) = address(arr[0,0]) + i * col_in_row * element_size + j * element_size – For column major order address(arr[i,j]) = address(arr[0,0]) + j * row_in_col * element_size + i * element_size

Associative Arrays Associative arrays (or hash) are used in Perl and Java – Store associations of a key to a value – The associated value can be easily retrieved by using the keys (good for searching)

Record Types In C, we use struct to form record type that includes fields of variables of different types – The use of operators in C increase the writability In Java, records can be defined as data classes, with data members as the record fields To refer to the record fields, some languages allow the use of elliptical references – the record name can be skipped in reference to a field Operations allowed in record type is limited – referencing, taking the address and assignments are the typical operations Assignment to a record is sometimes done through a collection of values, e.g., rec := (ABC, 100); – Supported by Ada and C (in initialization only)

Union Types A union is a type that allows a variable to store values of different data types at different times during program execution – Allows to define heterogeneous data structures such as tree structures of integers or floating points – In Java, inheritance from a root class can do the same task and is more reliable In some languages, union is a new data type itself (C/C++). It is called a free union On the other hand, some languages limits that union must be embedded in a record type. It is called a discriminated union Type checking is difficult – it must be dynamic – If no type checking is employed, there will be assurance that the value is of the intended type

Example of Discriminated Union Type type Node (Tag : Boolean) is record case Tag is when true => Count : Integer; when false => Sum : Float; end case; end record; Address * Offset BOOLEAN Discriminated Union False True INTEGER COUNT FLOAT SUM TAGCase table Name Type Name Type

Pointer Types A pointer type is one in which the variables that contain memory addresses, or null – Null is a special value that means the pointer cannot be used to reference any memory space Pointer provides the power of indirect addressing and a method of dynamic storage management – Variables storage is bound at runtime and memory is allocated from the heap – The pointer can dereference the variable that the pointer is pointing to indirectly – Data type of the values the pointer is pointing to is usually predefined

Pointer Problem – Dangling Pointers Occurs when a pointer that contains the address of a heap- dynamic variable has been deallocated: – Pointer p1 is set to point at a new heap-dynamic variable – Pointer p2 is assigned p1s value – p1 is then explicitly dealloacted (set to null) p2 is now dangling The deallocated location my have been reallocated to some new heap-dynamic variable with different data type – type checking error occurs if the dangling pointer is used Even no type checking error occurs, the dangling pointer should have no relation to the new variable. The dangling pointer can change the value of the new heap- dynamic variable If the heap variable is used by the storage management system, it is possible that it is used as a pointer in a chain – changing the value will cause the storage manager to fail

Pointer Problem – Lost Heap-Dynamic Variables Occurs when an allocated heap-dynamic variable is no longer accessible to the user program – Pointer p1 is set to point to a new heap-dynamic variable – Pointer p1 is then set to point to another new heap-dynamic variable original heap-dynamic variable is now inaccessible – We also call the inaccessible variable garbage Languages that require explicit deallocation of dynamic variables share the above problem, which is also known as memory leakage

Reference Types Reference type is a safer version of pointer – In C++, reference types provide a two-way communication between caller function and called function without explicit dereferencing – In Java, references refer to class instances and do not allow arithmetic on references – In Java, references can be assigned to refer to different class variables. – No dangling reference will occur in Java because Java class instances are implicitly deallocated

Part V Expressions

Arithmetic Expressions In programming languages, arithmetic expressions consist of – Operators (unary – single operand, binary – two operands, and/or ternary in C -- ? : ), – Operands, parentheses, and function calls Operator Evaluation Order – Fortran: ** > *, / > all +, - > binary +, - – C-based languages: postfix ++, -- > prefix ++, -- > unary +, - > *, /, % > binary +, - – Ada: **, abc > *, /, mod, rem > unary +, - > binary +, - Associativity – Fortran: All operators are left associative except **, which is right assocaitive – C-based languages: *, /, %, and binary + - are left associative, ++, -- and unary +, - are right associative – Ada: All operators are left associative except **, which is non-associative

Example of Operator Evaluation Order and Associativity Consider the expression 3 * 4 – 5 – 6 * 2 – 7 – Using mathematical precedence and associativity ( ( (3*4) – 5 ) – (6*2) ) – 7 = -12 – If precedence of – is higher than * and left associativity is used for all operators ( 3 * ( (4-5) – 6 ) ) * (2-7) = 105 – If precedence of – is higher than * and right associativity is used for all operators 3 * ( ( 4 – (5-6) ) * (2-7) ) = -75

Operand Evaluation Order Side effects of a function makes operand evaluation order important Example: int a=9, b; b = a + a++; – In C, as no specific operand evaluation order is defined, b may become both 18 and 19 can be produced depended on hot the compiler is implemented – In Java, the operands is evaluated in left-to-right order and eliminates the above problem

Overloaded Operators The same operator can mean different operations according to situation – Example * can mean both multiplication and dereferencing in different situation in C – We call the process operator overloading Problems – Poor readability and also hard to find the error because leaving out an operand may still yield a compilable program Another usually overloaded operator is / – For floating-point and integral division

Type Conversion When the compiler finds that the operands are not of the same type, coercion (type conversion) will occur according to the language specification – In most of the common languages, mixed mode arithmetic expression is allowed without any restriction – In Java, byte and short are coerced to int whenever any operator is applied to them – Too much coercion makes errors difficult to detect, while having too few makes the language less flexible Explicit type conversion can be made – type casting – Overflow or underflow problem may occur as a result of casting

Relational Expressions Relational operator is an operator that compares the values of the two operands – ==, !=, >, =, <= – Overloading relational operators for dfifferent data type is very common Relational expression gives a boolean result

Boolean Expressions Boolean expressions consist of Boolean variables/constants, relational expressions and Boolean opeartors (AND/OR/NOT) In C, AND has a higher precedence than OR and is left associative In Ada, the two operators have the same precedence

Precedence of Operators in C-based language (highest precedence) Postfix ++, -- Unary +, -, prefix ++, --, ! *, /, % Binary +, -, = ==, != && (lowest precedence) ||

Short-Circuit Evaluation A short-circuit evaluation is in which the result is determined without evaluating all of the operands in &&/|| operators – If first expression in && is false, the second expression needs not to be evaluated – Similarly, if second expression in || is true, the second expression needs not to be evaluated Advantages – More efficient in the evaluation of the expression as sometimes there is no need to evaluate the whole expression – We can make use of the first expression to avoid evaluating the second expression when it is undefined Example: (x>0) && (log(x)>0)

Assignment Statements Simple assignment – e.g., a = 10; Conditional Targets – e.g., flag ? count1 : count2 = 0; Multiple Targets – e.g., a, b, c := d; – Increase writability and efficiency because the value needs to load to the register for 1 time only Compound Assignment Operators increases writability – e.g., sum += value; Unary Assignment Operators – e.g., - count ++; – Aware of the precedence: it should be – (count ++)

Assignment as Expression For example: while ( (ch=getchar()) != EOF) {…} – ch stores the character got from the function – The expression itself also returns a value – the left side value of the expression Increase writability and efficient because the assigned value is already in register before the assignment statement is executed However, it decreases the readability Also, the expression may return a incompatible/invalid value and make it easy to make mistake – Example: we may take if (x=y) instead of if(x==y)