EXPERIMENT-7

USE OF SINGLE LEVEL AND MULTI-LEVEL INHERITENCE

SINGLE LEVEL INHERITENCE.

public class Inherit_Single {

protected String str;

Inherit_Single() {

str = "Java ";

}}

class SubClass extends Inherit_Single {

SubClass() {

str = str.concat("World !!!");

}

void display()
{

System.out.println(str);
}}

class MainClass {

public static void main (String args[]){

SubClass obj = new SubClass();

obj.display();
}}

output:

MULTI-LEVEL INHERITENCE
class Inherit_Multilevel {

protected String str;

Inherit_Multilevel() {

str = "J";
}}

class SubClass1 extends Inherit_Multilevel {

SubClass1() {

str = str.concat("A");
}}

class SubClass2 extends SubClass1 {

SubClass2() {

str = str.concat("V");
}}

class SubClass3 extends SubClass2 {

SubClass3() {
str = str.concat("A");
}

void display() {
System.out.println(str);
}}

class MainClass {
public static void main(String args[]) {
SubClass3 obj = new SubClass3();
obj.display();
}}
OUTPUT:

EXPERIMENT-8
USE OF SUPER KEY
class Parentclass
{
int num=100;
}

class Subclass extends Parentclass

{
int num=110;
void printNumber(){

System.out.println(super.num);
}
public static void main(String args[]){
Subclass obj= new Subclass();

obj.printNumber();

}
}

output:

EXPERIMENT-9

TO USE ABSTRACT CLASS AND ITS METHODS

abstract class Bike{

abstract void run();

class Honda4 extends Bike

void run(){System.out.println("running safely..");

public static void main(String args[])

Bike obj = new Honda4();

obj.run();

OUTPUT:

EXPERIMENT-10

USE OF WRAPPER CLASSES

class xyz
{

public static void main (String args[])

Float f1 = new Float (25.78);

Byte f2 = new Byte ((byte)25);

Double f3 = new Double(258.75);

Integer f4 = new Integer (2017);

Long f5 = new Long (256*256+100);

Boolean flag = new Boolean (true);

System.out.println("Integer wrap : "+f1);

System.out.println("Byte wrap : "+f2);

System.out.println("double wrap : "+f3);

}}

OUTPUT:

EXPERIMENT-11

USE OF STATIC KEYWORD FOR VARIABLES & METHODS.

class player{
String name,game;
static String nation;
player(String s1,String g1){
name=s1;
game=g1;
nation="INDIA";}
void show(){
System.out.println("Details of player are:");
System.out.println(name);
System.out.println(game);
System.out.println(nation);}
static void disp(){
System.out.println("static method");
System.out.println("static variable "+ nation);
}}
class xyz
{
public static void main(String x[])
{
player p1=new player ("abc","cricket");
player p2=new player("xyz","volley");
p1.show();
p2.show();
player.disp();}}
output:

EXPERIMENT-13
IMPLEMENTATION OF INTERFACE

interface inf
{
 public void sum(int x,int y);
}
class main
{
int ans;
void sum(int x,int y)
{
ans=x+y;
System.out.println("Answer is: "+ ans);
}
}
class myin {
public static void main(String arg[])
{
main obj=new main();
obj.sum(5,10);
}
}

OUTPUT:

EXPERIMENT-14
EXCEPTION HANDLING USING TRY,CATCH,FINALLY.

class E {
 public static void main(String args[]) {

int a[] = new int[2];

try {

System.out.println("Access element three :" + a[3]);

}catch(ArrayIndexOutOfBoundsException e) {

System.out.println("Exception thrown :" + e);

}finally {

a[0] = 6;

System.out.println("First element value: " + a[0]);

System.out.println("The finally statement is executed");

output:

EXPERIMENT-15

EXCEPTION HANDLING USING THROW AND THROWS.

import java.io.*;
class M{
void method()throws IOException{
throw new IOException("device error");
}
}
class Testt{
public static void main(String args[])throws IOException{
M m=new M();
m.method();

System.out.println("normal flow...");
}
}
OUTPUT:

EXPERIMENT-18
CREATION OF THREAD USING RUNNABLE INTERFACE AND
EXTENDING THREAD CLASS.
Using runnable interface:
class Multi3 implements Runnable
{
public void run()
{
System.out.println("thread starts execution.");
}

public static void main(String args[])

{
nannonm1=new nanno();
Thread t1 =new Thread(n1);
t1.start();
}
}

output:

Extending thread class:

class NANNO extends Thread
{
public void run()
{
System.out.println("thread Starts execution.");
}
 public static void main(String args[])
{
NANNO N1=new NANNO();
N1.start();
}
}
output: