Program-1
WAP to find out factorial of a number through recursion.
import java.lang.*;
import java.util.Scanner;
class FactorialDemo
{ public static void main(String args[])
{ Scanner scanner = new Scanner(System.in);
System.out.println("Enter the number:");
int num = scanner.nextInt();
int factorial = fact(num);
System.out.println("Factorial of entered number is: "+factorial);
static int fact(int n)
{ int output;
if(n==0)
{ return 1; }
else
return(n * fact(n-1));
}
Program-2
WAP to print Fibonacci series.
import java.lang.*;
import java.util.*;
class fibonacci{
public static void main(String[] args) {
int a=0, b=1, c;
int limit;
System.out.println("Enter the limit: ");
Scanner sc = new Scanner(System.in);
limit = sc.nextInt();
while(a <= limit){
System.out.println(a);
c = a + b;
a = b;
b = c;
}
}
Program-3
WAP to accept Command line arguments & print them.
class Demo
{
public static void main(String args[])
{
for(int i=0;i<args.length;i++)
{
System.out.println(args[i]);
}
}
}
Program-4
WAP to obtain a number by a user & check if it’s prime or not.
import java.lang.*;
import java.util.Scanner;
public class Num
{ public static void main(String args[])
{ int num, i, count=0;
Scanner scan = new Scanner(System.in);
System.out.print("Enter a Number : ");
num = scan.nextInt();
for(i=2; i<num; i++)
{ if (num%i == 0)
{ count++;
Break;} }
If (count == 0)
{ System.out.print("This is a Prime Number"); }
else
{ System.out.print("This is not a Prime Number"); }
Program-5
WAP that creates a class Accounts with following details:Instance variables:
ac_no., name, ac_name, balance .Methods: withdrawal(),deposit(),display().Use
constructors to initialize members.
import java.util.*;
class main{
public static void main(String[] args) {
Accounts ac1 = new Accounts(1, "Balwant", "SBI", 3000);
ac1.display();
ac1.withdrawal(2000);
ac1.display();
ac1.deposit(5000);
ac1.display();
}
}
class Accounts{
int ac_no;
String name, ac_name;
float balance;
public float withdrawal(float amount){
balance -= amount;
return balance;
}
public float deposit(float amount){
balance += amount;
return balance;
}
public void display(){
System.out.println("Balance: " + balance);
}
Accounts(int ac_no_in, String name_in, String ac_name_in, float balance_in){
ac_no = ac_no_in;
name = name_in;
ac_name = ac_name_in;
balance = balance_in;
}
}
Program-6
WAP to implement constructor overloading.
import java.lang.*;
class main
{ public static void main(String[] args)
{ conOverload co1 = new constructorOverloading(3, 4, 5);
co1.volume(); }}
class conOverload
{ float l, b, h;
constructorOverloading(int length, int breadth, int height)
{ l = length;
b = breadth;
h = height;}
conOverload(float length, float breadth, float height){
l = length;
b = breadth; h = height; }
public void volume()
{System.out.println("Volume: " + l * b * h);}
}
Program-7
WAP to count the no.of objects created in a program.
import java.lang.*;
class Test
{ static int noOfObjects = 0;
public Test()
{ noOfObjects += 1; }
public static void main(String args[])
{ Test t1 = new Test();
Test t2 = new Test();
Test t3 = new Test();
System.out.println(Test.noOfObjects);
}
Program-8
WAP to show call by value & call by reference.
//call by value
import java.lang.*;
class Operation
int data=50;
void change()
data=data+100;
public static void main(String args[])
{ Operation op=new Operation();
System.out.println("before change "+op.data);
op.change();
System.out.println("after change "+op.data); }
}
// call by reference.
import java.lang.*;
class CallbyReference{
int x;
public static void main ( String[] args ) {
Number a = new Number();
a.x=3;
System.out.println("Value of a.x before calling increment() is "+a.x);
increment(a);
System.out.println("Value of a.x after calling increment() is "+a.x);
public static void increment(Number n) {
System.out.println("Value of n.x before incrementing x is "+n.x);
n.x=n.x+1;
System.out.println("Value of n.x after incrementing x is "+n.x);
Program-9
WAP to implement method over ridding & method overloading.
import java.lang.*;
class main
{ public static int add(int a, int b)
{ return a + b; }
public static int add(int a, int b, int c){
return a + b + c; }
public static void main(String[] args)
{ System.out.println("Sum: " + add(3, 4));
System.out.println("Sum: " + add(3, 4, 5));
derived d = new derived();
d.show(); }}
class base
{ void show()
{ System.out.println("Base Class"); }
}
class derived extends base
{ void show()
{ System.out.println("Derived class");}}
Program-10
WAP that demonstrates all the usages of “super” keyword.
//To access the variable of parent class
import java.lang.*;
class base{
int num = 100;
}
class derived extends base{
int num = 110;
void print(){
System.out.println(super.num);
}
public static void main(String[] args) {
derived d = new derived();
d.print();
}
}
//To invoke constructor of parent class
import java.lang.*;
class base{
base(int num){
System.out.println("Base class Constructor");
System.out.println(num);
}
}
class derived extends base{
derived(int num_in){
super(num_in);
System.out.println("Derived class Constructor");
}
public static void main(String[] args) {
derived d = new derived(4);
}
}
Program-11
Create a class box having height, width , depth as the instance variables &
calculate its volume. Implement constructor overloading in it. Create a subclass
named box_new that has weight as an instance variable. Use super in the
box_new class to initialize members of the base class.
import java.lang.*;
class Box
{double length,breadth,height;
Box()
{length=-1;
breadth=-1;
height=-1;}
Box(double l,double b,double h)
{length=l;
breadth=b;
height=h;}
double volume()
{return length*breadth*height;}
class Box_new extends Box
{double weight;
Box_new(double w,double p,double q,double r)
{super (w,p,q);
weight=r;}
Box_new()
{weight=-1;}
class Demo
{ public static void main(String args[]){
Box_new b1=new Box_new(10,20,30,5);
Box_new b2=new Box_new(1,7,9,5);
Box_new b3=new Box_new();
double vol;
vol=b1.volume();
System.out.println("Volume of box1 is"+vol);
System.out.println("Weight of box1 is"+b1.weight);
vol=b2.volume();
System.out.println("Volume of box2 is"+vol);
System.out.println("Weight of box2 is"+b1.weight);
vol=b3.volume();
System.out.println("Volume of box3 is"+vol);
System.out.println("Weight of box3 is"+b1.weight);}
}
Program-12
WAP that implements multilevel inheritance.
import java.lang.*;
class A
{A()
{System.out.println("A's Constructor called");}}
class B extends A
{B()
{System.out.println("B's Constructor called");}}
class C extends B
{C()
{System.out.println("C's Constructor called");}}
class Demo
{ public static void main(String args[]){
C c=new C();}}
Program-13
WAP to implement Run time polymorphism.
import java.lang.*;
class Calculator
{int i,j;
void mul(int i,int j)
{int m=i*j;
System.out.println("Product is"+" "+m);}
void sub(int i,int j)
{int diff=i-j;
System.out.println("Difference is"+" "+diff);}
void add(int i,int j)
{int sum=i+j;
System.out.println("Sum is"+" "+sum);}}
class Calc extends Calculator
{int i,j;
void sub(int i,int j)
{int diff=j-i;
System.out.println("Difference is"+" "+diff);}}
class Demo
{ public static void main(String args[]){
Calculator c=new Calculator();
c.mul(2,3);
c.sub(5,4);
c.add(9,1);
Calc a=new Calc();
c=a;
c.sub(5,4);}
Program-14
WAP to implement interface. Create an interface named Shape having area() &
perimeter() as its methods. Create three classes circle, rectangle & square that
implement this interface.
Program-15
WAP to show multiple inheritance.
import java.lang.*;
interface I1
{ default void show()
{ System.out.println("Default Interface1"); } }
interface I2
{default void show()
{ System.out.println("Default Interface2"); }}
class Demo implements I1, I2
{ public void show()
{ I1.super.show();
I2.super.show(); }
public static void main(String args[])
{ Demo d = new Demo();
d.show(); } }
