No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

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 186

Preguntas 29

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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 😦

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

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

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.

🔆 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();
}

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

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

¿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

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.

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…

Ya llegaste hasta aca, no te rindas!
falta poco!

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();
    }
}

El curso empieza a distorsionarse mucho en estas últimas clases, por ejemplo:

  • No terminan explicando los 4 lenguajes con los que empezaron
  • Los conceptos de encapsulamiento y polimorfismos tienen pocos ejemplos y no dejan claridad con las diferencias entre modificadores de acceso

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")

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:

Extension Getter and Setter aqui con su explicacion de uso.

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.

este curso me deja muchisimo que desear, lo estoy tomando antes de empezar a estudiar JS a profundidad para tener bases de POO pero me estoy quedando igual que como comencé y esta es la clase 33. Lo voy a terminar meramente por el titulo porque no me apetece perder varias horas de mi tiempo pero no lo recomiendo.

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-

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

Vengo de el curso de Django, el profesor facundo dijo que primero debiamos tomar este curso para empezar con django y la verdad es que me molesta mucho que en la clase de encapsulamiento y en esta no hay información ni video de como ejecutar estas cosas en python, de tener que ir a youtube para ver como hacerlo

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

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

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

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

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

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.

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

Debido a que la profe omitio (hasta el momento) la forma de pasar los argumentos de uberVan los que exigian typeCarAccepted y seatsMaterial les dejo un ejemplo de la creacion completa de una instancia de UberVan sin omitir estas partes:

Map<String, Map<String, Integer>> typeCarAccepted = new HashMap<>();
        Map<String, Integer> carsByType = new HashMap<>();
        carsByType.put("Sedan", 3);
        carsByType.put("SUV", 5);
        typeCarAccepted.put("Toyota", carsByType);

        // Creación de una lista de materiales de asientos
        ArrayList<String> seatsMaterial = new ArrayList<>();
        seatsMaterial.add("Leather");
        seatsMaterial.add("Fabric");

        UberVan firstVan = new UberVan("uri45", new Account("juan", 34673, "[email protected]", "miclave123"), typeCarAccepted, seatsMaterial);

mm creo que se corta el video y no se entiende el ultimo pedazo, aunque para los que saben esto no es un problema
podria llegar a confundir a algunos

polimorfismo! nueva palabra favorita!

Deja bastante que desear este curso… creo que se debería analizar como explicar mejor los conceptos y tener mejor organización. Espero que no todos los cursos sean iguales

Vengo del pasado, a ver que edite el Map.

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.

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.")

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

Se me ha dificultado comprender el curso, al momento de codificar Anahí explica muy rápido, teclea y cambia muy rápido entre pantallas.

Quien es el encargado de hacer el control sobre las clases al final termine en java que python mal ahi

Polimorfismo cambiar la estructura o el comportamiento que viene de una clase padre

Al sobreescribir un metodo en este caso en Java estamos aplicando Polimorfismo con la Palabra reservada @Override

Polimorfismo: Significa muchas formas y sirve para construir metodos con el mismo nombre pero con direrente comportamiento

Creo que aquí ya termina el curso 😅 Hasta a la profe le salió mal el código y no me voy a poner a gastar de más tiempo en un language que por el momento usare.

@override --> indica que se esta sobreescribiendo

Generando Polimorfismo en Java

El polimorfismo es la capacidad de los objetos de una misma familia (herencia) de responder a un mismo mensaje, pero de forma diferente.

En Java, para generar polimorfismo debemos hacer uso de la sobreescritura de métodos (override) en las clases hijas.

Para entenderlo mejor, tomemos como ejemplo el siguiente código:


public class Vehicle {
    public void move() {
        System.out.println("Moving...");
    }
}

public class Car extends Vehicle {
    @Override
    public void move() {
        System.out.println("Driving on the road...");
    }
}

public class Bicycle extends Vehicle {
    @Override
    public void move() {
        System.out.println("Riding on the bike lane...");
    }
}


En este ejemplo, tenemos la clase padre Vehicle y dos clases hijas Car y Bicycle, que heredan el método move() de la clase padre. Sin embargo, cada una de las clases hijas sobrescribe el método move() con su propia implementación.

Ahora, si creamos un objeto Vehicle y lo asignamos a una variable de tipo Vehicle, podemos llamar al método move() sin saber de antemano de qué clase hija se trata:


Vehicle vehicle1 = new Car();
vehicle1.move(); // Salida: Driving on the road...

Vehicle vehicle2 = new Bicycle();
vehicle2.move(); // Salida: Riding on the bike lane...


En este ejemplo, se genera polimorfismo al llamar al mismo método move() en diferentes objetos de la familia Vehicle, pero obteniendo diferentes resultados según la implementación que haya sido sobrescrita en cada clase hija.

Es importante tener en cuenta que para generar polimorfismo en Java, el método sobrescrito debe tener la misma firma (nombre y parámetros) que el método de la clase padre. Además, se debe utilizar la anotación @Override para indicar que se está sobrescribiendo un método de la clase padre.

