.Implement a stack using exception handling and interfaces. In stack push(option 1) ,pop(option 2) and display(option 3) operation are done. Display the element specifying the index position.In display on trying to access an element out of bounds print the exception message.

Here is a simple implementation of a stack in Java using exception handling and interfaces.

import java.util.Scanner;

interface StackOperations {
    void push(int item);
    int pop();
    void display(int index);
}

class Stack implements StackOperations {
    private int[] stackArray;
    private int top;

    public Stack(int size) {
        stackArray = new int[size];
        top = -1;
    }

    public void push(int item) {
        try {
            stackArray[++top] = item;
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Stack is full. Cannot push " + item);
            top--;
        }
    }

    public int pop() {
        try {
            return stackArray[top--];
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Stack is empty. Cannot pop");
            top++;
            return -1;
        }
    }

    public void display(int index) {
        try {
            System.out.println("Element at index " + index + " is: " + stackArray[index]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Invalid index " + index + ". " + e.getMessage());
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter the size of the stack");
        int size = scanner.nextInt();
        Stack stack = new Stack(size);

        while (true) {
            System.out.println("Enter 1 to push, 2 to pop, 3 to display an element by index, 4 to quit");
            int choice = scanner.nextInt();
            switch (choice) {
                case 1:
                    System.out.println("Enter the element to push");
                    int item = scanner.nextInt();
                    stack.push(item);
                    break;
                case 2:
                    System.out.println("Popped element is: " + stack.pop());
                    break;
                case 3:
                    System.out.println("Enter the index of the element to display");
                    int index = scanner.nextInt();
                    stack.display(index);
                    break;
                case 4:
                    System.exit(0);
            }
        }
    }
}

This program first asks for the size of the stack. Then it enters an infinite loop where it asks for the operation to perform. If the user enters 1, it asks for the element to push onto the stack. If the user enters 2, it pops an element from the stack. If the user enters 3, it asks for the index of the element to display. If the user enters 4, it quits the program. If the stack is full and the user tries to push an element, it catches the ArrayIndexOutOfBoundsException and prints a message. Similarly, if the stack is empty and the user tries to pop an element, or if the user tries to display an element at an invalid index, it catches the ArrayIndexOutOfBoundsException and prints a message.