Interfaces arrays exceptions
This presentation is the property of its rightful owner.
Sponsored Links
1 / 41

Interfaces, Arrays, Exceptions PowerPoint PPT Presentation


  • 83 Views
  • Uploaded on
  • Presentation posted in: General

Interfaces, Arrays, Exceptions. Clone Checked Exceptions. Interface. An interface is an abstract class. Implicitly: Members are public . Fields are final and static (with initializers). Methods are abstract . Behavior may be informally specified.

Download Presentation

Interfaces, Arrays, Exceptions

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Interfaces arrays exceptions

Interfaces, Arrays, Exceptions

Clone

Checked Exceptions

Java Interfaces


Interface

Interface

  • An interface is anabstractclass. Implicitly:

    • Members arepublic.

    • Fields arefinalandstatic (with initializers).

    • Methods areabstract.

      • Behavior may be informally specified.

  • Java supports single inheritance of classes (fields and methods), but multiple inheritance of interfaces (constants and method signatures).

  • An interface can extend another interface.

  • A class can implement an interface.

Java Interfaces


Multiple inheritance pros and cons

Multiple Inheritance : ProsandCons

  • Tree-structured class hierarchyleads to needless code duplication when several abstractions are specializations of other orthogonal abstractions.

    • Independent sets of classes {A,B} and {C,D} can result in four new classes using multiple inheritance. In contrast, single inheritance requires four new class definitionsby copying.

Java Interfaces


Cont d

(cont’d)

  • DAG class structurefacilitates code sharing and reduces code duplication.

  • Unfortunately:

    • There is no uniform application-independent way to deal with repeated inheritance of fields in diamond net. (To share or to duplicate?)

    • There is no uniform strategy to resolve method conflicts or to combine method impls.

    • Reuse of source code possible, but not object code.

Java Interfaces


Java design decisions

Java Design Decisions

  • Simplify the language (compiler) by banning multiple inheritance of classes.

  • Support multiple inheritance of interfaces (to share method signatures and to document behavior).

  • Code duplication can be minimized by approximating multiple inheritance using composition and delegation.

Java Interfaces


Cont d1

(cont’d)

  • From orthogonal classes{A,B}and{C,D},generate subclassesAC (AD, BC, BD).

  • TheseextendA (A, B, B)with anew fieldof typeC (D, C, D).

  • Then,delegatethe call to a method inC (D, C, D)on objects of classAC (AD, BC, BD)to the new field.

Java Interfaces


Class c extends a b

class C extends A, B {…}

class A { ... };

interface IB { ...

T bm(Fs) { ... };

};

class B implements IB { …

T bm(Fs) { ... };

};

class C extends A implements IB { …

B b;

T bm { b.bm(Vs); };

};

Java Interfaces


Role of interfaces in java

