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

Generando polimorfismo en Java

33/37
Recursos

Polimorfismo: Muchas formas. Poli = muchas, morfismo = formas. NO es Poliformismo

Es construir métodos con el mismo nombre pero con comportamiento diferente

Aportes 146

Preguntas 23

Ordenar por:

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

Si no les imprime lo de UberVan, no agreguen la variable passenger en la clase UberVan porque les genera conflicto y provoca que no se le asignen los 6 pasajeros a passengers.

Para que funcione en la clase Car.java la variable passengers deberá estar encapsulada con el modificador de acceso protected para que las subclases tengan acceso a esa variable.

class Car{ //Definición de la clase
    private Integer id;
    private String license;
    private Account driver;
    protected Integer passengers;
import java.util.ArrayList;
import java.util.Map;

class UberVan extends Car{
    
    Map<String, Map<String, Integer>> typeCarAccepted;
    ArrayList<String> seatsMaterial; 

    /* public UberVan(String license, Account driver, 
    Map<String, ArrayList<String,Integer>> typeCarAccepted, ArrayList<String> seatsMaterial){
        super(license, driver);
        this.typeCarAccepted = typeCarAccepted;
        this.seatsMaterial = seatsMaterial;
    } */

    public UberVan(String license, Account driver){
        super(license, driver);
    }

    @Override
    public void setPassenger(Integer passengers) {
        if(passengers == 6){
            this.passengers = passengers;
        }else{
            System.out.println("Necesitas asignar 6 pasajeros");
        }
    }
    
}

Creo que en este punto hay unos conceptos que se pueden confundir, son en especifico 3:

  1. Sobrecarga -> Principalmente con los métodos
  2. Sobre-escritura -> Debe haber herencia, Cuando le cambias el comportamiento a un método que definió la super-clase
  3. Polimorfismo de Subtipado -> Centrado en usar el mimos nombre de método en diferentes clases, cuando se llamen se ejecutara

Daré unos ejemplos de cada uno con python:

Sobrecarga
Según algunos autores se le llamaría polimorfismo de sobrecarga, algunos ni si quiera lo llaman polimorfismo así que lo dejare:

class punto:
    # Nótese que no ninguna clase de herencia
    def __init__(self, x):
        # Creo cualquier método, en este caso el constructor
        self.x = x

    def __init__(self, x, y):
        # Mi primer caso de sobrecarga
        self.x = x
        self.y = y

    def __init__(self, x, y, z):
        # Mi segundo caso de sobrecarga
        self.x = x
        self.y = y
        self.z = z

Como pueden ver puede ser productivo en algunos casos, pero empieza a ser contraproducente cuando se usa demasiado(en el segundo caso por ejemplo).

Sobre-Escritura
Un caso puro de polimorfismo, busca alterar el método de la súper-clase, ya que el comportamiento es diferente

class Ave:
    # Nuestra Super-Clase
    def __init__(self, altura_vuelo):
        self.altura_vuelo = altura_vuelo

    def accion_animal(self):
        # Nuestro metodo a sobre-escribir
        # Obvia que todos volaran
        print("El ave volara a una altura {}".format(self.altura_vuelo))

class Pingüino(Ave):
    # Clase Hija o Sub-Clase
    def __init__(self, altura_vuelo, velocidad_nado):
        # Puse otro parametro para diferenciar un poco el metodo
        super.__init__(self, altura_vuelo) # pongo los metodos de la super-clase
        self.velocidad_nado = velocidad_nado

    def accion_animal(self):
        super.accion_animal()
        # Hagamos que tambien muestre eso
        print("El Ave nadará con una velocidad {}".format(self.velocidad_nado))
        # Tiene Su comportamiento diferente

Realmente muy útil, es l a mejor practica ya que la herencia podrá extender el proceso y si se quiere generar una particularidad se hace una clase

Polimorfismo de sobrecarga
Yo lo llamaría una “mala practica de uso para la sobrecarga”, prefiero usar la herencia y lo sobre-escribo, sin embargo la opción esta ahí

class Pingüino:
    # No hay ningun clase de herencia
    def __init__(self, velocidad_nado, velocidad_correr):
        self.velocidad_nado = velocidad_nado
        self.velocidad_correr = velocidad_correr

    def accion_animal(self):
        # Tengo que definir el mismo nombre
        print("El Ave nadará con una velocidad {} y corre a una velocidad {}".format(self.velocidad_nado, self.velocidad_correr))

class Aguila:
    # No hay ninguna clase de herencia
    def __init__(self, fuerza_garras, velocidad_vuelo):
        self.velocidad_vuelo = velocidad_vuelo
        self.fuerza_garras = fuerza_garras

