UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS

AÑO DEL BICENTENARIO DEL PERÚ: 200 AÑOS DE INDEPENDENCIA

E.P. INGENIERÍA DE SISTEMAS
ASIGNATURA DE POO

DOCENTE: Luis Ángel Guerra Grados

GRUPO: 7

TAREA N°3

INTEGRANTES:
Barbieri Canales, Marcelo Alessandro
Noa Romero, Luis Diego
Vilca Velasquez, Javier Alberto
Chavez Torres, Diego Alonso
Romero Ovalle, Antony Samuel

LIMA- PERÚ

Ciudad Universitaria, 2021

 EJERCICIO 1
Generar una lista de teléfonos. La lista debe ser un objeto que encapsula la matriz de
objetos persona, la clase CPersona define los atributos privados nombre, dirección,
teléfono relativos a una persona, métodos respectivos que en un menú de opciones
permita: añadir, eliminar y buscar en una lista.

Análisis del problema

● Se utilizará el método Ingresar( ) para pedir los datos de las personas
● Se utilizará el método Mostrar( ) para visualizar los datos
● Se utilizará el método Buscar( ) para encontrar una persona registrada
●
Diagrama de clases

Clase CPersona

Atributos:
nombre
direccion
telefono

Metodos:
CPersona(....)
AsignarNombre(....)
ObtenerNombre(....)
AsignarTelefono(...)
ObtenerTelefono(...)
AsignarDireccion(...)
ObtenerDireccion(...)

Clase ArregloPersona

Atributos:
CPersona[ ] pe

Métodos:
ArregloPersona( )
Ingresar( )
Mostrar( )
Buscar( )

Código en java
public class CPersona {
//Declaracion de atributos
private String telefono;
private String nombre;
private String direccion;
//Metodo constructor
public CPersona(){
}

public CPersona(String nom,String tel,String dir){

nombre=nom;
telefono=tel;
direccion=dir;
}
//Metodos Set y Get
public void setTelefono(String tel){
telefono=tel;
}

public void setNombre(String nom){

nombre=nom;
}

public void setDireccion(String dir){

direccion=dir;
}

public String getTelefono() {

return telefono;
}

public String getNombre() {

return nombre;
}

public String getDireccion() {

return direccion;
}

}// fin de la clase

