Introduction to Java

Object-Oriented
Programming
(OOP)
Java is an object-oriented programming language. This means that it is based on
the concept of objects. An object is a self-contained unit of data and code.
Object-oriented programming is a popular paradigm for designing software.

by Sahil Kshirsagar
Fundamental Concepts of Java OOP
1 Encapsulation
Hides data and methods within a class, allowing
access only through defined interfaces. This
promotes code organization and protects data
integrity.
3 Inheritance
Allows classes to inherit properties and methods
from parent classes, promoting code reusability
and creating hierarchical relationships between
objects.
2 Abstraction
Simplifies complex functionality by exposing only
essential details. This enhances code readability
and reduces complexity for users.
4 Polymorphism
Enables objects to take on multiple forms,
allowing different classes to respond to the same
message in their own way, promoting flexibility
and extensibility.
Classes and Objects in Java
Class
A blueprint or template for
creating objects. Defines the data
(attributes) and methods (behavior)
that objects of that class will have.
Object
An instance of a class. It is a real-
world entity that has its own
unique set of data and methods.
For example, a "Dog" class might
have attributes like name, breed,
and age, and methods like bark and
wagTail.
Example
The "Car" class would define
attributes like make, model, and
year, and methods like accelerate
and brake. A specific car like a
"Toyota Camry" would be an
object of the "Car" class.
Inheritance in Java
Parent Class
(Superclass)
Defines general characteristics
and behaviors common to a group
of related objects.
Child Class (Subclass)
Inherits properties and methods
from the parent class, adding its
own specific characteristics and
behaviors.
Example
A "Dog" class could inherit from
a "Animal" class, inheriting
properties like name and age,
while adding its own specific
behaviors like barking and
wagging its tail.
Polymorphism in Java
Compile-Time Polymorphism
Method overloading allows multiple
methods with the same name but different
parameters within the same class. The
compiler chooses the appropriate method
based on the provided parameters.
Runtime Polymorphism
Method overriding allows subclasses to
provide their own implementations of
methods inherited from parent classes. The
actual method called depends on the
object's runtime type.

Example
A "Cat" class might override the "speak" method inherited from the "Animal" class to make a
"meow" sound instead of the general "animal sound" from the parent class.
Encapsulation in Java
1 Data Hiding
Data members are declared as private, preventing direct access from outside the
class.

2 Getter and Setter Methods

Public methods provide controlled access to private data members. Getters retrieve
data, and setters modify data.

3 Example
A "Bank Account" class might have private attributes like balance and account
number, with public methods like getBalance and deposit to access and modify
these data members.
Abstraction in Java
Abstract Classes
Define common methods that
subclasses must implement,
providing a template for related
objects.
Interfaces
Specify methods that classes must
implement, but without providing
concrete implementations. They
enforce a standard for implementing
certain behaviors.
Example
An "Animal" abstract class could
define an abstract "speak" method,
which subclasses like "Dog" and
"Cat" would need to implement
according to their specific sounds.
Java OOP Example and Syntax
Class Declaration public class Animal {

Data Members private String name;

Constructor public Animal(String name) { this.name = name; }

Method public void speak() { System.out.println("Animal

sound"); }

Getter Method public String getName() { return name; }

Setter Method public void setName(String name) { this.name =

name; }

Main Method public static void main(String[] args) { Animal dog =

new Animal("Buddy"); dog.speak(); }