Overview of Object-Oriented SoftwareDesign and Java Programming potx

• A class generally contains private data and public operations called methods... • If we have a class definition called Car, then we can think of Audi, BMW, and Corvette as each being

Overview of Object-Oriented Software

Design and Java Programming

Putting the Pieces Together!

Object-Oriented Design

A technique for developing a program in which the solution

is expressed in terms of

objects self- contained

entities composed of data and operations on that data.

Object Oriented Programming

 Programmer thinks about and defines

the attributes and behavior of

objects.

 Often the objects are modeled after

real-world entities.

 Very different approach than

function-based programming (like C).

Reasons for OOP

Objects to Classes

• A class defines the pattern used when

instantiating an object of that type.

• A class generally contains private data and

public operations (called methods)

Class: Object Types

 A Java class is an object type

 When you create the definition of a class you are defining the attributes and

behavior of a new type

 Attributes are data members.

 Behavior is defined by methods.

Creating an object

 Defining a class does not result in

creation of an object

 Declaring a variable of a class type

creates an object You can have many variables of the same type (class)

Instantiation

Superclass and Subclass

• Inheritance enables us to define a new class

(called a subclass) that inherits the properties of

an already existing class.

• The newly derived class is then specialized by adding properties specific to it.

• The class being inherited from is the superclass

• The class that inherits properties is the subclass

Defining Objects

• An object-oriented program consists of

many objects.

• An object is composed of identity, state

(attributes, data, and their current values)

and behavior (operations)

Identity, State, Behavior

• Identity is the property of an object that distinguishes it from all other objects

• The failure to recognize the difference between the name of the object and the object itself is the source of many errors

in object-oriented (OO) programming

Identity, State, Behavior

• The state of an object encompasses all of the

(static) properties of the object plus the current (dynamic) values of each of these properties

• A property is an inherent or distinctive

characteristic, trait, quality, or feature that

contribute to making an object uniquely that

object

• We will use the word attribute, or data

member, to refer to the state of an object

Examples of State

• Properties

• Elevators travel up or down

• Vending machines accept coins

• Clocks indicate the current time

• Values

• Current floor

• Number of coins deposited

• The number of minutes since the last

hour

Identity, State, Behavior

in terms of state changes and interactions with other objects

• An operation is some action that one

object performs upon another in order to

blueprints) used to create objects I’d

say: descriptions of objects.

• To make a car the manufacturer must

first have a design from which to build

the first car Then, once all the problems are worked out, the design is used to

build all the cars of that model

• An object is an instance of a class.

• If we have a class definition called Car,

then we can think of Audi, BMW, and Corvette as each being an instance

(object) of the class Car, i.e., they are

each a type of car

Classes and Objects

• An object is an instance of exactly one class

• Corvette can not be an instance of a car class

and an instance of a plane class at the same

• Once a class is defined you can create as many instances of the class (objects from the class) as you would like

• Once a blue print is completed for the 2004 Porsche 911, Porsche will use an assembly line to build as many instances of the 2004 Porsche 911 as they wish

Defining a class

• Properties are variables which describe the

essential characteristics of an object.

• Properties of a car: color, model, make, how many doors, transmission type, direction of movement, etc.

• Behaviors are methods that describe how the

object behaves and how the properties may be modified

• Behavior of a car: braking, changing gears, opening doors, moving forwards or backwards, etc.

Instance variables

• The class definition will include parameter definitions

(properties) that represent data about a particular object,

instance variables

• Example, Joe's car may have 4 gallons of gas in it while John's car has 10 gallons.

• The amount of gas in each car may change without

affecting the amount of gas in the any other cars.

• All instances (objects) of a class will have a set of instance variables that are specific to that individual object.

• The combination of the values of these instance variables

is known as the object’s state.

Class variables

• The class definitions may also include

parameter definitions that represent data that

is shared by all class instances (objects),

called class variables.

• In the case of the car class, we will define a maximum allowed speed, by the law

(variable MaxSpeed) This will be the same

for each individual car.

Class variables

• Class variables may also be used to

keep track of things such as how many instances of a class exist

• Example: let’s create a counter the

records how many cars are in the

garage

• For Objects

• The object to whom

the message is being

sent.

• The name of the

method that object is

Messages and Methods

• In order to process a message, an object needs to have a method defined for the

requested task.

• A method is a small, well-defined piece of

code that completes a specific task.

• For our previous example, we need to

define a method to turn on the car's

hazard lights.

Messages and Methods

MaxSpeed = 145 turnOnHazard()

MaxSpeed MaxSpeed=155 NumCars = 3 turnOnHazard()

Instance methods

• Each class can have methods that are specific to

each object, called instance methods.

• These can only affect that object's parameters, i.e., it’s instance variables.

• Example: If BMW has 4 gallons of gas and

someone puts 6 more gallons of gas in his/her

car, the car now has 10 gallons The amount of gas in Audi and Corvette is unchanged.

Messages and Methods

MaxSpeed = 145 turnOnHazard() addGass(amount)

MaxSpeed MaxSpeed=155 NumCars = 3 turnOnHazard() addGass(amount)

• It is also possible that you want information

from an object; in this case, you would define

a method that sends (returns) a message back

to the requester containing that information.

• We need to know how much gas is in our cars,

so we will create a new method that returns

the value of Gas-Level variable for our car.

Messages and Methods

MaxSpeed = 145 GasLevel = 6 turnOnHazard() addGass(amount)