public class ArregloPersona {

CPersona pe[];
public ArregloPersona(){
pe= new CPersona [100];
}
public static int menu(){
Scanner leer = new Scanner(System.in);
int op;

System.out.println("1. Ingresar datos.");

System.out.println("2. Mostrar datos.");
 System.out.println("3. Buscar.");
System.out.println("4. Salir");
do{
System.out.println("Ingrese una opcion:");
op=leer.nextInt();
}while(op<1 || op>4);
return op;
}
public static void main(String args []){
Scanner leer = new Scanner(System.in);
CPersona pe[]=new CPersona[100];
String nombre_i,direccion_i,telefono_i = null;
int cant,opc,dato=2;
System.out.println("Ingrese el numeros de personas: ");
cant=leer.nextInt();
do{
opc=menu();
switch(opc){
case 1 -> { //Metodo ingresar datos
for(int i=0; i<cant; i++){
leer.nextLine();
System.out.println("Nombre: ");
nombre_i=leer.nextLine();
System.out.println("Telefono: ");
telefono_i=leer.nextLine();
System.out.println("Direccion: ");
direccion_i=leer.nextLine();

pe[i]= new CPersona(nombre_i, telefono_i ,direccion_i);

}

case 2 -> { //Metodo visualizar datos

for(int i=0; i<cant; i++){

System.out.println(" \n Nombre: "+pe[i].getNombre()+"\n Telefono:

"+pe[i].getTelefono()+"\n Direccion: " +pe[i].getDireccion());
}
}
case 3 ->{ //Metodo buscar dato
System.out.println("Ingrese el telefono ");
telefono_i=leer.nextLine();
for(int i=0;i<cant;i++){
if(telefono_i.equals(pe[i].getTelefono())){
dato=1;
System.out.println(" \n Nombre: "+pe[i].getNombre()+"\n Telefono:
"+pe[i].getTelefono()+"\n Direccion: " +pe[i].getDireccion());
 }
else
dato=2;

}
if(dato==2){
System.out.println("Telefono no encontrado ");
}

}
}
}while(opc!=4);
}
}

EJERCICIO 2

Dada la clase Test de Personalidad, con los datos: código, nombre del Test, y número de
preguntas; definir un arreglo de Test de Personalidad sabiendo que ellos son:
- Test de inteligencia (11 preguntas)
- Test de la comunicación (20 preguntas)
- Test del éxito profesional (18 preguntas)
- Test del carácter (14 preguntas)
- Test de tipo de personalidad (22 preguntas)
- Test de Extroversión e Introversión (8 preguntas)
- Test de Gastón Berger (10 preguntas)
- Test de Thompson (17 preguntas)
- Test de palabras (5 preguntas)
- Test de colores y Nombres (5 preguntas)
- Test de Personalidad afectiva (40 preguntas)
para permitir: ingresar y agregar por código de test cuando éste no exista, luego mostrar los
test ingresados con el número de preguntas.
Al ingresar se debe buscar si el código de Test existe o no en el arreglo, para poder agregar,
o, no. Al añadir un elemento, se actualiza la longitud del arreglo de objetos, y luego se
añade el objeto al final.
Presentar las opciones de ingreso y muestra de datos, en un menú de opciones.

Análisis del problema

● Se usa el método de objeto arreglo para el almacenamiento de datos enteros o
cadena.
● Se recurre a métodos get y set para el guardado y retorno de datos.
● Se emplea el método constructor de datos para el envío de datos ingresados a
través de los parámetros establecidos.
 ● Se emplea la variable estática para crear un método que permita elaborar un menú
de opciones.

SOLUCIÓN:

Diagrama de clases

Clase Objeto_test

Atributos:
nombre_test
código
nro_preguntas

Métodos:
Constructor(...)
Constructor_sobrecargadedatos(...)
AsignarNombre(....)
ObtenerNombre(....)
AsignarCodigo(...)
Obtenercodigo(...)
AsignarPreguntas(...)
ObtenerPreguntas(...)

Clase Test_personalidad

Atributos:
Ca[ ]

Métodos en la clase principal:

Crearmenu(...)
ObtenerRepetido(...)
MetodoPrincipal(...)

Pseudocódigo(Análisis)

Paquete Arreglo_menu;

Público clase Objeto_test {

//ATRIBUTOS
Privado cadena nombre_test
Privado entero código
Privado entero n_preguntas;

//Método constructor
Public Objeto_test(){
nombre_test="";
 n_preguntas=0;
codigo=' ';
}

//Método sobrecarga de datos

Público Objeto_test(Cadena q, Entero r, Entero s ){
nombre_test ← q
código ← r
n_preguntas ← s
}Fin método sobrecarga

//Metodo set
Público vacío setnombre(Cadena n){
nombre_test ← n
}

Público vacio setcodigo(Int c){

código ← c
}

Público vacio setpreguntas(Entero n){

n_preguntas ← n
}

// Método get
Publico cadena getnombre(){
retornar nombre_test
}

Público entero getcodigo(){

retornar codigo;
}

Público entero getpreguntas(){

retornar n_preguntas
}
}Fin Clase Objeto_test

Paquete Arreglo_menu

importar java.util.Scanner

Público clase Test_personalidad {

//Método crear menu

Público estático entero menú(){

 Scanner leer = new Scanner(System.in);

Entero op

Escribir("1. Ingresar datos.")

Escribir"2. Mostrar información registrada.")

Escribir("3. Salir.")

Hacer{

System.out.println("Ingrese una opción:");

op=leer.nextInt()

}Hasta(op>1 & op<3)

retornar op

}Fin Método menú

//Método Valor repetido

Público estático booleano repetido(Entero codigo, Entero i){

Objeto_test a[]= nuevo Objeto_test[100];

Para k=0, hasta k<i; con paso de 1{

Si( a[k].getcodigo== código)

Retornar verdadero

}Fin para

Retornar falso

}Fin método repetido

Público estático vacío principal (){

Scanner leer = nuevo Scanner(System.in);

Objeto_test a[]= nuevo Objeto_test[100];

Entero n_t = 0;

Cadena nombre

Entero código

Entero nro_preguntas
Entero opcion

Escribir("Ingrese el número de Test a ingresar: ");

leer(n_t)

Hacer{

opción=menú();

Según(opción) Hacer

Caso 1:

Para i=0; Hasta n_t; con paso de 1{

Escribir("Ingrese el nombre del Test: ")

leer(nombre)

Escribir("Ingrese el código del Test: ")

Leer(código)

Mientras(repetido(código,i)) Hacer

Escribir("----El código ya existe----")

Escribir("Ingrese el código del Test: ")

leer(código)

escribir("Ingrese el número de preguntas para el Test: ");

leer(nro_preguntas)

a[i]= new Objeto_test(nombre, código ,nro_preguntas);

Fin Caso 1

Caso 2:

Para i=0; Hasta n_t; con paso de 1 {

Mostrar (a[i].getnombre()+a[i].getcodigo()+a[i].getpreguntas());

}
 Fin Caso 2

}Fin Según

}Hasta(opción=3)

}Fin método Principal

}Fin clase Test_personalidad

Código

package Arreglo_menu;
import java.util.Scanner;
public class Test_personalidad {
public int[]a;
//MÉTODO CREAR MENU DE OPCIONES
public static int menu(){
Scanner leer = new Scanner(System.in);
int op;
System.out.print("\033[H\033[2J");
System.out.println("1. Ingresar datos.");
System.out.println("2. Mostrar informacion registrada.");
System.out.println("3. Salir.");
do{
System.out.println("Ingrese una opcion:");
op=leer.nextInt();
}while(op<1 || op>3);
return op;
}

//MÉTODO QUE PERMITE IDENTIFICAR EL VALOR REPETIDO

public static boolean repetido(int codigo, int i){
Objeto_test a[]= new Objeto_test[100];
for(int k=0; k<i; k++){
if(a[k].getcodigo()== codigo)
return true;
}
return false;
}

//MÉTODO PRINCIPAL
public static void main(String[] args){
Scanner leer = new Scanner(System.in);
Objeto_test a[]= new Objeto_test[100];

int n_t = 0;
 String nombre;
int codigo = 0;
int nro_preguntas;
int opcion;

System.out.println("Ingrese el numeros de Test: ");

n_t=leer.nextInt();

do{
opcion=menu();
switch(opcion){
case 1:
for(int i=0; i<n_t; i++){
System.out.print("\033[H\033[2J");
System.out.println("Ingrese el nombre del Test: ");
nombre=leer.nextLine();

System.out.println("Ingrese el codigo del Test: ");

codigo=leer.nextInt();
leer.nextLine();
while(repetido(codigo,i)){
System.out.println("----El codigo ya existe----");
System.out.println("Ingrese el codigo del Test: ");
codigo=leer.nextInt();
}
System.out.println("Ingrese el numero de preguntas para el Test: ");
nro_preguntas=leer.nextInt();
leer.nextLine();
a[i]= new Objeto_test(nombre, codigo ,nro_preguntas);
}
break;
case 2:
for(int i=0; i<n_t; i++){
System.out.print("\033[H\033[2J");
System.out.println(a[i].getnombre()+a[i].getcodigo()+a[i].getpreguntas());
}
break;
}
}while(opcion!=3);
}
}

package Arreglo_menu;
public class Objeto_test {
private String nombre_test;
private int codigo;
private int n_preguntas;
 //METODOS CONSTRUCTOR
public Objeto_test(){
nombre_test="";
n_preguntas=0;
codigo=0;
}
//METODOS SOBRECARGA DE DATOS
public Objeto_test(String q, int r, int s ){
nombre_test=q;
codigo=r;
n_preguntas=s;
}
//METODOS SET
public void setnombre(String n){
nombre_test=n;
}
public void setcodigo(int c){
código=c;
}
public void setpreguntas(int n){
n_preguntas=n;
}

//METODOS GET
public String getnombre(){
return nombre_test;
}
public int getcodigo(){
return codigo;
}
public int getpreguntas(){
return n_preguntas;
}
}
 EJERCICIO 4
SOLUCIÓN:
PAQUETE paqueteCelular

CLASE celula {

//ATRIBUTOS

Privado caracter c = Nuevo caracter [11]

Público celula () {}

Público celula (carácter [] gi) {

c ← gi

//PROCEDIMIENTOS

Público caracter [] getC () {

Retornar c

Público vacío mostrar () {

Para I ← 0 hasta 11 haga

Escribir (gectC () [i])

Público vacío setC (caracter [] c) {

This.c ← c

}
}

PAQUETE paqueteCelular

CLASE arregloCelula {

//ATRIBUTOS

Celula [] ac

Entero nElementos

//PROCEDIMIENTOS

Publico arregloCelula () {

nElementos ← 0

ac ← Nuevo celula [nElementos]

Publico vacio unElementoMas (celula [] ac1) {

nElementos ← ac1.length

ac ← nuevo celula [nElementos + 1]

Para i=0 hasta nElementos haga

ac [i] ← ac1 [i]

nElementos ← nElementos + 1

Publico vacio ponerValorEn (entero i, celula objeto) {

Si (i >= 0 AND i< nElementos)

Ac [i] ← objeto

SINO

Escribir (“Índice fuera de limites”)

FINSI
}

Publico vacio agregar (celula oc) {

UnElementoMas (ac)

PonerValorEn (nElementos – 1, oc)

Público vacio generacionInicial () {

Carácter tgi [] ← {'_','_','_','_','_','*','_','_','_','_','_'};

Celula oc ← nueva celula ()

Oc. setC (tgi)

Agregar (oc)

Publico vacio SiguienteGeneracion () {

Carácter []c ← nuevo carácter [11]

C ← ac[nElementos-1]. getC ()

Carácter [] tc ← nuevo carácter [11]

Para j=0 hasta 11

SI (j = 0)

SI (c[j] = ‘_’ AND c[10] = ’*’)

tc [j] = ‘*’

SINO

SI (c[j] = ‘_’ AND c[j+1] =’*’)

Tc [j] ← ‘*’

SINO

SI (c[j]='*' AND c [10] ='_' AND c[j+1] =='_')

Tc [j] ← ‘*’

SINO

SI (c[j]=='*' AND c[j+1] =='*')

Tc [j] ← ‘*’
 SINO

Tc [j] ← ‘_’

FINSI

FINSI

FINSI

FINSI

SI ((j>=1 AND j<10)

SI (c[j]=='_' AND c[j-1]=='*')

tc [j] = ‘*’

SINO

SI ((c[j]=='_' AND c[j+1]=='*')

Tc [j] ← ‘*’

SINO

SI (c[j]=='*' && c[j-1]=='_' && c[j+1]=='_')

Tc [j] ← ‘*’

SINO

SI (c[j]=='*' && c[j+1]=='*')

Tc [j] ← ‘*’

SINO

Tc [j] ← ‘_’

FINSI

FINSI

FINSI

FINSI

SI ((j = 10)

SI (c[j]=='_' && c[j-1]=='*')

 tc [j] = ‘*’

SINO

SI (c[j]=='_' && c[0]=='*')

Tc [j] ← ‘*’

SINO

SI (c[j]=='*' && c[j-1]=='_' && c[j+1]=='_')

Tc [j] ← ‘*’

SINO

SI (c[j]=='*' && c[0]=='*')

Tc [j] ← ‘*’

SINO

Tc [j] ← ‘_’

FINSI

FINSI

FINSI

FINSI

Publico vacio mostrar () {

Para i=0 hasta nElementos

Escribir (ac[i].getC())

}
PAQUETE paqueteCelular

CLASE Prueba () {

Publico estatico vacio principal () {

Carácter rpta

ArregloCelula oac = nuevo arregloCelula ()

Oac.generacionInicial ()

Oac.mostrar ()

HACER

Escribir (“Siguiente generación”)

SI (rpta = s)

Oac.SiguienteGeneracion ()

Oac.mostrar ()

MIENTRAS (rpta = s)

Oac.mostrar ()

}
 EJERCICIO 8

Análisis del problema

● Se pide una cantidad determinada de elementos y se procede a definir un arreglo de
tipo cadena.

● Se emplean dos métodos para pedir y mostrar los nombres, cada uno mediante un
ciclo for respectivamente.

Diagrama de clases

Clase Principal

Atributos:
- Entero cantElem
- Cadena lista[ ]

Métodos:
- principal
- pedirNombre
- mostrarNombre

package Tarea2;

import javax.swing.JOptionPane;

public class Principal {

public static void main(String[] args){

int cantElem = Integer.parseInt(JOptionPane.showInputDialog(" Ingrese la

cantidad de nombres: "));
String[] lista = new String[cantElem];

pedirNombre(lista, cantElem);
mostrarNombre(lista, cantElem);

public static void pedirNombre(String lista[],int cantElem){

for(int indice=0;indice<cantElem;indice++){
 lista[indice]=JOptionPane.showInputDialog((indice+1)+"Ingrese un nombre :
");
}
}

public static void mostrarNombre(String lista[], int cantElem){

for(int indice=0;indice<cantElem;indice++){
System.out.println((indice+1)+": "+lista[indice]);
}
}
}

EJERCICIO 9

Realizar un programa que lea una lista de valores introducidos por el teclado.
A continuación, y sobre las listas, buscar los valores máximo y mínimo, y escribirlos.

SOLUCIÓN:
Diagrama de clases

Clase Ejercicio9

Atributos:
- Double valores
- Entero n

Métodos:
- inicializar
- ordenamientoBurbuja
- mostrarResultados

import java.util.Scanner;

public class Ejercicio9 {

public static void inicializar(double valores[], Scanner entrada){

for (int i=0; i<valores.length;i++){
System.out.println("Ingrese el codigo ["+(i+1)+"]: ");
valores[i] = entrada.nextInt();
}
}
 public static void ordenamientoBurbuja(double valores[], int n){
double aux;
for(int i=0; i<n-1; i++){
for(int j=0; j<n-1; j++){
if(valores[j]< valores[j+1]){
aux = valores[j];
valores[j] = valores[j+1];
valores[j+1] = aux;

}
}
}
}

public static void mostrarResultados(double valores[], int n){

System.out.println("El mayor valor que ha ingresado es: "+ valores[n-1]);
System.out.println("El menor valor que ha ingresado es: "+ valores[0]);
}

public static void main(String[] args){

Scanner entrada = new Scanner (System.in);

double valores[];
int n;

System.out.println("Ingrese la cantidad de valores que va a ingresar: ");

n = entrada.nextInt();

valores = new double[n];

inicializar(valores,entrada);
ordenamientoBurbuja(valores,n);
mostrarResultados(valores,n);

}
 EJERCICIO 10

10. Realizar un programa que los peso e imprima el histograma correspondiente.

Suponer que los pesos están comprendidos entre los valores 10 y 100 Kg. En el
histograma sólo aparecerá los pesos que se corresponden con 1 o mas alumnos.

SOLUCIÓN:
Análisis del problema
● Se usa el método de objeto arreglo para el almacenamiento de datos enteros.

● Se emplea el método constructor de datos para el envío de datos ingresados.

Diagrama de clases

Clase Persona

Atributos:
valor

Métodos:
Constructor(...)

Clase vector

Atributos:
vector[] Persona

Métodos:
ingresar()
evaluar(.)
mostrar()

Código:
package Paquete;

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

int n,cont=0;
float valor;
 Scanner sc = new Scanner(System.in);

System.out.println("Ingrese la cantidad de alumnos: ");

n = sc.nextInt();

int peso[] = new int[n];

Persona vector[] = new Persona[n];

//Ingresardatos
for(int i=0;i<n;i++){
System.out.println("Ingrese el peso: ");
valor = sc.nextFloat();

if(valor>10 && valor<100){

vector[i]= new Persona(valor);
cont++;
}

//Mostrar
System.out.println("Vector:\n");
for(int i=0;i<cont;i++){
System.out.print("\t"+vector[i]);
}

EJERCICIO 11

11. Utilizando el método random de la clase Math del paquete java.lang, realizar un
programa que muestre 6 números aleatorios entre 1 y 49 ordenados
ascendentemente.

SOLUCIÓN:
Análisis del problema
● Se usa el método de objeto arreglo para el almacenamiento de datos enteros.

● Se emplea el método constructor de datos para el envío de datos obtenidos

aleatoriamente.
Diagrama de clases

Clase Numero

Atributos:
valor

Métodos:
Constructor(...)

Clase vector

Atributos:
vector[] Numero

Métodos:
ordenar(.)
mostrar()

package Paquete;

public class Numero {

int valor;

public Numero(int valor) {

this.valor = valor;
}

public static void mostrar(int vector[]) {

//Mostrar
System.out.println("\nEl orden ascedendente es: ");
for (int j = 0; j < 6; j++) {
System.out.println("\t" + vector[j]);
}

public static void ordenar(int vector[]) {

int aux;
//Método Burbuja
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
 if (vector[j] > vector[j + 1]) {
aux = vector[j];
vector[j] = vector[j + 1];
vector[j + 1] = aux;
}
}
}
}
}

package Paquete;

public class Main {

public static void main(String[] args) {

int aleatorio;

Numero vector[] = new Numero[6];

System.out.println("Los numeros son: \n");

for (int i = 0; i < 6; i++) {

aleatorio = (int) (Math.random() * 49);
vector[i] = new Numero(aleatorio);
System.out.print("\t" + aleatorio);
}