Mes: junio 2019

Arreglar la siguiente jerarquía de herencias para que incorpore constructores en las clases derivadas y funcione el área:

abstract class Figuras {
    abstract function area();  
}
abstract class Bidimensional extends Figuras{
    
}
class Circulo extends Bidimensional{
    private $radio;
}
class Triangulo extends Bidimensional{
  private $base;
  private $altura;
}
abstract class Tridimensional extends Figuras{
    
}
class Cubo extends Tridimensional{
   private $lado;
}
class Esfera extends Tridimensional{
   private $radio
}

class Estaticas {
   static public $iva;
   public $nombre;
}

$a=new Estaticas();
$b=new Estaticas();
$c=new Estaticas();
Estaticas::$iva=.21;
$a->nombre="Ana";
$b->nombre="Eva";
$c->nombre="Rosa";

var_dump($a::$iva);
var_dump($b::$iva);
var_dump($c::$iva);

class Producto{
    static private $iva=.21;
    public $nombre;
    public $precio;
    function __construct($nombre,$precio) {
        $this->nombre=$nombre;
        $this->precio=$precio;
    }
    function PVP(){
        return $this->precio*(1+$this::$iva);
    }
}
$manzana=new Producto("Manzana",2);
echo $manzana->PVP();
$uvas=new Producto("Uvas",3.5);
echo $uvas->PVP();

<?php

abstract class Figuras {
    abstract function dibujar();
    function saludo(){
        echo "Hola";
    }
}

abstract class Bidimensional extends Figuras{
    
}
class Circulo extends Bidimensional{
    function dibujar(){
        echo "Estoy dibujando un círculo";
    }
}
class Hexagono extends Bidimensional{
    function dibujar(){
        echo "Dibujando hexágono";
    }
}
abstract class Tridimensional extends Figuras{
    
}
class Cubo extends Tridimensional{
    function dibujar(){
        echo "Esto es un cubo";
    }
}
class Piramide extends Tridimensional{
    function dibujar(){
        echo "Porámide";
    }
}

$figuras=[new Circulo(),new Piramide(), new Cubo(),new Hexagono(),new Circulo()];

foreach ($figuras as $figura){
    $figura->dibujar();
}

Vamos a definir una clase ‘Producto’ con las propiedades nombre y precio, ambas obligatorias en el constructor.

Vamos a crear una función PVP que nos devuelve el precio mas el 21% de iva.

De ahí derivamos la clase Oferta que la función PVP es la misma que en el anterior pero aplicando un 10% de descuento.

Vamos a crear la clase Persona con las propiedades nombre (obligatoria) y DNI. Crearemos un método ‘saludo’ que nos devuelva un string con ‘Hola’+nombre

De ahí vamos a derivar la clase ‘caballero’ que tendrá la propiedad ‘tratamiento’ (obligatoria) . Sobre escribiremos el método ‘saludo’ para que devuelva ‘Hola’+tratamiento+nombre.
Añadiremos la propiedad renta de tipo int.

Vamos a derivar la clase ‘plebeyo’. Sobre escribiremos el método saludo para que devuelva ‘Hola’+nombre+’¿Qué pasa?’

Poned los getters y setters que hagan falta, pero que sea obligatorio poner un valor.

class Persona {
    private $nombre;
    private $dni;
    function __construct($nombre) {
        $this->nombre = $nombre;
    }
    function saludo() {
        return "Hola " . $this->nombre;
    }
    function __get($name) {
        return $this->$name;
    }
    function __set($name, $value) {
        if (empty($value)) {
            throw new Exception("La propiedad $name no puede estar vacía");
        }
        $this->$name = $value;
    }
}

class Caballero extends Persona{
    protected $tratamiento;
    protected $renta;
    function __construct($nombre,$tratamiento) {
        parent::__construct($nombre);
        $this->__set("tratamiento",$tratamiento);
    }
    function saludo(){
        return "Hola ".$this->tratamiento." ".$this->nombre;
    }
}

class Plebeyo extends Persona{
    function saludo(){
        return parent::saludo()." ¿Qué pasa?";
    }
}

<?php

/**
 * Description of Herencia
 *
 * @author incid
 */
class Empleado {

    private $nombre;

    function __construct($nombre) {
        $this->nombre = $nombre;
    }

    function __get($name) {
        return $this->$name;
    }

    function __set($name, $value) {

        if (empty($value)) {
            throw new Exception("No se puede poner valores vacíos");
        }
        $this->$name = $value;
    }

    function saludo() {
        echo "Hola";
    }

}

class Gerente extends Empleado {

    private $bonus;

    function __construct($nombre, $bonus) {
        parent::__construct($nombre);
        $this->__set("bonus", $bonus);
    }

    function saludo() {
        parent::saludo();
        echo "Los gerentes saludan así: Holi";
    }

    function despedida() {
        echo "Adios muy buenas";
    }

}

class Gerente2 extends Empleado {

    private $bonus;

    function __construct($nombre, $bonus) {
        parent::__construct($nombre);
        $this->setBonus($bonus);
    }

    function getBonus() {
        return $this->bonus;
    }

    function setBonus($bonus) {
        $this->bonus = $bonus;
    }

}

$juan = new Empleado("Juan Pérez");
$juan->nombre = "Pepito";
$juan->saludo();
//$juan->despedida(); //ERROR
var_dump($juan);
$eva = new Gerente("Eva Pi", 400);
$eva->saludo();
$eva->despedida();
//$eva->bonus=0;
var_dump($eva);

Vamos a crear la clase ‘Cliente’ con las siguientes propiedades privadas:

Nombre
NIF
Pais
Importe

Vamos a crear un constructor que pida obligatoriamente el Nombre y el NIF y vamos a crear getters y setters mágicos.

Los valores no pueden estar vacíos, el NIF tiene que empezar por una letra y tener una longitud de 9 caracteres y el importe no puede ser negativo.

Probad todas las características.

class Cliente {

    private $nombre;
    private $nif;
    private $pais;
    private $importe;

    function __construct($nombre, $nif) {
        $this->nombre = $nombre;
        $this->nif = $nif;
    }

    function __get($name) {
        if (!property_exists($this, $name)) {
            throw new Exception("La propiedad $name no existe");
        }
        return $this->$name;
    }

    function __set($name, $value) {
        if (!property_exists($this, $name)) {
            throw new Exception("La propiedad $name no existe");
        }
        if (empty($value)) {
            throw new Exception("La propiedad $name no puede estar vacía");
        }
        if($name=="importe" && $value<0){
             throw new Exception("El importe no puede ser negativo");
        }
        if($name=="nif" && $this->checkNif($value)) {
            throw new Exception("NIF incorrecto");
        }
        $this->$name = $value;
    }
    private function checkNif($nif){
        return (strlen($nif)!=9 || strtoupper(substr($nif, 0,1))<"A"
                || strtoupper(substr($nif, 0,1))>"Z");
    }

}

$pepe=new Cliente("Pepe", "B61235712");

$pepe->nif="B12345678";
$pepe->importe=500;

echo $pepe->nombre;

var_dump($pepe);

class Libro {

    private $titulo;
    private $autor;
    private $paginas;
    function getTitulo() {
        return $this->titulo;
    }

    function getAutor() {
        return $this->autor;
    }

    function getPaginas() {
        return $this->paginas;
    }

    function setTitulo($titulo) {
        $this->titulo = $titulo;
    }

    function setAutor($autor) {
        $this->autor = $autor;
    }

    function setPaginas($paginas) {
        $this->paginas = $paginas;
    }

        function __construct($titulo) {
        $this->__set("titulo",$titulo);
    }

    function __get($name) {
         $metodo="get$name";
        if (!method_exists($this, $metodo)) {
            throw new Exception("La propiedad $name no existe");
        }
        return $this->$metodo();
    }

    function __set($name, $value) {
        $metodo="set$name";
        if (!method_exists($this, $metodo)) {
            throw new Exception("La propiedad $name no existe");
        }
        if (empty($value)) {
            throw new Exception("El valor $name no puede estar vacío");
        }
        if ($name == "paginas" && ($value < 10 || $value > 1000)) {
            throw new Exception("Páginas entre 10 y 1000");
        }
        $this->$metodo($value);
    }

}