Fundamentos de Programación con Java

Fundamentos de Programación con

Java.Autor/compilador: ISC Raúl Oramas Bustillos, 2012.

[email protected], www.profesorjava.com

Este obra está bajo una licencia Creative Commons Atribución-NoComercial 2.5 México.

Tabla de Contenidos

1.Introducción a Java.............................................................................................................................................. 5

Un programa simple en Java............................................................................................................................. 6

Otro programa simple en Java........................................................................................................................... 7

2.Programas simples.............................................................................................................................................. 8

Variables............................................................................................................................................................ 9

Operaciones matemáticas simples..................................................................................................................10

Precedencia de los operadores de Java..........................................................................................................13

Leer números desde el teclado........................................................................................................................ 14

Constantes con nombre................................................................................................................................... 16

División de números enteros...........................................................................................................................18

Overflow/underflow.......................................................................................................................................... 20

¿Qué es la precisión?...................................................................................................................................... 21

Las conversiones numéricas...........................................................................................................................22

La clase Math.................................................................................................................................................. 23

3.Instrucciones de selección................................................................................................................................. 26

Comparación de dos valores........................................................................................................................... 27

La instrucción if simple.................................................................................................................................... 28

Instrucciones simples y compuestas...............................................................................................................30

La instrucción if/else........................................................................................................................................ 31

Instrucciones if anidadas................................................................................................................................. 34

La instrucción if/else/if..................................................................................................................................... 36

Revisión de dos condiciones o más.................................................................................................................38

La instrucción switch........................................................................................................................................ 40

4.Instrucciones de repetición................................................................................................................................ 43

Ciclo while....................................................................................................................................................... 44

Ciclos infinitos.................................................................................................................................................. 48

Ciclos while con cero iteraciones.....................................................................................................................49

Ciclos controlados por centinelas....................................................................................................................50

Instrucción de repetición do...while.................................................................................................................. 51

El ciclo for........................................................................................................................................................ 52

Ciclo for compuesto......................................................................................................................................... 53

Ciclos anidados............................................................................................................................................... 54

Instrucción break............................................................................................................................................. 57

Instrucción continue......................................................................................................................................... 59

El ciclo while.................................................................................................................................................... 60

Ciclos controlador por contador....................................................................................................................... 60

El ciclo while controlado por un centinela........................................................................................................62

Ciclo do/while................................................................................................................................................... 63

5.Métodos............................................................................................................................................................. 64

Declaración de un método............................................................................................................................... 65

Declaración de un método con un parámetro..................................................................................................68

Métodos void vs. return................................................................................................................................... 69

Declaración de métodos con múltiples parámetros.........................................................................................71

Orden en el paso de parámetros.....................................................................................................................72

Reutilización de código.................................................................................................................................... 73

Métodos sobrecargados (overload).................................................................................................................76

6.Arreglos de una dimensión................................................................................................................................ 77

Declaración de un arreglo................................................................................................................................ 78

Crear un arreglo............................................................................................................................................... 79

Asignar valores a un arreglo............................................................................................................................ 80

El tamaño del arreglo y valores por default.....................................................................................................81

Acceder a los elementos de un arreglo...........................................................................................................82

Inicialización de un arreglo al declararlo..........................................................................................................83

Inicializar un arreglo con valores desde el teclado..........................................................................................84

Inicializar un arreglo con valores aleatorios.....................................................................................................85

Imprimir el contenido de un arreglo.................................................................................................................86

Sumar todos los elementos del arreglo...........................................................................................................87

Encontrar el elemento mayor del arreglo.........................................................................................................88

Intercambio aleatorio de los elementos del arreglo.........................................................................................89

Desplazar elementos del arreglo.....................................................................................................................90

Instrucción for mejorada.................................................................................................................................. 91

Paso de arreglos a los métodos...................................................................................................................... 92

Regresar un arreglo desde un método............................................................................................................94

Listas de argumentos de longitud variable......................................................................................................95

Uso de argumentos de línea de comandos.....................................................................................................96

7.Arreglos bidimensionales................................................................................................................................... 97

Introducción..................................................................................................................................................... 98

Declaración de un arreglo................................................................................................................................ 99

Crear un arreglo............................................................................................................................................. 100

Asignar valores a un arreglo..........................................................................................................................101

El tamaño del arreglo y valores por default...................................................................................................102

Acceder a los elementos de un arreglo.........................................................................................................103

Inicialización de un arreglo al declararlo........................................................................................................104

Inicializar un arreglo bidimensional con valores desde el teclado..................................................................105

Inicializar un arreglo bidimensional con valores aleatorios............................................................................106

Imprimir el contenido de un arreglo bidimensional.........................................................................................107

Sumar todos los elementos de un arreglo bidimensional..............................................................................108

Suma los elementos de un arreglo bidimensional por columna....................................................................109

Suma por renglón y encuentra el mayor........................................................................................................110

Intercambio aleatorio de un arreglo bidimensional.........................................................................................111

1. Introducción a Java.

Contenido:

Un programa simple en Java.................................................................................................................................. 6

Otro programa simple en Java................................................................................................................................ 7

Fundamentos de Programación con Java → Introducción a Java. 6

Un programa simple en Java.

HolaMundo.java

public class HolaMundo{ public static void main( String[] args ) { System.out.println( "Hola Mundo." ); } }

© Raúl Oramas Bustillos 2012.

Fundamentos de Programación con Java → Introducción a Java. 7

Otro programa simple en Java.

Bienvenido.java

//Programa para imprimir texto.public class Bienvenido{ //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { System.out.print( "¡Bienvenido " ); System.out.println( "al Curso Java!" ); } //fin del método main} //fin de la clase Bienvenido


2. Programas simples.

Contenido:

Variables............................................................................................................................................................... 10

Operaciones matemáticas simples....................................................................................................................... 11

Precedencia de los operadores de Java...............................................................................................................14

Leer números desde el teclado............................................................................................................................. 15

Constantes con nombre........................................................................................................................................ 17

División de números enteros................................................................................................................................ 19

Overflow/underflow............................................................................................................................................... 21

¿Qué es la precisión?........................................................................................................................................... 22

Las conversiones numéricas................................................................................................................................ 23

La clase Math....................................................................................................................................................... 24

Fundamentos de Programación con Java → Programas simples. 9

Variables.

DobleNumero.java

//Programa para calcular el doble de un número.public class DobleNumero { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { int numero; //declaración de una variable int doble; //mensaje de usuario System.out.println( "Calcular el doble de un número." ); System.out.println( "" ); numero = 5; //asignación del valor a la variable doble = numero * 2; //expresión aritmética System.out.println( "El doble de " + numero + " es " + doble ); } //fin del método main} //fin de la clase DobleNumero



Operaciones matemáticas simples.

AreaRectangulo.java

//Programa que calcula e imprime el área de un rectángulo.public class AreaRectangulo { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { //declaración e inicialización de las variables int largo = 10; //el largo del rectángulo int ancho = 4; //el ancho del rectángulo int area; //el área del rectángulo

//mensaje de usuario System.out.println( "Calcular el área de un rectángulo." ); System.out.println( "" ); //calcula el área area = largo * ancho; //expresión //imprime el área del rectángulo System.out.println( "El área del rectángulo es: " + area ); } //fin del método main} //fin de la clase AreaRectangulo



PieMetro.java

//Programa que calcula el equivalente de pies a metros.public class PieMetro{ //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { //declara una variable de tipo double y la inicializa double nPies = 16; //mensaje de usuario System.out.println( "Convierte pies a metros." ); System.out.println( "" );

//proceso double metros = nPies * 0.305; //salida System.out.println( nPies + " son " + metros + " metros." ); } //fin del método main } //fin de la clase PieMetro



AreaTriangulo.java

//Programa que calcula el área de un triángulo. public class AreaTriangulo { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { //declaración de las variables int base, altura; double area; //inicialización de la base y la altura

base = 10; altura = 19; //calcula el área del triángulo area = ( base * altura ) / 2.0; //imprime el resultado System.out.println( "El area del triángulo es ", area ); } //fin del método main } //fin de la clase AreaTriangulo



Precedencia de los operadores de Java.

Promedio.java

//Programa que calcula el promedio de tres calificaciones.public class Promedio { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { //declaración y asignación de los valores double calif1 = 10.0, calif2 = 10.0, calif3 = 10.0;

double promedio; //mensaje de usuario System.out.println( "Promedio de tres calificaciones." ); System.out.println( "" ); promedio = calif1 + calif2 + calif3 / 3; System.out.println( "El promedio incorrecto es: " + promedio );

promedio = ( calif1 + calif2 + calif3 ) / 3; System.out.println( "El promedio correcto es: " + promedio ); } //fin del método main} //fin de la clase Promedio



Leer números desde el teclado.

DobleNumero.java

//Programa para calcular el doble de un número.import java.util.Scanner; //para leer del tecladopublic class DobleNumero { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { //Crea un objeto Scanner para leer desde el teclado Scanner entrada = new Scanner( System.in ); int numero; int doble; //mensaje de usuario System.out.println( "Calcular el doble de un número." ); System.out.println( "" );

//lectura del número entero System.out.print( "Introduce un número: " ); numero = entrada.nextInt(); //asignación del valor a la variable //calcula el doble del número doble = numero * 2; //imprime el resultado System.out.println( "El doble de " + numero + " es " + doble ); } //fin del método main} //fin de la clase DobleNumero



AreaCirculo.java

//Calcula el área de un círculo.import java.util.Scanner; //para leer del tecladopublic class Circulo{ //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { //Crea objeto para leer datos Scanner entrada = new Scanner( System.in );

//declaración de variables double radio, area;

//mensaje de usuario System.out.println( "Calcular el área de un círculo." ); System.out.println( "" ); //obtiene el radio del círculo System.out.print( "Radio? " ); radio = entrada.nextDouble(); //calcula el área area = radio * radio * 3.14159; //imprime el resultado System.out.println( "El área del círculo es: " + area ); } //fin del método main} //fin de la clase AreaCirculo



Constantes con nombre.

AreaCirculo.java

//Calcula el área de un círculo.import java.util.Scanner; //para leer del tecladopublic class Circulo{ //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { //declara una constante con nombre final double PI = 3.14159;

//Crea objeto para leer datos Scanner entrada = new Scanner( System.in );

//declaración de variables double radio, area;

//mensaje de usuario System.out.println( "Calcular el área de un círculo." ); System.out.println( "" ); //obtiene el radio del círculo System.out.print( "Radio? " ); radio = entrada.nextDouble(); //calcula el área area = radio * radio * PI; //imprime el resultado System.out.println( "El área del círculo es: " + area ); } //fin del método main} //fin de la clase AreaCirculo



Conversion.java

//Programa que convierte pies y pulgadas a centímetros.import java.util.Scanner; //para leer del tecladopublic class Conversion { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { final double CENTIMETRO_PULGADA = 2.54; final int PULGADA_PIE = 12; Scanner entrada = new Scanner( System.in ); //mensaje de usuario System.out.println( "Convertir pies y pulgadas a cms." ); System.out.println( "" ); //lectura de los datos System.out.print( "Pies? " ); int pie = entrada.nextInt(); System.out.println( "Pulgadas? " ); int pulgada = entrada.nextInt(); //procesa los datos de entrada int totalPulgadas = PULGADA_PIE * pie + pulgada; double cms = CENTIMETRO_PULGADA * totalPulgadas; //imprime el resultado System.out.println( "Total de pulgadas: " + totalPulgadas ); System.out.println( totalPulgadas + " = " + cms + " centímetros." ); } //fin del método main} //fin de la clase Conversion



División de números enteros.

Division.java

//Programa para calcular la división y módulo de dos números enteros. import java.util.Scanner; //para leer del teclado public class Division { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); //entrada System.out.print( "Introduce un número? " ); int num1 = entrada.nextInt(); System.out.print( "Introduce otro número? " ); int num2 = entrada.nextInt();

//proceso int div1 = num1 / num2; int mod1 = num1 % num2; int div2 = num2 / num1; int mod2 = num2 % num1; //salida System.out.printf( div1 ); System.out.printf( mod1 ); System.out.printf( div2 ); System.out.printf( mod2 ); } //fin del método main } //fin de la clase Division

Notas:



MinutoSegundo.java

//Programa que obtiene los minutos y segundos de una cantidad de//segundos leída desde el teclado.import java.util.Scanner; //para leer del tecladopublic class MinutoSegundo { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); //lectura de los datos System.out.print( "Cantidad de segundos: " ); int segundos = entrada.nextInt(); //procesa los datos int minutos = segundos / 60; //encuentra los minutos int restoSeg = segundos % 60; //obtiene los seg restantes //imprime el resultado System.out.println( segundos + " segundos equivalen a " + minutos + " minutos y " + restoSeg + " segundos." ); } //fin del método main} //fin de la clase MinutoSegundo



Overflow/underflow.

Desbordamiento.java

//Programa con valores overflow/underflow.public class Desbordamiento { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { //declaración e inicialización de dos variables int valor1 = 2147483647 + 1; int valor2 = 2147483648 1;; //imprime los resultados System.out.println( valor1 ); //overflow System.out.println( valor1 ); //underflow } //fin del método main} //fin de la clase Desbordamiento



¿Qué es la precisión?.

PuntoFlotante.java

//Programa que ilustra el concepto de precisión.public class PuntoFlotante{ //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { System.out.println( 1.0 – 0.1 – 0.1 – 0.1 – 0.1 – 0.1 ); //no imprime 0.5 System.out.println( 1.0 – 0.9 ); //no imprime 0.1 System.out.println( 10.03 – 100 ); //perdida de precisión System.out.println( 2.0 – 1.1 ); //no imprime 0.9 System.out.println( 100 – 4.35 ); //no imprime 435.0 } //fin del método main} //fin de la clase PuntoFlotante



Las conversiones numéricas.

ConversionNumerica.java

//Programa que demuestra la conversión de tipos.public class ConversionNumerica { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { System.out.println( 3 * 4.5 ); //es lo mismo que 3.0 * 4.5 System.out.println( ( int )40.7 ); System.out.println( ( double ) 1 / 2 ); } //fin del método main} //fin de la clase ConversionNumerica



La clase Math.

VolumenCilindro.java

//Programa que calcula el volumen de un cilindro.import java.util.Scanner; //para leer del tecladopublic class VolumenCilindro { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); //mensaje de usuario System.out.println( "Calcula el volumen de un cilindro." ); System.out.println( "" ); //lectura de los datos System.out.print( "Radio? " ); double radio = entrada.nextDouble(); System.out.print( "Altura? " ); double altura = entrada.nextDouble(); //proceso de los datos double area = Math.pow( radio, 2 ) * Math.PI; double volumen = area * altura; //impresión de los resultados System.out.println( "Área cilindro: " + area ); System.out.println( "Volumen cilindro: " + volumen ); } //fin del método main} //fin de la clase VolumenCilindro



Hipotenusa.java

//Programa para calcular la hipotenusa de un triángulo rectángulo.import java.util.Scanner;public class Hipotenusa { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); //mensaje de usuario System.out.println( "Hipotenusa de un triángulo rectángulo." ); System.out.println( "" ); //lectura de los datos System.out.print( "Ingresa los valores para el cateto a y b: " ); int catetoA = entrada.nextInt(); int catetoB = entrada.nextInt(); //procesa los datos int hipotenusa = ( int ) Math.sqrt( catetoA * catetoA + catetoB * catetoB ); //imprime el resultado System.out.println( "La hipotenusa es: " + hipotenusa ); } //fin del método main} //fin de la clase Hipotenusa



Distancia.java

//Programa para calcular la distancia entre dos puntos.import java.util.Scanner; //para leer del tecladopublic class Distancia { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); //mensaje de usuario System.out.println( "Calcula la distancia entre dos puntos" ); System.out.println( "(x1,y1) y (x2,y2)." ); System.out.println( "" ); //lectura de los datos System.out.print( "Introduce la coordenada (x1,y1): "); int x1 = entrada.nextInt(); int y1 = entrada.nextInt(); System.out.print( "Introduce la coordenada (x2,y2): "); int x2 = entrada.nextInt(); int y2 = entrada.nextInt(); //procesa los datos double distancia = Math.sqrt( Math.pow( x2x1 , 2 ) + Math.pow( y2 y1 , 2 ) ); //imprime el resultado System.out.println( "La distancia entre los dos puntos es: " + distancia ); } //fin del método main} //fin de la clase Distancia


3. Instrucciones de selección.

Contenido:

Comparación de dos valores................................................................................................................................ 28

La instrucción if simple.......................................................................................................................................... 29

Instrucciones simples y compuestas.................................................................................................................... 31

La instrucción if/else............................................................................................................................................. 32

Instrucciones if anidadas...................................................................................................................................... 35

La instrucción if/else/if.......................................................................................................................................... 37

Revisión de dos condiciones o más...................................................................................................................... 39

La instrucción switch............................................................................................................................................. 41

Fundamentos de Programación con Java → Instrucciones de selección. 27

Comparación de dos valores.

