Interfaces y Polimorfismo en Java

El lenguaje Java es uno de los lenguajes más populares entre todos los lenguajes de programación. Hay varias ventajas de utilizar el lenguaje de programación Java, ya sea por motivos de seguridad o para la construcción de grandes proyectos de distribución. Una de las ventajas de usar JA es que Java intenta conectar cada concepto del lenguaje con el mundo real con la ayuda de los conceptos de clases, herencia, polimorfismo, interfaces, etc. En este artículo, discutiremos los conceptos de polimorfismo e interfaz. .

El polimorfismo es que tiene muchas formas, lo que significa que una forma definida específica se usa de muchas maneras diferentes. El ejemplo más simple de la vida real es supongamos que tenemos que almacenar el nombre de la persona y el número de teléfono de la persona, pero hay muchas situaciones en las que una persona tiene dos números de teléfono diferentes. Tenemos que guardar el mismo número de teléfono con el mismo nombre.

Interpretémoslo con ayuda. Entonces, en Java, el problema se puede resolver usando un concepto orientado a objetos , void insertPhone(String name, int phone) . Entonces, este método se usa para guardar el número de teléfono de una persona en particular. De manera similar, podemos usar el mismo formulario pero una firma diferente significa diferentes parámetros para almacenar el número de teléfono alternativo del insertPhone vacío de la persona (String name, int phone1, int phone2). Un método tiene dos formas diferentes y realiza operaciones diferentes . Este es un ejemplo de polimorfismo, que es la sobrecarga de métodos .

Tipos de polimorfismo en Java :

1. Polimorfismo de tiempo de ejecución
2. Polimorfismo en tiempo de compilación

Tipo 1: polimorfismo en tiempo de ejecución

Este tipo de polimorfismo lo resuelve la máquina virtual de Java, no el compilador de Java. Es por eso que este tipo de polimorfismo se llama polimorfismo en tiempo de ejecución. El polimorfismo en tiempo de ejecución se produce durante la anulación de métodos en java.

Ejemplo 

// Java Program to Illustrate Run-time polymorphism
 
// Importing I/O classes
import java.io.*;
 
// Class 1 (Parent class)
class GFG1 {
  //name method
  void name() {
    System.out.println("This is the GFG1 class");
  }
}
 
// Class 2 (Child class)
// Main class extending parent class
public class GFG extends GFG1 {
 
  // Method 1
  void name() {
    // Print statement
    System.out.println("This is the GFG class");
  }
 
  // Method 2
  // Main drive method
  public static void main(String[] args) {
 
    // Now creating 2 objects with different references and
    // calling the Method 1 over the objects
 
    // Case 1: GFG1 reference and GFG1 is the object
    GFG1 ob = new GFG1();
    ob.name();
 
    // Case 2: GFG1 reference and GFG is the object
    GFG1 ob1 = new GFG();
    ob1.name();
  }
}

This is the GFG1 class
This is the GFG class

Explicación de salida: 

En el ejemplo anterior, la misma función, es decir, el nombre, se llama dos veces, pero en ambos casos, la salida es diferente. Las firmas de estos métodos también son las mismas. Es por eso que los compiladores no pueden identificar cuál debe ejecutarse. Esto se determina solo después de la creación del objeto y la referencia de la clase, que se realiza durante el tiempo de ejecución (gestión de memoria). Es por eso que esto es polimorfismo en tiempo de ejecución.

Tipo 2: polimorfismo en tiempo de compilación

La sobrecarga de métodos es un ejemplo del método de polimorfismo en tiempo de compilación. Sobrecarga significa una función que tiene el mismo nombre pero una firma diferente. Esto es polimorfismo en tiempo de compilación porque este tipo de polimorfismo se determina durante el tiempo de compilación porque durante la escritura del código ya mencionamos los diferentes tipos de parámetros para el mismo nombre de función.

Ejemplo:

// Java Program to Illustrate Run-time polymorphism
 
// Importing required classes
import java.io.*;
import java.util.*;
 
// Class 1
// Helper class
class First {
 
    // Method of this class
    // Without any parameter
    void check()
    {
 
        // Print statement if this method is called
        System.out.println("This is the class First");
    }
}
 
// Class 2
// Main class
class Second extends First {
 
    // Method overloading
    void check(String name)
    {
        // Printing the name of the class method having the
        // parameter
        System.out.println("This is the class " + name);
    }
 
    // Method 2
    // Main driver method
    public static void main(String args[])
    {
        // Creating object of class 2
        Second ob = new Second();
        // Calling method over class 2 object
        ob.check("Second");
 
        // Creating object of class 1
        First ob1 = new First();
        ob.check();
 
        // Upcasting
        First ob2 = new Second();
        ob.check();
    }
}

This is the class Second
This is the class First
This is the class First

Las interfaces son muy similares a las clases. Tienen variables y métodos, pero las interfaces solo permiten métodos abstractos (que no contienen el cuerpo de los métodos), pero ¿cuál es la diferencia entre las clases y las interfaces? La primera ventaja es permitir que las interfaces implementen herencias múltiples en una clase en particular. El lenguaje JAVA no admite herencias múltiples si extendemos varias clases en la clase, pero con la ayuda de las interfaces, se permiten herencias múltiples en Java.

Ejemplo de la vida real

El ejemplo del mundo real de las interfaces es que tenemos múltiples clases para diferentes niveles de empleados que trabajan en una empresa en particular y la propiedad necesaria de la clase es el salario de los empleados y esto. Debemos ser implementados en cada clase y. Además, es diferente para cada empleado aquí. Se utiliza el concepto de interfaz. Simplemente creamos una interfaz que contiene un método de salario abstracto y lo implementamos en todas las clases y podemos definir fácilmente diferentes salarios de los empleados.

Ejemplo:

// Java Program to Demonstrate Concept of interfaces
 
// Interface
interface salary {
    void insertsalary(int salary);
}
 
// Class 1
// Implementing the salary in the class
class SDE1 implements salary {
    int salary;
    @Override public void insertsalary(int salary)
    {
        this.salary = salary;
    }
    void printSalary() { System.out.println(this.salary); }
}
 
// Class 2
// Implementing the salary inside the SDE2 class
class SDE2 implements salary {
    int salary;
    @Override public void insertsalary(int salary)
    {
        this.salary = salary;
    }
    void printSalary() { System.out.println(this.salary); }
}
 
public class GFG {
 
    public static void main(String[] args)
    {
        SDE1 ob = new SDE1();
        // Insert different salaries
        ob.insertsalary(100000);
        ob.printSalary();
        SDE2 ob1 = new SDE2();
 
        ob1.insertsalary(200000);
        ob1.printSalary();
    }
}

100000
200000