Ybadoo - Soluções em Software Livre
Tutoriais
Programação Orientada a Objetos

Desenvolva uma classe chamada PlatonicSolid para representar um Sólido Platônico. A classe possui um único atributo denominado length, que representa o comprimento da aresta do Sólido Platônico, do tipo double e cujo valor deve ser maior ou igual a zero e menor ou igual a trinta. A classe possui dois construtores: o primeiro configura o comprimento da aresta do Sólido Platônico com o valor padrão um, e o segundo recebe como parâmetro o comprimento da aresta do Sólido Platônico. O comprimento da aresta do Sólido Platônico pode ser obtido e alterado pelo usuário por meio dos métodos getLength() e setLength(), respectivamente. A quantidade de faces, arestas e vértices do Sólido Platônico podem ser obitos pelo usuário por meio dos métodos getFaces(), getEdges() e getVertices(), respectivamente. A classe também apresenta os métodos area() e volume(), que retornam a área e o volume do Sólido Platônico, respectivamente.

Estenda a classe PlatonicSolid para implementar uma classe chamada Tetrahedron para representar um tetraedro, ou seja, um poliedro regular de quatro faces, considerado um dos cinco Sólidos Platônicos. Um tetraedro possui quatro faces, seis arestas e quatro vértices. A área de um tetraedro de aresta a é obtida pela fórmula √3 * a2. O volume de um tetraedro de aresta a é obtida pela fórmula √2 / 12 * a3.

Estenda a classe PlatonicSolid para implementar uma classe chamada Hexahedron para representar um hexaedro, ou seja, um poliedro regular de seis faces, considerado um dos cinco Sólidos Platônicos. Um hexaedro possui seis faces, doze arestas e oito vértices. A área de um hexaedro de aresta a é obtida pela fórmula 6 * a2. O volume de um hexaedro de aresta a é obtida pela fórmula a3.

Estenda a classe PlatonicSolid para implementar uma classe chamada Octahedron para representar um octaedro, ou seja, um poliedro regular de oito faces, considerado um dos cinco Sólidos Platônicos. Um octaedro possui oito faces, doze arestas e seis vértices. A área de um octaedro de aresta a é obtida pela fórmula 2 * √3 * a2. O volume de um octaedro de aresta a é obtida pela fórmula √2 / 3 * a3.

Estenda a classe PlatonicSolid para implementar uma classe chamada Dodecahedron para representar um dodecaedro, ou seja, um poliedro regular de doze faces, considerado um dos cinco Sólidos Platônicos. Um dodecaedro possui doze faces, trinta arestas e vinte vértices. A área de um dodecaedro de aresta a é obtida pela fórmula 3 * √(25 + 10 * √5) * a2. O volume de um dodecaedro de aresta a é obtida pela fórmula 1 / 4 * (15 + 7 * √5) * a3.

Estenda a classe PlatonicSolid para implementar uma classe chamada Icosahedron para representar um icosaedro, ou seja, um poliedro regular de vinte faces, considerado um dos cinco Sólidos Platônicos. Um icosaedro possui vinte faces, trinta arestas e doze vértices. A área de um icosaedro de aresta a é obtida pela fórmula 5 * √3 * a2. O volume de um icosaedro de aresta a é obtida pela fórmula 5 / 12 * (3 + √5) * a3.

 

Diagrama de Classes - Linguagem de Programação Java
Diagrama de Classes - Linguagem de Programação Java

Arquivo PlatonicSolid.java

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

package com.ybadoo.tutoriais.poo;

/**
 * Classe responsavel pela representacao de um solido platonico
 */
public class PlatonicSolid
{
  /**
   * Quantidade de arestas do solido platonico
   */
  private int edges;

  /**
   * Quantidade de faces do solido platonico
   */
  private int faces;

  /**
   * Comprimento da aresta do solido platonico
   */
  private double length;

  /**
   * Quantidade de vertices do solido platonico
   */
  private int vertices;

  /**
   * Construtor padrao
   */
  public PlatonicSolid()
  {
    this(1.0);
  }

  /**
   * Construtor para inicializar o comprimento da aresta do solido platonico
   *
   * @param length comprimento da aresta do solido platonico
   */
  public PlatonicSolid(double length)
  {
    setLength(length);
  }

