1a) Write a JAVA program to display default value of all primitive
data type of JAVA
Source code:
class defaultdemo
static byte b;
static short s;
static int i;
static long l;
static float f;
static double d;
static char c;
static boolean bl;
public static void main(String[] args)
System.out.println("The default values of primitive data types are:");
System.out.println("Byte :"+b);
System.out.println("Short :"+s);
System.out.println("Int :"+i);
System.out.println("Long :"+l);
System.out.println("Float :"+f);
System.out.println("Double :"+d);
System.out.println("Char :"+c);
System.out.println("Boolean :"+bl);
}
OUTPUT:
The default values of primitive data types are:
Byte :0
Short :0
Int :0
Long :0
Float :0.0
Double :0.0
Char :.
Boolean :false
3a) Write a JAVA program to implement class mechanism. Create a class,
methods and invokethem inside main method.
SOURCE-CODE:
1.no return type and without parameter-list:
class A
int l=10,b=20;
void display()
System.out.println(l);
System.out.println(b);
class methoddemo
{
public static void main(String args[])
A a1=new A();
a1.display();
OUT-PUT:
10
20
2.no return type and with parameter-list:
class A
void display(int l,int b)
System.out.println(l);
System.out.println(b);
class methoddemo
public static void main(String args[])
A a1=new A();
a1.display(10,20);
OUTPUT:
10
20
3. return type and without parameter-list :
class A
{ int l=10,b=20;
int area()
return l*b;
class methoddemo
public static void main(String args[])
A a1=new A();
int r=a1.area();
System.out.println("The area is: "+r);
OUT-PUT: The area is:200
4.return type and with parameter-list:
class A
int area(int l,int b)
return l*b;
}
class methoddemo {
public static void main(String args[])
A a1=new A();
int r=a1.area(10,20);
System.out.println(“The area is:”+r);
OUT-PUT: The area is:200
3b)
AIM: To write a JAVA program to implement constructor overloading
SOURCE-CODE:
class A
int l,b;
A()
l=10;b=20;
A(int u,int v)
l=u;b=v;
int area()
{
return l*b;
class overconstructdemo
public static void main(String args[])
A a1=new A();
int r1=a1.area();
System.out.println("The area is: "+r1);
A a2=new A(30,40);
int r2=a2.area();
System.out.println("The area is: "+r2);
OUT-PUT: The area is: 200
The area is: 1200
4a)
AIM: Write a JAVA program to implement Single Inheritance
SOURCE-CODE:
// Superclass
class Animal {
// Method in the superclass
void sound() {
System.out.println("Animals make sound");
}
}
// Subclass (Single inheritance: Dog inherits from Animal)
class Dog extends Animal {
// Method in the subclass
void bark() {
System.out.println("Dog barks");
}
}
public class SingleInheritanceExample {
public static void main(String[] args) {
// Create an object of the subclass
Dog dog = new Dog();
// Call methods from both the superclass and the
subclass
dog.sound(); // Inherited from the Animal class
dog.bark(); // Method from the Dog class
}
}
Output:
Animals make sound
Dog barks
4b)
AIM:Write a JAVA program to implement multi level Inheritance
SOURCE CODE:
// Base class
class Animal {
String name;
// Constructor
Animal(String name) {
this.name = name;
}
// Method to display the animal's name
void display() {
System.out.println("Name: " + name);
}
}
// Intermediate class (inherits from Animal)
class Mammal extends Animal {
// Constructor
Mammal(String name) {
super(name); // Call the Animal constructor
}
// Method to display mammal characteristics
void breathe() {
System.out.println(name + " breathes air.");
}
}
// Derived class (inherits from Mammal)
class Dog extends Mammal {
// Constructor
Dog(String name) {
super(name); // Call the Mammal constructor
}
// Method to display dog's behavior
void bark() {
System.out.println(name + " barks.");
}
}
public class SmallMultiLevelExample {
public static void main(String[] args) {
// Create a Dog object
Dog dog = new Dog("Buddy");
// Call methods from all levels of inheritance
dog.display(); // Inherited from Animal class
dog.breathe(); // Inherited from Mammal class
dog.bark(); // Method in Dog class
}
}
Output:
Name: Buddy
Buddy breathes air.
Buddy barks.
5a)
AIM: Write a JAVA program give example for “super” keyword
SOURCE CODE:
class Vehicle {
int maxSpeed = 120;
} // Subclass Car extending Vehicle class Car extends Vehicle
{
int maxSpeed = 180;
void display()
{
// Print maxSpeed of base class (Vehicle) using super keyword
System.out.println("Maximum Speed of Vehicle: " +
super.maxSpeed);
}
} // Driver Program
class Test {
public static void main(String[] args)
{
Car small = new Car();
small.display();
}
}
OUTPUT:
Maximum Speed of Vehicle: 120
5b)
AIM:Write a JAVA program to implement Interface. What kind of
Inheritance can be achieved?
SOURCE CODE:
// Define an interface
interface Animal {
// Abstract method (does not have a body)
void makeSound();
// Default method (has a body)
default void eat() {
System.out.println("This animal is eating.");
}
}
// Implement the interface in a class
class Dog implements Animal {
// Provide implementation for the abstract method
public void makeSound() {
System.out.println("The dog barks.");
}
// You can also override the default method if needed
public void eat() {
System.out.println("The dog is eating dog food.");
}
}
public class InterfaceExample {
public static void main(String[] args) {
// Create an instance of Dog
Dog dog = new Dog();
// Call methods from the Animal interface
dog.makeSound(); // Implemented in Dog class
dog.eat(); // Overridden in Dog class
}
}
Output:
The dog barks.
The dog is eating dog food.
6a)
AIM: Write a JAVA program that describes exception handling
mechanism
SOURCE CODE:
public class ExceptionHandlingExample {
// Method that may throw an exception
static void divideNumbers(int a, int b) {
try {
// Code that may throw an exception
int result = a / b;
System.out.println("Result: " + result);
} catch (ArithmeticException e) {
// Handle the exception
System.out.println("Error: Division by zero is not
allowed.");
} finally {
// This block will always execute
System.out.println("Execution of finally block.");
}
}
public static void main(String[] args) {
// Call method with valid inputs
divideNumbers(10, 2);
// Call method with invalid input to demonstrate
exception handling
divideNumbers(10, 0);
}
}
Output:
Result: 5
Execution of finally block.
Error: Division by zero is not allowed.
Execution of finally block.
6b)
AIM: Write a JAVA program Illustrating Multiple catch clauses
SOURCE CODE:
public class MultipleCatchExample {
public static void main(String[] args) {
try {
// This block of code may throw different types of
exceptions
int[] numbers = {1, 2, 3};
int result = numbers[3]; // This will cause
ArrayIndexOutOfBoundsException
// The following line will not execute due to the
exception above
int division = 10 / 0; // This will cause
ArithmeticException
} catch (ArrayIndexOutOfBoundsException e) {
// Handle ArrayIndexOutOfBoundsException
System.out.println("Error: Array index is out of
bounds.");
} catch (ArithmeticException e) {
// Handle ArithmeticException
System.out.println("Error: Division by zero is not
allowed.");
} catch (Exception e) {
// Handle any other exception
System.out.println("An unexpected error occurred: "
+ e.getMessage());
} finally {
// This block will always execute
System.out.println("Execution of finally block.");
}
}
}
Output:
Error: Array index is out of bounds.
Execution of finally block.
