package com.mycompany.

holamundo;

import java.util.Scanner;
import javax.swing.JOptionPane;

public class HolaMundo {

public static void main(String[] args) {

//==========================================
// SECCION 1: INTRODUCCION Y ENTRADA/SALIDA
//==========================================
/*System.out.println("Hola Mundo!");//Comentario de 1 linea
//TIPOS DE DATOS EN JAVA
// NUMEROS ENTEROS (Byte, Short, Int, Long)
// Byte tamaño 8 bits -128 a 127
byte entero = 12;
System.out.println("La variable Byte tiene el valor de: "+entero);
// Short tamaño 16 bits -32.768 a 32.767
short entero1 = 32767;
System.out.println("La variable Short tiene el valor de: "+entero1);
// Int tamaño 32 bits -2.147.483.648 a 2.147.483.647
int entero2 = 2147483647;
System.out.println("La variable Int tiene el valor de: "+entero2);
// Long tamaño 64 bits -9.223.372.036.854.775.808 a 9.223.372.036.854.775.808
long entero3 = 95455555;
System.out.println("La variable Long tiene el valor de: "+entero3);
//NUMEROS DECIMALES (Float, Double)
// Float tamaño 32 bits 1.4e-045 a 3.4e+038
float decimal = 9.5455555f;
System.out.println("La variable Float tiene el valor de: "+decimal);
// Double tamaño 64 bits 4.9e-324 a 1.8e+308
double decimal1 = 954.5455555;
System.out.println("La variable Double tiene el valor de: "+decimal1);
// TIPO CARACTER
// Char almacena un solo caracter
char caracter ='A';
System.out.println("La variable Char tiene el valor de: "+caracter);
// Boolean almacena un true o false
boolean desicion = false;
System.out.println("La variable Boolean tiene el valor de: "+desicion);
// TIPOS DE DATOS NO PRIMITIVOS
// Integer almacenan enteros y null y tienen metodos
Integer numero = null;
System.out.println("La variable Integer tiene el valor de: "+numero);
 // TIPO DE DATOS CADENA
// String almacenan cadena de caracteres en comillas dobles y tiene metodos
String palabra = "Hola Mundo";
System.out.println("La variable String tiene el valor de: "+palabra);
// CONSTANTES
// "Final" define constantes
final int cifra = 100;
System.out.println("La variable Final tiene el valor de: "+cifra);
//ENTRADA Y SALIDA DE DATOS POR CONSOLA
Scanner entrada = new Scanner(System.in);
/*int dato;
float dato1;
double dato2;

System.out.print("Digite un numero entero por favor: ");

dato = entrada.nextInt();
System.out.print("Digite un numero decimal flotante por favor: ");
dato1 = entrada.nextFloat();
System.out.print("Digite un numero decimal double por favor: ");
dato2 = entrada.nextDouble();
System.out.println("El dato entero ingresado fue : "+dato);
System.out.println("El dato Float ingresado fue : "+dato1);
System.out.println("El dato Double ingresado fue : "+dato2);
//ENTRADA DE CADENAS
String cadena;
System.out.print("Digite una cadena: ");
cadena = entrada.nextLine();*/
//ENTRADA Y SALIDA DE DATOS CON JoptionPane (AMBIENE GRAFICO)
/*String cadena;
char letra;
int entero;
double decimal;
float decimal1;
cadena = JOptionPane.showInputDialog("Digite una cadena: ");
letra = JOptionPane.showInputDialog("Digite un caracter: ").charAt(0);
entero = Integer.parseInt(JOptionPane.showInputDialog("Digite un entero: "));
decimal = Double.parseDouble(JOptionPane.showInputDialog("Digite un decimal Double: "));
decimal1 = Float.parseFloat(JOptionPane.showInputDialog("Digite un decimal float: "));
JOptionPane.showMessageDialog(null,"La cadena ingresada fue: "+cadena);
JOptionPane.showMessageDialog(null,"El caracter ingresada fue: "+letra);
JOptionPane.showMessageDialog(null,"El entero ingresada fue: "+entero);
JOptionPane.showMessageDialog(null,"El decimal Double ingresada fue: "+decimal);
JOptionPane.showMessageDialog(null,"El decimal Float ingresada fue: "+decimal1);
//============================================
//SECCION 2: OPERADORES Y EXPRESIONES EN JAVA
//============================================
// Operadores ATITMETICOS
==: igualdad
// !=: diferencia
// >: Mayor
// >=: Mayor o igual
// <: Menor
// <=: Menor o igual
//=======================================
// OPERADOR LOGICOS
//=======================================
// == Es igual
// != Es distinto
// <, <=, >, >= Menor, menor o igual, mayor, mayor o igual
// && Operador and (y)
// || Operador or (o)
// ! Operador not (no)
//======================================
float n1,n2,n3, suma, resta, div, multi,residuo, raiz,raiz1,pote, comi, acu=0, salariot;
/*n1= Float.parseFloat(JOptionPane.showInputDialog("Digite el numero de horas semanales trabajadas: "));
n2= Float.parseFloat(JOptionPane.showInputDialog("Digite el valor por hora: "));
n3= Float.parseFloat(JOptionPane.showInputDialog("Digite el tercer numero: "));
suma=n1+n2+n3;
resta= n1-n2;
multi= n1*n2;
/*div= n1/n2;
residuo=n1%n2;
JOptionPane.showMessageDialog(null,"La Suma de: "+n1+ " + "+n2+" + "+n3+ " es: "+suma);
JOptionPane.showMessageDialog(null,"La Resta de: "+n1+ " - "+ n2+" es: "+resta);
JOptionPane.showMessageDialog(null,"La Multiplicacion de: "+n1+ " * "+ n2+" es: "+multi);
JOptionPane.showMessageDialog(null, "La Division de: "+n1+ " / "+ n2+" es: "+div);
JOptionPane.showMessageDialog(null, "El Residuo de: "+n1+ " % "+ n2+" es: "+residuo);
// Operadores aritméticos combinados con asignación
n1+=5; // es lo mismo que n1=n1+5
n2-=5; //es lo mismo que n2=n2-5
JOptionPane.showMessageDialog(null, "El Valor de: "+n1+ " es: "+ n1);

// Operador de incremento y decremento

n1++; // Es lo mismo que n1=n1+1
n2--;// Es lo mismo que n2=n2-1
n2=n1++; //asignamos el valor de n1 a n2
n2=++n1;
// Clase Math
// Raiz Cuadrada
raiz=(float) Math.sqrt(n1);
raiz1=(float) Math.sqrt(n2);
// Potencia
pote=(float) Math.pow(n1,n2);
JOptionPane.showMessageDialog(null, "La Raiz cuadrada de: "+ n1+" es: "+raiz);
JOptionPane.showMessageDialog(null, "El Raiz cuadrada de: "+n2+" es: "+ raiz1);
//Redondeo
int red = Math.round(n1);
// Numero Aleatorio
double alea=Math.random();
JOptionPane.showMessageDialog(null, "El salario semanal es: "+multi);*/
//EJERCICIO 1:Hacer un programa que calcule e imprima la suma de 3 calificaciones
//JOptionPane.showMessageDialog(null, "El Valor de: "+n2+ " es: "+ n2);
// ELJERCICIO 2:Hacer un programa que calcule e imprima el salario semanal de un empleado a partir de sus horas semanales trabajadas y de su salario por hora.
//EJERCICIO 3: Guillermo tiene N dolares. Luis tiene la mitad de lo que posee Guillermo. Juan tiene la mitad de lo que posse Luis y Guillermo juntos. Hacer un programa que
calcule e imprima la cantidad de dinero que tienen entre los 3.
/* n1= Float.parseFloat(JOptionPane.showInputDialog("Digite la cantidad de Dolares que tiene Guillermo: "));
float luis = n1/2;
float juan = (luis+n1)/2;
suma = n1+luis+juan;
JOptionPane.showMessageDialog(null, "La cantidad de dinero de Guillermo: "+n1+" + la cantidad de Luis: "+luis+" + la cantidad de Juan: "+juan+" la cantidad total es:
"+suma);*/
// EJERCICIO 4:Una compañia de venta de carros usados, paga a su personal de ventas un salario de $1000 mensuales, mas una comision de $150 por cada carro vendido, mas
el 5% del valor de la venta por carro.
//Cada mes el capturista de la empresa ingresa en la computadora los datos pertinentes. Haceer un programa que calcule e imprima el salario mensual de un vendedor dado
/*int n;
final float salario=1000;
n = Integer.parseInt(JOptionPane.showInputDialog("Digite el numero de vehiculos vendidos: "));
for (int i=1;i<=n;i++){
n1= Integer.parseInt(JOptionPane.showInputDialog("Digite el valor del "+i+"° "+" vehiculo: "));
comi=(n1*5)/100;
acu=acu+comi;
}
salariot=salario+acu+(150*n);
JOptionPane.showMessageDialog(null, "La comision del 5% en cada vehiculo vendido es: "+acu);
JOptionPane.showMessageDialog(null, "La comisio de $150 por cada vehiculo vendido es: "+150*n);
JOptionPane.showMessageDialog(null, "El salario Basico es : "+salario);
JOptionPane.showMessageDialog(null, "El salario total es : "+salariot);*/

/*EJERCIICO 5: La calificacion final de un estudiante de informatica se calcula con base a las calificaciones de cuatro aspectos de su rendimiento academico:
participacion, primer examen parcial, segundo examen parcial y examen final. Sabiendo que las calificaciones anteriores entran a la calificacion final con ponderaciones
del 10%, 25%, 25% y 40%, Hacer un programa que calcule e imprima la calificacion final obtenida por un estudiante.
*/
/*float p,pp,sp, f, def;
p = Float.parseFloat(JOptionPane.showInputDialog("Digite la nota de participacion: "));
pp = Float.parseFloat(JOptionPane.showInputDialog("Digite la nota del Primer parcial: "));
sp = Float.parseFloat(JOptionPane.showInputDialog("Digite la nota del Segundo parcial: "));
f = Float.parseFloat(JOptionPane.showInputDialog("Digite la nota del examen final: "));
def=(p*0.10f)+(pp*0.25f)+(sp*0.25f)+(f*0.40f);
JOptionPane.showMessageDialog(null, "El Nota Definitiva es: "+def);*/
//EJERCICIO 6: Hacer un programa que calcule el cuadrado de una suma (a+b)^2 = a^2+b^2+2ab
/*double a, b,res;
a = Double.parseDouble(JOptionPane.showInputDialog("Digite el valor de a: "));
b = Double.parseDouble(JOptionPane.showInputDialog("Digite el valor de b: "));
res=Math.pow(a, 2)+Math.pow(b, 2)+(2*a*b);
JOptionPane.showMessageDialog(null, "El Resultado es: "+res);*/
//EJERCICIO 7: Construir un programa que, dado un numero total de horas, devuelva el numero de semanas, dias y horas equivalentes. Por ejempo, dado
// un total de 1000 horas debe mostrar 5 semanas, 6 dias y 16 horas.
/*int thrs,sem, dias, hrs;
thrs= Integer.parseInt(JOptionPane.showInputDialog("Digite el numero de horas: "));
sem = thrs/168;
dias = thrs%168/24;
hrs=thrs%24;
JOptionPane.showMessageDialog(null, "El numero de semanas transcurridas en: "+thrs+ " horas es: "+sem);
JOptionPane.showMessageDialog(null, "El numero de dias transcurridas en: "+thrs+ " horas es: "+dias);
JOptionPane.showMessageDialog(null, "El numero de hora transcurridas en: "+thrs+ " horas es: "+hrs);
//EJERCICIO 8: Construir un programa que calcule y muestre por pantalla las raices de la ecuacion de segundo grado de coeficientes reales. ax^2+bx+c=0
// -b+-(sqr b^2- 4ac
// x = ------------------
// 2a
double a,b,c,res1, res2;
a = Double.parseDouble(JOptionPane.showInputDialog("Digite el valor de a: "));
b = Double.parseDouble(JOptionPane.showInputDialog("Digite el valor de b: "));
c = Double.parseDouble(JOptionPane.showInputDialog("Digite el valor de a: "));
res1=(-b+Math.sqrt(Math.pow(b,2)-(4*a*c)))/(2*a);
res2=(-b+Math.sqrt(Math.pow(b,2)-(4*a*c)))/(2*a);
JOptionPane.showMessageDialog(null, "La raiz1 es: "+res1);
JOptionPane.showMessageDialog(null, "La raiz2 es: "+res2);
//=============================
// SECCION 3: CONDICIONALES
//=============================
// La sentencia if else
if(condicional){
Instruccion 1;
}else{
Instruccion2
}
int numero, dato=5;
numero = Integer.parseInt(JOptionPane.showInputDialog("Digite un numero: "));
if (numero == dato){
JOptionPane.showMessageDialog(null,"El numero es 5");
}
else {
JOptionPane.showMessageDialog(null,"El numero es diferente de 5");
}

// La Sentencia switch
switch (dato){
case 1: Instrucciones1;
break;
case 2: Instrucciones2;
break;
....
case n: InstruccionesN;
break;
default: CasoContrario;
break;
}
int dato;
dato = Integer.parseInt(JOptionPane.showInputDialog("Digite un numero entre 1-5: "));
switch (dato){
case 1: JOptionPane.showMessageDialog(null,"El numero es 1");
break;
case 2: JOptionPane.showMessageDialog(null,"El numero es 2");
break;
case 3: JOptionPane.showMessageDialog(null,"El numero es 3");
break;
case 4: JOptionPane.showMessageDialog(null,"El numero es 4");
break;
case 5: JOptionPane.showMessageDialog(null,"El numero es 5");
break;
default: JOptionPane.showMessageDialog(null,"El numero no esta entre el rango 1-5");
break;
}

// El Operador Ternario '?'

valor = (Condicion) ? valor1 : valor2
int numero;
numero = Integer.parseInt(JOptionPane.showInputDialog("Digite un numero: "));

JOptionPane.showMessageDialog(null,(numero%2==0)?"Es par":"Es impar");

//E J E R C I C I O S
// BLOQUE CONDICIONALES
Ejercicio 1: Hacer un programa que lea un numero entero y muestre si el numero es multiplo de 10.

int numero;
numero = Integer.parseInt(JOptionPane.showInputDialog("Digite un numero entero: "));
if (numero%10 == 0){
JOptionPane.showMessageDialog(null,"El numero: "+numero+" es multiplo de 10");
}else{
JOptionPane.showMessageDialog(null,"El numero: "+numero+" no es multiplo de 10");
}
Ejercicio 2: Pedir 2 numeros y decir cual es el mayor o si son iguales

int n1,n2;
n1 = Integer.parseInt(JOptionPane.showInputDialog("Digite el Primer Numero: "));
n2 = Integer.parseInt(JOptionPane.showInputDialog("Digite el Segundo Numero: "));
if (n1>n2){
JOptionPane.showMessageDialog(null,"El numero: "+n1+" es mayor que: "+n2);
}
else if (n2>n1){
JOptionPane.showMessageDialog(null,"El numero: "+n2+" es mayor que: "+n1);
}
else{
JOptionPane.showMessageDialog(null,"El numero: "+n1+" es igual que: "+n2);
}
Ejercicio 3: programa que lea un caracter por teclado y compruebe si es una letra mayuscula

char letra;
letra = JOptionPane.showInputDialog("Digite una letra: ").charAt(0);
String l=Character.toString (letra); //Usa Character.toString para convertir el ASCII a Carácter en Java
if(Character.isUpperCase(letra)){
JOptionPane.showMessageDialog(null,"La letra "+l+": Es una letra mayuscula");
}else{
JOptionPane.showMessageDialog(null,"La letra "+l+": Es una letra minuscula");
}

Ejercicio 4: En megapalaza se hace un 20% de descuento a los clientes cuya compra supere los $300.000; ¿Cual sera la cantidad que pagara una persona por su compra?

float com, des=0, tot;

com = Float.parseFloat(JOptionPane.showInputDialog("Digite el valor de la compra: "));
if(com>300000){
des = com*0.20f;
tot=com-des;
JOptionPane.showMessageDialog(null,"El total de su compra es: $"+com+" El descuento del 20% es: $"+des+" El Total a Pagar es: $"+tot);
}else{
JOptionPane.showMessageDialog(null,"El total de su compra es: $"+com);
}

Ejercicio 5: Un obrero necesita calcular su salario semanal, el cual se obtiene de la siguiente manera:
- Si trabaja 40 horas o menos se le paga $16.000 por hora.
- Si trabaja mas de 40 horas se le paga $16.000 por cada una de las primeras 40 horas y $20.000 por cada hora extra.

int hrs, ext = 0;

float sal, salt, totext = 0;
hrs = Integer.parseInt(JOptionPane.showInputDialog("Digite el numero de horas trabajadas en la semana: "));
if(hrs<=40){
sal = hrs*16000;
}else{
ext = (hrs-40);
totext =ext*20000;
sal= (hrs-ext)*16000 ;
}
salt = sal + totext;
JOptionPane.showMessageDialog(null,"El total de Horas Trabajadas es: "+hrs);
JOptionPane.showMessageDialog(null,"El total de Horas Extras es: "+ext);
JOptionPane.showMessageDialog(null,"El total de Devengado en horas Extras es: $"+totext);
JOptionPane.showMessageDialog(null,"El total de su Salario Semanal es: $"+salt);

Ejercicio 6: Hacer un programa que tome dos numeros y diga si ambos son pares o impares

int n1,n2;
n1 = Integer.parseInt(JOptionPane.showInputDialog("Digite el Primer Numero: "));
n2 = Integer.parseInt(JOptionPane.showInputDialog("Digite el Segundo Numero: "));
if((n1%2==0) && (n2%2==0)){
JOptionPane.showMessageDialog(null,"El Numero: "+n1+" y el "+n2+" son pares");
}else if ((n1%2!=0) && (n2%2!=0)){
JOptionPane.showMessageDialog(null,"El Numero: "+n1+" y el numero: "+n2+" son impares");
}else if (n1%2==0) JOptionPane.showMessageDialog(null,"El Numero :"+n1+" es Par");
else if (n2%2==0){
JOptionPane.showMessageDialog(null,"El Numero :"+n2+" es par");
}else if (n1%2!=0){ JOptionPane.showMessageDialog(null,"El Numero :"+n1+" es Impar");
}else if (n2%2!=0){
JOptionPane.showMessageDialog(null,"El Numero :"+n2+" es Impar");
}
// Ejercicio 7: Pedir tres numeros y mostrarlos ordenados de mayor a menor.
int n1,n2,n3;
n1 = Integer.parseInt(JOptionPane.showInputDialog("Digite el Primer Numero: "));
n2 = Integer.parseInt(JOptionPane.showInputDialog("Digite el Segundo Numero: "));
n3 = Integer.parseInt(JOptionPane.showInputDialog("Digite el Tecer Numero: "));
if((n1>n2) && (n2>n3)){
JOptionPane.showMessageDialog(null,"Orden : "+n1+" - "+n2+" - "+n3);
}else if ((n1>n3)&& (n3>n2)){
JOptionPane.showMessageDialog(null,"Orden : "+n1+" - "+n3+" - "+n2);
}else if ((n2>n1)&& (n1>n3)){
JOptionPane.showMessageDialog(null,"Orden : "+n2+" - "+n1+" - "+n3);
}else if((n2>n3)&&(n3>n1)){
JOptionPane.showMessageDialog(null,"Orden : "+n2+" - "+n3+" - "+n1);
}else if ((n3>n1)&& (n1>n2)){
JOptionPane.showMessageDialog(null,"Orden : "+n3+" - "+n1+" - "+n2);
}else{
JOptionPane.showMessageDialog(null,"Orden : "+n3+" - "+n2+" - "+n1);
}
// Ejercicio 8: Pedir un numero entre 0 y 99999 y decir cuantas cifras tiene
int num;
num = Integer.parseInt(JOptionPane.showInputDialog("Digite un numero entre [0 - 99999]: "));
while (num<=99999){
if (num<10){
JOptionPane.showMessageDialog(null,"El numero: "+num+" tiene 1 cifra");
}else if(num<100){
JOptionPane.showMessageDialog(null,"El numero: "+num+" tiene 2 cifra");
}else if (num<1000){
JOptionPane.showMessageDialog(null,"El numero: "+num+" tiene 3 cifra");
}else if (num<10000){
JOptionPane.showMessageDialog(null,"El numero: "+num+" tiene 4 cifra");
}else{
JOptionPane.showMessageDialog(null,"El numero: "+num+" tiene 5 cifra");

}
num = Integer.parseInt(JOptionPane.showInputDialog("Digite un numero entre [0 - 99999]: "));
}
JOptionPane.showMessageDialog(null,"El numero esta fuera del rango debe estar entre [0 - 99999]- Muchas Gracias");
// Ejercicio 9: Pedir el dia, mes y año de una fecha e indicar si la fecha es correcta. Suponiendo que todos los meses son de 30 dias.
int dia, mes, año;
dia = Integer.parseInt(JOptionPane.showInputDialog("Digite el dia del mes entre [1 - 31]: "));
mes = Integer.parseInt(JOptionPane.showInputDialog("Digite el mes del año entre [1 - 12]: "));
año = Integer.parseInt(JOptionPane.showInputDialog("Digite un numero del año entre [1980 - 3000]: "));
if ((dia>=1) && (dia<=31)){
if((mes>=1)&&(mes<=12)){
if (año!=0){
JOptionPane.showMessageDialog(null,"La Fecha: ["+dia+"/"+mes+"/"+año+"] es Correcta");
}
else{
 JOptionPane.showMessageDialog(null,"La Fecha es Incorrecta, año ["+año+"] incorrecto");
}
}
else {
JOptionPane.showMessageDialog(null,"La Fecha es Incorrecta, mes ["+mes+"] incorrecto");
}
}
else {
JOptionPane.showMessageDialog(null,"La Fecha es Incorrecta, dia ["+dia+"] incorrecto");
}

// Ejercicio 10: Pedir el dia, mes y año de una fecha e indicar si la fecha es correcta. Con meses de 28, 30 y 31 dias. Sin años bisiestos.
int dia, mes, año;
dia = Integer.parseInt(JOptionPane.showInputDialog("Digite el dia del mes entre [1 - 31]: "));
mes = Integer.parseInt(JOptionPane.showInputDialog("Digite el mes del año entre [1 - 12]: "));
año = Integer.parseInt(JOptionPane.showInputDialog("Digite un numero del año entre [1980 - 3000]: "));
if (año==0){
JOptionPane.showMessageDialog(null,"La Fecha es Incorrecta, año ["+año+"] incorrecto");
}
else if ((mes == 2) && (dia>=1 && dia<=28)){
JOptionPane.showMessageDialog(null,"La Fecha es Incorrecta, dia ["+dia+"] Correcta");
}
else if ((mes == 2 || mes == 6 || mes == 9 || mes == 11) && (dia>=1 && dia<=30)){
JOptionPane.showMessageDialog(null,"La Fecha: ["+dia+"/"+mes+"/"+año+"] es Correcta");
}
else if ((mes ==1 || mes == 3 || mes == 5 || mes == 7 || mes == 8 || mes ==10 || mes==12 )&& (dia>=1 && dia<=31)) {
JOptionPane.showMessageDialog(null,"La Fecha: ["+dia+"/"+mes+"/"+año+"] es Correcta");
}
else{
JOptionPane.showMessageDialog(null,"La Fecha: ["+dia+"/"+mes+"/"+año+"] es Incorrecta");
}
//Ejercicio 11: Construir un programa que simule el funcionamiento de una calculadora que puede realizar las cuatro operaciones aritmeticas
//basicas 8Suma, resta, producto y division)con valores numericos enteros. El usuario debe especificar la operacion con el primer caracter
//del primer parametro de la linea de comandos: S o s para la suma, R o r para la resta, P o p, m o m para el producto y D o d para la division
int n1,n2,s,r,m,d;
char op;
n1 = Integer.parseInt(JOptionPane.showInputDialog("Digite el Primer Numero: "));
n2 = Integer.parseInt(JOptionPane.showInputDialog("Digite el Segundo numero"));
op=JOptionPane.showInputDialog("Digite La Operacion que desea realizar:\n"
+"Digite 'S' ó 's' para [Suma]\n"
+"Digite 'R' ó 'r' para [Resta]\n"
+"Digite 'M' ó 'm' para [Multiplicacion]\n"
+"Digite 'D' ó 'd' para [division]" ).charAt(0);
switch (op){
 case 's':
case 'S': s=n1+n2;
JOptionPane.showMessageDialog(null,"La Suma de: "+n1+" + "+n2+" = "+s);
break;
case 'r':
case 'R': r=n1-n2;
JOptionPane.showMessageDialog(null,"La Resta de: "+n1+" - "+n2+" = "+r);
break;
case 'm':
case 'M': m=n1*n2;
JOptionPane.showMessageDialog(null,"La Multiplicacion de: "+n1+" * "+n2+" = "+m);
break;
case 'P':
case 'p':
case 'd':
case 'D': d=n1/n2;
JOptionPane.showMessageDialog(null,"La Division de: "+n1+" / "+n2+" = "+d);
break;
default: JOptionPane.showMessageDialog(null,"Operacion no Valida");
break;
}
//Ejercicio 12: Pedir una nota de 0 a 10 y mostrarla de la forma. Insuficiente, Suficiente, Bien, Notable y Sobresaliente.
int n;
n = Integer.parseInt(JOptionPane.showInputDialog("Digite la Nota del alumno: "));
switch (n){
case 0:
case 1:
case 2:
case 3:
case 4: JOptionPane.showMessageDialog(null,"Su nota: "+n+" es Insuficiente");
break;
case 5: JOptionPane.showMessageDialog(null,"Su nota: "+n+" es Suficiente");
break;
case 6: JOptionPane.showMessageDialog(null,"Su nota: "+n+" es Bien");
break;
case 7:
case 8: JOptionPane.showMessageDialog(null,"Su nota: "+n+" es Notable");
break;
case 9:
case 10: JOptionPane.showMessageDialog(null,"Su nota: "+n+" es Sobresaliente");
break;
default: JOptionPane.showMessageDialog(null,"Nota fuera del Rango");
break;
}
________________________________________________________________________________________________________________________________________
Ejercicio 13: Hacer un programa que simule un cajero automatico con un saldo inicial de 1000 Dolares, con el siguiente menu de opciones:
1.- Ingresar dinero a la cuenta
2.- Retirar dinero de la cuenta
3.- Salir
-----------------------------------------------------------------------------------------------------------------------------------------
final int si = 1000;
int op;
float i,r,sa ;
op = Integer.parseInt(JOptionPane.showInputDialog("""
BIENVENIDO A SU CAJERO
Elija una Opcion

1.- Ingresar Dinero a la Cuenta

2.- Retirar Dinero de la Cuenta
3.- salir

"""));
switch (op){
case 1: i = Float.parseFloat(JOptionPane.showInputDialog("Ingrese la cantidad de dinero a consignar: "));
sa = si+i;
JOptionPane.showMessageDialog(null,"Su Saldo Actual es: $"+sa);
break;
case 2:
r = Float.parseFloat(JOptionPane.showInputDialog("Ingrese la cantidad de dinero a Retirar: "));
if (r>si){
JOptionPane.showMessageDialog(null,"Fondos Insuficients");
}else{
sa = si-r;
JOptionPane.showMessageDialog(null,"Su Saldo Actual es: $"+sa);
}
break;

case 3: JOptionPane.showMessageDialog(null,"Muchas gracias por su Visita");

break;
default: JOptionPane.showMessageDialog(null,"Opcion fuera del Rango");
break;
}
_____________________________________________________________________________________________________________________________________
Ejercicio 14: Hacer un programa que pase de Kg a otra unidad de medida de masa, mostrar en pantalla un menu con las opciones posibles
-------------------------------------------------------------------------------------------------------------------------------------
float kg,h,d,g,dc,c,m;
int op;
kg =Float.parseFloat(JOptionPane.showInputDialog("Ingrese la cantidad de Kilogramos: "));
op = Integer.parseInt(JOptionPane.showInputDialog("""
MENU PRINCIPAL
Elija una Opcion

1.- Hectogramos
2.- Decagramos
3.- Gramos
4.- Decigramos
5.- Centigramos
6.- Miligramos\n
"""));
switch (op){
case 1: h = kg*10;
JOptionPane.showMessageDialog(null,""+kg+"Kg Equivalen a "+h+" Hectagramos");
break;
case 2: d = kg*100;
JOptionPane.showMessageDialog(null,""+kg+"Kg Equivalen a "+d+" Decagramos");
break;
case 3: g = kg*1000;
JOptionPane.showMessageDialog(null,""+kg+"Kg Equivalen a "+g+" Gramos");
break;
case 4: dc = kg*10000;
JOptionPane.showMessageDialog(null,""+kg+"Kg Equivalen a "+dc+" Decigramos");
break;
case 5: c = kg*100000;
JOptionPane.showMessageDialog(null,""+kg+"Kg Equivalen a "+c+" Centigramos");
break;
case 6: m = kg*1000000;
JOptionPane.showMessageDialog(null,""+kg+"Kg Equivalen a "+m+" Miligramos");
break;
default: JOptionPane.showMessageDialog(null,"Opcion fuera del Rango");
break;
}*/
//=====================================
// SECCION 4: CICLOS O BUCLES
//=====================================
//CICLO WHILE
/* While (condicion){
Instruciones;
}

int n=1;
while (n<=10){
JOptionPane.showMessageDialog(null,"Numero: "+n);
 n++;
}*/

//CICLO DO WHILE
/*
do{
Instruciones;
}While (condicion);
int n=1;

do{
JOptionPane.showMessageDialog(null,"Numero: "+n);
n++;
}while (n<=10);

// CICLO FOR
for(inicializacion; condicion; aumento o decremento){
Instrucciones;
}
int i,n;
n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese la cantidad de numeros: "));
for(i=1;i<=n;i++){
JOptionPane.showMessageDialog(null,"Numero: "+i);
}
for( i=n;i<=n && i>0;i--){
JOptionPane.showMessageDialog(null,"Numero: "+i);
}
//E J E R C I C I O S
//CICLOS O BUCLES
_________________________________________________________________________________________________________________
Ejercicio 1: Leer un numero y mostrar su cuadrado, repetir el proceso hasta que se introduzca un numero negativo
-----------------------------------------------------------------------------------------------------------------
int n, c;
n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero: "));
while (n>=0){
c=(int)Math.pow(n,2);
JOptionPane.showMessageDialog(null,"El Numero: "+n+" Elevado al cuadrado es: "+c);

n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero: "));

if (n<0){
JOptionPane.showMessageDialog(null,"El Numero: "+n+" es un numero negativo");
}
}
______________________________________________________________________________________________________________________
Ejercicio 2: Leer un numero e indicar si es positivo o negativo. El proceso se repetira hasta que se introduzca un 0.
----------------------------------------------------------------------------------------------------------------------
int n;
n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero: "));
while (n!=0){
if(n>=0){
JOptionPane.showMessageDialog(null,"El Numero: "+n+" Es positivo");
System.out.println("El numero: "+n+" es Positivo");
} else
JOptionPane.showMessageDialog(null,"El Numero: "+n+" Es Negativo");
System.out.println("El numero: "+n+" es Negativo");
n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero: "));

}
JOptionPane.showMessageDialog(null,"El Numero ingresado es un Cero ! A d i o s ¡");
__________________________________________________________________________________________________
Ejercicio 3: Leer numeros hasta que se introduzca un 0. Para cada uno indicar si es par o impar.
--------------------------------------------------------------------------------------------------
int n;
n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero: "));
while (n!=0){
if(n%2==0){
JOptionPane.showMessageDialog(null,"El Numero: "+n+" Es par");
System.out.println("El numero: "+n+" es par");
} else{
JOptionPane.showMessageDialog(null,"El Numero: "+n+" Es impar");
System.out.println("El numero: "+n+" es impar");
}
n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero: "));
}
JOptionPane.showMessageDialog(null,"El Numero ingresado es un Cero ! A d i o s ¡");
___________________________________________________________________________________________________________
Ejercicio 4: Pedir numeros hasta que se teclee uno negativo, y mostrar cuantos numeros se han introducido
-----------------------------------------------------------------------------------------------------------
int n,c=0;
n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero: "));
while (n>=0){
c=c+1;
JOptionPane.showMessageDialog(null,"El Numero: "+n+" es el "+c+"° numero introcucido");
System.out.println("El numero: "+n+" es el "+c+"° numero introcucido");
n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero: "));

}
JOptionPane.showMessageDialog(null,"El total de numeros positivos introducidos fue: "+c);
System.out.println("El total de numeros positivos introducidos fue: "+c);
___________________________________________________________________________________________________________________________________
Ejercicio 5: Realizar un juego para adivinar un numero. Para ello generar un numero aleatorio entre 0-100, y luego ir pidiendo
numeros indicando "es mayor" o "es menor" segun sea mayor o menor con respecto a N. El proceso termina cuando el u
usuario acierta y mostrar el numero de intentos.
___________________________________________________________________________________________________________________________________
int n,c=0,ale;
ale=(int)(Math.random()*100);
JOptionPane.showMessageDialog(null,"El Numero aleatorio es: "+ale);
System.out.println("El numero aleatorio es: "+ale);
n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero: "));
while (n!=ale){
c++;
if (n>ale){
JOptionPane.showMessageDialog(null,"El Numero: "+n+" es mayor que el numero aleatorio");
}else{
JOptionPane.showMessageDialog(null,"El Numero: "+n+" es menor que el numero aleatorio");
}
n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero: "));
}
JOptionPane.showMessageDialog(null,"Felicitaciones adivinastes, el total de intentos fue: "+c);
System.out.println("Felicitaciones adivinastes, el total de intentos fue: "+c);
________________________________________________________________________________________________________
Ejercicio 6: Pedir numeros hasta que se teclee un 0, mostrar la suma de todos los numeros introducidos
--------------------------------------------------------------------------------------------------------
int n,suma=0, c=0;
n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero diferente de Cero[0}: "));
while (n!=0){
c++;
suma= suma+ n;

n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero diferente de cero[0]: "));

}
JOptionPane.showMessageDialog(null,"La cantidad de numeros ingresados fue: "+c+" la suma de estos numeros es: "+suma);
System.out.println("La cantidad de numeros ingresados es: "+c+" la suma de estos numeros es. "+suma);
_____________________________________________________________________________________
Ejercicio 7: Pedir numeros hasta que se introduzca uno negativo, calcular la media.
-------------------------------------------------------------------------------------
int n,suma=0,c=0;
float media;
n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero positivo: "));
while (n>=0){
c++;
 suma= suma+ n;
n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero diferente de cero[0]: ")); }
if (c==0){
JOptionPane.showMessageDialog(null,"¡Error! La division entre Cero [0] no existe");
}else{
media=suma/c;
JOptionPane.showMessageDialog(null,"La cantidad de numeros ingresados fue: "+c+" la suma de estos numeros es: "+suma+" y la media es: "+media);

System.out.println("La cantidad de numeros ingresados es: "+c+" la suma de estos numeros es. "+suma+" y la media es. "+media);
}
__________________________________________________________________________
Ejercicio 8: Pedir un numero N, y mostrar todos los numeros del 1 al N.
--------------------------------------------------------------------------
int n,i=0;
n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero: "));
while (i<n){
i++;
JOptionPane.showMessageDialog(null,"El valor es: "+i);
System.out.println(" "+i);
}
_______________________________________________________________________________________________________________________
Ejercicio 9: Escribir todos los numeros del 100 al 0 de 7 en 7.
-----------------------------------------------------------------------------------------------------------------------

for(int i=100;i>=0;i-=7){
JOptionPane.showMessageDialog(null,"El valor es: "+i);
System.out.println(" "+i);
}
________________________________________________________
Ejercicio 10: Pedir 10 numeros y escribir la suma total.
--------------------------------------------------------
int n, suma=0;
for(int i=1;i<=10;i++){
n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese el "+i+"° numero: "));
suma=suma+n;
}
JOptionPane.showMessageDialog(null,"La suma de los 10 numeros es: "+suma);
System.out.println("La suma de los 10 numeros es: "+suma);
_____________________________________________________________________________________________
Ejercicio 11: Diseñar un programa que muestre el producto de los 10 primeros numeros impares
---------------------------------------------------------------------------------------------

int i,c=0;
long pro=1;
for(i=1;i<=100;i++){
if(i%2!=0){
c++;
pro=pro*i;
}
if(c==10){
i=100;
}
}

JOptionPane.showMessageDialog(null,"El producto de los primeros 10 numeros impares es: "+pro);

System.out.println("El producto de los primeros 10 numeros impares es: "+pro);
______________________________________________________________________
Ejercicio 12: Pedir un numero y calcular su factorial. N!=1*2*3*...*n
----------------------------------------------------------------------
int n;
long fac=1;
n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero: "));
for(int i=1;i<=n;i++){

fac=fac*i;
}
JOptionPane.showMessageDialog(null,"El factorial de: "+n+" es: "+fac);
System.out.println("El factorial de: "+n+" es: "+fac);
____________________________________________________________________________________________________________________________________
Ejercicio 13: Pedir 10 numeros. Mostrar la media de los numeros positivos, la media de los numeros negativos y la cantidad de ceros.
------------------------------------------------------------------------------------------------------------------------------------
int n,cp=0,cn=0, cc=0;
float mediaP=0, mediaN=0, sumaP=0, sumaN=0;
for(int i=1;i<=10;i++){
n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese el "+i+"° numero: "));
if (n>0){
cp=cp+1;
sumaP=sumaP+n;
}else if (n<0){
cn=cn+1;
sumaN=sumaN+n;
}else{
cc=cc+1;
}
}
if (cp==0 || cn==0){
JOptionPane.showMessageDialog(null,"El conteo de Positivos y Negativos es Cero, por lo tanto no se puede dividir por ceros");
System.out.println("La cantidad de positivos y negativos es cero y no se puede dividir por ceros");
 JOptionPane.showMessageDialog(null,"La Cantidad de ceros es: "+cc);
System.out.println("La cantidad de ceros es: "+cc);
}else{
mediaP=sumaP/cp;
mediaN=sumaN/cn;
JOptionPane.showMessageDialog(null,"La media de los numeros positivos es: "+mediaP);
JOptionPane.showMessageDialog(null,"La media de los numeros negativos es: "+mediaN);
System.out.println("La media de los numeros positivos es: "+mediaP);
System.out.println("La media de los numeros negativos es: "+mediaN);
JOptionPane.showMessageDialog(null,"La Cantidad de ceros es: "+cc);
System.out.println("La cantidad de ceros es: "+cc);
}
______________________________________________________________________________
Ejercicio 14: Pedir 10 sueldos. Mostrar su suma y cuantos hay mayores de 1000.
------------------------------------------------------------------------------
int cm=0;
float sumas=0,s;
for(int i=1;i<=10;i++){
s =Float.parseFloat(JOptionPane.showInputDialog("Ingrese el "+i+"° sueldo: "));
sumas=sumas+s;
if (s>1000){
cm++;
}
}
JOptionPane.showMessageDialog(null,"La suma de los 10 sueldos es: "+sumas);
JOptionPane.showMessageDialog(null,"Los sueldos mayores a $1000 son: "+cm);
System.out.println("La suma de los 10 sueldos es: "+sumas);
System.out.println("Los sueldos mayores a $1000 son: "+cm);
___________________________________________________________________________________________
Ejercicio 15: Dadas las edades y alturas de 5 alumnos, mostrar la edad y la estatura media,
la cantidad de alumnos mayores de 18 años, y la cantidad de alumnos que miden mas de 1.75.
-------------------------------------------------------------------------------------------
int ce=0,cm=0;
float se=0, sm=0,me,mm,ed,es;
for(int i=1;i<=5;i++){
ed =Float.parseFloat(JOptionPane.showInputDialog("Ingrese la edad del "+i+"° alumno: "));
es =Float.parseFloat(JOptionPane.showInputDialog("Ingrese la estatura del "+i+"° alumno: "));
se+=ed;
sm+=es;
if(ed>18){
ce++;
}
if(es>1.75){
cm++;
}
}
me=se/5;
mm=sm/5;
JOptionPane.showMessageDialog(null,"La media de las edades es: "+me);
JOptionPane.showMessageDialog(null,"La media de las estaturas es: "+mm);
JOptionPane.showMessageDialog(null,"La cantidad de alumnos mayores de 18 años es: "+ce);
JOptionPane.showMessageDialog(null,"La cantidad de alumnos que miden mas de 1.75 es: "+cm);
System.out.println("La media de las edades es: "+me);
System.out.println("La media de las estaturas es: "+mm);
System.out.println("La cantidad de alumnos mayores de 18 años es: "+ce);
System.out.println("La cantidad de alumnos que miden mas de 1.75 es: "+cm);
_____________________________________________________________________________________________________________
Ejercicio 16: Pide un numero (que debe estar entre 0 y 10) y mostrar la tabla de multiplicar de dicho numero.
-------------------------------------------------------------------------------------------------------------
int n,i;
char op;
n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero: "));
while (n!=0){
System.out.println("-------------------------");
for(i=1;i<=n;i++){
JOptionPane.showMessageDialog(null,""+n+" X "+i+" = "+n*i);
System.out.println(""+n+" X "+i+" = "+n*i);

}
op = JOptionPane.showInputDialog("Desea continuar ['s' o 'S' SI - 'n' o 'N' NO] ").charAt(0);

if(op =='s' || op=='S') {

n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero: "));
}else{
n=0;
JOptionPane.showMessageDialog(null,"Fue un Placer Servirte - !Hasta la vista Baby¡");
System.out.println("Fue un Placer Servirte - !Hasta la vista Baby¡");
}

}
_________________________________________________________________________________________________________________________
Ejercicio 17: Una empresa que se dedica a la venta de desinfectantes necesita un programa para gestionar las facturas.
En cada factura figura: el codigo del articulo, la cantidad vendida en litros y el precio por litro. Se pide de 5 facturas
introducidas: Facturacion total, cantidad en litros vendidos del articulo 1 y cuantas facturas se emitieron de mas de $600.
--------------------------------------------------------------------------------------------------------------------------
int cod,cf=0,l=0,cvl=0 ;
float ft=0,pl=0,f=0;
for(int i=1;i<=5;i++){
 cod =Integer.parseInt(JOptionPane.showInputDialog("Ingrese Codigo del "+i+"° Articulo: "));
cvl =Integer.parseInt(JOptionPane.showInputDialog("Ingrese Cantidad Vendida en litros del "+i+"° Articulo: "));
pl =Float.parseFloat(JOptionPane.showInputDialog("Ingrese Precio por litro del "+i+"° Articulo: "));
f=cvl*pl;
ft+=f;
if(f>600){
cf++;
}
if(cod==1){
l+=cvl;
}
}

JOptionPane.showMessageDialog(null,"La facturacion total fue: "+ft);

JOptionPane.showMessageDialog(null,"La Cantidad de litros vendidos del articulo 1 fue: "+l);
JOptionPane.showMessageDialog(null,"La facturas mayores de $600 fueron: "+cf);
System.out.println("La facturacion total fue: "+ft);
System.out.println("La Cantidad de litros vendidos del articulo 1 fue:: "+l);
System.out.println("La facturas mayores de $600 fueron: "+cf);
___________________________________________________________________________________________________________________
Ejercicio 18: Hacer unas modificaciones al ejercicio anterior suponiendo que no se introduce el precio por litro.
Solo existen tres productos con precios 1.- 0.6 $/litro
2.- 3 $/litro
3.- 1.25 E/litro
------------------------------------------------------------------------------------------------------------------
int cod,cf=0,l=0,cvl=0 ;
float ft=0,pl=0,f=0;
for(int i=1;i<=5;i++){
cod =Integer.parseInt(JOptionPane.showInputDialog("Ingrese Codigo del "+i+"° Articulo: "));
cvl =Integer.parseInt(JOptionPane.showInputDialog("Ingrese Cantidad Vendida en litros del "+i+"° Articulo: "));
switch (cod){
case 1 -> {
f=(float) (cvl*0.6);
l+=cvl;
}
case 2 -> f=(float)(cvl*3);
case 3 -> f=(float)(cvl*1.25);

default -> JOptionPane.showMessageDialog(null,"Codigo del producto Errado - No existe");

}
ft+=f;
if(f>600){
cf++;
}
}
JOptionPane.showMessageDialog(null,"La facturacion total fue: "+ft);
JOptionPane.showMessageDialog(null,"La Cantidad de litros vendidos del articulo 1 fue: "+l);
JOptionPane.showMessageDialog(null,"La facturas mayores de $600 fueron: "+cf);
System.out.println("La facturacion total fue: "+ft);
System.out.println("La Cantidad de litros vendidos del articulo 1 fue:: "+l);
System.out.println("La facturas mayores de $600 fueron: "+cf);
___________________________________________________________________________________________________________________
Ejercicio 19: Dadas 6 notas, escribir la cantidad de alumnos aprobados, condicionados (=4) y suspensos.
-------------------------------------------------------------------------------------------------------------------
int ca=0,cc=0,cs=0;
float nota;
for(int i=1;i<=6;i++){
do{
nota =Integer.parseInt(JOptionPane.showInputDialog("Ingrese la "+i+"° nota: "));
}while(nota<0 || nota>10);
if (nota==4){
cc++;
}else if(nota>=5) {
ca++;
}else{
cs++;
}

}
JOptionPane.showMessageDialog(null,"La Cantidad de alumnos aprobados es: "+ca);
JOptionPane.showMessageDialog(null,"La Cantidad de alumnos condicionados es: "+cc);
JOptionPane.showMessageDialog(null,"La Cantidad de alumnos suspensos es: "+cs);
System.out.println("La Cantidad de alumnos aprobados es: "+ca);
System.out.println("La Cantidad de alumnos condicionados es: "+cc);
System.out.println("La Cantidad de alumnos suspensos es: "+cs);
___________________________________________________________________________________
Ejercicio 20: Pedir un numero N, introducir N sueldos, y mostrar el sueldo maximo.
-----------------------------------------------------------------------------------
int s;
float st=0,sm=0;
s =Integer.parseInt(JOptionPane.showInputDialog("Ingrese cantidad de sueldos a procesarla "));
for(int i=1;i<=s;i++){

st =Float.parseFloat(JOptionPane.showInputDialog("Ingrese el "+i+"° sueldo: "));

if (st>=sm){
sm=st;
}
}
JOptionPane.showMessageDialog(null,"El sueldo maximo es: "+sm);
System.out.println("El sueldo maximo es: "+sm);
_______________________________________________________________________________________
Ejercicio 21: Pedir 10 numeros, y mostrar al final si se ha introducido alguno negativo.
---------------------------------------------------------------------------------------
int n,cn=0;
boolean Numeros_Negativos=false;
for(int i=1;i<=10;i++){

n =Integer.parseInt(JOptionPane.showInputDialog("Ingrese el "+i+"° numero: "));

if (n<0){
Numeros_Negativos=true;
cn++;
}
}
if (Numeros_Negativos==true){
JOptionPane.showMessageDialog(null,"Se introdujeron por lo menos "+cn+" numeros negativos ");
System.out.println("Se introdujeron por lo menos "+cn+" numeros negativos ");
}else{
JOptionPane.showMessageDialog(null,"Se introdujeron "+cn+" numeros negativos ");
System.out.println("Se introdujeron "+cn+" numeros negativos ");
}
_______________________________________________________________________________________
Ejercicio 22: Pedir 5 calificaciones de alumnos y decir al final si hay algun suspenso.
---------------------------------------------------------------------------------------
int ca=0,cc=0,cs=0;
float nota;
boolean s=false;
for(int i=1;i<=5;i++){
do{
nota =Integer.parseInt(JOptionPane.showInputDialog("Ingrese la "+i+"° nota: "));
}while(nota<0 || nota>10);
if (nota <5){
s=true;
cs++;
}
}
if (s==true){
JOptionPane.showMessageDialog(null,"Hay por lo menos "+cs+" alumnos suspenso(s)");
System.out.println("Hay por lo menos "+cs+" alumnos suspenso(s)");
}else{
JOptionPane.showMessageDialog(null,"No hay alumnos "+cs+" Suspensos");
System.out.println("No hay alumnos "+cs+" Suspensos");
}
//=====================================
// SECCION 5: ARREGLOS O VECTORES
//=====================================
1.- Definicion de Arreglo
2.- Llenar un arreglo
3.- Bucle for each
4.- Ejercicios de practica
Arrays Unidimensionales
Sintaxis
Tipo_de_variable[] Nombre_del_array = new Tipo_de_variable[dimension];
Ejemplo: int[] edad = new int[4];
// LLENAR UN ARREGLO
int i, t;
t =Integer.parseInt(JOptionPane.showInputDialog("Ingrese el tamaño del vector notas"));
double [] notas=new double[t];
for(i=0;i<t;i++){
notas[i] =Integer.parseInt(JOptionPane.showInputDialog("Ingrese el "+(i+1)+"° nota: "));
}
for(i=0;i<t;i++){
JOptionPane.showMessageDialog(null,"La "+(i+1)+"° Nota es: "+notas[i]);
System.out.println("La "+(i+1)+"° Nota es: "+notas[i]);
}
// BUCLE FOR EACH //Bucle for mejorado
//Sintaxis

int i,t;
t =Integer.parseInt(JOptionPane.showInputDialog("Ingrese el tamaño del vector nombres"));
String[] nombres = new String[t];
for(i=0;i<t;i++){
nombres[i] = JOptionPane.showInputDialog("Ingrese el "+(i+1)+"° nombre: ");
}
for(String a:nombres){
JOptionPane.showMessageDialog(null," "+a);
System.out.println(" "+a);
}
//E J E R C I C I O S
//ARREGLOS O ARRAYS
__________________________________________________________________________________________________
Ejercicio 1: Leer 5 numeros guardarlos en un arreglo y mostrarlos en el mismo orden introducido.
--------------------------------------------------------------------------------------------------
int i;
float[] numeros = new float[5];
for(i=0;i<5;i++){
numeros[i] = Float.parseFloat(JOptionPane.showInputDialog("Ingrese el "+(i+1)+"° numero: "));
}
i=1;
for(float a:numeros){

JOptionPane.showMessageDialog(null,"El "+(i)+" es: "+a);

System.out.println("El "+(i)+" es: "+a);
i++;
}
_____________________________________________________________________________________________________
Ejercicio 2: Leer 5 numeros guardarlos en un arreglo y mostrarlos en el orden inverso al introducido.
-----------------------------------------------------------------------------------------------------

float[] numeros = new float[5];

for(int i=0;i<5;i++){
numeros[i] = Float.parseFloat(JOptionPane.showInputDialog("Ingrese el "+(i+1)+"° numero: "));
}

for(int f=4;f>=0;f--){
JOptionPane.showMessageDialog(null,"El "+(f+1)+" es: "+numeros[f]);
System.out.println("El "+(f+1)+" es: "+numeros[f]);
}
________________________________________________________________________________________________
Ejercicio 3: Leer 5 numeros por teclado, almacenarlos en un arreglo y a continuacion realizar
la media de los numeros positivos, la media de los negativos y contar el numero de ceros.
------------------------------------------------------------------------------------------------
float sp=0,sn=0, mp,mn;
int cp=0,cn=0, cc=0;
float[] numeros = new float[5];
for(int i=0;i<5;i++){
numeros[i] = Float.parseFloat(JOptionPane.showInputDialog("Ingrese el "+(i+1)+"° numero: "));
}

for(int f=0;f<5;f++){
if(numeros[f]> 0){
sp+=numeros[f];
cp++;
}else if(numeros[f]<0){
sn+=numeros[f];
cn++;
}else{
cc++;
}
 }
//MEDIA DE LOS NUMEROS POSITIVOS
if(cp==0){
JOptionPane.showMessageDialog(null,"No se puede sacar la media de los numeros positivos - no se puede dividir por cero");
}else{
mp=sp/cp;
JOptionPane.showMessageDialog(null,"La media de los numeros positivos es: "+mp);
System.out.println("La media de los numeros positivos es: "+mp);
}
//MEDIA DE LOS NUMEROS NEGATIVOS
if(cn==0){
JOptionPane.showMessageDialog(null,"No se puede sacar la media de los numeros negativos - no se puede dividir por cero");
}else{
mn=sn/cn;
JOptionPane.showMessageDialog(null,"La media de los numeros negativos es: "+mn);
System.out.println("La media de los numeros negativos es: "+mn);
}
JOptionPane.showMessageDialog(null,"La Cantidad de numeros ceros es: "+cc);
System.out.println("La Cantidad de numeros ceros es: "+cc);
_______________________________________________________________________________________
Ejercicio 4: Leer 10 numeros enteros, guardarlos en un arreglo. debemos mostrarlos en
el siguiente orden: el primero, el ultimo, el segundo, el penultimo, el tercero, etc.
--------------------------------------------------------------------------------------
int[] numeros = new int[10];
for(int i=0;i<10;i++){
numeros[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el "+(i+1)+"° numero:"));
}
for(int i=0;i<5;i++){
JOptionPane.showMessageDialog(null,"El numero "+(i+1)+" es: "+numeros[i]+"");
JOptionPane.showMessageDialog(null,"El numero "+(9-i)+" es: "+numeros[9-i]+"");
System.out.println("El numero "+(i+1)+" es: "+numeros[i]+"");
System.out.println("El numero "+(9-i)+" es: "+numeros[9-i]+"");
}
_______________________________________________________________________________
Ejercicio 5: Leer por teclado dos tablas de 10 numeros enteros y mezclarlas en
una tercera de la forma: el 1° de A, el 1° de B, el 2° de A, el 2° de B, etc.
-------------------------------------------------------------------------------

int[] tabla_A = new int[10];

int[] tabla_B = new int[10];
int[] tabla_C = new int[20];
for(int i=0;i<10;i++){
tabla_A[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el "+(i+1)+"° numero de la Tabla A:"));
tabla_B[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el "+(i+1)+"° numero de la Tabla B:"));
}
int a=1;
for(int i=0;i<10;i++){
tabla_C[i]=tabla_A[i];
tabla_C[i+1]=tabla_B[i];
JOptionPane.showMessageDialog(null,"El "+(i+1)+"° elemento de la tabla A es: "+tabla_A[i]+"");
JOptionPane.showMessageDialog(null,"El "+(i+1)+"° elemento de la tabla B es: "+tabla_B[i]+"");
JOptionPane.showMessageDialog(null,"El "+(a)+"° y "+(a+1)+"° elementos de la tabla C son: "+tabla_C[i]+" - "+tabla_C[i+1]+"");
System.out.println("El "+(i+1)+"° elemento de la tabla A es: "+tabla_A[i]+"");
System.out.println("El "+(i+1)+"° elemento de la tabla B es: "+tabla_B[i]+"");
System.out.println("El "+(a)+"° y "+(a+1)+"° elementos de la tabla C son: "+tabla_C[i]+" - "+tabla_C[i+1]+"");
a+=2;
}
______________________________________________________________________________________________________
Ejercicio 6: Leer los datos correspondientes a dos tablas de 12 elementos numerericos,y mezclarlos en
una tercera de la forma: tres de la tabla A, tres de la B, otros tres de la A, otros 3 de la B, etc.
------------------------------------------------------------------------------------------------------
int[] tabla_A = new int[12];
int[] tabla_B = new int[12];
int[] tabla_C = new int[24];
int i,j, a=1;
for(i=0;i<12;i++){
tabla_A[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el "+(i+1)+"° numero de la Tabla A:"));
tabla_B[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el "+(i+1)+"° numero de la Tabla B:"));
}
i=0;
j=0;
while (i<12){
for (int k=0;k<3;k++){
tabla_C[j]=tabla_A[i+k];
j++;
}
for (int k=0;k<3;k++){
tabla_C[j]=tabla_B[i+k];
j++;
}
i+=3;
}

for( i=0;i<24;i++){
if(i<12) {
JOptionPane.showMessageDialog(null,"El "+(i+1)+"° elemento de la tabla A es: "+tabla_A[i]+"");
JOptionPane.showMessageDialog(null,"El "+(i+1)+"° elemento de la tabla B es: "+tabla_B[i]+"");
System.out.println("El "+(i+1)+"° elemento de la tabla A es: "+tabla_A[i]+"");
 System.out.println("El "+(i+1)+"° elemento de la tabla B es: "+tabla_B[i]+"");
}

JOptionPane.showMessageDialog(null,"El "+(i+1)+"° y "+(i+2)+"° elementos de la tabla C son: "+tabla_C[i]+" - "+tabla_C[i+1]);

System.out.println("El "+(i+1)+"° y "+(i+2)+"° elementos de la tabla C son: "+tabla_C[i]+" - "+tabla_C[i+1]);

}
______________________________________________________________________________________________
Ejercicio 7: Leer por teclado una serie de 10 numeros enteros. La aplicacion debe indicarnos
si los numeros estan ordenados de forma creciente, decreciente, o si estan desordenados.
---------------------------------------------------------------------------------------------
boolean creciente=false, decreciente=false;
int[] arreglo = new int[10];
for(int i=0;i<10;i++){
arreglo[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el "+(i+1)+"° numero del arreglo:"));
}
for (int i=0;i<9;i++){
if(arreglo[i]< arreglo[i+1]){
creciente=true;
}
if(arreglo[i]> arreglo[i+1]){
decreciente=true;
}
}
if (creciente ==true && decreciente==false){
System.out.println ("Este arreglo esta en forma Creciente. ");
for (int i=0;i<10;i++){
System.out.print(" "+arreglo[i]+" ");
System.out.print(" ");
System.out.print(" ");
}
}else if (creciente==false && decreciente==true){
System.out.println("Este arreglo esta en forma Decreciente. ");
for (int i=0;i<10;i++){
System.out.print(" "+arreglo[i]+" ");
System.out.print(" ");
System.out.print(" ");
}
}else if(decreciente==true && decreciente==true){
System.out.println("Este arreglo esta Desordenado. ");
for (int i=0;i<10;i++){
System.out.print(" "+arreglo[i]+" ");
System.out.print(" ");
System.out.print(" ");
 }
}else if(creciente==false && decreciente==false){
System.out.println("Elementos del arreglo: ");
for (int i=0;i<10;i++){
System.out.print(" "+arreglo[i]+" - ");
}
System.out.println("Todos los numeros del arreglo son iguales.");
}
______________________________________________________________________________________________________________________
Ejercicio 8: Diseñar una aplicacion que declare una tabla de 10 elementos enteros. Leer mediante el teclado 8 numeros.
Despues se debe pedir un numero y una posicion, insertarlo en la posicion indicada, desplazando los que esten detras.
----------------------------------------------------------------------------------------------------------------------
int[] arreglo = new int[10];
int numero, posicion;
for(int i=0;i<8;i++){
arreglo[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese "+(i+1)+"° numero del arreglo:"));
}
numero = Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero: "));
posicion = Integer.parseInt(JOptionPane.showInputDialog("Ingrese una posicion: "));
//Correr una posicion los elementos detras de la posicion que el usuario quiere
for (int i=7;i>=posicion;i--){
arreglo[i+1]= arreglo[i];
}
arreglo[posicion]= numero; //Insertamos el numero en la posicion requerida
System.out.println("El nuevo arreglo es: ");
for(int i=0;i<9;i++){
System.out.println("Posicion "+i+": "+arreglo[i]);
}
__________________________________________________________________________________________________________________________
Ejercicio 9: Crear un programa que lea por teclado una tabla de 10 numeros enteros y la desplace una posicion hacia abajo:
el primero pasa a ser el segundo, el segundo pasa a ser el trcero y asi sucesivamente. El ultimo pasa a ser el primero.
--------------------------------------------------------------------------------------------------------------------------
int[] arreglo = new int[10];
int i,ultimo;
for(i=0;i<10;i++){
arreglo[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese "+(i+1)+"° numero del arreglo:"));
}
ultimo =arreglo[9];

for(i=8;i>=0;i--){
arreglo[i+1]=arreglo[i];
}
arreglo[0]=ultimo;
for(i=0;i<10;i++){
 System.out.println("Posicion "+i+": "+arreglo[i]);
}
_______________________________________________________________________________
Ejercicio 10: Crear un programa que lea por teclado una tabla de 10 numeros
enteros y la desplace N posiciones en el arreglo N es digitado por el usuario).
------------------------------------------------------------------------------
int[] arreglo = new int[10];
int n_pos, ultimo;
for(int i=0;i<10;i++){
arreglo[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese "+(i+1)+"° numero del arreglo:"));
}
n_pos = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero de posiciones a desplazar:"));

for(int vuelta=1;vuelta<=n_pos;vuelta++){
ultimo=arreglo[9];
for(int i=8;i>=0;i--){
arreglo[i+1]=arreglo[i];
}
arreglo[0]=ultimo;
}
for(int i=0;i<10;i++){
System.out.println("Posicion "+i+": "+arreglo[i]);
}
___________________________________________________________________________________________________________________
Ejercicio 11: Leer 5 elementos numericos que se introduciran ordenados de forma creciente. Estos los guardaremos
en una tabla de tamaño 10. Leer un numero N, e insertarlo en el lugar adecuado para que la tabla continue ordenada.
-------------------------------------------------------------------------------------------------------------------
int[] arreglo = new int[10];
boolean creciente = true;
int numero, sitio=0, j=0;
do{
//Llenando el arreglo
for(int i=0;i<5;i++){ //Llenando el arreglo
arreglo[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese "+(i+1)+"° numero del arreglo:"));
}
// Comprobar si el arreglo esta ordenado crecientemente
for (int i=0;i<4;i++){
if (arreglo[i] < arreglo[i+1]){ //Creciente
creciente = true;
}
if(arreglo[i] > arreglo[i+1]){ //decreciente
creciente = false;
break;
}
 }
if (creciente == false){
JOptionPane.showMessageDialog(null,"El arreglo no esta ordenado en forma creciente, vuelva a digitar: ");
}
}while(creciente == false);
numero = Integer.parseInt(JOptionPane.showInputDialog("Digite un elemento a insertar: "));
// Esto es para darnos cuenta en que posicion va el numero
while (arreglo[j]<numero && j<5){
sitio++;
j++;
}
// Por ultimo, transladamos una posicion en el arreglo a los elementos que van detras de numero
for(int i=4;i>=sitio;i--){
arreglo[i+1] = arreglo[i];
}
// Insertamos el numero que el usuario puso
arreglo[sitio]= numero;
//Imprimimos el arreglo
for(int i=0;i<6;i++){
System.out.println("Posicion "+i+": "+arreglo[i]+" - ");
}
________________________________________________________________________________________________________
Ejercicio 12: Leer por teclado una tabla de 10 elementos numericos enteros y una posicion (entre 0 y 9).
Eliminar el elemento situado an la posicion dada sin dejar huecos.
--------------------------------------------------------------------------------------------------------
int[] arreglo = new int[10];
int posicion;
//Llenando el arreglo
for(int i=0;i<10;i++){ //Llenando el arreglo
arreglo[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese "+(i+1)+"° numero del arreglo:"));
}
do{
// pedimos la posicion en el rango de 0 - 9
posicion = Integer.parseInt(JOptionPane.showInputDialog("Digite una Posicion entre [0 - 9]: "));

}while(posicion<0 || posicion>9);
//Eliminando el elemento de posicion indicada
for(int i=posicion;i<9;i++){
arreglo[i] = arreglo[i+1];
}
//Imprimimos el arreglo
for(int i=0;i<9;i++){
System.out.println("Posicion "+i+": "+arreglo[i]+" - ");
}
_____________________________________________________________________________________________________
Ejercicio 13: Leer 10 enteros en una tabla. Guardar en otra tabla los elementos pares de la primera,
y a continuacion los elementos impares.
-----------------------------------------------------------------------------------------------------
int[] arreglo = new int[10];
int c_pares=0, c_impares=0;

//Llenando el arreglo
for(int i=0;i<10;i++){ //Llenando el arreglo
arreglo[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese "+(i+1)+"° numero del arreglo:"));
if(arreglo[i]% 2==0){
c_pares++;
}else{
c_impares++;
}
}
// Creamos los arreglos para pares e impares
int []pares = new int[c_pares];
int []impares = new int[c_impares];
//Guardamos los pares e impares en los arreglos
c_pares=0;
c_impares=0;
for(int i=0;i<10;i++){
if (arreglo[i] % 2 == 0){
pares[c_pares]= arreglo[i];
c_pares++;
}else{
impares[c_impares]= arreglo[i];
c_impares++;
}
}

//Imprimimos el arreglo original

System.out.println("Este es el arreglo original");
System.out.println("------------------------------");
for(int i=0;i<10;i++){

System.out.println("Posicion "+i+": "+arreglo[i]);

}
// imprimimos los pares
System.out.println("Estos son los numeros pares");
System.out.println("------------------------------");
for(int i=0;i<c_pares;i++){
 System.out.println("Posicion "+i+": "+pares[i]);
}
System.out.println("Estos son los numeros impares");
System.out.println("------------------------------");
for(int i=0;i<c_impares;i++){

System.out.println("Posicion "+i+": "+impares[i]);

}
__________________________________________________________________________________
Ejercicio 14: Leer dos series de 10 enteros, que estaran ordenados crecientemente.
Copiar (fusionar)las dos tablas en una tercera, de forma que sigan ordenados.
----------------------------------------------------------------------------------
int []a = new int[10];
int []b = new int[10];
int []c = new int[20];
boolean creciente = true;
do{
for(int i=0;i<10;i++){
a[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese "+(i+1)+"° numero del arreglo A:"));
}
//Comprobamos si el arreglo esta ordenado
for(int i=0;i<9;i++){
if(a[i]< a[i+1]){ //Creciente
creciente = true;
}
if(a[i]>a[i+1]){//Decreciente
creciente =false;
break;
}
}
if (creciente == false){
JOptionPane.showMessageDialog(null,"El arreglo no esta ordenado en forma creciente, vuelva a digitar: ");
}
}while(creciente == false);

do{
for(int i=0;i<10;i++){
b[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese "+(i+1)+"° numero del arreglo B:"));
}
//Comprobamos si el arreglo esta ordenado
for(int i=0;i<9;i++){
if(b[i]< b[i+1]){ //Creciente
creciente = true;
}
 if(b[i]>b[i+1]){//Decreciente
creciente =false;
break;
}
}
if (creciente == false){
JOptionPane.showMessageDialog(null,"El arreglo no esta ordenado en forma creciente, vuelva a digitar: ");
}
}while(creciente == false);
int i=0;//Iterador para arreglo A
int j=0;//Iterador para arreglo B
int k=0;//Iterador para arreglo C
while(i<10 && j<10){
if(a[i]<b[j]){ //Si elemento
c[k]=a[i];
i++;
}else{
c[k]= b[j];
j++;
}
k++;//avanzamos una posicion
}
if(i==10){
while(j<10){
c[k]=b[j];
j++;
k++;
}
}
else{
while(i<10){
c[k]=a[i];
i++;
k++;
}
}

for(k=0;k<20;k++){
System.out.println("Posicion "+k+": "+c[k]);
}
_______________________________________________________________________________________
Ejercicio 15: Leer 10 enteros ordenados crecientemente. Leer N y buscarlo en la tabla.
Se deben mostrar la posicion en que se encuentra. Si no esta, indicarlo con un mensaje
---------------------------------------------------------------------------------------
int arreglo[], numero;
boolean creciente = true;
arreglo = new int[10];
do{
//Pedimos el arreglo
for(int i=0;i<10;i++){
arreglo[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese "+(i+1)+"° numero del arreglo:"));
}
//Comprobamos si el arreglo esta ordenado
for(int i=0;i<9;i++){
if(arreglo[i]< arreglo[i+1]){ //Creciente
creciente = true;
}
if(arreglo[i]>arreglo[i+1]){//Decreciente
creciente =false;
break;
}
}
if(creciente == false){
JOptionPane.showMessageDialog(null,"El arreglo no esta ordenado en forma creciente, vuelva a digitar: ");
}
}while(creciente ==false);
numero = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero a buscar:"));
//Buscamos el numero en el arreglo
int i=0;
while(i<10 && arreglo[i]<numero){
i++;
}
if(i==10){//Hemos recorrido todo el arreglo y no encontramos nada
JOptionPane.showMessageDialog(null,"El numero no esta en el arreglo ");
}
else{
if(arreglo[i]== numero){
JOptionPane.showMessageDialog(null,"El numero: "+numero+ " encontrado en la posicion: "+i);
}
else{
JOptionPane.showMessageDialog(null,"Numero no encontrado");
}
}
_________________________________________________________________________________________________________________________________
Ejercicio 16: Queremos desarrollar una aplicacion que nos ayude a gestionar las notas de un centro educativo. Cada grupo(o clase)
esta compuesto por 5 alumnos. Se pide leer las notas del primer, segundo y tercer trimestre de un grupo. Debemos mostrar al final:
la nota media del grupo en cada trimestre, y la media del alumno que se encuentra en la posicion N (N se lee por teclado).
---------------------------------------------------------------------------------------------------------------------------------
float primer[],segundo[],tercer[];
primer = new float[5];
segundo = new float[5];
tercer = new float[5];
float sp=0,ss=0,st=0,pp,ps,pt,sa=0,pa;
int posicion;
//Ingresamos las notas del primer trimestre
for(int i=0;i<5;i++){
primer[i] = Float.parseFloat(JOptionPane.showInputDialog("Ingrese "+(i+1)+"° Alumno nota del Primer Trimestre:"));
sp+=primer[i];
}
// ingresamos notas del segundo trimestre
for(int i=0;i<5;i++){
segundo[i] = Float.parseFloat(JOptionPane.showInputDialog("Ingrese "+(i+1)+"° Alumno nota del Segundo Trimestre:"));
ss+=segundo[i];
}
// ingresamos notas del tercer trimestre
for(int i=0;i<5;i++){
tercer[i] = Float.parseFloat(JOptionPane.showInputDialog("Ingrese "+(i+1)+"° Alumno nota del Tercer Trimestre:"));
st+=tercer[i];
}
//Sacamos el promedio de cada uno de los trimestres
pp=sp/5;
ps=ss/5;
pt=st/5;
//Ahora pedimos la posicion del alumno N, para sacr su promedio
do{
posicion = Integer.parseInt(JOptionPane.showInputDialog("Digite la posicion del alumno [0-4], para sacr el promedio:"));
}while(posicion<0 || posicion>4);
//Sacamos la suma de las notas del alumno
sa=primer[posicion]+segundo[posicion]+tercer[posicion];
pa=sa/3;
// Mostrando los datos requeridos
JOptionPane.showMessageDialog(null,"El promedio del Primer Trimestre es: "+pp);
JOptionPane.showMessageDialog(null,"El promedio del Segundo Trimestre es: "+ps);
JOptionPane.showMessageDialog(null,"El promedio del Tercer Trimestre es: "+pt);
JOptionPane.showMessageDialog(null,"El promedio del "+posicion+"° alumno es: "+pa);
/=====================================
// SECCION 6: METODOS DE ORDENAMIENTO
//====================================
// 1. Metodo BURBUJA
//=====================================
int arreglo[], ne,aux;
ne = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero de elementos del arreglo:"));
arreglo = new int [ne]; //Asignamos el numero de elementos al vector
for (int i=0;i<ne;i++){
arreglo[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese "+(i+1)+"° elemento del vector:")); //Ingresamos los elementos al vector
}
//Implemetamos el metodo de Burbuja
for(int i=0;i<(ne-1);i++){
for(int j=0;j<(ne-1);j++){
if(arreglo[j]> arreglo[j+1]){ //Si NumeroActual > NumeroSiguiente
aux = arreglo[j];
arreglo[j]= arreglo[j+1];
arreglo[j+1]= aux;
}

}
}
// Mostrando el arreglo Ordenado crecientemente
System.out.println("---------------------------------------");
System.out.println("Arreglo ordenado en forma Creciente:");
System.out.println("---------------------------------------");
for(int i=0;i<ne;i++){
System.out.println("Posicion "+i+": "+arreglo[i]);
}
// Mostrando el arreglo ordenado decrecientemente
System.out.println("---------------------------------------");
System.out.println("Arreglo ordenado en forma Decreciente:");
System.out.println("---------------------------------------");
for(int i=(ne-1);i>=0;i--){
System.out.println("Posicion "+i+": "+arreglo[i]);
}
//=========================================
// 2. Metodo de ordenamiento por INSERCION
//==========================================
int arreglo[], ne,pos,aux;
ne = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero de elementos del arreglo:"));
arreglo = new int [ne]; //Asignamos el numero de elementos al vector
for (int i=0;i<ne;i++){
arreglo[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese "+(i+1)+"° elemento del vector:")); //Ingresamos los elementos al vector
}
//Implemetamos el metodo de Insercion
for(int i=0;i<(ne);i++){
pos=i;
aux = arreglo[i];
while ((pos>0) && (arreglo[pos-1]> aux)){
arreglo[pos]= arreglo[pos-1];
 pos--;
}
arreglo[pos]=aux;
}
// Mostrando el arreglo Ordenadocrecientemente
System.out.println("-----------------------------------------------------------");
System.out.println("Arreglo ordenado en forma Creciente por Metodo de Insercion:");
System.out.println("-----------------------------------------------------------");
for(int i=0;i<ne;i++){
System.out.println("Posicion "+i+": "+arreglo[i]);
}
// Mostrando el arreglo ordenado decrecientemente
System.out.println("-------------------------------------------------------------");
System.out.println("Arreglo ordenado en forma Decreciente por Metodo de Insercion:");
System.out.println("-------------------------------------------------------------");
for(int i=(ne-1);i>=0;i--){
System.out.println("Posicion "+i+": "+arreglo[i]);
}
/===========================================
// 3. Metodo de ordenamiento por SELECCION
//==========================================
int arreglo[], ne,min,aux;
ne = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero de elementos del arreglo:"));
arreglo = new int [ne]; //Asignamos el numero de elementos al vector
for (int i=0;i<ne;i++){
arreglo[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese "+(i+1)+"° elemento del vector:")); //Ingresamos los elementos al vector
}
//Implemetamos el metodo de Seleccion
for(int i=0;i<ne;i++){
min=i;
for(int j=i+1;j<ne;j++){
if (arreglo[j]< arreglo[min]){
min =j;
}
}
aux = arreglo[i];
arreglo[i]= arreglo[min];
arreglo[min]= aux;
}
// Mostrando el arreglo Ordenadocrecientemente
System.out.println("-----------------------------------------------------------");
System.out.println("Arreglo ordenado en forma Creciente por Metodo de Seleccion:");
System.out.println("-----------------------------------------------------------");
for(int i=0;i<ne;i++){
 System.out.println("Posicion "+i+": "+arreglo[i]);
}
// Mostrando el arreglo ordenado decrecientemente
System.out.println("-------------------------------------------------------------");
System.out.println("Arreglo ordenado en forma Decreciente por Metodo de Seleccion:");
System.out.println("-------------------------------------------------------------");
for(int i=(ne-1);i>=0;i--){
System.out.println("Posicion "+i+": "+arreglo[i]);
}
//==============================
// SECCION 7: B U S Q U E D A S
//===============================
//========================
// 1. Busqueda SECUENCIAL
//========================
int arreglo[], ne,dato;
boolean band = false;
ne = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero de elementos del arreglo:"));
arreglo = new int [ne]; //Asignamos el numero de elementos al vector
for (int i=0;i<ne;i++){
arreglo[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese "+(i+1)+"° elemento del vector:")); //Ingresamos los elementos al vector
}
dato = Integer.parseInt(JOptionPane.showInputDialog("Digite el elemento que quiere buscar:"));
// implementamos la Busqueda Secuencial
int i=0;
while (i<ne && band== false){
if (arreglo[i]== dato){
band = true;
}
i++;
}
if(band== false){
JOptionPane.showMessageDialog(null,"El numero no se encuentra en el arreglo");
}
else{
JOptionPane.showMessageDialog(null,"El numero: "+dato+" ha sido encontrado en la posicion "+(i-1));
}
//============================
// 2. Busqueda B I N A R I A
//============================
int arreglo[], ne, dato, inf, sup, mitad, i, aux;
boolean band = false;
ne = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero de elementos del arreglo:"));
arreglo = new int [ne]; //Asignamos el numero de elementos al vector
for (int j=0;j<ne;j++){
arreglo[j] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese "+(j+1)+"° elemento del vector:")); //Ingresamos los elementos al vector
}
//Ordenamos el vector crecientemente por el metodo de Burbuja
for(int k=0;k<(ne-1);k++){
for(int j=0;j<(ne-1);j++){
if(arreglo[j]> arreglo[j+1]){ //Si NumeroActual > NumeroSiguiente
aux = arreglo[j];
arreglo[j]= arreglo[j+1];
arreglo[j+1]= aux;
}

}
}
dato = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el elemento a buscar:"));
inf = 0;
sup = ne;
i=0;
mitad=(inf+sup)/2;
while(inf<=sup && i<ne){
if(arreglo[mitad]== dato){
band=true;
break;
}
if(arreglo[mitad]> dato){
sup= mitad;
mitad =(inf+sup)/2;
}
if(arreglo[mitad]< dato){
inf = mitad;
mitad = (inf+sup)/2;
}
i++;
}
if(band == true){
JOptionPane.showMessageDialog(null,"El numero: "+dato+" ha sido encontrado en la posicion "+mitad);
}
else{
JOptionPane.showMessageDialog(null,"El numero no se encuentra en el arreglo");
}
//==============================
// SECCION 8: M A T R I C E S
//===============================
int matriz[][],nf,nc;
nf = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero de filas de la matriz"));
nc = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero de columnas de la matriz"));
matriz = new int [nf][nc];// asignamos el numero de filas y columnas a la Matriz
for(int i=0;i<nf;i++){
for(int j=0;j<nc;j++){
matriz[i][j] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el elemento de la "+(i+1)+"° fila y la "+(j+1)+"° columna de la matriz:")); //Ingresamos los elementos al
la matriz
}
}
// IMPRIMIMOS LOS ELEMENTOS DE LA MATRIZ
for(int i=0;i<nf;i++){
for(int j=0;j<nc;j++){
System.out.print(matriz[i][j]);
}
System.out.println("");
}
//E J E R C I C I O S D E M A T R I C E S
_____________________________________________________________________________________
Ejercicio 1: Crear y cargar una matriz de tamaño n x m y decir si es simetrica o no.
-------------------------------------------------------------------------------------
int matriz[][],nf,nc;
boolean sime = true;
nf = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero de filas de la matriz"));
nc = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero de columnas de la matriz"));
matriz = new int [nf][nc];// asignamos el numero de filas y columnas a la Matriz
for(int i=0;i<nf;i++){
for(int j=0;j<nc;j++){
matriz[i][j] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el elemento de la "+(i+1)+"° fila y la "+(j+1)+"° columna de la matriz:")); //Ingresamos los elementos al
la matriz
}
}
// codigo que comprueba si la matriz es Simetrica
if(nf == nc){ //Si el numero de filas es igual al numero de columnas
int i,j;
i=0;
while(i<nf && sime==true){
j=0;
while (j<i && sime==true){
if(matriz[i][j]!= matriz[j][i]){
sime = false;
}
j++;
}
i++;
 }
if(sime == true){
JOptionPane.showMessageDialog(null,"La Matriz es Simetrica");
}
else{
JOptionPane.showMessageDialog(null,"La Matriz no es Simetrica");
}
}
else{
JOptionPane.showMessageDialog(null,"La Matriz no es Simetrica");
}
// IMPRIMIMOS LOS ELEMENTOS DE LA MATRIZ
for(int i=0;i<nf;i++){
for(int j=0;j<nc;j++){
System.out.print(matriz[i][j]);
}
System.out.println("");
}
_____________________________________________________________________________________
Ejercicio 2: Crear y cargar dos matrices de tamaño 3x3, sumarlas y mostrar su suma.
-------------------------------------------------------------------------------------
int matriz1[][],matriz2[][], suma[][],nf,nc;
nf = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero de filas de la matriz"));
nc = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero de columnas de la matriz"));
matriz1 = new int [nf][nc];// asignamos el numero de filas y columnas a la Matriz1
matriz2 = new int [nf][nc];// asignamos el numero de filas y columnas a la Matriz2
suma = new int [nf][nc];// asignamos el numero de filas y columnas a la suma
for(int i=0;i<nf;i++){ //Llenamos la matriz1 con sus elementos
for(int j=0;j<nc;j++){
//Llenamos la Matriz1 y la Matriz2
matriz1[i][j] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el elemento de la "+(i+1)+"° fila y la "+(j+1)+"° columna de la matriz1:")); //Ingresamos los elementos
al la matriz
matriz2[i][j] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el elemento de la "+(i+1)+"° fila y la "+(j+1)+"° columna de la matriz2:")); //Ingresamos los
elementos al la matriz
//Sumamos las matrices
suma[i][j]= matriz1[i][j]+ matriz2[i][j];
}
}
// IMPRIMIMOS LOS ELEMENTOS DE LA MATRIZ
for(int i=0;i<nf;i++){
for(int j=0;j<nc;j++){
System.out.print(suma[i][j]+" ");
}
System.out.println("");
}
_____________________________________________________________________________________
Ejercicio 3: Crear y cargar dos matrices de tamaño 3x3, trasponerla y mostrarla.
-------------------------------------------------------------------------------------
int matriz[][],traspuesta[][],nf,nc;
nf = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero de filas de la matriz"));
nc = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero de columnas de la matriz"));
matriz = new int [nf][nc];// asignamos el numero de filas y columnas a la Matriz1
traspuesta = new int [nc][nf];// asignamos el numero de filas y columnas a la Matriz2
for(int i=0;i<nf;i++){ //Llenamos la matriz1 con sus elementos
for(int j=0;j<nc;j++){
//Llenamos la Matriz1 y la Matriz2
matriz[i][j] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el elemento de la "+(i+1)+"° fila y la "+(j+1)+"° columna de la matriz1:")); //Ingresamos los elementos
al la matriz
}
}
// IMPRIMIMOS LA MATRIZ ORIGINALÑ
System.out.println("\nLa Matriz Original es: ");
System.out.println("------------------------------");
for(int i=0;i<nf;i++){
for(int j=0;j<nc;j++){
System.out.print(matriz[i][j]+" ");
}
System.out.println("");
}
//trasponemos la matriz
int aux;
for(int i=0;i<nf;i++){
for(int j=0;j<i;j++){
aux = matriz[i][j];
matriz[i][j]=matriz[j][i];
matriz[j][i] = aux;
}
}

// IMPRIMIMOS LOS ELEMENTOS DE LA MATRIZ

System.out.println("\nLa Matriz traspuesta es: ");
System.out.println("------------------------------");
for(int i=0;i<nf;i++){
for(int j=0;j<nc;j++){
System.out.print(matriz[i][j]+" ");
}
System.out.println("");
}
_________________________________________________________________________________________________________________________________
Ejercicio 4: Crear una matriz de tamaño 7x7 y rellenarla de forma que los elementos de la diagonal principal sean 1 y el resto 0.
---------------------------------------------------------------------------------------------------------------------------------
int matriz [][]= new int[7][7];
for (int i=0;i<7;i++){
for (int j=0;j<7;j++){
if(i==j){
matriz[i][j]= 1;
}
else {
matriz[i][j]= 0;
}
}
}
// Imprimimos la matriz
System.out.println("\nLa Matriz Diagonal es: ");
System.out.println("------------------------------");
for(int i=0;i<7;i++){
for(int j=0;j<7;j++){
System.out.print(matriz[i][j]+" ");
}
System.out.println("");
}
_______________________________________________________________________________________________________
Ejercicio 5: Crear y cargar una matriz de tamaño n x m, mostrar la suma de cada fila y de cada columna.
-------------------------------------------------------------------------------------------------------
int matriz[][],suma[][],nf,nc,sf,sc;
nf = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero de filas de la matriz"));
nc = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero de columnas de la matriz"));
matriz = new int [nf][nc];// asignamos el numero de filas y columnas a la Matriz
suma = new int [nc][nf];// asignamos el numero de filas y columnas a la suma
for(int i=0;i<nf;i++){ //Llenamos la matriz1 con sus elementos
for(int j=0;j<nc;j++){
//Llenamos la Matriz1 y la Matriz2
matriz[i][j] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el elemento de la "+(i+1)+"° fila y la "+(j+1)+"° columna de la matriz1:")); //Ingresamos los elementos
al la matriz
}
}
// IMPRIMIMOS LA MATRIZ ORIGINAL
System.out.println("\nLa Matriz Original es: ");
System.out.println("------------------------------");
for(int i=0;i<nf;i++){
for(int j=0;j<nc;j++){
System.out.print(matriz[i][j]+" ");
 }
System.out.println("");
}
//Procedemos a sumar las filas
for(int i=0;i<nf;i++){
sf=0;
for(int j=0;j<nc;j++){
sf+=matriz[i][j];
}
System.out.print("\nLa suma de la fila["+(i+1)+ "] es: "+sf);
}
System.out.println("");

//Procedemos a sumar las columnas

for(int j=0;j<nc;j++){
sc=0;
for(int i=0;i<nf;i++){
sc +=matriz[i][j];
}
System.out.print("\nLa suma de la columna["+(j+1)+ "] es: "+sc);
}
System.out.println("");
____________________________________________________________________________________________________________
Ejercicio 6: Utilizando dos matrices de tamaño 5 x 9 y 9 x 5, cargar la primera y trasponerla en la segunda.
------------------------------------------------------------------------------------------------------------
int matriz1[][], matriz2[][];
matriz1 = new int [5][9];
matriz2 = new int [9][5];
for(int i=0;i<5;i++){ //Llenamos la matriz1 con sus elementos
for(int j=0;j<9;j++){
//Llenamos la Matriz1 y la Matriz2
matriz1[i][j] = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el elemento de la "+(i+1)+"° fila y la "+(j+1)+"° columna de la matriz1:")); //Ingresamos los elementos
al la matriz
}
}
// IMPRIMIMOS LA MATRIZ ORIGINAL
System.out.println("\nLa Matriz Original es: ");
System.out.println("------------------------------");
for(int i=0;i<5;i++){
for(int j=0;j<9;j++){
System.out.print(matriz1[i][j]+" ");
}
System.out.println("");
}
 //TRASPONEMOS LA MATRIZ
int aux;
for(int i=0;i<5;i++){
for(int j=0;j<9;j++){
aux = matriz1[i][j];
matriz2[j][i]=matriz1[i][j];
}
}
// IMPRIMIMOS LOS ELEMENTOS DE LA MATRIZ TRASPUESTA
System.out.println("\nLa Matriz traspuesta es: ");
System.out.println("------------------------------");
for(int i=0;i<9;i++){
for(int j=0;j<5;j++){
System.out.print(matriz2[i][j]+" ");
}
System.out.println("");
}
__________________________________________________________________________
Ejercicio 7: Crear una matriz "marco" de tamaño 5x5: todos sus elementos
deben ser 0 salvo los de los bordes que deben ser 1. Mostrala.
--------------------------------------------------------------------------
int matriz [][]= new int[5][5];
for(int i=0;i<5;i++){ //Llenamos la matriz1 con sus elementos
for(int j=0;j<5;j++){
if(i==0 || i==4){ //Delimita las columnas
matriz[i][j]= 1;
}
else if(j==0 || j==4){
matriz[i][j]= 1;
}
else{matriz[i][j]=0;
}
}
}
// IMPRIMIMOS LOS ELEMENTOS DE LA MATRIZ
System.out.println("\nLa Matriz marco es: ");
System.out.println("------------------------------");
for(int i=0;i<5;i++){
for(int j=0;j<5;j++){
System.out.print(matriz[i][j]+" ");
}
System.out.println("");
}
}
//====================================================
// SECCION 9: Programacion Orientada a Objetos (POO)
//====================================================
//------------------------
//1.- Conceptos de POO
//------------------------
//Atributos, Propiedades, Caracteristicas (color, marca, Km)
//Metodos, Acciones (encender, Apagar, acelerar)
//----------------------------------
//2.- Creacion de Clases y Objetos
//----------------------------------
/* Creacion de Clase

public class Coche{

-----------------------
-----------------------
}
Creacion de Objeto
Coche coche1 = new Coche();

//11.- Miembros Estaticos de una Clase

//12.- Herencia
//13.- Clses y Metodos Final
//14.- Sobre escritura de Miembros
//15.- Clases y Metodos Abstarctos
//16.- Polimorfismo
//17.- Ejercicios de Parctica
package ClasesyObjetos;
import javax.swing.JOptionPane;

// 3.- CONCEPTO Y CREACION DE METODOS

// 4.- METODOS PARAMETROS Y ARGUMENTOS
public class Operacion { //Creo la clase
int suma, resta, multi, divi;
// 5.- METODOS RETORNO DE VALORES
----------------*/
public void sumar(int numero1, int numero2){ // Creo metodo para sumar 2 numeros
suma = numero1+numero2;
}
public void restar(int numero1, int numero2){ // Creo metodo para restar 2 numeros
resta = numero1-numero2;
}
public void multiplicar(int numero1, int numero2){ // Creo metodo para multiplicar 2 numeros
multi = numero1*numero2;
 }
public void dividir(int numero1, int numero2){ // Creo metodo para dividir 2 numeros
divi = numero1/numero2;
}
public void mostraResultados(){ // Creo metodo para mostrar resultados
System.out.println("\nLa Suma es: "+suma);
System.out.println("\nLa Resta es: "+resta);
System.out.println("\nLa Multiplicacion es: "+multi);
System.out.println("\nLa Division es: "+divi);
}
}

package ClasesyObjetos;
import javax.swing.JOptionPane;
public class Main { // Creo la clase Main
public static void main(String [] args){ // Creo el Metodo Main
int n1 = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el primer Numero: "));
int n2 = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el primer Numero: "));
Operacion op = new Operacion(); // Creo el objeto op de la clase operacion
op.sumar(n1, n2);
op.restar(n1,n2);
op.multiplicar(n1,n2);
op.dividir(n1,n2);
op.mostraResultados();
}
}

//6.- METODO CONSTRUCTOR

package ClasesyObjetos;
public class Persona {
//Atributos, Propiedades, Caracteristicas
String nombre;
int edad;

// Metodos
public Persona(String nombre, int edad){ //Creo el Metodo Constructor
this.nombre = nombre;
this.edad = edad;
}
public void mostrarDatos(){
System.out.println("El nombre es: "+nombre);
System.out.println("La edad es: "+edad);
}
}
package ClasesyObjetos;

public class Main {

public static void main(String[]args){
Persona p1 = new Persona("Alfonso", 58);
p1.mostrarDatos();
}
}
// 8.- MODIFICADORES DE ACCESO
package Paquete1;

public class Clase1 {

public int atributo1;
}
package Paquete1;

public class Clase2 {

public static void main(String[] args){

}
}
package Paquete2;
import Paquete1.Clase1;
public class Clase3 {
public static void main(String[] args){
Clase1 objeto1 = new Clase1();
objeto1.atributo1 = 15;
}
}
// 9.- ENCAPSULAMIENTO Y METODOS ACCESORES (Setters y Getters)
package Paquete1;

public class Clase1 {

private int edad;
private String nombre;
//Metodo Setters: Establecemos la edad

public void setEdad(int edad){

this.edad = edad;
}
//Metodo Getters: Mostramos la edad

public int getEdad(){

return edad;
}
// Podemos generar el Setters y getters en: Insertar/Code/Setters and Getters

public void setNombre(String nombre) {

this.nombre = nombre;
}

public String getNombre() {

return nombre;
}
}
package Paquete1;

public class Clase2 {

public static void main(String[] args){
Clase1 objeto1 = new Clase1();
objeto1.setEdad(58);
System.out.println("La edad es: "+objeto1.getEdad());
objeto1.setNombre("Alfonso");
System.out.println("El nombre es: "+objeto1.getNombre());
}

}
// 10.- C O N S T A N T E S
package Paquete1;

public class Persona {

//Declaro una constante con la palabra final

private final String nombre;

private int edad;

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

public void mostrarDatos (){

System.out.println("El nombre es: "+nombre);
System.out.println("La Edad es: "+edad);
}
 public int getEdad() {
return edad;
}

public void setEdad(int edad) {

this.edad = edad;
}
package Paquete1;

public class Principal {

public static void main(String[] args){
Persona p1 = new Persona("Alfonso", 58);
p1.setEdad(65);
p1.mostrarDatos();

}
}
// 11.- MIEMBROS ESTATICOS DE UNA CLASE (La clase es dueña del atributo)
package Paquete1;

public class Estatico {

private static final String frase = "Primera Frase"; // Creamos un atributo de tipo estatico (Le pertenece a la clase Estatico)

public static int sumar(int a, int b){// Creamos un metodo de tipo estatico (Le pertenece a la clase Estatico)
int suma = a+b;
return suma;
}
public static void main(String[] args){

System.out.println(Estatico.frase); // Asi se hace referencia a el atributo estatico

System.out.println("La suma es: "+Estatico.sumar(10, 4)); // Asi se hace referencia a el metodo estatico
}
}
/*________________________________________________________________________________
EJERCICIO 1: Construir un programa que calcule el área y el perímetro de un cuadrilátero dada
la longitud de sus dos lados. Los valores de la longitud deberan introducirse por linea de órdenes.
Si es un cuadrado, solo se proporcionará la longitud de uno de los lados al constructor.
------------------------------------------------------------------------------------------------------------------------------------*/

package Ejercicio1;

public class Cuadrilatero {

//ATRIBUTOS
private float lado1, lado2;
//METODOS
// Metodo Constructor 1 (Cuadrilatero)
public Cuadrilatero(float lado1, float lado2) {
this.lado1 = lado1;
this.lado2 = lado2;
}
// Metodo Constructor 2 (Cuadrado)
public Cuadrilatero(float lado1) {
this.lado1 = this.lado2=lado1;
}
public float getPerimetro(){
float perimetro = 2 * (lado1+lado2);
return perimetro;
}
public float getArea(){
float area = (lado1*lado2);
return area;
}
}

//--------------------
// M A I N
//--------------------

package Ejercicio1;

import javax.swing.JOptionPane;

public class Main {

public static void main(String[]args){
Cuadrilatero c1;
float lado1, lado2;
lado1 = Float.parseFloat(JOptionPane.showInputDialog("Digite el valor del lado1: "));
lado2 = Float.parseFloat(JOptionPane.showInputDialog("Digite el valor del lado2: "));
if(lado1 == lado2){ //Es un cuadrado
c1 = new Cuadrilatero(lado1);
}
else{
c1 = new Cuadrilatero(lado1, lado2);
}
System.out.println("El perimetro es: "+c1.getPerimetro());
System.out.println("El area es: "+c1.getArea());
}
}
/*__________________________________________________________________________________________________
EJERCICIO 2: Construir un programa que permita dirigir el movimiento de un objeto dentro de un tablero y actualice
su posición dentro del mismo. Los movimientos posibles son ARRIBA, ABAJO, IZQUIERDA y DERECHA. Tras cada movimiento
el programa mostrara la nueva dirección elegida y las coordenadas de situación del objeto dentro del tablero.
-------------------------------------------------------------------------------------------------------------------------------------------------------------------*/

package Ejercicios;

public class Tablero {

private int x;
private int y;

//Creamos el metodo Constructor

public Tablero(int x, int y) {

this.x = x;
this.y = y;
}

// METODOS
public void moverArriba(int incremento){
y += incremento;
}
 public void moverAbajo(int incremento){
y -= incremento;
}
public void moverDerecha(int incremento){
x += incremento;
}
public void moverIzquierda(int incremento){
x -= incremento;
}

public int getX() {

return x;
}

public int getY() {

return y;
}

//--------------------
// M A I N
//--------------------

Ejercicios;

import java.util.Scanner;
import javax.swing.JOptionPane;

public class Main {

public static void main(String[]args){
Scanner entrada = new Scanner(System.in);
Tablero t1;
int x,y,op, incremento=0;
x = Integer.parseInt(JOptionPane.showInputDialog("Digite la coordenada inicial de X: "));
y = Integer.parseInt(JOptionPane.showInputDialog("Digite la coordenada inicial de Y: "));

// LLAMAMOS AL CONSTRUCTOR
t1 = new Tablero (x,y); //Posicion inicial del objeto
do{
System.out.println("----------------------");
System.out.println(" M E N U ");
 System.out.println("----------------------");
System.out.println("1.- Mover hacia ARRIBA");
System.out.println("2.- Mover hacia ABAJO");
System.out.println("3.- Mover hacia la DERECHA");
System.out.println("4.- Mover hacia la IZQUIERDA");
System.out.println("5.- Salir");
System.out.print("Digite la opcion: ");
op = entrada.nextInt();
if (op !=5){
System.out.print("\nDigite la cantidad de espacios a moverse: ");
incremento = entrada.nextInt();
}
switch(op){
case 1: t1.moverArriba(incremento);
break;
case 2: t1.moverAbajo(incremento);
break;
case 3: t1.moverDerecha(incremento);
break;
case 4: t1.moverIzquierda(incremento);
break;
case 5: break;
default: System.out.println("Opcion fuera de rango [1-5]");
break;
}
System.out.println(("\nPosicion Actual(X,Y): ("+t1.getX()+" , "+t1.getY()+")"));
}while(op!=5 );
}
}

/*______________________________________________________________________________
EJERCICIO 3: Construir un programa que dada una serie de vehículos caracterizados por su marca,
modelo y precio, imprima las propiedades del vehículo más barato. Para ello, se deberán leer por
teclado las características de cada vehículo y crear una clase que represente a cada uno de ellos.
------------------------------------------------------------------------------------------------------------------------------------*/

package Ejercicios;

public class Vehiculo {

//ATRIBUTOS
private String marca,modelo;
private float precio;
//METODOS
//Constructor
public Vehiculo(String marca, String modelo, float precio) {
this.marca = marca;
this.modelo = modelo;
this.precio = precio;
}

public double getPrecio() {

return precio;
}
 public String mostrarDatos(){
return "Marca: "+marca+"\nModelo: "+modelo+"\nPrecio: $"+precio+"\n";
}
}

//--------------------
// M A I N
//--------------------

package Ejercicios;

import java.util.Scanner;
import javax.swing.JOptionPane;

public class Main {

public static int indcocBar(Vehiculo autos[]){
float precio;
int indice = 0;
precio = (float) autos[0].getPrecio();
for (int i=1;i<autos.length;i++){
if(autos[i].getPrecio()< precio){
precio = (float)autos[i].getPrecio();
indice= i;
}
}
return indice;
}
public static void main(String[]args){
Scanner entrada = new Scanner(System.in);
String marca, modelo;
float precio;
int nv, indautba;
nv = Integer.parseInt(JOptionPane.showInputDialog("Digite la cantidad de Vehiculos: "));
//Creamos los objetos para los coches
Vehiculo autos[] = new Vehiculo[nv];
for(int i=0;i<autos.length;i++){
entrada.nextLine();
System.out.println("\nDigite las caracteristicas del "+(i+1)+"o. auto: ");
System.out.print("Introduzca la Marca del coche: ");
marca = entrada.nextLine();
System.out.print("Introduzca el Modelo del coche: ");
modelo = entrada.nextLine();
System.out.print("Introduzca el Precio del coche: ");
precio = entrada.nextFloat();
 autos[i] = new Vehiculo(marca, modelo, precio);
}

// LLAMAMOS AL CONSTRUCTOR

indautba = indcocBar(autos);
System.out.println("\nEl Auto mas barato es: ");
System.out.println(autos[indautba].mostrarDatos());
}
}

/*_________________________________________________________________________
EJERCICIO 4: Construir un programa para una competencia de atletismo, el programa debe
gestionar una serie de atletas caracterizados por su número de atleta, nombre y tiempo
de carrera, al final el programa debe mostrar los datos del atleta ganador de la carrera.
------------------------------------------------------------------------------------------------------------------------*/

package Ejercicios;

public class Atleta {

//ATRIBUTOS
private int numAtl;
private String nombre;
private float tiempoCar;
//METODOS
//Constructor

public Atleta(int numAtl, String nombre, float tiempoCar) {

this.numAtl = numAtl;
this.nombre = nombre;
this.tiempoCar = tiempoCar;
}

public float getTiempoCar() {

return tiempoCar;
}

public String mostrarDatos(){

return "Numero de Atleta: "+numAtl+"\nNombre del atleta: "+nombre+"\nTiempo de carrera: "+tiempoCar+"\n";
}
}
//--------------------
// M A I N
//--------------------

package Ejercicios;

import java.util.Scanner;
import javax.swing.JOptionPane;

public class Main {

public static int indiceGanador(Atleta atletas[]){
float tiempoCar;
int indice = 0;
tiempoCar = (float) atletas[indice].getTiempoCar();
for (int i=1;i<atletas.length;i++){
if(atletas[i].getTiempoCar()< tiempoCar){
tiempoCar = (float)atletas[i].getTiempoCar();
indice= i;
}
}
return indice;
}
public static void main(String[]args){
Scanner entrada = new Scanner(System.in);
String nombre;
 int numAtl, na, indiceAtletaGanador;
float tiempoCar;

na = Integer.parseInt(JOptionPane.showInputDialog("Digite la cantidad de Atletas a participar: "));

//Creamos los objetos para los coches
Atleta atletas[] = new Atleta[na];
for(int i=0;i<atletas.length;i++){

System.out.println("\nDigite los datos del "+(i+1)+"o. Atleta: ");

System.out.print("Introduzca el numero del Atleta: ");
numAtl = entrada.nextInt();
entrada.nextLine();
System.out.print("Introduzca el Nombre del Atleta: ");
nombre = entrada.nextLine();
System.out.print("Introduzca el Tiempo de Carrera: ");
tiempoCar = entrada.nextFloat();
atletas[i] = new Atleta(numAtl, nombre, tiempoCar);
}

// LLAMAMOS AL CONSTRUCTOR

indiceAtletaGanador = indiceGanador(atletas);
System.out.println("\nEl Atleta ganador es: ");
System.out.println(atletas[indiceAtletaGanador].mostrarDatos());
}
}

/*________________________________________________________________________________________________________________________________________
EJERCICIO 5: Diseñar un programa para trabajar con triángulos isósceles. Para ello defina los atributos necesarios que se requieren, proporcione métodos de consulta, un
método constructor e implemente métodos para calcular el perímetro y el área de un triángulo, además implementar un método que a partir de un arreglo de triángulos
devuelva el área del triángulo de mayor superficie.
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/

package Ejercicios;
public class Triangulo_Isosceles {
//ATRIBUTOS
private double base, lado;

//METODOS
//Constructor

public Triangulo_Isosceles(double base, double lado) {

this.base = base;
this.lado = lado;
}
public double obtenerPerimetro(){
double perimetro = 2*lado+base;
return perimetro;
 }

public double obtenerArea(){

double area = (base*Math.sqrt((lado*lado)-((base*base)/4)))/2;
return area;
}
public String mostrarDatos(){
return "Base: "+base+"\nlado: "+lado+"\nPerimetro: "+obtenerPerimetro()+"\nArea: "+obtenerArea()+"\n";
}
}

//--------------------
// M A I N
//--------------------
package Ejercicios;

import java.util.Scanner;
import javax.swing.JOptionPane;

public class Main {

public static double mayorArea(Triangulo_Isosceles triangulos[]){
double area;
area = triangulos[0].obtenerArea();
for (int i=1;i<triangulos.length;i++){
if(triangulos[i].obtenerArea()> area){
area = triangulos[i].obtenerArea();
}
}
return area;
}
public static void main(String[]args){
Scanner entrada = new Scanner(System.in);
double base, lado;
int nTria;

nTria = Integer.parseInt(JOptionPane.showInputDialog("Digite el numero de Triangulos a Ingresar: "));

//Creamos los objetos para los coches
Triangulo_Isosceles triangulos[] = new Triangulo_Isosceles[nTria];
System.out.println("=============================");
System.out.println("INFORMACION DE LOS TRIANGULOS");
System.out.println("=============================");
for(int i=0;i<triangulos.length;i++){
System.out.println("\nDigite los datos del Triangulo "+(i+1)+":");
System.out.print("Introduzca la base: ");
 base = entrada.nextDouble();
entrada.nextLine();
System.out.print("Introduzca el Lado: ");
lado = entrada.nextDouble();
triangulos[i] = new Triangulo_Isosceles(base, lado);
System.out.println("\nEl Perimetro del Triangulo es: "+triangulos[i].obtenerPerimetro());
System.out.println("\nEl Area del Triangulo es: "+triangulos[i].obtenerArea());
}
// LLAMAMOS AL CONSTRUCTOR
System.out.println("\nEl Area del Triangulo de Mayor Superficie es: "+mayorArea(triangulos));
}
}
/*______________________________________________________________________________________________________
EJERCICIO 6: Construir un programa para trabajar con 2 números complejos, implemente el siguiente menú:
1.- Sumar dos números complejos
2.- Multiplicar 2 números complejos
3.- Comparar 2 números complejos (iguales o no)
4.- Multiplicar un numero complejo por un entero
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/

package Ejercicios;
public class NumeroComplejo {
//ATRIBUTOS
private double a,b;

//METODOS
//Constructor

public NumeroComplejo(double a, double b) {

this.a = a;
this.b = b;
}

public double getA() {

return a;
}

public double getB() {

return b;
}
/* SUMAR NUMEROS COMPLEJOS
numero1 = 3 + 4i
numero2 = 2 + 5i
suma = 5 + 9i
NumeroComplejo numero1 = new NumeroComplejo(3,4)
numero1.calcularSuma(numero2)
*/

public NumeroComplejo calcularSuma(NumeroComplejo c){

NumeroComplejo suma = new NumeroComplejo(a+c.getA(),b+c.getB());
return suma;
}
/* MULTIPLICAR NUMEROS COMPLEJOS
numero1 = 3 + 4i
numero2 = 2 + 5i
mult = (3*2 - 4*5) + (3*5 + 4*2)i
*/
public NumeroComplejo calcularProducto(NumeroComplejo c){
NumeroComplejo mult = new NumeroComplejo((a*c.getA()-b*c.getB()),(a*c.getB()+b*c.getA()));
return mult;
}
/* COMPARRA 2 NUMEROS COMPLEJOS
numero1 = 3 + 4i
numero2 = 2 + 5i
 */
public boolean comprobarIgualdad(NumeroComplejo c){
boolean igualdad = false;
if((a==c.getA()) && (b==c.getB())){
igualdad = true;
}
return igualdad;
}
/* MULTIPLICAR UN NUMERO COMPLEJO POR UN ENTERO
numero1 = 3 + 4i
entero = 2
mult = 6 + 8i
*/
public NumeroComplejo multiplicarPorEntero(int x){
NumeroComplejo mult = new NumeroComplejo(a*x,b*x);
return mult;
}

}
//--------------------
// M A I N
//--------------------
package Ejercicios;

import java.util.Scanner;
import javax.swing.JOptionPane;

public class Main {

public static double mayorArea(NumeroComplejo triangulos[]){
double area;
area = triangulos[0].obtenerArea();
for (int i=1;i<triangulos.length;i++){
if(triangulos[i].obtenerArea()> area){
area = triangulos[i].obtenerArea();
}
}
return area;
}
public static void main(String[]args){
Scanner entrada = new Scanner(System.in);
NumeroComplejo numero1,numero2,suma,mult;
double a,b,c,d;
int op,n;
do{
System.out.println("================================");
System.out.println("OPERACIONES CON NUMEROS COMPLEJOS");
System.out.println("================================");
System.out.println("1.- Sumar 2 numeros Complejos");
System.out.println("2.- Multiplicar 2 numeros Complejos");
System.out.println("3.- Comparar 2 numeros Complejos (Iguales o no)");
System.out.println("4.- Multiplicar un numeros Complejo por un entero");
System.out.println("5.- Salir");
System.out.print("Digite la Opcion de Menu: ");
op = entrada.nextInt();
switch (op){
case 1: System.out.println("\nDigite el primer numero complejo: ");
System.out.print("Digite la parte real: ");
a = entrada.nextDouble();
System.out.print("Digite la parte imaginaria: ");
b = entrada.nextDouble();
System.out.println("\nDigite el segundo numero complejo: ");
System.out.print("Digite la parte real: ");
c = entrada.nextDouble();
System.out.print("Digite la parte imaginaria: ");
d = entrada.nextDouble();
numero1 = new NumeroComplejo(a,b);
numero2 = new NumeroComplejo(c,d);
suma = numero1.calcularSuma(numero2);
System.out.println("\nLa Suma es: "+suma.getA()+" + "+suma.getB()+"i");
break;
case 2: System.out.println("\nDigite el primer numero complejo: ");
System.out.print("Digite la parte real: ");
a = entrada.nextDouble();
System.out.print("Digite la parte imaginaria: ");
b = entrada.nextDouble();
System.out.println("\nDigite el segundo numero complejo: ");
System.out.print("Digite la parte real: ");
c = entrada.nextDouble();
System.out.print("Digite la parte imaginaria: ");
d = entrada.nextDouble();
numero1 = new NumeroComplejo(a,b);
numero2 = new NumeroComplejo(c,d);
mult = numero1.calcularProducto(numero2);
System.out.println("\nLa Multiplicacion es: "+mult.getA()+" + "+mult.getB()+"i");
break;
case 3: System.out.println("\nDigite el primer numero complejo: ");
System.out.print("Digite la parte real: ");
a = entrada.nextDouble();
 System.out.print("Digite la parte imaginaria: ");
b = entrada.nextDouble();
System.out.println("\nDigite el segundo numero complejo: ");
System.out.print("Digite la parte real: ");
c = entrada.nextDouble();
System.out.print("Digite la parte imaginaria: ");
d = entrada.nextDouble();
numero1 = new NumeroComplejo(a,b);
numero2 = new NumeroComplejo(c,d);
if(numero1.comprobarIgualdad(numero2)){
System.out.println("\nLos Numeros Complejos son Iguales");
}else{
System.out.println("\nLos Numeros Complejos no son Iguales");
}
break;
case 4: System.out.println("\nDigite el numero complejo: ");
System.out.print("Digite la parte real: ");
a = entrada.nextDouble();
System.out.print("Digite la parte imaginaria: ");
b = entrada.nextDouble();
System.out.print("Ahora digite el numero Entero: ");
n = entrada.nextInt();
numero1 = new NumeroComplejo(a,b);
mult = numero1.multiplicarPorEntero(n);
System.out.println("\nLa Multiplicacion es: "+mult.getA()+" + "+mult.getB()+"i");
break;
}
System.out.println("");
}while(op>= 1 && op<=4);

}
}
/*______________________________________________________________________________________________________
EJERCICIO 7: Hacer un programa sencillo para realizar gestiones en un banco para lo cual tendremos 2 clases (Cliente y Cuenta).
Considerar que un cliente se caracteriza por su nombre, apellido y DNI. El cliente puede consultar saldo, así como ingresar y
retirar dinero de sus cuentas. Además, cada cuenta se caracteriza por un número de cuenta y un saldo.
------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/

package Ejercicios;

public class Cliente {

private String nombre, apellido, dni;
Cuenta cuentas[];

public Cliente(String nombre, String apellido, String dni, Cuenta[] cuentas) {

this.nombre = nombre;
this.apellido = apellido;
this.dni = dni;
this.cuentas = cuentas;
 }

public String getNombre() {

return nombre;
}

public String getApellido() {

return apellido;
}

public String getDni() {

return dni;
}
public double consultar_saldo(int n){
return cuentas[n].getSaldo();
}
public void ingresar_dinero(int n, double cantidad){
cuentas[n].ingresarDinero(cantidad);
}
public void retirar_dinero(int n, double cantidad){
cuentas[n].retirarDinero(cantidad);
}
}

package Ejercicios;

public class Cuenta {

private int numCuenta;
private double saldo;

public Cuenta(int numCuenta, double saldo) {

this.numCuenta = numCuenta;
this.saldo = saldo;
}

public int getNumCuenta() {

return numCuenta;
}

public double getSaldo() {

return saldo;
}
public void ingresarDinero(double cantidad){
saldo += cantidad;
 }
public void retirarDinero(double cantidad){
saldo -= cantidad;
}
}

//--------------------
// M A I N
//--------------------

package Ejercicios;
import java.util.Scanner;
import javax.swing.JOptionPane;

public class Main {

public static int buscarNumeroCuenta(Cuenta cuentas[], int n){
int i=0, indice=0;
boolean encontrado = false;
//Busqueda Secuencial
while((i<cuentas.length) && (encontrado==false)){
if(cuentas[i].getNumCuenta() == n){
encontrado = true;
indice= i;
}
i++;
}
if(encontrado == false){
indice = -1;
}
return indice;
}
public static void main(String[]args){
Scanner entrada = new Scanner(System.in);
String nombre, apellido, dni;
int numCuenta, nCuentas, op, indiceCuenta;
double saldo, cantidad;
Cuenta cuentas[];
Cliente cliente;
System.out.print("Digite el nombre del cliente: ");
nombre = entrada.nextLine();
System.out.print("Digite el apellido del Cliente: ");
apellido = entrada.nextLine();
System.out.print("Digite el DNI del Cliente: ");
dni = entrada.nextLine();
System.out.print("Ahora, digite cuantas cuentas tiene: ");
nCuentas = entrada.nextInt();
cuentas = new Cuenta[nCuentas];
for(int i=0;i<cuentas.length;i++){
System.out.println("\nDigite los datos para la cuenta "+(i+1)+":");
System.out.print("Digite el numero de cuenta: ");
numCuenta = entrada.nextInt();
System.out.print("Digite el saldo de la cuenta: ");
saldo = entrada.nextDouble();
cuentas[i] = new Cuenta(numCuenta, saldo);
}
cliente = new Cliente(nombre, apellido, dni, cuentas);
do{
System.out.println("==================");
System.out.println(" MENU PRINCIPAL");
System.out.println("==================");
System.out.println("1.- Ingresar Dinero en la Cuenta");
System.out.println("2.- Retirar Dinero de la Cuenta");
System.out.println("3.- Consultar saldo de la Cuenta");
System.out.println("4.- Salir");
System.out.print("Digite la opcion de menu: ");
op = entrada.nextInt();
switch(op){
case 1: System.out.print("\nDigite el numero de cuenta: ");
numCuenta = entrada.nextInt();
indiceCuenta = buscarNumeroCuenta(cuentas, numCuenta);
if(indiceCuenta == -1){
System.out.print("\nEl numero de cuenta ingresado no existe");
} else{
System.out.print("\nDigite la cantidad de dinero a ingresar: ");
cantidad = entrada.nextDouble();
cliente.ingresar_dinero(indiceCuenta, cantidad);
System.out.println("\nIngreso realizado correctamente");
System.out.println("Saldo disponible: "+cliente.consultar_saldo(indiceCuenta));
}
break;
case 2: System.out.print("\nDigite el numero de cuenta: ");
numCuenta = entrada.nextInt();
indiceCuenta = buscarNumeroCuenta(cuentas, numCuenta);
if(indiceCuenta == -1){
System.out.print("\nEl numero de cuenta ingresado no existe");
}else{
System.out.print("\nDigite la cantidad de dinero a retirar: ");
cantidad = entrada.nextDouble();
 if(cantidad>cliente.consultar_saldo(indiceCuenta)){
System.out.println("Saldo Insuficiente");
}else{
cliente.retirar_dinero(indiceCuenta, cantidad);
System.out.println("\nRetiro realizado correctamente");
System.out.println("Saldo disponible: "+cliente.consultar_saldo(indiceCuenta));
}
}
break;
case 3:System.out.print("\nDigite el numero de cuenta: ");
numCuenta = entrada.nextInt();
indiceCuenta = buscarNumeroCuenta(cuentas, numCuenta);
if(indiceCuenta == -1){
System.out.print("\nEl numero de cuenta ingresado no existe");
} else{
System.out.println("Saldo disponible: "+cliente.consultar_saldo(indiceCuenta));
}
break;
case 4: break;
default: System.out.println("La opcion digitada esta fuera del rango");
}
System.out.println("");
}while(op != 4);
}
}
/*__________________________________________________________________________________________________________________________________
EJERCICIO 8: Una empresa de envió de paquetes tiene varias sucursales en todo el país. Cada sucursal está definida por su número de sucursal, dirección y ciudad.
Para calcular el precio que cuesta enviar cada paquete, las sucursales tienen en cuenta el precio del paquete y la prioridad, sabiendo que se cobra un dólar por
kilo,10 dólares más si la prioridad es alta y 20 si es express, Cada paquete enviado tendrá un numero de referencia y el DNI de la persona que lo envía.
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/

package Ejercicios_8.newpackage;

public class Paquete {

private int nPaquete;
private String dni;
private double peso;
private int prioridad;// 0 =>normal, 1 =>alta, 2 =>express

public Paquete(int nPaquete, String dni, double peso, int prioridad) {

this.nPaquete = nPaquete;
this.dni = dni;
this.peso = peso;
this.prioridad = prioridad;
}
 public int getnPaquete() {
return nPaquete;
}
public String getDni() {
return dni;
}
public double getPeso() {
return peso;
}
public int getPrioridad() {
return prioridad;
}
public String mostrarDatosPaquete(){
return "Numero paquete: "+nPaquete
+"\nDNI: "+dni
+"\nPeso: "+peso
+"\nPrioridad: "+prioridad;
}
}
package Ejercicios_8.newpackage;

public class Sucursal {

private int nSucursal;
private String direccion;
private String ciudad;

public Sucursal(int nSucursal, String direccion, String ciudad) {

this.nSucursal = nSucursal;
this.direccion = direccion;
this.ciudad = ciudad;
}
public int getNsucursal() {
return nSucursal;
}
public String getDireccion() {
return direccion;
}

public String getCiudad() {

return ciudad;
}
public String mostrarDatosSucursal(){
return "Numero Sucursal: "+nSucursal
+"\nDireccion: "+direccion
 +"\nCiudad: "+ciudad;
}
public double calcularPrecio(Paquete t){
double precio;
precio = t.getPeso();
if(t.getPrioridad()==1){
precio +=10;
}
if(t.getPrioridad()==2){
precio +=20;
}
return precio;
}
}
//--------------------
// M A I N
//--------------------
package Ejercicios_8.newpackage;
import java.util.Scanner;
public class Main {
public static int buscarPaquete(Paquete t[],int nPaquete, int cPaquete){
int indice = 0;
boolean encontrado = false;
for(int i=0; i<cPaquete;i++){
if(t[i].getnPaquete()== nPaquete){
encontrado = true;
indice = i;
}
}
if(encontrado == false){
indice = -1;
}
return indice;

}
public static int buscarSucursal(Sucursal t[], int nSucursal, int cSucursal){
int indice = 0;
boolean encontrado = false;
for(int i=0; i<cSucursal;i++){
if(t[i].getNsucursal()== nSucursal){
encontrado = true;
indice = i;
}
}
 if(encontrado == false){
indice = -1;
}
return indice;
}
public static void main(String[] args){
Scanner entrada = new Scanner (System.in);
int nSucursal, nPaquete, prioridad, op, cSucursal=0, cPaquete=0, indiceSucursal, indicePaquete;
String direccion, ciudad, dni;
double peso, precioPaquete;
Sucursal sucursal[] = new Sucursal[50];
Paquete paquete[]= new Paquete[100];
do{
System.out.println("\t.: M E N U:.");
System.out.println("1.- Crear una nueva Sucursal");
System.out.println("2.- Enviar Paquete");
System.out.println("3.- Consultar Sucursal");
System.out.println("4.- Consultar Paquete");
System.out.println("5.- Mostra todas las Sucursales");
System.out.println("6.- Mostra todas los Paquetes");
System.out.println("7.- Salir");
System.out.print("Digite la opcion de Menu: ");
op = entrada.nextInt();
switch(op){
case 1: System.out.print("\nDigite el numero de la Sucursal: ");
nSucursal = entrada.nextInt();
entrada.nextLine();
System.out.print("Digite la Direccion: ");
direccion = entrada.nextLine();
System.out.print("Digite la Ciudad: ");
ciudad = entrada.nextLine();
sucursal[cSucursal]= new Sucursal(nSucursal, direccion, ciudad);
cSucursal++;
break;
case 2: System.out.print("Digite el numero de Sucursal: ");
nSucursal = entrada.nextInt();
indiceSucursal = buscarSucursal(sucursal, nSucursal, cSucursal);
if(indiceSucursal == -1){
System.out.println("La Sucursal no Existe");
} else{
System.out.print("\nDigite el Numero de Paquete: ");
nPaquete = entrada.nextInt();
System.out.print("\nDigite el DNI de la perona que envia el Paquete: ");
dni = entrada.nextLine();
 System.out.print("\nDigite el Peso del Paquete: ");
peso = entrada.nextDouble();
System.out.print("\nDigite el Prioridad de Entrega[0=Normal, 1=Alta, 2=Express: ");
prioridad = entrada.nextInt();
paquete[cPaquete] = new Paquete(nPaquete, dni, peso, prioridad);
precioPaquete = sucursal[indiceSucursal].calcularPrecio(paquete[cPaquete]);
System.out.println("\nEl Precio del Paquete es: $"+precioPaquete);
dni = entrada.nextLine();
cPaquete++;
}
break;
case 3: System.out.print("\nDigite el numero de Sucursal: ");
nSucursal = entrada.nextInt();
indiceSucursal= buscarSucursal(sucursal, nSucursal, cSucursal);
if(indiceSucursal == -1){
System.out.println("La Sucursal no Existe");
}
else{
System.out.println("Los Datos de la Sucursal son: ");
System.out.println(sucursal[indiceSucursal].mostrarDatosSucursal());
}
break;
case 4: System.out.print("\nDigite el numero de Paquete: ");
nPaquete = entrada.nextInt();
indicePaquete = buscarPaquete(paquete, nPaquete, cPaquete );
if(indicePaquete == -1){
System.out.println("El Paquete no Exixte");
}
else{
System.out.println("\nLos Datos del paquete son: ");
System.out.println(paquete[indicePaquete].mostrarDatosPaquete());
}
break;
case 5: for(int i=0;i<cSucursal;i++){
System.out.println("\nLos Datos de la Sucursal N° "+(i+1)+":");
System.out.println(sucursal[i].mostrarDatosSucursal());
}
break;
case 6: for(int i=0;i<cPaquete;i++){
System.out.println("\nLos Datos del Paquete N° "+(i+1)+":");
System.out.println(paquete[i].mostrarDatosPaquete());
}
break;
case 7: break;
 default: System.out.println("Error Opcion fuera de rango");
break;
}
System.out.println("");
}while(op !=7);
}
}

HERENCIA EN POO

pa
ckage Herencia;
public class Estudiante extends Persona {
private int codigoEstudiante;
private float notaFinal;
//CONSTRUCTOR
public Estudiante(String nombre, String apellido, int edad, int codigoEstuduante, float notaFinal){
 super (nombre, apellido, edad);
this.codigoEstudiante = codigoEstudiante;
this.notaFinal = notaFinal;
}
public void mostrarDatos(){
System.out.println("Nombre: "+getNombre()+
"\nApellido: "+getApellido()+
"\nEdad: "+getEdad()+
"\nCodigo Estudiante: "+codigoEstudiante+
"\nNota Final: "+notaFinal);
}
}
package Herencia;
public class Persona {
private String nombre;
private String apellido;
private int edad;

public Persona(String nombre, String apellido, int edad) {

this.nombre = nombre;
this.apellido = apellido;
this.edad = edad;
}
public String getNombre() {
return nombre;
}
public String getApellido() {
return apellido;
}
public int getEdad() {
return edad;
}
}
//--------------------
// M A I N
//--------------------
package Herencia;
public class Principal {
public static void main(String[] args){
Estudiante estudiante = new Estudiante("Alejandro", "Hernandez", 21, 15236, 15.6f);
estudiante.mostrarDatos();
}

}
package Herencia;
public class Figura {
private double tamaño;
public Figura(double tamaño){
this.tamaño = tamaño;
}
}
package Herencia;

public class FiguraCerrada extends Figura {

private int nLados;
public FiguraCerrada(int nLados, double tamaño){
super(tamaño);
this.nLados = nLados;
}
public final void dibujar(){
 System.out.println("Dibujo de una Figura Cerrada");
}
package Herencia;

public class FiguraAbierta extends Figura {

public FiguraAbierta(double tamaño){
super (tamaño);
}

}
package Herencia;

public class Cuadrado extends FiguraCerrada {

private double area;
public Cuadrado(double area, int nLados, double tamaño) {
super(nLados, tamaño);
this.area = area;
}
public void dibujar1(){
System.out.println("Dibujamos un Cuadrado");
}
}
//--------------------
// M A I N
//--------------------
package Herencia;

public class Principal {

public static void main(String[] args){
Cuadrado cuadrado = new Cuadrado(15.6,4,10);
cuadrado.dibujar();
}
}
package Herencia;
public class Animal {
public void comer(){
System.out.println("Esoy Comiendo");
}
}
package Herencia;
public class Persona extends Animal {
@Override
public void comer(){
System.out.println("Esoy comiendo sentado y con cubiertos");
}
}
package Herencia;
public class Perro extends Animal {
@Override
public void comer(){
System.out.println("Esoy comiendo con mi platico en el suelo");
}
}
package Herencia;
public class Vaca extends Animal{
 @Override
public void comer(){
System.out.println("Esoy comiendo pasto en el potrero");
}
}
//--------------------
// M A I N
//--------------------
package Herencia;
public class Principal {
public static void main(String[] args){
Persona persona = new Persona();
Perro perro = new Perro();
Vaca vaca = new Vaca();
persona.comer();
perro.comer();
vaca.comer();
}
}
package Herencia;
public abstract class SerVivo{
public abstract void alimentarse();
}
package Herencia;
public class Planta extends SerVivo {
@Override
public void alimentarse(){
System.out.println("La planta se alimenta atraves de la fotosintesis");
}
}
package Herencia;
public abstract class Animal extends SerVivo{
}
package Herencia;
public class AnimalCarnivoro extends Animal {
@Override
public void alimentarse(){
System.out.println("El animal carnivoro se alimenta de carne");
}
}
package Herencia;
public class AnimalHervivoro extends Animal{
@Override
public void alimentarse(){
System.out.println("El animal hervivoro se alimenta de hiervas");
}
}

//--------------------
// M A I N
//--------------------
package Herencia;
public class Principal {
public static void main(String[] args){
Planta planta = new Planta();
planta.alimentarse();
AnimalCarnivoro animalC = new AnimalCarnivoro();
animalC.alimentarse();
AnimalHervivoro animalH = new AnimalHervivoro();
animalH.alimentarse();
}
}
package Polimorfismo;
public class Vehiculo {
protected String matricula;
protected String marca;
protected String modelo;
public Vehiculo (String matricula, String marca, String modelo){
this.matricula = matricula;
this.marca = marca;
this.modelo = modelo;
}

public String getMatricula() {

return matricula;
}

public String getMarca() {

return marca;
}

public String getModelo() {

return modelo;
}
public String mostrarDatos(){
return "Matricula: "+matricula+"\nMarca: "+marca+"\nModelo: "+modelo;
}
}
package Polimorfismo;
public class VehiculoTurismo extends Vehiculo {
private int nPuertas;
public VehiculoTurismo(int nPuertas, String matricula, String marca, String modelo){
super(matricula, marca, modelo);
this.nPuertas = nPuertas;
}
public int getnPuertas(){
return nPuertas;
}
@Override
public String mostrarDatos(){
return "Matricula: "+matricula+"\nMarca: "+marca+"\nModelo: "+modelo+"\nCilindrada: "+nPuertas;
}
}
package Polimorfismo;

public class VehiculoDeportivo extends Vehiculo{

 private int cilindrada;
public VehiculoDeportivo (int cilindrada, String matricula, String marca, String modelo ){
super(matricula, marca, modelo);
this.cilindrada = cilindrada;
}

public int getCilindrada() {

return cilindrada;
}
@Override
public String mostrarDatos(){
return "Matricula: "+matricula+"\nMarca: "+marca+"\nModelo: "+modelo+"\nCilindrada: "+cilindrada;
}

}
package Polimorfismo;

public class VehiculoFurgoneta extends Vehiculo {

private int carga;
public VehiculoFurgoneta(int carga, String matricula, String marca, String modelo){
super(matricula, marca, modelo);
this.carga = carga;
}

public int getCarga() {

return carga;
}
@Override
public String mostrarDatos(){
return "Matricula: "+matricula+"\nMarca: "+marca+"\nModelo: "+modelo+"\nCarga: "+carga;
}

//--------------------
// M A I N
//--------------------
package Polimorfismo;
public class Principal {
public static void main(String[]args){
Vehiculo misVehiculos[]= new Vehiculo[4];
misVehiculos[0] = new Vehiculo("INK666","HYNDAI","TUCSON");
misVehiculos[1] = new VehiculoTurismo(4,"FVP551","WV","TIGUAN");
misVehiculos[2] = new VehiculoDeportivo(2000,"HGI989","FERRARI","TIGRE");
 misVehiculos[3] = new VehiculoFurgoneta(3000,"YIF652","DODGE","TURBO");
for (Vehiculo vehiculos: misVehiculos){
System.out.println(vehiculos.mostrarDatos());
System.out.println("");
}
}
}

Conversión Ascendente de tipos (Upcasting)

package Polimorfismo;

public class Principal {

public static void main(String[]args){
Vehiculo vehiculo = new VehiculoTurismo(4,"INK66","HYNDAI","TUCSON");
System.out.println(vehiculo);
}
}
 Conversión Descendente de tipos (Downcasting)
package Polimorfismo;

public class Principal {

public static void main(String[]args){
Vehiculo vehiculo = new VehiculoDeportivo(4,"INK66","HYNDAI","TUCSON");
VehiculoDeportivo nuevoVehiculo = (VehiculoDeportivo)vehiculo;
System.out.println(nuevoVehiculo);
}

}
package Ejercicio_9;
public abstract class Poligono {
protected int numeroLados;
public Poligono(int numeroLados) {
this.numeroLados = numeroLados;
}
public int getNumeroLados() {
return numeroLados;
 }
@Override
public String toString() {
return "numero de Lados :" + numeroLados;
}
//Declaramos el metodo area como abstracto
public abstract double area();
}
package Ejercicio_9;
public class Rectangulo extends Poligono{
private double lado1;
private double lado2;

public Rectangulo(double lado1, double lado2) {

super(2);
this.lado1 = lado1;
this.lado2 = lado2;
}

public double getLado1() {

return lado1;
}

public double getLado2() {

return lado2;
}

@Override
public String toString() {
return "Rectangulo: \n" + super.toString()+"\nlado1: "+lado1+", lado2: "+lado2;
}
@Override
public double area(){
return lado1*lado2;
}

}
package Ejercicio_9;

public class Triangulo extends Poligono {

private double lado1;
private double lado2;
private double lado3;

public Triangulo(double lado1, double lado2, double lado3) {

super(3);
this.lado1 = lado1;
this.lado2 = lado2;
this.lado3 = lado3;
}

public double getLado1() {

return lado1;
}

public double getLado2() {

return lado2;
}

public double getLado3() {

return lado3;
}

@Override
public String toString() {
return "Triangulo: \n" +super.toString()+ "\nlado1: " +lado1+ ", lado2: " +lado2+ ", lado3: " + lado3;
}
@Override
 public double area(){
double p = (lado1+lado2+lado3)/2;
return Math.sqrt((p*(p-lado1)*(p-lado2)*(p-lado3)));
}

}
//--------------------
// M A I N
//--------------------
package Ejercicio_9;

import java.util.ArrayList;
import java.util.Scanner;

public class Principal {

static ArrayList<Poligono> poligono = new ArrayList<>();
static Scanner entrada = new Scanner(System.in);
public static void main(String[]args){
//Llenar poligono
llenarPoligono();
//Mostrar los datos y el area de cada poligono
mostrarResultados();
}
public static void llenarPoligono(){
char respuesta;
int op;
do{
do{
System.out.println("Digite que Poligono desea");
System.out.println("1.- triangulo");
System.out.println("2.- Rectangulo");
System.out.print("Opcion: ");
op = entrada.nextInt();
}while(op<1 || op>2);
switch (op){
 case 1: llenarTriangulo(); //Llenar un triangulo
break;
case 2: llenarRectangulo(); //Llenar un rectangulo
break;
}
System.out.print("\nDesea introducir otro poligono[S/N]: ");
respuesta = entrada.next().charAt(0);
System.out.println("");
}while(respuesta== 'S'|| respuesta=='s');
}
public static void llenarTriangulo(){
double lado1, lado2, lado3;
System.out.print("\nDigite el lado1 del triangulo: ");
lado1 = entrada.nextDouble();
System.out.print("Digite el lado2 del triangulo: ");
lado2 = entrada.nextDouble();
System.out.print("Digite el lado3 del triangulo: ");
lado3 = entrada.nextDouble();
Triangulo triangulo = new Triangulo(lado1, lado2, lado3);
//Guardamos un triangulo dentro de nuestro arreglo de poligonos
poligono.add(triangulo);
}
public static void llenarRectangulo(){
double lado1, lado2;
System.out.print("\nDigite el lado1 del rectangulo: ");
lado1 = entrada.nextDouble();
System.out.print("Digite el lado2 del rectangulo: ");
lado2 = entrada.nextDouble();
Rectangulo rectangulo = new Rectangulo(lado1, lado2);
poligono.add(rectangulo);

}
public static void mostrarResultados(){
//Recorriendo el areglo de poligono
 for(Poligono poli: poligono){
System.out.println(poli.toString());
System.out.println("Area: "+poli.area());
System.out.println("");
}
}