Chapter 1

1. Chapter 1 Object-Oriented Programming

2. OO programming and design • Object-oriented programming and design can be contrasted with alternative programming approaches and associated design techniques. • For example, object-oriented programming and design can be contrasted with procedural programming and top-down functional decomposition design.

3. OO programming and design • The contrast between object-oriented programming and alternatives such as procedural programming can be highlighted by focusing on program modules. • A module is a program component that can be designed, coded, translated, and tested independently and then incorporated into a larger program.

4. Modules • Modules in procedural languages such as C are procedures, e.g., the C function int find_max( int n1, int n2 ) { if ( n1 > n2 ) return n1; else return n2; }

5. Modules • Modules in object-oriented languages such as Java are classes, which encapsulate or contain storage variables and procedures. • For example, Java has a Stringclass that encapsulates storage for the characters in a string together with procedures for constructing a string, determining a string’s length, checking whether a string contains a given character, and so on.

6. Top-down design • Procedural programming is associated with a design technique known as top-down design or top-down functional decomposition. • In top-down design, a problem is decomposed into subproblems. The problem and its subproblems are then assigned to procedures for solution.

7. Top-down design • For example, the problem of building a car might be decomposed into the subproblems of first building the chassis, the engine, the drivetrain, and so on and then of assembling the prebuilt parts. The overall problem of building the car could be assigned, in a simulation, to a main procedure, which in turn would invoke subprocedures such as build_chassis to handle the subproblems.

8. Top-down design • Top-down design and the associated procedural programming have drawbacks, particularly with respect to software maintenance. For example, a change in problem decomposition entails a change in procedural decomposition, which can ripple through an entire decomposition hierarchy. This is known as cascading changes.

9. Top-down design • For instance, suppose that the main procedure (which handles the main problem of building a car) needs to be changed by, for example, passing a new argument to subprocedures such as build_chassis, which in turn need to pass the new argument to their subprocedures, and so on until the change in main has rippled throughout the decomposition hierarchy.

10. OO design and programming • Object-oriented design and programming attempt to overcome shortcomings such as cascading changes. • In an object-oriented approach, classes behave as modules that can interact with other modules in such a way that a change to one does not require a change to all of the others.

11. Two senses of class • Class has two distinct but related senses: • In object-oriented design, a class is a collection of objects such as humans that share features or properties (e.g., humans are warm-blooded and risible) and behaviors or operations (e.g., humans gather, hunt, cook, and even tango). A class Human could represent humans in an object-oriented design.

12. Class as data type • In object-oriented programming, a class is a data type that can have instances. For example, Java has a Stringclass that is a standard data type in the language. Particular strings such as “Mary Leakey” would be represented in Java as Stringinstances or objects. A programmer-defined class such as Human might be introduced as a data type to represent humans.

13. Class as data type • The classes of object-oriented design can be represented in an object-oriented language as class data types. • Class data types encapsulate variables to represent class features (e.g., a variable footCount might be initialized to 2) and procedures to represent operations (e.g., a procedure might show a video of two humans doing the tango).

14. Class and encapsulation • The class as a data type can encapsulate • variables or fields, which represent features or properties that class instances share • procedures • Procedures used to create or construct instances of a class are known as constructors. • Procedures that represent class operations or behaviors are know as methods.

15. Class members • Fields are encapsulated variables, including arrays or other aggregates. • Constructors are encapsulated procedures used to construct class instances. • In Java, the code segment new String() uses the operator newand the String()constructor to construct a string.

16. Methods • Methods are encapsulated procedures that provide class operations. • In Java, the code segment String s = new String( “hi” ); int len = s.length(); first constructs a string and then invokes the encapsulated length method to determine the number of characters in the string.

17. “Class” and “instance” members • The class data types in object-oriented languages have two types of members: • Members associated with the class are “class members.” For example, an Empclass might have a “class member” named count to track how many Emp instances have been constructed.

18. “Class” and “instance” members • Members associated with class instances are “instance members.” For example, an Empclass might have a name “instance member” to represent each Employee’s name. • In Java, members marked as static are “class members,” whereas members not marked as static are “instance members.”

19. “Class” and “instance” members • The Java code segment class Emp { static int count; String name; } illustrates the syntax. The field count is a “class member,” whereas the field name is an “instance member.”

