Programming using Java.
–BCA 6th Sem
Practical File
Programming using Java
Submitted To Submitted By
Mrs. Lalita Name - Akash
Ma'am Section -B
Signature College Roll No. – 98
University Roll No. –
……………………… 221280400092
Session 2024-25
1
INDEX
s.no content Date Signature
1.
write a program on constructor overloading.
2.
Write a program on inheritance.
3.
write a program on interface.
4.
Write a program on polymorphism.
5.
Write a Program on exceptional handling.
6. Write a Program to find the factorial of a
number
7.
Write a Program to print the Fibonacci series
up to n terms.
8.
Write a Program to reverse a number.
9.
Write a Program to check if a number is a
palindrome.
10. Write a Program to find the sum of digits of a
number.
11.
Write a program to find the largest of three
numbers.
12. Write a Program to check whether a number is
prime.
Practical - 1
1.write a program on constructor overloading
// ConstructorOverloadingExample.java
class Student {
String name;
int age;
// Constructor 1: No parameters
Student() {
name = "Unknown";
age = 0;
}
// Constructor 2: One parameter
Student(String studentName) {
name = studentName;
age = 0;
}
// Constructor 3: Two parameters
Student(String studentName, int studentAge) {
name = studentName;
age = studentAge;
}
void display() {
System.out.println("Name: " + name + ", Age: " + age);
}
}
public class ConstructorOverloadingExample {
public static void main(String[] args) {
// Using different constructors
Student s1 = new Student();
Student s2 = new Student("Rahul");
Student s3 = new Student("Priya", 20);
// Display student details
s1.display();
s2.display();
s3.display();
}
}
Output :
Name: Unknown, Age: 0
Name: Rahul, Age: 0
Name: Priya, Age: 20
Explanation :
Constructor overloading means defining multiple constructors in the same
class with different parameter lists.
In the above example:
* Student() is a default constructor (no arguments).
* Student(String n) accepts only name.
* Student(String n, int a) accepts name and age.
Depending on how the object is created, the appropriate constructor is called.
Practical - 2
2.Write a program on inheritance.
// Base class / Parent class
class Animal {
void eat() {
System.out.println("This animal eats food.");
}
void sleep() {
System.out.println("This animal sleeps.");
}
}
// Derived class / Child class
class Dog extends Animal {
void bark() {
System.out.println("The dog barks.");
}
}
// Main class
public class InheritanceExample {
public static void main(String[] args) {
Dog d = new Dog();
// Calling methods from both base and derived class
d.eat(); // inherited from Animal
d.sleep(); // inherited from Animal
d.bark(); // from Dog class
}
}
Output :
This animal eats food.
This animal sleeps.
The dog barks.
Explanation :
* Inheritance allows a class to use the properties and methods of another class.
* Dog class extends Animal, so it inherits the eat() and sleep() methods.
* The Dog class also has its own method bark().
* In main(), we create a Dog object and call all the methods.
Practical - 3
3.write a program on interface.
// Interface
interface Shape {
void draw(); // abstract method
double getArea(); // abstract method
}
// Implementing class
class Circle implements Shape {
double radius;
Circle(double r) {
radius = r;
}
// Implementing draw method
public void draw() {
System.out.println("Drawing a Circle");
}
// Implementing getArea method
public double getArea() {
return 3.14 * radius * radius;
}
}
// Main class
public class InterfaceExample {
public static void main(String[] args) {
Circle c = new Circle(5.0);
c.draw();
System.out.println("Area of Circle: " + c.getArea());
}
}
Output :
Drawing a Circle
Area of Circle: 78.5
Explanation :
* An interface in Java is like a blueprint—it only has abstract methods (no body).
* The Shape interface has two methods: draw() and getArea().
* The Circle class implements the Shape interface and provides body for both methods.
* In main(), we create a Circle object, call draw(), and print the area.
Practical - 4
4.Write a program on polymorphism.
// Base class
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
// Derived class 1
class Dog extends Animal {
void sound() {
System.out.println("Dog barks");
}
}
// Derived class 2
class Cat extends Animal {
void sound() {
System.out.println("Cat meows");
}
}
// Main class
public class PolymorphismExample {
public static void main(String[] args) {
Animal a; // reference of base class
a = new Dog(); // Dog object
a.sound(); // calls Dog's sound()
a = new Cat(); // Cat object
a.sound(); // calls Cat's sound()
}
}
Output :
Dog barks
Cat meows
Expanation :
* Polymorphism means "many forms". In Java, it's achieved through
method overriding and dynamic method dispatch.
* The sound() method is overridden in Dog and Cat classes.
* The reference variable a is of type Animal, but it refers to different
child objects (Dog, Cat), and the correct method is called based on the
object type at runtime.
Practical - 5
5. Write a Program on exceptional handling.
import java.util.Scanner;
public class ExceptionHandlingExample {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
try {
System.out.print("Enter first number: ");
int a = sc.nextInt();
System.out.print("Enter second number: ");
int b = sc.nextInt();
int result = a / b;
System.out.println("Result: " + result);
}
catch (ArithmeticException e) {
System.out.println("Error: Cannot divide by zero.");
}
catch (Exception e) {
System.out.println("Error: Invalid input.");
}
finally {
System.out.println("Program ended.");
}
sc.close();
}
}
Output :1
Enter first number: 10
Enter second number: 2
Result: 5
Program ended.
Output : 2 (Division by zero)
Enter first number: 10
Enter second number: 0
Error: Cannot divide by zero.
Program ended.
Explanation :
* The program takes two numbers and divides them.
* If the user tries to divide by zero, it throws an ArithmeticException,
which is caught and handled.
* If any other error occurs (like entering text instead of a number),
it goes to the general Exception block.
* The finally block always runs, whether there is an error or not.
Practical - 6
6.Write a Program to find the factorial of a number
import java.util.Scanner;
public class FactorialExample {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Enter a number: ");
int num = sc.nextInt();
long factorial = 1;
// Check for negative numbers
if (num < 0) {
System.out.println("Factorial is not defined for negative numbers.");
} else {
for (int i = 1; i <= num; i++) {
factorial *= i;
}
System.out.println("Factorial of " + num + " is: " + factorial);
}
sc.close();
}
}
Output :
Enter a number: 5
Factorial of 5 is: 120
Explanation :
* The program takes a number from the user and calculates its factorial using a for loop.
* It uses a long variable to store the factorial because the value can get large.
* It also handles the case where the number is negative by showing a proper message.
Practical - 7
7. Write a Program to print the Fibonacci series up to n terms.
import java.util.Scanner;
public class FibonacciSeries {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Enter the number of terms: ");
int n = sc.nextInt();
int first = 0, second = 1;
System.out.print("Fibonacci Series: ");
// Printing the Fibonacci series
for (int i = 1; i <= n; i++) {
System.out.print(first + " ");
int nextTerm = first + second;
first = second;
second = nextTerm;
}
sc.close();
}
}
Output :
Enter the number of terms: 7
Fibonacci Series: 0 1 1 2 3 5 8
Explanation :
* The Fibonacci series starts with 0 and 1. Each subsequent
term is the sum of the previous two terms.
* The program asks for the number of terms (n) to display in the Fibonacci series.
* It then uses a for loop to calculate and print the terms in the series up to n.
Practical -8
8. Write a Program to reverse a number.
import java.util.Scanner;
public class ReverseNumber {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Enter a number: ");
int num = sc.nextInt();
int reversedNumber = 0;
// Reversing the number
while (num != 0) {
int digit = num % 10; // Get the last digit
reversedNumber = reversedNumber * 10 + digit; // Append the digit
num /= 10; // Remove the last digit
}
System.out.println("Reversed Number: " + reversedNumber);
sc.close();
}
}
Output :
Enter a number: 12345
Reversed Number: 54321
Explanation :
* The program takes a number from the user and reverses it using a while loop.
* In each iteration, the last digit of the number is obtained using the modulus
operator (%), and then the reversed number is built by appending this digit.
* The number is reduced by removing its last digit (num /= 10) in each loop iteration.
* The loop continues until the number becomes zero.
Practical - 9
9. Write a Program to check if a number is a palindrome.
import java.util.Scanner;
public class PalindromeNumber {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Enter a number: ");
int num = sc.nextInt();
int originalNum = num;
int reversedNumber = 0;
// Reversing the number
while (num != 0) {
int digit = num % 10;
reversedNumber = reversedNumber * 10 + digit;
num /= 10;
}
// Checking if the number is a palindrome
if (originalNum == reversedNumber) {
System.out.println(originalNum + " is a palindrome.");
} else {
System.out.println(originalNum + " is not a palindrome.");
}
sc.close();
}
}
Output :
Enter a number: 121
121 is a palindrome.
Explanation :
* A palindrome number is a number that reads the same forward and backward, like 121 or 12321.
* The program first stores the original number (originalNum) to compare it later.
* Then, it reverses the number using the same approach as the reverse number program.
* Finally, it checks if the original number is equal to the reversed number. If they
are equal, the number is a palindrome; otherwise, it’s not.
Practical - 10
10. Write a Program to find the sum of digits of a number.
import java.util.Scanner;
public class SumOfDigits {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Enter a number: ");
int num = sc.nextInt();
int sum = 0;
// Finding the sum of digits
while (num != 0) {
int digit = num % 10; // Get the last digit
sum += digit; // Add the digit to sum
num /= 10; // Remove the last digit
}
System.out.println("Sum of digits: " + sum);
sc.close();
}
}
Output :
Enter a number: 1234
Sum of digits: 10
Explanation :
* The program calculates the sum of digits of a number by extracting each
digit using the modulus operator (% 10).
* The number is then reduced by dividing it by 10 (removing the last digit).
* The loop continues until the number becomes zero.
* Each extracted digit is added to the sum variable.
* Finally, it prints the total sum of the digits.
Practical - 11
11. Write a program to find the largest of three numbers.
import java.util.Scanner;
public class LargestOfThree {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Enter the first number: ");
int num1 = sc.nextInt();
System.out.print("Enter the second number: ");
int num2 = sc.nextInt();
System.out.print("Enter the third number: ");
int num3 = sc.nextInt();
// Finding the largest number
int largest = num1;
if (num2 > largest) {
largest = num2;
}
if (num3 > largest) {
largest = num3;
}
System.out.println("The largest number is: " + largest);
sc.close();
}
}
Output :
Enter the first number: 12
Enter the second number: 25
Enter the third number: 18
The largest number is: 25
Explanation :
* The program takes three numbers as input from the user.
* It assumes the first number (num1) to be the largest.
* It then compares the second and third numbers with the current largest number and
updates the largest number accordingly.
* Finally, it prints the largest number.
Practical - 12
12. Write a Program to check whether a number is prime.
import java.util.Scanner;
public class PrimeNumberCheck {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Enter a number: ");
int num = sc.nextInt();
// Check if the number is prime
boolean isPrime = true;
if (num <= 1) {
isPrime = false; // 0 and 1 are not prime
} else {
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
isPrime = false; // Divisible by i, not prime
break;
}
}
}
if (isPrime) {
System.out.println(num + " is a prime number.");
} else {
System.out.println(num + " is not a prime number.");
}
sc.close();
}
}
Output :
Enter a number: 17
17 is a prime number.
Explanation :
* A prime number is a number greater than 1 that has no divisors other than 1 and itself.
* The program checks if a number is divisible by any number from 2 to num/2.
If it finds any divisor, the number is not prime.
* If no divisor is found, the number is prime.
* The program handles edge cases such as 0 and 1 (which are not prime).
