CS311 Short Notes by Beyza Aysun

MODULE 1: Object Oriented Paradigm

Objective: This module covers Object Orientation in detail, including Data Modeling, Abstraction, Inheritance, Encapsulation, Information Hiding, and their use in classes.

What is Object Orientation?

In the real world, the object-oriented approach focuses on objects that represent abstract or concrete things. Objects are the basic building blocks of OOP.

What is an Object?

Objects are key to understanding object-oriented programming. Look around yourself and you'll find many real-world examples: your dog, your desk, your TV, your bicycle. An object has two key characteristics: State — a noun, attribute, or well-defined property (e.g., dog's colour, name, breed) Behavior — a certain operation or action (e.g., dog's barking, fetching)

Note: Object = Variables + Functions. Example: Ali, House, Car are objects. Relation: Ali lives in the house, Ali drives a car.

What is a Model?

Modeling is an approach used at the beginning of software development. Reasons to model: Communication: Diagrams before implementation help users give feedback on system structure. Abstraction: Define what functionality is needed, then refine into an implementable design.

What is Abstraction?

Abstraction is the process of taking out essential characteristics from something in order to reduce it to a set of key features. A programmer hides irrelevant data about an object to reduce complexity and increase efficiency.

Graphical Class Representation: Class name at the top Attributes in the middle Operations/methods at the bottom + (plus) = public, −(minus) = private, # = protected

Advantages of Abstraction: Separate things that can be grouped to another type Frequently changing properties can be grouped separately Simplifies the representation of domain models

What is Inheritance?

Inheritance enables new objects to take on the properties of existing objects. Superclass / Base Class / Parent Class — the class from which properties are inherited Subclass / Derived Class / Child Class — the class that inherits A child inherits all characteristics of its parent and can add additional ones

Superclass (Parent)

Subclass (Child)

Also called Base Class Also called Derived Class Provides common properties Inherits + adds own properties Example: Animal Example: Dog, Cat Example: Fruit Example: Orange, Apple Example: Vehicle Example: Car, Bike

Types of Inheritance · Type · Description · Example

Single Inheritance One parent →One child Animal →Dog Multilevel Inheritance Grandparent →Parent → Child A →B →C

Multiple Inheritance Multiple parents →One child A, B →C

Hierarchical One parent →Multiple children Animal →Cat, Dog

Generalization & Specialization · Generalization · Specialization

Combining common features Creating specific classes from general Bottom-up approach Top-down approach Example: Cat + Dog →Animal Example: Animal →Cat

Encapsulation & Information Hiding

Encapsulation is a way to obtain information hiding — you don't need to know the internal working of a mobile phone to operate it. You have an interface to use the device behavior without knowing implementation details. Encapsulation = bundling data and methods together Information Hiding = hiding sensitive data from outside access

Accessibility

public Accessible from anywhere private Only within the same class protected Same class + subclasses default (no modifier) Same package only

Relationships: Association, Aggregation & Composition · Composition · Aggregation

Strong whole-part relationship Weak relationship Child cannot exist without parent Child can exist independently Parent deleted →Child deleted Parent deleted →Child survives Example: House has Rooms Example: Department has Teachers

Abstract Class vs Interface · Abstract Class · Interface

Can have some implementation Only method declarations (Java < 8) Uses extends keyword Uses implements keyword 'is-a' relationship Contract / Service agreement Can have constructors Cannot have constructors

Overloading vs Overriding

Same class Parent-child classes Different parameters Same parameters Compile-time polymorphism Runtime polymorphism