Object Oriented Programming

1. Object Oriented Programming Chapter 13

2. 13.1: Abstract Data Types • Imperative program design is based on functional decomposition, which systematically refines the problem into smaller and smaller parts until the functions are small enough to represent in primitive language statements. • Procedural or functional abstraction: programmers think about the program in terms of function interfaces and functionality (what does it do?)

3. Data Abstraction • Extends the idea of procedural abstraction to the data • Abstract data type: a set of values, and the operations that can be performed on them. • ADT: provides encapsulation for new data types

4. Encapsulation - Definition • Encapsulation is a mechanism which allows logically related constants, types, variables, methods, and so on, to be grouped into a new entity. • Encapsulation mechanisms limit the scope and visibility of data and functions. Examples: procedure, packages, classes.

5. History • Today, OO programming is the preferred way to implement encapsulation. • Objects aren’t new – Simula 67, Smalltalk-76 and Smalltalk-80. • Other methods include …

6. Encapsulation Mechanisms • C: (13.2-13.3) Header file + implementation file • Modula 2: Modules – definition and implementation • Ada: (13.4-13.5) Package – definition and implementation

7. Abstract Stack Designs/Fig 13.2 • Figure 13.2, 13.3: primitive version of ADT • Encapsulates data and operations for an integer stack • Linked structure, composed of value/pointer nodes • Header + implementation files. • Can’t generalize to other data types

8. stack.h header file to specify the STACK data type. A Stack Type in C Figure 13.2

9. Figure 13.3 – Implementation • Implementation file shows typical stack functions: • empty, newstack, pop, push, top • Any program that includes the header can declare variables of type STACK and use the functions in the implementation file

10. Independent Compilation ≠ADT • Now we have a stack data type and a way to dynamically declare stack variables, but… • There’s no way to prevent the client from bypassing the defined stack operations to directly access a stack variable; e.g. to search the stack for a particular value • There’s no way to generalize to other data types • Better: force stack access to be only through the interface (defined stack functions). • No inheritance, no encapsulation.

11. Objectives of Data Abstraction • Prevent public access to the underlying ADT representation and • provide a public interface to the ADT through its operations (functions) and prevent any other access; i.e., • provide information hiding by packaging data and functions together in a unit that provides access only through the defined interface.

12. Purpose • The purpose of information hiding is to protect the rest of the program from implementation changes. • Stable interface

13. Information Hiding Mechanisms • Pascal “units”, Modula “modules” and Ada “packages” support these goals. • Developers are able to prevent direct access to the underlying representation • These early versions provide encapsulation but lack other desirable characteristics.

14. Ada Packages – page 313 • Figures 13.4 & 13.5 contain the Ada specification for a generic stack. • Ada packages are similar to C++/Java class definitions • Two parts: package definition & package implementation. • Data and functions can be public or private.

15. Ada Packages • Package definition (13.4, p. 313): • Data + function declarations • Private and public (default) specification • Package implementation (13.4, p 314) • Function implementations • Package stack_pck is generic; instantiate with package int_stack is new stack_pck(element=>integer);

16. Problems with Modules, Packages, etc. • No mechanism for automatic initialization or for finalizing; e.g. open/close, memory alloc. • No simple way to extend ADT by adding new operations, modifying data characteristics, etc. (No inheritance) • Some computing paradigms (e.g. GUI-based) were not well modeled by imperative programming style

17. OO v Imperative Paradigm • Imperative: Design approach is functional decomposition + limited-feature abstract data types. • Object oriented: Design approach is object decomposition. Objects include both functions and data.

18. OO Programming/History • Simula, an early (mid to late 60’s) OO language, was developed as a simulation language • Included features for modeling the objects that participated in the simulations • Smalltalk (early 80’s) was the first language to call itself object-oriented, but concepts came from Simula.

19. Classes • Class:a type declaration which encapsulates constants, variables, and functions for manipulating these variables. • A class is itself an abstract data type and a mechanism for defining ADTs in programs. • OO languages support encapsulation and information hiding