En general, un curso sumamente confuso; por querer abarcar 4 lenguajes terminaron descuidando Python. Deberían pensar en las personas que hasta ahora estamos comenzando en estos temas!

Polimosfismo: Comportaminetos diferentes, asociados a objetos diferentes pueden compartir el mismo nombre. De esta forma reutilizan el comportamiento correspondiente al objeto que se esta usando.

Otra definición de polimorfismo es contruir metodos con el mismo nombre pero con comportamiento diferente.

Polimorfimso: Metodo que se comparte entre muchas clases. Cada clase le da el comportamiento que desea.

Polimosrmismo significa muchas formas.

Ejemplo de polimorfismo

Recordatorio: importar las clases ArrayList y Map

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

Yo tardé un rato y me seguía marcando error el map

sonaba tan difícil la palabra y con la explicación es más fácil de lo que parecía, hay que practicar eso si.

Ya para este punto creo que ya se abandono Python. Pero para los interesados, en Python es lo mismo que Java, pero no existe el decorador @Override (al menos no para esto) ni tampoco hay que poner nada en especial. Simplemente se sobrescriben los métodos.

Aquí hay algunos puntos importantes a tener en cuenta sobre el polimorfismo en Java:

  • El polimorfismo permite que un objeto adopte diferentes formas según la clase a la que pertenezca o la interfaz que implemente.

  • El polimorfismo se puede lograr a través de la herencia, la implementación de interfaces y el uso de clases abstractas.

  • El polimorfismo se puede utilizar para crear código más genérico y reutilizable. Por ejemplo, podemos tener una lista de objetos de diferentes clases que implementan la misma interfaz, y luego podemos tratar a todos ellos de manera uniforme a través de la interfaz.

Curso de JAVA.

Yo decidí utilizar otra restricción distinta a la de que solo se pueden subir 4 pasajeros (cosa que me parece poco lógica). En este código:

  • Máximo se pueden subir 4 pasajeros
  • Se tiene que subir alguien para que el setter sea válido
class Car{
    //private Integer id;
    private String license;
    private Account driver; //we change string type var for account class due to Driver is subclass of Account (heritage)
    private Integer passenger;

    //Constructor method
    public Car(String license, Account driver){ //it is used that these parameters have same name that class declaration
        this.license = license; //it is neccesary to put this because compiler interprets a self-assignment of 'license' variable and causes a loop
        this.driver = driver;
    }

    void PrintDataCar(){
        if (passenger != null){
            System.out.println("License: " + license + ", Driver: " + driver.name + ", Passengers: " + passenger);
        }    
    }

    public Integer getPassenger(){ //then is get into this function, in order to set introduced value (Subclass) into passenger
        return passenger;
    }

    public void setPassenger(Integer passenger){ //setPassenger passes a set of condition through Int passenger variable
        if(passenger <= 4 & passenger !=0){ //This condition along with private our attribute, it's a clear example of encapsulation
            this.passenger = passenger;
        }
        if(passenger == 0){
            System.out.println("There are no passengers!");
        }
        if (passenger >4){
            System.out.println("Passenger limit in UberX is 4!");
        }
    }
}
 

Información resumida de esta clase
#EstudiantesDePlatzi

  • Una de las partes más importantes en la POO es el polimorfismo

  • Polimorfismo = Muchas formas, construir métodos con el mismo nombre, pero con comportamiento diferente

  • Cuando sobreescribimos un método significa que estamos aplicando polimorfismo

RESUMEN CLASE 33:
GENERANDO POLIMORFISMO
EN JAVA

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

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

  • Muchas formas

  • Construir métodos con el mismo nombre pero con comportamiento diferente

Main Java

package Java;

public class Main {
    public static void main(String[] args) {
        System.out.println("Hola como estan");
        UberX uberX = new UberX("AMQ123", new Account("Abidan Triguero", "AND12"), "Chevrolet", "Sonic");
        uberX.setPassenger(4);
        uberX.printDataCar();

        UberVan uberVan = new UberVan("FGH345",  new Account("Abidan Triguero", "AND12"));
        uberVan.setPassenger(6);
        uberVan.printDataCar();

        // Car car2 = new Car("QWE567", new Account("Andrea Herrera", "ANDA876"));
        // car2.passenger = 3;
        // car2.printDataCar();
    }
}

Car Java

package Java;

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

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

    void printDataCar() {
        if(passenger != null){
            System.out.println("License: " + licence + " Name Driver: " + driver.name + " Passenger: " + passenger);
        }
    }

    public Integer getPassenger() {
        return passenger;
    }

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

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;
    private Integer passenger;

    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) {
            this.passenger = passenger;
        } else {
            System.out.println("Necesitas asignar 4 pasajeros");
        }
    }
}

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() {
        super.printDataCar();
        System.out.println("Modelo: " + model + " Brand: " + brand);
    }
}

Grandiosa clase, comprendo más el concepto.

Otra forma de hacer esto sería dar valores por defecto. Esto lo podríamos hacer colocando en el constructor la línea this.passengers = 4