Aula 3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aula 3\n",
    "Nessa aula trabalharemos um pouco mais em cima de Herança, trazendo os seguintes conceitos:\n",
    "\n",
    "* Classes Abstratas\n",
    "* *Traits* (traços)\n",
    "* Polimorfismo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes Abstratas\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classes abstratas são classes que possuem campos (métodos ou atributos) não definidos, pois os mesmos dependem de algum contexto. Quando criamos uma classe abstrata, esperamos que sejam criadas subclasses que herdem dela a fim de completá-la.\n",
    "\n",
    "Vamos utilizar o seguinte exemplo: **figuras**. Modelaremos a classe Figura seguindo os critérios:\n",
    "* toda figura tem um centro (utilizaremos uma classe Ponto para representá-lo)\n",
    "* podemos calcular a área de uma figura\n",
    "* podemos calcular o perímetro de uma figura"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Ponto(x: Int,y: Int){\n",
    "    def X = x\n",
    "    def Y = y\n",
    "}\n",
    "\n",
    "abstract class Figura(c: Ponto) {\n",
    "    def centro = c //método implementado\n",
    "    \n",
    "    def calcularArea: Double //método sem implementação\n",
    "    def calcularPerimetro: Int //método sem implementação\n",
    "    def desenhar: Unit //método sem implementação\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A partir da classe abstrata Figura, podemos implementar 2 outras classes: Quadrado e Retângulo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Quadrado(l: Int, c: Ponto) extends Figura(c){\n",
    "    \n",
    "    def lado = l\n",
    "    \n",
    "    //métodos da classe Figura\n",
    "    def calcularArea: Double = l*l\n",
    "    def calcularPerimetro: Int = 4*l\n",
    "    def desenhar: Unit = println(\"Um quadrado de lado \"+ l)\n",
    "}\n",
    "\n",
    "class Retangulo(b: Int, h: Int, c: Ponto) extends Figura(c){\n",
    "    \n",
    "    def base = b\n",
    "    def altura = h\n",
    "    \n",
    "    //métodos da classe Figura\n",
    "    def calcularArea: Double = b*h\n",
    "    def calcularPerimetro: Int = b*2 + h*2\n",
    "    def desenhar: Unit = println(\"Um retângulo de base \"+ b + \" e altura \"+h)\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora podemos criar objetos das classes Quadrado e Retângulo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "val q = new Quadrado(2, new Ponto(0,0))\n",
    "q.desenhar\n",
    "println(\"Perímetro: \"+q.calcularPerimetro)\n",
    "println(\"Área: \"+q.calcularArea)\n",
    "\n",
    "println(\"-----------------------------\")\n",
    "\n",
    "val r = new Retangulo(1,2,new Ponto(1,1))\n",
    "r.desenhar\n",
    "println(\"Perímetro: \"+r.calcularPerimetro)\n",
    "println(\"Área: \"+r.calcularArea)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Traits* (Traços)\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em Orientação à Objetos, existe um conceito além de classe abstrata: **interfaces**. Interfaces são classes abstratas *puras*, ou sejam, nenhum método é implementado. Um exemplo são operações: toda operação recebe um elemento e retorna outro. A operação que gera esse retorno fica definido pela subclasse."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scala trabalha com algo mais poderoso que interfaces: ***traits*** (ou traços). Um traço pode ser visto como uma classe abstrata, porém, semanticamente, ele não contém características o suficiente para ser chamado de classe.\n",
    "Vamos ao exemplo abaixo, onde definiremos uma classe abstrata para o cálculo de uma potência:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "abstract class Potencia{\n",
    "    val p: Int //o número da potência\n",
    "    \n",
    "    def apply(n: Int): Double //aplicação da potência\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nossa classe abstrata agora precisa do o valor de *p* para poder ser instanciada. Vamos trabalhar com potências de 2 e de 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "trait potencia2 {\n",
    "    val p = 2\n",
    "}\n",
    "\n",
    "trait potencia3 {\n",
    "    val p = 3\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos calcular potências negativas e positivas. Vamos criar traços para isso também:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "trait positiva extends Potencia{\n",
    "    def apply(n: Int) = math.pow(n,p)\n",
    "}\n",
    "\n",
    "trait negativa extends Potencia{\n",
    "    def apply(n: Int) = 1/math.pow(n,p)\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**OBS**: os traços *positiva* e *negativa* precisam extender de *Potencia* para que utilizem o valor de *p*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que os atributos e os métodos presentes nos traços tem de ter a **mesma assinatura** da classe abstrata, para que possam funcionar corretamente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora, podemos compor esses traços e obter diversos tipos de potências:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Quadrado extends Potencia with potencia2 with positiva //n²\n",
    "\n",
    "class QuadradoInversa extends Potencia with potencia2 with negativa //n⁻²\n",
    "\n",
    "class Cubica extends Potencia with potencia3 with positiva //n³\n",
    "\n",
    "class CubicaInversa extends Potencia with potencia3 with negativa //n⁻³"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "val q1 = new Quadrado\n",
    "println(q1(2))\n",
    "\n",
    "val q2 = new QuadradoInversa\n",
    "println(q2(2))\n",
    "\n",
    "val c1 = new Cubica\n",
    "println(c1(2))\n",
    "\n",
    "val c2 = new CubicaInversa\n",
    "println(c2(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Polimorfismo\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O fenômeno *polimorfismo* permite que um método comporte-se de várias maneiras. Existem diversas maneiras de ocorrer o polimorfismo, porém este material não discutirá sobre os conceitos. Para mais informações deve-se consultar um material apropriado para Orientação à Objetos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma maneira de usar polimorfismo é alterando os tipos dos parâmetros de um método. Esse tipo de polimorfismo chama-se *Sobrecarga*. No Objeto abaixo, que representa um somador, existem diversas maneiras de somar 2 elementos de diferentes tipos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "object Somador{\n",
    "    def apply(i: Int, j: Int): Int = i+j\n",
    "    def apply(i: Int, j: Double): Double = i+j\n",
    "    def apply(i: Double, j: Double): Double = i+j\n",
    "    \n",
    "    def apply(s: String, i: Int): String = s+i.toString\n",
    "}\n",
    "\n",
    "println(Somador(1,1))\n",
    "println(Somador(1,1.2))\n",
    "println(Somador(2.3,4.5))\n",
    "println(Somador(\"1 + 1 = \",2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outra maneira de ter-se polimorfismo é delegando a implementação do método para uma sublcasse. Esse tipo chama-se *Inclusão*. Como um exemplo, podemos pensar em Operadores Unários. Todo operador unário deve receber um número e retornar outro, aplicando uma operação sobre ele."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "trait OperadorUnario{\n",
    "    def apply(n: Int): Double\n",
    "}\n",
    "\n",
    "class Dobro extends OperadorUnario{\n",
    "    def apply(n: Int): Double = 2*n\n",
    "}\n",
    "\n",
    "class Quadrado extends OperadorUnario{\n",
    "    def apply(n: Int): Double = n*n\n",
    "}\n",
    "\n",
    "class Raiz extends OperadorUnario{\n",
    "    def apply(n: Int): Double = math.sqrt(n)\n",
    "}\n",
    "\n",
    "var op: OperadorUnario = new Dobro\n",
    "println(op(3))\n",
    "\n",
    "op = new Quadrado\n",
    "println(op(3))\n",
    "\n",
    "op = new Raiz\n",
    "println(op(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercícios\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Escreva implementações para a classe abstrata a seguir, a fim de fazer o código funcionar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "abstract class Expressao {\n",
    "    def apply(): Double\n",
    "}\n",
    "\n",
    "class Constante(n: Int) extends Expressao{\n",
    "    def apply(): Double = n\n",
    "}\n",
    "\n",
    "abstract class OperadorUnario(a: Expressao) extends Expressao{}\n",
    "\n",
    "abstract class OperadorBinario(a: Expressao, b: Expressao) extends Expressao{}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "//2 + (5 x 3² - (2+1)*(10/9) )\n",
    "val e: Expressao = new Soma(\n",
    "    new Constante(2),\n",
    "    new Subtracao(\n",
    "        new Produto(\n",
    "            new Constante(5),new Potencia(new Constante(3),new Constante(2))),\n",
    "        new Produto(\n",
    "            new Soma(\n",
    "                new Constante(2),new Constante(1)\n",
    "            ),\n",
    "            new Divisão(\n",
    "            new Constante(10),new Constante(9)\n",
    "            )\n",
    "        )\n",
    "    )\n",
    ")\n",
    "\n",
    "e()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Scala",
   "language": "scala",
   "name": "scala"
  },
  "language_info": {
   "codemirror_mode": "text/x-scala",
   "file_extension": ".scala",
   "mimetype": "text/x-scala",
   "name": "scala211",
   "nbconvert_exporter": "script",
   "pygments_lexer": "scala",
   "version": "2.11.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}