CS451 - Lecture 21

CS451Lecture 2: Introduction to Object Orientation

Yugi Lee

STB #555(816) 235-5932

leeyu@umkc.edu

www.sice.umkc.edu/~leeyu

*Acknowledgement: This lecture is based on material courtesy of Monash University

2CS451 - Lecture 2

Content

• Basic OOConcepts

AbstractDataTypes

Encapsulation

MessageSending

• Classes, Objects and State

Attributes

Instance

Class

Object creation & destruction

• Object Behaviour

Methods

InstanceMethods

ClassMethods

MethodOverloading

• Object Interfaces

Interface classes

AccessModifiers

Inheritance

3CS451 - Lecture 2

Object-oriented programming

• Construction of system which is structured collections of "classes", or abstract data type implementations.

• These classes produce runtime instances called "objects" which communicate by sending messages to each other.

• Each ADT encapsulates the state and behavior of its real-world counterpart.

• Using Java, OO concepts will be explanined.• Compare this with how structured programs are

developed!

4CS451 - Lecture 2

Object Oriented Concepts

• Abstract Data Type (ADT) – an abstract representation of a real-world entity

• Encapsulation – the combination of state and behavior into a single structure, whi

lst hiding the implementation

• Message sending – the process by which objects communicate

• Classes and objects – ADT implementations and their runtime equivalents

5CS451 - Lecture 2

Abstract Data Types (ADTs)

• Information Hiding and ADTs (1960-70) An ADT is a specification of a real-world "object"

with both hidden state and public behavior Implementation (class body) hides the data

representation and function realization at lower level The name of a class names an ADT (the interface(s)),

the type of data (the instances of the class), and the implementation (the hidden details)

6CS451 - Lecture 2

Abstract Data Types (ADTs)

E.g. int:primitive Java datatype with state (i.e., the value it holds), but no internal behaviour

E.g.

7CS451 - Lecture 2

Encapsulation: state plus behavior

• the combination of data and functionality into a single entity, with the implementation hidden from external entities

the other side of the ADT coin, of the separation of interface and implementation

a "black-box" approach to designing OO systems

8CS451 - Lecture 2

Encapsulation: state plus behavior

can only be achieved by "hiding" details of a class' implementation and letting other classes communicate with it only through a well defined set of messages (message sending)

9CS451 - Lecture 2

Message sending

Message sending is the technique objects use to communicate with each other (similar to calling a function)

Message handling: the same message can be sent to different objects, each may "respond" in a different way (polymorphism)

Methods of objects - comparable to function definitions - define the "response" of an object to a message.

10CS451 - Lecture 2

Message Sending

For example, if a bank Customer wished to deposit some money into their Account, the Customer object would send the "deposit" message to their Account object, along with an amount to deposit

11CS451 - Lecture 2

Classes, Objects and State

A class

• may only exist at compile time

• is a template/pattern for an object

• "only exists once"

• is an implementation of an ADT

• is by a class declaration

An Object• exists at runtime only

• is created/instantiated from a class specification

• can be created many times from one class

• is a runtime instance of a class

• is returned by the new operator

12CS451 - Lecture 2

Attributes

• ... are used to represent state.

• part of the interface and accessible only through methods or hidden and represent the internal state of objects.

variables which have some connection to a class and are declared, initialized, referenced and assigned

primitive, user-defined, or a class from the JDK API

13CS451 - Lecture 2

Attributes

Instance variables store information pertaining to one particular object's state (by far the most common of the two types of attribute)

Class variables store information pertaining to all objects of one class

14CS451 - Lecture 2

Instance variables

• Visible inside class; each instance object has its own values associated to the instance variable

To access an instance variable from within it's class, the name of the variable itself is

used

from outside its class, through a valid object reference

Initialization performed when object is created

15CS451 - Lecture 2

Class variables

Value shared by all instances of the class; sort of a "global variable" to all instances

Details Declared with the static keyword Initialized before main runs Writable only for methods in class (unless public)

If public, use dotting ClassName.ClassAttribute to access from outside class;

16CS451 - Lecture 2

Object creation and destruction

• Objects often require special initialization when they are first created.

• constructors are automatically called once a new instance object is created.

• finalize is required when an object is just about to be de-allocated. (Java: not allow manual memory allocation)

17CS451 - Lecture 2

Object creation and destruction

new: allocates the object and returns a reference to the newly-instantiated object invokes all instance variable initialization

invokes the constructor to initialize the object.

• finalize not equivalent to a destructor (release all critical

resources implicitly)

Called before the garbage collector frees up the object's memory

18CS451 - Lecture 2

Object behavior (Method)

• defined by its methods, which have some connection to a class

associated with a signature: a unique identifying name and parameter list, and a return type

all parameters are passed by value instance methods (invoked on an object), and

class methods (invoked on the class itself, even if no objects of that type exist)

19CS451 - Lecture 2

Instance methods

• methods you call on instances of a class. They make up the majority of the behavior in most classes.

• Encapsulation "requires" accessor and mutator methods for all instance variables

• accessing an instance method from outside the class is through a current object reference with the dot (.) notation

20CS451 - Lecture 2

Class methods

Can only operate on class variables (e.g., static)

To access a class method from outside the class, you must use the name of the class with the dot (.) notation as in Class.foo

Use class method name to access from within the class

21CS451 - Lecture 2

Method overloading

• Method overloading occurs whenever two or more methods have the same name, but different parameter lists in terms of number and/or type of parameters

resolved by matching number and types of parameters in method invocation against arguments in method definition

if no exact match, type coercions (type casts) are used to find the closest match

22CS451 - Lecture 2

Object Interfaces

• The interface keyword directly supports the separation of interface definition (of abstract data types) from their implementation.

• The implements keyword indicates that a class implements one or more interfaces.

• A class must conform with any interface it implements. This means every method specified in the interface must be implemented.

23CS451 - Lecture 2

Interface Classes

• Interface classes list only the signatures not bodies of methods.

• Interfaces support a kind of multiple inheritance: an interface or an implementation class can be subclass (can implement) several interfaces.

• No code is inherited from any of the interface class.

24CS451 - Lecture 2

Interface Classes

The larger a class' public interface, the closer the coupling of that class to other classes

The closer a class' coupling, the more work is required by client classes when the supplier changes

to decrease coupling and increase modularity Keep interface classes small

Use Java access modifiers wisely to maintain encapsulation and reduce coupling

Keep all state information inside the class

25CS451 - Lecture 2

Access modifiers: private and public

• In implementation classes, access modifier is attached to both methods and attributes at declaration time to govern their visibility to other classes.

• A class' public interface is the set of methods and attributes (accessor methods) accessible from outside the class.

• Public/Private: Accessible from any other class - provided an object reference is available / Accessible only from within the class in which they are declared

26CS451 - Lecture 2

Inheritance

• class A is the...

– parent

– ancestor

– superclass

– base class

• class B is the…– child

– descendent

– subclass

– derived class

27CS451 - Lecture 2

Inheritance

• A child class will inherit all non-private attributes and methods from it's parent

Subclasses are said to "specialize" superclasses' functionality and/or state

Base classes are often left unimplemented, and serve merely as a specification for a minimum subset of data and functionality in derived classes

28CS451 - Lecture 2

Inheritance

accomplished through the use of the extends keyword

Inheritance implies an "is-a" relationship between two classes (i.e., class B "is-a" type of class A, if class B inherits from class A)

If the derived class implements additional functionality to the parent class, the relationship is between the two classes is referred to as is-a-kind-of rather than just "is-a".