21.

Program on interface
interface Pet{
public void test();
}
class Dog implements Pet{
public void test(){
System.out.println("Interface Method Implemented");
}
public static void main(String args[]){
Pet p = new Dog();
p.test();
}
}

22. Program on accessing interfaces through Interface References

interface Callback {
void callback(int param); }
class Client implements Callback {
// Implement Callback's interface
public void callback(int p) {
System.out.println("callback called with " + p);
}
void aa() {
System.out.println("hi.");
} }
public class Main{
public static void main(String args[]) {
Callback c = new Client();
c.callback(42);
} }
23. Program on Multiple inheritance through interface
interface inter
{
int a=10,b=20;
public abstract void add();
}
interface inter1
{
int c=20,d=10;
public abstract void sub();
}
class c1 implements inter,inter1
{
public void add()
{
int sum=a+b;
System.out.println(" Sum of numbers is :" +sum);
}
public void sub()
{
int r=c-d;
System.out.println(" Difference of numbers is :" +r);
}
public static void main(String[] args)
{
c1 obj=new c1();
obj.add();
obj.sub();
}
}
Output: Sum of numbers is : 30
Difference of numbers is: 10
24. Program on Simple nested inner class
class Outer { // Simple nested inner class
class Inner { // show() method of inner class
public void show()
{ // Print statement
System.out.println("In a nested class method");
}
}
}
// Main class
class Main {
// Main driver method
public static void main(String[] args)
{ // Note how inner class object is created inside main()
Outer.Inner in = new Outer().new Inner(); // explained in next slide
// Calling show() method over above object created
in.show();
} }

25. Program on Anonymous inner class

interface Anonym {
void print();
}
class AnonymousClass {
// An anonymous class with OuterClass as base class
//start of the anonymous class.
static Anonym an = new Anonym() {
public void print() {
System.out.println("I am an implementation of interface Anonym");
}
};
public static void main(String[] args) {
an.print();
}
}

26. Program on Java Package

//save as Simple.java
package mypack;
public class Simple
{
public static void main(String args[])
{
System.out.println("Welcome to package");
}
}
To Compile: javac -d . Simple.java
To Run: java mypack.Simple
Output: Welcome to package

27. Program on package using classname

//save by A.java
package pack;
public class A{
public void msg() { System.out.println("Hello"); } }
//save by B.java
package mypack;
import pack.A;
class B{
public static void main(String args[]){
A obj = new A();
obj.msg();
} }

Output:Hello
28. Program on package using fully qualified name
//save by A.java
package pack;
public class A{
public void msg(){ System.out.println("Hello"); } }
//save by B.java
package mypack;
class B{
public static void main(String args[]){
pack.A obj = new pack.A();//using fully qualified name
obj.msg();
} }

29. Program on subpackage

package com.javatpoint.core;
class Simple{
public static void main(String args[ ]) {
System.out.println("Hello subpackage");
}
}
To Compile: javac -d . Simple.java
To Run: java com.javatpoint.core.Simple

30. Program on Exception handling

public class JavaExceptionExample{
public static void main(String args[]){
try
{
//code that may raise exception
int data=100/0;
}
catch(ArithmeticException e)
{
System.out.println(e);
}
//rest code of the program
System.out.println("rest of the code...");
}
}
Output: Exception in thread main java.lang.ArithmeticException:/ by zero rest
of the code...

31. Program on exception handling- Multiple catch block

public class MultipleCatchBlock2 {
public static void main(String[] args) {
try{
int a[]=new int[5];
System.out.println(a[10]); }
catch(ArithmeticException e)
{System.out.println("Arithmetic Exception occurs"); }
catch(ArrayIndexOutOfBoundsException e){
System.out.println("ArrayIndexOutOfBounds Exception occurs"); }
catch(Exception e)
{ System.out.println("Parent Exception occurs"); }
System.out.println("rest of the code"); }
}

32. Program on exception handling- Finally block

public class TestFinallyBlock1{
public static void main(String args[]){
try {
System.out.println("Inside the try block");
//below code throws divide by zero exception
int data=25/0;
System.out.println(data);
}
//cannot handle Arithmetic type exception
//can only accept Null Pointer type exception
catch(NullPointerException e){
System.out.println(e);
}
//executes regardless of exception occured or not
finally {
System.out.println("finally block is always executed");
}
System.out.println("rest of the code...");
}
}

33. Program on exception handling-throw block

public class TestThrow {
//defining a method
public static void checkNum(int num) {
if (num < 1) {
throw new ArithmeticException("\nNumber is negative, cannot calculate
square");
}
else {
System.out.println("Square of " + num + " is " + (num*num));
}
}
//main method
public static void main(String[] args) {
TestThrow obj = new TestThrow();
obj.checkNum(-3);
System.out.println("Rest of the code..");
}
}

Output:
34. Program on exception handling-throws block
public class TestThrows {
//defining a method
public static int divideNum(int m, int n) throws ArithmeticException {
int div = m / n;
return div;
}
//main method
public static void main(String[] args) {
TestThrows obj = new TestThrows();
try {
System.out.println(obj.divideNum(45, 0));
}
catch (ArithmeticException e){
System.out.println("\nNumber cannot be divided by 0");
}

System.out.println("Rest of the code..");

}
}

Output:
35. Program on user defined exception
public class CustomException extends Exception {
public CustomException(String message) {
super(message);
}
}

public class Main {

public static void main(String[] args) {
try {
throw new CustomException("This is a custom exception.");
} catch (CustomException e) {
System.out.println(e.getMessage());
}
}
}