“Año del Bicentenario, de la consolidación de nuestra Independencia, y de la

conmemoración de las heroicas batallas de Junín y Ayacucho”

Universidad Nacional “San Luis Gonzaga”

Facultad de Ingeniería de Sistemas

▪ Asignatura: Algoritmos y Estructura de Datos.

▪ Docente: Dr. Lino Martin Quispe Tincopa.
▪ Tema: Programación orientada a objetos usando java.
▪ Estudiantes:
- Chinchero Fernández Joao.
- Diaz Cuba Miguel.
- Patiño García Rosmery.
- Quispe Centeno Schubert.
▪ Ciclo: III Sección: “A”

2024
Ica – Perú
 RESUMEN CAPITULO 3: Conceptos básicos de
programación orientada a objetos

Reprogramación orientada a objetos se define como

un paradigma que permite realizar una abstracción
de la realidad que se puede interpretar en una
aplicación de software con el fin de resolver
problemas mediante el uso de un lenguaje de
programación
El paradigma de orientación a objetos comprende
una gran cantidad de conceptos que permite el desarrollo de aplicaciones robustas.
3.1 Paquete
Un paquete hizo un contenedor de clases, se utiliza para ordenar el código de forma
consistente de acuerdo a los servicios implementados.
package MiPaquete;
En donde “Mipaquete” es el nombre del paquete que contendrá el código Por otro lado si se
desea hacer uso de servicios implementados en otros paquetes se debe agregar el
siguiente código.
Java contiene una gran cantidad de paquetes que proveen una gran cantidad de servicios a
continuación una pequeña muestra de estos paquetes:

3.2 Clase
Una clase se define como un tipo extracto de dato que contiene atributos y métodos a
través de una clase se implementa un concepto abstraído de la realidad en este caso los
atributos hacen referencia a las características del concepto extraído y los métodos hacen
referencia a los servicios de dicho concepto.
-Atributos
Los atributos hacen referencia a las características que se le incluyen a la clase. Estos
atributos pueden ser declaraciones de tipos primitivos de datos o declaraciones de clases.
-Visibilidad
La visibilidad se refiere al nivel de accesibilidad de los atributos y métodos. Los niveles de
accesibilidad se dan por los siguientes términos
Private. Se puede acceder desde un método implementado desde la misma clase
Public. Se puede acceder desde un método implementado en cualquier clase
Protected. Se puede acceder desde un método implementado de una clase que herede la
clase que contiene esta visibilidad y es desde clases implementadas en el mismo paquete
-Métodos
Los métodos hacen referencia a los servicios que se incluyen a la clase. En estos métodos
se implementan el código necesario del servicio
Visibilidad. se debe establecer si el método es private public o protected.
Retorno. un método puede retornar Información. Si el método no retorno información se
debe colocar la palabra reservada void.
El retorno puede ser un tipo primitivo de dato o una clase si un método tiene retorno en la
implementación del método debe estar presente la palabra reservada return.
Nombre. identificador del método en la clase.
Parámetros. un método puede recibir de cero a n parámetros un parámetro puede ser un
tipo primitivo de dato una declaración de una clase los parámetros deben estar separados
por comas.
-Encapsulamiento
Eso característica que indica que los atributos que definen propiedades propias de la clase
deben tener visibilidad private, de esta forma se ofrece seguridad a la información
depositada en dichos atributos
-Apuntador “this”
El apuntador this permite acceder a los atributos y métodos de la clase, el uso del
apuntador no es obligatorio pero se recomienda usarlo como buena práctica es posible que
el parámetro de un método tenga el mismo nombre que un atributo en este caso el uso del
apuntador this es obligatorio para que la compilador identifique si estaba haciendo
referencia al atributo o al parámetro del método
3.3 Objeto
Un objeto es la referencia a instancia de una clase a crear una referencia se asigna a un
espacio de memoria dinámica al objeto pero no es utilizable al crear la instancia el objeto
es utilizable
3.4 Sentencia static
Una clase puede tener atributos y/o métodos propios o no del objeto la sentencia Static
define estos atributos y métodos de tal forma que puedan ser accedidos sin requerir una
instancia de la clase Por otro lado un atributo Static toma el mismo valor para todos los
objetos que sean instancia de la clase que lo contiene
3.5 Sentencia final
Una clase puede tener atributos finales que hacen referencia a constantes que no pueden
cambiar su valor en tiempo de ejecución de la aplicación.
3.6 Clasificacion de métodos: Se pueden clasificar de 4 tipos:
1.Constructores: Un constructor es un método especial que se ejecuta automáticamente
al crear una instancia de una clase. Se utiliza para inicializar los atributos de la clase. Debe
tener visibilidad pública, no tiene tipo de retorno y puede estar sobrecargado.