ExpresionRelacional.java

//Operadores de igualdad y relacionales public class ExpresionRelacional { public static void main( String[] args ) { System.out.println( "10 > 3 es " + ( 10 > 3 ) ); System.out.println( "10 < 3 es " + (10 < 3 ) ); System.out.println( "10 >= 3 es " + ( 10 >= 3 ) ); System.out.println( "10 <= 3 es " + ( 10 <= 3 ) ); System.out.println( "10 == 3 es " + ( 10 == 3 ) ); System.out.println( "10 != 3 es " + ( 10 != 3 ) ); } //fin del método main } //fin de la clase ExpresionRelacional



La instrucción if simple.

Comparacion.java

//If simple.public class Comparacion{ public static void main(String args[]) { int x = 10000; if( x > 5000 ) //¿ x es mayor que 5000? x = 1000; //cambia el valor x si la condición es true System.out.println( x ); } //fin del método main} //fin de la clase Comparacion



Multiplos.java

//If simple.import java.util.Scanner; //para leer del tecladopublic class Multiplos { public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); //lee un número System.out.print( "Ingresa un número entero: " ); int numero = entrada.nextInt(); if( numero % 5 == 0 ) System.out.println( "El número es múltiplo de 5." ); if( numero % 2 == 0 ) System.out.println( "El número es par." ); } //fin del método main} //fin de la clase Multiplos



Instrucciones simples y compuestas.

ValorAbsoluto.java

//Programa que determina el valor absoluto de un número.import java.util.Scanner; //para leer del tecladopublic class ValorAbsoluto { public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); //operación de lectura System.out.print( "Introduce un número: " ); int numero = entrada.nextInt(); if( numero < 0 ) //¿Es número menor que cero? { numero = numero; //le cambiamos el signo } //fin if

//imprime el valor absoluto System.out.println( "El valor absoluto es " + numero ); } //fin del método main} //fin de la clase ValorAbsoluto



La instrucción if/else.

ParImpar.java

//Instrucción if/else.import java.util.Scanner; //para leer del tecladopublic class ParImpar { public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); //operación de lectura System.out.print( "Introduce un número: " ); int num = entrada.nextInt(); if( numero % 2 == 0 ) System.out.println( num + " es par." ); else

System.out.println( num + " es impar." ); } //fin del método main} //fin de la clase ParImpar



Suma.java

//Programa para practicar sumasimport java.util.Scanner; //para leer del tecladopublic class Suma { public static void main( String[] args ) { Scanner entrada = new Scanner( System.in );

//genera dos números aleatorios con el método random int numero1 = ( int )( Math.random() * 10 ); int numero2 = ( int )( Math.random() * 10 ); //muestra la pregunta al usuario System.out.print( "¿Cuánto es " + numero1 + " + " + numero2 + " ? " ); int respuesta = entrada.nextInt(); //compara la respuesta if( numero1 + numero2 == respuesta ) { System.out.println( "La respuesta es correcta." ); } //fin if else { System.out.println( "La respuesta es incorrecta." ); } //fin else } //fin del método main} //fin de la clase Suma



Resta.java

//Programa para practicar restas.import java.util.Scanner; //para leer del tecladopublic class Resta { public static void main( String[] args ) { //genera los números aleatorios int numero1 = ( int )( Math.random() * 10 ); int numero2 = ( int )( Math.random() * 10 ); //si numero1 < numero2 intercambia los valores if( numero1 < numero2 ) { int temp = numero1; //variable local a if numero1 = numero2; numero2 = temp; } //fin if //pregunta al usuario System.out.print( "Cuanto es " + numero1 + " " + numero2 + "? " );

//lee la respuesta Scanner entrada = new Scanner( System.in ); int respuesta = entrada.nextInt(); //compara la respuesta if( numero1 numero2 == respuesta ) System.out.println( "La respuesta es correcta." ); else System.out.println( "La respuesta es incorrecta." ); } //fin del método main} //fin de la clase Resta



Instrucciones if anidadas.

Adivinanza.java

//Programa para jugar adivinanzas.import java.util.Scanner; //para leer del tecladopublic class Adivinanza { public static void main( String[] args ) { //genera el número secreto int numeroSecreto = ( int )( Math.random() * 10 ); Scanner entrada = new Scanner( System.in ); //pide un número al usuario System.out.print( "Piensa un número entre 0 y 9: " ); int numero = entrada.nextInt(); //evalúa if( numero == numeroSecreto ) System.out.println( "¡Adivinaste!" ); else { if( numero < numeroSecreto ) System.out.println( "¡Frío!" ); else System.out.println( "¡Caliente!" ); } //fin else } //fin del método main} //fin de la clase Adivinanza



Calificacion.java

//Utiliza if/else anidados para evaluar una calificación.import java.util.Scanner; //para leer del tecladopublic class Calificacion{ public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); System.out.print( "Calificación (110)? " ); //indicador //lee calificación del teclado int calif = entrada.nextInt(); if( calif >= 9 ) System.out.println( "La calificación es excelente." ); else if( calif >= 8 ) System.out.println( "La calificación es buena." ); else if( calif >= 7 ) System.out.println( "La calificación es regular." ); else System.out.println( "!Reprobado¡." ); System.out.println( "El estudio es la base del triunfo." ); } //fin del método main} //fin de la clase Calificacion



La instrucción if/else/if.

Adivinanza.java

//Programa para jugar adivinanzas.import java.util.Scanner; //para leer del tecladopublic class Adivinanza { public static void main( String[] args ) { //genera el número aleatorio int numeroSecreto = ( int )( Math.random() * 10 );

Scanner entrada = new Scanner( System.in );

//solicita un número al usuario System.out.print( "Piensa un número entre 0 y 9: " ); int numero = entrada.nextInt(); //evalúa if( numero == numeroSecreto ) System.out.println( "¡Adivinaste!" ); else if( numero < numeroSecreto ) System.out.println( "¡Frío!" ); else System.out.println( "¡Caliente!" ); } //fin del método main} //fin de la clase Adivinanza



Calificacion.java

//Utiliza if/else/if para evaluar una calificación.import java.util.Scanner; //para leer del tecladopublic class Calificacion{ public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); System.out.print( "Calificación (110)? " ); //indicador //lee calificación del teclado int calif = entrada.nextInt(); if( calif >= 9 ) System.out.println( "La calificación es excelente." ); else if( calif >= 8 ) System.out.println( "La calificación es buena." ); else if( calif >= 7 ) System.out.println( "La calificación es regular." ); else System.out.println( "!Reprobado¡." ); System.out.println( "El estudio es la base del triunfo." ); } //fin del método main} //fin de la clase Calificacion



Revisión de dos condiciones o más.

OperadoresLogicos.java

//Operadores lógicos && y ||public class OperadoresLogicos{ public static void main( String[] args ) { if( true && true ) System.out.println( "true true = verdadero." ); if( ( true && false ) || ( false && true ) || ( false && false ) ) System.out.println( "Nunca entra." ); if( ( true || false ) && ( false || true ) && ( true || true ) ) System.out.println( "Verdadero." ); if( false || false ) System.out.println( "Nunca entra." ); } //fin del metodo main } //fin de la clase OperadoresLogicos



Loteria.java

//Programa para jugar a la lotería.import java.util.Scanner; //para leer del tecladopublic class Loteria { public static void main( String[] args ) { //genera el número de la lotería int loto = ( int )( Math.random() * 100 ); Scanner entrada = new Scanner( System.in ); System.out.print( "Ingresa un número de dos dígitos: " ); int numGanador = entrada.nextInt(); //obtiene los dígitos de la lotería int digitoLoto1 = loto / 10; int digitoLoto2 = loto % 10; //obtiene los dígitos del usuario int digito1 = numGanador / 10; int digito2 = numGanador % 10; System.out.println( "El número de la lotería es: " + loto ); //Revisa por los premios if( loto == numGanador ) System.out.println( "Ganaste $10,000.00" ); else if( digito2 == digitoLoto1 && digito1 == digitoLoto2 ) System.out.println( "Ganaste $3,000.00" ); else if( digito1 == digitoLoto1 || digito1 == digitoLoto2 || digito2 == digitoLoto1 || digito2 == digitoLoto2 ) System.out.println( "Ganaste $1,000.00" ); else System.out.println( "Sigue participando." ); } //fin del método main} //fin de la clase Loteria



La instrucción switch.

SwitchDemo.java

