Wednesday, December 22, 2010

Java-Interface



->   100% abstract data structure.
->   It can contain only constant variables, abstract methods, classes and other interfaces.
->   An interface cannot contain non-abstract functions and variables.
->   We cannot create objects of an interface.
->   On compilation, an interface generates a .class extension file.


TestInterface1.java

interface Shapes {
  int i = 10;// implicit conversion to public static final int i = 10;
  void drawCircle();// public abstract void drawCircle();
}

class DrawShape1 implements Shapes { //directly implementing Shapes
  public void drawCircle() {//Interface methods are implicitly public abstract
    System.out.println(
                "drawCircle() - implemented in DrawShape1.");
  }
  public void function1() {
    System.out.println(
                "function1()- implemented in DrawShape1.");
  }
}

class SomeClass extends DrawShape1 {
//indirectly implementing Shapes via DrawShape1
}

class DrawShape2 implements Shapes { //directly implementing Shapes
  public void drawCircle() {
    System.out.println(
                "drawCircle() - implemented in DrawShape2.");
  }
  public void function1() {
    System.out.println(
                "function1()- implemented in DrawShape2.");
  }
}

class TestInterface1 {
  public static void main(String args[]) {
    /*DrawShape1 ds1 = new DrawShape1();
    ds1.drawCircle();
    ds1.function1();

    DrawShape2 ds2 = new DrawShape2();
    ds2.drawCircle();
    ds2.function1(); */

           Shapes s = new Shapes(); /*Shapes is abstract and cannot be instantiated*/

           Shapes s = new DrawShape2();
    s.drawCircle();
    s.function1(); /*cannot find symbol function1() in interface Shapes since function1() is invisible to Shape (reference variable s)*/
  }
}

---------------------------------------------------------------------------------
TestInterface3.java
interface Circle {
  void drawCircle();
}

interface Square {
  void drawCircle(int radius);
  void drawSquare();
}

class DrawShape implements Circle, Square {
  public void drawCircle(int r) {
    System.out.println("This is a circle with a radius of " + r);
  }
  public void drawCircle() {
    System.out.println("This is a circle.");
  }
  public void drawSquare() {
    System.out.println("This is a square.");
  }
}

class TestInterface3 {
  public static void main(String args[]) {
    DrawShape ds1 = new DrawShape();
    ds1.drawCircle();
    ds1.drawCircle(10);
    ds1.drawSquare();
  }
}

---------------------------------------------------------------------------------
TestInterface4.java
interface Circle {
  void drawCircle();
}
interface Square {
  void drawSquare();
}
class Triangle {
  public void drawCircle() {
           System.out.println(
                "This is a circle - in Triangle.");
     }
  public void drawTriangle() {
    System.out.println(
                "This is a triangle - in Triangle.");
  }
}

class DrawShape extends Triangle implements Circle, Square {
  public void drawCircle() {
           System.out.println(
                "This is a circle - in DrawShape.");
     }
  public void drawSquare() {
    System.out.println(
                "This is a square - in DrawShape.");
  }
}

class TestInterface4 {
  public static void main(String args[]) {
    DrawShape ds = new DrawShape();
    ds.drawCircle();
    ds.drawSquare();
    ds.drawTriangle();
  }
}

---------------------------------------------------------------------------------
TestInterface5.java
interface Circle {
  void drawCircle();
}

interface Square extends Circle {
  void drawSquare();
}

interface CircleSquareTriangle extends
     Circle, Square {
  void drawTriangle();
}


class DrawShape implements CircleSquareTriangle {
  public void drawCircle() {
    System.out.println("This is a circle.");
  }
  public void drawSquare() {
    System.out.println("This is a square.");
  }
  public void drawTriangle() {
    System.out.println("This is a triangle.");
  }
}

class TestInterface5 {
  public static void main(String args[]) {
    DrawShape ds1 = new DrawShape();
    ds1.drawCircle();
    ds1.drawTriangle();
    ds1.drawSquare();
  }
}


---------------------------------------------------------------------------------
TestInterface6.java
interface Circle {
  void drawCircle();
}
interface Square {
  void drawSquare();
}
interface Triangle {
  void drawTriangle();
}

interface CircleSquareTriangle extends Circle,Square,Triangle{ // Extending multiple interfaces
}

class DrawShape implements CircleSquareTriangle {
  public void drawCircle() {
    System.out.println("This is a circle.");
  }
  public void drawSquare() {
    System.out.println("This is a square.");
  }
  public void drawTriangle() {
    System.out.println("This is a triangle.");
  }
}

class TestInterface6 {
  public static void main(String args[]) {
    DrawShape ds1=new DrawShape();
    ds1.drawCircle();
    ds1.drawTriangle();
    ds1.drawSquare();
  }
}
 



->    The modifier final with a method prevents it from being overridden.
     A final method cannot be overridden.
->    The modifier final with a class prevents it from being inherited.
A final class cannot be inherited.
->   Return type of functions is not considered in overloading.
->   If the return type is non-primitive then we can use sub-type while overloading the method.
     public Rectangle doSomething() {
     }

public Container doSomething() { //overriding
     }

->    While overriding a function the access modifier can only be broadened, widened, or strengthened.
->    While overriding a function if the data type of an identifier is changed in the overridden function, it becomes overloading.
->    Modifier abstract cannot be used in combination with final, private or static.
     abstract + final ->  abstraction is resolved by overriding the functions, but final prevents the function from being overridden.
     abstract + private -> abstraction is resolved by overriding the functions in the sub-class, but private members are not inherited.
     abstract + static ->  static methods can be referred to by qualifying using class-name. Abstract methods are not definitive and hence make no sense.



->   implements - has a relationship.
->   extends - is a relationship.
->   An interface can extend one or more interfaces.
->   A class can extend only one class.
->   A class can implement one or more interfaces.
->   An interface cannot extend a class, since nothing can be non-abstract in an interface.
->   In Java, multiple inheritance can be attained only with the involvement of interface(s).
->   Where ever an interface is expected, we can pass the instance of a class that directly or indirectly implements the interface.



0 comments:

Post a Comment

Contact Form

Name

Email *

Message *

The Insane Techie - Android App

Launched an android app for the blog on 07th June 2016. Get it from google play store... Tips for using the app Use in landscape mo...