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 arent 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.
• Cant 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
• Theres 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
• Theres 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(elementgtint
  eger)

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 60s) OO language,
  was developed as a simulation language
• Included features for modeling the objects that
  participated in the simulations
• Smalltalk (early 80s) 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 objects 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 (ltparamsgt)
• ltcodegt // a constructor
• public lttypegt M (ltparamsgt)
• ltcodegt // a method
• //end class C

25
Class Definition C

• class C
• private int i, j // instance //
  variables
• public
• CC (ltparamsgt)
• ltcodegt // a constructor
• lttypegt CM (ltparamsgt)
• ltcodegt // a method
• //end class C

26
Object Declaration and Initialization (Java
syntax)

• Declare a variable as an object from the class C
  (declaration) C xNo storage is allocated.
• Declare initialize a variable x that is an
  object from class C (definition) C x new
  C(ltargumentsgt)
• 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 classs 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 arent affected.

31
Figure 13.8 Stack Class with Visibility
Modifiers

• 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)

Note the inclusion of an inner class (not the
same as a subclass)
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 doesnt 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 its 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 subclasss 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
• Its not possible to instantiate an object from
  an abstract class.

48
An Abstract Class

• An abstract class can represent an abstract
  concept.
• ExampleClite 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.

51
Java Interfaces

• A class may implement multiple interfaces, which
  allows it to appear to be many different types.
• Similar to multiple inheritance
• A class can inherit from its parent, but also
  draw features from interfaces.
• No danger of conflicting method definitions if
  the parent and interface have same-named methods
  the class is required to re-implement the method

52
Summary

• OO languages
• support encapsulation and data abstraction
  through the class mechanism
• Provides constructors
• Characterized by inheritance and sub-type
  polymorphism
• Support run-time type identification (RTTI) which
  allows an objects type to be identified at run
  time