20. Class and abstract data type • The class construct in object-oriented languages directly supports abstract data types—data types defined by high-level operations rather than by low-level implementation details. • Use of abstract data rather than primitive data types eases programming tasks.

21. Stack as an abstract data type • A Stack is an example of an abstract data type. A Stack is a list with insertions and deletions done at the same end, known as the top. Its high-level operations include • push, which inserts an item onto the Stack. • pop, which removes the Stack’s top item. • peek, which shows the Stack’s top item without removing it.

22. Stack class • A Stack class type would encapsulate methods such as push, pop, and peek to represent high-level Stack operations.Other methods such as isEmpty and isFull could be included to test whether a Stack is empty or full. Constructors would be provided to construct Stack instances.

23. Information hiding • An abstract data type exposes to clients a high-level interface that specifies the type’s behavior. • In the Stack example, the interface consists of methods such as push and pop that specify high-level operations on a Stack. • An abstract data type hides from clients the type’s low-level, implementation details.

24. Information hiding • In object-oriented languages, a class is a type that supports information hiding. • Class members such as high-level methods can be declared public to expose such methods to clients. • Class members that provide implementation detail can be declared private to hide such details from clients.

25. Information hiding • By directly supporting information hiding, a class in an object-oriented language is well suited for delivering abstract data types. • The Java String class is, in effect, an implementation of a string as an abstract data type.

26. Client/server model and OO • Object-oriented programming is based on a client/server model of computing • A class and its instances (objects) are servers that provide services to clients. • An application that uses a class and its instances are clients. • For instance, the Java String class provides string-processing services to client applications.

27. Message passing • In the client/server model, invoking a class or instance method sends a message that requests a service. • For instance, the code segment String s = “Hi, world!”; int n = s.length(); requests the length of the string to which s refers.

28. Inheritance • Object-oriented languages support inheritance hierarchies, which are parent/child relationships between classes. • For instance, a Window class might have DialogWindow as a subtype. In this case, the Window class is the parent class and the DialogWindow class is the child class.

29. Inheritance • Inheritance provides a basic form of code reuse in that a child class inherits parent class members, including the methods. • Some object-oriented languages (e.g., C++) allow a child class to have multiple parent classes. In Java, by contrast, every class except Object has exactly one parent.

30. Inheritance • Languages such as C++ thus support multiple inheritance for classes, whereas languages such as Java support only single inheritance for classes. • Designing inheritance hierarchies is a critical part of object-oriented design.

31. Polymorphism • Polymorphism is a powerful object-oriented construct in which distinct methods within an inheritance hierarchy can be invoked with the same syntax. • For instance, assume an inheritance hierarchy of window classes in each class has its own appropriate implementation of a show method, which shows the window on the screen.

32. Polymorphism • Regardless of whether win refers to, say, a MenuWindow or a MessageWindow, the statement win.show(); // show yourself displays the window. At run time, the systems determines the type of window to which win refers and invokes the show method encapsulated in that type.

33. Polymorphism • A method such as show is a polymorphic method; that is, a method invoked with the same syntax as other polymorphic methods in the same inheritance hierarchy. • Polymorphism is used widely in object-oriented programming because of its power, flexibility, and convenience.

34. Component-based programming • Modern object-oriented programs tend to be component-based. • A component is a prebuilt part or module that can be integrated with other such parts to build or extend an application. • A container is a special-purpose component that can hold or embed other components.

35. Component-based programming • Programs with graphical user interfaces are commonly component-based. For example, the user interface might consist of a framed window (container) that holds components such as buttons, lists, checkboxes, menus, and the like. • Component-based programming is not restricted to GUIs, however.

36. Component-based programming • To be easily usable, a component should be designed under object-oriented principles: • The component should expose to clients only high-level functionality. • The component should hide from clients the low-level implementation details that support its high-level functionality.

37. UML • The Unified Modeling Language (UML) facilitates the design, development, deployment, and maintenance of software systems. • UML has become the modeling language of choice for object-oriented design. • UML is graphical, expressive, and concise.

38. UML • Basic UML vocabulary consists of • Things: Entities to be modeled, whether concrete or abstract. • Relationships: Connections among things. • Diagrams: graphical depictions of things and their relationships

39. UML diagram 1 * University Academic Department

40. UML diagram • The diagram on the previous slide expresses that a university is a collection of arbitrarily many academic departments, each of which is associated with exactly one university. • UML diagrams can serve as high-level design specifications for software systems and, in this role, can guide code development.