Programación II

La programación orientada a objetos (POO) es un paradigma de programación que

se basa en el concepto de "objetos", los cuales representan entidades del mundo
real y poseen características (atributos) y comportamientos (métodos) asociados. La
POO se centra en la organización del código en estructuras modulares y
reutilizables, lo que promueve la modularidad, la flexibilidad y el mantenimiento
del software.

8.1. Definición de Clases:

En la programación orientada a objetos, una clase es una plantilla o un plano para
crear objetos. Define las propiedades (atributos) y los comportamientos (métodos)
comunes a un grupo de objetos relacionados. La clase actúa como un modelo para
los objetos que se crearán a partir de ella. Por ejemplo, si estás creando un
programa para administrar una biblioteca, podrías tener una clase Libro que
define los atributos como título, autor, año de publicación, etc., y métodos
como prestar, devolver, obtener información, etc.

8.2. Definición de Objeto:

Un objeto es una instancia particular de una clase. Es una entidad que tiene un
estado (representado por sus atributos) y un comportamiento (definido por sus
métodos). Los objetos son ejemplos concretos de las abstracciones definidas por
las clases. Siguiendo el ejemplo anterior, un objeto Libro específico podría ser "El
Quijote" de Miguel de Cervantes, con un título, un autor y un año de publicación
específicos.
8.3. Abstracción de Clases:
La abstracción es un principio fundamental de la programación orientada a objetos
que se refiere a la capacidad de modelar entidades del mundo real en un programa
informático. Las clases son una forma de abstracción, ya que representan un
conjunto de propiedades y comportamientos comunes a un grupo de objetos. La
abstracción permite simplificar y encapsular la complejidad de un sistema,
enfocándose solo en los aspectos relevantes para el problema que se está
resolviendo. Por ejemplo, al modelar un sistema de gestión de empleados, puedes
crear una clase Empleado que abstrae las características comunes a todos los
empleados, como el nombre, la edad, el salario, etc., sin preocuparte por los
detalles específicos de cada empleado individual.
8.3.1. Atributos:
Los atributos representan las características de un objeto. En la clase Automovil,
los atributos podrían ser marca, modelo, año y color. Estos atributos definen el
estado de un automóvil específico.

8.3.2. Métodos:
Los métodos definen el comportamiento de un objeto. En la clase Automovil, los
métodos podrían ser ‘ acelerar()’, ’ frenar()’, ‘girar()’ y
‘obtenerInformacion()’ . Estos métodos representan las acciones que un
automóvil puede realizar.
8.3.3. Control de Acceso a los Miembros:
En Java, puedes controlar el acceso a los miembros de una clase utilizando
modificadores de acceso como ‘ public’, ‘private’, ‘protected’ y el acceso por
defecto. En la clase ‘ Automovil’, los atributos se han declarado como ‘ private’
para encapsularlos y controlar el acceso a ellos desde fuera de la clase. Los
métodos, por otro lado, pueden tener diferentes modificadores de acceso según
tus necesidades de diseño.

Modificadores de Acceso en Java:

public: El miembro es accesible desde cualquier clase, ya sea en el mismo
paquete o en otro.
private: El miembro solo es accesible desde dentro de la misma clase. No puede
ser accedido desde clases externas, incluso si están en el mismo paquete.
protected: El miembro es accesible desde la misma clase, desde clases del
mismo paquete y desde subclases (herencia).
Sin modificador (acceso por defecto): El miembro es accesible solo desde
clases del mismo paquete, pero no desde clases externas al paquete.
Ejemplo en la Clase Automovil:
En la clase Automovil, hemos definido los atributos como private, lo que significa
que solo pueden ser accedidos dentro de la propia clase Automovil. Esto se hace
para encapsular los detalles internos del automóvil y evitar que sean modificados
directamente desde fuera de la clase.

public class Automovil {

// Atributos
private String marca; // Acceso privado
private String modelo; // Acceso privado
private int año; // Acceso privado
private String color; // Acceso privado

// Métodos
public void acelerar() {
// Implementación de acelerar (acceso
público)
}

private void frenar() {

// Implementación de frenar (acceso
privado)
}

// ...
}

Por otro lado, los métodos como acelerar() tienen un modificador de

acceso public, lo que significa que pueden ser accedidos desde cualquier
clase. En este caso, otros objetos pueden llamar al método acelerar()
para acelerar el automóvil, pero no pueden acceder directamente a los
detalles internos del automóvil como la marca o el modelo debido a que
están definidos como private.

Esta práctica de control de acceso ayuda a mantener la integridad y la

seguridad del objeto, ya que los datos internos solo pueden ser
modificados mediante métodos específicos definidos en la misma clase.

8.3.4. Problemas de Aplicación:

En la aplicación de la clase Automovil, algunos problemas comunes podrían incluir
la falta de validación de datos de entrada en los métodos, la gestión de
excepciones, la sincronización de acceso a datos compartidos entre múltiples hilos,
entre otros. Además, podrías enfrentarte a desafíos de diseño relacionados con la
jerarquía de clases (por ejemplo, si deseas modelar diferentes tipos de
automóviles) o la interacción con otras clases en un sistema más grande.

Es importante considerar estos aspectos al diseñar y desarrollar clases en Java (y en

cualquier lenguaje orientado a objetos) para garantizar que tu código sea robusto,
mantenible y fácil de entender.
8.4. Abstracción de Datos y Encapsulamiento:
La abstracción de datos se refiere al proceso de identificar y definir los datos
esenciales y las operaciones asociadas con un objeto, mientras que el
encapsulamiento consiste en ocultar los detalles de implementación de un objeto y
exponer solo la interfaz pública a otros objetos. En Java, el encapsulamiento se
logra utilizando modificadores de acceso y proporcionando métodos públicos para
acceder y modificar los datos internos de un objeto.

Abstracción de Datos:

La abstracción de datos implica identificar y definir las propiedades y

comportamientos esenciales de un objeto, sin preocuparse por los detalles internos
de implementación. En Java, esto se logra mediante la definición de clases y la
especificación de sus atributos y métodos.

Ejemplo:

Supongamos que queremos representar un objeto "Perro" en un programa Java.

Podemos identificar las propiedades esenciales de un perro, como su nombre,
edad y raza. Luego, definimos una clase Perro que encapsula estas propiedades:

public class Perro {

// Atributos
private String nombre;
private int edad;
private String raza;

// Constructor
public Perro(String nombre, int edad, String raza) {
this.nombre = nombre;
this.edad = edad;
this.raza = raza;
}
 // Métodos
public void ladrar() {
System.out.println("¡Guau! ¡Guau!");
}

public void dormir() {

System.out.println("Zzz...");
}

// Otros métodos...
}

En este ejemplo, hemos definido una clase Perro con atributos nombre, edad y
raza. Estos atributos representan las propiedades esenciales de un perro. Los
detalles internos de cómo se almacenan y gestionan estos datos están ocultos
fuera de la clase Perro, lo que facilita el uso de la clase sin preocuparse por su
implementación interna.

Encapsulamiento:

El encapsulamiento es un principio de la programación orientada a objetos que

consiste en ocultar los detalles de implementación de un objeto y exponer solo una
interfaz pública para interactuar con él. En Java, esto se logra utilizando
modificadores de acceso y proporcionando métodos públicos para acceder y
modificar los datos internos de un objeto.

Ejemplo:

Siguiendo con el ejemplo anterior, hemos definido los atributos nombre, edad y
raza como private, lo que significa que solo pueden ser accedidos desde dentro
de la clase Perro. Luego, proporcionamos métodos públicos ( getters y setters)
para acceder y modificar estos atributos de forma controlada:

public class Perro {

private String nombre;
private int edad;
private String raza;

public Perro(String nombre, int edad, String raza) {

this.nombre = nombre;
this.edad = edad;
this.raza = raza;
 }

// Métodos de acceso (getters y setters)

public String getNombre() {
return nombre;
}

public void setNombre(String nombre) {

this.nombre = nombre;
}

public int getEdad() {

return edad;
}

public void setEdad(int edad) {

this.edad = edad;
}

public String getRaza() {

return raza;
}

public void setRaza(String raza) {

this.raza = raza;
}

// Otros métodos...
}

Ahora, los datos internos de un objeto Perro están protegidos y solo pueden ser
accedidos y modificados a través de los métodos públicos getNombre(),
setNombre(), getEdad(), setEdad(), getRaza() y setRaza(). Esto asegura que
los datos se manipulen de manera controlada y evita que se acceda a ellos de
forma incorrecta desde fuera de la clase.
Getters:

