See this JLS specification and give a code that works according to it...

Question

5.1.5 Narrowing Reference Conversions
The following conversions are called the narrowing reference conversions:
NB: (NOT PART OF SPEC) : Rules for converting from class S to an interface K
From any class type S to any interface type K, provided that S is not final and does not implement K. (An important special case is that there is a narrowing conversion from the class type Object to any interface type.)
Give me a workable code example that illustrates this concept.
Thanks

Answer 1

1) For every narrowing (primitive or reference)
conversions there is a corresponding widening
(primitive or reference) conversion in the
opposite direction if the code is to be run without
throwing a run time exception. Where did you get that from? For the example code given by stevejluke in reply 5, there is no corresponding widening conversion in the opposite direction (the conversion in the opposite direction is in fact another narrowing conversion, from an interface type to a non-final class type). So no, in order for the codeto run without producing an exception, there does not need to be a widening conversion in the opposite direction.
Furthermore, primitive conversions never throw any exceptions anyway.
This can be put as:
It there is a narrowing (primitive or reference)
conversion from S to T, then there should be a
widening conversion from T to S (which is taken care
at Compile Time itself). No, this in itself is not correct
This guarantees that there
will be no run time exception.
Is this a necessary and sufficient condition for the
code to run without an exception? (Or)
Is it otherwise?Now its unclear what you really want to ask. It is not true that there is always an opposite widening conversion. Perhaps you mean to ask "If there happens to be an opposite widening conversion, then will the narrowing conversoin always execute at runtime without throwing an exception?". If this is what you are asking, then the answer is no: Consider a cast from type java.lang.Object to type int[]; This cast uses a narrowing reference conversion for which there is an opposite widening reference conversion (you can look them up in chapter 5 of the JLS); However, at runtime, the Object reference might be to any instance of Object, and so might fail. E.g.:
public class Test {
    public static void main(String[] argv) {
        Object obj = new Object();
        int[] arr = (int[])obj; // A narrowing reference conversion from type Object
                                 // to type int[]. There is a corresponding widening
                                 // reference conversion from int[] to Object,
                                 // but this cast will still fail at runtime as the runtime
                                 // type of arr is not int[]
2) Every narrowing conversion should be carried over
by an explicit cast using the cast operator, like:
S = (S) T;
No. This is true for narrowing reference conversions, but not for narrowing primitive conversions (which do not require a cast where the value is a compile-time constant small enough to be represented within the value set of the type it is being converted to).