Java - Que es exactamente el polimorfismo en Java

 
Vista:
sin imagen de perfil
Val: 15
Ha disminuido su posición en 2 puestos en Java (en relación al último mes)
Gráfica de Java

Que es exactamente el polimorfismo en Java

Publicado por Antonio (4 intervenciones) el 20/03/2020 18:47:25
Hola! Estoy empezando en el mundo de la programación (estoy comenzando por java), y no me queda claro que es exactamente el polimorfismo. Si alguien puede explicarmelo me sería de gran ayuda, ¡Gracias!
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Sebastian
Val: 316
Bronce
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Que es exactamente el polimorfismo en Java

Publicado por Sebastian (91 intervenciones) el 20/03/2020 22:49:08
Hola

"Polimorfismo es la capacidad de un objeto de adquirir varias formas. El uso más común de polimorfismo en programación orientada a objetos se da cuando se utiliza la referencia de una clase padre, para referirse al objeto de la clase hijo."
Tomado de: http://www.edu4java.com/es/progbasica/progbasica17.html

Para un ejemplo, se crea una clase GeometricFigure (Padre) que es la que va a tener un atributo para el nombre de la figura geometrica y dos metodos
que son:
- calculateArea: El cual calculara el area de la figura.
- calculatePerimeter: El cual calculara el perimetro de la figura.

1
2
3
4
5
6
7
8
public abstract class GeometricFigure  {
 
	protected String name;
 
	abstract double calculateArea();
	abstract double calculatePerimeter();
 
}

Tambien se crean dos clases.

Circle (Hijo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class Circle extends GeometricFigure  {
	private double radio;
	private double pi;
 
	public Circle(String name, double radio, double pi) {
		super();
		this.name = name;
		this.radio = radio;
		this.pi = pi;
	}
 
	public double getRadio() {
		return radio;
	}
 
	public void setRadio(double radio) {
		this.radio = radio;
	}
 
	public double getPi() {
		return pi;
	}
 
	@Override
	double calculateArea() {
		return this.pi * Math.pow(this.radio, 2);
	}
 
	@Override
	double calculatePerimeter() {
		return this.pi * (this.radio + this.radio);
	}

Triangle (Hijo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package com.ejercicio.run;
 
public class Triangle extends GeometricFigure{
 
	private double base;
	private double height;
	private double cO;
	private double cA;
	private double h;
 
 
	public Triangle(String name, double base, double height, double cO, double cA, double h ) {
		super();
		this.name = name;
		this.base = base;
		this.height = height;
		this.cO = cO;
		this.cA = cA;
		this.h = h;
 
		// TODO Auto-generated constructor stub
	}
 
	@Override
	double calculateArea() {
		return (base*height/2);
	}
 
	@Override
	double calculatePerimeter() {
		return cO+cA+h;
	}
 
}

Y el metodo que ejecuta el programa

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void main(String args[]) {
		GeometricFigure triangle = new Triangle("Equilatero", 10, 20, 15, 10, 30);
 
 
		System.out.println("Triangulo");
		System.out.println("Tipo de triangulo: "+ triangle.name);
		System.out.println("Area del triangulo: "+ triangle.calculateArea());
		System.out.println("Perimetro del triangulo: "+ triangle.calculatePerimeter());
 
		GeometricFigure circle = new Circle("Circle bullet", 10, Math.PI);
		System.out.println("Circle");
		System.out.println("Tipo de circulo: "+ circle.name);
		System.out.println("Area del circulo: "+ circle.calculateArea());
		System.out.println("Perimetro del circulo: "+ circle.calculatePerimeter());
	}

Entonces podemos observar que se crean dos figuras geometricas, una triangulo y otra circulo, a pesar de que parten de la misma clase (GeometricFigure), cada uno tiene atributos diferentes, y solo comparten un atributo que es el nombre.

Ademas ambas figuras tienen los dos metodos que permiten calcular el area y el perimetro, pero cada figura calcula diferente cada dato.

Hay varios casos los puedes ver aca
https://www.luaces-novo.es/polimorfismo-en-java/#inclusion

Espero te sirva.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
4
Comentar
sin imagen de perfil
Val: 15
Ha disminuido su posición en 2 puestos en Java (en relación al último mes)
Gráfica de Java

Que es exactamente el polimorfismo en Java

Publicado por Antonio (4 intervenciones) el 21/03/2020 11:38:46
Muchas gracias!, ahora lo entiendo mejor :D
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
sin imagen de perfil
Val: 23
Ha disminuido su posición en 3 puestos en Java (en relación al último mes)
Gráfica de Java

Que es exactamente el polimorfismo en Java

Publicado por Henry (7 intervenciones) el 22/03/2020 03:15:51
Hola buenas noches, igual soy nuevo... Entonces, polimorfismo es el nombre que comparten objetos o hijos? como perros, diferente razas, pero que comparten el sobrenombre perro... todavía es algo confuso para mi el termino.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Kabuto
Val: 2.268
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Que es exactamente el polimorfismo en Java

Publicado por Kabuto (568 intervenciones) el 22/03/2020 11:43:26
Polimorfismo es una palabra muy rimbombante que parece hacer referencia a algo muy complicado, y lo cierto es que no.

Polimorfismo significa "varias formas", ¿cómo se aplica esto a POO?

Por ejemplo, pensemos en la clase Hombre y en la clase Mujer, que ambos heredan de la clase Persona.

Hombre y Mujer son clases diferentes, van a tener atributos y métodos diferentes. Pero también van a tener algunos atributos/métodos comunes, que son los que van a heredar de Persona.

Bien, si yo ahora creo un array para guardar objetos Hombre.
1
Hombre[] hombres_arr = new Hombre[10];

Yo ahí no puedo poner objetos Mujer. Obvio porque es una clase distinta.
Pero tampoco puedo poner objetos Persona, a pesar de que un Hombre es una Persona.

Ese array solo acepta objetos que tengan la "forma" de Hombre, porque se espera que todos eso objetos tengan los métodos y atributos de la forma/clase Hombre.
Es decir, solo objetos capaces de comportarse como un Hombre son aceptados.

Bien, si yo ahora creo un array de Persona:
1
Persona[] personas_arr = new Persona[10];

Yo ahí puedo poner objetos Persona. Pero también puedo poner objetos Hombre y objetos Mujer.
¿Por qué?
Porque para ese array se pide que los objetos sepan comportarse como un objeto Persona.
Hombre y Mujer son distintos, pero saben comportarse como un objeto Persona, ya que heredan sus atributos/métodos.

Eso sí, mientras estén dentro del array Persona, su "forma" va a ser el de una Persona. Los objetos Hombre no podrán hacer cosas específicas de la clase Hombre y lo mismo para los objetos Mujer.

A eso hace referencia el polimorfismo: Un objeto puede tener varias "formas" según su "linaje hereditario" e ir cambiando de una a otra según las necesidades.

Así un Hombre, puede tener forma de Hombre, puede tener forma de Persona y también puede tener forma de Object. En Java todas las clases son hijas de la clase Object, de quien heredan métodos como por ejemplo el método toString()

Lo mismo para un objeto Mujer.

Y un objeto Persona puede tener forma de Persona y forma de Object, pues su línea hereditaria es menor.

Y bueno, eso es polimorfismo. Como digo no es nada extraño o complicado, pero la palabra asusta un poco xD
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
2
Comentar

Que es exactamente el polimorfismo en Java

Publicado por Costero (112 intervenciones) el 22/03/2020 17:07:28
Usando interface tu objeto puede tener mas parientes. Java solo permite extender una clase pero multiple interfaces.

Asi que prefieres Interface a Abstract clases o Concrete clases

No uses "objeto2 extends objeto1", "objeto3 extends objeto2", etc para crear un lineaje. Se considera muy mala practica:

La subclasificación tiene los siguientes problemas:

viola la encapsulación, ya que las implementaciones de la superclase y la subclase se acoplan estrechamente

Los nuevos métodos agregados a la superclase pueden romper la subclase
la superclase y la subclase deben evolucionar en paralelo

diseñar una clase para que pueda extenderse de forma segura requiere un trabajo adicional: es riesgoso extender una clase que no esté diseñada explícitamente para tal uso

los diferentes paquetes a menudo están bajo el control de diferentes programadores; extender una clase en un paquete diferente es arriesgado


Por ultimo no uses set/get hasta que sea realmented necesario, como una data class. Immutable classes es mejor.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public abstract class GeometricFigure  implements Comparable<GeometricFigure> {
    public GeometricFigure(String name) {
        this.name = name;
    }
 
    protected final String name;
    abstract double calculateArea();
    abstract double calculatePerimeter();
 
    @Override
    public int compareTo(GeometricFigure o) {
        return Double.compare(this.calculateArea(), o.calculateArea());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Circle extends GeometricFigure {
 
    private final double radio;
    private final double pi;
 
    public Circle(String name, double radio, double pi) {
        super(name);
        this.radio = radio;
        this.pi = pi;
    }
 
    @Override
    double calculateArea() {
        return this.pi * Math.pow(this.radio, 2);
    }
 
    @Override
    double calculatePerimeter() {
        return this.pi * (this.radio + this.radio);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class Triangle extends GeometricFigure{
 
    private final double base;
    private final double height;
    private final double cO;
    private final double cA;
    private final double h;
 
 
    public Triangle(String name, double base, double height, double cO, double cA, double h ) {
        super(name);
        this.base = base;
        this.height = height;
        this.cO = cO;
        this.cA = cA;
        this.h = h;
    }
 
    @Override
    double calculateArea() {
        return (base*height/2);
    }
 
    @Override
    double calculatePerimeter() {
        return cO+cA+h;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class Polimorfismo {
 
    public static void main(String[] args) {
        GeometricFigure triangle = new Triangle("Triangulo Equilatero", 10, 20, 15, 10, 30);
        GeometricFigure circle = new Circle("Circle bullet", 10, Math.PI);
 
        List<GeometricFigure> geometricFigures = new ArrayList<>();
        geometricFigures.add(circle);
        geometricFigures.add(triangle);
 
        System.out.println("Before sorting ....");
        for (GeometricFigure geometricFigure : geometricFigures) {
            print(geometricFigure);
        }
 
        // Nota como sort solo toma Comparable.class ...
        Collections.sort(geometricFigures);
 
        System.out.println();
        System.out.println("After sorting ....");
        for (GeometricFigure geometricFigure : geometricFigures) {
            print(geometricFigure);
            System.out.println();
        }
 
    }
 
    private static void print(GeometricFigure geometricFigure) {
        String name = geometricFigure.name;
        System.out.println(name);
        System.out.println("Area del " + name + ": " + geometricFigure.calculateArea());
        System.out.println("Perimetro del " + name + ": " + geometricFigure.calculatePerimeter());
    }
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar