Corresponds with Chapter 7 Classes and Objects Corresponds with Chapter 7

Principles of Object Orientation Encapsulation Data and behavior pertaining to an object are bundled together into a single unit Information Hiding Provide an interface to the user of a class via public members Hide details about the implementation of the class via private members Inheritance Grouping classes into hierarchies of categories and subcategories Subclasses inherit the members of the base class Poymorphism Poly = many, Morph = form  Many Forms The same method call (using identical signature) produces different behaviors depending on the class

Classes and Instances (Objects) Class = category Like a data type Declared using the class keyword Contains declarations of members Variables Methods Instance = object An actual piece of data (created on the heap) Member variables contain actual data Method calls apply to the particular instance

Example – The SimpleCircle Class (similar to Listing 7. 1, 7 Example – The SimpleCircle Class (similar to Listing 7.1, 7.2 pp 234-235) This is the application class with main method This is the another class representing a specific kind of object.

Overloaded Constructor Class Declaration Member variable declaration Default constructor (no parameters) Overloaded Constructor Method declaration Entire class declaration: bundles the data (member variables) with the behavior (methods)  encapsulation

Unified Modeling Language Diagrams for representing object oriented systems. Static class diagram: Represents classes in the system Boxes for representing classes Top part of box contains name Middle part contains attributes (member variables) Lower part contains operations (methods, including constructors)

UML Class Diagram for SimpleCircle Class Class name Attributes Operations Class Visio drawing of UML diagram

Declaring Objects Example: ClassName objectName; SimpleCircle myCircle; Class is like data type Variable name indicates a reference to an instance of the class

Creating Objects Instantiation objectName=new ClassName(); Example: myCircle=new SimpleCircle(); assignment operation puts the reference into the variable. new keyword creates the object on the heap (instantiation) Note the need for ()….instantiation automatically invokes a constructor method (more on this later) Specify the class of object being instantiated.

Declaring/Creating Objects in a Single Step ClassName objectName = new ClassName(); Example: SimpleCircle myCircle = new SimpleCircle();

The SimpleCircle Class (cont.) Instantiating an object: new keyword creates the object on the heap Overloaded constructor is invoked to initialize member variables

Constructors A constructor is a special method that is automatically called when an instance of the class is created. Constructor’s purpose – perform initialization operations (e.g. set initial values for variables). The constructor’s identifier is EXACTLY the same as the class’s name. Constructors have no return type (not even void). When the new operator creates an instance of a class, the constructor is automatically invoked. Default constructor – no parameters Can overload constructor, just like any other method.

Frame Stack Heap Declaring the reference variable Creating the object myCircle Creating the object on the heap (instantiation) SimpleCircle object radius main’s frame args Frame Stack Heap

Constructor method is invoked SimpleCircle constructor frame newRadius 5.0 this main’s frame SimpleCircle object radius args myCircle Frame Stack Heap

The this pointer An instance method is a method that is associated with a specific instance (NOT a static method). Constructors are instance methods. Every instance method has a special reference called this. this points to the instance for which the method was invoked. this is the way that an instance method knows which object to access when using or manipulating its data this is also a keyword in the Java language, and can be used to access members from within the instance (more on this later).

The constructor (an instance method) can access the member variables of the object via the this pointer. SimpleCircle constructor frame newRadius 5.0 this main’s frame SimpleCircle object radius args 5.0 myCircle Frame Stack Heap

After constructor terminates (and its frame popped from the frame stack), the new operator returns the address where the object was created. This is assigned into the variable myCircle. main’s frame SimpleCircle object radius args 5.0 myCircle Frame Stack Heap

Accessing Objects Referencing the object’s data: objectName.data myCircle.radius Referencing the object’s method: objectName.method myCircle.findArea() The dot (.) is a member access operator. (Sometimes just called the “dot operator”)

The SimpleCircle Class (cont.) Variable used outside the class. Accessed via dot operator. Member variable declaration. Available to multiple methods (scope is wider than a single method). Variable used inside the class. Note: radius is an instance variable. Every instance of the Circle class will have a variable called radius. Later we’ll compare this to static, or class variables.

Instance Methods objectName.methodName(); Instance methods belong to instances. These methods can only be applied after the instances are created. Later we’ll compare these to static, or class methods. Instance methods are called by the following: objectName.methodName(); The name of the reference variable The dot operator The name of the method.

The SimpleCircle Class (cont.) The method call The method declaration

Calling the method Frame Stack Heap NOTE: the instance method knows which object to access via its this pointer. This is identical to the reference variable through which the method was called. findArea’s frame this main’s frame SimpleCircle object radius args 5.0 myCircle Frame Stack Heap

The SimpleCircle Class (cont.) Instantiating an second object: new keyword creates the object on the heap Default constructor is invoked to initialize member variables

Frame Stack Heap Creating the second object Declaring the reference variable yourCircle Creating the second object on the heap (instantiation) SimpleCircle object radius main’s frame SimpleCircle object radius args 5.0 myCircle Frame Stack Heap

The constructor (this time the default constructor) can access the member variables of the object via the this pointer. SimpleCircle constructor frame SimpleCircle object radius 1.0 this main’s frame SimpleCircle object radius args 5.0 myCircle yourCircle Frame Stack Heap

After constructor terminates (and its frame popped from the frame stack), the new operator returns the address where the object was created. This is assigned into the variable yourCircle. SimpleCircle object radius 1.0 main’s frame SimpleCircle object radius args 5.0 myCircle yourCircle Frame Stack Heap

The SimpleCircle Class (cont.) Accessing the member variable via the reference variable

We know which radius variable is being accessed because the reference variable points us to the appropriate object. SimpleCircle object radius 100.0 main’s frame SimpleCircle object radius args 5.0 myCircle yourCircle Frame Stack Heap

The SimpleCircle Class (cont.) Invoking the method via the reference variable

The instance method’s this pointer will point at the same object as the reference variable through which the method was invoked. This is how the method knows which object it is associated with. findArea’s frame SimpleCircle object radius 100.0 this main’s frame SimpleCircle object radius args 5.0 myCircle yourCircle Frame Stack Heap

Principles of Object Orientation Encapsulation Data and behavior pertaining to an object are bundled together into a single unit Information Hiding Provide an interface to the user of a class via public members Hide details about the implementation of the class via private members Inheritance Grouping classes into hierarchies of categories and subcategories Subclasses inherit the members of the base class Poymorphism Poly = many, Morph = form  Many Forms The same method call (using identical signature) produces different behaviors depending on the class

Visibility Modifiers for Members public The class, data, or method is visible to any class in any package. private The data or methods can be accessed only by the declaring class. protected The data or methods can be accessed by the declaring class, its subclasses, and other classes in the same package. (more on this later) By default, a class’s members are protected

Public vs. Private Use public is you want everyone to be able to access a member Use private if you want to restrict access to a member: For example, you may want to make member variables private so that users of a class cannot arbitrarily set values For these private members, access would be done via public methods called “accessor methods” (for obtaining values) and “mutator methods” of changing values. Mutator methods can perform input verification to ensure that values being assigned to a member variable are valid.

Accessor and Mutator Methods Purpose of accessor/mutator methods is to provide controlled access to private member variables Two types: get – accessor returns the value in a private member. Return type is same as data type of the member variable. set – mutator changes the contents of the private member. Takes a parameter of the same type as the private member. Often does some validation to ensure that entered the input parameter value is legitimate before placing it into the member variable. Typically returns a void.  Each private member variable that should be accessed from outside the class will need accessor and mutator methods associated with it.

Set mutator validates parameter value The Circle Class (includes private member variable and accessor/mutator methods) The member variable is private Public constructors Using accessor and mutator to manipulate private member variable Public accessor and mutator Set mutator validates parameter value

Unified Modeling Language Diagrams for representing object oriented systems. Static class diagram: In class box, visibility modifiers are represented with + for public - for private * for protected

UML Class Diagram for Circle Class Attributes are private ( - ) Operations are public (+) Accessor/mutator methods as operations Visio drawing of UML diagram

Passing Objects to Methods Object reference variables can be passed as arguments, just like other variables Since these are reference variables, the method receiving them has access to the original data (similar to when we passed arrays)

Passing a Circle Object (similar to Listing 7.9 p249) Reference to an instance Reference as an actual parameter The corresponding formal parameter