  /**
   * Configurar as constantes do solido platonico
   *
   * @param edges quantidade de arestas do solido platonico
   * @param faces quantidade de faces do solido platonico
   * @param vertices quantidade de vertices do solido platonico
   */
  protected void config(int edges, int faces, int vertices)
  {
    this.edges = edges;

    this.faces = faces;

    this.vertices = vertices;
  }

  /**
   * Retornar a quantidade de arestas do solido platonico
   *
   * @return quantidade de arestas do solido platonico
   */
  public int getEdges()
  {
    return edges;
  }

  /**
   * Retornar a quantidade de faces do solido platonico
   *
   * @return quantidade de faces do solido platonico
   */
  public int getFaces()
  {
    return faces;
  }

  /**
   * Retornar o comprimento da aresta do solido platonico
   *
   * @return comprimento da aresta do solido platonico
   */
  public double getLength()
  {
    return length;
  }

  /**
   * Configurar o comprimento da aresta do solido platonico
   *
   * @param length comprimento da aresta do solido platonico
   */
  public void setLength(double length)
  {
    if((length >= 0.0) && (length <= 30.0))
    {
      this.length = length;
    }
    else
    {
      if(length > 30.0)
      {
        this.length = 30.0;
      }
      else
      {
        this.length = 0.0;
      }
    }
  }

  /**
   * Retornar a quantidade de vertices do solido platonico
   *
   * @return quantidade de vertices do solido platonico
   */
  public int getVertices()
  {
    return vertices;
  }

  /**
   * Retornar a area do solido platonico
   *
   * @return area do solido platonico
   */
  protected double area()
  {
    return Math.pow(getLength(), 2.0);
  }

  /**
   * Retornar o volume do solido platonico
   *
   * @return volume do solido platonico
   */
  protected double volume()
  {
    return Math.pow(getLength(), 3.0);
  }
}

Arquivo Tetrahedron.java

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

package com.ybadoo.tutoriais.poo;

/**
 * Classe responsavel pela representacao de um tetraedro
 */
public class Tetrahedron extends PlatonicSolid
{
  /**
   * Construtor padrao
   */
  public Tetrahedron()
  {
    this(1.0);
  }

