QLQ PANA ESPY, SUPONGO QUE ESTE TEMA ES NUEVO PARA TI ASI QUE

LO EXPLICARE COMO YO LO APRENDI, UN POCO DE TEORIA Y LUEGO

EJERICICIOS PRACTICOS EXPLICADOS, TOMA:

Introducción

En programación, cuando creamos una clase, estamos definiendo un tipo de

objeto que puede tener atributos (también conocidos como propiedades o campos)
y métodos. Los atributos son variables que almacenan valores, mientras que los
métodos son funciones que realizan acciones sobre esos valores.

El problema

Imagina que tienes una clase Persona con un atributo edad. Si permitimos que
cualquier parte del programa acceda directamente a este atributo, podríamos tener
problemas de seguridad y consistencia. Por ejemplo, alguien podría asignar un
valor negativo a la edad, lo que no tiene sentido en el contexto real.

La solución: Getters y Setters

Para resolver este problema, se introdujeron los getters y setters. Estos son
métodos especiales que nos permiten controlar el acceso a los atributos de una
clase.

Getters (Accesores)

Un getter es un método que devuelve el valor de un atributo. Su nombre suele

empezar con "get" seguido del nombre del atributo. Por ejemplo, en nuestra clase
Persona, podríamos tener un getter para el atributo edad:
public class Persona {

private int edad;

public int getEdad() {

return edad;

De esta manera, cuando queramos acceder al valor de la edad, debemos llamar al

método getEdad() en lugar de acceder directamente al atributo edad.

Setters (Mutadores)

Un setter es un método que asigna un valor a un atributo. Su nombre suele

empezar con "set" seguido del nombre del atributo. En nuestra clase Persona,
podríamos tener un setter para el atributo edad:

public class Persona {

private int edad;

public void setEdad(int edad) {

if (edad < 0) {

throw new IllegalArgumentException("La edad no puede ser negativa");

this.edad = edad;

}
}

De esta manera, cuando queramos asignar un valor a la edad, debemos llamar al

método setEdad() en lugar de acceder directamente al atributo edad. El setter nos
permite validar el valor antes de asignarlo, garantizando que sea válido.

NOTAS A TENER EN CUENTA SOBRE ESTAS VAINAS (PURA TEORIA PERO

LO PONGO POR QUE ES LA NORMA PERO LO NORMAL ES SALTARTELO):

Los dos elementos vistos previamente son empleados por medio de su

abanico de ventajas, permitiendo lograr una programación más eficiente y
"especializada" , dichas ventajas pueden enumerase como las siguientes:

Control de acceso: Podemos controlar quién puede acceder o modificar los

atributos de una clase.

Validación: Podemos validar los valores antes de asignarlos a los atributos.

Encapsulación: Los atributos se vuelven privados, lo que mejora la seguridad y la

integridad de los datos.

En resumen mano podemos decir que los getters y setters son métodos
especiales que nos permiten controlar el acceso a los atributos de una clase, de
tal forma que los getters devuelven el valor de un atributo, mientras que los setters
asignan un valor a un atributo después de validarla. Esto nos permite garantizar la
seguridad, consistencia y encapsulación de los datos en nuestra clase.
 AHORA SI EMPEZAMOS CON LO BUENO MANO, LOS
EJERCICIOS

Ejercicio 1: Crear una clase con un atributo y un getter

Enunciado: Crea una clase Rectangle con un atributo width (ancho) y un getter
para acceder a ese atributo.

Solución:

public class Rectangle {

private int width;

public Rectangle(int width) {

this.width = width;

public int getWidth() {

return width;

Explicación: En este ejemplo, creamos una clase Rectangle con un atributo width
que se inicializa en el constructor. Luego, creamos un getter getWidth() que
devuelve el valor del atributo width. De esta manera, podemos acceder al valor del
ancho del rectángulo de manera controlada.
Ejercicio 2: Crear una clase con un atributo y un setter

Enunciado: Crea una clase Persona con un atributo nombre y un setter para
asignar un valor a ese atributo.

Solución:

public class Persona {

private String nombre;

public void setNombre(String nombre) {

if (nombre == null || nombre.trim().isEmpty()) {

throw new IllegalArgumentException("El nombre no puede ser vacío");

this.nombre = nombre;

Explicación: En este ejemplo, creamos una clase Persona con un atributo nombre
que se asigna mediante un setter setNombre(). En el setter, validamos que el
nombre no sea vacío antes de asignarlo al atributo. De esta manera, podemos
garantizar que el nombre sea siempre válido.

Ejercicio 3: Crear una clase con un atributo, un getter y un setter

Enunciado: Crea una clase CuentaBancaria con un atributo saldo y un getter y un
setter para acceder y asignar un valor a ese atributo.

Solución:

public class CuentaBancaria {

private double saldo;

public CuentaBancaria(double saldo) {

this.saldo = saldo;

public double getSaldo() {

return saldo;

public void setSaldo(double saldo) {

if (saldo < 0) {

throw new IllegalArgumentException("El saldo no puede ser negativo");

this.saldo = saldo;

Explicación: En este ejemplo, creamos una clase CuentaBancaria con un atributo

saldo que se inicializa en el constructor. Luego, creamos un getter getSaldo() que
devuelve el valor del atributo saldo. También creamos un setter setSaldo() que
asigna un valor al atributo saldo después de validar que no sea negativo. De esta
manera, podemos acceder y asignar un valor al saldo de manera controlada.

Ejercicio 4: Uso de getters y setters

Enunciado: Crea un programa que utilice la clase CuentaBancaria para crear una
cuenta bancaria y asignarle un saldo inicial. Luego, utiliza los getters y setters para
acceder y modificar el saldo.

Solución:

public class Main {

public static void main(String[] args) {

CuentaBancaria cuenta = new CuentaBancaria(1000.0);

System.out.println("Saldo inicial: " + cuenta.getSaldo());

cuenta.setSaldo(2000.0);

System.out.println("Saldo después de asignar: " + cuenta.getSaldo());

try {

cuenta.setSaldo(-500.0);

} catch (IllegalArgumentException e) {

System.out.println("Error: " + e.getMessage());

}
 System.out.println("Saldo final: " + cuenta.getSaldo());

Explicación: En este ejemplo, creamos una cuenta bancaria con un saldo inicial de
1000.0. Luego, utilizamos el getter getSaldo() para acceder al saldo y mostrarlo
por pantalla. Después, utilizamos el setter setSaldo() para asignar un nuevo valor
al saldo. Intentamos asignar un valor negativo, lo que lanza una excepción
IllegalArgumentException. Finalmente, mostramos el saldo final utilizando el getter
getSaldo().

AHORA UNO DE LOS BUENOS

Ejercicio 5: Crear una clase Empleado con atributos y métodos para calcular el
salario

Enunciado: Crea una clase Empleado con los siguientes atributos:

nombre: el nombre del empleado

apellido: el apellido del empleado

salarioBase: el salario base del empleado

horasExtras: el número de horas extras trabajadas por el empleado

La clase debe tener los siguientes métodos:

getNombre(): devuelve el nombre del empleado

getApellido(): devuelve el apellido del empleado

getSalarioBase(): devuelve el salario base del empleado

getHorasExtras(): devuelve el número de horas extras trabajadas por el empleado

setHorasExtras(int horas): asigna un nuevo valor al número de horas extras

trabajadas por el empleado

calcularSalario(): calcula el salario total del empleado, considerando el salario

base y las horas extras trabajadas

Solución:

public class Empleado {

private String nombre;

private String apellido;

private double salarioBase;

private int horasExtras;

public Empleado(String nombre, String apellido, double salarioBase) {

this.nombre = nombre;

this.apellido = apellido;

this.salarioBase = salarioBase;

this.horasExtras = 0;

public String getNombre() {

return nombre;

}
 public String getApellido() {

return apellido;

public double getSalarioBase() {

return salarioBase;

public int getHorasExtras() {

return horasExtras;

public void setHorasExtras(int horas) {

if (horas < 0) {

throw new IllegalArgumentException("El número de horas extras no puede

ser negativo");

this.horasExtras = horas;

public double calcularSalario() {

double salarioTotal = salarioBase;

if (horasExtras > 0) {

salarioTotal += salarioBase * 0.1 * horasExtras;

return salarioTotal;
 }

Explicación:

En este ejercicio, creamos una clase Empleado con cuatro atributos: nombre,
apellido, salarioBase y horasExtras. Los tres primeros atributos se inicializan en el
constructor, mientras que horasExtras se inicializa en 0.

La clase tiene seis métodos:

getNombre(), getApellido(), getSalarioBase() y getHorasExtras() son getters que

devuelven los valores de los atributos correspondientes.

setHorasExtras(int horas) es un setter que asigna un nuevo valor al atributo

horasExtras. Validamos que el número de horas extras no sea negativo antes de
asignarlo.

calcularSalario() es un método que calcula el salario total del empleado. Primero,

se devuelve el salario base. Luego, si el empleado ha trabajado horas extras, se
agrega un 10% del salario base por cada hora extra trabajada.

Uso de la clase Empleado:

public class Main {

public static void main(String[] args) {

Empleado empleado = new Empleado("Juan", "Pérez", 3000.0);

System.out.println("Nombre: " + empleado.getNombre());

System.out.println("Apellido: " + empleado.getApellido());

 System.out.println("Salario base: " + empleado.getSalarioBase());

System.out.println("Horas extras: " + empleado.getHorasExtras());

System.out.println("Salario total: " + empleado.calcularSalario());

empleado.setHorasExtras(10);

System.out.println("Horas extras: " + empleado.getHorasExtras());

System.out.println("Salario total: " + empleado.calcularSalario());

Explicación del uso de la clase:

En este ejemplo, creamos un objeto Empleado con nombre "Juan", apellido

"Pérez" y salario base de 3000.0. Luego, mostramos los valores de los atributos
utilizando los getters. Calculamos el salario total utilizando el método
calcularSalario().

Después, asignamos 10 horas extras al empleado utilizando el setter

setHorasExtras(int horas). Mostramos nuevamente los valores de los atributos y
calculamos el salario total nuevamente. En este caso, el salario total incluye el
salario base y el pago por las horas extras trabajadas.
 EJERCICIOS PARA PRACTICAR (LUEGO ME LOS PASAS
Y TE CORRIJO Y EXPLICO CUALQUIER COSA)

Ejercicio 1: Crear una clase Persona con un atributo y un getter

Enunciado: Crea una clase Persona con un atributo nombre y un getter

getNombre() que devuelva el valor del atributo.

Requisitos:

La clase debe tener un constructor que inicialice el atributo nombre.

El getter getNombre() debe devolver el valor del atributo nombre.

Ejercicio 2: Crear una clase Cuenta con un atributo y un setter

Enunciado: Crea una clase Cuenta con un atributo saldo y un setter

setSaldo(double saldo) que asigne un valor al atributo.

Requisitos:

La clase debe tener un constructor que inicialice el atributo saldo.

El setter setSaldo(double saldo) debe asignar un valor al atributo saldo y validar

que no sea negativo.

Ejercicio 3: Crear una clase Libro con dos atributos y getters

Enunciado: Crea una clase Libro con dos atributos titulo y autor y getters
getTitulo() y getAutor() que devuelvan los valores de los atributos.

Requisitos:

La clase debe tener un constructor que inicialice los atributos titulo y autor.

Los getters getTitulo() y getAutor() deben devolver los valores de los atributos
titulo y autor, respectivamente.

Ejercicio 4: Crear una clase Vehiculo con un atributo y un getter y setter

Enunciado: Crea una clase Vehiculo con un atributo velocidad y un getter

getVelocidad() que devuelva el valor del atributo y un setter setVelocidad(int
velocidad) que asigne un valor al atributo.

Requisitos:

La clase debe tener un constructor que inicialice el atributo velocidad.

El getter getVelocidad() debe devolver el valor del atributo velocidad.

El setter setVelocidad(int velocidad) debe asignar un valor al atributo velocidad y

validar que no sea negativo.