Bienvenida e Introducción

1

¿Por qué aprender Programación Orientada a Objetos?

2

¿Qué resuelve la Programación Orientada a Objetos?

3

Paradigma Orientado a Objetos

4

Lenguajes Orientados a Objetos

5

Instalando Visual Studio Code

6

Diagramas de Modelado

7

Qué es UML

Orientación a Objetos

8

Objetos

9

Abstracción y Clases

10

Modularidad

11

Analizando Uber en Objetos

12

Reto 1: identificando objetos

Programación Orientada a Objetos. Análisis

13

Clases en UML y su sintaxis en código

14

Modelando nuestros objetos Uber

15

¿Qué es la herencia?

16

Aplicando Herencia a nuestro proyecto Uber

17

Reto 2: analicemos un problema

Clases, Objetos y Método Constructor

18

Creando nuestras carpetas iniciales para el curso

19

Definiendo clases en Java y Python

20

Definiendo Clases en JavaScript

21

Objetos, método constructor y su sintaxis en código

22

Objetos. Dando vida a nuestras clases en Java y Python

23

Declarando un Método Constructor en Java y JavaScript

24

JavaScript orientado a objetos, lo más nuevo

25

Declarando un método constructor en Python

Herencia

26

Aplicando herencia en lenguaje Java y PHP

27

Solución del reto de herencia en PHP

28

Aplicando herencia en lenguaje Python y JavaScript

29

Otros tipos de Herencia

30

Reto 4

Encapsulamiento

31

Encapsulamiento

32

Encapsulando atributos en Java

Polimorfismo

33

Generando polimorfismo en Java

34

Generando polimorfismo en PHP

Cierre del curso

35

El Diagrama UML de Uber

36

Conclusiones

37

Bonus: Qué es la Programación Orientada a Objetos

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Curso de Programación Orientada a Objetos: POO

Curso de Programación Orientada a Objetos: POO

Anahí Salgado Díaz de la Vega

Anahí Salgado Díaz de la Vega

Aplicando herencia en lenguaje Java y PHP

26/37
Recursos

Aportes 157

Preguntas 45

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

No se puede usar un ArrayList con dos parámetros de entrada, lo correcto es utilizar otro objeto tipo Map: Map<String, Map<String,Integer>> typeCarAccepted;

Hola, hay un error en la porción de java. El error es que ArrayList solo permite un argumento, por ejemplo: ArrayList<String> myList; y en el código la profesora esta usando dos.
Como necesitamos los dos argumentos, yo creo que lo que quería hacer la profesora es un Mapa donde el valor es otro mapa. Nos quedaría algo así:
Map<String, Map<String, Integer>> typeCarAccepted;

Estoy seguro que veremos el error en otro video y va a ser corregido, pero dejo esto aquí por si alguien se preguntaba porque aparece un error en ArrayList.

Atajos de Visual Studio Code:

Hola a todos, yo también cambié el ArrayList por Map, realicé el reto, gracias a todos los que apoyaron en los comentarios.

Para los que le sale este mismo error, no se preocupen a Anahí también le aparece y lo corrige en unas clases más adelante. No se permite Arraylist con estos dos tipos de datos, lo que deben hacer es cambiar ArrayList por Map.

No se puede usar un ArrayList con dos parámetros de entrada, da error.
Sería así: Map<String, Map<String,Integer>> typeCarAccepted;

En este link encontraran informacion de la estructura de datos Map. Se que no es agradable ver un tutorial y no saber la razon de por que el tutor hizo algo (Claro que si eso pasara los tutoriales serian infinitos) pero alli esta google el mejor amigo de un programador

Aplicando herencia


Java

class Student extends Person

Python

class Student(Person):

JavaScript

Con ES6 podemos hacerlo como en Java

class Student extends Person {
        constructor(nombre, apellido, altura, numeroDeEstudiante) {
        // con el método super() llamamos a las variables de Padre
        super(nombre, apellido, altura)
        this.numeroDeEstudiante = numeroDeEstudiante
    }
}

PHP

class Student extends Person

Ruby

class son < SuperClass
end

