Java OOPS Study Guide

What is OOPS, Purpose of OOPS, Advantages and Disadvantages

Revision Guide with Headings, Tables, Examples, and Explanations

1. What is OOPS (Object-Oriented Programming System)?

Object-Oriented Programming System (OOPS) is a programming paradigm that uses classes
and objects to design software. It allows developers to model real-world entities such as
students, cars, and bank accounts.

Key Terms
Term Definition

Class Blueprint used to create objects

Object Instance of a class

Property Variable that stores data

Method Function that defines behavior

Example:

class Student {
String name;
int age;

void study() {
[Link]("Student is studying");
}
}

Student s1 = new Student();

2. Purpose of OOPS

Purpose Explanation

Code Reusability Reuse code multiple times

Security Protect data using encapsulation

Maintainability Fix bugs easily

Scalability Support large systems

Real-world modeling Represent real objects

3. Advantages of OOPS

Advantage Explanation

Reusability Write once, use many times

Security Protect sensitive data

Easy maintenance Fix errors quickly

Modularity Divide program into classes

Scalability Build enterprise applications

4. Disadvantages of OOPS

Disadvantage Explanation

Complexity Hard for beginners

Memory usage Consumes more memory

Planning required Needs proper design

Performance overhead Object creation overhead

 Java Class and Object Study Guide
Complete Revision Guide with Definitions, Tables, Examples, and Explanations

1. Introduction to Class and Object

Class and Object are the fundamental concepts of Object-Oriented Programming (OOPS) in
Java. A class is a blueprint used to create objects, and an object is an instance of a class.
These concepts allow developers to model real-world entities in software.

2. What is a Class?
A class is a user-defined data type that contains variables (properties) and methods
(behaviors). It defines the structure and functionality of objects.

Syntax Example:

class Student {
String name;
int age;

void study() {
[Link]("Student is studying");
}
}

Class Components
Component Description

Variables Store object data

Methods Define object behavior

Constructors Initialize objects

Access Modifiers Control access level

3. What is an Object?
An object is an instance of a class. It represents a real-world entity and contains actual
values for the properties defined in the class.

Syntax Example:

Student s1 = new Student();

Object Characteristics
Characteristic Description

State Represents object data (variables)

Behavior Represents object methods

Identity Unique object reference

4. Complete Example
class Car {
String brand;
int speed;

void drive() {
[Link](brand + " is driving at " + speed + " km/h");
}
}

public class Main {

public static void main(String[] args) {
Car c1 = new Car();
[Link] = "BMW";
[Link] = 120;
[Link]();
}
}
5. Difference Between Class and Object
Feature Class Object

Definition Blueprint Instance of class

Memory No memory allocated Memory allocated

Purpose Defines structure Stores actual values

Example Car BMW car

6. Advantages of Using Class and Object

• Code reusability
• Better code organization
• Easy maintenance
• Real-world modeling
• Scalability
 Java Encapsulation Study Guide
Complete Revision Guide with Definitions, Tables, Examples, and Explanations

1. What is Encapsulation?
Encapsulation is one of the core concepts of Object-Oriented Programming (OOPS). It is the
process of wrapping data (variables) and code (methods) together into a single unit called a
class. Encapsulation also restricts direct access to data using access modifiers and allows
controlled access using getter and setter methods.

2. Purpose of Encapsulation
Purpose Explanation

Data hiding Protect sensitive data from direct access

Security Prevent unauthorized modification

Control access Allow controlled access using methods

Flexibility Change implementation without affecting

other code

Maintainability Make code easier to manage

3. How Encapsulation Works

Encapsulation is implemented using:
• Private variables (data hiding)
• Public getter methods (read access)
• Public setter methods (write access)
4. Example of Encapsulation
class Student {
private String name;

public void setName(String name) {

[Link] = name;
}

public String getName() {

return name;
}
}

public class Main {

public static void main(String[] args) {
Student s1 = new Student();
[Link]("Anif");
[Link]([Link]());
}
}

5. Without Encapsulation vs With Encapsulation

Feature Without Encapsulation With Encapsulation

Access Direct access allowed Access controlled

Security Low security High security

Flexibility Less flexible More flexible

Maintainability Harder to maintain Easier to maintain

6. Advantages of Encapsulation
Advantage Explanation

Data security Protect sensitive data

Controlled access Use getter and setter

Improved maintainability Easy to update code

Improved flexibility Change internal implementation

Better modularity Organized code structure

7. Summary
Encapsulation is a key OOPS principle used to protect data and control access. It improves
security, maintainability, and flexibility in Java applications.
 Java Inheritance Study Guide
Complete Revision Guide with Definitions, Types, Tables, Examples, and Explanations

1. What is Inheritance?
Inheritance is one of the core concepts of Object-Oriented Programming (OOPS). It allows
one class (child class) to inherit the properties and methods of another class (parent class).
This promotes code reusability and establishes a relationship between classes.

2. Purpose of Inheritance
Purpose Explanation

Code Reusability Reuse properties and methods of existing

class

Reduce redundancy Avoid duplicate code

Method extension Add new features in child class

Maintainability Easy to manage and update code

Hierarchy representation Represents real-world relationships

3. Syntax of Inheritance
class Parent {
// properties and methods
}

