Encapsulando atributos en Java

Getters y Setters Python
E n python no existen como tal las variables privadas, pero se pueden “esconder” o volver privadas con solo colocarle doble guion bajo al nombre de la variable.

def setPassenger(self,passengerNum):
        if passengerNum >= 4:
            self.__passenger = int(passengerNum)
            print("Passengers asgindados : " + str(self.__passenger)) 

        else:
            print("El número de pasajeros es demasiado bajo para esta categoría")

    def getPassenger(self):
        if self.__passenger != int:
            print(self.__passenger)```

Aquí quedo faltando al menos la lectura de encapsulamiento en Python y demás lenguajes, punto negativo.

En Python tenemos 3 modificadores de acceso:

1. Public -> name
2. Protected -> _address (solo accesible para la clase misma y subclases)
3. Private -> __password
   
   

Recién comprendí porque el profesor de mi universidad los utilizaba jajaja 😦

Los getters y setters son muy importantes porque nos permiten trabajar con propiedades que son privadas, pero no de manera directa, sino que a través de un getter podemos validar ese dato que estamos recibiendo:D!

Algo genial es que en algunos IDE’s para Java como NetBeans te permiten establecer los getters y setters dando un solo click en una opción xD

Lo hice en Javascript pero este no tiene modificadores de acceso como Java o Php

Declarando get y set en c#

Les comparto mis apuntes de la Clase:

Encapsulando atributos en Java

Cuando no se define un modificador de acceso, Java internamente asigna el modificador default.

Añadir un modificador de acceso en Java:

private Integer passenger;

Getters y Setters: son métodos que permiten acceder y modificar un dato que esta protegido por un modificador de acceso.

• Creando un gettter:

  public Integer getPassenger() {   // Integer → Tipo de dato que va a retornar el método
      return passenger;
  }
  

• Creando un setter:

  public void setPassenger(Integer passenger) { // void → Indica que el método no va a retornar nada.
      this.passenger = passenger;
  }
  

  El getter permite acceder al dato protegido, mientras que el setter permite modificar dicho dato. Al ser ambos métodos de tipo public estarán disponibles desde cualquier lugar. A la hora de llamar estos métodos, no cambio nada, el proceso es el mismo que al llamar a cualquier otro método.

  Usar getters y setter es particularmente útil no sólo para proteger datos, sino también para validarlos:

  public void setPassenger(Integer passenger) {
  
      if (passenger == 4) {
  
          this.passenger = passenger;
  
      } else {
  
          System.err.println("⚠  Necesitas asignar por lo menos 4 pasajeros");
  
      }
  
  }
  

PD: si quieren implementar lo que dijo la profe Anahí y validar que las variables de la Clase Car no sean null pueden hacer los siguiente:

void printDataCar() {
        
        if (license != null && driver != null && passenger != null) {
            
            System.out.println("License: " + license + " - Driver: " + driver.name + " Passengers: " + passenger);

        } else {

            System.err.println("⚠  Aegurate de completar todos los campos");

        }
        
    }

Si durante todo el curso se fue explicando, minimamente en Java y Python no esperaba menos de este tema. Sin embargo solo se explica en Java.
Hay oportunidades de mejora sin dudas en el curso.

Los Getters y Setteres permiten conjugar validaciones para restringir o dar accesos a datos de elementos encapsulados.

Es muy dificil para alguien que esta aprendiendo python y javascript entender estos lenguajes cuando solo explican con java. Realmente entiendo por partes pero no considero que sea un aprendizaje efectivos. Muy regular este curso por no decir menos .

Ojo en el setter de passengers no es necesario agregar la sentencia “else”, este es un caso donde el “if” si le agregas la palabra reservada “return” crearas una “guard clouse” por ende puedes quitar el else y dejar solo el “if” y dos returns, el return dentro del “if” y el return fuera del “if” asi siempre retornara algo y bien si cumple con la condición igual devuelve algo y si no tambien y no agrandas el nivel de identacion y mejoras la legibilidad.

Resumen de como aplicar getters y setters en python:

1. usar notación de guion bajo para la propiedad privada
2. usar getters and setters para modificar una propiedad
3. incluir excepciones de uso en el setter.

class Account:
    id         = int
    name       = str
    document   = str
    email      = str
    password   = str
    def __init__(self, name, document):
        self.name = name
        self.document = document


class Car:
    id         = int
    license    = str
    driver     = Account(str,str)
    passengers = int

    
    def __init__(self, id, license, driver):
                self.id = id
                self._license = license
                self.driver = driver
                self.__passengers = None

    
    # método getter en python
    @property
    def passengers(self):
        return self.__passengers
    
    # método setter en python
    @passengers.setter
    def passengers(self, passengers):
        if passengers == 4:
            self.__passengers = passengers
        else:
            raise ValueError(f'the passengers {passengers} is not supported')
       

class UberX(Car):
    brand = str
    model = str

    def __init__(self, id, license, driver, brand, model):
        super().__init__(id, license, driver)
        self.brand = brand
        self.model = model

       

if __name__ == "__main__":
    my_car = UberX(id=33, license="3155DLX" , driver=Account("Emma", "Document"), brand="Ford", model="Focus")
    my_car.passengers = 4
    print(vars(my_car))
    

Si cambian my_car.passengers = 2 u otro valor saltara el error elevado por raise, así se protege el cambio de un valor.

🐱‍💻 Encapsulando atributos 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');
      }
    }

    get passenger => _passenger;

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

import 'account.dart';
import 'uber_x.dart';

void main() {
  UberX uberX = UberX(license: 'AMQ123', driver: Account(name: 'Andres Herrera', document: 'AND123'), brand: 'Chevrolet', model: 'Sonic');
  uberX.passenger = 2;
  uberX.printDataCar();
}

Aquí mis clases con encapsulamiento:

//Getters: Nos sirve para obtener y/o acceder al valor ya asignado a un atributo y utlizarlo para cierto método
    public tipoDeDato getAtributo(){
        return atributo;
    }
//Setters: Nos sirve para asignar un valor inicial a un atributo, pero de forma explícita, siempre es void y solo nos permite dar acceso público a ciertos atributos que deeemos modificar
    public void setAtributo(tipoDeDato atributo){
        this.atributo = atributo;
    }
    //Método 
    subClase.setAtributo(valor);```

Encapsulamiento en Javascript:

Para declarar atributos privados en Javascript se puede usar el modificador #, por ej:

class Car {
	constructor(license, driver) {
		this.#id;
		this.#license = license;
		this.#driver = driver;
		this.#passenger;
	}
}

Existe literatura como “Clean code” y otras donde explican los beneficios de nombrar a los identificadores de tus setters y getters sin el prefijo “set” o “get” sobre todo por temas de legibilidad, pero eso si siempre si es un estandar respetarlo en todas las clases no en unas si y otras no

que caso tiene encapsular, si con setter y getter se puede acceder??

Que gran clase! por fin entendí el Encapsulamiento!. Anahí es una excelente profesora! 😃

https://www.youtube.com/watch?v=HXraQVigwwE

Getters and Setters para archivos js

Salu2 !!

En el caso de JavaScript como sería ? pienso que se podría hacer de igual manera con condicionales, y métodos, pero en cuanto a las palabras reservadas no estoy seguro pero creo que no existen en JS, pues para este tipo de uso.

En este video explican muy bien cómo hacer los getters y setters en PHP. La verdad que después de verlo, queda mucho más claro todo este tema de encapsulamiento, además de su importancia. Se los recomiendo.
Les adjunto mi código en PHP:

class Car {
    public $id;
    public $license;
    public $driver;
    private $passenger;
    
    public function __construct($license, $driver){
        $this->driver = $driver;
        $this->license = $license;
    }


    public function getPassengers(){
        return $this->passenger;
    }

    public function setPassengers($passengers){
        if($passengers == 4){
            $this->passenger = $passengers;
        } else {
            $this->passenger = "undefined";
            throw new Error('El número de pasajeros debe ser de 4');
        }
    }

    public function printDataCar($brand, $model){
        if ($brand == "" || $model == "" || $this->passenger == ""){
            throw new Error('Ingresa todos los datos necesarios');
        } else {
            echo "License: $this->license <br/>Driver: {$this->driver->name} <br/>Document: {$this->driver->document} <br/>Brand: $brand <br/>Model: $model </br>Passengers: $this->passenger</br><br/>";
        }
    }
}

Encapsulamiento en python seria así:

main:

clase car

clase uberx

Python: público, privado y protegido

Les recomiendo esta lectura corta para comprender la diferencia entre público, protegido y privado en Python pues tiene sus diferencias con respecto a Java.

https://programys.com/python/modificadoes-publico-privado-y-protegido/

hay alguna forma de hacer encapsulamiento en JS?

¿En vez de hacer lo que se hizo con los métodos Getter y Setter, no podemos inicializar el dato de asientos en el método constructor, y ahorrarnos todo esto?

Es de los peores cursos que he visto en platzi, con todo el respeto para la profesroa, la profesora es muy buena, pero quedo super mal estructurado el curso.

Si con UberVan tenemos una cantidad mucho más grande de pasajeros y la validación en el setter se aplica para todas las clases que heredan la clase Car lo mejor es definir setter y getter en cada clase Uber y no en la clase Car. Es mi humilde opinión.

Otra forma de manejar el incumplimiento de las reglas son los fallos de software mediante throw, para este caso lo implemente así:

public void setPassenger(Integer passenger)
	{
		if (passenger > 3)
		{
		this.passengers = passenger;
		}
		else
		{
			 throw new ArithmeticException ("Valor no permitido"); 
		}
	}

Esta clase esta muy larga y mala. Me recuerda a algunos cursos en Udemy que tardan un buen para explicar algo que no hace falta divagar mucho

Principio de responsabilidad única

El principio de responsabilidad única o SRP (siglas del inglés, Single Responsibility Principle) en ingeniería de software establece que cada módulo o clase debe tener responsabilidad sobre una sola parte de la funcionalidad proporcionada por el software y esta responsabilidad debe estar encapsulada en su totalidad por la clase. Todos sus servicios deben estar estrechamente alineados con esa responsabilidad.

tiene que ser ‘===’ o si no a futuro deproto hay errores

Clarísimo. Gracias