    def accion_animal(self):
        # Tengo que definir el mismo nombre
        print("El Ave atacara a su victica con una velocidad de {} y una fuerza de {}".format(self.velocidad_vuelo, self.fuerza_garras))

# Cuando se llame se deberia ejecutar el metodo
aves = [Pingüino("100","120"), Aguila("120","300")] # Numeros hipoteticos
for ave in aves:
    ave.accion_animal()

Este ultimo me parece algo innecesario pero que también se puede hacer sin necesidad de heredar.

Otra cosa que de pronto se me escapo pero es porque python al ser débilmente tipado puede hacer de forma natural y es el termino llamado Cohersion, algo que en Java puede compilarse un poco mas.

En los dos últimos temas y tal vez, de lo más relevantes en principios básicos de la OOP (encapsulamiento y polimorfismo) no se hicieron casos prácticos en los otros lenguajes que habíamos venido trabajando.
No a todos nos gusta Java 😦

Polimorfismo: Construir métodos con el mismo nombre pero con comportamiento diferente

Cuiden más las clases. Esta y la anterior se nota la improvisación, y falta de preparación.

🔆 Generando polimorfismo en lenguaje Dart.

import 'account.dart';

class Car {
  int _id;
  String license;
  Account driver;
  int _passenger;

  Car({this.license, this.driver});


  void printDataCar(){
    if(_passenger != null){
      print('License: $license Name Driver: ${driver.name} Passengers: $passenger');
    }
  }

  int get passenger => _passenger;

  set passenger(int value) {
    if(value == 4){
      _passenger = value;
    }else{
      print('Necesitas asignar 4 pasajeros');
    }
  }

  int get id => _id;

  set id(int value) {
    _id = value;
  }
}
import 'car.dart';

class UberX extends Car{
  String brand;
  String model;

  UberX({license, driver, this.brand, this.model}): super(license: license, driver: driver);

  @override
  void printDataCar() {
    super.printDataCar();
    print('Model: $model Brand: $brand');
  }
}
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);

  @override
  set passenger(int value) {
    if(value == 6){
      super.passenger = value;
    }else{
      print('Necesitas asignar 6 pasajeros');
    }
  }
}
import 'account.dart';
import 'uber_van.dart';
import 'uber_x.dart';

void main(List<String> arguments) {
  var uberX = UberX(license: 'AMQ123', driver: Account(name: 'Andres Herrera', document: 'AND123'), brand: 'Chevrolet', model: 'Sonic');
  uberX.passenger = 4;
  uberX.printDataCar();

  var uberVan = UberVan(license: 'FGH345', driver: Account(name: 'Andres Herrera', document: 'AND123'));
  uberVan.passenger = 6;
  uberVan.printDataCar();
}

Polimorfismo significa que un solo método puede tener un número de implementaciones diferentes.

Deja mucho que desear que se tenga en todo el código la palabra Passenger escrita de dos maneras y la instructora no lo mencione, también deja mucho que desear que cuando quieren aplicar polimorfismo a la clase uberVan no mencionen que el modificador de acceso private en la variable Passenger generara conflictos por que la subclase uberVan no podrá acceder a ella, si una persona no coloca un comentario diciendo que el modificador de clase correcto es protected me quedo patinando en ese problema.

En UberVan sobreescribi:

@Override
public void setPassenger(Integer passenger) {
    if(passenger == 6){
        super.passenger = passenger;
    }
}

Para poder modificar la cantidad de pasajeros sin tener que crear otro atributo protected Integer passenger; asi las clases hijas pueden modificar su valor

Estoy de acuerdo con @cesar-de-la-lima, puse las vacilaciones en las clases hijas: UberX, UberBlack, UberVan, UberPool.

Car:

public void setPassengers(Integer passengers){
        
        this.passengers = passengers;
    }

UberX, UberBlack, UberPool:

@Override
    public void setPassengers(Integer passengers) {
        
        if(passengers == 4){
            super.setPassengers(passengers);
        }else{
            System.out.println("UberVan needs 4 passengers assigned");
        }
    }

UberVan:

@Override
    public void setPassengers(Integer passengers) {
        
        if(passengers == 6){
            super.setPassengers(passengers);
        }else{
            System.out.println("UberVan needs 6 passengers assigned");
        }
    }

Y de esta forma no tube que aggregar la variable passengers a UberVan.

Al final sigue sin gustarme PHP 😦

Creo que se puede mejorar esta clase terminando el ejercicio, ambos conceptos (polimorfismo y encapsulamiento) dan para mucho. No se terminan de desarrollar los conceptos y pienso que terminando el ejercicio de este vídeo se podría entender mejor, abajo dejo el código funcional para el ejercicio, puesto que como esta en el vídeo no funciona la mitad. (Utilizo uberpool como si fuera uberVan por practicidad).

uberX

class UberX extends Car
{
    String brand;
    String model;
    Integer passenger;

    public UberX(String license, Account driver, String brand, String model)
    {
        super(license, driver);
        this.brand = brand;
        this.model = model;
    }
    @Override
    public void setPassenger(Integer passenger) 
    {
        if(passenger == 4)
        {   
            super.setPassenger(passenger);
            this.passenger = passenger;
        }
        else
        {   
            passenger = null;
            System.out.println("Debes selecionar 4 asientos");
        }
    }
    @Override
    void printCarResults() 
    {
        if( passenger == 4)
        {
            super.printCarResults();
            System.out.println("El modelo: " + model + "\nLa marca es: " + brand);
        }
    }
}