2.Consultores: También conocidos como getters, son métodos que permiten acceder al
valor de un atributo privado de una clase. Ayudan a implementar el concepto de
encapsulamiento.

3.Modificadores: También llamados setters, son métodos que permiten asignar un valor a
un atributo privado de una clase. También son parte del concepto de encapsulamiento.

4.Analizadores: Son métodos que implementan la lógica de un servicio en una clase. Aquí
se pueden implementar algoritmos requeridos para la manipulación de los atributos de la
clase.

3.7 Sobrecarga de métodos: Es la capacidad de definir varios métodos con el mismo

nombre pero con diferentes parámetros o tipos de retorno. Esto permite mayor flexibilidad y
reutilización de nombres de métodos.

3.8 Recursividad: Es la capacidad de un método de llamarse a sí mismo. Se utiliza para

resolver problemas de manera iterativa y puede ser útil en algoritmos fractales y de árboles.

3.9 Bajo acoplamiento: Es un principio de diseño que sugiere que las clases deben tener
una dependencia mínima entre sí. Esto se logra separando las responsabilidades de las
clases y reduciendo la interdependencia.

3.10 Alto cohesión: Es otro principio de diseño que sugiere que los elementos de una
clase deben estar relacionados y enfocados en una sola tarea o responsabilidad. Una clase
con alta cohesión es más fácil de entender y mantener.
3.11 Manejo de excepciones: Las excepciones son condiciones anormales que pueden
ocurrir durante la ejecución de un programa. En Java, se manejan mediante las estructuras
try-catch y throws, que permiten controlar y gestionar estos errores de manera adecuada.
3.11.1 Estructura try, catch y finally:
Las excepciones en Java deben ser capturadas mediante el uso de las estructuras "try",
"catch" y finally. En el bloque try se debe implementar el código del proceso que se desea
ejecutar.

Sobrecarga de métodos:
La sobrecarga de métodos es una de las características de la programación orientada a
objetos que permite definir múltiples métodos en una clase con el mismo nombre pero con
diferentes parámetros o tipos de retorno esto brinda flexibilidad al programador y facilita
la reutilización del código
public class Calculadora {
// Método sobrecargado 1: Suma de dos números enteros
public int sumar(int a, int b) {
return a + b;
}

// Método sobrecargado 2: Suma de tres números enteros

public int sumar(int a, int b, int c) {
return a + b + c;
}

// Método sobrecargado 3: Suma de dos números decimales

public double sumar(double a, double b) {
return a + b;
}
}

En este ejemplo la clase calculadora define tres métodos llamados sumar cada uno con
una lista diferente de parámetros esto permite utilizar mimo nombre de método para
realizar operaciones de suma con diferentes tipos de datos y números de
argumentos recursividad.
La recursividad es una técnica de la programación que implica la llamada un método
desde sí mismo esto crea un ciclo donde la función se llama repetidamente hasta que se
cunmpla una condicion de salida la recursividad se puede utilizar como alternativa a la
estructura de repetición como “while” o “for”
Ejemplo:
public class Factorial {
// Método recursivo para calcular el factorial de un número
public int factorial(int n) {
if (n == 0 || n == 1) {
return 1; // Caso base: factorial de 0 y 1 es 1
} else {
return n * factorial(n - 1); // Llamada recursiva
}
}
}

En este ejemplo el método de factorial calcula el factorial de un número n utilizando

recursión la función se llama así misma con un argumento decrementado en cada
interacción hasta alcanzar el caso donde n es 0 o 1,
Alta cohesión:
La alta cohesión es un principio de diseño de software que se refiere a la media en que
los elementos de un módulo o componente están relacionados y se centran en realizar
una única tarea de responsabilidad un alto nivel de cohesión índice que los elementos de
un modulo están estrechamente relacionados y trabajan juntos para lograr un propósito
común este principio promueve la modularidad el mantenimiento y la comprensión del
código.
public class OperacionesMatematicas {
// Métodos con alta cohesión para realizar operaciones matemáticas básicas

// Método para sumar dos números enteros

public int sumar(int a, int b) {
return a + b;
}

// Método para restar dos números enteros

public int restar(int a, int b) {
return a - b;
}

// Método para multiplicar dos números enteros

public int multiplicar(int a, int b) {
return a * b;
}
 // Método para dividir dos números enteros
public double dividir(int a, int b) {
if (b != 0) {
return (double) a / b;
} else {
throw new ArithmeticException("No se puede dividir por cero");
}
}
}