//Instrucción switch.import java.util.Scanner; //para leer del tecladopublic class SwitchDemo { public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); System.out.println( "Introduce un número del 1 al 7: " ); int diaSemana = entrada.nextInt(); switch( diaSemana ) { case 1: System.out.println( "Lunes." );break; case 2: System.out.println( "Martes." );break; case 3: System.out.println( "Miércoles." );break; case 4: System.out.println( "Jueves." );break; case 5: System.out.println( "Viernes." );break; case 6: System.out.println( "Sábado." );break; case 7: System.out.println( "Domingo." );break; default: System.out.println( "Error." );break; } //fin switch } //fin del método main} //fin de la clase SwitchDemo



PiedraPapelTijera.java

//Programa para jugar al piedrapapeltijera.import java.util.Scanner;public class PiedraPapelTijera { public static void main( String[] args ) { final int PIEDRA = 1, PAPEL = 2, TIJERA = 3; int jugador, computadora; Scanner entrada = new Scanner( System.in );

//solicita la jugada del usuario System.out.print( "Tu jugada? 1 = Piedra, 2 = Papel, 3 = Tijera" ); jugador = entrada.nextInt(); //genera la jugada de la computadora computadora = ( int )( Math.random() * 3 + 1 ); //muestra la jugada del usuario System.out.print( "La jugada del usuario: " ); switch( jugador ) { case PIEDRA: System.out.println( "PIEDRA." );break; case PAPEL: System.out.println( "PAPEL." );break; case TIJERA: System.out.println( "TIJERA." );break; } //fin switch //muestra la jugada de la computadora System.out.print( "La jugada de la computadora: " ); switch( computadora ) { case PIEDRA: System.out.println( "PIEDRA." );break; case PAPEL: System.out.println( "PAPEL." );break; case TIJERA: System.out.println( "TIJERA." );break; } //fin switch //determina el ganador if( jugador == PIEDRA && computadora == PIEDRA ) System.out.println( "Empate." ); else if( jugador == PIEDRA && computadora == PAPEL ) System.out.println( "La computadora gana." ); else if( jugador == PIEDRA && computadora == TIJERA ) System.out.println( "¡El jugador gana!" ); if( jugador == PAPEL && computadora == PIEDRA ) System.out.println( "¡El jugador gana!" ); else if( jugador == PAPEL && computadora == PAPEL ) System.out.println( "Empate." ); else if( jugador == PAPEL && computadora == TIJERA )



System.out.println( "La computadora gana." ); if( jugador == TIJERA && computadora == PIEDRA ) System.out.println( "La computadora gana." ); else if( jugador == TIJERA && computadora == PAPEL ) System.out.println( "¡El jugador gana!" ); else if( jugador == TIJERA && computadora == TIJERA ) System.out.println( "Empate." ); } //fin del método main} //fin de la clase PiedraPapelTijera


4. Instrucciones de repetición.

Contenido:

Ciclo while............................................................................................................................................................. 44

Ciclos controlados por centinelas......................................................................................................................... 48

Instrucción de repetición do...while.......................................................................................................................49

El ciclo for............................................................................................................................................................. 50

Instrucción break.................................................................................................................................................. 51

Instrucción continue.............................................................................................................................................. 53

Fundamentos de Programación con Java → Instrucciones de repetición. 44

Ciclo while.

ContadorWhile.java

//Instrucción while.public class ContadorWhile{ public static void main( String[] args ) { int contador = 1; //declara e inicializa //la variable de control while( contador <= 10 ) //condición de continuación de ciclo { System.out.println( contador ); contador++; //incrementa la variable de control en 1 } //fin de while } //fin del método main} //fin de la clase ContadorWhile



WhileDemo.java

//Instrucción while.import java.util.Scanner;public class WhileDemo{ public static void main( String[] args ) { int contador = 1; //variable de control int numero; Scanner entrada = new Scanner( System.in ); System.out.print( "Ingresa un número entero: " ); numero = entrada.nextInt(); while( contador <= numero ) //condición de //continuación de ciclo { System.out.println( contador ); contador++; //incrementa la variable de control en 1 } //fin de while System.out.println(); System.out.println( "Fin del programa." ); } //fin del método main} //fin de la clase WhileDemo



RaizCuadrada.java

//Raíz cuadrada de un cuadrado perfecto.import java.util.Scanner;public class RaizCuadrada{ public static void main( String[] args ) { int raiz = 0; Scanner entrada = new Scanner( System.in ); //lectura System.out.print( "Dame un número entero? " ); int numero = entrada.nextInt(); //proceso y salida if( numero >= 0 ) { //proceso while( raiz * raiz < numero ) raiz = raiz + 1; if( raiz * raiz != numero ) System.out.println( numero + " no es cuadrado perfecto" ); else System.out.println( "La raíz cuadrada de " + numero + " es " + raiz ); } else System.out.println( numero + " es un número negativo" ); } //fin del método main} //fin de la clase RaizCuadrada



Adivinanza.java

//Programa para jugar adivinanzas.import java.util.Scanner; //para leer del tecladopublic class Adivinanza { public static void main( String[] args ) { //genera el número aleatorio entre 0 y 100 int numeroSecreto = ( int )( Math.random() * 101 );

Scanner entrada = new Scanner( System.in );

//mensaje de usuario System.out.println( "Piensa un número entre 0 y 100." ); System.out.println( "" ); int numero = 1; while( numero != numeroSecreto ) { //solicita un número al usuario System.out.print( "Número? " ); numero = entrada.nextInt(); //evalúa if( numero == numeroSecreto ) System.out.println( "¡Adivinaste!" ); else if( numero < numeroSecreto ) System.out.println( "¡Frío!" ); else System.out.println( "¡Caliente!" ); } //fin while } //fin del método main} //fin de la clase Adivinanza



Ciclos controlados por centinelas.

Promedio.java

//Lee una serie de números enteros y calcula su promedio. import java.util.Scanner; //para leer del tecladopublic class Promedio { public static void main(String[] args) { Scanner entrada = new Scanner( System.in );

//mensaje de usuario System.out.println( "Ingresa una lista de números enteros positivos." ); System.out.println( "Marca el final de la lista con un cero." ); System.out.println( "");

int contador = 0; int suma = 0; System.out.print( "Ingresa un número (0 para terminar): " ); int numero = entrada.nextInt();

while( numero != 0 ) { suma = suma + numero; contador = contador + 1;

System.out.print( "Ingresa un número (0 para terminar): " ); numero = entrada.nextInt(); } //fin while

if( contador == 0 ) System.out.println( "No ingresaste ningún número." ); else { double promedio = ( double )suma / contador; System.out.println( "Números leídos: " + contador ); System.out.println( "El promedio es: " + promedio ); } //fin else } //fin del método main } //fin de la clase Promedio



Instrucción de repetición do...while.

PruebaDoWhile.java

//La instrucción de repetición do...while. public class PruebaDoWhile{ public static void main( String[] args ) { int contador = 1; //inicializa contador do { System.out.println( contador ); contador++; } while( contador <= 10 ); //fin de do...while } //fin del método main} //fin de la clase PruebaDoWhile



El ciclo for.

ContadorFor.java

//Repetición controlada con contador.public class ContadorFor{ public static void main( String[] args ) { //el encabezado de la instrucción for //incluye la iniacialización //la condición de continuación del ciclo y el incremento for( int contador = 1; contador <= 10; contador++ ) System.out.println( contador ); } //fin del método main} //fin de la clase ContadorFor



Instrucción break.

ForBreak.java

//La instrucción break para salir de un ciclo for.public class ForBreak{ //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { int cuenta; //la variable de control también se usa //cuando termina el ciclo for( cuenta = 1; cuenta <= 10; cuenta++ ) //itera 10 veces { if( cuenta == 5 ) //si cuenta es 5 break; //termina el ciclo System.out.println( cuenta ); } //fin de for System.out.println( "Salio del ciclo en cuenta = " + cuenta ); } //fin del método main } //fin de la clase ForBreak



WhileBreak.java

//La instrucción break para salir de un ciclo while.public class WhileBreak{ public static void main( String[] args ) { int suma = 0; int numero = 0; while( numero < 20 ) { numero++; suma += numero; if( suma >= 100 ) break; } //fin while System.out.printf( "Valor final de número = " + numero ); System.out.printf( "La suma = " + suma ); } //fin del método main } //fin de la clase WhileBreak



Instrucción continue.

PruebaContinue.java

//Instrucción continue.public class PruebaContinue{ public static void main( String[] args ) { for( int cuenta = 1; cuenta <= 10; cuenta++ ) { if( cuenta == 5 ) //si cuenta es 5, continue; //omite el resto del código en el ciclo System.out.println( cuenta ); } //fin de for System.out.println( "Se uso continue para omitir imprimir 5" ); } //fin del método main } //fin de la clase PruebaContinue


