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.

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

En Python tenemos 3 modificadores de acceso:

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

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

        }
        
    }

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

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.

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.

🐱‍💻 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);```

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.

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/

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

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.

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

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

Encapsulamiento en python seria así:

main:

clase car

clase uberx

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.

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.

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

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

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.

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

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

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

interesante los metodos

Alguien más es demasiado perfeccionista con el código y quiso en todos los ejercicios corregir el atributo que tenía la profe passegenger por passenger?

Les dejo lo que he echo en JavaScrip, no se si es la forma correcta pero me ha salido bien.
Car.js

class Car{

    constructor(license,driver){
        this.id;
        this.license = license;
        this.driver = driver;
        this.passegenger; 
    }
    
    printDataCar(){
        console.log(this.driver);
        //console.log("Hola");
        console.log(`Passegenger: ${this.getPassegenger()} aplicando Getter y Setters`);
    }
    
    getPassegenger(){
        return this.passegenger;
    }
    setPassegenger(passegenger){
        this.passegenger = passegenger;
    }
}

index.js

var car = new Car("ABC!",new Account("Josemaria","DNI"));
car.setPassegenger(4);
car.printDataCar();

No entendía como funcionan los setter y getter y en esta clase lo aprendí 😄

Solo para conocimiento general del OOP. Cuando se encapsulan datos como se hizo aqui y se escriben funciones (metodos) para acceder a esos datos privados o protegidos a eso se le llama Abstraccion de datos.

excelente clase

increíble

Ese momento en el que tu cerebro hace switch y comienzas a comprender al 100% los conceptos, genial!

Adicional sobre encapsulamiento.
https://www.youtube.com/watch?v=mxu9oxFj9b8

Que buena anologia de encapsulamiento

Encapsulamiento

Me encanto la clase!! ya había visto sobre Getters y Setters y no los había entendido bien hasta el día hoy! que buen ejemplo el de Uber y la organización del curso! felicitaciones Anahí, felicitaciones Platzi!

genial

Excelente!

Encapsulando en c#

  public int getPassenger
   {
       get
       {
          return passanger; 
       }
       set
       {
           passanger = value ;
       }
   }```

uberX.getPassenger=4;

Los Getters son los que mas se usan, ya que dependiendo de la lógica de cada aplicación puede convenir o no usar los Setters para modificar su valor

Así quedó por acá

Excelente clase, profesora.
Anteriormente ya había trabajado con Encapsulamiento y he hecho varios ejercicios, sin embargo, esta clase me ayudó a entenderlo aún mejor a nivel conceptual, no conocía qué permisos tenían esas palabras reservadas.
Excelente.

Otra forma

public int getPassenger(int passanger)
{
if (passanger == 4)
{   
this.passanger = passanger;
return passanger;
}
else
{
    Console.WriteLine("Debes tener por lo menos 4 pasajeros");
}
return passanger;

}

Buena clase, solo que if (passengers == null) No puede ejecutarse en mi código porque passenger necesita ser boolean para eso.

Así quedó mi clase Car

package Java;

class Car {
    int id;
    Account driver;
    String license;
    private int passengers;

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

    void printDataCar() {
        if ((passengers == 0 ||license == null) || driver == null) {
            System.out.println("Falta agregar datos. Intente de nuevo.");
        }
        else {
            System.out.println("License: " + license + "\nDriver: " + driver.name + "\nDNI: " + driver.document + "\nPassengers: " + passengers);
        }
    }

    public int getPassenger() {
        return passengers;
    }

    public void setPassengers(int passengers) {
        if (passengers == 4) {
            this.passengers = passengers;
        }

    }
}