MaxSpeed GasLevel MaxSpeed=155 NumCars = 3 addGass(amount) getGasLevel():GasLevel

turnOnHazard()

turnOnHazard()

Class methods

• Class methods are used to get or

manipulate information about all objects created from the class

• Typically, class methods are changing

class variables For example:

• Each time we move the car in or out of the garage, we need to add/subtract one to the

number of cars: carIn( ) & carOut( )

• Also, we may want to know how many cars

are actually in the garage: getNumCars( )

Messages and Methods

MaxSpeed = 145 GasLevel = 6 turnOnHazard()

MaxSpeed GasLevel MaxSpeed=155 NumCars = 3

addGass(amount) getGasLevel():GasLevel turnOnHazard()

carIn() carOut() getNumCars():NumCars

Object Oriented Programming

• When writing object-oriented

programs, first one must define the

classes (like Car).

• Then, while the program is running, the instances of the classes

(objects) (such as Audi, BMW,

Corvette in our example) are

Object Oriented Programming - Benefits

separately from the rest of the program,

modularity.

communicate with other objects, but other objects can not directly access its instance

variables, information hiding.

Information Hiding

 The interface to a class is the list of public

data members and methods.

 The interface defines the behavior of the

class to the outside world (to other classes

and functions that may access variables of your class type).

 The implementation of your class doesn't matter outside the class – only the

interface.

Information Hiding (cont.)

 You can change the implementation and nobody cares! (as long as the interface is the same).

 You can use other peoples classes without fear!

The ability of different objects to respond to

the same message in different ways.

 You can create a new class that inherits

from an existing class

 You can add new members and methods

 You can replace methods

 The new class is a specialization of the

existing class

class hierarchy.

and the lower level classes are more

specific

higher level classes and inherit instance

variables and methods from those higher

level class They also may contain their

own (new) instance variables and methods

• A higher level class is called a superclass;

a lower level class is called a subclass.

• A subclass may also be a superclass

behaviors once and then to reuse those

behaviors over and over again in the

subclasses This is called reusability.

Inheritance Example

 Base class is shape, represents the

abstract notion of a shape

Inheritance Example

• Our Car class is very general

• Let's define a new class called BMW that contains the parameters: model, color, engine size

MaxSpeed GasLevel

turnOnHazard() addGass(amount) getGasLevel():GasLevel

• Now let's define two new classes One for the Z3 and another for the 3 Series

Sedan

• What might be some of the differences

between the two classes?

• Number of doors (3, 5)

• Roof (soft or hardtop)

• Therefore, we add variables NumDoors and Roof

MaxSpeed GasLevel

turnOnHazard() addGass(amount) getGasLevel():GasLevel

Z3

Model Color EngineSize Roof

MaxSpeed GasLevel

3 series

Model Color EngineSize NumDoors MaxSpeed GasLevel

Views of the class

• A class can be viewed as a sort of contract that specifies what instances of the class can, and cannot do

• It is possible to distinguish between the outside and inside view of a class

• The interface of a class provides its outside

view and emphasizes the abstraction

• The implementation of a class is its inside view

• Most classes provide three levels of access

to their members (state and behavior):

• Public

• The part of the class that is visible to all clients of the

class

• Protected

• The part of the class that is only visible to

subclasses of the class

• Private

• A part of the class that is not visible to any other

Private vs Public

 Public data members and methods can

be accessed outside the class directly

 The public stuff is the interface.

 Private members and methods are for internal use only

Protected Class members/methods

 We've already seen private and public

 Protected means derived classes have access to data members and methods, but otherwise the members/methods are private

Special Member Functions

is created (instantiated)

 can be many constructors, each can take different arguments.

is eliminated (not in Java)

 only one, has no arguments

Accessing Data Members

 Data members are available within each method (as if they were local variables)

 Public data members can be accessed

by other functions using the member

access operator "." (just like C++ struct)

Accessing class methods

 Within other class methods, a method can be called just like a function

 Outside the class, public methods can

be called only when referencing an

object of the class

static methods

 A static method is a class method that can be called without having an object

 Method can't access non-static data

members! (they don't exist unless we

have an object)

Static Data Members

 It is possible to have a single variable that is

shared by all instances of a class (all the

objects).

 declare the variable as static.

 Data members that are static must be

declared and initialize outside of the class.

 at global or file scope.

Static data member example

Two Programming Paradigms

OBJECT

Operations Data

OBJECT

Operations Data

OOP Terms Java Equivalents

member function )

internal state (values of private data members)

Inheritance Hierarchy Among

Vehicles

vehicle

bicycle car

four-door two-door

 is a mechanism by which one class acquires (inherits) the properties (both data and

operations) of another class

 the class being inherited from is the Base

Class (Superclass)

 the class that inherits is the Derived Class (Subclass)

 the derived class is then specialized by

adding properties specific to it

Composition (or Containment)

 is a mechanism by which the internal data (the state) of one class includes

an object of another class

TimeCard Class

TimeCard has a Time object

Private data:

hrs mins secs

Punch

Private data:

id timeStamp

Constructor Rules for Derived Classes

 at run time, the base class constructor is

implicitly called first, before the body of the derived class’s constructor executes

 if the base class constructor requires

parameters, they must be passed by the

derived class’s constructor

Order in Which Constructors are

Executed Given a class X,

is executed first

executed (using their own default constructors if none is specified)

End of Lecture