Programacion Orientada a Objetos
Perfilado de sección
-
https://openwebinars.net/blog/introduccion-a-poo-en-java-objetos-y-clases/
¿Qué es una CLASE en programación?
El concepto de Clase está ligado a la programación orientada a objetos.
Una clase es una herramienta que tenemos para modelar objetos de programación, lograr que se comporten como queremos y hacer tantas copias de estos objetos como necesitemos.
La Programación Orientada a Objetos (POO) es un enfoque de programación que se basa en la creación y manipulación de “objetos”. Estos objetos son entidades que combinan datos y comportamientos en un solo paquete.
En la POO, los objetos tienen atributos que representan sus características o propiedades, y métodos que definen las acciones que pueden realizar. Las clases se utilizan para definir la estructura y el comportamiento de los objetos. Una clase actúa como una plantilla o un modelo a partir del cual se crean objetos individuales con características únicas.
En Términos Generales una clase :
Una clase en programación, fundamental en la Programación Orientada a Objetos (POO), actúa como una plantilla o molde para crear objetos. Define la estructura y el comportamiento de una entidad del mundo real, agrupando atributos (datos o características) y métodos (funciones o acciones) que serán compartidos por los objetos creados a partir de ella.Conceptos Clave de una Clase:- Plantilla/Molde: La clase es el plano teórico, mientras que el objeto es la instancia funcional creada a partir de ese plano.
- Atributos (Datos): Son las variables que definen las características o estado de la clase (ej. nombre, color, tamaño).
- Métodos (Comportamientos): Son funciones definidas dentro de la clase que describen qué pueden hacer los objetos.
- Encapsulación: Las clases permiten agrupar datos y los métodos que los manipulan, ocultando la complejidad interna.
Actividades: 0 -
Constructores
Qué es un constructor
Estructura general en Java
Constructor por defecto
Constructor “de oficio” (vacío explícito)
Constructor paramétrico
Constructor de copia
Ejemplos claros y comparativos¿Qué es un constructor?
Un constructor es un método especial que:
- Tiene el mismo nombre que la clase.
- No tiene tipo de retorno.
- Se ejecuta automáticamente cuando se crea un objeto.
- Se usa para inicializar atributos.
Estructura general de un constructor en Java
public NombreClase(parametros) {
// inicialización
}Reglas importantes:
- No lleva void.
- Puede estar sobrecargado.
- Puede usar this.
Constructor por defecto (implícito)
Definición:
Es el constructor que Java crea automáticamente si la clase no tiene ningún constructor definido.
Si usted define un constructor, Java ya NO genera el constructor por defecto.
Ejemplo
public class Persona {
String nombre;
int edad;
}Aunque no lo veamos, Java genera internamente:
public Persona() {
}Constructor “de oficio” (vacío explícito)
Definición:
Es el constructor vacío que el programador escribe explícitamente.
Se usa cuando:
- Queremos permitir crear objetos sin parámetros.
- Queremos agregar lógica inicial básica.
Estructura
public class Persona {
String nombre;
int edad;
public Persona() {
nombre = "Sin nombre";
edad = 0;
}
}Uso
Persona p1 = new Persona();
Constructor paramétrico
Definición:
Es aquel que recibe parámetros para inicializar los atributos con valores específicos.
Es el más usado en diseño profesional.
Estructura
public class Persona {
String nombre;
int edad;
public Persona(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
}Uso
Persona p1 = new Persona("Carlos", 25);
Aquí se inicializa el objeto con datos reales.
Constructor de copia
Definición:
Es un constructor que recibe un objeto del mismo tipo y crea una copia del mismo.
Java no lo genera automáticamente (a diferencia de C++), se debe programar manualmente.
Estructura
public class Persona {
String nombre;
int edad;
public Persona(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
// Constructor de copia
public Persona(Persona otraPersona) {
this.nombre = otraPersona.nombre;
this.edad = otraPersona.edad;
}
}🔎 Uso
Persona p1 = new Persona("Ana", 30);
Persona p2 = new Persona(p1);Ahora:
- p1 y p2 son objetos distintos en memoria.
- Pero tienen los mismos valores.
Comparación clara para clase
Tipo de Constructor
Parámetros
¿Lo crea Java automáticamente?
Uso principal
Por defecto
No
Sí (si no hay otros)
Inicialización básica
De oficio
No
No
Personalizar inicialización
Paramétrico
Sí
No
Inicialización personalizada
De copia
Objeto mismo tipo
No
Duplicar objetos
Concepto de Método en Programación Orientada a Objetos
Definición
Un método es un bloque de código definido dentro de una clase que describe una acción o comportamiento que puede realizar un objeto. En otras palabras: Un método es una función asociada a una clase que permite ejecutar operaciones sobre los datos del objeto.
Los métodos permiten:
- Organizar el código
- Reutilizar funciones
- Encapsular comportamientos
Estructura de un Método en Java
La estructura general de un método es:
modificador tipoRetorno nombreMetodo(parametros) {
// instrucciones
}Elementos
Elemento
Descripción
modificador
nivel de acceso (public, private, protected)
tipoRetorno
tipo de dato que devuelve
nombreMetodo
identificador del método
parámetros
datos que recibe el método
Los niveles de acceso en Java (public, private, protected, y default) son modificadores que determinan la visibilidad y accesibilidad de clases, métodos y atributos desde otras partes del código. Controlan el encapsulamiento, permitiendo proteger los datos sensibles (private) y definir qué partes son accesibles internamente o globalmente.
- public: Acceso total. El miembro o clase es visible desde cualquier otra clase en cualquier paquete.
- private: Acceso restringido. Solo es visible dentro de la propia clase donde se declara.
- protected: Acceso limitado. Visible dentro del mismo paquete y por subclases (clases hijas) incluso si están en paquetes distintos.
- default (sin modificador): Acceso a nivel de paquete. Visible solo para clases dentro del mismo paquete.
____________________________________
Ejemplo
public int sumar(int a, int b) {
return a + b;
}Este método:
- Es público
- Retorna int
- Recibe dos parámetros
Tipos de Métodos
En Java se pueden clasificar en cuatro casos básicos que son muy útiles pedagógicamente.
Método sin parámetros y sin retorno
public void saludar() {
System.out.println("Hola estudiantes");
}Uso:
saludar();
Método con parámetros y sin retorno
public void mostrarNombre(String nombre) {
System.out.println("Nombre: " + nombre);
}Uso:
mostrarNombre("Carlos");
3. Método sin parámetros y con retorno
public int obtenerNumero() {
return 10;
}Uso:
int n = obtenerNumero();
4. Método con parámetros y con retorno
public double calcularPromedio(double n1, double n2) {
return (n1 + n2) / 2;
}//Uso:
double promedio = calcularPromedio(4.0, 3.5);
Ejercicio Resuelto 1
Clase Calculadora
Problema
Crear una clase Calculadora con métodos para realizar operaciones básicas.
Código
public class Calculadora {
public int sumar(int a, int b) {
return a + b;
}
public int restar(int a, int b) {
return a - b;
}
public int multiplicar(int a, int b) {
return a * b;
}
public double dividir(double a, double b) {
return a / b;
}
}Clase principal
public class Principal {
public static void main(String[] args) {
Calculadora calc = new Calculadora();
System.out.println("Suma: " + calc.sumar(5,3));
System.out.println("Resta: " + calc.restar(10,4));
System.out.println("Multiplicación: " + calc.multiplicar(6,7));
System.out.println("División: " + calc.dividir(10,2));
}
}
Actividades: 0 -
Idea Central
La sobrecarga ocurre cuando una clase tiene dos o más métodos con el mismo nombre, pero con diferentes firmas. (Definición de Firma: Es la combinación del nombre del método + la lista de sus parámetros (cantidad, tipo y orden). El tipo de retorno no forma parte de la firm)a.
¿Por qué es útil para un Ingeniero?
Evita crear nombres genéricos y confusos como sumarEnteros(), sumarDoubles(), sumarTresNumeros(). Simplemente usamos sumar() y dejamos que el compilador elija el correcto.
2. Reglas de Oro
Para que el compilador de Java no se confunda, debe cumplirse al menos una de estas condiciones:
- Diferente número de parámetros.
- Diferentes tipos de datos en los parámetros.
- Diferente orden de los tipos de parámetros.
3. Ejemplo Práctico: Clase LiquidacionNomina
Imagina un sistema que calcula el pago de un empleado. El pago puede variar según los bonos o deducciones.
java
public class CalculadoraNomina {
// 1. Pago básico: Solo salario mensual
public double calcularPago(double salarioBase) {
return salarioBase;
}
// 2. Sobrecarga: Salario + un bono fijo
public double calcularPago(double salarioBase, double bono) {
return salarioBase + bono;
}
// 3. Sobrecarga: Salario + bono + porcentaje de deducción (ej. salud/pensión)
public double calcularPago(double salarioBase, double bono, int porcentajeDeduccion) {
double deduccion = salarioBase * (porcentajeDeduccion / 100.0);
return (salarioBase + bono) - deduccion;
}
}
5. Ejercicio de Reto para el Estudiante
Reto: El Buscador de Precios
Crea una clase llamada Catalogo que tenga un método sobrecargado buscarPrecio():- Si se recibe un String (nombre del producto), devuelve el precio de una lista interna.
- Si se recibe un int (código de barras), busca por código.
- Si se recibe un String (nombre) y un boolean (esMayorista), devuelve el precio con un 20% de descuento.
__________________________________________________________________________________________________________
__________________________________________________________________________________________________________
Métodos de Instancia (Instance Methods)
- Asociación: Ligados a una instancia (objeto) particular de la clase.
- Uso: Modifican o acceden al estado específico del objeto (this en Java/C#, self en Python).
- Invocación: Requieren crear primero el objeto: Objeto obj = new Objeto(); obj.metodo();.
- Ejemplo: factura1.calcularIVA().
Métodos Estáticos (Static Methods / Class Methods)
- Asociación: Ligados a la clase, no a instancias. Se crea una sola copia.
- Uso: Operaciones que no dependen del estado de un objeto, ideales para funciones de utilidad o métodos "fábrica".
- Invocación: Se llaman directamente desde la clase: NombreClase.metodo();.
- Restricciones: No pueden acceder a variables o métodos de instancia directamente.
- Ejemplo: Math.sqrt(16) o Utilidades.convertirMoneda().
Diferencias Clave
Característica
Métodos de Instancia
Métodos Estáticos (de Clase)
Requiere Instancia
Sí (new)
No
Acceso al Estado
Sí (a this/self)
No (solo datos estáticos)
Uso principal
Comportamientos específicos del objeto
Funciones de utilidad/auxiliares
Ejemplo (Java)
void setNombre() {}
static void print() {}
Los Getters y Setters en Java
son métodos públicos utilizados para acceder (get) y modificar (set) el valor de atributos privados de una clase, facilitando el encapsulamiento y la protección de datos. Un getter devuelve el valor, mientras que un setter actualiza el valor del atributo.
public class Persona {
// Atributos privados (encapsulamiento)
private String nombre;
private int edad;
// Constructor
public Persona(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
// Getter para nombre
public String getNombre() {
return nombre;
}
// Setter para nombre
public void setNombre(String nombre) {
this.nombre = nombre;
}
// Getter para edad
public int getEdad() {
return edad;
}
// Setter para edad con validación
public void setEdad(int edad) {
if (edad > 0) {
this.edad = edad;
} else {
System.out.println("La edad no puede ser negativa.");
}
}
}
// Uso de la clase
public class Main {
public static void main(String[] args) {
Persona p = new Persona("Ana", 25);
// Uso de getters
System.out.println(p.getNombre()); // Imprime: Ana
// Uso de setters
p.setNombre("Pedro");
p.setEdad(30);
System.out.println(p.getNombre() + " tiene " + p.getEdad() + " años."); // Pedro tiene 30 años.
}
}
Beneficios y Características:
- Encapsulamiento: Protege las variables de instancia.
- Validación: Los setters pueden validar datos antes de asignarlos (ej. evitar edades negativas).
- Generación Automática: Los IDEs como Eclipse o NetBeans generan estos métodos automáticamente (clic derecho -> "Generate Getters and Setters").
- Convención: Usan la estructura getNombreAtributo() y setNombreAtributo().
Actividades: 0 -
ESTUDIANTES DIURNOS ATENCION - ATENCION - IS02D4
El parcial se aplicara el Jueves 19 de Marzo a partir de la 2:00 pm en punto. tendrá una duración de 120 minutos, Dicho parcial tendrá como objetivo, identificar el nivel de conocimiento que se tiene de la Programación Orientada a Objeto. y su incidencia en el contexto del estudiante. El parcial será estilo Test, con preguntas tipo selección, además de ejercicios prácticos, donde podrá aplicar el conocimiento adquirido.
ESTUDIANTES NOCTRUNO - ATENCION - ATENCION - IS02N1
El modelo de evaluación para estos estudiantes será la aplicación de luna RUBRICA PARA LOS ESTUDIANTES DEL CURSO NOCTURNO.
Criterio
Excelente (5.0)
Bueno (4.0)
Básico (3.0)
Bajo (1–2.9)
Comprensión de POO
Explica claramente los conceptos de clase, objeto y método
Comprende la mayoría de conceptos
Presenta confusión parcial
No reconoce los conceptos
Identificación de clases y objetos
Identifica correctamente clases y objetos en código
Identifica la mayoría
Presenta errores frecuentes
No logra identificarlos
Comprensión de métodos
Reconoce correctamente estructura y uso
Reconoce parcialmente
Confunde parámetros o retorno
No identifica métodos
Sobrecarga de métodos
Identifica correctamente sobrecarga en ejemplos
Reconoce algunos casos
Confunde con otros conceptos
No reconoce sobrecarga
Interpretación de código
Analiza correctamente código Java
Interpreta parcialmente
Presenta errores frecuentes
No logra interpretar
Criterio
Excelente (5.0)
Bueno (4.0)
Básico (3.0)
Bajo
Definición de clase
Clase correctamente definida
Pequeños errores
Estructura incompleta
Incorrecta
Uso de atributos
Atributos correctos y bien usados
Algunos errores
Uso limitado
No funciona
Implementación de métodos
Métodos correctos y funcionales
Funciona parcialmente
Errores lógicos
No funciona
Sobrecarga de métodos
Sobrecarga correcta
Intento válido
Implementación incorrecta
No existe
Ejecución del programa
Programa ejecuta correctamente
Errores menores
Errores frecuentes
No ejecuta
Criterio
Excelente (5.0)
Bueno (4.0)
Básico (3.0)
Bajo
Documento presentado
Presentan un excelente documento con las normas APA
Presentan un buen documento con las normas APA
Presentan un aceptable documento con las normas APA
NO Presentan un documento con las normas APA
Presentación
Utilizan una excelente herramienta digital para sustentar el proyecto
Utilizan una buena herramienta digital para sustentar el proyecto
Utilizan una aceptable herramienta digital para sustentar el proyecto
NO Utilizan herramienta digital para sustentar el proyecto
Definición de clase
Clase correctamente definida
Pequeños errores
Estructura incompleta
Incorrecta
Uso de atributos
Atributos correctos y bien usados
Algunos errores
Uso limitado
No funciona
Implementación de métodos
Métodos correctos y funcionales
Funciona parcialmente
Errores lógicos
No funciona
Sobrecarga de métodos
Sobrecarga correcta
Intento válido
Implementación incorrecta
No existe
Ejecución del programa
Programa ejecuta correctamente
Errores menores
Errores frecuentes
No ejecuta
Presentación Personal
Su presentación personal es excelente
Su presentación personal es buena
Su presentación personal es aceptable
Deb mejorar la presentación personal
Puntual
Se presenta puntual a la sustentación
Debe mejorar en su puntualidad
No es puntual al llegar
Coordinación
El equipo demuestra excelente coordinación en la sustentación
El equipo demuestra buena coordinación en la sustentación
El equipo demuestra poca coordinación en la sustentación
El equipo No demuestra coordinación en la sustentación
Mejo del tiempo
Utilizan el tiempo acordado para la sustentación
Se les dificulta Utilizan el tiempo acordado para la sustentación
NO Utilizan el tiempo acordado para la sustentación
Actividades: 0 -
Java Encapsulamiento y reutilización
En Java el concepto de encapsulamiento es de los primeros que aparece y hace referencia a limitar el acceso a las variables de nuestras clases Java de tal forma que podamos tener un mayor control sobre ellas. Normalmente utilizando métodos set/get.
El encapsulamiento en Java es un principio de la programación orientada a objetos (POO) que agrupa datos (atributos) y métodos en una sola unidad (clase), restringiendo el acceso directo a los componentes internos. Se logra usando modificadores de acceso (private,protected) y métodosgetter/setterpara proteger la integridad de los datosAspectos Clave del Encapsulamiento:- Ocultamiento de datos: Los atributos de una clase se declaran como
privatepara que no sean accesibles directamente desde fuera de la clase. - Métodos Getter y Setter: Se proporcionan métodos públicos para leer (
get) o modificar (set) los valores de los atributos privados, permitiendo validar la información antes de cambiarla.
Seguridad y Control: Evita la modificación accidental o incorrecta de los datos, mejorando la robustez del código.Flexibilidad: Permite cambiar la implementación interna de una clase sin afectar a las clases que la utilizanEjemplo de encapsulación en Java
A continuación se muestra un ejemplo que demuestra cómo lograr la encapsulación en Java:
/* File name : EncapTest.java */ public class EncapTest { private String name; private String idNum; private int age; public int getAge() { return age; } public String getName() { return name; } public String getIdNum() { return idNum; } public void setAge( int newAge) { age = newAge; } public void setName(String newName) { name = newName; } public void setIdNum( String newId) { idNum = newId; } }Los métodos públicos setXXX() y getXXX() son los puntos de acceso a las variables de instancia de la clase EncapTest . Normalmente, estos métodos se denominan getters y setters. Por lo tanto, cualquier clase que desee acceder a las variables debe hacerlo a través de estos getters y setters.
Se puede acceder a las variables de la clase EncapTest mediante el siguiente programa:
/* File name : RunEncap.java */ public class RunEncap { public static void main(String args[]) { EncapTest encap = new EncapTest(); encap.setName("James"); encap.setAge(20); encap.setIdNum("12343ms"); System.out.print("Name : " + encap.getName() + " Age : " + encap.getAge()); } } public class EncapTest { private String name; private String idNum; private int age; public int getAge() { return age; } public String getName() { return name; } public String getIdNum() { return idNum; } public void setAge( int newAge) { age = newAge; } public void setName(String newName) { name = newName; } public void setIdNum( String newId) { idNum = newId; } }Beneficios de la encapsulación
-
Los campos de una clase pueden configurarse como de solo lectura o de solo escritura.
-
Una clase puede tener control total sobre lo que se almacena en sus campos.
Encapsulación de Java: Clase de solo lectura
Una clase de solo lectura solo puede tener métodos getter para obtener los valores de los atributos; no debe tener ningún método setter.
Ejemplo: Creación de una clase de solo lectura
En este ejemplo, definimos una clase Person con dos métodos getter: getName() y getAge() . Estos métodos se pueden usar para obtener los valores de los atributos declarados como privados en la clase.
// Class "Person" class Person { private String name = "Robert"; private int age = 21; // Getter methods public String getName() { return this.name; } public int getAge() { return this.age; } } public class Main { public static void main(String args[]) { // Object to Person class Person per = new Person(); // Getting and printing the values System.out.println("Name of the person is: " + per.getName()); System.out.println("Age of the person is: " + per.getAge()); } }Encapsulación de Java: Clase de solo escritura
Una clase de solo escritura solo puede tener métodos setter para establecer los valores de los atributos; no debe tener ningún método getter.
Ejemplo: Creación de una clase de solo escritura
En este ejemplo, definimos una clase Person con dos métodos setter: setName() y setAge() . Estos métodos se pueden usar para establecer los valores de los atributos declarados como privados en la clase.
// Class "Person" class Person { private String name; private int age; // Setter Methods public void setName(String name) { this.name = name; } public void setAge(int age) { this.age = age; } } public class Main { public static void main(String args[]) { // Object to Person class Person per = new Person(); // Setting the values per.setName("Robert"); per.setAge(21); } }Encapsulación en Java: Más ejemplos
Ejemplo 1: Clase Persona (totalmente encapsulada)
Este ejemplo crea una clase completamente encapsulada llamada "Persona". Esta clase tiene atributos de clase privados, métodos setter y getter.
// Class "Person" class Person { private String name; private int age; // Setter Methods public void setName(String name) { this.name = name; } public void setAge(int age) { this.age = age; } // Getter methods public String getName() { return this.name; } public int getAge() { return this.age; } } // The Main class to test encapsulated class "Person" public class Main { public static void main(String args[]) { // Objects to Person class Person per1 = new Person(); Person per2 = new Person(); // Setting the values per1.setName("Robert"); per1.setAge(21); per2.setName("Riyan"); per2.setAge(22); // Printing the values System.out.println("Person 1: Name : " + per1.getName() + " Age : " + per1.getAge()); System.out.println("Person 2: Name : " + per2.getName() + " Age : " + per2.getAge()); } }Ejemplo 2: Clase Empleado (Totalmente Encapsulada)
Este ejemplo crea una clase completamente encapsulada llamada "Empleado". Esta clase tiene atributos de clase privados, métodos setter y getter.
// Class "Employee" class Employee { private String emp_name; private String emp_id; private double net_salary; // Constructor public Employee(String emp_name, String emp_id, double net_salary) { this.emp_name = emp_name; this.emp_id = emp_id; this.net_salary = net_salary; } // Getter methods public String getEmpName() { return emp_name; } public String getEmpId() { return emp_id; } public double getSalary() { return net_salary; } // Setter methods public void setEmpName(String emp_name) { this.emp_name = emp_name; } public void setEmpId(String emp_id) { this.emp_id = emp_id; } public void setSalary(double net_salary) { this.net_salary = net_salary; } } // The Main class to test encapsulated class "Employee" public class Main { public static void main(String args[]) { // Objects to Employee class // First object - setting values using constructor Employee emp = new Employee("Robert", "EMP001", 75450.00); // Printing data System.out.println("Employee (Intial Values):"); System.out.println(emp.getEmpId() + " , " + emp.getEmpName() + " , " + emp.getSalary()); // Updating values using setter methods emp.setEmpName("Riyan"); emp.setEmpId("EMP002"); emp.setSalary(90500.00); // Printing data System.out.println("Employee (Updated Values):"); System.out.println(emp.getEmpId() + " , " + emp.getEmpName() + " , " + emp.getSalary()); } }ACTIVIDAD
Tome el código que esta propuesto en este documento, e impleméntelo en Netbeans.
Deberá presentarlo ya desarrollado en nuestro próximo encuentro académico (próxima clase)
Actividades: 0 - Ocultamiento de datos: Los atributos de una clase se declaran como
-
Actividades: 0
-
Actividades: 0
-
Actividades: 0
-
Actividades: 0
-
Actividades: 0
-
Actividades: 0
-
Actividades: 0
-
Actividades: 0
-
Actividades: 0
-
Actividades: 0
-
Actividades: 0