1 / 55

Object-Oriented Concepts

Object-Oriented Concepts. A Review. Terminology. Object : A thing that exists in the domain of the problem E.g. An office building might have a number of ‘Elevators’, ‘Offices’, ‘SecurityDoors’, etc.

aerona
Download Presentation

Object-Oriented Concepts

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Object-Oriented Concepts A Review

  2. Terminology • Object: A thing that exists in the domain of the problem • E.g. An office building might have a number of ‘Elevators’, ‘Offices’, ‘SecurityDoors’, etc. • Software is object-oriented if the design and implementation of that software is based on the interaction between the objects of the domain

  3. Terminology • Class: A template used for the creation of objects • A class describes various attributes an object might have • e.g. A ‘Person’ class might have various attributes, including age, weight, height, eye colour, address, etc.

  4. A Case Study A Grocery Store

  5. A Case Study: Grocery Store • A grocery store has a number of ‘classes’ and ‘objects’ in its domain: • Shopping carts, shelves, cashiers, and various items • A shopping cart is a class or template that describes all shopping carts • Several instances of shopping carts, each with its own distinct properties, may exist in the grocery store • These shopping cart instances are objects in the grocery store

  6. Grocery Store Classes Carrier Item Bread Fruit Basket Cart Apple Orange

  7. Classes and Objects • Students often have trouble with the difference between classes and objects • ‘Apple’ in our example is a class • A grocery store may have hundreds of instances of this class • Large apples, small apples, red apples, green apples, etc.

  8. Classes and Objects • Since ‘Apple’ is a class, and a class is a template, it makes sense that you can’t eat ‘Apple’ • However, you could eat ‘an apple’, which would be an instance of an Apple • It should be obvious that, if you eat an apple, the template ‘Apple’ still exists, as well as other instances • If you eat an apple, other apples to not disappear, nor does the existence of a fruit called an Apple

  9. Classes and Objects • Thus, typically one interacts directly with class instances (objects) and not with classes themselves • In fact, in the object-oriented paradigm, any behaviour is defined using object interactions • For object-oriented software, an application is a collection of objects which interact to create software functionality

  10. Classes and Objects • Let’s examine a software example • A Menu in a graphical user interface is an example of a class • An application may have many menus (File, Edit, Help, …) • This the application may have several Menu instances (objects)

  11. Classes and Objects • The ‘Menu’ class may have several attributes: • A list of menu items • A background colour • A label (‘File’, ‘Edit’, ‘Help’) • ‘Menu’ may also have several actions that are possible: • show(): - make the menu visible • hide(): - make the menu invisible • addMenuItem(): - add a menu item to the list • setLabel(): - define the menu’s label

  12. Why Classes? • Classes evolved through the concept of encapsulation • Encapsulation means taking all related elements and packaging them inside a single unit • In everyday terms, encapsulation means that objects should be specified in such a way, that they define their own behaviour and attributes

  13. Encapsulation: Subroutines • Encapsulation was first applied to program behaviour alone • Programmers noticed that they had to repeat code that was similar or identical many times in a single program • e.g. The code to print a line of text to the monitor, the code to multiple two numbers, etc.

  14. Encapsulation: Subroutines • Eventually, programmers began placing this code into accessible areas of memory • This code would be called repeatedly • These reusable code units were called subroutines • Although modern programmers call them functions, procedures, or methods

  15. Encapsulation: Objects • The first incarnations of objects were called ‘records’ • They typically placed related information together into a single data structure • In C/C++: structs • In Pascal: records • e.g. For a person, one might group age, height, weight, address, and other information into a single record: ‘person’

  16. Encapsulation: Objects • Code that manipulated that data was kept separate • e.g. void movePerson(person p1, char *newAddr) { p1.address = newAddr; }

  17. Encapsulation: Objects • Eventually, they began placing functionality (as well as data) into a single unit • Thus, the class was born • One side effect of object encapsulation is that the data becomes somewhat irrelevant • Since the behaviour is what is important, the functionality can be achieved using data in any way possible • Thus, what data is stored, and how it is stored is irrelevant outside the object itself • Objects, in general, contain persistent data • This data ‘persists’ from one call to another

  18. Information Hiding • Usually, since the way data is stored and used in an object is irrelevant outside the object, it is kept hidden • In object-oriented systems, this data is called private data or hidden data • E.g. In Java and C++, hidden data is achieved through private class variables

  19. Implementation Hiding • Also the method in which data is manipulated to accomplish behaviour is irrelevant outside the object • The behaviour provided by an object is defined by the object’s interface • In fact, two different objects that provide the same behaviour could be used interchangeably as long as they share the same interface

  20. Interfaces • An interface is simply a description of the functionality defined by an object • An interface typically contains a list of available operations, as well as a description of the data passed in and out of these operations

  21. An Example CashRegister interface total : num enterItem() Implementation of enterItem() getTotal() Implementation of getTotal() pay() Implementation of pay() • This cash register simply keeps a running total • Likely the receipt includes only the total due

  22. An Example DetailedCashRegister interface items : List<Item> enterItem() Implementation of enterItem() getTotal() Implementation of getTotal() pay() Implementation of pay() • This cash register keeps track of all items • Likely the receipt displays all items and their prices

  23. An Example • Since the objects have identical interfaces, they could be used interchangeably • However, the two cash registers do their job differently • Both objects in this example were only accessible through their ‘interface’ • Which normally is a set of externally accessible operations and not data items themselves

  24. An Visual Idea Interface Implementation Data

  25. Classes • Let’s expand our definition of classes, to specifically refer to classes in software • Classes define everything that is common to all instances: • Definitions of member operations • The actual code is defined with the class • Declarations of data members • The data type and name of the data members is defined with the class

  26. Objects • Objects, on the other hand, contain everything that is different with each instance • The values of the data members is an example • Even though the data members are defined in the class definition, the actual memory allocated to store that data is associated with each object, not the class

  27. Objects • In addition, the member operations on a class must be associated with a specific object, so they can access member data for that specific object • There are two ways this can be done: • The member operations themselves can be defined on each object • Thus, operations are duplicated for each instance • The operations, when called, must be told which object is involved • For example, a reference or handle to the object could be passed along with the input parameters

  28. Exceptions to this Rule • Sometimes, items normally associated with an object instance, are associated with the class itself • Operations that do not access member variables or member operations • Variables that should contain the same value for all instances • When the value is changed using one instance, the value on the other instances should also change • In Java and C++, such members are called ‘static’ variables and ‘static’ operations • In other languages, they are called class variables and class operations

  29. Messages • Messages are how objects interact • Messages typically involve an object making an invocation of another object’s operation • Messages contain the following information: • A handle (or reference) of the object whose operation is to be called • The name of the operation • A number of arguments to be passed to/from the operation • This could include input parameters, output parameters, or parameters that are used for input and output

  30. Inheritance • In the previous lecture, we saw a diagram illustrating relationships between classes • One relationship classes can have is inheritance • A class A inheritsfrom another class, B, if it represents something more specific, but A is still a type of B • e.g. Apple is a type of Fruit • e.g. Notebook is a type of Computer • e.g. JPEGImage is a type of Image

  31. Inheritance • If class A inherits from class B • A is a subclass of B • B is a superclass of A • Questions: • Is it possible for a class to have more than one subclass? • Is it possible for a class to have more than one superclass?

  32. Multiple Inheritance • Multiple inheritance makes sense in the real world: • Here is an example: • Susan works at a bank, thus she is an instance of the type ‘Banker’ • Susan plays professional soccer, thus she is an instance of the type ‘SoccerPlayer’ • Possibly, SoccerPlayer is a subclass of a class called Athlete or something similar • Therefore, Susan must be an instance of some class, that is a subclass (or descendant) of SoccerPlayer and a subclass (or descendant) of Banker

  33. Multiple Inheritance • Java does not support pure multiple inheritance • A Java class can inherit from only (and exactly) one class • If none is specified, Object is assumed • A Java class can, however, implement as many interfaces as you want

  34. Multiple Inheritance • C++ classes can inherit from multiple classes • Here is an example: class A : public B, public C, public D { … }

  35. Polymorphism • While polymorphism seems simple, it creates complications for running programs • For example, look at this statement in Java: Printer printer = …; printer.print(Document doc); • Which version (on which subclass) of the ‘print’ method will be called? • It depends on the type of object stored in ‘printer’

  36. Polymorphism • Here’s another example: • There is a class called ‘Car’ which defines a method called ‘accelerate’ • One subclass of ‘Car’ called ‘AutomaticCar’ would define ‘accelerate’ in one way, while another subclass ‘ManualCar’ would define it another way

  37. Dynamic vs. Static Binding • In the example, we learned that sometimes a runtime environment must determine which version of an operation to execute at run time • This is known as dynamic binding • Normally, the operation to be executed is determined at compile time • This is known as static binding

  38. Overriding • Overriding is when a subclass defines an operation that is already defined on the superclass • Using dynamic binding, the subclass’ version of the operation will be executed when a variable contains an instance of the subclass

  39. Overloading • Overloading is a similar concept to overriding • An operation (or operator, such as +, =, …) can be defined more than once to operate on different arguments • Thus a given operation name may be reused for several operations, as long as the signature is different • An operation’s signature or template is its name, as well as the number, order, and types of its arguments

  40. Genericity • Genericity is the term applied to situations where code operates on data, whose type is unknown until run time • An example might be creating a quicksort operation which takes an array • If this operation supports genericity, the type of the objects in the array could be unknown until the program is actually run • Now, the same operation can be used to sort integers, strings, etc. by simply associating the operation with the appropriate type within the program

  41. Summary • So far, I have introduced the following vital ingredients in object-oriented development: • Encapsulation • Classes • Objects • Information hiding • Implementation hiding and interfaces • Inheritance • Messages • Polymorphism • Overriding • Overloading • Genericity

  42. Summary • To give you a foundation, I’ll now give you examples of each in some OOP languages • I will give Java examples • In some cases, Java5 will be used when a feature is not available in previous versions

  43. Encapsulation • Java, C++, and Eiffel use ‘classes’ for encapsulation • In all 3 languages, operations and attributes can be combined into a single unit • In Java: public class Person { private int age = 0; void birthday() { age++; } }

  44. Encapsulation • The spirit of encapsulation is grouping related concepts • Thus classes provide attributes to store data about an entity • Classes provide operations to manipulate the entity in some way

  45. Information Hiding • The example also uses information hiding since, the attributes are declared as private • That means that the attribute cannot be modified directly, like this: Person person = …; person.age = 14; // this is illegal

  46. Interfaces • Implementation hiding can be reinforced by using interfaces • In Java (stored in AgedEntity.java and Person.java): public interface AgedEntity { void birthday(); } public class Person implements AgedEntity { private int age = 0; void birthday() { age++; } }

  47. Inheritance • Java supports single inheritance: public class A extends B { … }

  48. Messages • Messages in Java occur in the form of method invocations • In Java: obj.doSomething(11); or person.birthday();

  49. Polymorphism in Java • Dynamic binding is automatically used in Java, so polymorphism is a natural consequence: public abstract class A { private int a = 0; abstract void doSomething(int val); } public class B extends A { void doSomething(int val) { a = val; } } public class C extends A { void doSomething(int val) { a = val * val; } }

  50. Polymorphism in Java • Consider the following lines of code: A obj = null; obj = new B(); obj.doSomething(15); // obj.a should be 15 (a = val) obj = new C(); obj.doSomething(15); // obj.a should be 225 (a = val * val)

More Related