¿Todos los métodos en una interfaz Java son abstractos?

En Java, la interfaz se denomina modelo de una clase y se utiliza para lograr la abstracción en Java. Al usar solo interfaces, podemos lograr múltiples herencias en Java.

• Comprendamos el concepto de plano a través de un ejemplo, como un plano del edificio que constará de propiedades y comportamientos del edificio, pero para cada edificio, puede ser diferente, similar a estas interfaces que tienen métodos abstractos que cuando se implementan por clases tendrán su propio comportamientos únicos.
• Al implementar una interfaz, obligamos a la clase a implementar sus métodos y, si no los implementa, debemos declarar esa clase como abstracta. Podemos tener métodos predeterminados y estáticos en la interfaz.
• Java 8 introdujo el concepto de métodos predeterminados, la razón por la que se agregaron en Java 8 es para un escenario determinado en el que la interfaz no era cómoda de usar. Por ejemplo, si tenemos un método implementado por muchas clases y la funcionalidad es la misma para cada caso, entonces para la misma funcionalidad necesitamos escribir esta función una y otra vez en cada clase para eliminar esta dificultad en los métodos predeterminados de Java 8. fueron dados.
• Por defecto, todos los métodos son públicos y abstractos hasta que no lo declaramos como predeterminado y las propiedades son estáticas y finales.

¡Todos los métodos en una interfaz Java son abstractos!

Los métodos abstractos no tienen cuerpo, solo tienen declaración pero no definición. La definición se define implementando clases. Así que miramos todos los ejemplos donde un método puede existir con su comportamiento (cuerpo) dentro de la interfaz. Ahora intentaremos dar cuerpo a métodos en diferentes escenarios dentro de interfaces.

Ejemplo 1:

• En este ejemplo, tendremos un método abstracto heightDisplay() (no tiene cuerpo) que será implementado por la clase GFG.
• Entonces, la clase GFG necesita implementar el método heightDisplay() y para llamar a este método crearemos el objeto de la clase GFG.
• Así que nuestro primer ejemplo nos dice que podemos tener métodos abstractos en las interfaces, y estamos haciendo esto para probar que las interfaces solo contienen métodos abstractos.

A continuación se muestra el ejemplo de tener un método abstracto solo dentro de la interfaz:

import java.io.*;
interface Building {
    // abstract methods
    void heightDisplay();
}
 
class GFG implements Building {
    // implementing the abstract method
    // of building interface
    public void heightDisplay()
    {
        System.out.println("height is 5");
    }
    public static void main(String[] args)
    {
        GFG gfg = new GFG();
        gfg.heightDisplay();
    }
}

height is 5

Ejemplo 2:

• En este ejemplo, tendremos un método de instancia widthDisplay() que también tendrá su cuerpo. Dentro del cuerpo, estaremos imprimiendo una declaración.
• Ahora, como sabemos, las interfaces consisten solo en métodos abstractos, por lo que cuando ejecutemos esto obtendremos los errores. Habrá 3 errores, pero el primero estará en el nombre del error de la línea 6: los métodos abstractos de la interfaz no pueden tener un cuerpo.
• Entonces demostramos con este ejemplo que no podemos tener métodos de instancia dentro de la interfaz. En términos simples, los métodos de instancia son los métodos que no son estáticos. Los métodos de instancia producirán diferentes salidas para diferentes métodos, ya que diferentes objetos tienen diferentes propiedades de instancia en las que funciona el método de instancia.
• Entonces, este ejemplo también respalda la afirmación de que la interfaz solo puede consistir en métodos abstractos.

A continuación se muestra el ejemplo de tener un método de instancia y un método abstracto dentro de la interfaz:

import java.io.*;
interface Building {
    // abstract methods
    void heightDisplay();
 
    // instance method with body
    void widthDisplay()
    {
        System.out.pritnln("width is 1");
    }
}
 
class GFG implements Building {
    // implementing the abstract method
    // of Building interface
    public void heightDisplay()
    {
        System.out.println("height is 5");
    }
 
    public static void main(String[] args)
    {
        GFG gfg = new GFG();
        gfg.heightDisplay();
        gfg.widthDisplay();
    }
}

Producción

