1. CHAPTER 13 Object Oriented Programming

2. Objectives  Design class definitions  Implement data hiding and encapsulation  Use accessor and mutator methods  Implement an initializing constructor  Use public, and private access modes  Create and reference a two-dimensional array

3. Introduction  An abstraction is an idea with varying amounts of definition  In computer science, abstractions are class definitions  Examples of system-defined class definitions: Button, TextBox, Label, Form  Objects are created from class definitions (abstractions)  Objects are implementations of the abstraction

4. Introduction (continued)

5. System namespace ( System ) Drawing class library ( System::Drawing ) Math class library ( System::Math ) Drawing::Graphics Drawing::Brush Drawing::Font Drawing::Pen. Math::Sin() Math::Cos() Math::Sqrt() Math::PI. methods constant object class defs

6. Introduction (continued)

7. OOP Example  Consider a program in which Frog objects are created and made to hop across the screen  The Frog class definition is an abstraction  The Frogs seen on the interface are objects (instances of the class)  Objects exhibit all the properties and methods defined by the class they are derived from

8. OOP Example (continued)

10. The Frog Class Definition  A Frog class definition needs  Class variables (the Frog icons)  Instance variables X and y coordinates of the Frog The assigned icon  Constructor

11. The Frog Class Definition (continued)  A Frog class definition needs  Instance methods Operations that Frog objects can perform Example: showIcon() Returns the Frog’s assigned icon to the client program so that it can be displayed

12. The Frog Class Definition (continued)

13. Instantiation and Use  Frog objects can be instantiated using gcnew

14. Instantiation and Use (continued)

15. Initializing Constructors  Constructors are used to instantiate objects  Initializing constructors use parameters to construct objects with specific properties that can be passed in as actual arguments

16. Initializing Constructors (continued)  The code for an initializing constructor (from Frog.h)  Parameters xcoord and ycoord are assigned to instance variables x and y

17. Initializing Constructors (continued)  The default constructor assigns every Frog object it makes the same x and y coordinates  Initializing constructors may be preferable to default constructors because the client can specify the location for each Frog object created  To prevent the client from using the default constructor, it should be placed in the private portion of the Frog class definition

19. Data Hiding  Data hiding is the practice of making data members inaccessible by designating them as private  Data members that are private can only be accessed by class methods and not by the client

20. Data Hiding (continued)  In this example, the client constructs a Frog with x and y locations -50, -75 and later assigns other negative coordinate values  This could lead to problems, since negative coordinates are off of the interface

21. Data Hiding (continued)  To make it impossible for the client to place invalid values into instance variables like x and y, these data members can be “hidden” by placing them in the private portion of the class definition  Invalid assignments by the client are no longer allowed  Unfortunately, valid assignments are not allowed either  public methods are provided to the client to allow it to change values stored in private data members

22. Data Hiding (continued)  Hidden data members are not visible to the client  The good news:  Invalid assignments are no longer possible  The bad news  Valid assignments are not allowed either  public methods are provided to the client to allow it to change values stored in private data members

23. Accessor and Mutator Methods (continued)  Accessor and mutator methods are public methods that provide access to private data members  An accessor method is a public method that returns the value stored in a private data member

24. Accessor and Mutator Methods (continued)  In this example, public methods getX() and getY() are available to the client, allowing it to retrieve the data stored in private data members x and y

25. Accessor and Mutator Methods (continued)  The definitions of public methods getX() and getY() are contained in the class definition

26. Accessor and Mutator Methods (continued)  A mutator method is a public method that changes the value stored in a private data member  In this example, setX() is a public mutator method used to change the private x coordinates of each of four Frog objects

27. Accessor and Mutator Methods (continued)  Mutator methods can be used to screen data before it is assigned to a private data member, as shown in the class definition of setX()

29. Utility Methods  Utility methods are instance methods that perform operations other than those performed by constructors, destructors, accessors, and mutators. (Example: verifyX() )

30. Utility Methods (continued)  A Frog class definition might want a public method that the client can call when they want a frog to hop

31. Complete Frog Class Definition  private data members  x, y, icon  private methods  Default constructor ( Frog() )  Utility methods verifyX() verifyY()

32. Complete Frog Class Definition (continued)  public methods  Initializing constructor ( Frog(int, int) )  Accessor methods getX() getY() showIcon()

33. Complete Frog Class Definition (continued)  public methods  Mutator methods setX() – used to assign a value to x setY() - used to assign a value to y setLeaping() used to assign the leaping icon setSitting() used to assign the sitting icon  Utility method hop() – used to add 25 to the x coordinate

34. Complete Frog Class Definition (continued)

37. Client Code  The client needs to instantiate four Frog objects and position them vertically along a starting line  Constant STARTX stores the starting x coordinate postion  Constants START1, START2, START3 and START4 store the starting y coordinate positions

39. Client Code (continued)  Using the initializing constructor, each new Frog can be positioned in a different location

40. Client Code (continued)  To draw a single Frog you first construct a Rectangle object  Upper left corner x coordinate is Frog->getX()  Upper left corner y coordinate is Frog->getY()  Width and height are both 25 pixels  The DrawIcon() method displays an icon in a Rectangle  The icon is Frog1->showIcon()

41. Client Code (continued)

42.  To reset the interface all frogs are repositioned back to their starting X location and all frog icons are set to the sitting frog icon

43. Client Code (continued)  A random number is used to select one of the four frogs. The chosen frog’s icon is set to the leaping icon

44. Summary  Class definitions are abstractions  Objects are instances of the class  Initializing constructors are useful if the objects they construct need to have unique values assigned to their attributes  public data members and methods are visible to the client  private data members and methods are not visible to the client

45. Summary (continued)  Data hiding is used to restrict client access to data members  Accessor methods are public methods that can be used to retrieve a value stored in a private data member  Mutator methods are public methods that can be used to assign new values to a private data member

46. Summary (continued)  Utility methods are carry out operations that constructors, destructors, accessors and mutators do not perform