hecho 😃

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


    //metodo constructor    
    public Car ( String license, Account driver )
    {
         //this hace referencia a la clase,
         // asi podemos diferenciar la variable local lincense con la de la clase 
        this.license = license;
        this.driver = driver;
    }

    //metodo para imprimir 
    void printdatacar()
    {
        //verificamos que todos los datos sean diferentes a nulos
        if(pasajeros != null)
        {
        System.out.println("license:" + license +"   driver:"+ driver.name +" pasajeros:" + pasajeros);
        }
    }


    //estos metodos permiten alterar el dato pasajeros dentro de la clase 

    public Integer getpasajeros()
    {
        return pasajeros;
    }

    public void setpasajeros(Integer pasajeros)
    {
       if(pasajeros == 4)
       { 
        this.pasajeros = pasajeros; //seteamos el dato como si fuera un constructor
       }
       else
       {System.out.println("nececitas asignar 4 pasajeros");}
    }

    
}```

hay alguna forma de hacer encapsulamiento en Python?

Faltó Python.

get & set!

De verdad despues de tantos problemas que tuve ver como funciona es Genial!.

Encapsular me protege de errores y fraudes.

Excelente pude entender mejor el funcionamiento del Set y Get al momento de establecer un encapsulamiento de tipo private, con el ejemplo se puede ver cómo aprovechar estas palabras clave para mantener mayor privacidad en los distintos atributos, muchas gracias por la clase instructora Anahí.

en javaScript tambien se usa el encapsulamiento… pero ¿¿cual seria el equivalente a ‘public’, ‘protected’, ‘default’ y ‘private’???

Encapsulando/escondiendo atributos de clases.

¿El getters y setters viene siendo igual que las propiedades en C#?

dos puntos por terminar de ver el video :v

Excelente, he aprendido bastante.

las clases con el principio de encapsulamiento nos permite controlar el cambio de valor que pueda producirse en ellas añadiendo validaciones como ingresar la cantidad de pasajeros.

encapsulamiento no permite ver los atributos de la clase
pero solo lo ve en la clase

Aquí entran también los setters y getters.

Muy interesante esta clase …

Metodos Getters y Setters.

gracias excelente clase genial =)

Que buena clase. Por fin entendí la utilidad de los Getters y Setters 😃

Posdata: Solo falta corregir “passenger” en vez de “passegenger” y listo.

muy pobre explicación de las ultimas 10 clases, de verdad que le falta aprender más sobre como explicar las cosas

Podrían compartir casos de uso de estos encapsulamientos?
Comparto uno.
Usar metodos en la clase para para validar y que algún compañero o yo mismo en el futuro no coloque un dato que no deba de estar ahí.
///////////////////
Método del video en Typescript
Car.ts
public setPassenger( passenger: number):void { passenger === ? this.passenger = passenger : console.error("Necesitas asignar pasajeros ") }

En PHP queda así:

Car.php

<?php
require_once 'Account.php';
class Car
{
    public $id;
    public $license;
    public $driver;
    private $passenger;

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

    public function printDataCar()
    {
        
        print '<p>'.'License: ' . $this->license . '</p>';
        print '<p>'.'Driver Name: ' . $this->driver->name .'</p>';
        print '<p>'.'Driver Document: ' . $this->driver->document .'</p>';
        
        if (is_numeric($this->passenger)) 
        {    
            print '<p>'.'Passengers: '.$this->passenger.'</p>';
        }
        
    }

    public function getPassenger()
    {
        return $this->passenger; 
    }

    public function setPassenger($passenger)
    {
        if (is_numeric($passenger)) 
        {
            $this->getPassenger();
        }
        else 
        {
            print 'Se ha introducido un valor no permitido';
        }

        
    }
}

index.php

<?php

    require_once 'Car.php';
    require_once 'UberX.php';
    require_once 'UberPool.php';
    require_once 'UberBlack.php';
    require_once 'Account.php';
    require_once 'User.php';

    use PHP\Account;
    use PHP\User;

/*$car = new Car("A56F460", new Account("Armando Diaz", "H7912U"));

    $car->printDataCar();*/

    $uberX = new UberX("CBVA1234", new Account(1, "Andres Ferran", "AND5687", "[email protected]", "askk"), "Chevrolet", "Spark");
    $uberX->printDataCar();

    echo "<hr/>";

    $uberPool = new UberPool("CBVA1234", new Account(1, "Andres Ferran", "AND5687", "[email protected]", "askk"), "Dodge", "Attitude");
    $uberPool->printDataCar();

    echo "<hr/>";

    $user = new User(1, "Fernado Sanchéz", "LUO234", "[email protected]", password_hash("asdñfoLj _", PASSWORD_BCRYPT ));
    $user->show();

    echo "<hr/>";

    $uberBlack = new UberBlack("CBVA1234", new Account(1, "Andres Ferran", "AND5687", "[email protected]", "askk"), "Chevrolet", "Spark");
    $uberBlack->printDataCar();
    $uberBlack->setPassenger(6);
    $uberBlack->getPassenger();```

Public : Todas las Clases.
Protected : En la misma Clase, paquetes, subclases.
Default : En la misma Clase y paquetes internos.
Private : Solo en la misma Clase

Getters y Setters son métodos de accesos que debemos declarar siempre public, Getters para retornar el valor y Setters para asignar el valor.

El encapsulamiento protege el dato, pero con otro método lo podemos utilizar.

Metodos Getters & Setters nos permiten manipular los datos encapsulados

Que claridad para poder explicar los conceptos. Mis felicitaciones Anahí!!

Si a nuestras clases y variables no le asignamos un modificador de acceso por defecto su modificador de acceso sera el “deafult” de alli el nombre.

https://www.youtube.com/watch?v=YuevbLXrXQo

Mi versión en C#

Uberx uberx = new Uberx("ADB123", new Account("Juan Carlos", "123432434"),"Chevrolet","AveoFt");
uberx.setPassenger(4);
uberx.imprimir();

internal class Car
    {
        private int id;
        public String licence;
        public Account driver;
        private int passengenger;

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

        public void imprimir()
        {
            if (passengenger != 0)
            {
                Console.WriteLine("Condctor: " + driver.name + " Matricula: " + licence + " Pasajeros: " + passengenger);
                Console.ReadKey();
            }
        }

        public int GetPassenger()
        {
            return passengenger;
        }

        public void setPassenger(int passengenger)
        {
            if (passengenger == 4)
            {
                this.passengenger = passengenger;
            }
            else
            {
                Console.WriteLine("Deben ser 4 pasajeros");
            }
        }
    }

