Tutoriais - Programação Orientada a Objetos
Tutoriais
Programação Orientada a Objetos

/**
 * Copyright (C) 2009/2024 - 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);
  }
}

/**
 * Copyright (C) 2009/2024 - 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();
  }
}

/**
 * Copyright (C) 2009/2024 - 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();
  }
}

/**
 * Copyright (C) 2009/2024 - 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();
  }
}

/**
 * Copyright (C) 2009/2024 - 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();
  }
}

/**
 * Copyright (C) 2009/2024 - 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();
  }
}

/**
 * Copyright (C) 2009/2024 - 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());
  }
}

/**
 * Copyright (C) 2009/2024 - 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

/**
 * Copyright (C) 2009/2024 - 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);
}

/**
 * Copyright (C) 2009/2024 - 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

/**
 * Copyright (C) 2009/2024 - 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();
}

/**
 * Copyright (C) 2009/2024 - 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

/**
 * Copyright (C) 2009/2024 - 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();
}

/**
 * Copyright (C) 2009/2024 - 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

/**
 * Copyright (C) 2009/2024 - 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();
}

/**
 * Copyright (C) 2009/2024 - 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

/**
 * Copyright (C) 2009/2024 - 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();
}

/**
 * Copyright (C) 2009/2024 - 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

/**
 * Copyright (C) 2009/2024 - 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();
}

/**
 * Copyright (C) 2009/2024 - 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;
}