Sobreescritura

<?php 
        class A {
            public $nombre;
            public function __construct($nombre) {
                $this->nombre=$nombre;
            }
            
            function saludo(){
                echo "Hola ".$this->nombre;
            }
        }
        class B extends A{
            public $apellidos;
            public function __construct($nombre,$apellidos) {
                parent::__construct($nombre);
                $this->apellidos=$apellidos;
            }
            function saludo(){
                echo "Hola ".$this->nombre." ".$this->apellidos;
            }
        }
        $ana=new A("Ana");
        $ana->saludo();
        
        $juan=new B("Juan","Pi");
        $juan->saludo();
        ?>

Valores estáticos

 <?php
        class foo{
            public static $ciudad="Barcelona";
            public $nombre;
            public function __construct($nombre) {
                $this->nombre=$nombre; 
            }
            public static function saludo(){
                       echo "Hola estoy en ".self::$ciudad;
         
            }
             public static function otroSaludo(){
                echo "Hola ".$this->nombre; //Esto da un error por ser estático
            }
        }
        $ana=new foo("Ana");
        $juan=new foo("Juan");
        
        print_r($ana);
        print_r($juan);
        
        echo foo::$ciudad;
        echo $ana::$ciudad;
        echo $juan::$ciudad;
        
        foo::$ciudad="Turruncún";
        echo foo::$ciudad;
        echo $ana::$ciudad;
        echo $juan::$ciudad;
        
        $juan::saludo();
        $ana::saludo();
        ?>

Constructores

 <?php

        class A {

            public $elementos = [];

            public function __construct() {
                for ($i = 0; $i < 10; $i++) {
                    $this->elementos[] = $i;
                }
            }
          

        }

        class B {

            public $elementos = [];

            public function __construct($num=10) {
                for ($i = 0; $i < $num; $i++) {
                    $this->elementos[] = $i;
                }
            }

        }

        $a = new A();
        $b = new A();


        $c = new B(3);
        $d = new B(9);
        $e = new B();

        print_r($c->elementos);
        print_r($d->elementos);
        print_r($e->elementos);
        ?>

Herencia y visibilidad

 <?php

        class A {

            public $aa = "aa";
            private $bb = "bb";
            protected $cc = "cc";

        }

        class B extends A {

            public $dd = "dd";
            private $ee = "ee";

            function test() {
                echo $this->aa;
                echo $this->bb; //Esta no la imprime
                echo $this->cc;
                echo $this->dd;
                echo $this->ee;
            }

        }

        $obj = new B();
        $obj->test();

        echo $obj->aa;
        echo $obj->bb;//Esta no la imprime
        echo $obj->cc;//Esta no la imprime
        echo $obj->dd;
        echo $obj->ee;//Esta no la imprime

Ejercicio alumnos

class Alumno {

            private $nombre;
            private $nota;
            private $apellidos;

            //Set y get para todas las propiedades. La nota enter 0 y 10
            //El resto no vacíos
            //Función aprobado que nos devuelva true si la nota es >=5
            //Función nombre completo que nos devuelva el nombre y el apellido
            //¿Sería posible hacerlo como propiedad y no como función?
            //Functión mágica toString que nos devuelva nombre completo y nota

            function __set($name, $value) {
                if (property_exists($this, $name)) {
                    if ($name == 'nota') {
                        if ($value >= 0 && $value <= 10) {
                            $this->nota = $value;
                        } else {
                            throw new Exception("La nota debe estar entre 0 y 10");
                        }
                    } else {
                        if (!empty($value)) {
                            $this->$name = $value;
                        }
                    }
                }
            }

            function aprobado() {
                return $this->nota >= 5;
            }

            function __get($name) {
                if (property_exists($this, $name)) {
                    return $this->$name;
                } else {
                    if ($name == "nombreCompleto") {
                        return $this->nombreCompleto();
                    }
                }
            }

            function nombreCompleto() {
                return $this->nombre . " " . $this->apellidos;
            }

            public function __toString() {
                return $this->nombreCompleto." - ".$this->nota;
            }

        }

        $ana = new Alumno();
        $ana->nombre="Ana";
        $ana->apellidos="Pi";
        $ana->nota=7;
        echo $ana->nombreCompleto."<br/>";
        echo $ana;
        ?>

Setters y getters, diferentes formas

