diff --git a/notebooks/pt/c02oo/s12interface/s01aula-tarefa/interface-poligono.ipynb b/notebooks/pt/c02oo/s12interface/s01aula-tarefa/interface-poligono.ipynb index 4b909d9..5bcb763 100644 --- a/notebooks/pt/c02oo/s12interface/s01aula-tarefa/interface-poligono.ipynb +++ b/notebooks/pt/c02oo/s12interface/s01aula-tarefa/interface-poligono.ipynb @@ -27,7 +27,7 @@ { "data": { "text/plain": [ - "com.twosigma.beaker.javash.bkr60a7d4cf.Retangulo" + "com.twosigma.beaker.javash.bkrf6ac97ad.Retangulo" ] }, "execution_count": 1, @@ -71,7 +71,7 @@ { "data": { "text/plain": [ - "com.twosigma.beaker.javash.bkr60a7d4cf.Circulo" + "com.twosigma.beaker.javash.bkrf6ac97ad.Circulo" ] }, "execution_count": 2, @@ -179,7 +179,7 @@ { "data": { "text/plain": [ - "com.twosigma.beaker.javash.bkr60a7d4cf.Geometria" + "com.twosigma.beaker.javash.bkrf6ac97ad.Geometria" ] }, "execution_count": 4, @@ -202,7 +202,7 @@ { "data": { "text/plain": [ - "com.twosigma.beaker.javash.bkr60a7d4cf.Retangulo" + "com.twosigma.beaker.javash.bkrf6ac97ad.Retangulo" ] }, "execution_count": 5, @@ -246,7 +246,7 @@ { "data": { "text/plain": [ - "com.twosigma.beaker.javash.bkr60a7d4cf.Circulo" + "com.twosigma.beaker.javash.bkrf6ac97ad.Circulo" ] }, "execution_count": 6, @@ -364,16 +364,16 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "com.twosigma.beaker.javash.bkr60a7d4cf.EmprestimoSimples" + "com.twosigma.beaker.javash.bkrf6ac97ad.EmprestimoSimples" ] }, - "execution_count": 16, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -403,16 +403,16 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "com.twosigma.beaker.javash.bkr60a7d4cf.EmprestimoComposto" + "com.twosigma.beaker.javash.bkrf6ac97ad.EmprestimoComposto" ] }, - "execution_count": 13, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -447,7 +447,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -472,7 +472,7 @@ "null" ] }, - "execution_count": 17, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -494,6 +494,674 @@ " i++;\n", "}" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Recebendo `Interface` como Parâmetro\n", + "\n", + "Considere o novo cenário a seguir em que é definida uma `interface` para as classes `Retangulo` e `TrianguloRetangulo` utilizadas no notebook sobre classes abstratas. Neste caso, não há mecanismo de herança envolvida.\n", + "\n", + "O método `sameProportions` recebe um objeto que implementa a interface `Retangular`, ou seja, pode se comparar com qualquer objeto que implementa essa interface:\n", + "~~~java\n", + "public boolean sameProportions(Retangular toCompare)\n", + "~~~\n", + "\n", + "A classe `Retangulo` implementa duas interfaces:\n", + "~~~java\n", + "public class Retangulo implements Geometria, Retangular\n", + "~~~" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "com.twosigma.beaker.javash.bkrf6ac97ad.Retangular" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "public interface Retangular {\n", + " public int getAltura();\n", + " public int getLargura();\n", + " public boolean sameProportions(Retangular toCompare);\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "com.twosigma.beaker.javash.bkrf6ac97ad.TrianguloRetangulo" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "public class TrianguloRetangulo implements Retangular {\n", + " private int altura;\n", + " private int largura;\n", + " \n", + " public TrianguloRetangulo(int altura, int largura) {\n", + " this.altura = altura;\n", + " this.largura = largura;\n", + " }\n", + "\n", + " public int getAltura() {\n", + " return altura;\n", + " }\n", + " \n", + " public int getLargura() {\n", + " return largura;\n", + " }\n", + " \n", + " public float getArea() {\n", + " return getAltura() * getLargura() / 2;\n", + " }\n", + " \n", + " public boolean sameProportions(Retangular toCompare) {\n", + " return (largura / altura == toCompare.getLargura() / toCompare.getLargura());\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "com.twosigma.beaker.javash.bkrf6ac97ad.Retangulo" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "public class Retangulo implements Geometria, Retangular {\n", + " private int altura;\n", + " private int largura;\n", + "\n", + " public Retangulo(int altura, int largura) {\n", + " this.altura = altura;\n", + " this.largura = largura;\n", + " }\n", + " \n", + " public int getAltura() {\n", + " return altura;\n", + " }\n", + " \n", + " public int getLargura() {\n", + " return largura;\n", + " }\n", + " \n", + " public float getPerimetro() {\n", + " return 2 * (altura + largura);\n", + " }\n", + " \n", + " public float getArea() {\n", + " return altura * largura;\n", + " }\n", + " \n", + " public boolean sameProportions(Retangular toCompare) {\n", + " return (largura / altura == toCompare.getLargura() / toCompare.getLargura());\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Medidas do triangulo retângulo - altura: 60; largura: 100\n", + "Medidas do retângulo - altura: 6; largura: 10\n", + "Ambos têm as mesmas proporções\n" + ] + }, + { + "data": { + "text/plain": [ + "null" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Retangular tr = new TrianguloRetangulo(60, 100);\n", + "Retangular rt = new Retangulo(6, 10);\n", + "\n", + "System.out.println(\"Medidas do triangulo retângulo - altura: \" +\n", + " tr.getAltura() + \"; largura: \" + tr.getLargura());\n", + "System.out.println(\"Medidas do retângulo - altura: \" +\n", + " rt.getAltura() + \"; largura: \" + rt.getLargura());\n", + "\n", + "if (tr.sameProportions(rt))\n", + " System.out.println(\"Ambos têm as mesmas proporções\");\n", + "else\n", + " System.out.println(\"Ambos têm proporções diferentes\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Reunindo Interfaces\n", + "\n", + "Se quisermos reunir interfaces adotadas por `Retangulo` e `TrianguloRetangulo`?\n", + "\n", + "## Herança de Interfaces\n", + "\n", + "* Mecanismo de extensão de interface a partir da existente\n", + "* No exemplo a seguir não é possível dissociar Retangular de Geometria" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "com.twosigma.beaker.javash.bkrf6ac97ad.Geometria" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "public interface Geometria {\n", + " public float getPerimetro();\n", + " public float getArea();\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "com.twosigma.beaker.javash.bkrf6ac97ad.Retangular" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "public interface Retangular extends Geometria {\n", + " public int getAltura();\n", + " public int getLargura();\n", + " public boolean sameProportions(Retangular toCompare);\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "com.twosigma.beaker.javash.bkrf6ac97ad.Retangulo" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "public class Retangulo implements Geometria, Retangular {\n", + " private int altura;\n", + " private int largura;\n", + "\n", + " public Retangulo(int altura, int largura) {\n", + " this.altura = altura;\n", + " this.largura = largura;\n", + " }\n", + " \n", + " public int getAltura() {\n", + " return altura;\n", + " }\n", + " \n", + " public int getLargura() {\n", + " return largura;\n", + " }\n", + " \n", + " public float getPerimetro() {\n", + " return 2 * (altura + largura);\n", + " }\n", + " \n", + " public float getArea() {\n", + " return altura * largura;\n", + " }\n", + " \n", + " public boolean sameProportions(Retangular toCompare) {\n", + " return (largura / altura == toCompare.getLargura() / toCompare.getLargura());\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "com.twosigma.beaker.javash.bkrf6ac97ad.TrianguloRetangulo" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "public class TrianguloRetangulo implements Retangular {\n", + " private int altura;\n", + " private int largura;\n", + " \n", + " public TrianguloRetangulo(int altura, int largura) {\n", + " this.altura = altura;\n", + " this.largura = largura;\n", + " }\n", + "\n", + " public int getAltura() {\n", + " return altura;\n", + " }\n", + " \n", + " public int getLargura() {\n", + " return largura;\n", + " }\n", + " \n", + " public float getPerimetro() {\n", + " return (float) (altura + largura + Math.sqrt(altura * altura + largura * largura));\n", + " }\n", + " \n", + " public float getArea() {\n", + " return getAltura() * getLargura() / 2;\n", + " }\n", + " \n", + " public boolean sameProportions(Retangular toCompare) {\n", + " return (largura / altura == toCompare.getLargura() / toCompare.getLargura());\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Medidas do retângulo - altura: 6; largura: 10\n", + "Medidas do triangulo retângulo - altura: 60; largura: 100\n", + "Perímetro do retângulo: 32.0\n", + "Área do retângulo: 60.0\n", + "Perímetro do triângulo retângulo: 276.61905\n", + "Área do triângulo retângulo: 3000.0\n", + "Ambos têm as mesmas proporções\n" + ] + }, + { + "data": { + "text/plain": [ + "null" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Retangular rt = new Retangulo(6, 10);\n", + "Retangular tr = new TrianguloRetangulo(60, 100);\n", + "\n", + "System.out.println(\"Medidas do retângulo - altura: \" +\n", + " rt.getAltura() + \"; largura: \" + rt.getLargura());\n", + "System.out.println(\"Medidas do triangulo retângulo - altura: \" +\n", + " tr.getAltura() + \"; largura: \" + tr.getLargura());\n", + " \n", + "System.out.println(\"Perímetro do retângulo: \" + rt.getPerimetro());\n", + "System.out.println(\"Área do retângulo: \" + rt.getArea());\n", + "\n", + "System.out.println(\"Perímetro do triângulo retângulo: \" + tr.getPerimetro());\n", + "System.out.println(\"Área do triângulo retângulo: \" + tr.getArea());\n", + "\n", + "if (tr.sameProportions(rt))\n", + " System.out.println(\"Ambos têm as mesmas proporções\");\n", + "else\n", + " System.out.println(\"Ambos têm proporções diferentes\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Herança Múltipla de Interfaces\n", + "\n", + "Uma interface pode ser herdeira de mais de uma interface. Nesse caso, ela irá requerer a combinação de todos os métodos declarados nas interfaces que ela herda (mais métodos que ela possa acrescentar)." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "com.twosigma.beaker.javash.bkrf6ac97ad.Geometria" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "public interface Geometria {\n", + " public float getPerimetro();\n", + " public float getArea();\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "com.twosigma.beaker.javash.bkrf6ac97ad.Retangular" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "public interface Retangular {\n", + " public int getAltura();\n", + " public int getLargura();\n", + " public boolean sameProportions(Retangular toCompare);\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "com.twosigma.beaker.javash.bkrf6ac97ad.GeometriaRetangular" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "public interface GeometriaRetangular extends Geometria, Retangular {\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "com.twosigma.beaker.javash.bkrf6ac97ad.Circulo" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "public class Circulo implements Geometria {\n", + " public static float PI = 3.1416f;\n", + " \n", + " private int raio;\n", + " \n", + " public Circulo(int raio) {\n", + " this.raio = raio;\n", + " }\n", + " \n", + " public int getRaio() {\n", + " return raio;\n", + " }\n", + " \n", + " public float getPerimetro() {\n", + " return 2 * Circulo.PI * raio;\n", + " }\n", + " \n", + " public float getArea() {\n", + " return Circulo.PI * raio * raio;\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "com.twosigma.beaker.javash.bkrf6ac97ad.Retangulo" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "public class Retangulo implements GeometriaRetangular {\n", + " private int altura;\n", + " private int largura;\n", + "\n", + " public Retangulo(int altura, int largura) {\n", + " this.altura = altura;\n", + " this.largura = largura;\n", + " }\n", + " \n", + " public int getAltura() {\n", + " return altura;\n", + " }\n", + " \n", + " public int getLargura() {\n", + " return largura;\n", + " }\n", + " \n", + " public float getPerimetro() {\n", + " return 2 * (altura + largura);\n", + " }\n", + " \n", + " public float getArea() {\n", + " return altura * largura;\n", + " }\n", + " \n", + " public boolean sameProportions(Retangular toCompare) {\n", + " return (largura / altura == toCompare.getLargura() / toCompare.getLargura());\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "com.twosigma.beaker.javash.bkrf6ac97ad.TrianguloRetangulo" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "public class TrianguloRetangulo implements Retangular {\n", + " private int altura;\n", + " private int largura;\n", + " \n", + " public TrianguloRetangulo(int altura, int largura) {\n", + " this.altura = altura;\n", + " this.largura = largura;\n", + " }\n", + "\n", + " public int getAltura() {\n", + " return altura;\n", + " }\n", + " \n", + " public int getLargura() {\n", + " return largura;\n", + " }\n", + " \n", + " public float getArea() {\n", + " return getAltura() * getLargura() / 2;\n", + " }\n", + " \n", + " public boolean sameProportions(Retangular toCompare) {\n", + " return (largura / altura == toCompare.getLargura() / toCompare.getLargura());\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Medidas do retângulo - altura: 6; largura: 10\n", + "Perímetro do retângulo: 32.0\n", + "Área do retângulo: 60.0\n", + "Perímetro do círculo: 50.2656\n", + "Área do círculo: 201.0624\n", + "Medidas do triangulo retângulo - altura: 60; largura: 100\n", + "Retângulo e triângulo retângulo têm as mesmas proporções\n" + ] + }, + { + "data": { + "text/plain": [ + "null" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "GeometriaRetangular rt = new Retangulo(6, 10);\n", + "\n", + "System.out.println(\"Medidas do retângulo - altura: \" +\n", + " rt.getAltura() + \"; largura: \" + rt.getLargura());\n", + "System.out.println(\"Perímetro do retângulo: \" + rt.getPerimetro());\n", + "System.out.println(\"Área do retângulo: \" + rt.getArea());\n", + "\n", + "Geometria ci = new Circulo(8);\n", + "\n", + "System.out.println(\"Perímetro do círculo: \" + ci.getPerimetro());\n", + "System.out.println(\"Área do círculo: \" + ci.getArea());\n", + "\n", + "Retangular tr = new TrianguloRetangulo(60, 100);\n", + "\n", + "System.out.println(\"Medidas do triangulo retângulo - altura: \" +\n", + " tr.getAltura() + \"; largura: \" + tr.getLargura());\n", + "\n", + "if (tr.sameProportions(rt))\n", + " System.out.println(\"Retângulo e triângulo retângulo têm as mesmas proporções\");\n", + "else\n", + " System.out.println(\"Retângulo e triângulo retângulo têm proporções diferentes\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tarefa\n", + "\n", + "## Classe `ConjuntoEmprestimos`\n", + "\n", + "Baseado no notebook sobre polimorfismo, construa uma classe denominada `ConjuntoEmprestimos` que é responsável por controlar um conjunto de empréstimos que podem ser simples ou compostos. Essa classe deve definir pelo menos os seguintes métodos:\n", + "\n", + "* `construtor` - recebe como parâmetro o número máximo de empréstimos;\n", + "* `adicionaEmprestimo` - recebe como parâmetro um empréstimo (simples ou composto) e o armazena (se não ultrapassar o número máximo);\n", + "* `proximasParcelas` - mostra as próximas parcelas de todos os empréstimos cadastrados (para fins de simplificação, considere que o número da próxima parcela é igual para todos); o método retorna um status de verdadeiro se houve pelo menos um empréstimo com próxima parcela.\n", + "\n", + "Utilize uma interface para generalizar o tratamento de empréstimo. É possível se criar um vetor de interfaces." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/src/src/pt/c02oo/s12interface/s03poligono/AppPoligonoInterface2.java b/src/src/pt/c02oo/s12interface/s03poligono/AppPoligonoInterface2.java index 27ee52a..d0d2605 100644 --- a/src/src/pt/c02oo/s12interface/s03poligono/AppPoligonoInterface2.java +++ b/src/src/pt/c02oo/s12interface/s03poligono/AppPoligonoInterface2.java @@ -3,15 +3,18 @@ public class AppPoligonoInterface2 { public static void main(String[] args) { - Geometria g = new Retangulo(6, 10); + Retangular tr = new TrianguloRetangulo(60, 100); + Retangular rt = new Retangulo(6, 10); - System.out.println("Perímetro do retângulo: " + g.getPerimetro()); - System.out.println("Área do retângulo: " + g.getArea()); - - g = new Circulo(8); - - System.out.println("Perímetro do círculo: " + g.getPerimetro()); - System.out.println("Área do círculo: " + g.getArea()); + System.out.println("Medidas do triangulo retângulo - altura: " + + tr.getAltura() + "; largura: " + tr.getLargura()); + System.out.println("Medidas do retângulo - altura: " + + rt.getAltura() + "; largura: " + rt.getLargura()); + + if (tr.sameProportions(rt)) + System.out.println("Ambos têm as mesmas proporções"); + else + System.out.println("Ambos têm proporções diferentes"); } } diff --git a/src/src/pt/c02oo/s12interface/s04poligono/AppPoligonoInterface3.java b/src/src/pt/c02oo/s12interface/s04poligono/AppPoligonoInterface3.java index 41c38c7..7788d4e 100644 --- a/src/src/pt/c02oo/s12interface/s04poligono/AppPoligonoInterface3.java +++ b/src/src/pt/c02oo/s12interface/s04poligono/AppPoligonoInterface3.java @@ -3,15 +3,24 @@ public class AppPoligonoInterface3 { public static void main(String[] args) { - Geometria g = new Retangulo(6, 10); + Retangular rt = new Retangulo(6, 10); + Retangular tr = new TrianguloRetangulo(60, 100); - System.out.println("Perímetro do retângulo: " + g.getPerimetro()); - System.out.println("Área do retângulo: " + g.getArea()); + System.out.println("Medidas do retângulo - altura: " + + rt.getAltura() + "; largura: " + rt.getLargura()); + System.out.println("Medidas do triangulo retângulo - altura: " + + tr.getAltura() + "; largura: " + tr.getLargura()); + + System.out.println("Perímetro do retângulo: " + rt.getPerimetro()); + System.out.println("Área do retângulo: " + rt.getArea()); - g = new Circulo(8); + System.out.println("Perímetro do triângulo retângulo: " + tr.getPerimetro()); + System.out.println("Área do triângulo retângulo: " + tr.getArea()); - System.out.println("Perímetro do círculo: " + g.getPerimetro()); - System.out.println("Área do círculo: " + g.getArea()); + if (tr.sameProportions(rt)) + System.out.println("Ambos têm as mesmas proporções"); + else + System.out.println("Ambos têm proporções diferentes"); } } diff --git a/src/src/pt/c02oo/s12interface/s05poligono/AppPoligonoInterface3.java b/src/src/pt/c02oo/s12interface/s05poligono/AppPoligonoInterface3.java deleted file mode 100644 index a84a9e3..0000000 --- a/src/src/pt/c02oo/s12interface/s05poligono/AppPoligonoInterface3.java +++ /dev/null @@ -1,17 +0,0 @@ -package pt.c02oo.s12interface.s05poligono; - -public class AppPoligonoInterface3 { - - public static void main(String[] args) { - Geometria g = new Retangulo(6, 10); - - System.out.println("Perímetro do retângulo: " + g.getPerimetro()); - System.out.println("Área do retângulo: " + g.getArea()); - - g = new Circulo(8); - - System.out.println("Perímetro do círculo: " + g.getPerimetro()); - System.out.println("Área do círculo: " + g.getArea()); - } - -} diff --git a/src/src/pt/c02oo/s12interface/s05poligono/AppPoligonoInterface4.java b/src/src/pt/c02oo/s12interface/s05poligono/AppPoligonoInterface4.java new file mode 100644 index 0000000..f86618a --- /dev/null +++ b/src/src/pt/c02oo/s12interface/s05poligono/AppPoligonoInterface4.java @@ -0,0 +1,29 @@ +package pt.c02oo.s12interface.s05poligono; + +public class AppPoligonoInterface4 { + + public static void main(String[] args) { + GeometriaRetangular rt = new Retangulo(6, 10); + + System.out.println("Medidas do retângulo - altura: " + + rt.getAltura() + "; largura: " + rt.getLargura()); + System.out.println("Perímetro do retângulo: " + rt.getPerimetro()); + System.out.println("Área do retângulo: " + rt.getArea()); + + Geometria ci = new Circulo(8); + + System.out.println("Perímetro do círculo: " + ci.getPerimetro()); + System.out.println("Área do círculo: " + ci.getArea()); + + Retangular tr = new TrianguloRetangulo(60, 100); + + System.out.println("Medidas do triangulo retângulo - altura: " + + tr.getAltura() + "; largura: " + tr.getLargura()); + + if (tr.sameProportions(rt)) + System.out.println("Retângulo e triângulo retângulo têm as mesmas proporções"); + else + System.out.println("Retângulo e triângulo retângulo têm proporções diferentes"); + } + +} diff --git a/src/src/pt/c02oo/s12interface/s05poligono/Retangulo.java b/src/src/pt/c02oo/s12interface/s05poligono/Retangulo.java index 9d9d287..c133f25 100644 --- a/src/src/pt/c02oo/s12interface/s05poligono/Retangulo.java +++ b/src/src/pt/c02oo/s12interface/s05poligono/Retangulo.java @@ -1,6 +1,6 @@ package pt.c02oo.s12interface.s05poligono; -public class Retangulo implements Geometria, Retangular { +public class Retangulo implements GeometriaRetangular { private int altura; private int largura;