programming languages and paradigms object-oriented programming

Programming Languagesand Paradigms

Object-Oriented Programming

6/15/2005Copyright 2005, by the authors of these slides, and Ateneo

de Manila University. All rights reserved. L6: OOPSlide 2

Object-Oriented Programming

Objects, classes, fields, methods Encapsulation inheritance Abstraction and reuse Polymorphism and dynamic binding

Program units: Classes



Object

Definition: a thing that has identity, state, and behavior

identity: a distinguished instance of a class state: collection of values for its variables behavior: capability to execute methods

* variables and methods are defined in a class



Class

Definition: a collection of data (fields/ variables) and methods that operate on that data data/methods define the

contents/capabilities of the instances (objects) of the class

a class can be viewed as a factory for objects

a class defines a recipe for its objects



Instantiation

Object creation Memory is allocated for the object’s

fields as defined in the class Initialization is specified through a constructor a special method invoked when objects

are created



Encapsulation

A key OO concept: “Information Hiding” Key points

The user of an object should have access only to those methods (or data) that are essential

Unnecessary implementation details should be hidden from the user

In Java/C++, use classes and access modifiers (public, private, protected)



Inheritance Inheritance:

programming language feature that allows for the implicit definition of variables/methods for a class through an existing class

Subclass relationship B is a subclass of A B inherits all definitions (variables/methods) in A

Superclass variables, subclass objects Polymorphism and dynamic binding



Abstraction

OOP is about abstraction Encapsulation and Inheritance are

examples of abstraction What does the verb “abstract” mean?



Reuse

Inheritance encourages software reuse Existing code need not be rewritten Successful reuse occurs only through

careful planning and design when defining classes, anticipate future

modifications and extensions



Polymorphism “Many forms”

allow several definitions under a single method name

Example: “move” means something for a person object

but means something else for a car object Dynamic binding:

capability of an implementation to distinguish between the different forms during run-time



Java and C++ Comparison

Program Structure and Execution Encapsulation and Inheritance Objects, Variables, and Arrays Constructors Methods, Operators, and Binding Containers and Reuse GUI Programming



Program Structure Class definition similar in Java and C++ Java: two types of programs

application (with main() function) applet (typically embedded in a web page)

C++ a program is (still) a collection of functions

that may use objects and classes main() function serves as driver



Program Execution Java: Virtual Machine (VM)

programs: both compiled and interpreted compiler produces .class from .java VM loads .class file(s) as needed

C++: compiled, linked, and loaded modules separately compiled linked to produce executable static vs dynamic libraries



Encapsulation Enforced through access keywords

public: for interface private: to make implementation

inaccessible protected: access for subclasses only

In Java each member is prefixed with a keyword

In C++ public, private, and protected sections



Breaking Encapsulation

Possible in C++ through the friend keyword

A method or class may be declared as a friend of an existing class

Allows access to private members



Inheritance Feature that allows a class to be defined based

on another class methods and attributes are inherited

Java and C++ difference Java: public class A extends B { … } C++: class A: public B { … }

(different types of inheritance) Multiple inheritance possible in C++, not in

Java But in Java, one may implement several interfaces



Objects and Identity Questions:

How/when are objects created? What is the relationship between a

variable and an object? Difference between Java and C++

distinction between primitive (built-in) type variables and variables for objects

reference relationship between variable and actual object



Variables for Built-in Types

Variables for built-in types (C++ and Java)

int x; …x = 5;

5

X

X



Reference Variables(in Java)

Reference type variables

Button x; …x = new Button(“click”);

X

X

“click”

Button Object



Variables That “hold” Objects (in C++)

Declaration of an object variable allocates space for the object

Button x(“click”);

“click”

X



Pointers (in C++)

Variables can be explicitly declared as pointers to objects

Button *x; …x = new Button(“click”);

X

X

“click”

Button Object



Disposing ofAllocated Memory

In Java, garbage collection is automatic Memory allocated objects are reclaimed

when no variables refer to them Need to set reference variables to null

when the object is no longer needed In C++, object destruction is the

programmer’s responsibility using the delete keyword



delete in C++ There should be a delete for every new

SomeClass *x = new SomeClass(…); // … use object pointed to by x delete x; // done using object

Memory leak Occurs when you forget to delete Wasted memory Can this occur in Java?



Object Construction

Constructor place where you include code that

initializes the object Default Constructor

no additional info required User-defined Constructor

with parameters that specify values or sizes



Arrays

int x[20]; Button b[20]; Valid declarations in C++, not in Java Creates 20 ints and 20 Button objects

In Java, Declaration and array creation separate For object arrays, individual object

creation necessary



Pointers and Arrays

In C++, there is a close relationship between pointers and arrays

Instead of int x[20]; can issueint *x; x = new int[20];to allow for dynamic allocation Usage of the array (e.g., x[3] = 5;)

identical in both cases To deallocate, use delete [] x;



Constructors in Java and C++

In Java, a constructor is invoked only through the new

keyword recall that all object variables are references

In C++, a constructor is called upon variable

declaration, or explicitly through new with pointers, or in other situations

other types of constructors



C++ Destructor

Special method whose signature is a ~ followed by the name of the class e.g., ~SomeClass();

Particularly if the class contains pointers and the constructor contains calls to new, a destructor needs to be defined e.g., SomeClass() { A = new int[20]; }

~SomeClass() { delete [] A; }



C++ Control Over Copy and Assignment

In C++, the semantics of “a = b” (assignment) can be specified by defining the copy-assignment

operator In C++, there is a copy constructor

specifies what happens during object copying, e.g., when function parameters are passed

There is more low-level control shallow copy vs deep copy



Methods Defines object behavior Static methods vs instance methods Method overloading

within class, two methods with the same name but different signatures

Method overriding same signatures across different classes

(subclass and superclass)



Operators

In C++, operators like =, +, *, ==, etc. can be defined, just like methods

Example: class Matrix {

// ... Matrix operator+(Matrix m) { … } // …}

c = a + b; // equiv to c = a.operator+(b);



Method Binding Let Teacher be a subclass of Employee

Also, suppose promote() is a method defined in both classes

Employee variables can refer to Teachers In Java, Employee e; … e = new Teacher(); In C++, Employee *e; … e = new Teacher;

e.promote() (or e->promote() ) calls which promote() method?



Static vs Dynamic Binding In C++, Employee’s promote() is called

Determined at compile time and deduced from the type of the variable (static binding)

In Java, Teacher’s promote is called Determined at run-time because the actual

type of the referred object is checked then (dynamic binding)

* C++ uses virtual functions for dynamic binding



Static Binding Pointer is typed to know the base class and

is ignorant of the structure or existence of the derived classes

If the virtual keyword is NOT used, if a derived class has its own variation on the implementation of a base class member function, it will NOT cause the derived class version to be selected when a function is invoked on an object of than class through a variable declared in terms of the base class.



Another exampleclass Employee{public: double salary() {return sal;} double computeRaise() {return 25;} Employee(double salary) {sal = salary;}private: double sal;};

class Manager: public Employee

{public: double computeRaise() {return 100;} Manager(double

Salary) : Employee (salary)

{}};



Sample continued

Driver Code:Manager * boss1 = new Manager(2000);double boss1Salary = boss1->salary(); // 2000Employee *boss2 = new Manager(2300);double *boss2Salary = boss2->salary(); //2300double boss1Raise = boss1->computeRaise(); //

100double boss2Raise = boss2->computeRaise(); // 25



C++ Run Time Binding

If the intent is for the selection of the function to be determined by the object’s class, not by the declaration of the pointer used to address it: Declare some base class members to be

virtual If virtual, the compiler will deposit the

“type field” of the class in the object



Virtual Functions

Base class usually defines a body for a virtual function.

Inherited by derived class as default if it chooses not to override the implementation

Virtual keyword in function declaration, not in definition



Containers Examples: Lists, Stacks, Files, etc. Structures that “contain” elements Often, the element’s type has little or

nothing to do with the containers’ operations

Possible room for re-use unified container code for a stack of

integers, a stack of webpages, a stack of strings, ...



Java and the Object Hierarchy

All classes extend the Object class: A variable of class Object can refer to any

Java object Example:

public class Stack { Object A[]; int top; // … void push(Object elt) // ...}



C++ and Templates Templates allow for a generic definition

parameterized definition, where the element type is the parameter

Example: template<class T>

class Stack<T> { T A[MAX]; int top; public: void push(T element) // …}



C++ Templates <class T> indicates that a template is being

declared T is the type name (can be a class) Usage example:

Stack <int> iStack; Stack <Cards> cStack;

where Cards is a user defined class A type used as a template argument must

provide the interface expected by the template



Defining a Template

When defining a template member outside of its class, it must be explicitly declared a template

Example template <class T> Stack<T>::Stack()



C++ Standard Containers Vector : 1-D array of T list : double linked list of T dequeue : double-ended queue of T queue : queue of T stack : stack of T map : associative array of T set : set of T bitset : set of booleans



GUI Programming In Java, GUI is part of its development kit

java.awt.* is a collection of classes that support visual programming and graphics

visual objects (buttons, text fields, etc), layout managers, events, etc.

In C++ not part of the language libraries dependent on platform (e.g., MFCs

and Motif)

programming languages and paradigms object-oriented programming

Documents