Fundamento de poo en php
-
Upload
robert-moreira -
Category
Internet
-
view
344 -
download
7
Transcript of Fundamento de poo en php
LOGOMsig. Ing. Robert Moreira [email protected]
Septiembre de 2016
TEMA:
«PROGRAMACIÓN ORIENTADA
A OBJETOS EN PHP»1.- Usando Tomcat de XAMPP como server en NETBEANS.
2.- Método constructor en PHP.
3.- typekit en PHP (solo para clases y arrays).
4.- Herencia en PHP.
5.- Acceso y visibilidad de métodos y atributos.
6.- Métodos y propiedades estáticas en PHP.
7.- Constantes en PHP.
8.- Clases abstractas e interfaces.
9.- Herencia múltiple en PHP (TRAIT).
10.- Excepciones en PHP.
11.- Clases y métodos finales en PHP.
12.- Métodos de destrucción en PHP.
13.- Conversión de objeto a cadenas en PHP.
14.- Sobrecarga de métodos en PHP.
15.- Objetos clonados en PHP.
16.- Autocarga de clases en PHP.
17.- Paquetes y namespaces en PHP .
18.- Búsqueda de clases en PHP.
19.- Búsqueda de métodos en PHP.
20.- API Reflection en PHP (ingeniería inversa de clases).
21.- Constantes mágicas en PHP.
22.- PHP UNIT.
Ejercicios en:
http://ouo.io/IOUUkj
1. Usando Tomcat de XAMPP como server en NETBEANS.
Company Logo
PRIMER PASO.- Modificar el archivo en las líneas
indicadas
SEGUNDO PASO.- Agregar el server dentro de
netbeans
2. MÉTODO CONSTRUCTOR EN PHP
Company Logo
<?php
class persona{
public $edad;
public $nombre;
public function run(){
echo "estoy corriendo";
}
public function __construct($nombre,$edad)
{
$this->nombre=$nombre;
$this->edad=$edad;
}
}
$persona1=new persona("Andrea", 24);
echo $persona1->nombre;
echo "<br>";
$persona1->run();
?>
- El constructor lleva doble
guion bajo.
- El constructor no se
sobrecarga.
3.- typekit en PHP (solo para clases y arrays).
Company Logo
<?php
class persona{
public $edad;
public $nombre;
public function run(persona $instancia){
echo "estas corriendo en mis latidos
".$instancia->nombre;
}
public function __construct($nombre,$edad) {
$this->nombre=$nombre;
$this->edad=$edad;
}
}
$persona1=new persona("Andrea",24);
echo "<br>";
$persona1->run($persona1);
?>
- El constructor hasta
la fecha de esta
práctica no puede
recibir instancias del
mismo tipo como
parámetro.
- Cualquier otro
método que no sea el
constructor puede tener
como argumento una
instancia del propio
tipo de la clase.
4.- Herencia en PHP.
<?php
class Animal{
public $tipo_sonido=" sin definir";
public function run(){
echo "<br>yo corro ";
}
public function walk(){
echo "<br>yo camino ";
}
public function __construct() {
echo "<br>Ha nacido un animal ";
}
public function getSonido(){
echo $tipo_sonido;
}
}
class Perro extends Animal{
public function __construct(){
$tipo_sonido="ladra";
echo "<br>Ha nacido un perro y ". $tipo_sonido."<br><br>";
}
}
class Gato extends Animal{
public function __construct(){
parent::__construct();
$tipo_sonido="maulla";
echo "<br> Ha nacido un gato y ". $tipo_sonido."<br><br>";
}
}
$mascota1=new Gato();
$mascota2=new Perro();
if ($mascota1 instanceof Gato){
echo "Es un gato ";
if ($mascota1 instanceof Animal){
echo "Es un animal ";
}
}
?>
Forma de llamar al
constructor de la
clase principal.
Uso de instanceof para saber a que
clase corresponde una instancia
5.- Acceso y visibilidad de métodos y atributos.
<?php
class Perfil{
protected $email="valor en el padre";
public function setEmail($email){
$this->email=$email;
}
public function getEmail(){
return $this->email;
}
public function __construct(){
}
}
class HeredandoPerfil extends perfil{
public function __construct(){
$this->email="valor en el hijo";
}
}
$perfil1=new Perfil();
echo "<br> El mail del primer perfil: ".$perfil1->getEmail();
$perfil2=new HeredandoPerfil();
echo "<br> El mail del segundo perfil: ".$perfil2->getEmail();
?>
Los especificadores PROTECTED Y PUBLIC permiten
la herencia y el mismo resultado:El mail del primer perfil: valor en el padre
El mail del segundo perfil: valor en el hijo
El especificador PRIVATE restringe la herencia, el
resultado con private es:El mail del primer perfil: valor en el padre
El mail del segundo perfil: valor en el padre
Tanto PROTECTED como PRIVATE hacen que la
siguiente instrucción lance error:$perfil1=new Perfil();
echo $perfil1->email;
6.- Métodos y propiedades estáticas en PHP.
Cuando queramos acceder a una constante o
método estático desde dentro de la clase, usamos la
palabra reservada: self.
Cuando queramos acceder a una constante o
método de una clase padre, usamos desde la clase
extendida la palabra reservada: parent
<?php
class AccesoBd{
protected static $host="localhost";
protected static $usuario="root";
protected static $clave="123456";
protected static function imprimirDatosConexion(){
return "<br>host: ".self::$host."<br>usuario:
".self::$usuario."<br>clave: ".self::$clave;
}
public function __construct() {
echo $this->imprimirDatosConexion();
}
}
class InsertEnTabla extends AccesoBd{
protected $tipoPrivilegio="Insertar";
public function __construct(){
echo "<br>Llamando al metodo constructor del padre: ";
echo parent::__construct();
echo "<br>Accediendo a una propidad estática: ".self::$host;
echo "<br>Accediendo a una propiedad no estatica: ".$this-
>tipoPrivilegio;
}
}
$instancia1=new AccesoBd();
$instancia2=new InsertEnTabla();
?>
No se concatenan estas dos líneas en una sola
debido a que el INTERPRETE PHP, resuelve primero
la llamada al constructor del padre y luego la
sentencia ECHO, lo que produce una salida no
deseada:
host: localhost
usuario: root
clave: 123456
Llamando al metodo constructor del padre:
<?php
class Configuracion{
const ENVIRONMENT='desarrollo';
public function __construct(){
}
}
class AccesoEnBd extends Configuracion
{
protected function generandoCadenaConexion(){
if ('desarrollo' == self::ENVIRONMENT){
echo "generando cadena de conexion para ambiente de
desarrollo";
}
}
public function __construct(){
$this->generandoCadenaConexion();
}
}
$instancia= new AccesoEnBd();
?>
7.- Constantes en PHP.
Las constantes en PHP igual que elementos estáticos
son accedidos con self.
this hace referencia al objeto (propiedades y
métodos que se crean al instanciar una clase).
self hace referencia a la clase (propiedades y
métodos que están disponibles para acceso en una
clase sin necesidad de que esta se instancie.
La importancia de las constantes se ve por
ejemplo en una clase de configuración para
manejo de la cadena de conexión.
8.- Clases abstractas e interfaces (PARTE 1 DE 2).
las clases abstractas nos permiten limitar y/o definir
con precisión las capacidades de cada objeto. En el
ejemplo sería no dable (a menos que se quite el
abstract)una definición como esta:
$fruta = new Fruta();
$fruta->comer();
Ya que de poderse invocar al método comer, no
cabría una interpretación en función de la POO con
una pregunta como por ejemplo:
¿A qué te supo la fruta?
Las clases abstractas entonces son aquellas que no
son instanciadas, se utilizan para definir estructura y
funcionalidad.
En las clases abstractas se puede definir
funcionalidad, en este caso por ejemplo hay
funcionalidad en el método “setColor” de la clase
Fruta.
<?php
abstract class Fruta {
private $color;
abstract public function comer();
public function setColor($c) {
$this->color = $c;
}
}
class Manzana extends Fruta {
public function comer() {
echo "<br>Masticar hasta llegar al Centro";
}
}
class Naranja extends Fruta {
public function comer() {
echo "<br>Pelar la Naranja";
echo "<br>Masticar";
}
}
$manzana = new Manzana();
$manzana->comer();
?>
8.- Clases abstractas e interfaces (PARTE 2 DE 2).
En las interfaces no se puede definir
funcionalidad, es decir ningún método tiene llaves
de entrada y cierre en el que haya código
Las interfaces nos permiten compartir
comportamientos entre objetos no relacionados
<?php
interface iDB{
public function connect();
}
class MySQL implements iDB{
public function connect(){
echo "<br>Conectandose a Mysql";
}
public function __construct() {
$this->connect();
}
}
class Oracle implements iDB{
public function connect(){
echo "<br>Conectandose a Oracle";
}
public function __construct() {
$this->connect();
}
}
$conexinMysql=new MySQL();
$conexionOracle=new Oracle();
?>
<?php
class Fruta{
function cosechar(){
echo "la fruta es el ovario...";
}
}
class Verdura{
function cosechar(){
echo "agarrala de cualquier parte...";
}
}
class ClaseQueHereda extends Fruta, Verdura{
}
?>
9.- Herencia múltiple en PHP.
En PHP la herencia múltiple no esta permitida.
<?php
trait Fermentacion{
function fermentar(){
echo "fermentando ". $this->materiaPrima."<br>";
}
}
class Whisky{
use Fermentacion;
public $materiaPrima="Cereal";
function proceso(){
echo "<b>El whisky se obtiene:</b> ";
echo Fermentacion::fermentar();
}
}
class Cerveza{
use Fermentacion;
public $materiaPrima="Cebada";
function proceso(){
echo "<b>La cerverza se obtiene:</b> ";
echo Fermentacion::fermentar();
}
}
$bebida1=new Whisky();
$bebida2=new Cerveza();
$bebida1->fermentar();
$bebida2->fermentar();
$bebida1->proceso();
$bebida2->proceso();
?>
La variable $materia prima a usarse en el
trait debe especificarse tanto en la clase
Cerveza como en la clase Whisky.
CODIGO 1 CODIGO 2
La referencia
$this es necesaría
debido a que
indicará que se
usa la variable
$materiaPrima de
cada clase.
10.- Excepciones en PHP.
1. La definición de una excepciónsiempre debe heredar de la clasegenérica Exception.
2. Una excepción puede serlanzada ("thrown"), y atrapada("catched").
3. Se pueden usar múltiplesbloques catch para atrapardiferentes clases de excepciones.
4. El código de dentro delbloque finally siempre se ejecutarádespués de los bloques try y catch,independientemente de que sehaya lanzado una excepción o no.
5. El orden de los catch debe irordenado desde lo más específicohasta lo más genérico, así se veque el último catch es:catch (Exception $exc)
<?php
class DBException extends Exception{}
class FILEException extends Exception{}
class Main
{
public function __construct()
{
try
{
throw new DBException("No se conecta a la base de datos");
//throw new FILEException("No se conecta al archivo de texto");
}catch (FILEException $exc)
{
echo "Error en archivo de texto: ".$exc->getMessage()."<br>";
}
catch (DBException $exc)
{
echo "Error en base de datos: ".$exc->getMessage()."<br>";
}
catch (Exception $exc)
{
echo "Error genérico: ".$exc->getMessage()."<br>";
}
finally
{
echo "Cerrando medio de almancenamiento usado";
}
}
}
$instancia =new Main();
?>
11.- Clases y métodos finales en PHP.
<?php
class ClasePadre{
final public function metodoQueSePretendeHeredar()
{
echo "Método para heredar";
}
}
class ClaseHija extends ClasePadre{
public function metodoQueSePretendeHeredar()
{
echo "Intentando reescribir método";
}
}
$instancia =new ClaseHija();
?>
<?php
final class ClasePadre{
public function metodoQueSePretendeHeredar()
{
echo "Método para heredar";
}
}
class ClaseHija extends ClasePadre{
public function metodoQueSePretendeHeredar() {
echo "Intentando reescribir método";
}
}
$instancia =new ClaseHija();
?>
La palabra clave final, impide que las clases hijas
sobrescriban un método, antecediendo su
definición con final. Por ello este código
devuelve error al ejecutarlo
Si la propia clase se define como final,entonces no se podrá heredar de ella. Por
ello este código devuelve error al ejecutarlo.
<?php
class ChuckNorris{
public function __construct() {
echo "Creando instancia <br>";
}
public function __destruct() {
echo "<br>Borrando instancia";
}
}
$rangerTexas=new ChuckNorris();
for($i=1;$i<10;$i++){
echo $i."-";
if ($i==5)
unset($rangerTexas);
}
exit();
?>
12.- Métodos de destrucción en PHP.
El método destructor será llamado tanpronto como no hayan otras referencias aun objeto determinado (finalizó el scriptPHP), o en cualquier otra circunstancia definalización (ejecutó la instrucción EXIT, o sellamo al destructor explícitamente a travésde unset($instanciaCreada))
<?php
class Persona{
public $nombre, $apellido;
public function __construct($nombre,$apellido) {
$this->nombre=$nombre;
$this->apellido=$apellido;
}
public function __toString() {
return $this->nombre." ".$this->apellido;
}
}
$donMario=new Persona("Mario", "Cedeño");
echo $donMario;
?>
13.- Conversión de objeto a cadenas en PHP.
El método toString permite configurar auna clase para que sus instancias noden error, cuando se las intenta usarcomo cadenas de texto.
<?php
class mujer{
public $nombre;
public $colorOjo;
public $tezPiel;
public $signoZodiacal;
public function __construct($nombre, $colorOjo, $tezPiel, $signoZodiacal) {
$this->nombre=$nombre;
$this->colorOjo=$colorOjo;
$this->tezPiel=$tezPiel;
$this->signoZodiacal=$signoZodiacal;
}
public function __call($name, $arguments) {
$no_existe_metodo=TRUE;
$verboMetodo= substr($name, 0,3);
$accionMetodo=substr($name, 3);
if ($verboMetodo=='get')
{
$no_existe_metodo=FALSE;
return $this->$accionMetodo;
}
if ($verboMetodo=='set')
{
$no_existe_metodo=FALSE;
$this->$accionMetodo=$arguments[0];
}
if ($no_existe_metodo)
{
throw new Exception("Método no definido");
}
}
}
$Andrea=new mujer("Andrea", "Negro", "Trigueña", "Tauro");
echo $Andrea->getnombre()."<br>";
$Andrea->setnombre("Karol");
echo $Andrea->getnombre()."<br>";
echo $Andrea->getprueba();
?>
14.- Sobrecarga de métodos en PHP.
El método call recibe dos parámetros,uno es el nombre del método al que seintenta invocar.
Por ejemplo, en la línea:
$Andrea->setnombre("Karol");
El método call recibe como nombre“setnombre” y en $arguments recibe“Karol” que estaría en $arguments[0]
<?PHP
class VentanaSingleton{
private static $instancia;
public $aplicacion;
private function __construct(){}
public function construirVentana()
{
if(self::$instancia==null)
{
self::$instancia = new static();
return self::$instancia;
}
}
}
//$ventana=new VentanaSingleton();
$ventana1= VentanaSingleton::construirVentana();
$ventana1->aplicacion="Word";
$ventana2= $ventana1;
$ventana2->aplicacion="Power Point";
echo "<br>Antes de usar la función clone";
echo "Ventana 1 es: {$ventana1->aplicacion} y Ventana 2 es:
{$ventana2->aplicacion}";
$ventana2=clone $ventana1;
$ventana2->aplicacion="Excel";
echo "<br><br>Después de usar la función clone";
echo "Ventana 1 es: {$ventana1->aplicacion} y Ventana 2 es:
{$ventana2->aplicacion}"
?>
15.- Objetos clonados en PHP.
1. Al definir el constructor como privadono será posible instanciar usando lainstrucción.$ventana=new VentanaSingleton();
2. Al usar la instrucción :$ventana2= $ventana1;Se hace que ambas apunten a la mismareferencia de objeto en memoria, por lotanto la salida será:Power Point
3. Al usar la instrucción :$ventana2=clone $ventana1;Se hace que ambas apunten a distintareferencia de objeto en memoria, por lotanto la salida será:Power Point y Excel.
16.- Autocarga de clases en PHP.
1. Cada vez que se ejecuta un new y noencuentra la correspondiente clase, sedispara la función“spl_autoload_register()”
2. La función“spl_autoload_register()”recibe como argumento elnombre de las clases que sequieren instanciar en new:Config y Config2
<?php
function CargadorClase($class){
include $class.'.php';
}
spl_autoload_register('CargadorClase');
?>
AutoLoad.php
<?php
require_once ('AutoLoad.php');
$instConfig=new Config();
$instConfig2=new Config2();
echo $instConfig::ENTORNO;
echo "<br>";
echo $instConfig2::ENTORNO;
?>
index.php
<?php
class Config{
const ENTORNO="DESARROLLO";
}
?>
Config.php y Config2.php
Muchos desarrolladores que escriben aplicaciones orientadas a objetos
crean un fichero fuente de PHP para cada definición de clase. Una de
las mayores molestias es tener que hacer una larga lista de inclusiones
al comienzo de cada script (uno por cada clase).
La función spl_autoload_register() registra cualquier número de
autocargadores, posibilitando que las clases e interfaces sean cargadas
automáticamente si no están definidas actualmente.
es una especie de última opción de cargar un archivo que necesitamos
y funciona de la siguiente manera: Cuando se necesita una clase
(haciendo un new, en un extends, un implements, etc…) si la clase no
está cargada se llama a la función mágica spl_autoload_register()
17.- Paquetes y namespaces en PHP (Parte 1 de 2).
1) Siempre que utilicemos un namespace directamente hay que empezar con
un \ slash invertido. Ejemplo:
$carro = \Codehero\Cursos\Carro::rodar();
2) Para separar los namespaces se utiliza la barra invertida ( \ ), veamos
algunos subnamespaces validos.
Proyecto\BD\MySQL
Proyecto\BD\Mongo
3) Cuando tenemos muchas funciones que debemos llamar de varios
namespaces es muy tedioso escribir todas las rutas completas. Para esto
existe la opción de importar namespaces con la sentencia use. Se pueden
importar todos los que sean necesarios, veamos un ejemplo de como
importarlos:
17.- Paquetes y namespaces en PHP (Parte 2 de 2).
1. Pueden ser sustituidos por unafunción de autoload.
Facebook.php
index.php
Tweeter.php
<?php
require_once 'redessociales/Facebook.php';
require_once 'redessociales/Tweeter.php';
use redessociales\Facebook\Publicacion as Face;
use redessociales\Tweeter\Publicacion as Tweet;
class Principal{
public $post1;
public $post2;
public function __construct() {
$this->post1=new Face();
$this->post2=new Tweet();
}
}
$instancia=new Principal();
echo $instancia->post1->getContenido()."<br>";
echo $instancia->post2->getContenido();
?>
<?php
namespace redessociales\Facebook;
class Publicacion
{
const PLATFORM = 'facebook';
private $estado;
function __construct()
{
$this->estado = "Trotando";
}
public function getContenido()
{
return $this->estado;
}
}
?>
<?php
namespace redessociales\Tweeter;
class Publicacion
{
const PLATFORM = 'tweeter';
private $tweet;
function __construct()
{
$this->tweet = "Saliendo de casa";
}
public function getContenido()
{
return $this->tweet;
}
}
?>
<?php
class Animal{
public $numeroPatas;
}
class Perro{
public function morder(){
echo "analizando víctima...";
}
}
//echo class_exists("Animal");
$clases=['Animal','Gato','Perro'];
foreach($clases as $clase){
echo "<br>La clase ". $clase .":" .
(class_exists($clase)?' Si existe ': ' No existe ');
}
?>
18.- Búsqueda de clases en PHP.
Esta función verifica si la clase dada ha sido
definida o no, el nombre es coincidido de
manera insensible a mayúsculas y minúsculas.
<?php
abstract class AcariciarAlAmo{
public function caricia(){echo "Lamiendo la mano..";}
}
interface Enterrar{
public function moverTierra();
}
trait Olfato{
public function oler(){
echo"<br> usando la nariz...";
}
}
class Animal extends AcariciarAlAmo{
Use Olfato;
public $numeroPatas;
}
class Perro extends AcariciarAlAmo implements Enterrar{
Use Olfato;
public function morder(){
echo "<br> analizando víctima...";
}
public function moverTierra() {
echo "<br> arando con las patas traseras";
}
public function __construct() {}
}
$instancia=new Perro;
var_dump(get_class_methods($instancia));
?>
19.- Búsqueda de métodos en PHP.
Devuelve un array con los nombres de los
métodos definidos para la clase especificada
por class_name. Es caso de error devuelve
NULL.. La salida de la instrucción muestra:
Morder – Método propio
moverTierra – Método de interface
__construct
caricia – Método heredado de clase abstracta
oler – Método del trait usado para herencia
múltiple
<?php
abstract class AcariciarAlAmo{
public function caricia(){echo "Lamiendo la mano..";}
}
interface Enterrar{
public function moverTierra();
}
trait Olfato{
public function oler(){
echo"<br> usando la nariz...";
}
}
class Animal extends AcariciarAlAmo{
Use Olfato;
public $numeroPatas;
}
class Perro extends AcariciarAlAmo implements Enterrar{
Use Olfato;
public function morder(){
echo "<br> analizando víctima...";
}
public function moverTierra() {
echo "<br> arando con las patas traseras";
}
public function __construct() {}
}
$reflect_class =new ReflectionClass('AcariciarAlAmo');
Reflection::export($reflect_class);
echo $reflect_class->getName()."<br>";
echo $reflect_class->isAbstract()."<br>";
echo $reflect_class->isInstantiable()."<br>";
echo $reflect_class->isInternal()."<br>";
?>
20.- API Reflection en PHP (ingeniería inversa de clases).
Ofrece varias formas de obtener comentarios
de documentación de funciones, clases y
métodos.
<?php
class FILEException extends Exception{};
class Loger{
public $name;
public static function log($text)
{
try
{
throw new FILEException("No se guardo en el archivo");
} catch (Exception $ex) {
$prefix=date('d-m-Y- h:i:s ::: ');
file_put_contents('log.txt',
$prefix . "Error en el archivo: " . __FILE__ .
" En la línea: " . __LINE__ .
" En la clase: " . __CLASS__ .
" En el método: ".__METHOD__.
" En el trait: ".__TRAIT__."\n",
FILE_APPEND);
}
}
}
Loger::log("Mensaje por si acaso");
?>
21.- Constantes mágicas en PHP.
PHP ofrece un largo número
de constantes predefinidas a
cualquier script en ejecución.
Muchas de estas constantes, sin
embargo, son creadas por
diferentes extensiones, y sólo
estarán presentes si dichas
extensiones están disponibles,
bien por carga dinámica o
porque han sido compiladas.
Para este ejemplo fue
necesario crear un
archivo log.txt en el
directorio del proyecto
web.
file_put_contents
recibe 3 argumentos
22.- PHP UNIT (PARTE 1 DE 3) – Probándolo desde consola
1) Descargar el proyecto PHPUNIT en https://phpunit.de/ se descargará un archivo con extensión PHAR.
Los archivos phar son similares en concepto a los archivo JAR de Java, pero están adaptados a las necesidades y a
la flexibilidad de apliciones de PHP. Un archivo Phar se usa para distribuir una aplicación o biblioteca PHP
completa en un único fichero
2) Configurar para usarlo
2.1 CONFIGURACIÓN PARA USAR PHP UNIT DESDE CONSOLA
- Copiar el archivo descargado dentro del directorio C:\xampp\php
- En “variables de Entorno” -> “variables de sistema” agregar la siguiente entrada: C:\xampp\php.
- Ejecutar la siguiente instrucción en consola:
<?php
require_once ('AutoLoad.php');
class Operacion extends PHPUnit_Framework_TestCase{
protected $valor1;
protected $valor2;
protected $resultado;
public function testcargar1($v){
$this->valor1=$v;
}
}
$instancia=new Operacion();
$res=$instancia->testcargar1($v);
?>
Para que PHPUnit funcione con el método
de una clase, hay que escribir test delante
del método que quiera probarse, en este
caso: testcargar.
Se debe agregar esta herencia
en la cabecera de una clase que
será revisada con PHPUnit.
Código que arroja error para PHPUnit
22.- PHP UNIT (PARTE 2 DE 3) – Probándolo desde netbeans y XAMPP
Este se descarga de la dirección
https://phpunit.de/
PASO 1
PASO 2
PASO 3
Se selecciona el interprete de PHP
Crear un folder llamado test dentro del
proyecto, y generar los dos archivos que
se indican.
22.- PHP UNIT (PARTE 3 DE 3) – Probándolo desde netbeans
<?php
class Empleado extends PHPUnit_Framework_TestCase{
public $nombre;
public $salario;
public $alta;
public function __construct($nombre,$salario,$alta) {
$this->nombre=$nombre;
$this->salario=$salario;
$this->alta=$alta;
}
public function testgetNombre(){
return $this->nombre;
}
public function testgetSalario(){
return $this->salario;
}
public function testgetAlta(){
return $this->alta;
}
}
$empleado1=new Empleado("Luis", 1000, "Febrero");
$res=$empleado1->testgetNombre();
echo $res;
?>
Código que no arroja error para PHPUnit