al principio lo ignore poniendo un solo tipo: ArrayList<String>, pero… en la parte de java el error es que ArrayList solo permite un argumento, vi que hay muchos preguntando por eso y en el código la profesora esta usando dos y como necesitamos los dos tipos para el año del auto tambien, usando otro map nos quedaría algo así:
Map<String, Map<String, Integer>> typeCarAccepted;

eso hice yo y ya nos salvamos del error, por ahora 😃

Asi se realiza en c#

Uber X

using System;
namespace Uber.Clases
{
    public class UberX : Car
    {
        String brand;
        String model;

      public UberX(String license, Account driver, String brand, String model) : base(license, driver)
      {
          this.brand = brand;
          this.model = model;
      } 
        
    }
}

UberPool

using System;
namespace Uber.Clases
{
    public class Uberpool : Car
    {
        String brand;
        String Model;

        public Uberpool (String license, Account driver, String brand, String Model) : base(license, driver)
        {
           this.brand = brand;
           this.Model = Model;
        }

    }
}

UberBlack

using System;
using System.Collections;
using System.Collections.Generic;
namespace Uber.Clases
{
    public class UberBlack : Car
    {
        Dictionary<string,string> typeCarAccepted = new Dictionary<string,string>();
        ArrayList seatsMaterial = new ArrayList();
        public UberBlack(String license, Account driver, ArrayList seatsMaterial, Dictionary<string,string> typeCarAccepted  ) : base(license, driver)
        {
        this.license = license;
        this.driver = driver;
        this.seatsMaterial = seatsMaterial;
        this.typeCarAccepted = typeCarAccepted;
           
        }
    }
}

UberVan

using System;
using System.Collections;
using System.Collections.Generic;
namespace Uber.Clases
{
    public class UberVan : Car
    {
        //typeCarAccepter 
        Dictionary<string,string> typeCarAccepted = new Dictionary<string,string>();

        //seatsMaterials;
        ArrayList seatsMaterial = new ArrayList();
        public UberVan(String license, Account driver, ArrayList seatsMaterial, Dictionary <string,string> typeCarAccepted ) : base(license, driver)
        {
            this.license = license;
            this.driver = driver; 
            this.seatsMaterial = seatsMaterial;
            this.typeCarAccepted = typeCarAccepted;
        }
    }
}

UberX

<?php
require_once './Car.php';
class UberX extends Car 
{
  public $brand;
  public $model;

  public function __construct($license, $driver, $brand, $model)
  {
    parent::__construct($license, $driver);
    $this->brand = $brand;
    $this->model = $model;
  }
}

UberBlack

<?php
require_once './Car.php';

class UberBlack extends Car 
{
  public $typeCarAccepted;
  public $seatsMaterial;

  public function __construct($license, $driver, $typeCarAccepted, $seatsMaterial)
  {
    parent::__construct($license, $driver);
    $this->typeCarAccepted = $typeCarAccepted;
    $this->seatsMaterial = $seatsMaterial;
  }
}

Antes de avanzar hay que tener en cuenta que en esta clase se muestra un error que creo será tratado más adelante en el puesto en marcha de la herencia en Java, específicamente hay un error con la cantidad de parámetros que le pasamos al ArrayList, ya que este solo puede admitir un parámetro, tengan en cuenta eso, si lo que necesitamos son dos valores entonces debemos cambiar por un tipo de dato Map. Sigamos con las clases 😃

Mientras tanto JavaScript

En Javascript también podemos heredar de una clase utilizando la palabra extends, nada más que tenemos que ejecutar el super constructor:

class Desarrollador extends Persona {
constructor (name, lastName){
super();
super(name, lastName) -> Ponemos super para llamar al super constructor
}
}

Ya hice el reto de PHP 😄

Uber Pool

Uber Black

Uber Van

Uber X

Estupenda clase, ahora conozco la manera correcta de aplicar la herencia para crear las nuevas clases a partir de la superclase o clase padre.
 
Por cierto, para las personas que les sale el error con ArrayList al crear UberBlack, se puede arreglar cambiando la palabra ArrayList que está entre los símbolos <> por Map.

💡 Aplicando herencia en lenguaje Dart.

import 'car.dart';

class UberX extends Car{
  String brand;
  String model;
  
  UberX({license, driver, this.brand, this.model}): super(license: license, driver: driver);
}
import 'car.dart';

