CHAPTER 13 Object Oriented Programming. Objectives Design class definitions Implement data hiding...
-
Upload
pamela-howard -
Category
Documents
-
view
222 -
download
2
Transcript of CHAPTER 13 Object Oriented Programming. Objectives Design class definitions Implement data hiding...
CHAPTER 13
Object Oriented Programming
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
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
Introduction (continued)
Introduction (continued)
System namespace(System)
Drawing class library(System::Drawing)
Math class library(System::Math)
Drawing::GraphicsDrawing::BrushDrawing::FontDrawing::Pen
.
.
.
Math::Sin()Math::Cos()Math::Sqrt()Math::PI
.
.
.
methods
constant
object class defs
Introduction (continued)
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
OOP Example (continued)
OOP Example (continued)
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
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
The Frog Class Definition (continued)
Instantiation and Use
Frog objects can be instantiated using gcnew
Instantiation and Use (continued)
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
Initializing Constructors (continued) The code for an initializing constructor
(from Frog.h) Parameters xcoord and ycoord are
assigned to instance variables x and y
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
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
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
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
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
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
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
Accessor and Mutator Methods (continued) The definitions of public methods getX() and getY() are contained in the class definition
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
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()
Utility Methods
Utility methods are instance methods that perform operations other than those performed by constructors, destructors, accessors, and mutators. (Example: verifyX() )
Utility Methods (continued)
A Frog class definition might want a public method that the client can call when they want a frog to hop
Complete Frog Class Definition private data members
x, y, icon private methods
Default constructor (Frog()) Utility methods
verifyX() verifyY()
Complete Frog Class Definition (continued) public methods
Initializing constructor (Frog(int, int)) Accessor methods
getX() getY() showIcon()
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
Complete Frog Class Definition (continued)
Complete Frog Class Definition (continued)
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
Client Code (continued)
Using the initializing constructor, each new Frog can be positioned in a different location
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()
Client Code (continued)
Client Code (continued)
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
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
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
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
Summary (continued)
Utility methods are carry out operations that constructors, destructors, accessors and mutators do not perform