5. Métodos.

Contenido:

Declaración de un método.................................................................................................................................... 55

Declaración de un método con un parámetro.......................................................................................................58

Métodos void vs. return......................................................................................................................................... 59

Declaración de métodos con múltiples parámetros..............................................................................................61

Orden en el paso de parámetros.......................................................................................................................... 62

Reutilización de código......................................................................................................................................... 63

Métodos sobrecargados (overload)...................................................................................................................... 66

Fundamentos de Programación con Java → Métodos. 55

Declaración de un método.

Curso.java

//Declaración de un método.public class Curso{ //muestra un mensaje de bienvenida public static void mostrarMensaje() { System.out.println( "Bienvenido al curso de Java." ); } //fin del método mostrarMensaje public static void main( String[] args ) { mostrarMensaje(); //llamada al método } //fin del método main} //fin de la clase Curso



Temperatura.java

//Utiliza dos métodos para convertir de celsius //a fahrenheit y viceversa.import java.util.Scanner; //para leer del tecladopublic class Temperatura{ //convierte de fahrenheit a celsius public static void fahrenheitCelsius() { //variables locales double fahrenheit; double celsius; Scanner entrada = new Scanner( System.in ); //lee la temperatura System.out.print( "Ingresa una temperatura en fahrenheit: " ); fahrenheit = entrada.nextDouble(); //realiza la conversión celsius = 5.0 / 9.0 * fahrenheit 32; //imprime el resultado System.out.println( "La temperatura en celsius es " + celsius ); } //fin del método fahrenheitCelsius //convierte de celsius a fahrenheit public static void celsiusFahrenheit() { //variables locales double fahrenheit; double celsius; Scanner entrada = new Scanner( System.in ); //lee la temperatura System.out.print( "Ingresa una temperatura en celsius: " ); celsius = entrada.nextDouble(); //realiza la conversión fahrenheit = 9.0 / 5.0 * celsius + 32; //imprime el resultado System.out.println( "La temperatura en fahrenheit es " + fahrenheit ); } //fin del método celsiusFahrenheit



