Java Polimorfismo através da interface - Como usar?

s4lezardv1A · 11 de maio de 2019

Boa noite, tenho o seguinte exercicio:

Dada a interface <<FormaGeometrica>> com os métodos calcularArea e calcularPermimetro
implementem a classe Quadrado e Círculo e retornem a área e o perímetro dessas duas formas. Feita a
implementação, criem uma classe Main para que o usuário possa fornecer os dados necessários para que
possamos criar cada uma das formas geométricas (O quadrado necessita saber o valor de um dos seus lados,
o círculo necessita saber seu raio). Feito isso exibir na tela qual a área e o perímetro de cada uma das formas
geométricas utilizando polimorfismo através de interfaces.

Estou em duvida do porque usar polimorfismo ao invés de usar uma variavel normal, pois os resultados foram o mesmo

Minha interface FormaGeometrica

public interface FormaGeometrica {
	
	 double calcularArea(double dado);
	 double calcularPerimetro(double dado);
}

Minha classe Quadrado

public class Quadrado implements FormaGeometrica{

	@Override
	public double calcularArea(double lado) {
		return Math.pow(lado,2);
	}

	@Override
	public double calcularPerimetro(double lado) {
		return lado+lado+lado+lado;
	}

}

Minha classe Main( vou postar só com o quadrado OK)

public class MainFormaGeometrica {

	public static void main(String[] args) {
		//Polimorfismo, O JEITO QUE EU FIZ O EXERCICIO
	FormaGeometrica quadrado = new Quadrado();
	System.out.println("A area do quadrado é: "+quadrado.calcularArea(5));
	System.out.println("O perimetro do quadrado é: "+quadrado.calcularPerimetro(5));
	
		//Normal EXEMPLO
	Quadrado quadrado2 = new Quadrado();
	System.out.println("A area do quadrado é: "+quadrado2.calcularArea(5));
	System.out.println("O perimetro do quadrado é: "+quadrado2.calcularPerimetro(5));
	
	}

}

Fiz o exercicio com polimorfismo igual aos codigos q eu postei, só tirei o circulo para mostrar melhor. A minha duvida é,caso,se eu entendi o exercicio, e se fiz da maneira correta, porque usar polimorfismo em interface sendo que se eu só usar uma variavel Tipo Quadrado que ja tem o contrato com formageometrica, ja vou poder utilizar os metodos da propria classe(override)?

AdrianoSiqueira · 12 de maio de 2019

Dentro do contexto do seu exemplo, imagine que você tem uma função que retorna o valor da área de uma forma geométrica, não importa qual seja. Sem usar polimorfismo, você deveria criar essa função para cada uma das formas geométricas que você está trabalhando. Já usando polimorfismo você só precisa pedir a interface FormaGeometrica e qualquer classe que implemente essa interface automaticamente também será aceita.

Recomendo os cursos do DevDojo. Seguem as aulas referentes ao polimorfismo em ordem 1, 2 e 3:

https://www.youtube.com/watch?v=Ps2ptq1twyA

https://www.youtube.com/watch?v=FukH_mIRzV8

https://www.youtube.com/watch?v=PMFxgfqYYuE

s4lezardv1A · 12 de maio de 2019

Ola Adriano, então, dessa parte de polimorfismo eu entendi.Eu estava utilizando ele com herança de uma superclasse. Exemplo: Uma super classe com o nome de EmpresaFotocopias que tem a função de tirar fotocopias por um valor, suas classes filhas Copiadora1 e Copiadora2 herdam essa função. Então via polimorfismo eu utilizo o seguinte:

EmpresaFotocopias empresa1 = new Copiadora1();
empresa1.tirarFotocopias();

EmpresaFotocopias empresa2 = new Copiadora1();
empresa2.tirarFotocopias();

A empresa1 do tipo EmpresaFotocopias é uma Copiadora1 que utilizara seus metodos.
Não seria isso?

Eu não estou entendendo muito interface. Pelo que eu estudei( aprendi ontem), interface é um contrato que uma classe obedece. O que foi explicado é que interface diferente de uma superclasse, só possui metodos.

AdrianoSiqueira · 12 de maio de 2019

Pensa na interface da seguinte forma: "A classe que implementa a interface sabe o que tem que fazer, mas não sabe como."

Você já deve ter percebido que os métodos das interfaces não possuem corpo, apenas a declaração. Isso significa que a classe que implementar essa interface já sabe o que tem que fazer porque o método já foi declarado, mas não sabe como e é por isso que você deve implementar as funções.

adicionado 29 minutos depois

Segue um exemplo funcional:

Interface FormaGeometrica:

package pacote;

/**
 * A classe que implementar essa interface já sabe o que tem que fazer:
 * - calcular a área da figura
 * - calcular o perímetro da figura
 *
 * Mas ainda não sabe como vai fazer isso. É por isso que as funções não tem corpo.
 */
public interface FormaGeometrica {
    double calcularArea();

    double calcularPerimetro();
}

classe Quadrado:

package pacote;

public class Quadrado implements FormaGeometrica {

    private double lado;

    public Quadrado() {
    }

    public Quadrado(double lado) {
        this.lado = lado;
    }

    public double getLado() {
        return lado;
    }

    public void setLado(double lado) {
        this.lado = lado;
    }

    @Override
    public double calcularArea() {
        return lado * lado;
    }

    @Override
    public double calcularPerimetro() {
        return lado * 4;
    }
}

classe Circulo:

package pacote;

public class Circulo implements FormaGeometrica {

    private double raio;

    public Circulo() {
    }

    public Circulo(double raio) {
        this.raio = raio;
    }

    public double getRaio() {
        return raio;
    }

    public void setRaio(double raio) {
        this.raio = raio;
    }

    @Override
    public double calcularArea() {
        return Math.PI * (raio * raio);
    }

    @Override
    public double calcularPerimetro() {
        return 2 * Math.PI * raio;
    }
}

classe Principal:

package pacote;

public class Principal {
    public static void main(String[] args) {
        FormaGeometrica quadrado1 = new Quadrado(3);
        FormaGeometrica quadrado2 = new Quadrado(12);
        FormaGeometrica quadrado3 = new Quadrado(6);
        FormaGeometrica quadrado4 = new Quadrado(2);

        FormaGeometrica circulo1 = new Circulo(3);
        FormaGeometrica circulo2 = new Circulo(12);
        FormaGeometrica circulo3 = new Circulo(6);
        FormaGeometrica circulo4 = new Circulo(2);

        System.out.println(">> Área quadrados");
        exibirArea(quadrado1);
        exibirArea(quadrado2);
        exibirArea(quadrado3);
        exibirArea(quadrado4);

        System.out.println(">> Área circulos");
        exibirArea(circulo1);
        exibirArea(circulo2);
        exibirArea(circulo3);
        exibirArea(circulo4);

        System.out.println(">> Perímetro quadrados");
        exibirPerimetro(quadrado1);
        exibirPerimetro(quadrado2);
        exibirPerimetro(quadrado3);
        exibirPerimetro(quadrado4);

        System.out.println(">> Perímetro circulos");
        exibirPerimetro(circulo1);
        exibirPerimetro(circulo2);
        exibirPerimetro(circulo3);
        exibirPerimetro(circulo4);
    }

    private static void exibirArea(FormaGeometrica forma) {
        System.out.println("Área: " + forma.calcularArea());
    }

    private static void exibirPerimetro(FormaGeometrica forma) {
        System.out.println("Perímetro: " + forma.calcularPerimetro());
    }
}

Perceba na classe Principal que os métodos não especificam que o argumento deve ser um quadrado ou um círculo, apenas diz que deve ser uma forma geométrica, ou seja, qualquer classe que implemente a interface FormaGeometrica será aceita por esse método. Isso evita que você tenha que criar uma função para o quadrado, outra para o círculo, e assim por diante.

s4lezardv1A · 17 de maio de 2019

Em 12/05/2019 às 10:13, AdrianoSiqueira disse: