Interfaces arrays exceptions
Download
1 / 41

Interfaces, Arrays, Exceptions - PowerPoint PPT Presentation


  • 120 Views
  • Uploaded on

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.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Interfaces, Arrays, Exceptions' - finna


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


    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


    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


    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


    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


    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


    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


    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


    • 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


  • 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


    • 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


    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


    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


    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


    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


    ad