Fundamentos
Lo que aprenderás sobre POO en PHP
Deuda técnica
Code smell
Código espagueti
Inclusión de archivos
Programación orientada a objetos
Introducción a clases y objetos
Abstracción
Alcance o Encapsulamiento
Modularidad
Polimorfismo
Polimorfismo: interfaz
Herencia
Interfaces
Resumen
Proyecto en PHP
Iniciando nuestro proyecto: PHPUnit y clases heredadas
Continuando nuestro proyecto
Revisión del proyecto
Reto - Ejercicio
Conclusión - Frameworks PHP
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Aportes 128
Preguntas 12
Como observación… el orden de los include afecta … ya que si ponemos de la siguiente forma, marcara un Fatal Error, quiero pensar que es porque lee primero la clase admin sin tener person y user antes
<?php
include './clases/admin.php';
include './clases/person.php';
include './clases/user.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet();```
Como adelanto, para los que se asusten al leer “extends” y digan “¿QUÉ ES ESTO? ¿WTF? ¿COMO QUE EXTENDS?”
Hace referencia a una cosa muy bonita de la Programación Orientada a Objetos que se llama “Herencia” que, of course, se explica más adelante en este curso :3
La clase es el molde con el cual crearemos nuestros objetos. Para crear una clase y después un objeto lo hacemos así:
<?php
class User {
public $type;
}
class Admin {
public function greet() {
return "Hola admin";
}
}
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
Y después partirlos en módulos:
<?php
require_once './person.php';
require_once './user.php';
require_once './admin.php';
$usuario = new User;
$usuario->type = new Admin;
echo $usuario->type->greet();
<?php
class Person {
public function greet() {
return "Hola $this->name";
}
}
<?php
class User {
public $type;
}
<?php
class Admin extends Person {
public $name = 'Administrador';
}
😵¿Qué es la Poo?
La Poo es una paradigma que nos permite mapear objetos reales al mundo digital. 🚀
🤔¿Qué es una clase?
Una clase es una un “Molde” para crear objetos, la cual esta compuesta por atributos y métodos. 😯
🔳¿Qué es un objeto?
Son entidades que tienen un determinado estado, comportamiento e identidad.😎
Es el resultado de la instancia de una clase.
😧¿A que se refieren con instancia?
Se refiere a la actividad de crear un objeto mediante la lectura, recuperación de los atributos de una clase.🤩
index.php
<?php
include './clases/person.php';
include './clases/user.php';
include './clases/admin.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
person.php
<?php
class Person
{
public function greet()
{
return "Hola $this->name";
}
}
user.php
<?php
class User
{
public $type;
}
admin.php
<?php
class Admin extends Person
{
public $name = "Administrador";
}Cuando divides el código en varios archivos, ya no necesitas incluir Person.php en el principal. Porque Admin.php se encarga de tomar los datos de Person.php.
Aquí el código:
.
INDEX.PHP
<?php
include 'User.php';
include 'Admin.php';
//creo un objeto de tipo USER
$Usuario = new User;
//uso una variables propias de User y le asigno un objeto ADMIN
$Usuario->type = new Admin;
//mando a pantalla la funcion greep que viene de Admin y Admin la toma de Person
echo $Usuario->type->greep();
PERSON.PHP
<?php
class Person{
public function greep(){
return "Hola $this->name";
}
}
USER.PHP
<?php
// include 'User.php';
// include 'Admin.php';
class User{
public $type;
}
ADMIN.PHP
<?php
include 'Person.php';
class Admin extends Person{
public $name = "Administrador";
}
🎯 La palabra reservada class nos permite declarar una clase. Por otro lado extends hace referencia a la herencia.
Sigo desde hace tiempo a Italo y en ningun curso puede faltar el clasico ejemplo del blog y los post xD Que buen profe 😃
Index.php
<?php
require_once('./classes/User.php');
require_once('./classes/Admin.php');
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
User.php
<?php
class User
{
public $type;
}
Admin.php
<?php
require_once('Person.php');
class Admin extends Person
{
public $name = 'Administrador';
}
Person.php
<?php
class Person
{
public function greet()
{
return "Hola, $this->name";
}
}
Mi aporte de la clase
como Dice Anuar Rodríguez el orden si afecta
<?php
require('./clases/Person.php');
require('./clases/User.php');
require('./clases/Admin.php');
?>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<h2>
<?php
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
?>
</h2>
</body>
</html>```
Este es mi codigo:
El index
La Clase Usuario
La Clase Persona
El Administrador
Clase Molde
<?php #Person.class.php
abstract class Person
{
public $name;
public function greet()
{
return "Hola {$this->name}";
}
}
?>
Clase User
<?php #User.class.php
class User
{
public $type;
}
?>
Clase Administrador
<?php #Admin.class.php
require_once "Person.class.php";
class Admin extends Person
{
public $name = 'Administrador';
}
?>
Por último el archivo index.php
<?php #index.php
require_once "Classes\User.class.php";
require_once "Classes\Admin.class.php";
$user = new User();
$user->type = new Admin();
echo $user->type->greet();
?>
<?php
require_once ‘./person.php’; //clases en uso person.php,user.php,admin.php
require_once ‘./user.php’;
require_once ‘./admin.php’;
$usuario = new User; //objeto de la plase usuario
$usuario->type = new Admin; //objecto de la clase administrador
echo $usuario->type->greet(); //mensaje que viene de las 3 clases
index.php
<?php
require_once "User.php";
require_once "Admin.php";
require_once "Person.php";
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
person,php
<?php
class Person
{
public $name;
public function greet()
{
return "Hola $this->name";
}
}
User.php
<?php
class User
{
public $type;
}
Admin.php
<?php
include "Person.php";
class Admin extends Person
{
public $name = 'Administrador';
}
deben incluir $name en la clase para no generar error!
archivos
index
person
admin
user
echo
Una clase es una plantilla para los objetos. Y un objeto es la instancia de una clase.
index.php
<?php
require_once 'Admin.php';
require_once 'User.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
User.php
<?php
class User
{
public $type;
}
Admin.php
<?php
require_once 'Person.php';
class Admin extends Person
{
public $name = 'Administrador';
}
Person.php
<?php
class Person
{
public function greet()
{
return "Hola $this->name";
}
}
<?php
include './Person.php';
include './User.php';
include './Admin.php';
$user = new User();
$user->$type = new Admin();
echo $user->$type->greet(); // Hola administrador
En mi caso lo tengo de esta manera:
index.php
<?php
include('classes/User.php');
include('classes/Admin.php');
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
?>
Ya que, para hacer el Extends en la clase Admin, agregué el include ahí.
<?php
include('Person.php');
class Admin extends Person
{
public $name = 'Administrador';
}
?>
<?php
require_once('./Person.php');
class Admin extends Person
{
public $name = 'Administrador';
}
require('./User.php');
require('./Admin.php');
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
A mi entender, incluir la clase Peson debe estar en el archivo Admin y no en el index.
Debe ser así porque al querer utilizar la clase Admin desde otro archivo este fallaría.
include_once("./Admin.php");
include_once("./User.php");
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
class User
{
public $type;
}
class Person
{
public function greet()
{
return "hola $this->name";
}
}
include_once("./Person.php");
class Admin extends Person
{
public $name = "Administrador";
}
Podemos resumir que clases es el molde y a partir de ese molde estoy creando diferentes objetos, en términos más sencillos digamos que tenemos un único molde de usuarios y a partir de allí se pueden registrar miles de usuarios, es eso en esencia; si tengo una clase llamada post, esta clase me va a permitir crear n cantidad de post.
Digamos que la programación orientada a objetos me permite llamar a cada una de estas cosas como objetos, es la técnica utilizada y en este caso la vamos a utilizar en el lenguaje de programación PHP.
CARACTERÍSTICAS: Existe la herencia, la modularidad, abstracción, polimorfismo (No tiene porque ser complicado).
Son diferentes conceptos que van relacionados.
Vamos a crear clases y a partir de ella vamos a crear objetos, nosotros simplemente tenemos que memorizar y entender de forma clara a cada una de estas características ara crear código correctamente escrito.
Los diferentes signos son muy sencillos, por ejemplo, una clase requiere la palabra reservada class le colocas el nombre abre llave, cierra llave, esto es lo necesario.
Para crear un objeto a partir de esta clase utilizamos una palabra reservada que dice new, creamos una variable igual new y colocamos el nombre de esta clase, al hacerlo creamos automáticamente un objeto, no hay mayor ciencia detrás de estos conceptos.
Es muy importante tomar en cuenta el orden en el que incluimos los archivos, primero se deben llamar los archivos que no tengan dependencia de otros.
index.php
<?php
include './entities/Person.php';
include './entities/User.php';
include './entities/Admin.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
Clase Person
<?php
class Person
{
public function greet()
{
return "Hey $this->name, como estás?";
}
}
Clase User
<?php
class User
{
public $type;
}
Clase Admin
<?php
class Admin extends Person
{
public $name = 'Administrador';
}
Resumen de la clase
<?php
class Person{
public function greet(){
return "Hello $this->name";
}
}
class User{
public $type;
}
class Admin extends Person{
public $name = 'Administrador';
}
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
?>
Pese a que había visto algo de POO antes, si cuesta un poco entenderlo a la primera 😅
Pero sigamos que queda mucho por aprender!
Les comparto mi apunte:
index.php
<?php
// Se incluyen los diferentes archivos donde están las clases creadas
include_once('./Admin.php');
include_once('./User.php');
// Se crean las instancias
$usuario = new User();
// Se le asigna un valor a las propiedades del objeto
$usuario->type = new Admin(); // A la propiedad 'type' se le asigna una instancia de la clase 'Admin'
// Invocamos algún metodo
$usuario->type->greet();
.
Person.php
<?php
// Se crea la clase 'Person'
class Person{
// Se le definen atributos o métodos segun sea el caso
function greet(){ // método de saludar
echo("Hola $this->name");
}
}
.
Admin.php
<?php
// Se incluye la clase 'Person' para hacer uso de sus propiedades y métodos
include_once("./Person.php");
// Se crea la clase 'Admin' que a su vez extiene de la clase 'Person'
class Admin extends Person{
public $name = "Administrador";
}
.
User.php
<?php
// Se crea la clase 'User'
class User {
// Se le definen atributos o métodos segun sea el caso
public $type;
}
.
Resultado
Excelente profesor, explica muy bien estos conceptos.
person.php
<?php
class Person
{
public function greet()
{
return "Hi $this->name";
}
}
user.php
<?php
class User{
public $type;
}
admin.php
<?php
require_once 'person.php';
class Admin extends Person {
public $name = 'Administarador';
}
index.php
<?php
require_once 'user.php';
require_once 'admin.php';
$user = new User();
$user->type = new Admin();
echo $user->type->greet();
TERMINAL
Master JJ@Darth-Kamus MINGW64 ~/Documents/Emma/Escuela de WORDPRESS/POO-PHP
$ php index.php
Hi Administarador
Resultado en index.php con el codigo segmentado
<?php
require 'user.php';
require 'admin.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
Mi humilde aporte.
Index.php
<?php
include 'person.php';
include 'user.php';
include 'admin.php';
$user = new user;
$user->type = new Admin;
echo $user->type->greet();
Admin.php
<?php
class admin extends Person
{
public $name = 'Administrador';
}
Person.php
<?php
class person
{
public function greet()
{
return "Hola $this->name";
}
}
User.php
<?php
class user
{
public $type;
}
Aquí está mi aporte.
<?php
include './person.php';
include './user.php';
include './admin.php';
$usuario = new User;
$usuario->type = new Admin;
echo $usuario->type->greet();```
<?php
class Admin extends Person
{
public $name = ‘Administrador’;
}
<?php
class Person
{
public function greet()
{
return “Hola $this->name”;
}
}
<?php
class User
{
public $type;
}
<?php
include './person.php';
include './user.php';
include './admin.php';
$usuario = new User;
$usuario->type = new Admin;
echo $usuario->type->greet();```
<?php
class Admin extends Person
{
public $name = ‘Administrador’;
}
<?php
class Person
{
public function greet()
{
return “Hola $this->name”;
}
}
<?php
class User
{
public $type;
}
Aqui el pequeño aporte:
Quizá ya lo habrán comentado, pero es muy buena idea empezar con el curso de POO que imparte Anncode.
Mas que nada para tener las bases de la POO.
No suelo hacer muchos aportes, pero si hay algo que corregir, por favor hacérmelo saber. 😋
index.php
<?php
/**
* Llamando las clases
*/
require_once 'User.php';
require_once 'Admin.php';
/**
* Creando objetos a partir de las clases
*/
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
User.php
<?php
class User
{
public $type;
}
Admin.php
<?php
require_once 'Person.php';
class Admin extends Person
{
public $name = 'Administrador';
}
Person.php
<?php
class Person
{
public function greet()
{
return "Hola $this->name";
}
}
Hola, RETO cumplido!, pero agregue algunas modificaciones para colocar mi aporte a la clase.
No entendí cual era el objetivo del archivo User y la class User pero aun así lo incluí en la practica para seguir la linea del profesor.
ARCHIVO(index.php)
<?php
require 'Person.php';
require 'Admin.php';
require 'User.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
#======================
echo "<br>";
#======================
$role = new Admin;
echo $role->greet(3);
ARCHIVO(Person.php)
<?php
class Person
{
public function greet($value = 0) // Person.php
{
return "Hola " . $this->role[$value];
}
}
ARCHIVO (Admin.php)
<?php
class Admin extends Person
{
public $role =[
'Administrador',
'Vendedor',
'Gerente',
'RRHH'];
}
ARCHIVO (User.php)
<?php
class User
{
public $type;
}
Listo así quedo:
Reto de la clase:
<?php
include 'user.php';
include 'admin.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
<?php
class Person
{
public function greet()
{
echo "hola $this->name";
}
}
<?php
class User
{
public $type;
}
<?php
include 'person.php';
class Admin extends Person
{
public $name = 'Administrador';
}
index.php
<?php
include 'person.php';
include 'user.php';
include 'admin.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
?>
person.php
<?php
class Person {
public function greet()
{
return "Hola $this->name";
}
}
user.php
<?php
class User
{
public $type;
}
admin.php
<?php
class Admin extends Person
{
public $name = 'Administrador';
}
Saludos, por acá dejo mi aporte.
<?php
include 'Person.php';
include 'Admin.php';
include 'User.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
En este caso Incluí persona en administrador para no llamarlo en el index.php y carga bien en mi localhost
Yo justo hice las clases separadas y luego las llame desde el index
Index.php
<?php
include 'User.php';
include 'Admin.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
User.php
<?php
class User{
public $type;
}
Admin.php
<?php
include 'Person.php';
class Admin extends Person{
public $name = 'Administrador';
}
Person.php
<?php
class Person{
public function greet(){
return "Hola $this->name";
}
}```
la clase Person.php la llamo en Admin.php porque ahi esta la extencion de esa clase
<?php
require_once 'User.php';
require_once 'Admin.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
archivo Person.php
<?php
include ‘admin.php’;
class Person
{
public function great(){
return “Hola $this->name”;
}
}
archivo Admin.php
<?php
include ‘User.php’;
class Admin extends Person{
public $name = “Administrador”;
}
archivo User.php
<?php
class User
{
public $type;
}
archivo index.php
<?php
include ‘Person.php’;
$user = new User;
$user->type = new Admin;
echo $user->type->great();
Usuario.php
class Usuario
{
public $tipo;
}
Persona.php
class Persona
{
public function saludar()
{
return "Hola $this->name";
}
}
Admin.php
class Admin extends Persona
{
public $name = "Administrador";
}
Index.php
Herencia, Modularidad, Polimorfismo.
ClassNewLes comparto el código de la clase dividido en 4 archivos.
index.php
<?php
require_once 'Person.php';
require_once 'User.php';
require_once 'Admin.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
Person.php
<?php
class Person
{
public function greet()
{
return "Hola $this->name";
}
}
User.php
<?php
class User
{
public $type;
}
Admin.php
<?php
class Admin extends Person
{
public $name = 'Administrador';
}
no hé logrado entenderlo
<require_once('User.php');
require_once('Person.php');
require_once('Admin.php');
$user = new User;
$user->type = new Admin;
echo $user->type->greet();>
include(“User.php”);
include(“Person.php”);
include(“Admin.php”);
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
<?php
include ‘./admin.php’;
include ‘./person.php’;
include ‘./user.php’;
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
?>
<?php
include('person.php');
include('user.php');
include('Admin.php');
$user= new User;
$user->type = new Admin;
echo $user->type->greet();
Aquí va mi aporte comunidad:
Como primer paso creé una carpeta llamada Models
mkdir Models
Segundo paso cree los archivos Person.php y User.php dentro de esa carpeta con sus recpectivos códigos
Person.php
<?php
class Person
{
public function greet()
{
return "Hola $this->name";
}
}
User.php
<?php
class User
{
public $type;
}
Después realicé mi clase Admin.php
<?php
include './Models/Person.php';
class Admin extends Person
{
public $name = 'Administrador';
}
Y por último en mi archivo index dejé el siguiente código
<?php
include './Models/User.php';
include './Models/Admin.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
<?php
include “Person.php”;
include “Admin.php”;
include “User.php”;
$user = new User;
$user->type = new Admin;
echo $user->type->saludar();
Mi solución.😒
<?php
include "./clasesobjetos/classperson.php"; //En primer lugar por que llama a la funcion greet que esta contenida en el Padre
include "./clasesobjetos/classuser.php";
include "./clasesobjetos/classAdmin.php";
$user= new User;
$user->type = new Admin;
echo $user->type->greet();
index.php
<?php
require_once 'admin.php';
require_once 'person.php';
require_once 'user.php';
// INTANCIAR UN OBJETO
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
?>
person.php
<?php
// CLASES
class Person
{
public function greet()
{
return "Hola $this->name";
}
}
?>
user.php
<?php
// CLASES
class User
{
public $type;
}
?>
admin.php
<?php
require_once 'person.php';
// CLASES (herencia)
class Admin extends Person
{
public $name = 'Administrador';
}
?>
Dejo mi código, no importo incluyo a person.php, dado que admin.php lo posee incluido.
<?php
include './admin.php';
include './user.php';
$user = new User;
$user->type= new Admin;
echo $user->type->greet();
Mi modo:
Admin.php
<?php
require_once 'Person.php';
class Admin extends Person
{
public $name = 'Administrador';
}
index.php
<?php
require_once 'User.php';
require_once 'Admin.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
Person.php
<?php
class Person
{
public function greet()
{
return "Hola $this->name";
}
}
User.php
<?php
class User
{
public $type;
}
Person.php
<?php
class Person
{
public function greet()
{
return “Hola $this->name”;
}
}
Admin.php
<?php
require_once ‘./Person.php’;
class Admin extends Person
{
public $name = ‘Administrador’;
}
User.php
<?php
class User
{
public $type;
}
index.php
<?php
require_once ‘./Admin.php’;
require_once ‘./User.php’;
$User = new User;
$User->type = new Admin;
echo $User->type->greet();
Index.php
<?php
require_once 'person.php';
require_once 'user.php';
require_once 'admin.php';
$user = new User;
$user->type = new Admin;
$user->name = 'Jose';
echo $user->type->greet($user->name);
person.php
<?php
class Person
{
public function greet($name)
{
return "Hola $this->rol $name";
}
}
user.php
<?php
class User
{
public $type;
public $name;
}
Admin
<?php
class Admin extends Person
{
public $rol = 'Administrador';
}
class person.php
<?php
class person
{
public function saludo(){
return "HOLA $this->name";
}
}
?>
class user.php
<?php
class user
{
public $type;
}
?>
class admin.php
<?php
class admin extends person
{
public $name = "Administrador";
}
?>
index.php
<?php
include 'person.php';
include 'admin.php';
include 'user.php';
$usuario = new user;
$usuario->type = new admin;
echo $usuario->type->saludo();
?>
Quise usar lo aprendido en el curso anterior con composer y lo que hemos aprendido hasta ahora en este con un tema un poco diferente para asegurarme de que estaba entendiendo y resulto bien, dejo mi código por si quieren darle un vistazo y ver algo un tanto diferente siguiendo la filosofía del curso
/**
index.php
*/
<?php
require '../vendor/autoload.php';
use MiContexto\WaterType;
use MiContexto\Squirtle;
$pokemon = new WaterType;
$pokemon->monster = new Squirtle;
echo $pokemon->monster->roar();
/**
WaterType.php
*/
<?php
namespace MiContexto;
class WaterType{
public $monster;
}
/**
Squirtle.php
*/
<?php
namespace MiContexto;
use MiContexto\Pokemon;
class Squirtle extends Pokemon{
public $name = 'Squirtle';
}
/**
Pokemon.php
*/
<?php
namespace MiContexto;
class Pokemon{
public function roar(){
return "$this->name roars";
}
}
Admin.php
index.php
user.php
Person.php
<?php
include 'User.php';
include 'Person.php';
include 'Admin.php';
include 'SubAdmin.php';
$user = new User;
$user2 = new User;
$user->type = new Admin;
$user2->type = new subAdmin;
echo $user->type->greet().'<br>';
echo $user2->type->greet();
index.php
<?php
include './Person.php';
include './User.php';
include './Admin.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet(); //Hola Administrdor
Person.php
<?php
class Person
{
public function greet()
{
return "Hola $this->name";
}
}
User.php
<?php
class User
{
public $type;
}
Admin.php
<?php
class Admin extends Person
{
public $name = "Administrador";
}
Utilizando psr-4 con composer
//Admin.php
<?php
namespace PooPHP;
class Admin{
public function great(){
echo json_encode(["rta"=>"Hola administrador"]);
}
}
//User.php
<?php
namespace PooPHP;
class User extends Admin{
public $user;
}
index.php
<?php
echo ‘<!DOCTYPE html>
<html lang=“es”>
<head>
<meta charset=“UTF-8”/>
<title>POO CON PHP</title>
</head>
<body>’;
require_once DIR."/vendor/autoload.php";
use \PooPHP\User;
$alfa= new User;
$alfa->great();
echo ‘</body>
</html>’;
tengo un problema al querer hacer el echo, no me muestra lo que quiere imprimir o un error sino que me muestra en el navegador la porción de código
Este es el index.php
<?php
require_once './person.php';
require_once './user.php';
require_once './admin.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
Clase person
<?php
class Person
{
public function greet(){
return "Hola $this->name";
}
}
Clase User
<?php
class User
{
public $type;
}
Clase admin
<?php
class Admin extends Person
{
public $name = 'Administrador';
}
<?php
require_once "user.php";
require_once "person.php";
require_once "admin.php";
require_once "clients.php";
$type_sesion = "ADMINISTRADOR";
if($type_sesion == "ADMINISTRADOR")
{
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
}elseif($type_sesion == "CLIENTE")
{
$user2 = new User;
$user2->type = new Clients;
echo $user2->type->greet();
}
le agregue un if para poder interactuar y entender mejor esto de las clases
<?php
include './person.php';
include './user.php';
include './admin.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet();```
<?php
require_once “Person.php”;
class Admin extends Person
{
public $name = "Administrador";
}
?>
Que significa la flecha ->? Nose si me pase el video donde explican la flecha, el resto lo entiendo perfecto ya que es similar ah JS como instanciar objetos.🤔
Excelente clase!
index.php
<?php
include './clases/Person.php';
include './clases/User.php';
include './clases/Admin.php';
$user = new User();
$user->type = new Admin;
echo $user->type->greet();
Admin.php
<?php
class Admin extends Person
{
public $name = 'Administrador';
}
Person.php
<?php
class Person
{
public function greet()
{
return "Hola $this->name";
}
}
User.php
<?php
class User
{
public $type;
}
aprendi mucho en esta clase
//index.php
<?php
require 'user.php';
require 'admin.php';
$user= new user;
$user->type=new admin;
echo $user->type->greet();
//user.php
<?php
class user
{
public $type;
}
//persona.php
<?php
class persona
{
public function greet()
{
return "hola $this->name";
}
}
//admin.php
<?php
require 'persona.php';
class admin extends persona
{
public $name='administrador';
}
Person.php
<?php
class Person
{
public function greet()
{
return "Hola $this->name";
}
}
User.php
<?php
class User
{
public $type;
}
Admin.php
<?php
class Admin extends Person
{
public $name = 'Administrador';
}
Inidex.php
<?php
include 'Person.php';
include 'User.php';
include 'Admin.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
Excelente
<?php
require_once 'Person.php';
require_once 'User.php';
require_once 'Admin.php';
$user = new User;
$user->type = new Admin;
echo $user->type->greet();```
.
index
<?php
include("Person.php");
include("Admin.php");
include("User.php");
//Creamos un objeto
$user = new User;
//Definimos el tipo de user
$user->type = new Admin;
Person
<?php
class Person
{
public function greet()
{
return "Hola $this->name";
}
}
User
<?php
class User
{
public $type;
}
Admin
<?php
require_once("Person.php");
class Admin extends Person
{
public $name = "Administrador";
}
Yo lo realice aplicando la herramienta Composer
User.php
<?php
namespace App;
class User
{
public $type;
}
Person.php
<?php
namespace App;
class Person
{
public function greet()
{
return "Hola $this->name";
}
}
Admin.php
<?php
namespace App;
use App\Person;
class Admin extends Person
{
public $name = 'Administrador';
}
index.php
<?php
require __DIR__.'/vendor/autoload.php';
use App\User;
use App\Admin;
$user = new User;
$user->type = new Admin;
echo $user->type->greet();
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?