class UberPool extends Car{
  String brand;
  String model;
  
  UberPool({license, driver, this.brand, this.model}): super(license: license, driver: driver);
}
import 'car.dart'

class UberBlack extends Car{
  Map<String, Map<String, int>> typeCarAccepted;
  List<String> seatsMaterial;
  
  UberBlack({license, driver, this.typeCarAccepted, this.seatsMaterial}):super(license: license, driver: driver);
}
import 'car.dart'

class UberVan extends Car{
  Map<String, Map<String, int>> typeCarAccepted;
  List<String> seatsMaterial;
  
  UberVan({license, driver, this.typeCarAccepted, this.seatsMaterial}):super(license: license, driver: driver);
}

alguien mas tuvo este error ?
podrian explicarme como solucionarlo por favor
(url)

Por Dios, no estoy entendiendo absolutamente nada de este curso ni de lo que está haciendo esta señora, que es todo que escribe? que es Map<>? que es ArrayList? que es todo eso?

Este curso es poco didáctico . No es recomendable de ninguna manera la metodología que utiliza, enseñar 4 lenguajes de esta manera es inadecuado, en mi caso que deseo aprender POO para Python hasta ahora siento que estoy en el limbo y se supone que tengo conocimientos previos del lenguaje.

PHP es el mejor lenguaje para desarrollo web y los errores se encuentran rápidamente

No se puede usar un ArrayList con dos parámetros de entrada, lo correcto es utilizar otro objeto tipo Map: Map<String, Map<String,Integer>> typeCarAccepted;

En JavaScript también se puede usar la palabra extends de la siguiente manera:

class Person {
    constructor(name, lastname) {
        this.name = name
        this.lastname = lastname
    }
}

class Student extends Person {
    constructor(year) {
        super(name, lastname)
        this.year = year
    }
}

El uso de super ayuda en no repetir lo escrito en la clase padre que también se usará en la clase hijo para reducir líneas de código.

Deberian explicar mejor como funciona el ArrayList

Un uso parecido al “super” de Java o al “parent” de PHP pero en C# es con “base”, pueden notar que la herencia y uso del keyword base se implementa con el simbolo “:” justo al lado de la definición de la clase (para heredar) y al lado del constructor para asignar la herencia a la super clase.

UberX.cs

using System;

namespace C_
{
    class UberX : Car
    {
        public string brand;
        public string model;

        public UberX(string license, Account driver, string brand, string model) : base (license, driver)
        {
            this.brand = brand;
            this.model = model;
        }
    }
}

Program.cs equivalente a Main.Java en este caso

using System;

namespace C_
{
    class Program
    {
        static void Main(string[] args)
        {
            UberX uberX_1 = new UberX("UML-5590", new Account("Pedro Pinto", "R-887779"), "Jaguar", "E55L");
            Console.WriteLine($"El Uber con la placa {uberX_1.license}, del conductor {uberX_1.driver.name} portador del documento {uberX_1.driver.document}, posee un {uberX_1.brand} modelo {uberX_1.model}");
            Console.ReadKey();
        }
    }
}

OUTPUT: El Uber con la placa UML-5590, del conductor Pedro Pinto portador del documento R-887779, posee un Jaguar modelo E55L

Hola, estoy teniendo un error al usar java.util.ArrayList, soy nuevo en esto y me esta costando encontrar la solución. Adjunto imagen con el error.
Desde ya muchas gracias

No me gusta PHP, y eso que es la primera vez que lo uso 😄

Herencia en python y Javascript con las clases User y Driver:

Cualquier cosa me comentan feedback 😃

  • Python:




  • Javascript:




Utilizamos la palabra reservada Super para obtener los datos heredados.

Definición Herencia por lenguaje
Java =>
class Student extends Person
Python =>
class Student(Person):
JavaScript =>
student.prototype = new Person();
PHP =>
class Student extends Person

No me rindo, no han hecho casi nada con JS pero sigo trabajandolo con el xD

Para archivos de PHP, si contiene solamente código propio puedes omitir la etiqueta de cierre ’ ?> ’ al final

<?php

class UberX extends Car {
...
}

