1.

Constructor Overloading: Book Class

Question: Create a Book class with attributes title, author, and price. Implement the
following overloaded constructors:

 One that takes no parameters and initializes default values.

 One that takes only the title and author.
 One that takes all three attributes: title, author, and price.

Solution:

class Book {
String title;
String author;
double price;

// Constructor with no parameters, sets default values

public Book() {
this.title = "Unknown Title";
this.author = "Unknown Author";
this.price = 0.0;
}

// Constructor with title and author only

public Book(String title, String author) {
this.title = title;
this.author = author;
this.price = 0.0; // Default price
}

// Constructor with all parameters

public Book(String title, String author, double price) {
this.title = title;
this.author = author;
this.price = price;
}

// Method to display book details

public void displayDetails() {
System.out.println("Title: " + title + ", Author: " + author + ",
Price: $" + price);
}

public static void main(String[] args) {

// Create objects using different constructors
Book book1 = new Book();
Book book2 = new Book("The Alchemist", "Paulo Coelho");
Book book3 = new Book("1984", "George Orwell", 15.99);

// Display the details of each book

book1.displayDetails();
book2.displayDetails();
book3.displayDetails();
}
}

2. Constructor Overloading: Rectangle Class

Question: Write a Rectangle class that has attributes length and width. Implement multiple
constructors:

 A constructor that sets both dimensions to a default value.

 A constructor that sets only the length.
 A constructor that sets both length and width.

Solution:

class Rectangle {
double length;
double width;

// Constructor with default values for length and width

public Rectangle() {
this.length = 1.0;
this.width = 1.0;
}

// Constructor that sets only the length, default width

public Rectangle(double length) {
this.length = length;
this.width = 1.0; // Default width
}

// Constructor that sets both length and width

public Rectangle(double length, double width) {
this.length = length;
this.width = width;
}

// Method to calculate the area of the rectangle

public double calculateArea() {
return length * width;
}

public static void main(String[] args) {

// Create objects using different constructors
Rectangle rect1 = new Rectangle();
Rectangle rect2 = new Rectangle(5.0);
Rectangle rect3 = new Rectangle(4.0, 6.0);

// Calculate and display the area of each rectangle

System.out.println("Rectangle 1 Area: " + rect1.calculateArea());
System.out.println("Rectangle 2 Area: " + rect2.calculateArea());
System.out.println("Rectangle 3 Area: " + rect3.calculateArea());
}
}
3. Constructor Overloading: BankAccount Class

Question: Create a BankAccount class with attributes accountNumber, accountHolderName,

and balance. Implement overloaded constructors:

 One that takes no arguments.