Un getter es un método público que se utiliza para obtener el valor de un atributo

de un objeto. Proporciona acceso de solo lectura al atributo, lo que significa que
solo se puede obtener su valor pero no modificarlo.
 En general, los getters tienen el siguiente formato:

public tipoDeDato getNombreDelAtributo() {

return nombreDelAtributo;
}

Donde:

 tipoDeDato es el tipo de dato del atributo que se va a devolver.

 getNombreDelAtributo es el nombre del getter que se utilizará para obtener el
valor del atributo.
 nombreDelAtributo es el nombre del atributo cuyo valor se desea obtener.

Setters:

Un setter es un método público que se utiliza para modificar el valor de un atributo

de un objeto. Proporciona acceso de escritura al atributo, lo que significa que se
puede establecer un nuevo valor para el atributo.

En general, los setters tienen el siguiente formato:

public void setNombreDelAtributo(tipoDeDato nuevoValor) {

this.nombreDelAtributo = nuevoValor;
}

Donde:

 tipoDeDato es el tipo de dato del atributo que se va a modificar.

 setNombreDelAtributo es el nombre del setter que se utilizará para modificar el
valor del atributo.
 nombreDelAtributo es el nombre del atributo cuyo valor se desea modificar.
 nuevoValor es el nuevo valor que se asignará al atributo.

Diferencia entre Getters y Setters:

La principal diferencia entre los getters y setters radica en su funcionalidad:

 Los getters permiten obtener el valor de un atributo (lectura).

 Los setters permiten establecer un nuevo valor para un atributo (escritura).
En resumen, los getters y setters son métodos que proporcionan un mecanismo
controlado para acceder y modificar los atributos de un objeto. Esto ayuda a
mantener el principio de encapsulamiento al ocultar los detalles de
implementación de los atributos y proporcionar una interfaz pública para
interactuar con ellos.

Ejemplo simple que utiliza getters y setters en Java para una clase Persona que
tiene atributos como nombre, edad y ocupación:
public class Persona {
// Atributos
private String nombre;
private int edad;
private String ocupacion;

// Constructor
public Persona(String nombre, int edad, String ocupacion) {
this.nombre = nombre;
this.edad = edad;
this.ocupacion = ocupacion;
}

// Getters
public String getNombre() {
return nombre;
}

public int getEdad() {

return edad;
}

public String getOcupacion() {

return ocupacion;
}

// Setters
public void setNombre(String nombre) {
this.nombre = nombre;
}

public void setEdad(int edad) {

this.edad = edad;
 }

public void setOcupacion(String ocupacion) {

this.ocupacion = ocupacion;
}

// Método principal para probar la clase

public static void main(String[] args) {
// Crear un objeto Persona
Persona persona1 = new Persona("Juan", 30, "Ingeniero");

// Obtener los atributos utilizando getters

System.out.println("Nombre: " + persona1.getNombre());
System.out.println("Edad: " + persona1.getEdad());
System.out.println("Ocupación: " + persona1.getOcupacion());

// Modificar los atributos utilizando setters

persona1.setEdad(35);
persona1.setOcupacion("Desarrollador");

// Obtener los nuevos valores de los atributos utilizando getters

System.out.println("\nDespués de la modificación:");
System.out.println("Nombre: " + persona1.getNombre());
System.out.println("Edad: " + persona1.getEdad());
System.out.println("Ocupación: " + persona1.getOcupacion());
}
}

Este ejemplo muestra una clase Persona con atributos nombre, edad y ocupacion.
Se definen getters ( getNombre(), getEdad(), getOcupacion() ) para acceder a estos
atributos y setters ( setNombre(), setEdad(), setOcupacion()) para modificarlos.
Luego, en el método main, creamos un objeto Persona, obtenemos y modificamos
sus atributos utilizando getters y setters, respectivamente. Esto muestra cómo se
pueden utilizar getters y setters para acceder y modificar los atributos de un objeto
de forma controlada.
8.5. Constructores:
Los constructores son métodos especiales dentro de una clase que se utilizan para
inicializar objetos de esa clase. Tienen el mismo nombre que la clase y no tienen
tipo de retorno. En Java, puedes tener varios constructores en una clase y pueden
aceptar diferentes parámetros. Los constructores se utilizan para asignar valores
iniciales a los atributos de un objeto cuando se crea una instancia de la clase.
public class Persona {
private String nombre;
private int edad;

// Constructor sin parámetros

public Persona() {
this.nombre = "Victor";
this.edad = 24;
}

// Constructor con parámetros

public Persona(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
}

Ejercicios
1.- una calculadora básica que puede sumar y restar números. Utilizaremos la
programación orientada a objetos para crear una clase Calculadora que tenga
métodos para sumar y restar.

public class Calculadora {

// Método para sumar dos números
public int sumar(int num1, int num2) {
return num1 + num2;
}

// Método para restar dos números

 public int restar(int num1, int num2) {
return num1 - num2;
}

// Método principal para probar la clase

public static void main(String[] args) {
// Crear un objeto de la clase Calculadora
Calculadora miCalculadora = new Calculadora();

// Utilizar los métodos de la calculadora

int resultadoSuma = miCalculadora.sumar(5, 3);
int resultadoResta = miCalculadora.restar(10, 4);

// Mostrar los resultados

System.out.println("Resultado de la suma: " + resultadoSuma);
System.out.println("Resultado de la resta: " + resultadoResta);
}
}

En este ejercicio:

 Creamos una clase Calculadora.

 Definimos dos métodos dentro de la clase: sumar y restar, que realizan
operaciones de suma y resta respectivamente.
 En el método main, creamos un objeto de la clase Calculadora.
 Utilizamos los métodos sumar y restar del objeto miCalculadora para realizar
operaciones de suma y resta respectivamente.
 Finalmente, mostramos los resultados en la consola.

Este ejercicio simple ilustra cómo puedes utilizar la programación orientada a

objetos para crear clases que contienen métodos que realizan acciones específicas.
La clase Calculadora encapsula la funcionalidad relacionada con la suma y la resta,
lo que hace que el código sea más modular y fácil de entender.

Clase Círculo: Crea una clase Circulo que tenga un atributo radio y métodos
para calcular el área y el perímetro del círculo.
public class Circulo {
private double radio;
 public Circulo(double radio) {
this.radio = radio;
}

public double calcularArea() {

return Math.PI * radio * radio;
}

public double calcularPerimetro() {

return 2 * Math.PI * radio;
}

public static void main(String[] args) {

Circulo miCirculo = new Circulo(5);
System.out.println("Área del círculo: " + miCirculo.calcularArea());
System.out.println("Perímetro del círculo: " + miCirculo.calcularPerimetro());
}
}

Clase Estudiante: Crea una clase Estudiante que tenga atributos como nombre,
edad, curso y métodos para obtener y establecer estos atributos.

public class Estudiante {

private String nombre;
private int edad;
private String curso;

public Estudiante(String nombre, int edad, String curso) {

this.nombre = nombre;
this.edad = edad;
this.curso = curso;
}

public String getNombre() {

return nombre;
}

public int getEdad() {

return edad;
 }

public String getCurso() {

return curso;
}

public static void main(String[] args) {

Estudiante estudiante1 = new Estudiante("Juan", 20, "Ingeniería");
System.out.println("Nombre del estudiante: " + estudiante1.getNombre());
System.out.println("Edad del estudiante: " + estudiante1.getEdad());
System.out.println("Curso del estudiante: " + estudiante1.getCurso());
}
}

Clase Libro: Crea una clase Libro que tenga atributos como título, autor, año y
métodos para obtener y establecer estos atributos.

public class Libro {

private String titulo;
private String autor;
private int año;

public Libro(String titulo, String autor, int año) {

this.titulo = titulo;
this.autor = autor;
this.año = año;
}

public String getTitulo() {

return titulo;
}

public String getAutor() {

return autor;
}

public int getAño() {

return año;
 }

public static void main(String[] args) {

Libro libro1 = new Libro("El Principito", "Antoine de Saint-Exupéry", 1943);
System.out.println("Título del libro: " + libro1.getTitulo());
System.out.println("Autor del libro: " + libro1.getAutor());
System.out.println("Año de publicación: " + libro1.getAño());
}
}

Clase Tienda: Crea una clase Tienda que represente una tienda de productos
electrónicos. Debe tener atributos como nombre, dirección, listaDeProductos y
métodos para agregar, eliminar y mostrar productos.

import java.util.ArrayList;

public class Tienda {

private String nombre;
private String direccion;
private ArrayList<String> listaDeProductos;

public Tienda(String nombre, String direccion) {

this.nombre = nombre;
this.direccion = direccion;
this.listaDeProductos = new ArrayList<>();
}

public void agregarProducto(String producto) {

listaDeProductos.add(producto);
}

public void eliminarProducto(String producto) {

listaDeProductos.remove(producto);
}

public void mostrarProductos() {

System.out.println("Productos disponibles en la tienda:");
for (String producto : listaDeProductos) {
 System.out.println(producto);
}
}

public static void main(String[] args) {

Tienda miTienda = new Tienda("Mi Tienda", "Calle Principal");
miTienda.agregarProducto("Televisor");
miTienda.agregarProducto("Computadora");
miTienda.agregarProducto("Smartphone");
miTienda.mostrarProductos();
miTienda.eliminarProducto("Computadora");
System.out.println("\nDespués de eliminar un producto:");
miTienda.mostrarProductos();
}
}

Clase Empleado: Crea una clase Empleado que tenga atributos como nombre,
apellido, salario y métodos para calcular el salario después de un aumento.

public class Empleado {

private String nombre;
private double salario;

public Empleado(String nombre, double salario) {

this.nombre = nombre;
this.salario = salario;
}

public void aumentarSalario(double porcentajeAumento) {

salario += salario * (porcentajeAumento / 100);
}

public double getSalario() {

return salario;
}

public static void main(String[] args) {

Empleado empleado1 = new Empleado("Juan", 2000);
System.out.println("Salario inicial: " + empleado1.getSalario());
 empleado1.aumentarSalario(10);
System.out.println("Salario después del aumento: " + empleado1.getSalario());
}
}

Clase Rectángulo: Crea una clase Rectangulo que tenga atributos base y altura
y métodos para calcular el área y el perímetro del rectángulo.

public class Rectangulo {

private double base;
private double altura;

public Rectangulo(double base, double altura) {

this.base = base;
this.altura = altura;
}

public double calcularArea() {

return base * altura;
}

public double calcularPerimetro() {

return 2 * (base + altura);
}

public static void main(String[] args) {

Rectangulo rectangulo1 = new Rectangulo(5, 3);
System.out.println("Área del rectángulo: " + rectangulo1.calcularArea());
System.out.println("Perímetro del rectángulo: " +
rectangulo1.calcularPerimetro());
}
}

Clase Banco: Crea una clase Banco que tenga atributos como nombre, dirección,
listaDeClientes y métodos para agregar, eliminar y mostrar clientes.

import java.util.ArrayList;

public class Banco {

 private String nombre;
private String direccion;
private ArrayList<String> listaDeClientes;

public Banco(String nombre, String direccion) {

this.nombre = nombre;
this.direccion = direccion;
this.listaDeClientes = new ArrayList<>();
}

public void agregarCliente(String cliente) {

listaDeClientes.add(cliente);
}

public void eliminarCliente(String cliente) {

listaDeClientes.remove(cliente);
}

public void mostrarClientes() {

System.out.println("Clientes del banco:");
for (String cliente : listaDeClientes) {
System.out.println(cliente);
}
}

public static void main(String[] args) {

Banco miBanco = new Banco("Mi Banco", "Calle Principal");
miBanco.agregarCliente("Juan");
miBanco.agregarCliente("María");
miBanco.agregarCliente("Pedro");
miBanco.mostrarClientes();
miBanco.eliminarCliente("María");
System.out.println("\nDespués de eliminar un cliente:");
miBanco.mostrarClientes();
}
}

Clase Coche: Crea una clase Coche que tenga atributos como marca, modelo, año y
métodos para obtener y establecer estos atributos.
public class Coche {
private String marca;
private String modelo;
private int año;

public Coche(String marca, String modelo, int año) {

this.marca = marca;
this.modelo = modelo;
this.año = año;
}

public String getMarca() {

return marca;
}

public String getModelo() {

return modelo;
}

public int getAño() {

return año;
}
public static void main(String[] args) {
Coche coche1 = new Coche("Toyota", "Corolla", 2020);
System.out.println("Marca del coche: " + coche1.getMarca());
System.out.println("Modelo del coche: " + coche1.getModelo());
System.out.println("Año del coche: " + coche1.getAño());
}
}