En este ejemplo, la clase Operaciones Matemáticas tiene métodos que realizan

operaciones matemáticas básicas como sumar, restar, multiplicar y dividir. Cada método
tiene una responsabilidad clara y se centra en realizar una sola operación matemática, lo
que demuestra un alto nivel de cohesión en la clase. Esto facilita la comprensión y el
mantenimiento del código, ya que cada método se ocupa de una tarea específica.
Ejercicios Propuestos:
1. . Implemente una clase denominada Cuadrado que contenga un atributo privado,
dos métodos constructores sobrecargados con y sin parámetros, métodos
consultores, métodos modificadores y métodos analizadores que calculen el área y
perímetro del cuadrado:
import java.util.Scanner;
public class cuadrado {
private double lado;

//constructor sin parametros

public cuadrado() {
this.lado = 0.0;
}

//con parámetro
public cuadrado(double lado) {
this.lado = lado;
}

//consultor
public double getLado() {
return lado;
 }

// modificador
public void setLado(double lado) {
this.lado = lado;
}
// metodo analizador para el area
public double calcularArea() {
return lado * lado;
}
// metodo analizador para el perimetro
public double calcularPerimetro() {
return 4 * lado;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

System.out.print("Ingrese el lado del cuadrado: ");

double lado = scanner.nextDouble();
cuadrado cuadrado = new cuadrado(lado);
System.out.println("Constructor sin parametros: lado = " + new
cuadrado().getLado());
System.out.println("Constructor con parametro: lado = " + cuadrado.getLado());
System.out.println("Metodo consultor : lado = " + cuadrado.getLado());
System.out.println("Metodo analizador : area = " + cuadrado.calcularArea());
System.out.println("Metodo analizador : perimetro = " +
cuadrado.calcularPerimetro());
System.out.print("Ingrese un nuevo valor para el lado: ");
double nuevoLado = scanner.nextDouble();
cuadrado.setLado(nuevoLado);
System.out.println("Metodo modificador : lado = " + cuadrado.getLado());
System.out.println("Metodo analizador : area = " + cuadrado.calcularArea());
System.out.println("Metodo analizador : perimetro = " +
cuadrado.calcularPerimetro());
}
}
2. Implemente una clase denominada Triángulo que contenga un atributo privado,
dos métodos constructores sobrecargados con y sin parámetros, métodos
consultores, métodos modificadores y métodos analizadores que calculen el área
y perímetro del triángulo:
3.Implemente una clase denominada Rectángulo que contenga un atributo privado,
dos métodos constructores sobrecargados con y sin parámetros, métodos
consultores, métodos modificadores y métodos analizadores que calculen el área y
perímetro del rectángulo:
public class rectangulo {
// Atributo privado
private double longitud;
private double ancho;

// Constructor sin parámetros

public rectangulo() {
longitud = 0.0;
ancho = 0.0;
}

// Constructor con parámetros

public rectangulo(double longitud, double ancho) {
this.longitud = longitud;
this.ancho = ancho;
}

// Métodos consultores
public double getLongitud() {
return longitud;
}

public double getAncho() {

return ancho;
}

// Métodos modificadores
public void setLongitud(double longitud) {
this.longitud = longitud;
}
 public void setAncho(double ancho) {
this.ancho = ancho;
}

// Método analizador para calcular el area

public double calcularArea() {
return longitud * ancho;
}

// Método analizador para calcular el perimetro

public double calcularPerimetro() {
return 2 * (longitud + ancho);
}

public static void main(String[] args) {

// Ejemplo de uso
rectangulo rectangulo1 = new rectangulo();
System.out.println("Area: " + rectangulo1.calcularArea());
System.out.println("Perimetro: " + rectangulo1.calcularPerimetro());

rectangulo rectangulo2 = new rectangulo(5.0, 3.0);

System.out.println("Area: " + rectangulo2.calcularArea());
System.out.println("Perimetro: " + rectangulo2.calcularPerimetro());
}
}
//El problema no especifico que los datos tenian que ser ingresados por teclado
4.Implemente una clase denominada Operaciones, que contenga métodos estáticos
que calculen el factorial de un numero y que verifiquen si un numero es primo: