Java es un lenguaje de programación orientado a objetos (OOP) que es especialmente útil cuando necesita implementar un código bien estructurado y aumentar su reutilización y mantenimiento.
OOP utiliza cuatro principios para describir la relación entre clases: herencia, encapsulación, abstracción y polimorfismo. Hay al menos una clase en cada programa Java. Por lo tanto, es importante comprender los principios de OOP y cómo usarlos en sus aplicaciones.
Este artículo analiza el polimorfismo en sus diversas formas, su relación con otras clases de Java y sus casos de uso y mejores prácticas.
Si tiene problemas de tiempo, utilice los enlaces a continuación para encontrar exactamente lo que está buscando:
¿Qué es el polimorfismo en Java?
El polimorfismo, que literalmente significa «varias formas», es uno de los conceptos básicos de la programación orientada a objetos. El polimorfismo explora cómo crear y usar dos métodos con el mismo nombre para realizar dos funciones diferentes, por ejemplo, agregar dos funciones con el mismo nombre pero aceptando diferentes parámetros.
Por ejemplo, veamos cómo definir dos funciones llamadas Multiplicar(). Uno es para el producto de dos números enteros y el otro es para el producto de dos números dobles.
public class Main { public static void main(String[] args) {
// using the first method
Multiplier.Multiply(3,5);
// using the second method
Multiplier.Multiply(3.5,5.1);
}
}
Cuando se ejecuta el código, la salida es la siguiente:
Multiplicar enteros, resultado = 15
multiplicacion doble, resultado = 17.8499999999999998
Notará que al llamar a estos dos métodos no hay más diferencia que los parámetros pasados. Además, tenga en cuenta que la salida depende del tipo de parámetros pasados.
Diferencias entre herencia y polimorfismo
Es comprensible que los programadores a veces confundan el polimorfismo con otro concepto básico de programación orientada a objetos: la herencia. Sin embargo, los dos principios son fundamentalmente diferentes.
En la herencia, una clase a la que se hace referencia como clase secundaria puede heredar métodos y atributos de otra clase (clase principal). Vea el siguiente ejemplo:
class Shape {// methods of Shape class
}
class Square extends Shape {
// methods of Shape class are not specified here but are automatically accessible to this Square class thanks to inheritance
// methods of Square class
}
En la herencia sin polimorfismo, la clase secundaria hereda los mismos atributos y métodos de la clase principal sin modificar su funcionalidad. Debido al polimorfismo, una clase secundaria hereda atributos y métodos, pero proporciona su propia implementación (código) para estos métodos.
La herencia es una forma de permitir la reutilización del código, mientras que el polimorfismo es una forma de decidir dinámicamente qué versión de una función se invocará. Por ejemplo, la herencia permite el uso de atributos y métodos de la clase padre. Por el contrario, el polimorfismo permite que una clase secundaria defina su versión de una función con el mismo nombre que en la clase principal. Alternativamente, le permite implementar una función con el mismo nombre de varias maneras diferentes, y elegirá una para ejecutar según la cantidad y los tipos de parámetros proporcionados.
El polimorfismo también se usa para apoyar el principio «abierto-cerrado» que representa la «O» en DE CONFIANZA acrónimo. Establece que el código debe estar abierto a la extensión y cerrado a la modificación. En otras palabras, cuando intente agregar más funcionalidad a su código, no debe modificar las clases existentes (cerradas para modificación). En su lugar, debe ampliar la funcionalidad con herencia y polimorfismo.
Polimorfismo y herencia: un ejemplo
Si tiene dos tipos de automóviles, BMW y Mercedes, por ejemplo, puede crear Coche clase, luego ten BMW clase i mercedes la clase de la que cada uno hereda Coche clase. Esto significa que heredan sus atributos y funciones.
Debido al polimorfismo, se puede suponer que el automóvil (clase principal) puede ser BMW (clase secundaria) o Mercedes (clase secundaria). Por lo tanto, puede usar la clase principal, Cocherefiriéndose a uno de los dos tipos de coches.
public class Car{}Public class BMW extends Car {}
Public class Mercedes extends Car{}
Car myCar = new BMW();
//…some code…
myCar = new Mercedes();
//…some code…
Este ejemplo de código define una variable mi coche escribe Coche y lo usó para almacenar un nuevo objeto: BMW. Luego usó la misma variable para referirse a ella. mercedeslo cual es posible porque ambas son clases secundarias Coche.
Este es un ejemplo simple de una conversión donde la clase principal se refiere a un objeto de la clase secundaria. Al usar upcasting, puede acceder a la versión secundaria de la clase principal. Esto significa que puede acceder a métodos que solo están definidos en la clase principal, pero si se especifica un método con el mismo nombre en la clase secundaria, puede acceder a ese método. Upcasting es útil cuando una aplicación necesita determinar qué versión de código llamar en tiempo de ejecución.
Tipos y ejemplos de polimorfismo en Java
Java admite dos tipos de polimorfismo:
- Polimorfismo en tiempo de compilación (polimorfismo estático)
- Polimorfismo en tiempo de ejecución (polimorfismo dinámico)
Polimorfismo en tiempo de compilación
También llamado polimorfismo estático, este tipo de polimorfismo se logra mediante la creación de múltiples métodos con el mismo nombre en la misma clase, pero cada uno con una cantidad diferente de parámetros o parámetros de diferentes tipos de datos.
En el siguiente ejemplo, observe que los tres métodos tienen el mismo nombre pero cada uno toma una cantidad diferente de parámetros o tipos de datos diferentes:
package com.hubspot;class Multiplier {
static void Multiply(int a, int b)
{
System.out.println("Integer Multiplication, Result = "+ a*b);
}
// Method 2
static void Multiply(double a, double b)
{
System.out.println("double Multiplication, Result = "+ a*b);
}
// Method 3
static void Multiply(double a, double b, double c)
{
System.out.println("Three parameters, double Multiplication, Result = "+ a*b*c);
}
}
public class Main {
public static void main(String[] args) {
// using the first method
Multiplier.Multiply(3,5);
// using the second method
Multiplier.Multiply(3.5,5.1);
// using the third method
Multiplier.Multiply(3.6,5.2, 6.3);
}
}
Cuando se ejecuta el código, la salida es la siguiente:
Multiplicar enteros, resultado = 15
multiplicacion doble, resultado = 17.8499999999999998
Tres parámetros, doble multiplicación, resultado = 117.936
El primer método toma dos números enteros con diferentes parámetros, el segundo método toma dos parámetros dobles y el tercer método toma tres parámetros dobles. Tenga en cuenta que no proporcionamos ninguna información adicional al invocar. Las tres llamadas son iguales excepto por el número o tipo de parámetro.
Polimorfismo en tiempo de ejecución
También llamado polimorfismo dinámico, este tipo de polimorfismo ocurre cuando una clase secundaria tiene su propia definición de uno de los métodos miembros de la clase principal. Esto se denomina anulación de método. En la mayoría de los casos, el polimorfismo en tiempo de ejecución está relacionado con el upcasting. Esto sucede cuando la clase principal apunta a una instancia de la clase secundaria.
Aquí hay un ejemplo:
package com.hupspot;// Super Class
class Shape{
protected double length;
Shape(double length){
this.length = length;
}
void area(){
}
}
// Child class
class Square extends Shape{
//constructor
Square(double side){
super(side); // calling the super class constructor
}
//Overriding area() method
void area(){
System.out.println("Square Area = " + length*length);
}
}
// Child class
class Circle extends Shape{
//constructor
Circle(double radius){
super(radius); // calling the super class constructor
}
//Overriding area() method
void area(){
System.out.println("Circle Area = " + 3.14*length*length);;
}
}
public class Main {
public static void main(String[] args){
Shape shape = new Square(5.0);
// calling the area() method of the Square Class
shape.area();
shape = new Circle(5.0); // upcasting
// calling the area() method of the Circle Class
shape.area();
}
}
Salida:
área cuadrada = 25.0
Área del círculo = 75.0
El último ejemplo representa el principio «Abierto-Cerrado» del principio SOLID. Ampliamos el código con clases secundarias y no modificamos la clase Shape existente.
Casos de uso y mejores prácticas de polimorfismo
Un caso de uso para el polimorfismo es cuando se usa un solo nombre de método para llamar automáticamente al método correcto según la clase. Por ejemplo, cuando se utiliza un único elemento de memoria para albergar varios tipos, el siguiente ejemplo implementa un Configurar escribe Forma del ejemplo anterior y almacena objetos de diferentes clases secundarias, como Circulos y Cuadrados:
Set<Shape> hs = new HashSet<Shape>();hs.add(circle1);
hs.add(circle2);
hs.add(square1);
hs.add(square2);
for(Shape hs_element : hs){
hs_element.area();
}
Otro caso de uso para el polimorfismo es reemplazar declaraciones condicionales en su código. Por ejemplo, el código siguiente utiliza un cambiar una declaración en el método de área para determinar qué código se ejecutará cuando se invoque, en función del primer parámetro que se le pase. Notará que logra el mismo resultado que en el ejemplo de código de polimorfismo en tiempo de ejecución anterior. Sin embargo, este enfoque no es tan simple.
package org.hubspot;// Super Class
class Shape{
enum Type {
SQUARE,
CIRCLE
}
protected double length;
Type shape_type;
Shape(Type shape, double length){
this.length = length;
this.shape_type = shape;
}
double area(){
double area = 0;
switch (shape_type)
{
case SQUARE:
area = length * length;
break;
case CIRCLE:
area = 3.14*length * length;
break;
}
return area;
}
}
public class Main {
public static void main(String[] args) {
Shape Circle = new Shape(Shape.Type.CIRCLE, 10);
System.out.println("Circle Area equals = "+ Circle.area());
Shape Square = new Shape(Shape.Type.SQUARE, 10);
System.out.println("Square Area equals = "+ Square.area());
}
}
Usando polimorfismo en Java
El polimorfismo es una herramienta útil cuando se programa en Java o cualquier otro lenguaje orientado a objetos. Este artículo explica qué es el polimorfismo en Java y cómo usarlo en sus aplicaciones. Mostró ejemplos del polimorfismo utilizado, como multiplicador, clases y diferentes cálculos de área para diferentes formas.
También identificamos algunas ventajas del polimorfismo, como la reutilización del código. Además, permite el uso de una interfaz para admitir varios tipos de clases. También cumple con el principio SOLID OOP, extendiendo clases en lugar de usar cambiar maleta. Esto mantiene la aplicación abierta para expansión y cerrada para modificación.
Finalmente, el polimorfismo es muy útil cuando se trata de métodos que se llaman en tiempo de ejecución o en tiempo de compilación.
