Usuario:ManuelRomero/ProgramacionWeb/php/POO/practica

De WikiEducator
Saltar a: navegación, buscar



Calculadora Real/Racional

  • Se pide que realicemos una aplicación web que resuelva cálculos aritméticos con operadores reales o racionales
  • La operación se insertará en una caja de texto
  • La operación tendrá el siguiente formato
OP1 operador OP2
  • Donde
  1. OP1 es un operador real o racional
  2. operador es una operación que puede ser +,-,*,/,:.
    1. según los operandos sean reales o racionales el operador división será / o : respectivamente
  • El tipo de operación, la deberemos obtener según nos indique un método stático de la clase operación según se indica más abajo.
  • En la pantalla mostraremos un pequeño texto explicativo y una caja de texto donde el usuario podrá interactuar

PracticaCalculadoraIndex.png


  • Vamos a aplicar una pequeña css para la pantalla

Plantilla:MRM Ejemplos

  • Al presionar intro aparecerá un texto (en el primer caso 9/8+4/7)

PracticaCalculadoraUso1.png

  • En el segundo caso ( 9.4 / 2)

PracticaCalculadoraUso2.png

  • En el tercer caso ( 9/6:6)

PracticaCalculadoraUso3.png

  • En el cuarto caso es erróneo ( 9/5*5.6 )

PracticaCalculadoraUso4.png


  • Para realizar este ejercicio, tendremos que implementar las siguientes clases según aparece en el dibujo
  • Es obligatorio usar esta jerarquía de clase.

Racional.png

  • Todos los atributos private o protected (no debe de haber atributos public)
  • Los métodos según correspondan serán private protected o public
  • A continuación una descripción de las clases.
Racional (p.e 10/6)
Propiedades
  1. Num (p.e 10)
  2. Den (p.e 6)
Métodos
  1. constructor. Hay que sobrecargarlo según se indica, aunque en este caso, solo usemos el constructor con cadena de caracteres
$a = new Racional();      //Crea el racional 1/1
$a=  new Racional (10);   //Crea el racional 10/1
$a = new Racional(10,6);  //Crea el racional 10/6 
$a = new Racional("10/6");//Crea el racional 10/6
$a = new Racional("10");//Crea el racional 10/6
No hace falta recoger otras situaciones no deseadas, no obstante si se hace se debería de crear el Racional 1/1
  1. simplifica() Simplifica si se puede numerador y denominador (Utilizar el método de Euclides (mcd))


  1. suma
  2. resta
  3. multiplica
  4. divide
  5. __toString
Todos estos métodos operan con un argumento racional y retorna un Racional resultado de operarse él mismo con el racional que pasamos como argumento
//En la clase
public function suma (Racional $b) {
 $numResultado = ....;
 $denResultado = ....
 $resultado = new Racional......
 return $resultado;
}
.....
//En el programa que use la clase
 
$a = new Racional("5/6");
$b = new Racional (6,4);
$c= $a->sumar($b);
echo "$a+$b=$c"//Me visualizará 5/6+6/4=56/24, o bien simplificado 7/3
  • Por defecto todas las operaciones se deben de facilitar con el racional simplificado, salvo que se pase en la operación un segundo parámetro a valor false, en cuyo caso no se simplifica y se da el valor sin simplificar

{{Plegable|hide|Clase Racional|

<?php
 
class Racional {
 
    private $num;
    private $den;
 
    /**
     * 
     * @param type $num
     * @param type $den
     * @description Construimos un objeto de la clase recional en las siguientes situaciones
     *  //opciones new Racional () =>1/1
        //opciones new Racional (5) =>5/1
        //opciones new Racional (5,2) =>5/2
        //opciones new Racional ("5/2") =>5/2
        //opciones new Racional ("5") =>5/1
 
        //Otra sitiación no se instancia
 
     */
    public function __construct($num, $den) {
        if (is_null($den)) {
            switch (is_numeric($num)) {
                case true:
                    $this->num = $num;
                    $this->den = 1;
                    break;
                case false:
                    if (is_null($num)) {
                        $this->num = 1;
                        $this->den = 1;
                    } else {
                        $this->num = (int) $num;
                        //if (strpos($num, "/") == FALSE) {
                        $this->den = (int) substr($num, strpos($num, "/") + 1);
                        //} else
                        //    $this->den = 1;
                    }
                    break;
            }
        } else {
            $this->num = $num;
            $this->den = $den;
        }
    }
 
    /**
     * @param Racional $op1 segundo operando
     * @return \Racional Resultado de sumar al objeto racional actual, el objeto raciona que recibimos como parámetro
     */
    public function sumar(Racional $op1) {
        $num = $this->num * $op1->den + $this->den * $op1->num;
        $den = $this->den * $op1->den;
        return new Racional($num, $den);
    }
 
    /**
     * @param Racional $op1 segundo operando
     * @return \Racional Resultado de restar al objeto racional actual, el objeto raciona que recibimos como parámetro
     */
    public function restar(Racional $op1) {
        $num = $this->num * $op1->den - $this->den * $op1->num;
        $den = $this->den * $op1->den;
        return new Racional($num, $den);
    }
 
    /**
     * @param Racional $op1 segundo operando
     * @return \Racional Resultado de multiplicar al objeto racional actual, el objeto raciona que recibimos como parámetro
     */
    public function multiplicar(Racional $op1) {
        $num = $this->num * $op1->num;
        $den = $this->den * $op1->den;
        return new Racional($num, $den);
    }
    /**
     * @param Racional $op1 segundo operando
     * @return \Racional Resultado de dividir al objeto racional actual, el objeto raciona que recibimos como parámetro
     */
    public function dividir(Racional $op1) {
        $num = $this->num * $op1->den;
        $den = $this->den * $op1->num;
        return new Racional($num, $den);
    }
 
    /**
     * 
     * @return type un string del tipo a/b
     */
    public function __toString() {
        return ($this->num . "/" . $this->den);
    }
}
Operación
  • Como vemos en el diagrama va a tener algún método abstracto, por lo que la vamos a considerar abstracta
Propiedades
  • Operando1 es un atributo que podrá ser real o racional, pero como en php no hay que declarar tipos, nos va bien
  • Operando2 igual
  • Operación será la cadena de caracteres que el usuario inserte en la caja de texto.
  • Operador es el carácter que indica el tipo de operación que se quiere realizar.
  • Resultado es el resultado de la operación, puede ser real o racional
  • Esta clase descompondrá la operación y generará un resultado

{{Plegable|hide|Clase Operacion|

<?php
 
abstract class Operacion {
 
    //put your code here
    protected $op1;
    protected $op2;
    protected $operador;
    protected $operacion;
    static protected $tipo;
 
    const RACIONAL = 1;
    const REAL = 2;
    const ERROR = -1;
 
    /**
     * @param $operacion string que especifica la operación que se desar analizar
     * @description Establece de qué tipo es una operación en función de sus argumentos
     *      * Operacion real numero_real operando  numero_real
     *      * Operacion racional  numero_racional operandoRacional numero_racional
     *      * Operacion racional  numero_entero operandoRacional numero_racional
     *      * Operacion racional  numero_racional operandoRacional numero_entero
     *      * Otro caso se especificará un error
     * 
     *  Usamos expresiones regulares para especificarlo
     * **/
 
    public static function tipoOperacion($operacion) {
        self::$tipo = Operacion::ERROR;
 
        $numReal = '[0-9]+(\.[0-9]*)?';
        $numEntero = '[0-9]+';
        $op = '[\+|\-|\*|\/]';
        $numRacional = '[0-9]+\/[0-9]+';
        $opRacional = '[\+|\-|\*|\:]';
 
 
        $exp = "/^$numReal$op$numReal$/";
        if (preg_match($exp, $operacion)) {
            self::$tipo = Operacion::REAL;
        } else {
            /*Escribe el código que consideres*/ 
 
 
 
        }
        return self::$tipo;
 
    }
 
    public function __construct($operacion) {
        $this->operacion = $operacion;
        $this->operador = $this->obtenerOperador($operacion);
        $this->op1 = $this->obtenerOperador1($operacion);
        $this->op2 = $this->obtenerOperador2($operacion);
    }
 
    private function obtenerOperador1($operacion) {
 
 /*Escribe el código que consideres*/ 
    }
 
    private function obtenerOperador2($operacion) {
 /*Escribe el código que consideres*/ 
    }
 
    private function obtenerOperador($operacion) {
 /*Escribe el código que consideres*/ 
 
    }
 
 
    /**
     *  Métodos get and set 
     */
 
 
    public function getOp1() {
        return $this->op1;
    }
 
    public function getOp2() {
        return $this->op2;
    }
 
    public function getOperador() {
        return $this->operador;
    }
 
    public function getTipo() {
        return $this->tipo;
    }
 
    public function __toString() {
        return "$this->op1$this->operador$this->op2";
    }
 
    /**
     * 
     * @return string  que describe las  propiedades de una operacion
     * Lo devuelve como contenido de una tabla sin especificar la tabla
     */
    public function describe() {
        $operacion = "<tr><th>Operando 1 </th> <th> $this->op1</th></tr>";
        $operacion.="<tr><th>Operando 2 </th> <th> $this->op2</th></tr>";
        $operacion.="<tr><th>Operación </th> <th> $this->operador</th></tr>";
        if (self::$tipo == Operacion::RACIONAL)
            $tipo = "Racional";
        else
            $tipo = "Real";
        $operacion.="<tr><th>Tipo de operacion  </th> <th> $tipo</th></tr>";
        return $operacion;
    }
 
    /**
     * método abstracto que se implementará cuando se sepa si una operación es real o racional
     */
    abstract public function opera();
}
OpReal
OpRacional
  • A continuación el código del index.php que he usado yo