School of Compupter Science & Engineering Introduction to Object-Oriented-Programming course 67125

Transcription

1 School of Compupter Science & Engineering Introduction to Object-Oriented-Programming course Slide 1

2 Course Overview Course Goals: (1) Learn advanced Object Oriented Concepts using Java. (2) Learn basic Object-Oriented Design. (3) Implement various data structures using Java. (4) Get to know various important and useful Java classes from the Java API (5) Learn new Java 5.0 features Slide 2

3 Course Topics Object-Oriented Concepts revisited (today's lesson) Progrmming in an Integrated Develpoment Environment (IDE) Input-Output using streams. Advanced Object-Oriented Concepts. Basic Design-Patterns in OOP: Iterator, Composite. A short introduction to UML (Unified Modelling language) Slide 3

4 Course Topics (cont.) Event-Based programming and simulation. Genericity. The Java Collections API. Graphical User Interface and Event-Handling in Java. Implementing data structures in Java. Learning new Java 5.0 concepts and features. Slide 4

5 Course Mechanics Course website: Course Staff: Lecturer:Tomer Hertz Teaching Assistants: Tal El-Hay, Elad Dinur Course Tzar : Moran Yassour Course Duties: 5 programming Exercises Final Exam Many more details in the OOP_Mechanics.pdf file Slide 5

6 Object-Oriented Revisited Object: A thing presented to or capable of being presented to the senses. Object-Oriented: Directed toward just about anything you can think of. Many other different definitions. No clear agreement on what the concept actually means. Slide 6

7 OOP concepts A list of 12 OOP Guru's were locked in a single room. Each one made a list of indespensible OOP propeties. They now had 2 options: (1) Create one long list which is the union of their individual list. (2) Create a short list which is the intersection of their lists. The Guru's chose the 2 nd option and got a very short list indeed: it was the word Encapsulation! Finally someone suggested to choose the most popular properties in all lists! This yielded 9 OOP concepts. Slide 7

8 OOP concepts 9 Object Oriented Concepts: (1) Encapsulation (2) Information/Implementation hiding (3) State retention (4) Object identity (5) Messages (6) Classes (7) Inheritance (8) Polymorphism (9) Genericity Slide 8

9 OOP concepts Karel Revisited In order to understand these concepts let us return to Karel the Robot. The task:we would like to create a program which allows Karel to walk through a path from start to end assuming a single path exists between the two. Slide 9

10 The Karel And KarelWorld Classes Fortunately we already have both a Karel class and a KarelWorld class at our disposal. Karel's API: public boolean setstartlocation(point location) public void turnleft(), public void turnright() public void moveforward() public Point getlocation() public boolean frontisclear() Slide 10

11 The KarelWorld Classes KarelWorld's API: public KarelWorld() public Point getstartposition() public Point getendposition() public void display() Slide 11

12 A solution KarelWorld world = new KarelWorld(); Karel robot = new Karel(); Point startpoint = world.getstartposition(); boolean setok = robot.setstartlocation(startpoint); while(!robot.frontisclear()) robot.turnleft(); while(! robot.getlocation().equals(world.getendposition) ) { while(!robot.frontisclear()) } robot.turnleft(); robot.moverforward(); world.display(); Slide 12

13 Encapsulation Encapsulation is the grouping of related ideas into one unit, which can thenforth be referred to by a single name. An old concept dating back to the early 1940's The basic idea a repeating pattern could be grouped together at a corner of a program and invoked by a single name from several different points in the main program a subroutine/procedure/function - encapsulation of instructions. Advantages: saves computer memory (very important back then!) saves human memory represents a conceptual chunk that can be considered and manipulated as a single idea. Slide 13

14 OOP Encapsulation OOP Encapsulation is the grouping of procedures around data. (more precisely encapsulation of a state within the procedural mechanisms for accessing and modifying that state.) An object consists of a set of methods and a set of variables: frontisclear() getlocation() dir location moveforward() turnleft() Slide 14

15 OOP Encapsulation (cont.) Variables are used internally to remember information. Variables are accessed and updated by an object's methods. Variables are private to the object and cannot be directly accessed. The methods form a protective ring around the central core of the variables. frontisclear() moveforward() getlocation() dir location turnleft() Slide 15

16 Information/Implemention Hiding Information/Implementaion Hiding is the use of encapsulation to restrict from external visibility certain information or implementation decisions that are internal to the encapsulation structure. information hiding information from within the unit cannot be preceived outside the unit. implementation hiding implementation details within the unit cannot be preceived from the outside. Many times the object allows access to information via public methods, but still hides implementation details. Slide 16

17 Information/Implemention Hiding Karel's direction is an example of both information hiding and of implementation hiding: We don't know whether Karel's direction is stored as a char ('e','n','s' or 'w') or as a numerical angle (with values of deg). Note: This is true even if we have implemented a getdirection method. (why?) The object may be seen as a black box to an extent observer. The extent observer has full knowledge of what the object can do, but has no knowledge about how the object does what it does, and how frontisclear() it is constructed internally. moveforward() getlocation() dir turnleft() locatio n Slide 17

18 Information/Implemention Hiding Information/Implementation hiding has 2 major benefits: (1) It localizes decisions private decisions (those within an object) have little or no impact on the rest of the system. Therefore they can be easily made and changed. (limits the ripple of change effect). (2)It decouples the content of information from its form of representation. Thus, an external user of the information content. This prevents external users from meddling with the object's interior. Also prevents introducing connections to an object that depend on tricks or accidents of format and are therefore unstable. Slide 18

19 State Retention An object should have the ability to retain it's state. Traditional procedural modules (e.g. Functions) which die when they return to their caller leaving behind only their result (or return value). Modules have no memory - when the module is called again, its as if it is reborn. An object such as robot, is aware of its past. It retains information inside itself for an indefinite amount of time. Slide 19

20 State Retention Object's State: the values that the object holds. For example: Karel's state includes its current location in the world, and the direction in which it is currently facing. The way in which the object chooses to retain its state is its own internal business. Slide 20

21 Partial Recap So far we have discussed: (1) Encapsulation (2)Information/Implemenation hiding (3)State retention All three are at the core of Object Orientation. However, they are not new ideas and have been studied for years in the field of Abstract Data Types (ADT's). As we'll now see Object Orientation goes well beyond the ADT. Slide 21

22 Object Identity Object identity is the property by which each object (regardless of its class or current state) can be identified and treated as a distinct software entity. Each object has something unique which distinguishes it from all its fellow objects. This something unique is provided by the object-handle mechanism. What is an object handle? Consider the following line of code: Karel robot = new Karel(); The right hand side of this line creates a new object (of class Karel). Slide 22

23 Object Identity (cont.) Karel robot = new Karel(); frontisclear() moveforward() getlocation() dir location turnleft() Object Handle An object handle is an identifier attached to an object when it is created. (AKA Object Identifier (OID)). The object has the same handle for its entire life, regardless of its state during that time. No two objects can have the same handle. Whenever a new object is created at run-time, the system assigns a different handle from all other past, present or future handles. Slide 23

24 Object Identity (cont.) Karel robot = new Karel(); The left-hand side of the line of code is a declaration of a variable by which the programmer can use to refer to a word of memory which can hold a value. The assignment operation can be read as now refers to (or now points to ) causes the variable robot to hold the handle of the object created on the righthand side of the assignment statement. No one (programmer,user,anyone) will ever actually see the handle (102237) of the new object. Instead, the programmer will access the object via the Slide 24

25 Object Identity (cont.) Karel robot = new Karel(); frontisclear() moveforward() robot getlocation() dir location turnleft() In java this handle is a virtual address (and not a physical address). If we create another object it will have a new and different identity. If we now write robot1 = robot; we now have aliasing, but still each of the object's has its own unique ID. Slide 25

26 Messages A Message is the way in which a sender object ob1 conveys to a target object ob2 a demand for object ob2 to apply one of its methods. Message structure a message is comprised of several syntactic parts, each of which is important for OOD. In order for object ob1 to send a message to object ob2, object ob1 must know three things: (1) The handle of ob2 usually kept as one of ob1's variables. (2)The name of the method of ob2 that it wishes to execute. (3)Any additinal information (arguments) that ob2 will require in the execution of its method. Slide 26

27 Messages (Cont.) The karel program provides several examples of messages e.g. robot.turnleft(); Here robot points to (contains the handle of) the target object of the message. turnleft() is the name of the method (of the target object) that's to be executed. Sending of a message therefore looks like traditional calling of a function or procedure. In a procedural language we might have written: turnleft(karel robot); Notice the inversion! Slide 27

28 Messages (Cont.) In the procedural approach, we appeal to a procedural unit and supply it with the object upon which to act. In object orientation, we appeal to the object, which then executes one of its procedural units. While this seems only a syntactic (and maybe also philosophical) difference, when polymorphism, overloading and dynamic binding are introduced, we'll see that this inversion creates and important practical difference between the two approaches. This is because different classes of objects may use the same method name for methods that accomplish different or class-specific behaviours. Slide 28

29 Messages (cont.) Message arguments each message can pass arguments back and forth (input arguments and a return value). These are sometime called the method's signature (types of arguments?) A message therefore consists of 2 parts: the method name and its signature. An object can be a sender and a target in different contexts. Slide 29

30 Three types of messages: Message Types (1) Informative message A message to an object that provides it with information to update itself. (aka update,forward, or push message). A past-oriented message. (2) Interrogative message A message to an object requesting it to reveal some information about itself (aka read,backward or pull message). A present-oriented message. (3) Imperative message A message to an object that requires the object to take some action on itself, another object, or even the envirornment around the system (aka force or action message). A future-oriented message. Slide 30

31 Examples: Message Types Informative message: robot.setstartlocation(point p); tells the Karel object where in the world it has been placed. In general tells the object about something that's happened. Interrogative message: robot.getlocation(); which asks the robot to tell us which square it's currently on. This type of message does not change anything, it usually queries the piece of the world that the object represents. Imperative message: robot.moveforward(); which causes the robot to move forward. This kind of message often results in the target object excuting some significant algorithm in order to work out what to do. (e.g. robot. MoveToWall() ) Slide 31

32 Classes A Class is the stencil from which objects are created (instantiated). Each object has the same structure and behavior as the class from which it is instantiated. Whenever we execute the new command we instantiate an object that is structurally identical to all other objects created from the same class. Structurally identical - all objects from the same class have the same methods and variables, as defined by their class. Objects from the same class differ from one another in 2 ways: (1) Each object has a different object handle. Slide 32 (2)At a particular time, each object will probably have a different

33 Class vs. Object? The distinction between a class and an object: A class is what you design and program Objects are what you create (from a class) at runtime. Therefore Object-Oriented Programming should have been called class-structured programming! Example: Excel (see open office's Calc) is the class from which spreadsheets are created. Each spreadsheet has all the spreadsheet machinery available to is as an instance of the Excel class. One may have many objects from the same class. Slide 33

34 Objects in Memory Suppose we instantiate 3 different objects from the same class. All of them have the same structure (identical variables and methods). In principle each object (instance) of a class has its own copy of the set of methods and variables it needs. However, while (most) variables are indeed object specific, the methods need not be allocated again for each new object from the same class. Therefore all objects share the same physical copy of the methods (to save memory). Slide 34

35 Object methods and variables Recall that an object can have two types of methods variables: Instance methods/variables which belong to individual objects. Class methods/variables (static) which belong to the class. By definition there is always one copy of these regardless of the number of objects which have been instantiated. Example : the constructor method. Slide 35

36 Inheritance Inheritance (by B from A) is the facility by which objects of a class B may use a method or variable that would otherwise be available only to objects of class A, as if the method or variable has been defined upon B. A is termed a superclass of B. B is a subclass of A. Allows to build software incrementally : First build classes to cope with the most straightforward (or general) case. Then, in order to deal with special cases, add more specialized classes and inherit from the first class. The new classes will be entitled to use all the methods and variables (both class and instance) of the original class. Slide 36

37 Inheritance (cont.) Aircraft bool:turn(course:int) Glider ReleaseTowline() isattached:bool Aircraft ac = new Aircraft(); Glider gl = new Glider(); boolean turnok = ac.turn(200); gl.releasetowline(); gl.turn(180); ac.releasetowline(); Slide 37

38 Object vs. Instance We saw the distinction between class and object. There is also a subtle distinction between object and instance inheritance in a sense permits a single object to be simultaneously an instance of more than one class. This corresponds to the real world: if you own a glider (object) it is at the same time an example of a glider and an example of an aircraft. This demonstrates the is a test for inheritance: If you can say a D is a C then D almost certainly should be a subclass of C. Slide 38

39 Polymorphism Comes from two Greek words that mean many and form. Something polymorphic has the ability to take on many forms. Two different definitions in the literature: (A) Polymorphism is the facility by which a single method name may be defined upon more than one class, and may take on different implementations in each of those classes. (B) Polymorphism is the property whereby a variable may point to (hold the handle of) objects of different classes at different times. Slide 39

40 Polymorphism Example: Shapes hierarchy Polygon int:area() Triangle int: area() Rectangle int:area()... Hexagon Slide 40

41 Polymorphism (cont.) The method area() in Polygon would need a fairly sophisticated algorithm in order to compute the area of a general polygon. All of the shapes that inherit from Polygon, inherit the method area(). However, the designer/programmer of area() for rectangle would write the code for this method very differently (and also much simpler and efficient). Slide 41

42 Polymorphism If we have a ref td to type twodshapes which sends a message to its object as follows: td.area(); then (a) We may not know which algorithm for computing area() will be executed. (b) This Reason is that we many not know exactly to which class td belongs. There are 5 possiblities: Triangle, Rectangle, Hexagon, Polygon, Customer Which causes what to happen? Easy to construct simple code in which the class of an object cannot be determined at compile time (how?) Slide 42

43 Polymorphism Where are the 2 definitions of polymorphism here? (1) The method area() being defined on several classes is a good example of polymorphism using definition (A). (2) The variable td, capable of pointing to object of several different classes (for example, Triangle and Hexagon) is an example of polymorphism under definition (B). This shows that these two aspects of polymorphism work together. Slide 43

44 Polymorphism and Dynamic Binding An Object-Oriented environment implements polymorphism is through dynamic binding. The environment inspects the actual class of the target object of a message at the last possible moment at run-time, when the message is sent. Dynamic Binding (or runtime/late binding) is the technique by which the exact piece of code to be executed is assessed only at run-time (as opposed to compile-time). Slide 44

45 Overriding and Overloading Overriding is the definition of a method defined on class C in one of C's subclasses. The method area() originally defined by Polygon is overriden in Triangle. Triangle's method has the same name but a different algorithm. Sometimes overriding can be used to cancel a method by redefining it simply to return an error. Slide 45

46 Overriding and Overloading Overloading a name or a symbol occurs when several methods (or operators) defined on the same class have that name or symbol. We say that the name or symbol is overloaded. Both polymorphism and overloading often require that the specific method to be executed be picked at run-time. (why?) The distinction between polymorphism and overloading is that polymorphism allows the same method name to be defined differently across different classes, while overloading allows the same method name to be defined differently several times in the same class. Slide 46

47 Genericity Genericity is the construction of class C so that one or more of the classes that it uses internally is supplied only at run-time (at the time that an object of class C is instantiated). An informative example Designing a Linked-List: Suppose that you are required to implement a Linked-List of integers for a specific exercise, and then required to implement a Linked-List of shapes for another exercise. What are your design options? Slide 47

48 Genericity (cont.) There are 3 possible solutions: (1) Clone the old code and replace the int data with a Shape reference. (Pros? Cons?) (2) Define the Linked-List data as a reference to Object. (Pros? Cons?) (3) Define the Linked-List to be a generic class, which means that the list's data won't be assigned until run-time Genericity. Slide 48

49 Genericity (cont.) We could define the List class as follows: class List<ListData> { private Node<ListData> head;... public void print(){...} } The <ListData> is a generic class argument whose actual value will be supplied only at run-time. If we instantiate a List object and call the method print we now make fine use of polymorphism, since when it is defined in a generic class, we don't know what the exact type will be. Slide 49 This requires that every type we use will have a print method defined

50 Genericity (cont.) As of Java 1.5 Genericity is an essential part of the language. More on genericity in a few lessons. Slide 50