Pool que lo uso cono Van para este ejemplo

class UberPool extends Car
{
    String brand;
    String model;
    Integer passenger;

    public UberPool(String license, Account driver, String brand, String model)
    {
        super(license, driver);
        this.brand = brand;
        this.model = model;
    }
    @Override
    public void setPassenger(Integer passenger) 
    {
        if(passenger == 6)
        {   
            super.setPassenger(passenger);
            this.passenger = passenger;
        }
        else
        {   
            passenger = null;
            System.out.println("Debes selecionar 6 asientos");
        }
    }
}

Main

class Main
{
    public static void main(String[] args) 
    {
        System.out.println("Mi primer linea en Java\n");

        UberX uberX = new UberX("DNS786", new Account("Dario Arcos", "12345"),"Renault\n", "Logan");
        UberPool uberPool = new UberPool("FPA123", new Account("Felipe", "12345"),"audi", "A7");
        uberX.setPassenger(4);
        uberPool.setPassenger(6);
        uberPool.printCarResults();
        uberX.printCarResults();
    }
}

¿Soy el unico que se ha dado cuenta que a la profesora no le imprimió uber van?

Ahora veo porque tanta bronca para imprimir uber van ni a la profa le salio jajajaja




Así Sobrescribí en Python el method setPassenger en la clase UberVan para aplicar polimorfismo según la lógica de negocio para UberVan:

# Super class or class Father
from car import Car

class UberVan(Car):
    """class UberVan instance, herencia"""
    typeCarAccepted = []
    seatsMaterial = []

    # Override method constructor of super class Car
    def __init__(self, license, driver, typeCarAccepted, seatsMaterial):
        super().__init__(license, driver)
        self.typeCarAccepted = typeCarAccepted
        self.seatsMaterial = seatsMaterial

    # Override method setPassenger of super class Car for apply Polyomorphs
    def setPassenger(self, passenger):
        if passenger == 6:
            self.setPassenger = passenger
        else:
            print("You need yo assign 6 passengers")

Faltó la clase de Encapsulamiento en Python y JavaScript… es una lástima… solo se usarlo en Python pero si queria saber como se hacia en JavaScript…

Java me parece un lenguaje genial cubre todos los conceptos de la POO y los implementa de una manera sencilla. El polimorfismo nos dara el super poder de hacer metodos generales y especializarlos si es necesario en las clases hijos. Esto se pone mas interesante con las clases abstractas.

Extension Getter and Setter aqui con su explicacion de uso.

Dejo repositorio del curso por si se quiere recordar sobre algun concepto
POO

muy mal explicacion de practicamente todo. decepcionante, toca terminar buscando en otro lado porque este curso deja mucho que desear

me hubiera gustado saber como se hace en Python :\ he quedado medio decepcionada de este curso. Demasiados lenguajes confunden y no permiten profundizar.

Al sobrescribir un método es pieza clave de un polimorfismo.

Para completar la explicación. Se tiende mucho a confundir, sobrecarga de métodos con polimorfismo. Por lo que hay que tener en cuenta que:

  1. La sobrecarga hace referencia a un conjunto de métodos con el mismo nombre pero que van a comportarse de manera diferente. ( misma definición dada por la profesora ). Sin embargo estos métodos se encuentran definidos en la misma clase y tienen diferente número de parámetros de entrada.
  2. El polimorfismo hace referencia a un conjunto de métodos **con el mismo nombre e igual número de parámetros con comportamiento desigual ** PERO definidos en diferentes clases. El polimorfismo busca alterar el comportamiento de la superclase.

Es cuando haces código que sea general.

Cada vez, me enamoro mas de VScode 😍

Por fin vi el error de Array xD

Lo que aun no sé, es por qué no hizo las clases que serán heredadas (es decir las clases padres) como Abstract?. Creo que ha hecho falta explicar eso si se habla de herencia y polimorfismo.

Excelente clase, en resumen el polimorfismo abarca tener un método que se comparte entre clases pero que hace acciones diferentes en cada una de ellas.

Polimorfismo Es una característica que nos brinda la herencia en la cual nos ayuda a invocar métodos de un objeto sin necesidad de indicar directamente qué tipo de clase es (definición mía, creo que me falta desarrollarla, me pueden ayudar).
En cuanto a las definiciones que se mencionan en este video, creo que son poco acertadas, la primera que dice es la de “…construir métodos con el mismo nombre…”, pero eso es sobrecarga, y la otra es la de “…cambiar el comportamiento de métodos…” pero eso es sobre escritura. Me pueden ayudar por favor.

Leí este comentario mucho más abajo, recoemndado.

“Interesante, pero tuviste que sobrescribir el mismo metodo de printDataCar() en UberX, UberPool y UberBlack, podemos ahorrarnos eso, cambiando primero la propiedad passenger a protected, así esta podrá ser seteada desde las clases hijas, lo que quiere decir que no tengo que agregar la variable passenger en las otras clases, haciendo que solo en UberVan tenga que hacer polimorfismo para el printDataCar().”
-Keneth andrés Chugandro-

Y el vídeo de “Polimorfismo en PHP”, al final del vídeo Anahí hace mención que la siguiente clase se verá la aplicación de polimorfismo en PHP, pero resultó ser que la siguiente clase es una recapitulación del diagrama de clases que se elaboró en este proyecto

UberVan.java

<import java.util.ArrayList;
import java.util.Map;

class UberVan extends Car {
    Map<String, Map<String,Integer>> typeCarAccepted;
    ArrayList<String> seatsMaterial;
    
    public UberVan(String license, Account driver){
        super(license, driver);

    }

    
    public UberVan(String license, Account driver, 
    Map<String, Map<String,Integer>> typeCarAccepted,
    ArrayList<String> seatsMaterial){
        super(license, driver);
        this.typeCarAccepted = typeCarAccepted;
        this.seatsMaterial = seatsMaterial;
    }


    @Override
    public void setPassenger(Integer passenger) {
        if(passenger == 6){
        super.passegenger = passenger;
            }else{
                System.out.println("Necesitas asignar 6 pasajeros");
            }
        }
  
}>

Car.java

<class Car {
    private Integer id;
    private String license;
    private Account driver;
    protected Integer passegenger;

    public Car(String license, Account driver){
        this.license = license;
        this.driver = driver;
        
    }

    void printDataCar() {
        if(passegenger != null){
            System.out.println("License: " + license + " Name Driver: " + driver.name + " Passengers: " + passegenger);
        }
        
    }


    public Integer getPassenger(){
        return passegenger;
    }

    public void setPassenger(Integer passenger) {
        if(passenger == 4){
            this.passegenger = passenger;
        }else{
            System.out.println("Necesitas asignar 4 pasajeros");
        }
    }

    /**
     * @return the id
     */
    public Integer getId() {
        return id;
    }

    /**
     * @param id the id to set
     */
    public void setId(Integer id) {
        this.id = id;
    }

    /**
     * @return the license
     */
    public String getLicense() {
        return license;
    }

    /**
     * @param license the license to set
     */
    public void setLicense(String license) {
        this.license = license;
    }

    /**
     * @return the driver
     */
    public Account getDriver() {
        return driver;
    }

    /**
     * @param driver the driver to set
     */
    public void setDriver(Account driver) {
        this.driver = driver;
    }

    
}>

Finalmente entendí lo siguiente:

Poliformismo: “Sobreescribir un metódo de la Clase Padre para darle un comportamiento diferente”

La única solución correcta que vi en los comentarios es sacar la validación de cars, y validar en cada subclase (UberX, UberPool, etc.). La solución más votada que propone encapsular passengers como protected, es incorrecta, porque eso permite que desde el Main uno pueda asignarle el valor que quiera directamente, sin necesidad de usar un setter.

En conclusión, el polimorfismo es cambiar la estructura o el comportamiento de un método que proviene de una clase padre.

Se corto el audio F

me quedo mucho mas claro el polimorfismo gracias n,n

En Visual Studio Code, presionando ALT + Z activas el text word wrap. Así no necesitarás hacer scroll de lado a lado para ver donde termina la línea de código… Pruébenlo, es útil!

Si no imprime el uberVan.
Debes borrar la variable passenger en uberVan.java y cambiar a protected en Car.java

genial

sobre escribir una cosa = polimorfismo

Excelente!!

Bien explicado este tema, le agradezco Ann

dos puntos por terminar de ver el video :v

Un método que se comparte entre muchas clases, y cada clase le da un comportamiento diferente

El polimorfismo ayuda mucho en cuanto a comportamiento que se quieren dar a una clase

Asi quedaria nuestra clase uberVan despues de la herencia y el polimorfismo aplicado.

package Java;

import java.util.ArrayList;
import java.util.Map;

//HERENCIA DE CLASE Car
class UberVan extends Car {

    Integer passenger;

    Map<String, Map<String,Integer>> typeCarAceepted;
    ArrayList<String> seatsMaterial;

    //METODO CONSTRUCTOR CON HERENCIA y ATRIBUTOS PROPIOS
    public UberVan (String license, Account driver/*,
                    Map<String, Map<String,Integer>> typeCarAceepted, ArrayList<String> seatsMaterial*/)
    {
        super(license, driver);
        /*
        this.typeCarAceepted = typeCarAceepted;
        this.seatsMaterial = seatsMaterial;*/
    }

    //POLIMORFISMO
    @Override
    public void setPassenger(Integer passenger) {

        if(passenger == 6){
            this.passenger = passenger;
        }else{
            this.passenger = 0;
        }
    }

    @Override
    void printCar() {
        if(this.passenger == 6){
            System.out.println(" la licencia del carro es " + license + " y el conductor es " + driver.name +" "+"y la cantidad de pasajeros son: "+this.passenger);
        }else{
            System.out.println("Ingrese una cantidad de pasajeros valida para uber van");
        }
    }

}

Yo me pregunto quién es Andrés Herrera y por qué maneja tantos autos…

Bueno, esto seria mas o menos asi.
Python.

from car import Car
#Agregando componentes a la clase.
class uberX(Car):
    brand = str
    model = str
    
    #__init__ inicializa la funcion para jalar datos desde la clase padre (herencia).
    def __init__(self, licence, driver, brand, model):
        super().__init__(licence, driver)
        self.brand = brand
        self.model = model
        
    # Override method setPassenger of super class Car for apply Polyomorphs
    def setPassengers(self, passengers):
        if passengers == 4:
            self._passengers = passengers
        else:
            print("You need yo assign 4 passengers")
from car import Car

class uberVan(Car):
    typeCarAccepted = [] # ya que esto sera un listado, Array
    seatsMaterial =[] #Materiales aceptados.
    
    #__init__ inicializa la funcion para jalar datos desde la clase padre (herencia).
    def __init__(self, licence, driver, typeCarAccepted, seatsMaterial):
        super().__init__(licence, driver)
        self.typeCarAccepted = typeCarAccepted
        self.seatsMaterial= seatsMaterial
        
        
    def setPassengers(self, passengers):
        if passengers == 6:
            self._passengers = passengers
        else:
            print("You need yo assign 6 passengers")
from account import Account

class Car:
    id          = int
    licence     = str
    driver      = Account(str, str)
    _passengers  = int #protegiendo atributos.

#usando los valores de la clase, y llamar las caracteristicas usando self
    def __init__(self, licence, driver):
        self.licence = licence
        self.driver = driver
    

    def getPassengers(self):
        return self._passengers
    

    def setPassengers(self, a):
        self._passengers = a


    def delPassengers(self):
        del self._passengers
    
    passgenger = property(getPassengers, setPassengers, delPassengers) 
    
    def printCar(self):
        if type(self).__name__ == "uberX":
            print("*"*32)
            print("id : {}\nlicence: {}".format(self.id, self.licence))
            print("Name: {}\nlicence: {}".format(self.driver.name, self.driver.Document))
            print("Marca: {}".format(self.brand))
            print("Modelo: {}".format(self.model))
            print("Pasajeros: {}".format(self._passengers))
            print("*"*32)
            print("")
        elif type(self).__name__ == "uberVan":
            print("*"*32)
            print("id : {}\nlicence: {}".format(self.id, self.licence))
            print("Name: {}\nlicence: {}".format(self.driver.name, self.driver.Document))
            print("Modelo: {}".format(self.typeCarAccepted))
            print("Material : {}".format(self.seatsMaterial))
            print("Pasajeros: {}".format(self._passengers))
            print("*"*32)
            print("")
        else:
            print("No cumple con los valores.")

Hey Guys! He creado un grupo de whatsapp para Developers (Programadores) para poder ayudarnos principalmente con dudas sobre código y cosas por el estilo. Queremos que sea un grupo pequeño y poder ayudarnos entre todos a entender un poco mejor el mundo de la programación. Los espero!🎉✨

https://chat.whatsapp.com/EwdTZOH2IdHEgORO3BCIWi

Esta es una explicación para python

https://www.youtube.com/watch?v=1J9bCm2J8wU

Polimorfismo en Java, vamos con los otros lenguajes …

El uso de polimorfismo nos abre a las posibilidades de utilizar esos métodos de igual nombre pero distinto fin, se pueden utilizar en un sin fin dé aplicaciones.

Sobre-carga: mismo método pero con diferentes parámetros (cantidad)
Sobre-escritura: redefines un método que heredas de la clase padre.
Polimorfismo: clases hijas implementando de forma diferente un método heredado de la clase padre, y para su uso se usa un objeto de tipo del padre.

sus opiniones…

Que es el polimorfismo: Dentro de las reglas de POO, este concepto se refiere a la capacidad de tomar mas de una forma, una operacion puede tomar diferentes comportamientos y instancias y el comportamiento se define mediante al tipo de dato de la operacion.

PO LI MOR FIS MO.

Se podria corregir el resultado del else en el archivo Ubervan.java
Ya que a asignar pasajeros diferentes a 6, nos devolverá el mensaje de “Necesitas asignar 4 pasajeros” lo que puede confundir.
Deberia decir asi “Necesitas asignar 6 pasajeros”.

Quedo mas que claro el concepto, Gracias!

**Polimorfismo: **
Nos permite construir nombres con el mismo nombre, pero con comportamiento diferente.

Clase padre Car.java

Clase hija Uberx.java

Polimorfismo en programación: Muchas formas.
Construir métodos con el mismo nombre pero con distinto
comportamiento.
O sea, se cambia la estructura o el comportamiento de
un método que proviene de una clase padre.

Concepto de polimorfismo. 2'15"

Solo diré que: polimorfismo != sobreescritura de métodos