public static void main( String[] args ) { int opcion; //variable local Scanner entrada = new Scanner( System.in ); //mensaje de usuario System.out.println( "1. Convertir de Fahrenheit a Celsius." ); System.out.println( "2. Convertir de Celsius a Fahrenheit." );

//lee la opción del usuario System.out.print( "Opción: " ); opcion = entrada.nextInt(); if( opcion == 1 ) fahrenheitCelsius(); else celsiusFahrenheit(); } //fin del método main} //fin de la clase Temperatura



Declaración de un método con un parámetro.

Curso.java

//Declaración de un método con un parámetro.public class Curso{ //muestra un mensaje de bienvenida public static void mostrarMensaje( String nombreCurso ) { System.out.println( "Bienvenido al curso de " + nombreCurso + "." ); } //fin del método mostrarMensaje public static void main( String[] args ) { mostrarMensaje( "Java" ); //llamada al método mostrarMensaje( "C Sharp" ); //llamada al método } //fin del método main} //fin de la clase Curso



Métodos void vs. return.

TestMetodoVoid.java

//Define un método void.public class TestMetodoVoid{ public static void calificar( double calificacion ) { if( calificacion >= 90.0 ) System.out.println( 'A' ); else if( calificacion >= 80.0 ) System.out.println( 'B' ); else if( calificacion >= 70.0 ) System.out.println( 'C' ); else if( calificacion >= 60.0 ) System.out.println( 'D' ); else System.out.println( 'E' ); } //fin del método calificar public static void main( String[] args ) { System.out.print( "Obtuviste una " ); calificar( 78.5 ); System.out.print( "Obtuviste una " ); calificar( 59.5 ); } //fin del método main} //fin de la clase TestMetodoVoid



TestMetodoReturn.java

//Define un método returnpublic class TestMetodoReturn{ public static char calificar( double calificacion ) { if( calificacion >= 90.0 ) return 'A'; else if( calificacion >= 80.0 ) return 'B'; else if( calificacion >= 70.0 ) return 'C'; else if( calificacion >= 60.0 ) return 'D'; else return 'E'; } //fin del método calificar public static void main( String[] args ) { System.out.print( "Obtuviste una " + calificar( 78.5 ) ); System.out.print( "Obtuviste una " + calificar( 59.5 )); } //fin del método main} //fin de la clase TestMetodoReturn



Declaración de métodos con múltiples parámetros.

Mayor.java

//Método con múltiples parámetros.public class Mayor{ //devuelve el máximo de sus tres parámetros double public static double maximo( double x, double y, double z ) { double valorMaximo = x; //asume que x es el mayor para empezar //determina si y es el mayor que valorMaximo if( y > valorMaximo ) valorMaximo = y; //determina si z es mayor que valorMaximo if( z > valorMaximo ) valorMaximo = z; return valorMaximo; } //fin del método máximo public static void main( String[] args ) { double z = maximo( 9.35, 2.75, 5.1 ); System.out.println( "El mayor es " + z ); } //fin del método main} //fin de la clase Mayor



Orden en el paso de parámetros.

PasoParametros.java

//Paso de parámetros.public class PasoParametros{ public static void nPrint( String mensaje, int n ) { for( int i = 0; i < n; i++ ) System.out.println( mensaje ); } //fin del método nPrint public static void main( String[] args ) { nPrint( "Hola", 3 ); //El orden de los parámetros es correcto nPrint( 3, "Hola" ); //El orden de los parámetros es incorrecto nPrint( "Hola", 3.5 ); //El tipo es incorrecto nPrint(); //faltan argumentos nPrint( "Hola" ); //faltan argumentos } //fin del método main} //fin de la clase PasoParametros



Reutilización de código.

Mayor.java

//Reutilización de código.public class Mayor{ //devuelve el máximo de sus tres parámetros double public static double maximo( double x, double y, double z ) { return Math.max( x, Math.max( y, z ) ); } //fin del método máximo public static void main( String[] args ) { double z = maximo( 9.35, 2.75, 5.1 ); System.out.println( "El mayor es " + z ); } //fin del método main} //fin de la clase Mayor



MaximoComunDivisor.java

//Programa para obtener el máximo común divisor de dos números.import java.util.Scanner; //para leer del tecladopublic class MaximoComunDivisor{ public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); //solicita los dos números enteros System.out.print( "Ingresa el primer número: " ); int n1 = entrada.nextInt(); System.out.print( "Ingresa el segundo número: " ); int n2 = entrada.nextInt(); System.out.println( "El máximo común divisor para " + n1 + " y " + n2 + " es " + gcd( n1, n2 ) ); } //fin del método main

//regresa el máximo común divisor public static int gcd( int n1, int n2 ) { int gcd = 1; //el gcd inicial es 1 int k = 2; //posible gcd while( k <= n1 && n2 % k <= n2 ) { if( n1 % k == 0 && n2 % k == 0 ) gcd = k; //actualiza gcd k++; } //fin while return gcd; //regresa el gcd } //fin del método gcd} //fin de la clase MaximoComunDivisor



NumeroPrimo.java

//Programa que imprime los primeros 50 números primos.public class NumeroPrimo{ public static void main( String[] args ) { System.out.println( "Los primeros 50 números primos son: " ); imprimirNumerosPrimos( 50 ); } //fin del método main public static void imprimirNumerosPrimos( int nPrimos ) { final int PRIMO_POR_LINEA = 10; //despliega 10 por línea int contador = 0; //cuenta el número de primos int numero = 2; //número a probar si es primo //encuentra los números primos while( contador < nPrimos ) { //imprime el número primo e incrementa el contador if( esPrimo( numero ) ) { contador = contador + 1; if( contador % PRIMO_POR_LINEA == 0 ) { //imprime el número y avanza una línea System.out.println( numero ); } //fin if else System.out.print( numero + " " ); } //fin if //busca si el siguiente es número primo numero = numero + 1; } //fin while } //fin del método imprimirNumerosPrimos //verifica si un número es primo public static boolean esPrimo( int numero ) { for( int divisor = 2; divisor <= numero / 2; divisor++ ) if( numero % divisor == 0 ) return false; //el número no es primo return true; //el número es primo } //fin del método esPrimo } //fin de la clase NumeroPrimo



Métodos sobrecargados (overload).

Calculadora.java

//Métodos overload.public class Calculadora { //suma dos números enteros public static int suma( int operandoUno, int operandoDos ) { return operandoUno + operandoDos; } //fin del método suma

//suma dos números double public static double suma( double operandoUno, double operandoDos ) { return operandoUno + operandoDos; } //fin del método suma

public static void main( String[] args ) { System.out.println( suma( 10, 2 ) ); System.out.println( suma( 10, 2.0 ) ); //promoción del argumento System.out.println( suma( 10.0, 2.0 ) ); } //fin del método main} //fin de la clase Calculadora


6. Arreglos de una dimensión.

Contenido:

Declaración de un arreglo..................................................................................................................................... 81

Crear un arreglo.................................................................................................................................................... 82

Asignar valores a un arreglo................................................................................................................................. 83

El tamaño del arreglo y valores por default...........................................................................................................84

Acceder a los elementos de un arreglo................................................................................................................85

Inicialización de un arreglo al declararlo...............................................................................................................86

Inicializar un arreglo con valores desde el teclado...............................................................................................87

Inicializar un arreglo con valores aleatorios..........................................................................................................88

Imprimir el contenido de un arreglo......................................................................................................................89

Sumar todos los elementos del arreglo................................................................................................................90

Encontrar el elemento mayor del arreglo..............................................................................................................91

Intercambio aleatorio de los elementos del arreglo..............................................................................................92

Desplazar elementos del arreglo.......................................................................................................................... 93

Instrucción for mejorada....................................................................................................................................... 94

Paso de arreglos a los métodos...........................................................................................................................95

Regresar un arreglo desde un método.................................................................................................................97

Listas de argumentos de longitud variable............................................................................................................98

Uso de argumentos de línea de comandos..........................................................................................................99

Fundamentos de Programación con Java → Arreglos de una dimensión. 68

Declaración de un arreglo.

DeclararArreglo.java

//Declara un arreglo de una sola dimensión.public class DeclararArreglo{ public static void main( String[] args ) { double[] miArreglo; //double miArreglo[]; } //fin del método main } //fin de la clase DeclaraArreglo



Crear un arreglo.

CrearArreglo.java

//Declara y crea un arreglo.public class CrearArreglo{ public static void main( String[] args ) { //double[] miArreglo; //miArreglo = new Arreglo[10]; double[] miArreglo = new double[10]; } //fin del método main } //fin de la clase CrearArreglo



Asignar valores a un arreglo.

ValoresArreglo.java

//Declara un arreglo de una sola dimensión.public class ValoresArreglo{ public static void main( String[] args ) { double[] miArreglo = new double[10]; //inicializa los valores del arreglo miArreglo[0] = 5.6; //el arreglo inicia en la posición 0 miArreglo[1] = 4.5; miArreglo[2] = 3.3; miArreglo[3] = 13.2; miArreglo[4] = 4.0; miArreglo[5] = 34.33; miArreglo[6] = 34.0; miArreglo[7] = 45.45; miArreglo[8] = 99.93; miArreglo[9] = 999; //el arreglo termina en la posición: n 1 } //fin del método main } //fin de la clase ValoresArreglo



El tamaño del arreglo y valores por default.

DefaultArreglo.java

//Tamaño del arreglo y valores por default.public class DefaultArreglo{ public static void main( String[] args ) { double[] miArreglo = new double[10];

//accede la primera posición del arreglo System.out.println( "miArreglo[0] = " + miArreglo[0] ); //utiliza la propiedad length para obtener el tamaño del arreglo System.out.println( "Tamaño del arreglo = " + miArreglo.length ); } //fin del método main } //fin de la clase DefaultArreglo



Acceder a los elementos de un arreglo.

ElementosArreglo.java

//Acceder a los elementos de un arreglo.public class ElementosArreglo{ public static void main( String[] args ) { double[] miArreglo = new double[10];

//inicializa los valores del arreglo miArreglo[0] = 5.6; miArreglo[1] = 4.5; miArreglo[2] = 3.3; System.out.println( "Los tres primeros elementos del arreglo:" ); System.out.println( "miArreglo[0] = " + miArreglo[0] ); System.out.println( "miArreglo[1] = " + miArreglo[1] ); System.out.println( "miArreglo[2] = " + miArreglo[2] ); } //fin del método main } //fin de la clase ElementosArreglo



Inicialización de un arreglo al declararlo.

DatosArreglo.java

//Declara e inicializa un arreglo.public class DatosArreglo{ public static void main( String[] args ) { double[] miArreglo = {1.9, 2.9, 3.4, 3.5}; System.out.println( "Contenido del arreglo:" ); System.out.println( "miArreglo[0] = " + miArreglo[0] ); System.out.println( "miArreglo[1] = " + miArreglo[1] ); System.out.println( "miArreglo[2] = " + miArreglo[2] ); System.out.println( "miArreglo[3] = " + miArreglo[3] ); } //fin del método main } //fin de la clase DatosArreglo



Inicializar un arreglo con valores desde el teclado.

LecturaArreglo.java

//Inicializar los valores de un arreglo.import java.util.Scanner;public class LecturaArreglo{ public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); double[] miArreglo; System.out.print( "Introduce el tamaño del arreglo? " ); int tamaño = entrada.nextInt(); //crea el arreglo miArreglo = new double[tamaño]; //lee los valores del teclado System.out.println( "Lectura de los datos del arreglo." );

for( int i = 0; i < miArreglo.length; i++ ) { System.out.print( "Valor? " ); miArreglo[i] = entrada.nextDouble(); } //fin for } //fin del método main } //fin de la clase LecturaArreglo



Inicializar un arreglo con valores aleatorios.

ArregloAleatorio.java

//Inicializar los valores de un arreglo.public class ArregloAleatorio{ public static void main( String[] args ) { double[] miArreglo = new double[10]; //inicializa el arreglo con valores aleatorios for( int i = 0; i < miArreglo.length; i++ ) { //0.0 hasta 100 sin incluirlo miArreglo[i] = Math.random()*100; } //fin for } //fin del método main } //fin de la clase ArregloAleatorio



Imprimir el contenido de un arreglo.

ImprimirArreglo.java

//Imprime los valores de un arreglo.public class ImprimirArreglo{ public static void main( String[] args ) { double[] miArreglo = new double[10]; //inicializa el arreglo con valores aleatorios for( int i = 0; i < miArreglo.length; i++ ) { //0.0 hasta 100 sin incluirlo miArreglo[i] = Math.random()*100; } //fin for //imprime los valores del arreglo System.out.println( "Los valores del arreglo:" ); for( int i = 0; i < miArreglo.length; i++ ) { System.out.println( miArreglo[i] ); } //fin for } //fin del método main } //fin de la clase ImprimirArreglo



Sumar todos los elementos del arreglo.

SumaArreglo.java

//Sumar los valores de un arreglo.public class SumaArreglo{ public static void main( String[] args ) { double[] miArreglo = new double[10]; double suma = 0;

//inicializa el arreglo con valores aleatorios for( int i = 0; i < miArreglo.length; i++ ) { //0.0 hasta 100 sin incluirlo miArreglo[i] = Math.random()*100; //va sumando los valores del arreglo suma = suma + miArreglo[i]; } //fin for //imprime la suma del arreglo System.out.println( "La suma de los valores del arreglo es " + suma ); } //fin del método main } //fin de la clase SumaArreglo



Encontrar el elemento mayor del arreglo.

MayorArreglo.java

//Encuentra el elemento mayor de un arreglo.public class MayorArreglo{ public static void main( String[] args ) { double[] miArreglo = {1.9, 2.9, 1.8, 3.4, 2.2}; double mayor = miArreglo[0]; //asume que es el mayor //procesa el arreglo, iniciando en el indice 1 for( int i = 1; i < miArreglo.length; i++ ) { if( miArreglo[i] > mayor ) mayor = miArreglo[i]; } //fin for //imprime la suma del arreglo System.out.println( "El elemento mayor es " + mayor ); } //fin del método main } //fin de la clase MayorArreglo



Intercambio aleatorio de los elementos del arreglo.

Shuffling.java

//Intercambia aleatoriamente los valores del arreglo.public class Shuffling{ public static void main( String[] args ) { double[] miArreglo = { 1, 5, 3, 4, 7, 9 }; //procesa el arreglo for( int i = 0; i < miArreglo.length; i++ ) { //genera el indice j aleatoriamente int j = ( int )( Math.random() * miArreglo.length ); //intercambia miArreglo[i] con miArreglo[j]; double temporal = miArreglo[i]; miArreglo[i] = miArreglo[j]; miArreglo[j] = temporal; } //fin for

//imprime los valores del arreglo System.out.println( "Los valores del arreglo:" ); for( int i = 0; i < miArreglo.length; i++ ) { System.out.print( miArreglo[i] + " " ); } //fin for } //fin del método main } //fin de la clase Shuffling



Desplazar elementos del arreglo.

RotarArreglo.java

//Rotar los elementos de un arreglo.public class RotarArreglo{ public static void main( String[] args ) { double[] miArreglo = { 1, 5, 3, 4, 7, 9 }; double temporal = miArreglo[0]; //guarda el primer elemento //procesa el arreglo for( int i = 1; i < miArreglo.length; i++ ) { miArreglo[i1] = miArreglo[i]; } //fin for

//mueve el primer elemento al último miArreglo[ miArreglo.length 1 ] = temporal; //imprime los valores del arreglo System.out.println( "Los valores del arreglo:" ); for( int i = 0; i < miArreglo.length; i++ ) { System.out.print( miArreglo[i] + " " ); } //fin for } //fin del método main } //fin de la clase RotarArreglo



Instrucción for mejorada.

ForEach.java

//Ciclo foreach.public class ForEach{ public static void main( String[] args ) { double[] miArreglo = {1, 5, 3, 4, 7, 9}; //procesa el arreglo for( double elemento : miArreglo ) System.out.println( elemento ); } //fin del método main } //fin de la clase ForEach



Paso de arreglos a los métodos.

PasoParametros.java

//Paso de arreglos a los métodos.public class PasoParametros{ public static void main( String[] args ) { double[] x = { 12.0, 34.0, 43.4, 12.0, 23.4 }; double[] y = { 11.4, 31.7, 13.4, 12.8, 21.8 };

imprimir( x ); imprimir( y );

//usando un arreglo anónimo imprimir( new double[]{ 11.0, 12.0, 13.0, 14.0, 15.0 } ); } //fin del método main

public static void imprimir( double[] arreglo ) { for( int i = 0; i < arreglo.length; i++ ) System.out.print( arreglo[i] + " " ); System.out.println(); } //fin del método imprimir} //fin de la clase PasoParametros



PasoArreglo.java

//Paso de arreglos y elementos individuales de un arreglo a los métodos.public class PasoArreglo{ //main crea el arreglo y llama a modificarArreglo y modificarElemento public static void main( String[] args ) { int arreglo[] = { 1, 2, 3, 4, 5 }; System.out.println( "Efectos de pasar una referencia a un arreglo completo:\n" + "Los valores del arreglo original son:" ); //imprime los elementos originales del arreglo for( int valor : arreglo ) System.out.print( " " + valor ); modificarArreglo( arreglo ); //pasa la referencia al arreglo System.out.println( "\n\nLos valores del arreglo modificado son:" ); //imprime los elementos modificados del arreglo for( int valor : arreglo ) System.out.printf( " " + valor ); System.out.println( "\n\nEfectos de pasar el valor de un elemento del arreglo;\n" + "arreglo[3] antes de modificarElemento: " + arreglo[ 3 ] ); modificarElemento( arreglo[ 3 ] ); //intento por modificar arreglo[3] System.out.println( "\narreglo[3] despues de modificarElemento: " + arreglo[ 3 ] ); } //fin del método main //multiplica cada elemento de un arreglo por 2 public static void modificarArreglo( int arreglo2[] ) { for( int contador = 0; contador < arreglo2.length; contador++ ) arreglo2[ contador ] = arreglo2[contador] * 2; } //fin del método modificarArreglo //multiplica el argumento por dos public static void modificarElemento( int elemento ) { elemento = elemento * 2; System.out.println( "Valor del elemento en modificarElemento: " + elemento ); } //fin del método modificarElemento} //fin de la clase PasoArreglo



Regresar un arreglo desde un método.

ProductoVectores.java

//Calcula el producto de dos arreglos A y B.import java.util.Scanner; //para leer del tecladopublic class ProductoVectores{ private static final int MAX = 10; //tamaño del arreglo public static void main( String[] args ) { //entrada System.out.println( "Arreglo 1." ); int[] a = leerArreglo(); System.out.println( "Arreglo 2." ); int[] b = leerArreglo(); //proceso int producto = productoVectores( a, b ); //salida System.out.println( "El producto de AxB = " + producto ); } //fin del método main private static int[] leerArreglo() { //crea el objeto de lectura Scanner entrada = new Scanner( System.in ); int[] temp = new int[MAX]; for( int i = 0; i < temp.length; i++ ) { System.out.print( "Valor? " ); temp[i] = entrada.nextInt(); } //fin for return temp; } //fin del método leerArreglo private static int productoVectores( int[] a, int[] b ) { int producto = 0; for( int i = 0; i < MAX; i++ ) producto = producto + ( a[i] * b[i] ); return producto; } //fin del método productoVectores } //fin de la clase ProductoVectores



Listas de argumentos de longitud variable.

PruebaVarargs.java

//Uso de listas de argumentos de longitud variable.public class PruebaVarargs{ //calcula el promedio public static double promedio( double...numeros ) { double total = 0.0; //inicializa el total //calcula el total usando la instrucción for mejorada for( double d : numeros ) total = total + d; return total / numeros.length; } //fin del método promedio public static void main( String args[] ) { double d1 = 10.0; double d2 = 20.0; double d3 = 30.0; double d4 = 40.0; System.out.println( "Valores iniciales." ); System.out.println( "" ); System.out.println( "d1 = " + d1 ); System.out.println( "d2 = " + d2 ); System.out.println( "d3 = " + d3 ); System.out.println( "d4 = " + d4 ); System.out.println( "El promedio de d1 y d2 es " + promedio( d1, d2 ) ); System.out.println( "El promedio de d1, d2, d3 y d4 es " + promedio( d1, d2, d3, d4 ) ); } //fin del método main } //fin de la clase PruebaVarargs



Uso de argumentos de línea de comandos.

Suma.java

//Uso de los argumentos args.public class Suma { public static void main ( String[] args ) { //comprueba el número de argumentos de línea de comandos if( args.length != 2 ) System.out.println( "Se necesitan dos argumentos." ); else { //obtiene los valores de la línea de comandos int numUno = Integer.parseInt( args[0] ); int numDos = Integer.parseInt( args[1] );

//obtiene la suma int suma = numUno + numDos;

//muestra la suma System.out.println( args[0] + " + " + args[1] + " es " + suma ); } //fin del método main} //fin de la clase Suma


7. Arreglos bidimensionales.

Contenido:

Introducción.......................................................................................................................................................... 15

Trabajando con números................................................................................................................................ 15

Dificultades numéricas.................................................................................................................................... 16

Cálculos simples............................................................................................................................................. 16

Imprimir texto, versión 1.1..................................................................................................................................... 17



Variables............................................................................................................................................................... 18

Programa para sumar dos números...............................................................................................................18

Calculadora simple......................................................................................................................................... 19

Precedencia de los operadores............................................................................................................................ 20

Circulo Versión 1.0................................................................................................................................................ 20

Circulo Versión 1.1................................................................................................................................................ 21

Circulo Versión 1.2................................................................................................................................................ 22

Operadores de igualdad y relacionales................................................................................................................22

Instrucción if simple.............................................................................................................................................. 24

Fundamentos de Programación con Java → Arreglos bidimensionales. 88

Introducción.



Declaración de un arreglo.

DeclararArreglo.java

//Declara un arreglo de dos dimensiones.public class DeclararArreglo2D{ public static void main( String[] args ) { double[][] matriz; //double matriz[][]; } //fin del método main } //fin de la clase DeclararArreglo2D



Crear un arreglo.

CrearArreglo.java

//Declara y crea un arreglo de dos dimensiones.public class CrearArreglo2D{ public static void main( String[] args ) { //double[][] matriz; //matriz = new Arreglo[10][10]; double[][] matriz = new double[10][10]; } //fin del método main } //fin de la clase CrearArreglo2D



Asignar valores a un arreglo.

ValoresArreglo.java

//Declara un arreglo de dos dimensiones.public class ValoresArreglo2D{ public static void main( String[] args ) { double[][] matriz = new double[10][10]; //inicializa los valores del arreglo2D miArreglo[0][0] = 5.6; miArreglo[0][1] = 4.5; miArreglo[0][2] = 3.3; miArreglo[0][3] = 13.2; miArreglo[0][4] = 4.0; miArreglo[0][5] = 34.33; miArreglo[0][6] = 34.0; miArreglo[0][7] = 45.45; miArreglo[0][8] = 99.93; miArreglo[0][9] = 99.54; } //fin del método main } //fin de la clase ValoresArreglo2D



El tamaño del arreglo y valores por default.

DefaultArreglo.java

//Tamaño del arreglo y valores por default.public class DefaultArreglo2D{ public static void main( String[] args ) { double[][] matriz = new double[10][10];

//accede la primera posición de la matriz System.out.println( "matriz[0][0] = " + matriz[0][0] ); //utiliza la propiedad length para obtener el tamaño del arreglo System.out.println( "Tamaño del arreglo = " + matriz.length ); System.out.println( "Tamaño del renglón = " + matriz[0].length ); } //fin del método main } //fin de la clase DefaultArreglo2D



Acceder a los elementos de un arreglo.

ElementosArreglo2D.java

//Acceder a los elementos de una matriz.public class ElementosArreglo2D{ public static void main( String[] args ) { double[][] matriz = new double[10][10];

//inicializa los valores de la matriz matriz[0][0] = 5.6; matriz[1][0] = 4.5; matriz[2][0] = 3.3; System.out.println( "matriz[0][0] = " + miArreglo[0][0] ); System.out.println( "matriz[1][0] = " + miArreglo[1][0] ); System.out.println( "matriz[2][0] = " + miArreglo[2][0] ); } //fin del método main } //fin de la clase ElementosArreglo2D



Inicialización de un arreglo al declararlo.

DatosArreglo.java

//Declara e inicializa un arreglo de dos dimensiones.public class DatosArreglo2D{ public static void main( String[] args ) { double[] matriz = { { 1.9, 2.9, 3.4, 3.5 }, { 5.5, 7.2, 3.3, 1,9 }, { 8.7, 3.4, 8.6, 9.9 } };

} //fin del método main } //fin de la clase DatosArreglo2D



Inicializar un arreglo bidimensional con valores desde el teclado.

LecturaArreglo2D.java

//Inicializa los datos de un arreglo 2D desde el teclado.import java.util.Scanner;public class LecturaArreglo2D{ public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); int[][] tabla = new int[2][3];

System.out.println( "Arreglo con " + tabla.length + " renglones y " + tabla[0].length + " columnas." ); System.out.println( "Introduce números enteros:" ); //lectura del arreglo for( int ren = 0; ren < tabla.length; ren++ ) { for( int col = 0; col < tabla[ren].length; col++ ) { System.out.print( "Valor[" + ren + "][" + col + "]? " ); tabla[ren][col] = entrada.nextInt(); } //fin for } //fin for //imprime el primer renglón System.out.print( "El renglón 1 = [" ); System.out.print( tabla[0][0] + " " ); System.out.print( tabla[0][1] + " " ); System.out.print( tabla[0][2] + "]" ); } //fin del método main } //fin de la clase LecturaArreglo2D



Inicializar un arreglo bidimensional con valores aleatorios.

Arreglo2DAleatorio.java

//Inicializa un arreglo 2D con valores aleatorios.public class Arreglo2DAleatorio{ public static void main( String[] args ) { int[][] tabla = new int[2][3];

System.out.println( "Arreglo con " + tabla.length + " renglones y " + tabla[0].length + " columnas."); System.out.println( "El arreglo 2D tiene valores random." ); //inicializa el arreglo 2D for( int ren = 0; ren < tabla.length; ren++ ) for( int col = 0; col < tabla[ren].length; col++ ) tabla[ren][col] = ( int )( Math.random() * 100 ); //imprime el primer renglón System.out.print( "El renglón 1 = [" ); System.out.print( tabla[0][0] + " " ); System.out.print( tabla[0][1] + " " ); System.out.print( tabla[0][2] + "]" ); } //fin del método main} //fin de la clase Arreglo2DAleatorio



Imprimir el contenido de un arreglo bidimensional.

ImprimirArreglo2D.java

//Imprime el contenido de un arreglo2D.public class ImprimirArreglo2D{ public static void main( String[] args ) { //Declara e inicializa un arreglo 2D de 3 renglones, 3 columnas int[][] tabla = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9} }; System.out.println( "Valores del arreglo." ); System.out.println( "" );

//imprime el contenido del arreglo for( int ren = 0; ren < tabla.length; ren++ ) { System.out.print( "Renglon " + ren + " = [ " ); for( int col = 0; col < tabla[ren].length; col++ ) System.out.print( tabla[ren][col] + " " ); System.out.println( "]" ); } //fin for } //fin del método main} //fin de la clase ImprimirArreglo2D



Sumar todos los elementos de un arreglo bidimensional.

SumaArreglo2D.java

//Suma todos los elementos del arreglo 2D.public class SumaArreglo2D{ public static void main( String[] args ) { //declara e inicializa un arreglo de 4x5 double[][] tabulador = { { 10.50, 12.00, 14.50, 16.75, 18.00 }, { 20.50, 22.28, 24.00, 26.25, 27.50 }, { 34.00, 36.50, 38.00, 40.35, 43.00 }, { 50.00, 60,00, 70.00, 80.00, 99.99 } }; System.out.println( "Suma los datos del tabulador." ); System.out.println( "" );

double suma = 0.0; for( int ren = 0; ren < tabulador.length; ren++ ) for( int col = 0; col < tabulador[ren].length; col++ ) suma = suma + tabulador[ren][col]; System.out.println( "Suma = " + suma ); } //fin del método main} //fin de la clase SumaArreglo2D.



