Q)A superclass Perimeter has been defined to calculate the perimeter of a

parallelogram. Define a subclass Area to compute the area of the parallelogram by

using the required data members of the superclass. The details are given below:

Class name: Perimeter

Data members/instance variables:
a: to store the length in decimal
b: to store the breadth in decimal
Member functions:
Perimeter (…): parameterized constructor to assign values to data members
double Calculate(): calculate and return the perimeter of a parallelogram is 2*
(length + breadth)
void show(): to display the data members along with the perimeter of the
parallelogram
Class name: Area
Data members/instance variables:
h: to store the height in decimal
area: to store the area of the parallelogram
Member functions:
Area(…): parameterized constructor to assign values to data members of both the
classes
void doarea(): compute the area as (breadth * height)
void show(): display the data members of both classes along with the area and
perimeter of the parallelogram.
Specify the class Perimeter giving details of the constructor (…), double Calculate
and void show (). Using the concept of inheritance, specify the class Area giving
details of the constructor (…), void doarea () and void show (). The main function
and algorithm need not be written.
OUTPUT
// Superclass to calculate the perimeter of a parallelogram

class Perimeter

protected double a; // Length

protected double b; // Breadth

Perimeter(double a, double b)

this.a = a;

this.b = b;

double Calculate()

return 2 * (a + b);

void show()

System.out.println("Length: " + a);

System.out.println("Breadth: " + b);

System.out.println("Perimeter: " + Calculate());

class Area extends Perimeter // Subclass to compute the area of the parallelogram

double h; // Height
 double area; // Area

Area(double a, double b, double h)

super(a, b); // Call superclass constructor

this.h=h; // Initialize height

void doarea()

area = b * h;

@Override

void show()

super.show(); // Call superclass's show method

System.out.println("Height: " + h);

System.out.println("Area: " + area);

// Main class

class Main

void main()

Area obj = new Area(5.0, 3.0, 4.0); // Initialize dimensions

obj.doarea(); // Calculate area

obj.show(); // Display all details

}
}

OUTPUT
 Q.Write a program to insert a node in binary tree in
java?

Algorithm
Step1:Start

Step2: Define the Node Class: Step3: Define

the main Method: Step4: Define the run
Method: Step5:DefinetheinsertMethod:
Step6: Execution:
Step7: Stop
Code
public class Binary_Tree_Insert

void main()

new BinaryTreeInsert().run();

static class Node

Node left;

Node right;

int value;

public Node(int value)

this.value=value;

public void run()

Node rootnode = new Node(25);

System.out.println("Buildingtreewithrootvalue" +

rootnode.value);

System.out.println("=================================");

insert(rootnode, 11);

insert(rootnode, 15);

insert(rootnode, 16);
 insert(rootnode, 23);

insert(rootnode, 79);

public void insert(Node node, int value)

if(value<node.value)

if (node.left!=null)

insert(node.left,value);

} else

System.out.println("Inserted"+value+"toleftofNode"+node.value);

node.left=newNode(value);

else if(value>node.value)

if (node.right!= null)

insert(node.right,value);

else

System.out.println("Inserted" + value + "torightofNode" + node.value);

node.right=newNode(value);
 }

Output
 Q.Write a program to remove an element in different
ways using LinkList?

Algorithm

Step1:Start

Step2:Create a LinkedList:

Step3:Remove a Specific Element:

Step4:Remove an Element by Index:

Step5:Add a Collection of Elements:

Step6:Remove All Elements from a Collection: Step7 :Remove

the First Element:
Step8:Remove the Last Element:

Step9 :Remove the First Occurrence of a Specific Element: Step10:Remove the

Last Occurrence of a Specific Element: Step11 :Clear the List:
Step12:Stop
Code
import java.util.*;

publicclassLinkedList3

void main()

LinkedList<String> ll=new LinkedList<String>(); ll.add("Ravi");

ll.add("Vijay");

ll.add("Ajay");

ll.add("Anuj");

ll.add("Gaurav");

ll.add("Harsh");

ll.add("Virat");

ll.add("Gaurav");

ll.add("Harsh");

ll.add("Amit");

System.out.println("Initiallistofelements:"+ll);

ll.remove("Vijay"); //Removingspecificelementfromarraylist