 One that takes accountNumber and accountHolderName.
 One that takes all attributes (accountNumber, accountHolderName, and balance).

Solution:

class BankAccount {
String accountNumber;
String accountHolderName;
double balance;

// Constructor with no arguments, initializes default values

public BankAccount() {
this.accountNumber = "000000";
this.accountHolderName = "Unknown";
this.balance = 0.0;
}

// Constructor with accountNumber and accountHolderName

public BankAccount(String accountNumber, String accountHolderName) {
this.accountNumber = accountNumber;
this.accountHolderName = accountHolderName;
this.balance = 0.0; // Default balance
}

// Constructor with all attributes

public BankAccount(String accountNumber, String accountHolderName, double
balance) {
this.accountNumber = accountNumber;
this.accountHolderName = accountHolderName;
this.balance = balance;
}

// Method to display account details

public void displayDetails() {
System.out.println("Account Number: " + accountNumber +
", Account Holder: " + accountHolderName +
", Balance: $" + balance);
}

public static void main(String[] args) {

// Create objects using different constructors
BankAccount account1 = new BankAccount();
BankAccount account2 = new BankAccount("123456", "John Doe");
BankAccount account3 = new BankAccount("789012", "Jane Smith",
500.0);
 // Display account details
account1.displayDetails();
account2.displayDetails();
account3.displayDetails();
}
}

4. Composition: Computer and Processor Classes

Question: Create a Computer class that has a Processor class as a member. The Processor
class has attributes brand and speed. The Computer class has attributes brand, model, and a
Processor object.

Solution:

// Processor class (a part of Computer)

class Processor {
String brand;
double speed; // in GHz

// Constructor to initialize Processor

public Processor(String brand, double speed) {
this.brand = brand;
this.speed = speed;
}

// Method to display processor details

public void displayProcessorDetails() {
System.out.println("Processor Brand: " + brand + ", Speed: " + speed
+ " GHz");
}
}

// Computer class (contains a Processor)

class Computer {
String brand;
String model;
Processor processor; // Composition: Processor is part of Computer

// Constructor to initialize Computer with Processor

public Computer(String brand, String model, Processor processor) {
this.brand = brand;
this.model = model;
this.processor = processor;
}

// Method to display computer details

public void displayComputerDetails() {
System.out.println("Computer Brand: " + brand + ", Model: " + model);
processor.displayProcessorDetails(); // Display processor info
}
 public static void main(String[] args) {
// Create a Processor object
Processor processor = new Processor("Intel", 3.5);

// Create a Computer object with a Processor

Computer computer = new Computer("Dell", "Inspiron", processor);

// Display details of the computer and its processor

computer.displayComputerDetails();
}
}

5. Composition: Smartphone and Camera Classes

Question: Write a Smartphone class that has a Camera class as a member. The Camera class has
attributes resolution and aperture. The Smartphone class has attributes brand, model, and a
Camera object.

Solution:

// Camera class (a part of Smartphone)

class Camera {
String resolution;
double aperture;

// Constructor to initialize Camera

public Camera(String resolution, double aperture) {
this.resolution = resolution;
this.aperture = aperture;
}

// Method to display camera details

public void displayCameraDetails() {
System.out.println("Camera Resolution: " + resolution + ", Aperture:
" + aperture);
}
}

// Smartphone class (contains a Camera)

class Smartphone {
String brand;
String model;
Camera camera; // Composition: Camera is part of Smartphone

// Constructor to initialize Smartphone with Camera

public Smartphone(String brand, String model, Camera camera) {
this.brand = brand;
this.model = model;
this.camera = camera;
}
 // Method to display smartphone details
public void displaySmartphoneDetails() {
System.out.println("Smartphone Brand: " + brand + ", Model: " +
model);
camera.displayCameraDetails(); // Display camera info
}

public static void main(String[] args) {

// Create a Camera object
Camera camera = new Camera("12MP", 1.8);

// Create a Smartphone object with a Camera

Smartphone smartphone = new Smartphone("Samsung", "Galaxy S20",
camera);

// Display details of the smartphone and its camera

smartphone.displaySmartphoneDetails();
}
}

6. Composition: House and Room Classes

Question: Create a House class that contains a Room class. The Room class has attributes
roomType and area. The House class has a HouseName and a list of Room objects.

Solution:

import java.util.ArrayList;
import java.util.List;

// Room class (a part of House)

class Room {
String roomType;
double area; // in square meters

// Constructor to initialize Room

public Room(String roomType, double area) {
this.roomType = roomType;
this.area = area;
}

// Method to display room details

public void displayRoomDetails() {
System.out.println(roomType + " - Area: " + area + " sq.m");
}
}

// House class (contains multiple Room objects)

class House {
String houseName;
List<Room> rooms; // Composition: House contains a list of Room objects
 // Constructor to initialize House
public House(String houseName) {
this.houseName = houseName;
this.rooms = new ArrayList<>(); // Initialize an empty list of rooms
}

// Method to add a room to the house

public void addRoom(Room room) {
rooms.add(room);
}

// Method to display house details

public void displayHouseDetails() {
System.out.println("House Name: " + houseName);
for (Room room : rooms) {
room.displayRoomDetails(); // Display details of each room
}
}

public static void main(String[] args) {

// Create a House object
House house = new House("Dream Villa");

// Create Room objects and add them to the house

house.addRoom(new Room("Bedroom", 20.0));
house.addRoom(new Room("Kitchen", 15.0));
house.addRoom(new Room("Living Room", 25.0));

// Display details of the house and its rooms

house.displayHouseDetails();
}
}

7. Aggregation: Team and Player Classes

Question: Write a Team class and a Player class. The Player class has attributes name and
position. The Team class has a teamName and a list of Player objects.

Solution:

import java.util.ArrayList;
import java.util.List;

// Player class
class Player {
String name;
String position;

// Constructor to initialize Player

public Player(String name, String position) {
this.name = name;
this.position = position;
}
 // Method to display player details
public void displayPlayerDetails() {
System.out.println("Player: " + name + ", Position: " + position);
}
}

// Team class (aggregates Player objects)

class Team {
String teamName;
List<Player> players; // Aggregation: Team contains a list of Player
objects

// Constructor to initialize Team

public Team(String teamName) {
this.teamName = teamName;
this.players = new ArrayList<>(); // Initialize an empty list of
players
}

// Method to add a player to the team

public void addPlayer(Player player) {
players.add(player);
}

// Method to display team details

public void displayTeamDetails() {
System.out.println("Team Name: " + teamName);
for (Player player : players) {
player.displayPlayerDetails(); // Display each player's details
}
}

public static void main(String[] args) {

// Create a Team object
Team team = new Team("Dream Team");

// Create Player objects and add them to the team

team.addPlayer(new Player("John", "Forward"));
team.addPlayer(new Player("Alice", "Goalkeeper"));

// Display details of the team and its players

team.displayTeamDetails();
}
}
8. Aggregation: City and Citizen Classes

Question: Create a City class and a Citizen class. The Citizen class has attributes name and
age. The City class has an attribute cityName and a list of Citizen objects.

Solution:

import java.util.ArrayList;
import java.util.List;

// Citizen class
class Citizen {
String name;
int age;

// Constructor to initialize Citizen

public Citizen(String name, int age) {
this.name = name;
this.age = age;
}

// Method to display citizen details

public void displayCitizenDetails() {
System.out.println("Citizen: " + name + ", Age: " + age);
}
}

// City class (aggregates Citizen objects)

class City {
String cityName;
List<Citizen> citizens; // Aggregation: City contains a list of Citizen
objects

// Constructor to initialize City

public City(String cityName) {
this.cityName = cityName;
this.citizens = new ArrayList<>(); // Initialize an empty list of
citizens
}

// Method to add a citizen to the city

public void addCitizen(Citizen citizen) {
citizens.add(citizen);
}

// Method to display city details

public void displayCityDetails() {
System.out.println("City Name: " + cityName);
for (Citizen citizen : citizens) {
citizen.displayCitizenDetails(); // Display each citizen's
details
}
}

public static void main(String[] args) {

 // Create a City object
City city = new City("Metropolis");

// Create Citizen objects and add them to the city

city.addCitizen(new Citizen("John", 30));
city.addCitizen(new Citizen("Alice", 25));

// Display details of the city and its citizens

city.displayCityDetails();
}
}

9. Aggregation: Department and Employee Classes

Question: Design a Department class and an Employee class. The Employee class has attributes
name, ID, and salary. The Department class has a departmentName and a list of Employee
objects.

Solution:

import java.util.ArrayList;
import java.util.List;

// Employee class
class Employee {
String name;
String ID;
double salary;

// Constructor to initialize Employee

public Employee(String name, String ID, double salary) {
this.name = name;
this.ID = ID;
this.salary = salary;
}

// Method to display employee details

public void displayEmployeeDetails() {
System.out.println("Employee Name: " + name + ", ID: " + ID + ",
Salary: $" + salary);
}
}

// Department class (aggregates Employee objects)

class Department {
String departmentName;
List<Employee> employees; // Aggregation: Department contains a list of
Employee objects

// Constructor to initialize Department

public Department(String departmentName) {
this.departmentName = departmentName;
 this.employees = new ArrayList<>(); // Initialize an empty list of
employees
}

// Method to add an employee to the department

public void addEmployee(Employee employee) {
employees.add(employee);
}

// Method to display department details

public void displayDepartmentDetails() {
System.out.println("Department Name: " + departmentName);
for (Employee employee : employees) {
employee.displayEmployeeDetails(); // Display each employee's
details
}
}

public static void main(String[] args) {

// Create a Department object
Department department = new Department("Sales");

// Create Employee objects and add them to the department

department.addEmployee(new Employee("John Doe", "E001", 50000));
department.addEmployee(new Employee("Jane Smith", "E002", 55000));

// Display details of the department and its employees

department.displayDepartmentDetails();
}
}

10. Inheritance: Vehicle, Car, and Bike Classes

Question: Create a base class Vehicle with attributes make and year. Derive a class Car that
adds an attribute numberOfDoors. Derive a class Bike that adds an attribute type (e.g., sports,
cruiser).

Solution:

// Base class: Vehicle

class Vehicle {
String make;
int year;

// Constructor to initialize Vehicle

public Vehicle(String make, int year) {
this.make = make;
this.year = year;
}

// Method to display vehicle details

public void displayDetails() {
 System.out.println("Make: " + make + ", Year: " + year);
}
}

// Derived class: Car

class Car extends Vehicle {
int numberOfDoors;

// Constructor to initialize Car

public Car(String make, int year, int numberOfDoors) {
super(make, year); // Call Vehicle constructor
this.numberOfDoors = numberOfDoors;
}

// Method to display car details

public void displayDetails() {
super.displayDetails(); // Call Vehicle's display method
System.out.println("Number of Doors: " + numberOfDoors);
}
}

// Derived class: Bike

class Bike extends Vehicle {
String type;

// Constructor to initialize Bike

public Bike(String make, int year, String type) {
super(make, year); // Call Vehicle constructor
this.type = type;
}

// Method to display bike details

public void displayDetails() {
super.displayDetails(); // Call Vehicle's display method
System.out.println("Type: " + type);
}

public static void main(String[] args) {

// Create objects of Car and Bike
Car car = new Car("Toyota", 2020, 4);
Bike bike = new Bike("Yamaha", 2022, "Sports");

// Display details of the car and bike

System.out.println("Car Details:");
car.displayDetails();
System.out.println("\nBike Details:");
bike.displayDetails();
}
}
11. Inheritance: Employee, Manager, and Developer Classes

Question: Create a base class Employee with attributes name and employeeID. Derive a class
Manager that adds an attribute department. Derive a class Developer that adds an attribute
programmingLanguage.

Solution:

// Base class: Employee

class Employee {
String name;
String employeeID;

// Constructor to initialize Employee

public Employee(String name, String employeeID) {
this.name = name;
this.employeeID = employeeID;
}

// Method to display employee details

public void displayDetails() {
System.out.println("Employee Name: " + name + ", Employee ID: " +
employeeID);
}
}

// Derived class: Manager

class Manager extends Employee {
String department;

// Constructor to initialize Manager

public Manager(String name, String employeeID, String department) {
super(name, employeeID); // Call Employee constructor
this.department = department;
}

// Method to display manager details

public void displayDetails() {
super.displayDetails(); // Call Employee's display method
System.out.println("Department: " + department);
}
}

// Derived class: Developer

class Developer extends Employee {
String programmingLanguage;

// Constructor to initialize Developer

public Developer(String name, String employeeID, String
programmingLanguage) {
super(name, employeeID); // Call Employee constructor
this.programmingLanguage = programmingLanguage;
}
 // Method to display developer details
public void displayDetails() {
super.displayDetails(); // Call Employee's display method
System.out.println("Programming Language: " + programmingLanguage);
}

public static void main(String[] args) {

// Create objects of Manager and Developer
Manager manager = new Manager("Alice", "M001", "Sales");
Developer developer = new Developer("Bob", "D001", "Java");

// Display details of the manager and developer

System.out.println("Manager Details:");
manager.displayDetails();
System.out.println("\nDeveloper Details:");
developer.displayDetails();
}
}

12. Inheritance: Appliance, WashingMachine, and Refrigerator Classes

Question: Create a base class Appliance with attributes brand and power. Derive a class
WashingMachine that adds an attribute loadCapacity. Derive a class Refrigerator that adds
an attribute volume.

Solution:

// Base class: Appliance

class Appliance {
String brand;
double power; // in watts

// Constructor to initialize Appliance

public Appliance(String brand, double power) {
this.brand = brand;
this.power = power;
}

// Method to display appliance details

public void displayDetails() {
System.out.println("Brand: " + brand + ", Power: " + power + "W");
}
}

// Derived class: WashingMachine

class WashingMachine extends Appliance {
double loadCapacity; // in kg

// Constructor to initialize WashingMachine

public WashingMachine(String brand, double power, double loadCapacity) {
super(brand, power); // Call Appliance constructor
this.loadCapacity = loadCapacity;
 }

// Method to display washing machine details

public void displayDetails() {
super.displayDetails(); // Call Appliance's display method
System.out.println("Load Capacity: " + loadCapacity + " kg");
}
}

// Derived class: Refrigerator

class Refrigerator extends Appliance {
double volume; // in liters

// Constructor to initialize Refrigerator

public Refrigerator(String brand, double power, double volume) {
super(brand, power); // Call Appliance constructor
this.volume = volume;
}

// Method to display refrigerator details

public void displayDetails() {
super.displayDetails(); // Call Appliance's display method
System.out.println("Volume: " + volume + " liters");
}

public static void main(String[] args) {

// Create objects of WashingMachine and Refrigerator
WashingMachine washingMachine = new WashingMachine("LG", 2000, 7.5);
Refrigerator refrigerator = new Refrigerator("Samsung", 150, 300);

// Display details of the washing machine and refrigerator

System.out.println("Washing Machine Details:");
washingMachine.displayDetails();
System.out.println("\nRefrigerator Details:");
refrigerator.displayDetails();
}
}

13. Polymorphism: Animal Class and Subclasses

Question: Create a base class Animal with a method makeSound(). Derive classes Dog and Cat,
and override the makeSound() method for each.

Solution:

// Base class: Animal

class Animal {
// Method to be overridden
public void makeSound() {
System.out.println("Animal makes a sound");
}
}
// Derived class: Dog
class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Dog barks");
}
}

// Derived class: Cat

class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("Cat meows");
}
}

