1.

Overview of Object-Oriented Programming (OOP)

Java is an Object-Oriented Programming (OOP) language, which means it follows the

OOP paradigm to design and develop software. OOP allows you to model real-world entities
and interactions using objects and classes.

Key Features of OOP:

 Encapsulation: Binding data (attributes) and methods (functions) that manipulate the
data within a single unit (class). It helps in data hiding and protecting object integrity.
 Abstraction: Hiding complex implementation details and exposing only the essential
features of an object.
 Inheritance: Allows one class (subclass/child) to inherit properties and methods from
another class (superclass/parent).
 Polymorphism: Allows objects to be treated as instances of their parent class.
Polymorphism supports method overloading (compile-time) and method overriding
(runtime).

2. Classes and Objects in Java

Class:

A class is a blueprint or template for creating objects. It defines the properties (fields) and
behaviors (methods) of the object.

Syntax of a Class:

class ClassName {

// fields (attributes)

int field1;

String field2;

// methods (behaviors)

void methodName() {

// method body

Object:
An object is an instance of a class. It represents a real-world entity and is created from the
class.

Creating an Object:

ClassName obj = new ClassName();

Example: Class and Object in Java

public class Car {

// Fields (attributes)

String brand;

int speed;

// Method (behavior)

void displayInfo() {

System.out.println("Brand: " + brand + ", Speed: " + speed + " km/h");

public static void main(String[] args) {

// Creating an object of the Car class

Car myCar = new Car();

// Setting the values of the object's fields

myCar.brand = "Toyota";

myCar.speed = 120;

// Calling the object's method

myCar.displayInfo(); // Output: Brand: Toyota, Speed: 120 km/h

 Class: Car defines two fields (brand and speed) and a method (displayInfo).
  Object: myCar is an instance of the Car class, and the method displayInfo is called
on it.

3. Constructors in Java

A constructor is a special method used to initialize objects. A constructor has the same name
as the class and no return type.

Types of Constructors:

1. Default Constructor: Provided by Java when no constructor is explicitly defined.

2. Parameterized Constructor: Allows passing parameters to initialize object fields
when the object is created.

Example: Default Constructor:

public class Book {

String title;

int pages;

// Default constructor

Book() {

title = "Unknown";

pages = 0;

void display() {

System.out.println("Title: " + title + ", Pages: " + pages);

public static void main(String[] args) {

Book myBook = new Book(); // Calls default constructor

myBook.display(); // Output: Title: Unknown, Pages: 0

}
Example: Parameterized Constructor:

public class Book {

String title;

int pages;

// Parameterized constructor

Book(String t, int p) {

title = t;

pages = p;

void display() {

System.out.println("Title: " + title + ", Pages: " + pages);

public static void main(String[] args) {

Book myBook = new Book("Java Programming", 500); // Calls parameterized constructor

myBook.display(); // Output: Title: Java Programming, Pages: 500

4. Encapsulation

Encapsulation is the process of wrapping data (fields) and methods into a single unit (class).
It restricts direct access to fields and allows access through methods (getters and setters).

Example of Encapsulation:

public class Person {

// Private fields

private String name;

private int age;

 // Public getter method

public String getName() {

return name;

// Public setter method

public void setName(String name) {

this.name = name;

// Public getter method

public int getAge() {

return age;

// Public setter method

public void setAge(int age) {

this.age = age;

public static void main(String[] args) {

Person person = new Person();

person.setName("John");

person.setAge(30);

System.out.println("Name: " + person.getName());

System.out.println("Age: " + person.getAge());

}
The name and age fields are private and can only be accessed through the getName, setName,
getAge, and setAge methods, ensuring data security.

5. Inheritance in Java

Inheritance allows a class to inherit fields and methods from another class. It promotes code
reusability and establishes a parent-child relationship between classes.

 Superclass (Parent): The class being inherited from.

 Subclass (Child): The class that inherits from the superclass.

Syntax:

class ParentClass {

// Fields and methods

class ChildClass extends ParentClass {

// Additional fields and methods

Example of Inheritance:

// Superclass

class Animal {

String name;

void makeSound() {

System.out.println(name + " makes a sound.");

// Subclass

class Dog extends Animal {

void bark() {

System.out.println(name + " barks.");

 }

public class Main {

public static void main(String[] args) {

Dog dog = new Dog();

dog.name = "Buddy";

dog.makeSound(); // Inherited from Animal class

dog.bark(); // Defined in Dog class

6. Polymorphism in Java

Polymorphism allows objects to take many forms. The two types of polymorphism in Java
are:

1. Compile-time Polymorphism (Method Overloading): Multiple methods have the

same name but different parameter types or numbers.
2. Run-time Polymorphism (Method Overriding): A subclass provides a specific
implementation of a method that is already defined in its superclass.

Example of Method Overriding:

// Superclass

class Animal {

void makeSound() {

System.out.println("The animal makes a sound");

// Subclass

class Dog extends Animal {

// Overriding the method of the superclass

@Override
 void makeSound() {

System.out.println("The dog barks");

public class Main {

public static void main(String[] args) {

Animal myDog = new Dog(); // Upcasting

myDog.makeSound(); // Output: The dog barks

7. Practice Problems (Day 7–8)

Problem 1: Define a Person Class

Define a class Person with attributes name and age, and a method introduce to print a
greeting message.

public class Person {

String name;

int age;

void introduce() {

System.out.println("Hi, I am " + name + " and I am " + age + " years old.");

public static void main(String[] args) {

Person person1 = new Person();

person1.name = "Alice";

person1.age = 25;

person1.introduce();

}
Problem 2: Create a LibraryBook Class with Constructor

Create a class LibraryBook that includes attributes like title, author, and ISBN. Create a
constructor to initialize these values and a method to display them.

public class LibraryBook {

String title;

String author;

String ISBN;

// Parameterized constructor

LibraryBook(String title, String author, String ISBN) {

this.title = title;

this.author = author;

this.ISBN = ISBN;

// Method to display book details

void displayDetails() {

System.out.println("Title: " + title + ", Author: " + author + ", ISBN: " + ISBN);

public static void main(String[] args) {

LibraryBook book = new LibraryBook("Java Programming", "John Doe", "1234567890");

book.displayDetails();

Problem 3: Demonstrate Inheritance

Create a base class Vehicle with a method start. Derive a subclass Car that inherits the
start method and adds a drive method.

class Vehicle {
 void start() {

System.out.println("The vehicle starts.");

class Car extends Vehicle {

void drive() {

System.out.println("The car drives.");

public class Main {

public static void main(String[] args) {

Car myCar = new Car();

myCar.start(); // Inherited from Vehicle class

myCar.drive(); // Defined in Car class

Day 7–8 Goals

 Understand the concepts of OOP: classes, objects, constructors, encapsulation,

inheritance, and polymorphism.
 Practice creating classes and objects, working with constructors, and using
inheritance and polymorphism.
 Gain confidence in applying OOP concepts to solve problems using real-world
examples.