Java OOPS – Full 6 Pages Detailed Notes

Page 1: Introduction to OOPS and Java Basics

Object-Oriented Programming System (OOPS) is a programming paradigm based on the concept of objects.
Objects represent real-world entities and contain both data (fields) and behavior (methods). OOPS aims to organize
software design around data rather than functions and logic. This approach improves code reusability, modularity,
scalability, and maintainability.

Java is a strongly typed, object-oriented, and platform-independent programming language widely used for building
enterprise applications, web services, mobile apps (Android), and distributed systems. Java follows the principle of
“Write Once, Run Anywhere” (WORA) because Java programs compile into bytecode that runs on the Java Virtual
Machine (JVM).

In Java, everything is associated with classes and objects (except primitive data types). A class is a blueprint or
template used to create objects. Objects are instances of classes that represent real-world entities. For example, a
class Car may have properties like color and speed, and methods like start() and stop().

Java programs follow a structured lifecycle: writing source code, compiling with the Java compiler (javac), and
executing on the JVM. The JVM handles memory management, garbage collection, and security. This abstraction
makes Java applications portable across different operating systems.

Key advantages of OOPS in Java include code reusability through inheritance, data security through encapsulation,
flexibility through polymorphism, and abstraction to hide implementation details. These principles form the
foundation of robust and maintainable Java applications.
Page 2: Classes, Objects, Encapsulation, and Data Hiding

A class in Java defines the structure and behavior of objects. It contains fields (variables) and methods (functions).
Objects are created using the new keyword and represent real entities in memory. Each object has its own state
and can perform actions defined by its class.

Encapsulation is the concept of wrapping data and methods into a single unit (class). It helps in protecting the
internal state of an object from unauthorized access. In Java, encapsulation is achieved by declaring class variables
as private and providing public getter and setter methods to access and modify them. This ensures controlled
access to data.

Data hiding is closely related to encapsulation. By restricting direct access to class variables, developers can
prevent unintended modification of data. This improves security and reliability of the code. Access modifiers such as
private, protected, default, and public define the visibility of classes, methods, and variables.

The use of encapsulation allows developers to change the internal implementation of a class without affecting other
parts of the program. As long as the public interface remains the same, internal changes do not break dependent
code. This supports maintainability and flexibility in large applications.

Encapsulation also enables validation logic within setter methods. For example, a setter method can validate input
values before assigning them to class fields. This ensures that objects always remain in a valid state, improving
overall program robustness.
Page 3: Inheritance and Code Reusability

Inheritance is a mechanism in Java that allows a class (subclass) to acquire the properties and behaviors of another
class (superclass). It promotes code reusability and establishes a parent-child relationship between classes. The
keyword extends is used to implement inheritance in Java.

Through inheritance, common functionality can be defined in a base class and reused by multiple subclasses. This
reduces code duplication and improves maintainability. For example, a base class Employee can define common
attributes like id and name, while subclasses like Manager and Developer can extend this functionality with specific
features.

Java supports single inheritance for classes, meaning a class can extend only one superclass. However, Java
supports multiple inheritance through interfaces. This design choice avoids ambiguity issues such as the diamond
problem. Interfaces allow a class to implement multiple behaviors without inheriting implementation.

Method overriding allows a subclass to provide a specific implementation of a method already defined in its
superclass. This supports runtime polymorphism and enables dynamic behavior. The @Override annotation helps
ensure that the method signature matches the parent class method.

The use of the super keyword allows subclasses to access superclass members and constructors. Proper use of
inheritance supports extensibility and helps build hierarchical class structures that reflect real-world relationships
between entities.
Page 4: Polymorphism and Method Overloading/Overriding

Polymorphism means “many forms” and allows objects to be treated as instances of their parent class while
exhibiting different behavior. It enables one interface to represent multiple underlying forms. Polymorphism
improves flexibility and scalability of object-oriented programs.

Compile-time polymorphism in Java is achieved through method overloading. Method overloading allows multiple
methods with the same name but different parameter lists within the same class. The compiler determines which
method to call based on the method signature at compile time.

Runtime polymorphism is achieved through method overriding. When a subclass overrides a method of its
superclass, the method call is resolved at runtime based on the object type. This allows dynamic method dispatch,
where the JVM decides which method implementation to execute.

Polymorphism supports the principle of “programming to an interface.” Developers can write code that depends on
abstract classes or interfaces rather than concrete implementations. This reduces coupling and improves
extensibility.

Real-world examples of polymorphism include different shapes implementing a draw() method or different payment
methods implementing a processPayment() method. Each implementation behaves differently while sharing a
common interface, enabling flexible and scalable designs.
Page 5: Abstraction, Abstract Classes, and Interfaces

Abstraction is the process of hiding implementation details and exposing only essential features of an object. It
allows developers to focus on what an object does rather than how it does it. Abstraction reduces complexity and
improves code readability and maintainability.

In Java, abstraction is implemented using abstract classes and interfaces. An abstract class can contain both
abstract methods (without implementation) and concrete methods (with implementation). It can also have instance
variables and constructors. Abstract classes are used when there is a base class with common functionality and
some methods to be implemented by subclasses.

Interfaces define a contract that implementing classes must follow. They contain method declarations (and default
methods in modern Java). A class can implement multiple interfaces, enabling multiple inheritance of behavior.
Interfaces are ideal for defining capabilities or roles such as Runnable, Serializable, or Comparable.

Abstraction enables loose coupling between components. By coding against interfaces rather than concrete
classes, applications become more flexible and easier to modify or extend. This supports dependency inversion and
better software design principles.

The use of abstraction promotes cleaner architecture, testability, and easier maintenance. It allows developers to
change implementations without affecting dependent code, as long as the abstract contract remains consistent.
Page 6: Relationships, Composition, and Best Practices

In object-oriented design, relationships between classes include association, aggregation, and composition.
Association represents a general relationship between objects. Aggregation represents a “has-a” relationship where
objects can exist independently. Composition is a stronger form of aggregation where the lifecycle of child objects
depends on the parent object.

Composition is often preferred over inheritance because it provides greater flexibility and avoids tight coupling
between classes. By composing objects, developers can change behavior at runtime and build modular systems.
This follows the principle of “favor composition over inheritance.”

Good object-oriented design follows principles such as SOLID: Single Responsibility, Open/Closed, Liskov
Substitution, Interface Segregation, and Dependency Inversion. These principles help create scalable,
maintainable, and extensible software systems.

Best practices in Java OOPS include writing small, cohesive classes, avoiding tight coupling, using interfaces for
abstraction, handling exceptions properly, and following naming conventions. Code should be modular, readable,
and well-documented.

Regular refactoring, unit testing, and design reviews help maintain code quality over time. Applying OOPS principles
effectively enables developers to build robust, scalable, and maintainable Java applications that can evolve with
changing requirements.