internal class Uberx : Car 
    {
        public String brand;
        public String model;

        public Uberx(string licence, Account driver , String brand, String model)
            : base(driver, licence)
        {
            this.brand = brand;
            this.model = model;
        }

    }

Pareciera como si dijera ay ya terminemos esto solo con Java.
Pero bueno. En python hay dos formas, la de usar para getter
@property y para setter @passengers.setter, pero use y me funciono mejor la de usar get y set y después asignarles property

from account import Account

class Car:
    id = int
    licence = str
    driver = str
    passengers = int
    
    def __init__(self, license, driver):
        self.license = license
        self.driver = driver
        self.__passengers = None
        
    #Metodo Getter
    #@property
    def get_passengers(self):
    # def passengers(self):
        return self.__passengers
    
    #Metodo Setter 
    def set_passengers(self, passengers):
    #@passengers.setter
    # def pasengers(self, passengers):
        if passengers == 4:
            self .__passengers = passengers
        else:
            raise ValueError(f'Passengers: {passengers} it is not possible')
            #print("You need assign 4 passengers")
    
    passengers = property(
        get_passengers,
        set_passengers
    )

getters y setters
#getters --> obtiene un dato
#setters --> fijar un dato

Encapsulando atributos en Java

En Java, la encapsulación de atributos se logra utilizando los modificadores de acceso private, public y protected.

La idea detrás de la encapsulación es evitar que los atributos de una clase sean modificados directamente por otras clases externas, lo que podría llevar a errores y problemas de seguridad. En su lugar, se utilizan métodos llamados getters y setters para acceder y modificar los atributos.

Para hacer un atributo privado, se utiliza la palabra clave private. Esto significa que solo se puede acceder al atributo desde dentro de la propia clase. Los métodos getters y setters son públicos, lo que significa que se pueden utilizar desde otras clases.

A continuación se muestra un ejemplo de cómo encapsular atributos en Java:

public class Car {
   private String brand;
   private String model;

   public String getBrand() {
      return brand;
   }

   public void setBrand(String brand) {
      this.brand = brand;
   }

   public String getModel() {
      return model;
   }

   public void setModel(String model) {
      this.model = model;
   }
}

En este ejemplo, los atributos brand y model son privados y solo se pueden acceder a ellos a través de los métodos públicos getBrand(), setBrand(), getModel() y setModel().

Los métodos get permiten obtener el valor del atributo, mientras que los métodos set permiten modificar el valor del atributo.

La utilización de getters y setters permite un mayor control sobre la modificación de los atributos, lo que puede ayudar a prevenir errores y problemas de seguridad.

Humm esta clase creo que va un poco rapido y se explica por encima, pero bueno sirve para darse una idea

En Python no se utilizan modificadores de acceso como en otros lenguajes de programación orientados a objetos. En su lugar, se utiliza la convención de los guiones bajos y se confía en la responsabilidad del programador para acceder y modificar los atributos de una clase de manera adecuada.

Esto debido a la filosofía “we are all consenting adults here”

Se pueden usar la convencion por buena practica y es recomendable pero no es necesaria

Para los interesados en Python, en este no existen las palabras public, private o protected, lo que se utiliza es un guion bajo antes del atributo o método para declararlo protected y doble guion bajo para private. Y para el caso de los getter y setter se utiliza un objeto especial llamado property. A continuación un ejemplo:

class Car:
    def __init__(self, license, driver):
        self._id = int()  # Protected attribute
        self.license = license
        self.driver = driver
        self.__passengers = int()  # Private attribute

    def __get_passengers(self):
        return self.__passengers

    def __set_passengers(self, passengers):
        if passengers == 4:
            self.__passengers = passengers
        else:
            print('Necesitas asignar 4 pasajeros')

    passengers = property(
        __get_passengers,
        __set_passengers
    )


uberX = UberX('AMQ123', Account('Andres Herrera', 'AND123'), 'Chevrolet', 'Sonic')

uberX.passengers = 2

En VSCode si seleccionamos nuestro atributo y oprimimos Ctrl + . saldrá una opción que nos ayudara a crear los Getter and Setter de manera sencilla.

Si tuviera que ponerle en ejemplo
Diria que nuestros atributos de una clase son como nuestro sistema digestivo o cualquier otro, cuando tenemos hambre no le ponemos solamnete una imagen al estomago y ya comio, hay que procesar el alimento para que pueda digerirlo. Verificar si no esta vencido o tienen algo malo que nos produzca un error en nuestro sistema

y luego este tienen sus funciones para obtener sus nutrientes

Es como tener esos filtros para que todo funcione bien
son como formularios que llenas para poder hacer un tramine. creo que ahora los comprendo un poco mas

Leyendo un poco más sobre Getters y Setters me encontre con este articulo donde se dice que hacer uso de esos métodos es una práctica terrible.

https://arcanefoam.medium.com/getters-setters-perversos-punto-fe889b690332#:~:text=Los Setters y Getters son,valor de un campo%2Fatributo.

El término encapsulamiento en Java, consiste en ocultar atributos de un objeto de manera que solo se pueda cambiar mediante operaciones definidas en ese objeto. Está estrechamente relacionado con la visibilidad

¿Qué sentido tiene encapsular un atributo, si luego vamos a acceder a él por el método Getter o por el Setter?

Así hice los getters y setters en PHP

public function getPassenger(){
      echo $this->passenger;
    }

    public function setPassenger($passenger){
      if($passenger==4){
        $this->passenger=$passenger;
      }else{
        echo "Debe asignar 4 pasajeros";
      }
    }
?>

Información resumida de esta clase
#EstudiantesDePlatzi

• Ponemos el modificador de acceso al principio en donde definimos la variable

• Cuando necesites validar un campo puedo hacerlo accesible en todas las clases

• Getters y setters son métodos especiales que si me permiten acceder a los datos del atributo

Los getters y setters son muy importantes porque nos permiten trabajar con propiedades que son privadas, pero no de manera directa, sino que a través de un getter podemos validar ese dato que estamos recibiendo:D! Algo genial es que en algunos IDE’s para Java como NetBeans te permiten establecer los getters y setters dando un solo click en una opción xD

passenger

RESUMEN CLASE 32:
ENCAPSULANDO
ATRIBUTOS EN JAVA

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

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

Car Java

package Java;

public class Car {
    Integer id;
    String licence;
    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");
        }
    }
}

La encapsulación es el mecanismo de restringir el acceso a tus datos mediante funciones (getters y setters) y obviamente en primer lugar a los datos se los tuvo que haber marcado con un modificador de acceso como protected, private, etc.

Esta clase si fue dudosa 😕.

¿Para qué encapsular atributos de una clase si al final, con los getters y setters, se puede acceder al valor de éstos?

Getters y Setters son unos métodos que son especiales en Java y que son especiales en muchos lenguajes porque estos métodos si nos permiten acceder a los datos del atributo.

-Hola compañeros espero que se encuentren muy bien, alguien me puede decir cómo puedo evitar que me salga todo esto al ejecutar mi código

cd /mnt/c/Users/user/Documents/CursoPOOUber ; /usr/bin/env /usr/lib/jvm/java-11-openjdk-amd64/bin/java -cp /home/jhonftb3/.vscode-server/data/User/workspaceStorage/b7aff1fa41789826fe3d7a3760250421/redhat.java/jdt_ws/CursoPOOUber_b11ef4ab/bin Main 
hola mundo 
License: FJB879Driver: juan seballos: passengers: 4

• Alguien que me pueda colaborar gracias

******Todod super bien ******

class Main {
    public static void main(String[] args) {
        System.out.println("hola mundo ");
        UberX uberX = new UberX("FJB879", new Account("juan seballos: ", "JHF846"), "chevrolet", "aveo");
        uberX.setPassenger(3);
        uberX.printDataCar();
       
        
        /*Car car2 = new Car("FJB879", new Account("juan seballos", "JHF846"));
        car2.passegenger = 5;
        car2.printDataCar();*/

    }
}

hola mundo 
License: FJB879Driver: juan seballos: passengers: 4

Me arrepiento de no haber visto este curso antes, me iba a evitar muchos dolores de cabeza, la profe es genial

Mi solución en Python usando el decorador @property

Main

from UberX import UberX