Suma los elementos de un arreglo bidimensional por columna.

SumaColumna.java

//Suma las columnas de un arreglo 2D.public class SumaColumna{ public static void main( String[] args ) { //declara e inicializa un arreglo de 4x5 double[][] tabulador = { { 10.50, 12.00, 14.50, 16.75, 18.00 }, { 20.50, 22.28, 24.00, 26.25, 27.50 }, { 34.00, 36.50, 38.00, 40.35, 43.00 }, { 50.00, 60,00, 70.00, 80.00, 99.99 } }; System.out.println( "Suma los datos x columna." ); System.out.println( "" );

for( int col = 0; col < tabulador[0].length; col++ ) { double sumaCol = 0.0; for( int ren = 0; ren < tabulador.length; ren++ ) sumaCol = sumaCol + tabulador[ren][col]; System.out.println( "Columna " + col + " = " + sumaCol ); } //fin for } //fin del método main} //fin de la clase SumaColumna



Suma por renglón y encuentra el mayor.

SumaRenglon.java

//Suma los renglones de un arreglo 2D y encuentra el mayor.public class SumaRenglon{ public static void main( String[] args ) { //declara e inicializa un arreglo de 4x5 double[][] tabulador = { { 10.50, 12.00, 14.50, 16.75, 18.00 }, { 20.50, 22.28, 24.00, 26.25, 27.50 }, { 34.00, 36.50, 38.00, 40.35, 43.00 }, { 50.00, 60,00, 70.00, 80.00, 99.99 } }; System.out.println( "Suma los datos x renglón." ); System.out.println( "" );