  /**
   * Construtor para inicializar o comprimento da aresta do tetraedro
   *
   * @param length comprimento da aresta do tetraedro
   */
  public Tetrahedron(double length)
  {
    super(length);

    config(6, 4, 4);
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.PlatonicSolid#area()
   */
  public double area()
  {
    return Math.sqrt(3.0) * super.area();
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.PlatonicSolid#volume()
   */
  public double volume()
  {
    return Math.sqrt(2.0) / 12.0 * super.volume();
  }
}

Arquivo Hexahedron.java

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

package com.ybadoo.tutoriais.poo;

/**
 * Classe responsavel pela representacao de um hexaedro
 */
public class Hexahedron extends PlatonicSolid
{
  /**
   * Construtor padrao
   */
  public Hexahedron()
  {
    this(1.0);
  }

  /**
   * Construtor para inicializar o comprimento da aresta do hexaedro
   *
   * @param length comprimento da aresta do hexaedro
   */
  public Hexahedron(double length)
  {
    super(length);

    config(12, 6, 8);
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.PlatonicSolid#area()
   */
  public double area()
  {
    return 6.0 * super.area();
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.PlatonicSolid#volume()
   */
  public double volume()
  {
    return super.volume();
  }
}

Arquivo Octahedron.java

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

package com.ybadoo.tutoriais.poo;

/**
 * Classe responsavel pela representacao de um octaedro
 */
public class Octahedron extends PlatonicSolid
{
  /**
   * Construtor padrao
   */
  public Octahedron()
  {
    this(1.0);
  }

  /**
   * Construtor para inicializar o comprimento da aresta do octaedro
   *
   * @param length comprimento da aresta do octaedro
   */
  public Octahedron(double length)
  {
    super(length);

    config(12, 8, 6);
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.PlatonicSolid#area()
   */
  public double area()
  {
    return 2.0 * Math.sqrt(3.0) * super.area();
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.PlatonicSolid#volume()
   */
  public double volume()
  {
    return Math.sqrt(2.0) / 3.0 * super.volume();
  }
}

Arquivo Dodecahedron.java

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

package com.ybadoo.tutoriais.poo;

/**
 * Classe responsavel pela representacao de um dodecaedro
 */
public class Dodecahedron extends PlatonicSolid
{
  /**
   * Construtor padrao
   */
  public Dodecahedron()
  {
    this(1.0);
  }

  /**
   * Construtor para inicializar o comprimento da aresta do dodecaedro
   *
   * @param length comprimento da aresta do dodecaedro
   */
  public Dodecahedron(double length)
  {
    super(length);

    config(30, 12, 20);
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.PlatonicSolid#area()
   */
  public double area()
  {
    return 3.0 * Math.sqrt(25.0 + 10.0 * Math.sqrt(5.0))
      * super.area();
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.PlatonicSolid#volume()
   */
  public double volume()
  {
    return 1.0 / 4.0 * (15.0 + 7.0 * Math.sqrt(5.0))
      * super.volume();
  }
}

Arquivo Icosahedron.java

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

package com.ybadoo.tutoriais.poo;

/**
 * Classe responsavel pela representacao de um icosaedro
 */
public class Icosahedron extends PlatonicSolid
{
  /**
   * Construtor padrao
   */
  public Icosahedron()
  {
    this(1.0);
  }

  /**
   * Construtor para inicializar o comprimento da aresta do icosaedro
   *
   * @param length comprimento da aresta do icosaedro
   */
  public Icosahedron(double length)
  {
    super(length);

    config(30, 20, 12);
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.PlatonicSolid#area()
   */
  public double area()
  {
    return 5.0 * Math.sqrt(3.0) * super.area();
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.PlatonicSolid#volume()
   */
  public double volume()
  {
    return 5.0 / 12.0 * (3.0 + Math.sqrt(5.0)) * super.volume();
  }
}

Arquivo Application.java

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

package com.ybadoo.tutoriais.poo;

/**
 * Classe responsavel pela execucao da hierarquia de classes PlatonicSolid
 */
public class Application
{
  /**
   * Metodo principal da linguagem de programacao Java
   *
   * @param args argumentos da linha de comando (nao utilizado)
   */
  public static void main(String[] args)
  {
    Tetrahedron tetrahedron = new Tetrahedron(5.0);

    System.out.println("A quantidade de faces do tetraedro eh: "
      + tetrahedron.getFaces());

    System.out.println("A quantidade de arestas do tetraedro eh: "
      + tetrahedron.getEdges());

    System.out.println("A quantidade de vertices do tetraedro eh: "
      + tetrahedron.getVertices());

    System.out.println("O comprimento da aresta do tetraedro eh: "
      + tetrahedron.getLength());

    System.out.println("A area do tetraedro eh: "
      + tetrahedron.area());

    System.out.println("O volume do tetraedro eh: "
      + tetrahedron.volume());


    Hexahedron hexahedron = new Hexahedron(5.0);

    System.out.println("\nA quantidade de faces do hexaedro eh: "
      + hexahedron.getFaces());

    System.out.println("A quantidade de arestas do hexaedro eh: "
      + hexahedron.getEdges());

    System.out.println("A quantidade de vertices do hexaedro eh: "
      + hexahedron.getVertices());

    System.out.println("O comprimento da aresta do hexaedro eh: "
      + hexahedron.getLength());

    System.out.println("A area do hexaedro eh: "
      + hexahedron.area());

    System.out.println("O volume do hexaedro eh: "
      + hexahedron.volume());


    Octahedron octahedron = new Octahedron(5.0);

    System.out.println("\nA quantidade de faces do octaedro eh: "
      + octahedron.getFaces());

    System.out.println("A quantidade de arestas do octaedro eh: "
      + octahedron.getEdges());

    System.out.println("A quantidade de vertices do octaedro eh: "
      + octahedron.getVertices());

    System.out.println("O comprimento da aresta do octaedro eh: "
      + octahedron.getLength());

    System.out.println("A area do octaedro eh: "
      + octahedron.area());

    System.out.println("O volume do octaedro eh: "
      + octahedron.volume());


    Dodecahedron dodecahedron = new Dodecahedron(5.0);

    System.out.println("\nA quantidade de faces do dodecaedro eh: "
      + dodecahedron.getFaces());

    System.out.println("A quantidade de arestas do dodecaedro eh: "
      + dodecahedron.getEdges());

    System.out.println("A quantidade de vertices do dodecaedro eh: "
      + dodecahedron.getVertices());

    System.out.println("O comprimento da aresta do dodecaedro eh: "
      + dodecahedron.getLength());

    System.out.println("A area do dodecaedro eh: "
      + dodecahedron.area());

    System.out.println("O volume do dodecaedro eh: "
      + dodecahedron.volume());


    Icosahedron icosahedron = new Icosahedron(5.0);

    System.out.println("\nA quantidade de faces do icosaedro eh: "
      + icosahedron.getFaces());

    System.out.println("A quantidade de arestas do icosaedro eh: "
      + icosahedron.getEdges());

    System.out.println("A quantidade de vertices do icosaedro eh: "
      + icosahedron.getVertices());

    System.out.println("O comprimento da aresta do icosaedro eh: "
      + icosahedron.getLength());

    System.out.println("A area do icosaedro eh: "
      + icosahedron.area());

    System.out.println("O volume do icosaedro eh: "
      + icosahedron.volume());
  }
}

Saída

A quantidade de faces do tetraedro eh: 4
A quantidade de arestas do tetraedro eh: 6
A quantidade de vertices do tetraedro eh: 4
O comprimento da aresta do tetraedro eh: 5.0
A area do tetraedro eh: 43.30127018922193
O volume do tetraedro eh: 14.731391274719742

A quantidade de faces do hexaedro eh: 6
A quantidade de arestas do hexaedro eh: 12
A quantidade de vertices do hexaedro eh: 8
O comprimento da aresta do hexaedro eh: 5.0
A area do hexaedro eh: 150.0
O volume do hexaedro eh: 125.0

A quantidade de faces do octaedro eh: 8
A quantidade de arestas do octaedro eh: 12
A quantidade de vertices do octaedro eh: 6
O comprimento da aresta do octaedro eh: 5.0
A area do octaedro eh: 86.60254037844386
O volume do octaedro eh: 58.92556509887897

A quantidade de faces do dodecaedro eh: 12
A quantidade de arestas do dodecaedro eh: 30
A quantidade de vertices do dodecaedro eh: 20
O comprimento da aresta do dodecaedro eh: 5.0
A area do dodecaedro eh: 516.1432201766901
O volume do dodecaedro eh: 957.8898700780791

A quantidade de faces do icosaedro eh: 20
A quantidade de arestas do icosaedro eh: 30
A quantidade de vertices do icosaedro eh: 12
O comprimento da aresta do icosaedro eh: 5.0
A area do icosaedro eh: 216.50635094610965
O volume do icosaedro eh: 272.71187382811405
Diagrama de Classes - Linguagem de Programação C++
Diagrama de Classes - Linguagem de Programação C++

Arquivo PlatonicSolid.h

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#ifndef PLATONICSOLID_H
#define PLATONICSOLID_H

/**
 * Classe responsavel pela representacao de um solido platonico
 */
class PlatonicSolid
{
  private:

  /**
   * Quantidade de arestas do solido platonico
   */
  int edges;

  /**
   * Quantidade de faces do solido platonico
   */
  int faces;

  /**
   * Comprimento da aresta do solido platonico
   */
  double length;

  /**
   * Quantidade de vertices do solido platonico
   */
  int vertices;

  protected:

  /**
   * Configurar as constantes do solido platonico
   *
   * @param edges quantidade de arestas do solido platonico
   * @param faces quantidade de faces do solido platonico
   * @param vertices quantidade de vertices do solido platonico
   */
  void config(int edges, int faces, int vertices);

  /**
   * Retornar a area do solido platonico
   *
   * @return area do solido platonico
   */
  double area();

  /**
   * Retornar o volume do solido platonico
   *
   * @return volume do solido platonico
   */
  double volume();

  public:

  /**
   * Construtor padrao
   */
  PlatonicSolid();

  /**
   * Construtor para inicializar o comprimento da aresta do solido platonico
   *
   * @param length comprimento da aresta do solido platonico
   */
  PlatonicSolid(double length);

  /**
   * Retornar a quantidade de arestas do solido platonico
   *
   * @return quantidade de arestas do solido platonico
   */
  int getEdges();

  /**
   * Retornar a quantidade de faces do solido platonico
   *
   * @return quantidade de faces do solido platonico
   */
  int getFaces();

  /**
   * Retornar o comprimento da aresta do solido platonico
   *
   * @return comprimento da aresta do solido platonico
   */
  double getLength();

  /**
   * Configurar o comprimento da aresta do solido platonico
   *
   * @param length comprimento da aresta do solido platonico
   */
  void setLength(double length);

  /**
   * Retornar a quantidade de vertices do solido platonico
   *
   * @return quantidade de vertices do solido platonico
   */
  int getVertices();
};

#endif

Arquivo PlatonicSolid.cpp

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include <cmath>
#include "PlatonicSolid.h"

/**
 * Construtor padrao
 */
PlatonicSolid::PlatonicSolid()
{
  setLength(1.0);
}

/**
 * Construtor para inicializar o comprimento da aresta do solido platonico
 *
 * @param length comprimento da aresta do solido platonico
 */
PlatonicSolid::PlatonicSolid(double length)
{
  setLength(length);
}

/**
 * Configurar as constantes do solido platonico
 *
 * @param edges quantidade de arestas do solido platonico
 * @param faces quantidade de faces do solido platonico
 * @param vertices quantidade de vertices do solido platonico
 */
void PlatonicSolid::config(int edges, int faces, int vertices)
{
  PlatonicSolid::edges = edges;

  PlatonicSolid::faces = faces;

  PlatonicSolid::vertices = vertices;
}

/**
 * Retornar a quantidade de arestas do solido platonico
 *
 * @return quantidade de arestas do solido platonico
 */
int PlatonicSolid::getEdges()
{
  return edges;
}

/**
 * Retornar a quantidade de faces do solido platonico
 *
 * @return quantidade de faces do solido platonico
 */
int PlatonicSolid::getFaces()
{
  return faces;
}

/**
 * Retornar o comprimento da aresta do solido platonico
 *
 * @return comprimento da aresta do solido platonico
 */
double PlatonicSolid::getLength()
{
  return length;
}

/**
 * Configurar o comprimento da aresta do solido platonico
 *
 * @param length comprimento da aresta do solido platonico
 */
void PlatonicSolid::setLength(double length)
{
  if((length >= 0.0) && (length <= 30.0))
  {
    PlatonicSolid::length = length;
  }
  else
  {
    if(length > 30.0)
    {
      PlatonicSolid::length = 30.0;
    }
    else
    {
      PlatonicSolid::length = 0.0;
    }
  }
}

/**
 * Retornar a quantidade de vertices do solido platonico
 *
 * @return quantidade de vertices do solido platonico
 */
int PlatonicSolid::getVertices()
{
  return vertices;
}

/**
 * Retornar a area do solido platonico
 *
 * @return area do solido platonico
 */
double PlatonicSolid::area()
{
  return pow(getLength(), 2.0);
}

/**
 * Retornar o volume do solido platonico
 *
 * @return volume do solido platonico
 */
double PlatonicSolid::volume()
{
  return pow(getLength(), 3.0);
}

Arquivo Tetrahedron.h

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include "PlatonicSolid.h"

#ifndef TETRAHEDRON_H
#define TETRAHEDRON_H

/**
 * Classe responsavel pela representacao de um tetraedro
 */
class Tetrahedron : public PlatonicSolid
{
  private:

  /**
   * Inicializar o tetraedro
   *
   * @param length comprimento da aresta do tetraedro
   */
  void init(double length);

  public:

  /**
   * Construtor padrao
   */
  Tetrahedron();

  /**
   * Construtor para inicializar o comprimento da aresta do tetraedro
   *
   * @param length comprimento da aresta do tetraedro
   */
  Tetrahedron(double length);

  /**
   * Retornar a area do tetraedro
   *
   * @return area do tetraedro
   */
  double area();

  /**
   * Retornar o volume do tetraedro
   *
   * @return volume do tetraedro
   */
  double volume();
};

#endif

Arquivo Tetrahedron.cpp

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include <cmath>
#include "Tetrahedron.h"

/**
 * Construtor padrao
 */
Tetrahedron::Tetrahedron()
{
  init(1.0);
}

/**
 * Construtor para inicializar o comprimento da aresta do tetraedro
 *
 * @param length comprimento da aresta do tetraedro
 */
Tetrahedron::Tetrahedron(double length)
{
  init(length);
}

/**
 * Inicializar o tetraedro
 *
 * @param length comprimento da aresta do tetraedro
 */
void Tetrahedron::init(double length)
{
  setLength(length);

  config(6, 4, 4);
}

/**
 * Retornar a area do tetraedro
 *
 * @return area do tetraedro
 */
double Tetrahedron::area()
{
  return sqrt(3.0) * PlatonicSolid::area();
}

/**
 * Retornar o volume do tetraedro
 *
 * @return volume do tetraedro
 */
double Tetrahedron::volume()
{
  return sqrt(2.0) / 12.0 * PlatonicSolid::volume();
}

Arquivo Hexahedron.h

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include "PlatonicSolid.h"

#ifndef HEXAHEDRON_H
#define HEXAHEDRON_H

/**
 * Classe responsavel pela representacao de um hexaedro
 */
class Hexahedron : public PlatonicSolid
{
  private:

  /**
   * Inicializar o hexaedro
   *
   * @param length comprimento da aresta do hexaedro
   */
  void init(double length);

  public:

  /**
   * Construtor padrao
   */
  Hexahedron();

  /**
   * Construtor para inicializar o comprimento da aresta do hexaedro
   *
   * @param length comprimento da aresta do hexaedro
   */
  Hexahedron(double length);

  /**
   * Retornar a area do hexaedro
   *
   * @return area do hexaedro
   */
  double area();

  /**
   * Retornar o volume do hexaedro
   *
   * @return volume do hexaedro
   */
  double volume();
};

#endif

Arquivo Hexahedron.cpp

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include "Hexahedron.h"

/**
 * Construtor padrao
 */
Hexahedron::Hexahedron()
{
  init(1.0);
}

/**
 * Construtor para inicializar o comprimento da aresta do hexaedro
 *
 * @param length comprimento da aresta do hexaedro
 */
Hexahedron::Hexahedron(double length)
{
  init(length);
}

/**
 * Inicializar o hexaedro
 *
 * @param length comprimento da aresta do hexaedro
 */
void Hexahedron::init(double length)
{
  setLength(length);

  config(12, 6, 8);
}

/**
 * Retornar a area do hexaedro
 *
 * @return area do hexaedro
 */
double Hexahedron::area()
{
  return 6.0 * PlatonicSolid::area();
}

/**
 * Retornar o volume do hexaedro
 *
 * @return volume do hexaedro
 */
double Hexahedron::volume()
{
  return PlatonicSolid::volume();
}

Arquivo Octahedron.h

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include "PlatonicSolid.h"

#ifndef OCTAHEDRON_H
#define OCTAHEDRON_H

/**
 * Classe responsavel pela representacao de um octaedro
 */
class Octahedron : public PlatonicSolid
{
  private:

  /**
   * Inicializar o octaedro
   *
   * @param length comprimento da aresta do octaedro
   */
  void init(double length);

  public:

  /**
   * Construtor padrao
   */
  Octahedron();

  /**
   * Construtor para inicializar o comprimento da aresta do octaedro
   *
   * @param length comprimento da aresta do octaedro
   */
  Octahedron(double length);

  /**
   * Retornar a area do octaedro
   *
   * @return area do octaedro
   */
  double area();

  /**
   * Retornar o volume do octaedro
   *
   * @return volume do octaedro
   */
  double volume();
};

#endif

Arquivo Octahedron.cpp

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include <cmath>
#include "Octahedron.h"

/**
 * Construtor padrao
 */
Octahedron::Octahedron()
{
  init(1.0);
}

/**
 * Construtor para inicializar o comprimento da aresta do octaedro
 *
 * @param length comprimento da aresta do octaedro
 */
Octahedron::Octahedron(double length)
{
  init(length);
}

/**
 * Inicializar o octaedro
 *
 * @param length comprimento da aresta do octaedro
 */
void Octahedron::init(double length)
{
  setLength(length);

  config(12, 8, 6);
}

/**
 * Retornar a area do octaedro
 *
 * @return area do octaedro
 */
double Octahedron::area()
{
  return 2.0 * sqrt(3.0) * PlatonicSolid::area();
}

/**
 * Retornar o volume do octaedro
 *
 * @return volume do octaedro
 */
double Octahedron::volume()
{
  return sqrt(2.0) / 3.0 * PlatonicSolid::volume();
}

Arquivo Dodecahedron.h

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include "PlatonicSolid.h"

#ifndef DODECAHEDRON_H
#define DODECAHEDRON_H

/**
 * Classe responsavel pela representacao de um dodecaedro
 */
class Dodecahedron : public PlatonicSolid
{
  private:

  /**
   * Inicializar o dodecaedro
   *
   * @param length comprimento da aresta do dodecaedro
   */
  void init(double length);

  public:

  /**
   * Construtor padrao
   */
  Dodecahedron();

  /**
   * Construtor para inicializar o comprimento da aresta do dodecaedro
   *
   * @param length comprimento da aresta do dodecaedro
   */
  Dodecahedron(double length);

  /**
   * Retornar a area do dodecaedro
   *
   * @return area do dodecaedro
   */
  double area();

  /**
   * Retornar o volume do dodecaedro
   *
   * @return volume do dodecaedro
   */
  double volume();
};

#endif

Arquivo Dodecahedron.cpp

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include <cmath>
#include "Dodecahedron.h"

/**
 * Construtor padrao
 */
Dodecahedron::Dodecahedron()
{
  init(1.0);
}

/**
 * Construtor para inicializar o comprimento da aresta do dodecaedro
 *
 * @param length comprimento da aresta do dodecaedro
 */
Dodecahedron::Dodecahedron(double length)
{
  init(length);
}

/**
 * Inicializar o dodecaedro
 *
 * @param length comprimento da aresta do dodecaedro
 */
void Dodecahedron::init(double length)
{
  setLength(length);

  config(30, 12, 20);
}

/**
 * Retornar a area do dodecaedro
 *
 * @return area do dodecaedro
 */
double Dodecahedron::area()
{
  return 3.0 * sqrt(25.0 + 10.0 * sqrt(5.0)) * PlatonicSolid::area();
}

/**
 * Retornar o volume do dodecaedro
 *
 * @return volume do dodecaedro
 */
double Dodecahedron::volume()
{
  return 1.0 / 4.0 * (15.0 + 7.0 * sqrt(5.0)) * PlatonicSolid::volume();
}

Arquivo Icosahedron.h

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include "PlatonicSolid.h"

#ifndef ICOSAHEDRON_H
#define ICOSAHEDRON_H

/**
 * Classe responsavel pela representacao de um icosaedro
 */
class Icosahedron : public PlatonicSolid
{
  private:

  /**
   * Inicializar o icosaedro
   *
   * @param length comprimento da aresta do icosaedro
   */
  void init(double length);

  public:

  /**
   * Construtor padrao
   */
  Icosahedron();

  /**
   * Construtor para inicializar o comprimento da aresta do icosaedro
   *
   * @param length comprimento da aresta do icosaedro
   */
  Icosahedron(double length);

  /**
   * Retornar a area do icosaedro
   *
   * @return area do icosaedro
   */
  double area();

  /**
   * Retornar o volume do icosaedro
   *
   * @return volume do icosaedro
   */
  double volume();
};

#endif

Arquivo Icosahedron.cpp

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include <cmath>
#include "Icosahedron.h"

/**
 * Construtor padrao
 */
Icosahedron::Icosahedron()
{
  init(1.0);
}

/**
 * Construtor para inicializar o comprimento da aresta do icosaedro
 *
 * @param length comprimento da aresta do icosaedro
 */
Icosahedron::Icosahedron(double length)
{
  init(length);
}

/**
 * Inicializar o icosaedro
 *
 * @param length comprimento da aresta do icosaedro
 */
void Icosahedron::init(double length)
{
  setLength(length);

  config(30, 20, 12);
}

/**
 * Retornar a area do icosaedro
 *
 * @return area do icosaedro
 */
double Icosahedron::area()
{
  return 5.0 * sqrt(3.0) * PlatonicSolid::area();
}

/**
 * Retornar o volume do icosaedro
 *
 * @return volume do icosaedro
 */
double Icosahedron::volume()
{
  return 5.0 / 12.0 * (3.0 + sqrt(5.0)) * PlatonicSolid::volume();
}

Arquivo Application.cpp

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include <iostream>
#include "Tetrahedron.h"
#include "Hexahedron.h"
#include "Octahedron.h"
#include "Dodecahedron.h"
#include "Icosahedron.h"

using namespace std;

/**
 * Metodo principal da linguagem de programacao C++
 *
 * @param argc quantidade de argumentos na linha de comando (nao utilizado)
 * @param argv argumentos da linha de comando (nao utilizado)
 */
int main(int argc, char** argv)
{
  Tetrahedron* tetrahedron = new Tetrahedron(5.0);

  cout << "A quantidade de faces do tetraedro eh: "
       << tetrahedron->getFaces() << endl;

  cout << "A quantidade de arestas do tetraedro eh: "
       << tetrahedron->getEdges() << endl;

  cout << "A quantidade de vertices do tetraedro eh: "
       << tetrahedron->getVertices() << endl;

  cout << "O comprimento da aresta do tetraedro eh: "
       << tetrahedron->getLength() << endl;

  cout << "A area do tetraedro eh: "
       << tetrahedron->area() << endl;

  cout << "O volume do tetraedro eh: "
       << tetrahedron->volume() << endl;

  delete tetrahedron;


  Hexahedron* hexahedron = new Hexahedron(5.0);

  cout << endl;

  cout << "A quantidade de faces do hexaedro eh: "
       << hexahedron->getFaces() << endl;

  cout << "A quantidade de arestas do hexaedro eh: "
       << hexahedron->getEdges() << endl;

  cout << "A quantidade de vertices do hexaedro eh: "
       << hexahedron->getVertices() << endl;

  cout << "O comprimento da aresta do hexaedro eh: "
       << hexahedron->getLength() << endl;

  cout << "A area do hexaedro eh: "
       << hexahedron->area() << endl;

  cout << "O volume do hexaedro eh: "
       << hexahedron->volume() << endl;

  delete hexahedron;


  Octahedron* octahedron = new Octahedron(5.0);

  cout << endl;

  cout << "A quantidade de faces do octaedro eh: "
       << octahedron->getFaces() << endl;

  cout << "A quantidade de arestas do octaedro eh: "
       << octahedron->getEdges() << endl;

  cout << "A quantidade de vertices do octaedro eh: "
       << octahedron->getVertices() << endl;

  cout << "O comprimento da aresta do octaedro eh: "
       << octahedron->getLength() << endl;

  cout << "A area do octaedro eh: "
       << octahedron->area() << endl;

  cout << "O volume do octaedro eh: "
       << octahedron->volume() << endl;

  delete octahedron;


  Dodecahedron* dodecahedron = new Dodecahedron(5.0);

  cout << endl;

  cout << "A quantidade de faces do dodecaedro eh: "
       << dodecahedron->getFaces() << endl;

  cout << "A quantidade de arestas do dodecaedro eh: "
       << dodecahedron->getEdges() << endl;

  cout << "A quantidade de vertices do dodecaedro eh: "
       << dodecahedron->getVertices() << endl;

  cout << "O comprimento da aresta do dodecaedro eh: "
       << dodecahedron->getLength() << endl;

  cout << "A area do dodecaedro eh: "
       << dodecahedron->area() << endl;

  cout << "O volume do dodecaedro eh: "
       << dodecahedron->volume() << endl;

  delete dodecahedron;


  Icosahedron* icosahedron = new Icosahedron(5.0);

  cout << endl;

  cout << "A quantidade de faces do icosaedro eh: "
       << icosahedron->getFaces() << endl;

  cout << "A quantidade de arestas do icosaedro eh: "
       << icosahedron->getEdges() << endl;

  cout << "A quantidade de vertices do icosaedro eh: "
       << icosahedron->getVertices() << endl;

  cout << "O comprimento da aresta do icosaedro eh: "
       << icosahedron->getLength() << endl;

  cout << "A area do icosaedro eh: "
       << icosahedron->area() << endl;

  cout << "O volume do icosaedro eh: "
       << icosahedron->volume() << endl;

  delete icosahedron;

  return 0;
}

Saída

A quantidade de faces do tetraedro eh: 4
A quantidade de arestas do tetraedro eh: 6
A quantidade de vertices do tetraedro eh: 4
O comprimento da aresta do tetraedro eh: 5
A area do tetraedro eh: 43.3013
O volume do tetraedro eh: 14.7314

A quantidade de faces do hexaedro eh: 6
A quantidade de arestas do hexaedro eh: 12
A quantidade de vertices do hexaedro eh: 8
O comprimento da aresta do hexaedro eh: 5
A area do hexaedro eh: 150
O volume do hexaedro eh: 125

A quantidade de faces do octaedro eh: 8
A quantidade de arestas do octaedro eh: 12
A quantidade de vertices do octaedro eh: 6
O comprimento da aresta do octaedro eh: 5
A area do octaedro eh: 86.6025
O volume do octaedro eh: 58.9256

A quantidade de faces do dodecaedro eh: 12
A quantidade de arestas do dodecaedro eh: 30
A quantidade de vertices do dodecaedro eh: 20
O comprimento da aresta do dodecaedro eh: 5
A area do dodecaedro eh: 516.143
O volume do dodecaedro eh: 957.89

A quantidade de faces do icosaedro eh: 20
A quantidade de arestas do icosaedro eh: 30
A quantidade de vertices do icosaedro eh: 12
O comprimento da aresta do icosaedro eh: 5
A area do icosaedro eh: 216.506
O volume do icosaedro eh: 272.712