System.out.println("Afterinvokingremove(object)method:"+ll);
//Removingelementonthebasisofspecificposition ll.remove(0);

System.out.println("After invoking remove(index) method:"+ll);

LinkedList<String> ll2=new LinkedList<String>();

ll2.add("Ravi");

ll2.add("Hanumat");

// Adding new elements to arraylist ll.addAll(ll2);

System.out.println("Updatedlist:"+ll);

//Removing all the new elements from array list ll.removeAll(ll2);

System.out.println("AfterinvokingremoveAll()method:"+ll);
 //Removing first element from the list ll.removeFirst();

System.out.println("AfterinvokingremoveFirst()method:"+ll);

//Removing first element from thel ist ll.removeLast();

System.out.println("AfterinvokingremoveLast()method:"+ll);

//Removing first occurrence of element from the list ll.removeFirstOccurrence("Gaurav");

System.out.println("After invoking removeFirstOccurrence() method: "+ll);

//Removinglastoccurrenceofelementfromthelist

ll.removeLastOccurrence("Harsh");
System.out.println("After invoking remove LastOccurrence() method:" ll );

//Removing all the elements available in the list ll.clear();

System.out.println("After invoking clear()method:"+ll);

Output
Q) A superclass Detail has been defined to store the details of a customer. Define a
subclass Bill to compute the monthly telephone charge of the customer as per the chart is
given below:
Number of calls: Rate
1 – 100: Only rental charge
101 – 200: 60 paise per call + rental charge
201 – 300: 80 paise per call + rental charge
Above 300: 1 rupee per call + rental charge
The details of both the classes are given below:

Class name: Detail

Data members/instance variables:
name: to store the name of the customer
address: to store the address of the customer
telno: to store the phone number of the customer
rent: to store the monthly rental charge
Member functions:
Detail (…): parameterized constructor to assign values to data members
void show (): to display the details of the customer

Class name: Bill

Data members/instance variables:
n: to store the number of calls
amt: to store the amount to be paid by the customer
Member functions:
Bill (…): parameterized constructor to assign values to data members of both classes and
to initialize amt = 0.0void cal(): calculate the monthly telephone charge as per the chart is
given above
void show(): displays the details of the customer and amount to be paid.
Specify the class Detail giving details of the constructor, and void show(). Using the
concept of inheritance, specify the class Bill giving details of the constructor(), void cal()
and void show().
THE MAIN ( ) FUNCTION AND ALGORITHM NEED NOT BE WRITTEN.
CODE

// Superclass to store customer details

class Detail

// Instance variables

protected String name; // Name of the customer

protected String address; // Address of the customer

protected String telno; // Phone number of the customer

protected double rent; // Monthly rental charge

// Parameterized constructor

Detail(String name, String address, String telno, double rent)

this.name = name;

this.address = address;

this.telno = telno;

this.rent = rent;

// Method to display customer details

void show()

System.out.println("Customer Name: " + name);

System.out.println("Address: " + address);

System.out.println("Telephone Number: " + telno);

System.out.println("Monthly Rental Charge: " + rent);

 }

class Bill extends Detail // Subclass to calculate and display the bill

// Instance variables

private int n; // Number of calls

private double amt; // Amount to be paid

// Parameterized constructor

Bill(String name, String address, String telno, double rent, int n)

// Call the constructor of the superclass

super(name, address, telno, rent);

this.n = n; // Initialize number of calls

this.amt = 0.0; // Initialize amount to 0

void cal() // Method to calculate the amount to be paid

if (n <= 100)

amt = rent;

else if (n <= 200)

amt = rent + (n - 100) * 0.60;

else if (n <= 300)

amt = rent + (100 * 0.60) + (n - 200) * 0.80;

else
 {

amt = rent + (100 * 0.60) + (100 * 0.80) + (n - 300) * 1.0;

// Method to display customer details and bill amount

void show()

super.show(); // Call the superclass show method

System.out.println("Number of Calls: " + n);

System.out.println("Amount to be Paid: " + amt);

// Example usage

class Main

void main()

// Create a Bill object

Bill obj = new Bill("Alice", "123 Maple Street", "9876543210", 150.0, 250);

// Calculate the bill

obj.cal();

// Display the customer details and bill amount

obj.show();

OUTPUT