Con funciones:

 class Coche{
            private $marca;
            private $modelo;
            private $velocidad;
            
            //Crear las funciones que nos permitan poner y obtener valores
            //En el caso de la velocidad el valor permitido está entre 50 y 300
            //En el caso de marca y modelo comprobar que no esté vacío
            
            function setMarca($marca){
                if (!empty($marca)){
                    $this->marca=$marca;
                }
            }
            function setModelo($modelo){
                if (!empty($modelo)){
                    $this->modelo=$modelo;
                }
            }
            function setVelocidad($velocidad){
                if ($velocidad>=50 && $velocidad<=300){
                    $this->velocidad=$velocidad;
                } else{
                    throw new Exception("La velocidad debe estar entre 50 y 300");
                }
            }
            
            function getMarca(){
                return $this->marca;
            }
            function getModelo(){
                return $this->modelo;
            }
            function getVelocidad(){
                return $this->velocidad;
            }
        }
        
        $seat=new Coche();
        $seat->setMarca("Seat");
        $seat->setModelo("Panda");
        $seat->setVelocidad(180);
        print_r($seat);

Con __get y __set

     <?php
        class Coche {

            private $marca;
            private $modelo;
            private $velocidad;

            //Crear las funciones que nos permitan poner y obtener valores
            //En el caso de la velocidad el valor permitido está entre 50 y 300
            //En el caso de marca y modelo comprobar que no esté vacío

            function __get($name) {
                if (property_exists('Coche', $name)) {
                    return $this->$name;
                }
            }

            function __set($name, $value) {
                if ($name == "velocidad") {
                    if ($value >= 50 && $value <= 300) {
                        $this->velocidad = $value;
                    } else {
                        throw new Exception("La velocidad debe estar entre 50 y 300");
                    }
                } else {
                    if (!empty($value) && property_exists('Coche', $name)) {
                        $this->$name = $value;
                    }
                }
            }

        }

        $seat = new Coche();
        $seat->marca = "Seat";
        $seat->modelo = "Panda";
        $seat->velocidad = 180;
        $seat->color="rojo";
        echo $seat->modelo;
        echo $seat->color;
        print_r($seat);

Ejemplo clases

<?php
        //Enter your code here, enjoy!
class empleado {
    public $sueldo;
    private $nombre;
function paga(){
return $this->sueldo/12;
}
public function __get($propiedad) {
if (property_exists($this, $propiedad)) {
return $this->$propiedad;
}
}
public function __set($property, $value) {
if (property_exists($this, $property)) {
   if (!empty($value)){
$this->$property = $value;
   }
}
}
}
class comercial extends empleado{
    public $comision=.1;
    public $ventas=200000;
function paga(){
$p=parent::paga();
return $p+$this->ventas*$this->comision/12;
}
}
$juan= new empleado();
$juan->nombre=”Juan”;
echo $juan->nombre;
$juan->nombre=””;
echo $juan->nombre;
$juan->sueldo=30000;
echo $juan->paga().”|”;
$ana=new comercial();
$ana->sueldo=30000;
echo $ana->paga();

Programación orientada a objetos

<?php

class miClase {

 public $propiedad;

 function muestraContenido() {
 echo $this->propiedad;
 }

}

$obj1 = new miClase;
$obj2 = new miClase();
$obj1->propiedad = "Hola";
$obj2->propiedad = "Adios";

echo $obj1->propiedad;
$obj2->muestraContenido();

class Alumno {

 public $nombre;
 public $apellido;
 public $nota;
 private $cuota;

 function nombreCompleto() {
 echo $this->nombre . " " . $this->apellido;
 }

 function aprobado() {
 if ($this->nota >= 5) {
 return true;
 } else {
 return false;
 }
 }

 function cuota($valor) {
 if ($valor == 100 || $valor == 200 || $valor == 300) {
 $this->cuota = $valor;
 }
 }

 function anualidad() {
 return $this->cuota * 12;
 }

}

$juan = new Alumno();
$ana = new Alumno();
$juan->nombre = "Juan";
$juan->apellido = "Pérez";
$juan->nota = 6;
$juan->nombreCompleto();
if ($juan->aprobado()) {
 echo "Aprobado!!!";
}
$juan->cuota(200);
echo $juan->anualidad();

$ana->apellido = "Ana";