Role of Interfaces in Java

  • Defining Scalar types (a la C++) in Java 1.4 and before

    • Improves Readability but not Reliability. (Cf. Ada)

      • Java 5 natively supports Enumerated types

  • Enables integration of multiple implementations of an abstract data type.

    • Polymorphic data in arrays; Dynamic binding.

    • Serves as a type parameter.

      • (Cf. Ada Generics, C++ Templates, ML’s Functors, etc)

  • In AWT, it provides a convenient, abstract and reliable means for connecting event generating graphical/widget objects to application dependent event handlers.

  • Java Interfaces


    Cont d2

    (cont’d)

    • Multiple Inheritance of interfaces facilitates approximating multiple inheritance of classes for minimizing code duplication. This involves defining a field for each “parent” class and explicitly maintaining consistency among its fields and dispatching each method incorporating conflict resolution strategies.

    Java Interfaces


    Interfaces arrays exceptions

    interface I {

    Vector v = new Vector(); int i = 5;

    }

    interface J extends I {

    Vector w = (Vector) v.clone();

    int i = 10; int j = i;

    }

    class Interface implements J {

    public static void main(String [] args) {

    // I.v = J.w; ERROR

    System.out.println(" i = " + i + " j = " + j );

    I.v.addElement(new Integer(44));

    System.out.println(" w = " + w + " v = " + v);

    System.out.println(" Hidden I.i = " + I.i);

    }

    }

    i = 10 j = 10

    w = [44] v = [44]

    Hidden I.i = 5

    Java Interfaces


    Interfaces arrays exceptions

    interface I {

    Vector v = new Vector();

    String i = “ABC”;

    }

    interface J extends I {

    Vector w = (Vector) v.clone();

    String i = new String(“pqr ”); String j = i + “+ XYZ”;

    }

    class InterfaceVectorString implements J {

    public static void main(String [] args) {

    System.out.println(" Hidden I.i = " + I.i);

    // compile-time constant – no interface initialization

    System.out.println(" i = " + i + " j = " + j );

    // J initialized after I

    System.out.println(" w = " + w + " v = " + v);

    I.v.addElement(new Integer(55));

    System.out.println(" w = " + w + " v = " + v);

    }

    }

    Hidden I.i = ABC

    i = pqr j = pqr + XYZ

    w = [] v = []

    w = [] v = [55]

    Java Interfaces


    Interfaces arrays exceptions

    interface I {

    Vector v = new Vector();

    String i = “ABC”;

    }

    interface J extends I {

    Vector w = (Vector) v.clone();

    String i = “PQR ”; String j = i + “+ XYZ”;

    }

    class InterfaceVectorString1 implements J {

    public static void main(String [] args) {

    System.out.println(" Hidden I.i = " + I.i);

    System.out.println(" i = " + i + " j = " + j );

    // compile-time constant – no interface initialization

    I.v.addElement(new Integer(55));

    System.out.println(" w = " + w + " v = " + v);

    // J initialized after I

    }

    }

    Hidden I.i = ABC

    i = PQR j = PQR + XYZ

    w = [55] v = [55]

    Java Interfaces


    Interfaces arrays exceptions

    interface I {

    Vector v = new Vector();

    String i = “ABC”;

    }

    interface J extends I {

    Vector w = (Vector) v.clone();

    String i = new String(“pqr ”); String j = i + “+ XYZ”;

    }

    class InterfaceVectorString2 implements J {

    public static void main(String [] args) {

    System.out.println(" Hidden I.i = " + I.i);

    // compile-time constant – no interface initialization

    System.out.println(" i = " + i + " j = " + j );

    // J initialized after I; I’s value is NOT a compile-time constant

    I.v.addElement(new Integer(55));

    System.out.println(" w = " + w + " v = " + v);

    }

    }

    Hidden I.i = ABC

    i = pqr j = pqr + XYZ

    w = [] v = [55]

    Java Interfaces


    Arrays

    Arrays

    Java Interfaces


    Arrays1

    Arrays

    • An array object contains a number of variables accessed using a non-negative integer index.

    • Array Type and Array Variable

      • int [] []twoD;

      • Stringitems[];

  • Array Creation and Initialization

    • int [] []twoD = { {1,2}, null };

    • String []items = {“abc”};

  • Java Interfaces


    Array members

    Array Members

    • publicfinallength;

      • number of elements in the array.

  • publicObjectclone () { ... }

    • creates a new array object and then initializes its elements from the “source” array.

    • copying isshallow, not recursive.

  • int []ia1 = {1,2,3};

  • int []ia2 = (int [])ia1.clone();

    • Cf. Assignment: ia1 = ia2;

    • Array indices checked at run-time.(ArrayStoreException)

    • Cf. Ada Unconstrained array types

  • Java Interfaces


    Cloning

    Cloning

    Cf. copy constructor

    Java Interfaces


    Cloning1

    Cloning

    publicclassObject{ ...

    protectedObjectclone()

    throwsCloneNotSupportedException { ... }

    }

    public interfaceCloneable{ }

    • clone() method creates an object from another object of the same type.

    • Direct instances of classObject cannot be cloned.

    • Cloneable is a marker interface.

    Java Interfaces


    Cont d3

    (cont’d)

    A class may

    • supportclone, by defining a publiccloneandimplementing Cloneable.

    • conditionally supportclone, if “contents” support it. (Collection classes)

    • allow subclasses to supportclone. (E.g., Object)

    • forbidclone by throwingCloneNotSupportedException.

    Java Interfaces


    Interfaces arrays exceptions

    class A {

    protected Object clone()

    throws CloneNotSupportedException {

    return super.clone(); //assume a new defn

    }

    }

    class B {

    public Integer b = new Integer(5);

    public Object clone()

    throws CloneNotSupportedException {

    return super.clone();

    }

    }

    • Cannot clone both A- and B-objects.

    • Subclasses of B must declare clone public.

    • Used for appropriate clone for descendents.

    Java Interfaces


    Interfaces arrays exceptions

    class C extends B implements Cloneable {

    public Integer c = new Integer(6);

    public Object clone()

    throws CloneNotSupportedException {

    return super.clone();

    }

    }

    • Supports clone but descendents can throw exception.

      class D extends C {

      public Object clone() {

      try { return super.clone();

      } catch (CloneNotSupportedException e){}

      }

      }

    • Descendents must support public clone that does not throw any exception.

    Java Interfaces


    Interfaces arrays exceptions

    class TestClone {

    public static void main(String [] args)

    throws CloneNotSupportedException {

    new Object() . clone(); // compile-time error

    new A() . clone(); // run-time error

    new B() . clone(); // run-time error

    C cobj = new C(); C cobjc = cobj.clone();

    System.out.println( “C: “ + (cobj == cobjc));

    // C: false

    D dobj = new D(); D dobjc = dobj.clone();

    System.out.println( “D: “ + (dobj = dobjc));

    // D: [email protected]

    }

    }

    Java Interfaces


    Recursive types cf expanded types

    Recursive types (Cf. Expanded types)

    class Problem {

    Problem p = new Problem()

    }

    class Infinite {

    public static void main(String[] args) {

    new Problem();

    }

    }

    Java Interfaces


    Deep clone

    Deep Clone?

    public class IntStack implements Cloneable {

    private int[] buf;

    private int top;

    public IntStack(int max) {

    buf = new int[max]; top = -1;

    }

    public Object clone() {

    try {

    IntStack is =

    (IntStack) super.clone();

    is.buf = (int[]) buf.clone();

    return is;

    } catch (CloneNotSupportedException e){

    throw new InternalError(e.toString());

    }

    }

    }

    Java Interfaces


    Exceptions

    Exceptions

    Java Interfaces


    Interfaces arrays exceptions

    • Compiler checkssyntax, and flagstype mismatches, uninitialized variables, etc.

    • Semantic constraints of thelanguageorapplicationscanbe violated at run-time.

      Instead of aborting a program, or exhibiting arbitrary behavior when such violations occur, the exception mechanism enables “graceful degradation”, enhancing portability and robustness.

    Java Interfaces


    The causes of exceptions in java

    The causes of exceptions in Java

    • An abnormal execution condition was synchronously detected by JVM.

      • Java semantics violation.

      • Error in linking/loading of a program.

      • Exceeding resource limitations.

  • A throw-statement (user-defined exception) was executed.

  • An asynchronous exception occurred as

    • Thread.stop() was invoked.

    • An internal error occurred in JVM.

  • Java Interfaces


    Construct

    Construct

    try{ ...

    throw newException(“test”);

    ...

    }catch(InterruptedExceptione) { ...

    }catch(Exceptione) { ...

    }finally{ ...

    }

    Java Interfaces


    Interfaces arrays exceptions

    • Exceptions are well-integrated into the class hierarchy.

    • When an exception is thrown, control is transferred to the nearest dynamically enclosing catch-clause of a try-statement that handles the exception.

      • Context-sensitive handling

  • catch-clauses are ordered using “exception specificity”.

  • An exception thrown by the finally-block is propagated in preference to an exception thrown by the try-block.

  • Java Interfaces


    Interfaces arrays exceptions

    • class Exp1 {

    • public static void main(String[] args) throws Exception{

    • try {

    • throw new Exception("Throw Exception");

    • } catch (Exception e) {

    • throw e;

    • throw new Exception("REThrown Exception");

    • }

    • finally { throw new Exception("FINALLY"); }

    • }

    • }

      No Exception

      Exception in thread "main" java.lang.Exception: Throw Exception

      at Exp1.main(Exp1.java:4)

      Exception in thread "main" java.lang.Exception: REThrown Exception

      at Exp1.main(Exp1.java:7)

      Exception in thread "main" java.lang.Exception: FINALLY

      at Exp1.main(Exp1.java:9)

    Java Interfaces


    Interfaces arrays exceptions

    class Exp2 {

    static String f() {

    try {

    throw(new Exception());

    return("first-try");

    } catch (Exception e) {

    return("second-catch");

    } finally {

    return("third-finally");

    }

    }

    public static void main(String[] args) {

    System.out.println(f());

    }

    }

    first-try

    //return(first-try) unreachable

    second-catch

    third-finally

    Java Interfaces


    Examples

    Examples

    try{ ...

    CallThatThrowsException(“TRY”); ...

    }finally{ ...

    throw newException(“FINALLY”);

    }

    try{ ...

    return (“TRY”); ...

    }finally{ ...

    return (“FINALLY”);

    }

    Java Interfaces


    Exception handlers

    Exception Handlers

    • Pinpoint location/cause of problem (in a layered software). Record information for debugging.

    • Give diagnostic message, and take corrective or alternate action.

      • In a real-time system, this may be turning-on fault indicator lights to turning-off devices.

  • Restore environment to a well-defined state.

    • Release resources (locks), save files, etc.

  • Java Interfaces


    Exceptions vs error codes

    Exceptions vs Error codes

    Checking and Returning error code to signal abnormal condition is unsuitable because:

    • Error handling code and normal processing code mixed up.

    • A “caller” can ignoreerror code.

      • Not conducive to portability and robustness.

      • Difficult to pinpoint source/location of abnormality from results that are only indirectly related to it.

  • For a sequence of nested calls, the intermediate procedures must explicitly check and propagate codes.

    • Using global variable or gotos is not appropriate either.

    • In Java, the compiler guarantees that checked exceptions are always handled, and the JVM takes care of propagating exceptions using the call-stack.

  • Java Interfaces


    Java errors and exceptions

    Java Errors and Exceptions

    • Subclasses ofclassThrowable

      • Error

        • unchecked: recovery difficult or impossible

      • Exception(language defined + user-defined)

        • unchecked: too complex for compiler guarantees; too cumbersome for programmer to declare/handle. (logic errors)

        • checked: requires programmer to provide an exception handler or propagate exceptionexplicitly.

    Java Interfaces


    Interfaces arrays exceptions

    class Exp {

    void p() { q(1); }

    int q(int x) { return 1/(x - x); }

    public static void main(String[] args)

    { (new Exp()).p(); }

    }

    >javaExp

    java.lang.ArithmeticException:

    / by zero

    at Exp.q(Exp.java:3)

    at Exp.p(Exp.java:2)

    at Exp.main(Exp.java:6)

    L10Exceptions


    Interfaces arrays exceptions

    class MyExp extends Exception { }

    class TestExp3 {

    static void p() throws MyExp {

    throw new MyExp();

    }

    public static void main(String [] args)

    throws MyExp {

    p();

    }

    }

    • Checked Exception is explicitly propagated by main.

    L10Exceptions


    Interfaces arrays exceptions

    class MyExp extends Exception { }

    class TestExp4 {

    static void p() throws MyExp {

    throw new MyExp();

    }

    public static void main(String [] args){

    try{

    p();

    }catch (MyExp e) {};

    }

    }

    • Checked Exception is explicitly handled in main.

    L10Exceptions


    Errors

    Errors

    • Loading: ClassFormatError, ClassCircularityError, NoClassDefFoundError.

    • Linking: IllegalAccessError,InstantantiationError, NoSuchField, NoSuchMethodError.

    • Verification: VerifyError.

    • Initialization: ExceptionInInitializerError.

    • Resource: InternalError, OutOfMemoryError, StackOverflowError, UnknownError.

    Java Interfaces


    Runtimeexception

    RuntimeException

    • EmptyStackException

    • ArithmeticException

    • ArrayStoreException

    • ClassCastException

    • IllegalMonitorStateException

    • NegativeArraySizeException

    • NullPointerException

    • SecurityException

    Java Interfaces


    Checked exception

    (Checked) Exception

    • CloneNotSupportedException, NumberFormatException.

    • IOException, InterruptedException, FileNotFoundException, EOFException.

    • TooManyListenersException.

    • AlreadyBoundException.

    • User-defined Exceptions

    Java Interfaces


  • Login