Classes

1. Classes L7Class

2. Class :: Instance (Object) Static structure vs Run-time structure (Analogy -- a statue :: Lincoln Memorial) • Class :: Abstract Data Type A class is an ADT equipped with a possibly partial implementation. • Class :: Metaclass A metaclass is a class whose instances are classes. (Useful for manipulating class representations at run-time by interpreters, browsers, etc.) L7Class

3. Abstraction : Equivalence Relations • Computability • Recursive vs Non-recursive • Semantics • Behavioral Equivalence • Resource-independent interchangeability • Performance aspect irrelevant for “correctness” • E.g., Groups, Fields, Sorting, UNIX, etc • Complexity (Algorithms) • Time and Space requirements • Big-Oh (Worst-case Analysis) • NP-hard vs Polynomial-time L7Class

4. Specification of Data Types: Motivation • Precise and unambiguous description. • Sound and complete description. • Avoids over-specification. • Spec: Flexible enough to accommodate all possible implementations. • Impl.: Constraining enough to exploit representation details for efficiency. L7Class

5. Specification of Data Types: Details Type : Values + Operations Specify SyntaxSemantics Signature of OpsMeaning of Ops Model-basedAxiomatic(Algebraic) Description in terms of Give axioms satisfied standard “primitive” data types by the operations L7Class

6. ADT Table (symbol table/directory) empty : Table update : Key x Info x Table ->Table lookUp: Key x Table -> Info lookUp(K,empty) = error (Use of variable) (Alternative : Use of Preconditions) lookUp(K,update(Ki, I, T)) = if K = Ki then I else lookUp(K,T) (“last update overrides the others”) L7Class

7. Implementations • Array-based • LinearList-based • Tree-based • Binary Search Trees, AVL Trees, B-Trees etc • HashTable-based • These exhibit a common Table behavior, but differ in performance aspects. • Correctness of a client program is assured even when the implementation is changed. L7Class

8. Java approach to metaclass benefits • To make available certain features to all classes, Java defines a root class (class Object) with those features. E.g., Thread support (locks), cloning, equality check, string representation, etc • Certain class operations are given special status. E.g., creation and initialization of an object is incorporated via constructors. • Meta-programming is achieved through appropriate libraries supporting Reflection and Introspection. E.g., In Java 1.1, package java.lang.reflect. L7Class

9. Class as module and type • Module (unit of software decomposition) • Syntactic: Only affects the form of software text, not what the software can do. Separately compilable. • Type (static description of dynamic objects) • Semantic: Influences execution of a software system by defining objects manipulated at run-time. The facilities provided by a class, viewed as a module, are precisely the operations on instances of the class. L7Class

10. Example : class Point • Features/Members • Attributes/Fields (represented using memory) • Routines/Methods (represented using computation) real x-coord, y-coord; real radius, angle; real distance(Point); void translate(real x,y); L7Class

11. Feature Classification by Role No result Returns result Procedure Arguments No Arguments Function Computation Memory Routine Function Attribute (Field) L7Class

12. Feature Classification by Implementation Computation Memory Routine (Method) Attribute (Field) Result No result Procedure Function L7Class

13. Uniform Access principle • A client should be able to access a property (feature) of an object using a single notation whether the property is implemented by memory or by computation. • Eiffel : 0-ary routine f and attribute f have the same syntax. Attributes cannot be directly assigned. • Java: 0-ary method syntax is f() (not f).InSmallTalk/Java Beans, a field is accessed via getF() and/or setF(valueType) methods. L7Class

14. Object-Oriented Style of Computation • Single Target Principle • Every operation is relative to a certain object. • E.g., pt1.distance(pt2) • Current Instance • May be implicit, or referred to explicitly using a keyword such as this (Java/C++), self (Self), Current (Eiffel), etc. • Module-Type Identification L7Class

15. double distance( Point p ) { if (p =/= this) { return Math.sqrt( (x - p.x) * (x - p.x) + (y - p.y) * (y - p.y) ); } else { return 0; } } L7Class

16. Composition : Client and Supplier • A class C which contains a declaration of the form S x is said to be a client of S. S is said to be a supplier (server) of C. • x may be an attribute or a function of C, or a local entity or argument of a routine of C. L7Class

17. Qualified calls x.f or x.f() x.f(a,b,…) Unqualified calls f or f() f(a,b,…) Equivalently, this.f or this.f() this.f(a,b,…) Operators infix associativity prefix Operator definitions supported in order to be consistent with the standard mathematical notations. A * B, - 5, etc. Feature Calls L7Class

18. Selective Export and Information Hiding • Eiffel has a general mechanism to export a feature to designated clients and their proper descendants. • Java and C++ support three levels: • public : all clients. • private : (all instances of) current class. • protected: all subclasses. • Default : package wide visibility. L7Class

19. Function In-lining in C++ • Interface file ( “.h” extension ). • Contains prototype declarations, and (short) function definitions that may be in-lined. • Implementation file ( “.c++” extension ). • Contains function definitions, possibly with inline directive. • In-lining enables programmers to have benefits of encapsulation while avoiding some of the run-time costs of function invocation. L7Class

20. Genericity • Unconstrained • Type parameterized classes • Generic type : List[G] • Instantiations: List[int], List[String], List[Window], etc • Constrained • Types with operations • Constrained Genericity: Ordered, Group, etc • Java interface types. L7Class

21. type INTMAT is array ( POSITIVE range <>, POSITIVE range <>) of integer; function int_sum_all( M : INTMAT ) return integer is sum : integer := 0; begin for I in M'range(1) loop for J in M'range(2) loop sum := sum + M(I,J); end loop; end loop; return (sum); end; L7Class

22. generic type ET is private; type INDEX is (<>); ID : ET; type AR is array ( INDEX range <>, INDEX range <>) of ET; with function "+" ( X,Y : ET ) return ET is <>; function sum_all( M : AR ) return ET; function sum_all( M : AR ) return ET is sum : ET := ID; begin for I in M'range(1) loop for J in M'range(2) loop sum := sum + M(I,J); end loop; end loop; return (sum); end; L7Class