El polimorfismo está muy ligado a la herencia

para los que tuvieron problemas con la clase UberVan esta es mi solucion:
1- en la clase Car modifiqué el metodo setPassenger para que revisará que no fuera un campo null

2- en la clase uberVan puse la condicion de que fuera solo 6 el parametro de passenger y en caso de serlo que lo enviara al metodo en la clase Car

3- lo mismo con uberX

4- por ultimo el Main:

Sinceramente, estos errores y desprolijidades le bajan la calidad a la plataforma. Deberían chequear antes de publicar un curso, y tener mayor participación de los profesores en los comentarios, para aclarar estas cosas.

De acuerdo con el polimorfismo, es mejor dejar que el setPassenger dentro de la clase Car solo asigne el valor pasado sin validaciones. Estas validaciones se harían dentro de las clases de Uberx, UberBlack y UberVan. Junto con la solución del profe Miguel Torres

public class Car {
    private Integer id;
    private String license;
    private Account driver;
    protected Integer passengers;

    public Car(String license, Account driver){
        this.license = license;
        this.driver = driver;
    }

    public void setPassenger(Integer passengers){
        this.passengers = passengers;
    }
}
public class UberX extends Car{
    String brand;
    String model;

	public UberX(String license, Account driver, String brand, String model) {
        //Referencia a los metodos y atributos de la clase padre
		super(license, driver);
        this.brand = brand;
        this.model = model;
	}

    @Override
    public void setPassenger(Integer passengers) {
        if(passengers == 4) {
            super.setPassenger(passengers);
        } else {
            System.out.println("Necesitas asignar 4 pasajer al UberX");
        }
    }
}
public class UberVan extends Car{
    Map<String, Map<String, Integer>> typeCarAccepted;
    ArrayList<String> seatsMaterial;

	public UberVan(String license, Account driver) {
		super(license, driver);
	}

	@Override
	public void setPassenger(Integer passengers) {
		if (passengers == 6) {
			super.setPassenger(passengers);
		} else {
			System.out.println("Necesitas asignar 6 pasajer al UberVan");
		}
	}
}

Se debe de observar que al principio se modifica la clase car eliminado el map y luego vuelve a su estado original, lo otro como dicen en otros comentarios

la clase debe de iniciar así, de lo contrario genera errores

public class Car {
private Integer id;
private String license;
private Account driver;
protected Integer passenger;

lo otro dentro de la clase ubervan
private Interger passanger no va

Supongo que estos temas(al menos las ultimas clases) no los están explicando tan a profundidad con Python y Javascript ya que hay cursos especializados de POO para estos lenguajes al menos en JS en la ruta de desarrollo web es así, no se si en otras escuelas habrán mas cursos de POO para java y php, y por eso se enfocan en lo practico en estos lenguajes, mientras que en los otros te lo explican de manera mas teórica para tener una noción y ya en los cursos especializados aplicarlos, aunque si bien podrán tener parecidos estos lenguajes, entender los 4 de la sola para alguien que recién empieza podría resultarle confuso, por eso yo simplemente trato de enfocarme en JS. Saludos

muyyyyy buena claseeeeeee 😄

Mi aporte en Java

RESUMEN DE LOS CONCEPTOS MÁS IMPORTANTES DE POO

  1. Abstracción: Construir un objeto de nuestro entorno en programación.
  2. Herencia: Dar atributos y métodos de una superclase a subclases.
  3. Encapsulamiento: Hacer no visibles atributos que pueden ser “sensibles” o delicados.
  4. Polimorfismo: Modificar un método heredado de una clase padre según la conveniencia de la clase hija.

😄 Que milagro que Java no me dio Error uff 😄

El polimorfismo en POO está muy ligado a las interfaces, pero de acuerdo a la lista de videos, creo que no vieron eso en este curso. Mal ahí ya que es la mejor forma de demostrar cómo programar contra una abstracción.

Polimorfismo es cuando un método se comparte entre varias clases y cada una de estas le da el comportamiento que ella desee.

Hola me quedo de esta manera.

No hay caso. No me funciona el método printDataCar() cuando sobreescribo el método setPassenger. Me rindo.

Hay que modificar el atributo passegenger a protected, para que se pueda acceder desde todas las clases heredadas, de ahí solo dejó el codigo con las 3 diferentes formas en las que puedes asignar un valor a passegenger.

import java.util.ArrayList;
import java.util.Map;

classuberVanextendsCar
{
    Map<String, Map<String, Integer>> TipoCarroAceptado;
    ArrayList<String> MaterialDeAciento;
    //private Integer passenger;

    public uberVan(String licenseUv, Account driverUv)
    {
        super(licenseUv, driverUv);
       // this.TipoCarroAceptado = TipoCarroAceptadoUv;
       // this.MaterialDeAciento = MaterialDeAcientoUv;
    }


    @Override
    public void setPassenger(Integer passengerUV) 
    {
        if(passengerUV <= 6)
        {
            this.passgenger = passengerUV;
         // super.passenger = passengerUV;  
         // this.passenger = passengerUV;  
        }
        else
        {
            System.out.println("¡Rebasaste el maximo permitido de pasajeros! \n\n");
        }
    }
}

Diferencia de saturaciones:

  • Sobrecarga -> Principalmente con los métodos

  • Sobre-escritura -> Debe haber herencia, Cuando le cambias el comportamiento a un método que definió la super-clase

  • Polimorfismo de Subtipado -> Centrado en usar el mimos nombre de método en diferentes clases, cuando se llamen se ejecutara

ooooooooo

Polimorfismo en python:

https://youtu.be/kV1cN_bqcSw

Polimorfismo = sobre carga en metodos 😃

Aunque no es parte de la clase, en algunas clases también se le llama polimorfismo a la capacidad de las clases hijas de heredar de varias clases padres, , aunque también se le suele llamar herencia múltiple dependiendo de quien lo utilice y en que lenguaje. un nombre que se entiende mucho mas y tal vez por eso sea el mas común, esto en Java por ejemplo se suele implementar por medio de interfaces que son parecidas a clases abstractas.

De haber sabido que era enfocado para Java, no lo hubiera visto.

Vengo del pasado, a ver que edite el Map.

Concuerdo con los comentarios de los compañeros. Si al inicio del curso, nos comentaron que se iban a ver todas las formas en 4 lenguajes diferentes. Debieron respetar eso en todo el curso.

Al final se siente como si le hubiera dado flojera seguir con los ejemplos de los demas lenguajes.

Otro punto que me gustaria resaltar es que la profesora tiene algunos errores en su codigo. Entiendo que debemos ser capaces de reconocer errores y solucionarlos, pero se supone que se deberian reconocer y solucionar en clase.

Tengo entendido que el ejemplo es sobreescitura de métodos más que polimorfismo.

Una pregunta, porque debe agregarse un nuevo atributo a la clase UberVan? acaso este atributo no fue heredado ya desde Car? esta parte no me quedo muy clara 😕

Resumen:
Poliformismo: Muchas Formas
Construir métodos con el mismo nombre pero con comportamiento distinto
Ventaja: las clases pueden compartir atributos entre ellas

Ejemplo donde se plasma el concepto de herencia y polimorfismo en Python:

class Vehiculo:

    #Metodo constructor
    def __init__(self, marca, modelo):
        self.marca = marca
        self.modelo = modelo
        self.enmarcha = False
        self.acelera = False
        self.frena = False

    def arrancar(self):
        self.enmarcha = True

    def acelerar(self):
        self.acelera = True

    def frenar(self):
        self.frena = True

    def estado(self):
        print(
            "Marca: ", self.marca, 
            "\nModelo: ", self.modelo, 
            "\nEn marcha: ", self.enmarcha, 
            "\nAcelerando: ", self.acelera, 
            "\nFrenando: ", self.frena
            )

# Hereda de Vehiculo
class Furgoneta(Vehiculo):

    def carga(self, cargar):
        self.cargado = cargar
        if self.cargado:
            return "La furgoneta esta cargada"
        else:
            return " La furgoneta no esta cargada"


# Hereda de Vehiculo
class Moto(Vehiculo):
    hcaballito = ""
    def caballito(self):
        self.hcaballito = "Voy haciendo el caballito"

    # Polimorfismo (Sobreescribiendo el metodo estado)
    def estado(self):
        print(
            "Marca: ", self.marca, 
            "\nModelo: ", self.modelo, 
            "\nEn marcha: ", self.enmarcha, 
            "\nAcelerando: ", self.acelera, 
            "\nFrenando: ", self.frena, 
            "\n", self.hcaballito
            )


class VElectricos(Vehiculo):
     # Sintaxis si queremos añadir más atributos default
     # al constructor padre en la clase hija
    def __init__(self, marca, modelo):
        super().__init__(marca, modelo)
        self.autonomia = 100

    def cargarEnergia(self):
        self.cargando = True
        print("Cargando energía: ", self.cargando)

#Sintaxis de herencia multiple. BicicletaElectrica hereda de VElectricos y Vehiculo
#La herencia toma como prioridad la primera clase nombrada, de esta forma hay que 
#contruir un objeto con el constructor de esta primera clase de la que hereda.  
class BicicletaElectrica(VElectricos, Vehiculo):
    pass


print("Creando primer objeto")
miMoto = Moto("Honda", "CBR")
miMoto.caballito()
miMoto.estado()

print("                   ")
print("Creando segundo objeto")
miFurgoneta=Furgoneta("Renault", "Kango")
miFurgoneta.arrancar()
miFurgoneta.estado()
print(miFurgoneta.carga(True))

print("                   ")
print("Creando tercer objeto")
miBici = BicicletaElectrica("Orbea", "hk1")
miBici.estado()
miBici.cargarEnergia()
class VElectricos(Vehiculo):
     #  si queremos añadir más atributos pasados como parametros
  