double max = 0.0; //el renglón mayor //obtiene la suma del primer renglón y lo asigna a max for( int col = 0; col < tabulador[0].length; col++ ) max = max + tabulador[0][col]; //procesa el arreglo2D, imprime la suma por cada renglón //y muestra el renglón con la suma más grande for( int ren = 0; ren < tabulador.length; ren++ ) { double sumaRen = 0.0; for( int col = 0; col < tabulador[ren].length; col++ ) sumaRen = sumaRen + tabulador[ren][col]; if( sumaRen > max ) //Busca la suma más grande max = sumaRen; //actualiza el renglón mayor System.out.println( "Renglón " + ren + " = " + sumaRen ); } //fin for System.out.println( "El renglón de mayor suma = " + max ); } //fin del método main} //fin de la clase SumaRenglon



Intercambio aleatorio de un arreglo bidimensional.

Shuffling2D.java

//Intercambio aleatorio de los elementos de un arreglo 2D.public class Shuffling2D{ public static void main( String[] args ) { //declara e inicializa un arreglo de 3x3 int[][] tabla = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9} }; //procesa el arreglo intercambiando los valores for( int ren = 0; ren < tabla.length; ren++ ) { for( int col = 0; col < tabla[ren].length; col++ ) { //genera indices aleatorios para ren, col int renAux = ( int )( Math.random() * tabla.length ); int colAux = ( int )( Math.random() * tabla[col].length ); //intercambia tabla[ren][col] por tabla[renAux][colAux] int temp = tabla[ren][col]; tabla[ren][col] = tabla[renAux][colAux]; tabla[renAux][colAux] = temp; } //fin for } //fin for

System.out.println( "El arreglo después del shuffling." ); //imprime el contenido del arreglo for( int ren = 0; ren < tabla.length; ren++ ) { System.out.print( "Renglón " + ren + " = [ " ); for( int col = 0; col < tabla[ren].length; col++ ) System.out.print( tabla[ren][col] + " " ); System.out.println( "]" ); } //fin for } //fin del método main} //fin de la clase Shuffling2D


Fundamentos de Programación con Java

Documents

Transcript of Fundamentos de Programación con Java