muy poca explicación de por qué algunas cosas se escriben así. No se si es que es de las primeras clases de esta profesora, pero le recomiendo ver clases de freddy donde explica super detallado cada una de las líneas de codigo. Esta profesora solo dice: “vamos a hacerlo así” sin dar una explicación

Bastante claro pero seria mucho mejor si se creara un curso para cada uno de estos ya que por ejemplo los que no utilizamos PHP será algo poco agradable verlo.

Clases de Java aplicando 2 capas de herencia:
Clase padre: Car.java:

Capa 1:
CarBasic.java:

CarAdvanced.java:

Capa 2:
UberX:

UberPool.Java es básicamente el mismo que UberX.
UberBlack:

Y lo mismo entre UberBlack y UberVan.

Hola, tengo éste error en la línea: Map<String, ArrayList<String,Integer>> typeCarAccepted; de las Clases UberBalck y UberVan, ya he importado MAP y ARRAYLIST

Incorrect number of arguments for type ArrayList<E>; it cannot be parameterized with arguments <String, Integer>Java(16777741)```

Al parecer el código que tengo es el mismo, pero no me funciona, me sale ese error, alguien sabe que puede ser???

En mi caso para evitar copiar y pégar código para asi cumplir con del principio de Don’t Repeat Yourself cree una clase llamada CarBasic y otra llamada CarAdvanced de las cuales heredan los diferentes tipos de Uber, puesto que se repiten atributos en UberPool y UberX, y ocurre lo mismo en el caso de UberSUV y UberBlack.

Esto es un ejemplo de lo que hice:
CarBasic.java

class CarBasic extends Car {

    String brand;
    String model;

    public CarBasic(String license, Account driver, String brand, String model) {

        super(license, driver);
        this.brand = brand;
        this.model = model;

    }

}

UberPool.java

class UberPool extends CarBasic {
    
    public UberPool(String license, Account driver, String brand, String model) {

        super(license, driver, brand, model);

    }

}

Mientras mas veo esto mas quiero a python♥

Super, representa a la super clase y es como si llamaras al constructor de la clase que estamos haciendo referencia

Éste es mi código del reto, omito UberVan porque es igual a este. otra cosa que noté es que al compilarlo me pedía que agregara la función require_once()

<?php

require_once("Car.php");

class UberBlack extends Car {
  public $typeCar;
  public $seatsMaterial;

  public function __construct($license, $driver, $typeCar, $seatsMaterial) {
    parent::__construct($license, $driver);

    $this->typerCar = $typeCar;
    $this->seatsMaterial = $seatsMaterial;
  }
}

?>

java.utils.ArrayList solo puede ser de un tipo negérico, no acepta los 2 tipos de el ejemplo.
Map<String, ArrayList<String, Integer>> está mal.
Para obtener lo que se quiere en el ejemplo que sería una Lista de autos aceptados (no se por qué esto sería una propiedad del auto) sería algo como Map<String, Map<String, Integer>> que representado en JSON sería algo como:

typeAcceptedCars: {
	brand:{
		mode: string,
		year: number
	}[]
}[]

Tenía el mismo problema en el ArrayList de dos parámetros, pero gracias a los comentarios pude corregir.

con C#, usas “:” para heredar y también para implementar una interfaz

class Student : Person
{
	Console.WriteLine("Hola, estoy heredando de la clase Person")
}

class Student : IPerson
{
	Console.WriteLine("Hola, estoy implementando la interfaz IPerson")
}

Los objetos MAP son los que ahora se utilizan para crear arreglo de dos parámetros.

Ha sido de poner mucha atención a las sentencias “import” de java, ya que por ese descuido tuve algunos problemas al compilar. Recomendaría no perderlas de vista.

<?php
class UberX extends Car {
    public $brand;
    public $model;

    public function __construct($license, Account $driver, $brand, $model)
    {
        parent::__construct($license, $driver);
        $this->brand = $brand;
        $this->model = $model;
    }
}
?>

<?php
class UberPool extends Car {
    public $brand;
    public $model;

    public function __construct($license, Account $driver, $brand, $model)
    {
        parent::__construct($license, $driver);
        $this->brand = $brand;
        $this->model = $model;
    }
}
?>

<?php
class UberVan extends Car {
    
    public $typeCarAccepted;
    public $seatsMaterial;

    public $brand;
    public $model;


    public function __construct($license, Account $driver, $brand, $model, $typeCarAccepted, $seatsMaterial)
    {
        parent::__construct($license, $driver);
        $this->brand = $brand;
        $this->model = $model;
        $this->typeCarAccepted = $typeCarAccepted;
        $this->seatsMaterial = $seatsMaterial;
    }
}
?>

<?php
class UberBlack extends Car {
    
    public $typeCarAccepted;
    public $seatsMaterial;

    public $brand;
    public $model;


    public function __construct($license, Account $driver, $brand, $model, $typeCarAccepted, $seatsMaterial)
    {
        parent::__construct($license, $driver);
        $this->brand = $brand;
        $this->model = $model;
        $this->typeCarAccepted = $typeCarAccepted;
        $this->seatsMaterial = $seatsMaterial;
    }
}
?>

UberBlack:

<?php

class UberBlack extends Car {
    public $typeCarAccepted = array();
    public $seatsmodel = array();

    public function __construct($license, $driver, $typeCarAccepted, $seatsmodel){
        parent::__construct($license,$driver);
        $this->$typeCarAccepted = $typeCarAccepted;
        $this->$seatsmodel = $seatsmodel;
    }
}

?>

cuando pongo el siguiente codigo en NetBeans 8 me tira un error:
Map<String, ArrayList<String,Integer>> TipoCarAccepted;
¿como puedo solucionarlo?

Explicacion de herencia en Java.

Herencia en PHP

Herencia en JavaScript

Creando clase Uberx en Java.

Creando clase UberX en PHP.

las extenciones de las clases, depende demasiado de los objetos, pero porque no depende de otros factores???’

dos puntos por terminar de ver el video :v

De momento no quiero saber sobre PHP, pero igual es didáctico el curso de esa forma, gracias.

super();

😃

UberPool es igual a UberX
UberBlack es igual a UberVan
Clase UberBlack
<?php
require_once(“Car.php”);
class UberBlack extends Car{
public $typeCarAccepted;
public $seatsMaterial;

    public function __construct($license,$driver, $tipeCarAccepted, $seatsMaterial){
        parent::__construct($license, $driver);
        $this->typeCarAccepted=$typeCarAccepted;
        $this->seatsMaterial;
    }

}

?>

UberVan.php

<?php
class UberVan extends Car {
    
    public $typeCarAccepted;
    public $seatsMaterial;

    public $brand;
    public $model;


    public function __construct($license, Account $driver, $brand, $model, $typeCarAccepted, $seatsMaterial)
    {
        parent::__construct($license, $driver);
        $this->brand = $brand;
        $this->model = $model;
        $this->typeCarAccepted = $typeCarAccepted;
        $this->seatsMaterial = $seatsMaterial;
    }
}
?>

UberPool.php

<?php
class UberPool extends Car {
    public $brand;
    public $model;

    public function __construct($license, Account $driver, $brand, $model)
    {
        parent::__construct($license, $driver);
        $this->brand = $brand;
        $this->model = $model;
    }
}
?>

UberBlakc.php

<?php
class UberBlack extends Car {
    
    public $typeCarAccepted;
    public $seatsMaterial;

    public $brand;
    public $model;


    public function __construct($license, Account $driver, $brand, $model, $typeCarAccepted, $seatsMaterial)
    {
        parent::__construct($license, $driver);
        $this->brand = $brand;
        $this->model = $model;
        $this->typeCarAccepted = $typeCarAccepted;
        $this->seatsMaterial = $seatsMaterial;
    }
}
?>

Estas son las clases de PHP
Para UberPool.php:

<?php
require_once 'Account.php';

class UberPool extends Car {
    public $brand;
    public $model;

    function __construct($license, Account $driver, $brand, $model) {
        parent::__construct($license,$driver);
        $this->brand = $brand;
        $this->model = $model;
    }

}
?>

Para UberBlack.php

<?php
require_once 'Account.php';

class UberBlack extends Car {
    public $typeCarAccepted;
    public $seatsMaterial;

    function __construct($license, Account $driver, $typeCarAccepted, $seatsMaterial) {
        parent::__construct($license,$driver);
        $this->typeCarAccepted = $typeCarAccepted;
        $this->seatsMaterial = $seatsMaterial;
    }

}
?>

Para UberVan.php

<?php
require_once 'Account.php';

class UberVan extends Car {
    public $typeCarAccepted;
    public $seatsMaterial;

    function __construct($license, Account $driver, $typeCarAccepted, $seatsMaterial) {
        parent::__construct($license,$driver);
        $this->typeCarAccepted = $typeCarAccepted;
        $this->seatsMaterial = $seatsMaterial;
    }

}
?>

Yo realicé esto en PHP

UberX:

<?php
class UberX extends Car{
    public $brand;
    public $model;

    public function __construct($license, $driver ,$brand, $model){
        parent::__construct($license, $driver);
        $this->model = $model;
        $this->brand = $brand;
    }
}

UberPool:

<?php
class UberPool extends Car{
    public $brand;
    public $model;

    public function __construct($license, $driver ,$brand, $model){
        parent::__construct($license, $driver);
        $this->model = $model;
        $this->brand = $brand;
    }

UberBlack:

<?php
class UberBlack extends Car{
    public $typeCarAccept = Array();
    public $seatMaterial = Array();

    public function __construct($license, $driver, $seatMaterial, $typeCarAccept){
        parent::__construct($license, $driver);
        $this->setSeatMaterial($seatMaterial);
        $this->setTypeCarAccept($typeCarAccept);
    }
}

UberVan:

<?php
class UberVan extends Car{
    public $typeCarAccept = Array();
    public $seatMaterial = Array();

    public function __construct($license, $driver, $seatMaterial, $typeCarAccept){
        parent::__construct($license, $driver);
        $this->setSeatMaterial($seatMaterial);
        $this->setTypeCarAccept($typeCarAccept);
    }
}

Les comparto este repositorio que sirve de guía para el examen final, pues contiene las preguntas que se encuentran en el examen, la justificación y el video del curso donde se habla sobre eso. Espero y les sea de utilidad 😄.
Platzi-Test

La palabra super hará referencia a los atributos y métodos de la super clase y this hará referencia a los atributos de la clase hija

🦠La profe explica muy bien y cada vez voy entendiendo mejor el concepto, como funciona bien y no solo poner los atributos por ponerlos y ya. Me siento muy feliz conmigo mismo por lo que he logrado!

👾🚀

Hola a todos este es mi aporte. 📗💻🚀

Aplicando herencia
Java
class Student extends Person
Python
class Student(Person):
JavaScript
Con ES6 podemos hacerlo como en Java
class Student extends Person {
constructor(nombre, apellido, altura, numeroDeEstudiante) {
// con el método super() llamamos a las variables de Padre
super(nombre, apellido, altura)
this.numeroDeEstudiante = numeroDeEstudiante
}
}
PHP
class Student extends Person
Ruby
class son < SuperClass
end

💥TE MARCA ERROR

Para los que le sale este mismo error, no se preocupen a Anahí también le aparece y lo corrige en unas clases más adelante.

En la actualidad con ECMASCRIPT 6+ en javascript se puede usar la palabra clave class y tambien extends cuando se quiere heredar de una clase constructora. Es lo que se conoce como azucar sintactica.

genial

Los modificadores de acceso nos dice que elementos se heredan y cuales no:

public: se heredan.
protected: se heredan.
private: no se hereda.

Ejercicio PHP:

Estas son las clases de Uber que genere como parte del ejercicio propuesto por la profesora:

Uber Pool:

<?php
class UberPool extends Car {
    public $brand;
    public $model;

    public function __construct($license, $driver, $brand, $model){
        parent::__construct($license,$driver);
        $this->brand= $brand;
        $this->model= $model;
    }
}
?>

Uber Black:

<?php
class UberBlack extends Car {
    public $typeCarAccepted;
    public $seatsMaterial;

    public function __construct($license, $driver, $typeCarAccepted, $seatsMaterial){
        parent::__construct($license,$driver);
        $this->typeCarAccepted= $typeCarAccepted;
        $this->seatsMaterial= $seatsMaterial;
    }
}
?>

Uber Van:

<?php
class UberVan extends Car {
    public $typeCarAccepted;
    public $seatsMaterial;

    public function __construct($license, $driver, $typeCarAccepted, $seatsMaterial){
        parent::__construct($license,$driver);
        $this->typeCarAccepted= $typeCarAccepted;
        $this->seatsMaterial= $seatsMaterial;
    }
}
?>

Reto Php :

PHP

UberX

<?php
require_once("Car.php");
class UberX extends Car {
    public $brand;
    public $model;

    public function __construct($license, $driver, $brand, $model) {
        parent::__construct($license, $driver);
        $this->brand = $brand;
        $this->model = $model;
    }
}

UberPull

<?php
require_once("Car.php");
class UberPull extends Car {
    public $brand;
    public $model;

    function __construct($license, $driver, $brand, $model) {
        parent::__construct($license, $driver);
        this->model = $model;
        this->brand = $brand;
    }

}

UberBlack

<?php
require_once("Car.php");
class UberBlack extends Car {
    public $typeCardAcepted;
    public $material;

    function __construct($license, $driver, $typeCardAcepted, $material) {
        parent::__construct($license, $driver);
        this->typeCardAcepted = $typeCardAcepted;
        this->material = $material;
    }
}

UberVan

<?php
require_once("Car.php");
class UberVan extends Car {
    public $typeCardAcepted;
    public $material;

    function __construct($license, $driver, $typeCardAcepted, $material) {
        parent::__construct($license, $driver);
        this->typeCardAcepted = $typeCardAcepted;
        this->material = $material;
    }
}

👍

Me frustre mucho cuando la profe Anahi hace uso de Map, no lo entendí y me pause en esta parte de la clase, lo consulte y lo entendí a través de concepto que comparto:
La interface Map, extraído de java.util. Nos permite representar una estructura de datos para almacenar pares “clave/valor”; de tal manera que para una clave solamente tenemos un valor.

Link de apoyo en donde entendi esta información: https://jarroba.com/map-en-java-con-ejemplos/

Reto:
UberX.php

<?php
class Uberx extends Car{
    public $brand;
    public $model;
    public function __construct($license, $driver, $brand, $model){
        parent::__construct($license, $driver) //Equivale al "super" de Java
        $this->$brand = $brand;
        $this->$model = $model;
    }
}
?>

UberPool.php

<?php
class UberPool extends Car{
    public $brand;
    public $model;
    public function __construct($license, $driver, $brand, $model){
        parent::__construct($license, $driver) //Equivale al "super" de Java
        $this->$brand = $brand;
        $this->$model = $model;
    }
}
?>

UberBlack.php

<?php
class UberBlack extends Car{
    public $typeCarAccepted; 
    public $seatsMaterial;
    public function __construct($license, $driver, $typeCarAccepted, $seatsMaterial){
        parent::__construct($license, $driver);
        $this->$typeCarAccepted = $typeCarAccepted;
        $this->$seatsMaterial = $seatsMaterial;
    }
}
?>

UberVan.php

<?php
class UberVan extends Car{
    public $typeCarAccepted; 
    public $seatsMaterial;
    public function __construct($license, $driver, $typeCarAccepted, $seatsMaterial){
        parent::__construct($license, $driver);
        $this->$typeCarAccepted = $typeCarAccepted;
        $this->$seatsMaterial = $seatsMaterial;
    }
}
?>

Si en PHP todo parece ir bien, y aún cuando miras el código de los recursos se ve igual, revisa los nombres de las palabras reservadas, si hay un punto y coma, cosas super pequeñas y simples. Yo estuve dos horas intentando correr el código y el error estaba en que había escrito contruct cuando era construct.

Genial

Ahora en javascript es posible hacerlo igual que en PHP y Java, con un class Subclase extends Clase

Aca esta el reto con PHP

Apuntes de la Clase Aplicando herencia en lenguaje Java y PHP

Implementando la Herencia en diferentes lenguajes:

  • Java: la herencia se define de forma explicita usando la palabra reservada extends seguida de la Clase padre.

    class CarBasic extends Car
    

    Luego de esto hay que crear un método constructor dentro de la Clase hija que coincida con el de la Clase padre. Luego se usa super() para llamar al método constructor de la Clase padre (súper Clase).

    ```superhace referencia a la Clase padre, de hecho consuper`` se puede acceder a los atributos/métodos de la Clase padre usando notación de punto.

    Luego se usa this para pasar el valor de los parámetros a los atributos

    public CarBasic(String license, Account driver, String brand; String model) { /* Los parámetros incluyen los del constructor de la clase padre más los parámetros propios de la clase hija */
    	super(license, driver);
        this.brand = brand;
        this.model = model;
    }
    
  • Python: la herencia se define pasando la Clase padre como parámetro al instanciar la Clase Hija.

    class Student(Person):
    
  • JavaScript: aquí se toma la “clase” hija (prototipo) y la instancia cómo si fuera la “Clase” padre.

    student.prototype = new Person();
    
  • PHP: se usa la misma sintaxis de Java para definir la herencia.

    <?php
    
    class CarBasic extends Car {
    
        public $brand;
        public $model;    
    
    }
    
    ?>
    

    Luego se declaran los atributos de la Clase hija, después se crea el método constructor. En el caso de PHP en lugar de usar super() como en Java se usa parent::__construct() para acceder al constructor de la Clase padre.

    Después de esto se puede usar ```$this`` para acceder a los atributos de la Clase y asignarles el valor de los parámetros del método constructor.

    public function __construct($license, $driver, $brand, $model) { /* Método Constructor, recibe los parámetros d ela Clase padre junto con los de la Clase hija */
            
    	parent::__construct($license, $driver, $brand. $model);
         $this->brand = $brand;
         $this->model = $model;
        
    }
    
la maestra es buena pero no me gustó el curso, les recomiendo más el de Poo con Python de David Aroesti tiene más escencia

Amigos aparenrtemente tengo correcto el codigo pero me da este error , a alguien mas? Hep me please 😦

En Java: Palabra clave “super” para referirnos al método constructor de la clase padre
En PHP: “parent::” seguido de su constructor

el video de esta clase no se reproduce y no tiene audio sera solo ami que me esta dando problemas o hay alguien mas?

Por si no quedo claro la palabra “super”, miren esto:

El método super() es un uso especial de la palabra clave super donde se llama un constructor principal sin parámetros. En general, la palabra clave super se puede utilizar para llamar a métodos anulados, acceder a propiedades ocultas o invocar al constructor de una superclase.

Joder, PHP se me hace un poco complejo 😦, terminando POO me tomaré el curso de PHP.

El complemento perfecto para mi proyecto de la universidad

La herencia es muy importante en poo .
Algunos errores con ArrayList pero deduzco que mas adelante se corregirán

Por que comenta Anahi que es complicado encontrar un error en PHP

Saludos, espero me puedan ayudar me aparece un error de tipo

syntax error, unexpected ‘__construct’ (T_STRING), expecting variable (T_VARIABLE)

en la linea:

public function __construct($license, $driver) {

Gracias.

Todo estuvo perfecto, hasta que intente crear la variable Map, revise que todo estuviera exacto al ejemplo, pero siempre obtuve este error, alguien sabe porqué? Profeee aiudaaaa!

Nota personal, fijarme primero en los aportes de los compañeros, ellos ya resolvieron los problemas que seguro me pasaran, y no andar solo y triste buscando solución. Gracias aportes de Platzy 😃

Excellente Explicacion con Java

<?php
require_once(‘car.php’);

class UberVan extends Car {
public $typeCarAccepted;
public $seatsMaterial;

public function __construct ($license, $driver, $typeCarAccepted, $seatsMaterial){
    parent::__construct($license, $driver);
    $this->typeCarAccepted = $typeCarAccepted;
    $this->seatsMaterial = $seatsMaterial;
}

}

Listo

<?php

class UberBlack extends Car{
    public $typeCarAccepted;
    public $seatsMaterial;

    public function __construct($license, $driver, $typeCarAccepted, $seatsMaterial)
    {
        parent::__construct($license,$driver);
        this->$typeCarAccepted = $typeCarAccepted;
        this->$seatsMaterial = $seatsMaterial;
    }
}
?>

Buen curso hasta el momento, solamente una cosa, Me parece que en el archivo uberX.php faltó agregar un requiere_once(‘car.php’);
para que la herencia se pueda aplicar bien.

Que interesante como dos lenguajes muy diferentes se aproximan tanto en la implementacion de la herencia. Solo que quizas PHP usa un nombre mas obvio para la herencia.