def run():
    print('UberX example')
    uberX = UberX("QWE345", "Juan Perez", "Renault", "Logan")
    print(vars(uberX))

    # Setting passenger
    uberX.passenger = 4

    # Use getter
    uberX.passenger


if __name__ == "__main__":
    run() 

Car

from account import Account


class Car:
    id = int
    license = str
    driver = Account("", "")
    __passenger = int

    # Constructor
    def __init__(self, license, driver) -> None:
        self.license = license
        self.driver = driver

    # Using @property decorator
    @property
    
    # Getter method
    def passenger(self):
        if self.__passenger != int:
            print(f'Passengers: {self.__passenger}')
        else:
            print('Error with passenger')

    # Setter method
    @passenger.setter
    def passenger(self, passenger: int):
        if passenger == 4:
            self.__passenger = int(passenger)
            print(f'Passangers assigned: {self.__passenger}')
        else:
            print('You need to assign four passengers')

Si a ti se te ha hecho dificil comprender esto de encapsulamiento… A mi también, te daré mi explicacion en propias palabras
.
Encapsular es esconder atributos o metodos de una clase para que desde fuera de dicha clase no se pueda acceder o modificar esos metodos o atributos.
.
Vale, imagina que tienes la clase main:
.
class carrito {
Integer año;

car (Integer año) {
	this.año = año;
}

}
.
Todo bien, cierto? es una clase que tiene una funcion constructora con un atributo.
.
Pero…
.
Y si tu no quieres que desde el metodo de otra clase pueda modificarse el atributo en tu clase carrito?
.
Entonces, tu lo puedes “encapsular”, es como meter los atributos de la clase dentro de una caja negra para que no puedan ser vistos desde afuera.
.
De esta forma, tu tienes mayor control sobre como se modifica ese atributo o metodo.
.
class carrito {
private Integer año;

car (Integer año) {
	this.año = año;
}

}
.
Al colocar private antes del nombre del atributo, estás modificando el acceso que tiene dicho atributo.(en la clase pasada vimos los modificadores de acceso).
.
En este caso, el acceso es privado, lo que significa que solo los puedes modificar dentro de la misma clase donde fue declarado el atribto, en este caso, la clase carrito.

Para quienes entraron en pánico como yo por los vacíos que hay en este curso con respecto a Javascript, y no han visto que hay un curso de POO para Javascript solito:

https://platzi.com/cursos/javascript-poo/

Juan David al rescateee

Espero que en los siguientes cursos de JavaScript o Python se toque a fondo estos temas de encapsulamiento porque la mayoría de los conceptos se vieron con Java 😦

En Python no existen palabras reservadas para encapsular métodos o atributos de una clase. En cambio se pueden usar para ambos el doble guión bajo para encapsular el uso sólo a la clase. Si el método era method(), entonces ahora es __method() para que quede encapsulado, lo mismo para las variables de clase.

Java

Metodo Getter

    public Integer getPasseInteger(){
        return passenger;

    }

Metodo Setter

    public void setPassenger(Integer passenger){
        if(passenger == 4){
            this.passenger = passenger;
        }else{
            System.out.println("The car can take only 4 passengers");
        }
    }
}

Output

❯ java main
Hello, World!
License: ASD123
Driver: Juan
Passenger: 4

No se si alguien ya lo puso antes, pero me parece que si se pone otro valor diferente a 4, regresa null debido a que la función no esta configurada para retornar nada, con lo cual lo deja en nulo, otra opción mas compacta es la siguiente

public void setPassenger(Integer passenger){
	this.passenger = (passenger >= 4) ? passenger : 4;
}

Con esto logramos que si el numero de pasajeros es menor que 4, se le asigna 4 por fuerza, si son mas, se aplica el numero indicado

se arrastra el mal tipeado de passenger

‘passegenger’

Para verlo en python mirarse esta clase con los getters y los setters, además de usar los guiones bajos.

https://platzi.com/clases/1775-poo-python/25225-encapsulacion-getters-and-setters/

Aquí una explicación para python
https://www.youtube.com/watch?v=0rS7nrbwgiA

Metodos Especiales en java

• Public : Todas las Clases.

• Protected : En la misma Clase, paquetes, subclases.

• Default : En la misma Clase y paquetes internos.

• Private : Solo en la misma Clase