20. Section 13.2: The Object-Oriented Model • Object: an instance (variable) of the class • Instance variables: the local variables of a class.Also called member variables, fields, … • Methods: functions that operate on objects • Local variables: variables declared in a method • Message: a request to perform an operation on an object (function call). • Client (of a class): a program or class or method that uses an object of the class data type

21. OO Languages Address the Problems That Exist in Modules • Inheritance • Allows classes to be modified and specialized, which improves reusability. • Constructors • Special methods that initialize local instance variables • Destructors • Some languages have these to finalize objects when they are no longer needed; e.g. free memory when an object’s scope ends.

22. Features of OO Languages • Program Organization • Visibility and Information Hiding • Methods and Constructors • Inheritance • Polymorphism

23. OO Program • An object-oriented program is modeled as a collection of objects that communicate with each other and the user by sending and receiving messages. • Classic example: GUI application • Objects = buttons, text areas, pull-down menus, etc.

24. Class Definition - Java public class C { private int i, j: // instance // variables public C (<params>) {<code>} // a constructor public <type> M (<params>) {<code>} // a method } //end class C

25. Class Definition – C++ class C { private: int i, j: // instance // variables public: C::C (<params>) {<code>} // a constructor <type> C::M (<params>) {<code>} // a method } //end class C

26. Object Declaration and Initialization (Java syntax) • Declare a variable as an object from the class C: (declaration)C x;No storage is allocated. • Declare & initialize a variable x that is an object from class C: (definition)C x = new C(<arguments>); • A new object is allocated on the heap and assigned values.

27. Initialization of an Object in the Heap Figure 7.6

28. Objects v. Data Structures • Objects are active, as opposed to the traditional view of data structures as entities that are acted on by functions. • A message is similar to a function call, but instead of being made by one function to another, a message may be sent from one object to another.

29. Visibility in OO Languages • Visibility characterizes the degree of information hiding attached to components (methods, instance variables) of a class. • Visibility modifiers include • Private: visible only to the current class. • Protected: visible also to a class’s subclasses &, in Java, to members of other classes in the same package (an unfortunate design decision, according to the authors) • Public: visible to any client or subclass of the class

30. Visibility in OO Languages • Friend functions in C++ can access private members of other classes. • Declared by the class it can access • Used as a stand-alone function • Usually: class data is private (information hiding) and methods public • forces clients to interface with the class through its API (interface). • If concrete implementation of data changes, client classes and subclasses aren’t affected.

31. Figure 13.8 Stack Class with Visibility Modifiers Note the inclusion of an inner class (not the same as a subclass) public class MyStack{ protected class Node { public Object val; public Node next; public Node (Object v, Node n){ val = v; next = n; } } private Node theStack; public MyStack ( ) {theStack = null;} public boolean empty ( ) { return theStack == null;} public Object top( ) { return theStack.val; } public Object pop( ) { Object result = theStack.val; theStack = theStack.next: return result; } public void push(Object v) { theStack = new Node(v, theStack); } } The MyStack class is public, the Node class is protected (visible only to subclasses.) Stack data is private, the interface is defined by the functions empty, top, etc.

32. Constructors & Other Methods • Note constructors in myStack example. • Constructors are invoked by the new operation; heap space is allocated and instance variables may be intialized • Node objects are initialized to values, • MyStack objects are initialized to the null pointer • Constructors are examples of class methods. • Not invoked through a specific object • push, pop, etc. are examples of instance methods and are invoked through an object.

33. Using the Stack • Declare a myStack object as follows:myStack s = new myStack(); • Create a stack with the values 1 and 5: s.push(1); s.push(2); s.pop(); // creates garbage s.push(5);

34. Creation of a Stack with Two Values Figure 13.7

35. Inheritance: The Class Hierarchy • Parent or superclass, child or subclass • is-a relation: a member of a subclass is-a member of the superclass • has-a relation: if class A is a client of class B, then A has-a B (has-a doesn’t reflect a subclass-superclass relationship) • Has-a relation between classes sometimes is called an aggregation: C1 is an aggregation of C2 if C1 contains objects of type C2.

36. Inheritance • If D is a subclass of C, then D can inherit from C, or acquire attributes (instance variables and methods, including constructors) from it. • In this case we may refer to C as the base class and D as the derived class. • In some languages, we say D extends C • Inheritance supports code reuse

37. Single Inheritance • Single inheritance limits a class to having only one superclass. • Single inheritance produces a class hierarchy that can be represented as a tree, with a single root. (Object, in Java)

38. Multiple Inheritance • A class may have multiple superclasses. • Inheritance from more that one parent has good features and bad. • Good: facilitates code reuse by borrowing characteristics from several parent classes • Bad: confusing. For example, what if two parent classes have a method with the same name, but different definitions?

39. Definition • A language is object-oriented if it supports (1) an encapsulation mechanism with information hiding for defining abstract data types; e.g., classes (2) virtual methods, and (3) inheritance. • A language is object-based if it allows a program to create any number of instances of an abstract data type. • You may also see the 3 characteristics listed as (1) classes, (2) polymorphism, and (3) inheritance.

40. Virtual Methods & Polymorphism • Informally, a class method is virtual if its subclasses (inheriting classes) can override the implementation in the original class. • Virtual methods allow OO languages to express polymorphism: the late binding of a call to one of several different implementations in an inheritance hierarchy.

41. Kinds of Polymorphism • Parametric polymorphism: a function is defined as a template or generic. • Apply the same operations, in the same way, to different types • In subtype polymorphism, virtual (polymorphic) functions can also be applied to variables of different types, but the functions themselves behave differently. • Also called inclusion polymorphism because it’s a result of inheritance & sub-typing. • Function or operator overloading is sometimes called ad hoc polymorphism.

42. Templates • A template defines a family of classes parameterized by one or more types • Example: collection classes such as lists, stacks, queues, hash tables. • A list can have members from different types: list of integers, list of strings, etc. • Templates are also called generics. • Function code is written without any reference to types.

43. (sub-type) Polymorphism • Polymorphic functions have different implementations, depending on the subclass, but all have the same general purpose. • In a way, polymorphism is a form of information hiding – makes it possible to specify a general kind of behavior, and worry about details later (when subclasses are defined)

44. Example: Class Hierarchy Drawable paint() Ellipse Circle Triangle Square The class “Drawable” has several subclasses, each of which has its own version of the paint function. A list (myList) of drawable objects is maintained. To draw each object: for(Drawable obj : myList) // uses the appropriate paint method obj.paint();

45. Principle of Substitutability • A subclass method is substitutable for a parent class method if the subclass’s method performs the same general function • E.g. “draw” – but note that it is the same function only in an abstract sense. • This is the essence of polymorphism in OO languages.

46. Abstract Classes • Abstraction is an essential feature of computer science. It is a way of filtering out specific details in order to focus on a few important concepts. • In OO programming, abstract classes support this design mechanism.

47. Abstract Class • An abstract class is one that is either declared to be abstract or has one or more abstract methods. • An abstract method is a method that contains no code beyond its signature. • signature = prototype • It’s not possible to instantiate an object from an abstract class.

48. An Abstract Class • An abstract class can represent an abstract concept. Example:Clite Expression • Abstract syntax rule: Expression = VariableRef | Value | Binary | Unary • A Java implementation includes an abstract class Expression with subclasses Variable, Binary, Unary, Value.

49. Fig. 13 Clite Expression as an Abstract Class Expression (abstract) display Unary display Value Binary display Variable display FloatValue display CharValue display BoolValue display IntValue display

50. Java Interfaces • Encapsulate a collection of constants and abstract method signatures. An interface may not include either variables, or constructors, or nonabstract methods. • Declared like an abstract class, except with the word interface. ( public interface Map {…} ) • All methods in an interface are abstract & must be implemented by any class that implements the interface.