// Main class to demonstrate polymorphism

public class Main {
public static void main(String[] args) {
Animal myDog = new Dog(); // Animal reference, Dog object
Animal myCat = new Cat(); // Animal reference, Cat object

// Call the overridden methods

myDog.makeSound(); // Outputs: Dog barks
myCat.makeSound(); // Outputs: Cat meows
}
}

14. Polymorphism: Shape Class and Subclasses

Question: Create a base class Shape with a method area(). Derive classes Circle and
Rectangle, and override the area() method for each.

Solution:

// Base class: Shape

class Shape {
// Method to be overridden
public double area() {
return 0; // Default implementation
}
}

// Derived class: Circle

class Circle extends Shape {
double radius;

// Constructor to initialize Circle

public Circle(double radius) {
this.radius = radius;
}
 @Override
public double area() {
return Math.PI * radius * radius; // Area of circle
}
}

// Derived class: Rectangle

class Rectangle extends Shape {
double length;
double width;

// Constructor to initialize Rectangle

public Rectangle(double length, double width) {
this.length = length;
this.width = width;
}

@Override
public double area() {
return length * width; // Area of rectangle
}
}

// Main class to demonstrate polymorphism

public class Main {
public static void main(String[] args) {
Shape circle = new Circle(5); // Shape reference, Circle object
Shape rectangle = new Rectangle(4, 6); // Shape reference, Rectangle
object

// Call the overridden methods

System.out.println("Area of Circle: " + circle.area()); // Outputs
area of circle
System.out.println("Area of Rectangle: " + rectangle.area()); //
Outputs area of rectangle
}
}

15. Polymorphism: Payment Class and Subclasses

Question: Create a base class Payment with a method processPayment(). Derive classes
CreditCardPayment and CashPayment, and override the processPayment() method for each.

Solution:

// Base class: Payment

class Payment {
// Method to be overridden
public void processPayment() {
System.out.println("Processing payment...");
}
}
// Derived class: CreditCardPayment
class CreditCardPayment extends Payment {
@Override
public void processPayment() {
System.out.println("Processing credit card payment...");
}
}

// Derived class: CashPayment

class CashPayment extends Payment {
@Override
public void processPayment() {
System.out.println("Processing cash payment...");
}
}

// Main class to demonstrate polymorphism

public class Main {
public static void main(String[] args) {
Payment creditCardPayment = new CreditCardPayment(); // Payment
reference, CreditCardPayment object
Payment cashPayment = new CashPayment(); // Payment reference,
CashPayment object

// Call the overridden methods

creditCardPayment.processPayment(); // Outputs: Processing credit
card payment...
cashPayment.processPayment(); // Outputs: Processing cash payment...
}
}