    def __init__(self, marca, modelo, autonomia):
        super().__init__(marca, modelo)
        self.autonomia = autonomia

#Instanciando la clase
miBici = BicicletaElectrica("Orbea", "hk1", 90)

I made an example with Minecraft, stating that all blocks (e.g. DirtBlock) extend from an abstract class called “MotherBlock”:
Abstract class in java can’t be instantiated. An abstract class is mostly used to provide a base for subclasses to extend and implement the abstract methods and override or use the implemented methods in an abstract class.

Now for example, if we have a class called MotherBlock.java like the one that follows:

public class MotherBlock {

	private int width = 0;
	private int length = 0;

	public MotherBlock(int width, int length) {
		this.width = width;
		this.length = length
	}
}

And is extended to many classes like the class DirtBlock.java:

public class DirtBlock extends MotherBlock {
	
	public DirtBlock(int width, int length) {
		super(width, lenght)
	}

	//some methods...
}

And as you might have already guessed, you will never create a MotherBlock instance, since it’s only the mold for other blocks like the DirtBlock. Because of that, it’s recommended to set it as an abstract class. So it will look like this at the end:

public abstract class MotherBlock {

	private int width = 0;
	private int length = 0;

	public MotherBlock(int width, int length) {
		this.width = width;
		this.length = length
	}
}

Abstract classes can’t be instantiated, however we can create an instance from the abstract super class that takes the “shape” of a child class.

//from DirtBlock.java
MotherBlock testBlock = new DirtBlock(12, 231);

The above is the same as saying:

//from DirtBlock.java
DirtBlock testBlock = new DirtBlock(12, 231);

El polimorfismo es construir métodos con el mismo nombre pero con comportamientos diferentes.

el setPassenger no saldra ya que no estamos guardando la variable dentro de de la clase padre(super) por eso no esta imprimiendoles el mensaje. si quieren que les imprima el mensaje tiene que sacar el private de la variable passenger para que poderla llamar desde la clase uberVan y guardar el dato que le damos en el main a uberVan. asi lo tengo:

clase UverVan

 @Override
    public void setPassegenger(int passegenger) {
        
        if(passegenger == 6){
            
            super.passegenger = passegenger;
        }else{
            System.out.println("No coincide con lo rquerido");
        }
    }

clase Car

public class Car {
    private int id;
    private String license;
    private Account driver;
    int passegenger;

y el main

UberVan uberVan = new UberVan("KLSJ", new Account("jon", "12354"));
        uberVan.setPassegenger(6);
        uberVan.printDataCar();

y lo que me impime es esto

the license es: KLSJ and driver is: jon Passengers 6

Una manera de como lo resolvi fue con un passangerLimit, y ya es solo de settearlo en el constructor.

car . java

package Java;

public class Car {
    private Integer id;
    private String license;
    private Account driver;
    private Integer passanger;

    Integer passangerLimit;

    // Constructor
    public Car(String license, Account driver) {
        this.license = license;
        this.driver = driver;
        
        this.setPassangerLimit(4);

        
    }

    void printDataCar() {
        System.out.print("License: " + license + " Driver: " + driver.name);

        if(this.passanger != null) {
            System.out.println(" Passangers: " + passanger);
        }
    }

    public Integer getPassenger() {
        return passanger;
    }

    public void setPassenger(Integer passenger) {
        if (passenger == passangerLimit) {
            this.passanger = passenger;
        }
        else {
            System.out.println("Error: Necesitas de " + this.getPassangerLimit() + "pasajeros");
        }
        
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getLicense() {
        return license;
    }

    public void setLicense(String license) {
        this.license = license;
    }

    public Account getDriver() {
        return driver;
    }

    public void setDriver(Account driver) {
        this.driver = driver;
    }

    public Integer getPassangerLimit() {
        return passangerLimit;
    }

    public void setPassangerLimit(Integer passangerLimit) {
        this.passangerLimit = passangerLimit;
    }

    
}

uberX . java

package Java;

public class UberX extends Car {

    String brand;
    String model;

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

    @Override
    void printDataCar() {
        // TODO Auto-generated method stub
        super.printDataCar();
        System.out.println("Modelo: " + model + " Brand: " + brand);
    }
    
}

uberVan . java

package Java;

import java.util.ArrayList;
import java.util.Map;

public class UberVan extends Car {

    Map<String, Map<String, Integer>> typeCarAccepted; 
    ArrayList<String> seatsMaterial;

    String brand;
    String model;

    public UberVan(
        String license, 
        Account driver 
        ) {
            super(license, driver);
            this.setPassangerLimit(6);
    }
    
}

Si estan usando IntelliJ, den clic derecho, den clic en generate y clic en getter and setter y pueden seleccionar sus datos y listo!
Ojalá les ayude

Muchas gracias Todo Entendido

Definicion de polimorfismo.

Esta es una buena clase para entender el polimorfismo

Excelente clase de polimorfismo.
Es construir métodos con el mismo nombre pero con comportamiento diferente

Qué fenomenal lo explicaste Ann!