class Child extends Parent {

// additional properties and methods
}
4. Example of Inheritance
class Animal {
void eat() {
[Link]("Animal is eating");
}
}

class Dog extends Animal {

void bark() {
[Link]("Dog is barking");
}
}

public class Main {

public static void main(String[] args) {
Dog d = new Dog();
[Link]();
[Link]();
}
}

5. Types of Inheritance in Java

Type Description

Single Inheritance One child inherits from one parent

Multilevel Inheritance Chain of inheritance

Hierarchical Inheritance Multiple children inherit from one parent

Multiple Inheritance Not supported with classes (supported via

interfaces)
6. Advantages of Inheritance
Advantage Explanation

Code reuse Reuse existing class code

Improved maintainability Easy to manage

Extensibility Add new features easily

Improved structure Better code organization

7. Summary
Inheritance allows a class to inherit properties and methods from another class. It improves
code reuse, structure, and maintainability.
 Java Polymorphism Study Guide
Complete Revision Guide with Definitions, Types, Tables, Examples, and Explanations

1. What is Polymorphism?
Polymorphism is one of the core concepts of Object-Oriented Programming (OOPS). The
word polymorphism means 'many forms'. It allows one method, object, or operator to
perform different tasks depending on the context.

2. Purpose of Polymorphism
Purpose Explanation

Flexibility Same interface, different implementation

Code reusability Reuse method names

Extensibility Easily add new behavior

Maintainability Simplifies code updates

3. Types of Polymorphism
Type Description

Compile-time Polymorphism Method overloading

Runtime Polymorphism Method overriding

4. Compile-Time Polymorphism (Method Overloading)
class Calculator {
int add(int a, int b) {
return a + b;
}

int add(int a, int b, int c) {

return a + b + c;
}
}

5. Runtime Polymorphism (Method Overriding)

class Animal {
void sound() {
[Link]("Animal makes sound");
}
}

class Dog extends Animal {

void sound() {
[Link]("Dog barks");
}
}

Animal a = new Dog();

[Link]();

6. Advantages of Polymorphism
Advantage Explanation

Code flexibility One interface, multiple behavior

Code reuse Reuse existing code

Improved readability Cleaner code

Extensibility Easy to extend functionality

 Java Abstraction Study Guide
Complete Revision Guide with Definitions, Methods, Tables, Examples, and Explanations

1. What is Abstraction?
Abstraction is one of the core concepts of Object-Oriented Programming (OOPS). It is the
process of hiding implementation details and showing only essential features to the user.
Abstraction helps reduce complexity and improves code maintainability.

2. Purpose of Abstraction
Purpose Explanation

Hide implementation User does not see internal logic

Reduce complexity Simplifies usage

Improve security Sensitive details are hidden

Improve maintainability Easy to modify code

Improve flexibility Supports scalable design

3. How Abstraction is Achieved in Java

Method Description

Abstract class Class with abstract and concrete methods

Interface Fully abstract class with abstract methods

4. Example using Abstract Class
abstract class Animal {
abstract void sound();
}

class Dog extends Animal {

void sound() {
[Link]("Dog barks");
}
}

Animal a = new Dog();

[Link]();

5. Example using Interface

interface Vehicle {
void start();
}

class Car implements Vehicle {

public void start() {
[Link]("Car starts");
}
}

6. Advantages of Abstraction
Advantage Explanation

Reduces complexity Simplifies code usage

Improves security Hides implementation

Improves maintainability Easy to update

Supports flexibility Supports scalable systems

7. Summary
Abstraction hides implementation details and shows only essential features. It improves
security, flexibility, and maintainability in Java applications.
 Java Association, Aggregation, and
Composition Study Guide
Complete Revision Guide with Definitions, Comparisons, Tables, Examples, and
Explanations

1. Association
Association is a relationship between two classes where objects of one class use or interact
with objects of another class. It represents a 'uses-a' relationship. Both objects can exist
independently.

Example:
class Student {
String name;
}

class Teacher {
String name;

void teach(Student s) {
[Link]("Teacher teaches student");
}
}

Feature Association

Relationship Uses-a relationship

Dependency Weak dependency

Lifetime Independent objects

2. Aggregation
Aggregation is a special type of association that represents a 'has-a' relationship. It
represents a weak ownership. The child object can exist independently of the parent.

Example:
class Address {
String city;
}

class Student {
Address address;

Student(Address address) {
[Link] = address;
}
}

Feature Aggregation

Relationship Has-a relationship

Dependency Weak ownership

Lifetime Independent objects

3. Composition
Composition is a strong form of aggregation. It represents a strong 'has-a' relationship. The
child object cannot exist independently of the parent.

Example:
class Engine {
}

class Car {
private Engine engine;

Car() {
engine = new Engine();
}
}

Feature Composition

Relationship Strong has-a relationship

Dependency Strong ownership

Lifetime Dependent objects

4. Comparison Table
Feature Association Aggregation Composition

Relationship Uses-a Has-a Strong has-a

Ownership No ownership Weak ownership Strong ownership

Lifetime Independent Independent Dependent

dependency

Example Teacher-Student Student-Address Car-Engine

5. Summary
Association, Aggregation, and Composition define relationships between classes.
Association is a general relationship, Aggregation is weak ownership, and Composition is
strong ownership.