prog.java:10: error: interface abstract methods cannot have body
    {
    ^
prog.java:15: error: GFG is not abstract and does not override abstract method widthDisplay() in Building
class GFG implements Building {
^
prog.java:27: error: cannot find symbol
        gfg.widthDisplay();
           ^
  symbol:   method widthDisplay()
  location: variable gfg of type GFG
3 errors

Ejemplo 3:

• En este ejemplo, tendremos el método final widthDisplay() que en su cuerpo imprimirá el ancho. Por lo tanto, estamos definiendo un método final con su cuerpo.
• Esto viola las reglas de interfaz de tener métodos abstractos solo porque tiene un cuerpo de método.
• Una cosa a tener en cuenta es que no podemos usar la palabra clave final con métodos abstractos, por lo que esto también nos da el error de combinación ilegal de palabras clave. Pero no usamos palabras clave abstractas de cómo podemos obtener el error de combinación ilegal. Porque por defecto todos los métodos son abstractos dentro de la interfaz.
• Entonces, este ejemplo establece que no podemos tener métodos finales dentro de las interfaces. Por lo tanto, este ejemplo también muestra que podemos tener métodos abstractos solo dentro de la interfaz.

A continuación se muestra el ejemplo de tener un método final y otro abstracto dentro de la interfaz.

import java.io.*;
interface Building {
    // abstract methods
    void heightDisplay();
 
    // final methods
    final void widthDisplay()
    {
        System.out.pritnln("width is 1");
    }
}
 
class GFG implements Building {
    public void heightDisplay()
    {
        System.out.println("height is 5");
    }
    public static void main(String[] args)
    {
        GFG gfg = new GFG();
        gfg.heightDisplay();
    }
}

Producción 

prog.java:9: error: modifier final not allowed here
    final void widthDisplay()
               ^
prog.java:10: error: interface abstract methods cannot have body
    {
    ^
prog.java:15: error: GFG is not abstract and does not override abstract method widthDisplay() in Building
class GFG implements Building {
^
3 error

Ejemplo 4:

• En este ejemplo, tendremos un método abstracto widthDisplay() que tendrá su cuerpo dentro de la interfaz. Como sabe, los métodos abstractos no pueden tener el cuerpo, por lo que también nos dará el error, el del error será que los métodos abstractos no pueden tener el cuerpo.
• Entonces, en este ejemplo, tratamos de darle cuerpo a un método abstracto incluso si sabíamos que los métodos abstractos no pueden tener un cuerpo solo para demostrar que solo podemos tener métodos abstractos dentro de la interfaz.
• Entonces, este ejemplo también respalda nuestra afirmación de que las interfaces pueden consistir solo en métodos abstractos.

A continuación se muestra el ejemplo de tener un método abstracto con el cuerpo dentro de la interfaz:

import java.io.*;
interface Building {
    // abstract method
    void heightDisplay();
 
    // giving body to abstract method
    abstract void widthDisplay()
    {
        System.out.pritnln("width is 1");
    }
}
 
class GFG implements Building {
    public void heightDisplay()
    {
        System.out.println("height is 5");
    }
    public static void main(String[] args)
    {
        GFG gfg = new GFG();
        gfg.heightDisplay();
    }
}

Producción 

prog.java:10: error: interface abstract methods cannot have body
    {
    ^
prog.java:15: error: GFG is not abstract and does not override abstract method widthDisplay() in Building
class GFG implements Building {
^
2 errors

Nota: antes de Java 8 no teníamos métodos estáticos dentro de las interfaces, pero ahora podemos tener métodos estáticos dentro de las interfaces.

Ejemplo 5:

• Hasta Java 8 no teníamos métodos estáticos dentro de la interfaz pero desde Java 8 en adelante podemos tener métodos abstractos dentro de la interfaz.
• Pero en este ejemplo, no habrá ningún error. Entonces podemos tener métodos que pueden tener su propio cuerpo dentro de la interfaz, uno de ellos es un método estático.
• Entonces, desde Java 8 en adelante, no es 100% correcto decir que la interfaz solo puede tener métodos abstractos.

A continuación se muestra el ejemplo de tener un método estático dentro de la interfaz:

import java.io.*;
interface Building {
    // abstract method
    void heightDisplay();
 
    // static method
    static void widthDisplay()
    {
        System.out.println("width is 1");
    }
}
 
class GFG implements Building {
    // implementing tha abstract method
    // of Building interface
    public void heightDisplay()
    {
        System.out.println("height is 5");
    }
    public static void main(String[] args)
    {
 
        GFG gfg = new GFG();
        gfg.heightDisplay();
        // accessing the static method
        // by using of interface name
        Building.widthDisplay();
    }
}

height is 5
width is 1

Ejemplo 6:

• Desde Java 8 también podemos tener métodos predeterminados. Los métodos predeterminados permiten que la interfaz tenga un método que no necesita ser implementado por la clase que implementa esa interfaz.
• Un ejemplo en el que los métodos predeterminados son los más adecuados, suponga que tiene un método de interfaz que utilizan muchas clases y la funcionalidad es la misma para todas las clases; en este caso, debe implementarlo en cada clase aunque el cuerpo sea el mismo para cada clase. Entonces, Java 8 introdujo el concepto de un método predeterminado para superar este escenario.
• Por lo tanto, podemos decir que podemos tener métodos estáticos y predeterminados dentro de la interfaz y, aparte de estos, solo tendremos métodos abstractos.

A continuación se muestra el ejemplo de tener el método predeterminado dentro de la interfaz:

import java.io.*;
interface Building {
    // abstract methods
    void heightDisplay();
 
    // default method
    default void widthDisplay()
    {
        System.out.println("width is 1");
    }
}
 
class GFG implements Building {
    // implementing abstract method
    // of Building interface
    public void heightDisplay()
    {
        System.out.println("height is 5");
    }
    public static void main(String[] args)
    {
        GFG gfg = new GFG();
        gfg.heightDisplay();
 
        // calling default method
        gfg.widthDisplay();
    }
}

height is 5
width is 1