Codigos Java

CÓDIGOS DE PROGRAMAS
en Java
Efraín Soto Apolinar

Códigos de Programas
en el lenguaje Java
Compilados por
Efraín Soto Apolinar
PISIS
Monterrey, N.L., México. 2009

Índice de contenidos
1 Introducción 7
1.1 Conceptos básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.1.1 Conceptos de programación . . . . . . . . . . . . . . . . . . . . . . 8
1.1.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2 Palabras reservadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.2.1 Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.3 Ventajas de usar Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.4 Flujo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.4.1 If then else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.5 Clase Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2 Códigos 17
2.1 Programación científica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
PISIS Códigos de programas en java

4
2.1.1 Sucesión de Fibonacci . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.1.2 Detector de números primos . . . . . . . . . . . . . . . . . . . . . 19
2.1.3 Piedra, papel y tijera . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.2 Aproximación de π . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.3 Factoriales y aproximación del número e . . . . . . . . . . . . . . . . . . 25
2.4 Coeficientes binomiales y el triángulo de Pascal . . . . . . . . . . . . . 26
2.5 Programas de muestra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.5.1 Novia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.5.2 Mensajes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.5.3 Tu Nombre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.5.4 Diálogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.5.5 Entero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.5.6 Fibonacci (V.2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2.5.7 Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.5.8 IgnoreSpaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.5.9 AlReves . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.5.10 CuentaPalabras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.5.11 CountLetter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.5.12 LetterArithmetics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.5.13 Comparar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
2.5.14 RandomArray . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.5.15 Distribucion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Códigos de programas en java PISIS

2.5.16 cloneArray . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.5.17 Cards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
2.5.18 Cards.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
2.5.19 Card3.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
2.5.20 Card4.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
2.5.21 Complex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
2.5.22 Fraccion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.5.23 Estructura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3 Gráficos 51
3.1 Swing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.1.1 HelloWorld . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.1.2 HelloPanel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.1.3 MyJButton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Términos de uso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
6

Uno
Introducción

8 Introducción
1.1 CONCEPTOS BÁSICOS

En este apartado se dan algunos conceptos que necesitas conocer para poder
aprovechar la lectura de este material.
Se presentan diversas secciones con contenidos igual de importantes. Los primeros

tienen que ver con las bases de programación y después se incluyen los que
conciernen al lenguaje java.
1.1.1 Conceptos de programación
Los conceptos que debes entender para iniciarte en el arte de la programación

son:
Definición 1.1.1.1
ALGORITMO
Una sucesión ordenada de instrucciones para resolver un problema o una
tarea. Puedes pensar en un algoritmo como si se tratara de una receta. Es el
procedimiento que se debe realizar para resolver un problema específico.
Definición 1.1.1.2
COMPILADOR
Es el programa de computadora que traduce las instrucciones que nosotros le
damos en un lenguaje específico.
Definición 1.1.1.3
PROGRAMA FUENTE
Es el código que tú vas a escribir. En este texto encontrarás el programa fuente
para resolver muchos problemas. El programa fuente también se conoce como
código fuente.

1.1 Conceptos básicos 9
Definición 1.1.1.4
CÓDIGO
Es un conjunto de instrucciones en algún lenguaje de alto nivel. En este mate-
rial solamente encontrarás código en java.
El código no necesariamente es un programa completo, puede tratarse sola-
mente de una parte del programa.
Definición 1.1.1.5
SINTAXIS
Son las reglas de acuerdo a las cuales debes escribir el programa fuente. Cada
lenguaje de programación tiene su sintaxis. Puedes imaginar que la sintaxis
son las reglas de gramática de ese lenguaje.
Definición 1.1.1.6
COMPILAR
Indicar a la computadora que verifique que el programa fuente no contenga
errores. Esta tarea siempre la realizará un software (el compilador).
Definición 1.1.1.7
CORRER (UN PROGRAMA)
Ordenar a la computadora que ejecute las instrucciones indicadas por el código
de un programa. Evidementemente, un programa en javadebe correrse en un
compilador de ese lenguaje. (Yo utilizo el Dev-java, que es gratuito.)
Algunas veces el compilador no encontrará errores, pero existe la posibilidad

de que sí existan. Por ejemplo, en el caso de que tú hayas cometido el error de
escribir un + en lugar de un *, el compilador no se da cuenta, porque no sabe
realmente qué debe hacer el programa. En otras palabras, las computadoras
todavía no pueden leer tu mente.

10 Introducción
Definición 1.1.1.8
MENSAJE DE ERROR
Es un mensaje que el compilador te dará cuando encuentre errores en el pro-
grama fuente. Estos mensajes te ayudan a corregir el código.
Definición 1.1.1.9
ERROR DE SINTÁXIS
Ocurre cuando el código no está completamente escrito de acuerdo a las re-
glas de sintaxis del mismo. Por ejemplo, si escribes, Go To en lugar de GOTO,
cometiste un error de sintaxis (de acuerdo a la sintáxis del lenguaje GWBasic).
Definición 1.1.1.10
ERRORES LÓGICOS
Los que comete el programador cuando traduce el algoritmo al lenguaje java.
El programa realmente no hace lo que el algoritmo indica. Tal vez no tenga
errores de sintáxis... simplemente no realiza la tarea que debe realizar. Cuidado
con esto.
1.1.2 Variables
IDENTIFICADOR
Es el nombre que el programador asigna a un valor dentro de un programa. En
java, un identificador debe empezar con una letra o el símbolo: ’_’ y los demás
caracteres deben ser letras, dígitos o el símbolo ’_’.

1.2 Palabras reservadas 11
VARIABLE
Es una herramienta de programación utilizada para asignar valores (no nece-
sariamente numéricos) a letras o cadenas de letras. Las variables se clasifican
de acuerdo al tipo de valor que almacenan.
CONSTANTE
Es un valor que no cambia durante la ejecución del programa. Una constante
puede ser de cualquiera de los tipos de datos definidos en java.
1.2 PALABRAS RESERVADAS
abstract default if private this

boolean do implements protected throw
break double import public throws
byte else instanceof return transient
case extends int short try
catch final interface static void
char finally long strictfp volatile
class float native super while
const for new switch
continue goto package synchronized assert
Las palabras const y goto no puede utilizarse en java, pero generan errores
de compilación cuando se convierte código a C++.
Otras tres palabras que cabe mencionar aquí son null, true y false. Estas no
son palabras clave, sino valores que tampoco pueden utilizarse como identifi-
cadores.

12 Introducción
Definición 1.2.1
IDENTIFICADOR
Las palabras que utilizamos para indicar los nombres de las variables.
Para definir un identificador se deben seguir las siguientes reglas.
i. Un identificador no debe ser igual a una palabra clave, ni igual a las pala-
bras null, true o false.
ii. Un identificador puede consistir de letras, dígitos, el símbolo _, o el signo

de pesos ($).
iii. Un identificador debe iniciar con una letra, el signo _ o el signo de pesos
($).
Dado que el lenguaje java es Case Sensitive, es decir, diferencia entre mayús-
culas y minúsculas, podemos definir como identificador a la palabra Transient,
ya que ésta no es una palabra clave, la palabra clave transient inicia con letra
minúscula.
1.2.1 Tipos de datos
Variable Rango Precisión Ejemplo

short −32 767 a 32 767 No Aplica 23
int −2 147 483 647 a 2 147 483 647 No Aplica −4
float 10−38 a 1038 7 dígitos 3.1416
double 10−308 a 10308 15 dígitos 3.141592654
long 10−4932 a 104932 19 dígitos 2.718281828
char \u000 a \ufff No aplica ’a’
string No aplica No aplica ’Hola Amigo.’
boolean False/True No aplica False

1.3 Ventajas de usar Java 13
1.3 VENTAJAS DE USAR JAVA

Java es un lenguaje sencillo.
Si sabes programar en C o en C++ aprender java es muy sencillo.
java te ayuda porque no requieres del manejo de memoria, porque utiliza un

colector de basura que verifica cuándo un objeto no tiene alguna referencia y
por tanto no se requiere su uso.
Esto permite al programador concentrarse en crear los objetos, hacer que in-
teraccionen como deben y en preocuparse por lo que debe hacer el programa.
En otras palabras, te simplifica latarea como programador.

14 Introducción
1.4 FLUJO
Para determinar el flujo de las instrucciones en un programa utilizamos diferen-
tes instrucciones.
Siempre debe haber una variable booleana que va a determinar qué hacer, de
acuerdo a la instrucción que se utilice en cada caso.
1.4.1 If then else
// codigo que se está ejecuntando...

if (condicion){
\\ Realiza esto si la condicion es verdadera
}
// código que se ejecutará después...
El siguiente código nos ayuda con una segunda posibilidad. En caso de que la
condición condicion sea verdadera el programa va a realizar las instrucciones
que están dentro del argumento entre llaves después de la condición, pero si es
falsa, entonces realizará las instrucciones que están en el argumento después
de la palabra clave else:
\if(condicion){
// Si la condicion es verdadera
// realiza las instrucciones que están
// en este argumento...
}
else{
// Si la conición es falsa
// realiza las instrucciones que están
// en este argumento...
}
// Después continúa con las instrucciones
// que están enseguida...

1.5 Clase Math 15
1.5 CLASE MATH

En java una clase que utilizaremos muy frecuentemente es la clase Math.
En esta clase se contienen métodos (funciones matemáticas) de uso frecuente

como las exponenciales, logarítmicas y trigonométricas.
Algunos de los métodos definidos son los siguientes:
Método: Regresa:
E e ≈ 2.718281828 base de los logaritmos naturales.
PI π ≈ 3.141592654.
abs(double a) valor absoluto de a (double)
abs(float a) valor absoluto de a (float)
abs(int a) valor absoluto de a (int)
acos(double a) arcocoseno de a (double). El resultado está entre 0
y π.
asin(double a) arcoseno de a (double). El resultado está entre
−π/2 y π/2.
atan(double a) arcotangente de a (double). El resultado está entre
−π/2 y π/2.
cbrt(double a) raíz cúbica de a (double)
ceil(double a) menor entero mayor o igual a a (double).
cos(double a) coseno de a (double)
cosh(double a) coseno hiperbólico de a (double).
exp(double a) e a , siendo a un (double).
floor(double a) mayor entero menor o igual a a (double).
log(double a) ln(a ), siendo a un (double).
log10(double a) log10 (a ), siendo a un (double).
max(double a, double b) mayor de los valores a (double) y b (double).
max(float a, float b) mayor de los valores a (float) y b (float).
max(long a, long b) mayor de los valores a (long) y b (long).
min(double a, double b) menor de los valores a (double) y b (double).
min(float a, float b) menor de los valores a (float) y b (float).
min(long a, long b) menor de los valores a (long) y b (long).

16 Introducción
Método: Regresa:
pow(double a, double b) a b , siendo a un (double) y b un (double).
random() un (double) aleatorio en el intervalo [0.0, 1.0)
rint(double a) (double) igual al entero más cercano a a (double).
round(double a) (long) más cercano a a (double).
round(float a) (int) más cercano a a (float).
sin(double a) seno de a (double).
sinh(double a) seno hiperbólico de a (double).
tan(double a) tangente de a (double).
toDegrees(double
convierte a grados angRad que es un ángulo medido
angRad)
en radianes (double).
toRadians(double
convierte a radianes angDeg que es un ángulo me-
angDeg)
dido en grados (double).

Dos
Códigos

18 Códigos
2.1 PROGRAMACIÓN CIENTÍFICA

Los siguientes códigos fueron realizados para practicar mi programación, usando
los ejercicios que se quedaron de tarea en el curso de programación científica
impartida por Dra. Elisa Schaeffer.
2.1.1 Sucesión de Fibonacci
La serie de Fibonacci se define por la ecuación recursiva siguiente:
F (n) = F (n − 1) + F (n − 2)
Los primeros elementos son F (0) = 0 y F (1) = 1, por lo cual la serie comienza
con:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946...
Objetivo Escribir un programa en java al cual el usuario define el índice n y el
programa imprime en la pantalla el valor de F (n).
Serie de Fibonacci. Este programa permite que el usuario de varios valores de

n.
Enseguida se muestra en código en el lenguaje java.
1 /*
2 *Programa Fibonacci
3 *
4 * Este programa genera la sucesión de
5 * Fibonacci
6 *
7 * Fecha: 26 de marzo de 2008
8 *
9 */
10
11 import java.util.Scanner;
12
13 class Fibonacci {
14 static Scanner input = new Scanner(System.in);
15 //
16 // Genera los números de Fibonacci
17 public static void main(String[] args) {
18 int b4 = 0;

2.1 Programación científica 19
19 int now = 1;
20 int i;
21 int n;
22 System.out.println("\n\nCuantos terminos de la sucesion");
23 System.out.print("de Fibonacci desea que se impriman? ");
24 for (;;){ // hasta que introduca un numero positivo...
25 n = input.nextInt();
26 if (n <= 0){
27 System.out.println("\n\nError en argumento...");
28 System.out.println("Por favor, intente de nuevo.");
29 System.out.println("Introduzca un entero positivo...\n");
30 }
31 break;
32 } // end for
33 for (i = 0 ; i <= n ; i++) {
34 System.out.println("a_" + i + " = " + now);
35 now = b4 + now;
36 b4 = now - b4;
37 }
38 }
39 }
2.1.2 Detector de números primos
Objetivo:
Escribir un programa en java1 al cual el usuario define un número entero pos-

itivo n y el programa determina si es o no primo.
Por ejemplo,
1876953 = 3 ∗ 13 ∗ 17 ∗ 19 ∗ 149
donde todos los factores son primos.
Para esta tarea considero la siguiente definición:
Definición 2.1.2.1
NÚMERO PRIMO
Es un número natural que tiene exactamente dos divisores naturales.
Esto significa que el número 1 NO es primo, dado que tiene solamente un divi-
sor.
1 Este código compila y funciona correctamente en el JCreator Ver. 4.50.010con JDK 6.

20 Códigos
No se requiere, pero para no dejar a un lado:
Definición 2.1.2.2
NÚMERO COMPUESTO
Es un número natural que tiene más de dos divisores naturales.
De nuevo, el número 1 NO es compuesto, pues NO tiene más de dos divisores

naturales.
Verificar si un número es primo.
Enseguida se muestra el programa en el lenguaje java.
1 /**
2 * @(#)primos.java
3 *
4 *
5 * @author: Efraín Soto Apolinar
6 * @version 1.00
7 * Fecha: 26 de marzo de 2008.
8 */
10
11 public class primos {
13 /**
14 * Creates a new instance of <code>primos</code>.
15 */
16 public primos() {
17 }
18
19 /**
20 * @param args the command line arguments
21 */
23 // TODO code application logic here
24 int n, N, i, j, divisor, prime;
25 int[] factor = new int[20];
26 System.out.print("\nEste programa calcula indica si");
27 System.out.print("\nun numero dado es primo o no...\n");
28 for(;;){ // Hasta que ingrese un entero positivo
29 System.out.print("\n\nIngresa un entero positivo: ");
31 if (n <= 0){
33 System.out.println("Por favor, intente de
34 nuevo...");
35 System.out.println("Introduzca un entero positivo.");
36 continue;

2.1 Programación científica 21
37 }
38 break;
39 }
40 //
41 N = n; // Nueva variable para modificarla...
42 // verifico que el numero ingresado sea positivo...
43 if (n<0){
44 System.out.print("\nError en argumento...");
45 System.out.print("\nPor favor, introduce un numero
46 entero positivo...");
47 return;
48 }
49 if (n==1){
50 System.out.print("\nEl numero 1 No es primo...");
51 System.out.print("...pero tampoco es compuesto...");
52 return;
53 }
54
55
56 prime = 0; // Supongo que el numero NO es primo...
57 i = 0; //Inicio el indice del arreglo
58
59 // Reinicio el arreglo factor[20]
60 for (j=0;j<=19;j++){
61 factor[j]= 0;
62 }
63
64 // verifico que no sea par...
65 divisor = 2;
66 while (N%2 == 0){
67 factor[i]=divisor;
68 i++;
69 prime = 1;
70 N = N/divisor;
71 }
72 // verifico que no se divida por impares...
73 divisor = 3;
74 while (N >= divisor){
75 while (N%divisor == 0){
76 factor[i]=divisor;
77 i++;
78 prime = 1;
79 N = N / divisor;
80 }
81 divisor = divisor + 2;
82 if (divisor%3 == 0) divisor = divisor + 2;
83 }
84
85 // Ahora imprimo los factores...
86 if (i>=2){
87 System.out.print("\n\n\nEl numero " + n + "
88 no es primo...\n\n\n");
89 // reinicio el indice i
90 j = 0;
91 System.out.print("\n\n\n" + n + " = ");
92 for (j=0;j<i;j++){
93 System.out.print(factor[j]);

22 Códigos
94 if (factor[j+1]!=0){
95 System.out.print(" * ");
96 }
97 }
98 System.out.print("\n\n\n");
99 }
100 if (i == 1){
101 System.out.print("El numero " + n + "
102 es primo...\n\n\n");
103 }
104 }
105 }
2.1.3 Piedra, papel y tijera
Objetivo:
Escribir un programa en java que juega interactivamente piedra-papel-tijera

con el usuario.
Juego Piedra – papel – tijera.
Enseguida se muestra el código de este programa en el lenguaje java:
1 /**
2 * @(#)tres.java
3 *
4 *
5 * @author: Efraín Soto Apolinar.
6 * @date: 27 de marzo de 2008.
7 */
9
10 public class tres {
12 /**
13 * Creates a new instance of <code>tres</code>.
14 */
15 public tres() {
16 }
17
18 /**
20 */
23 int usuario,compu;
24 //

2.2 Aproximación de π 23
25 System.out.print("\n\n\nEste programa juega interactivamente");

26 System.out.print("\n\n\nPiedra - Papel o tijera");
27 System.out.print("\ncon el usuario...");
28
29 for (;;){ // for infinito
30 System.out.print("\n\n1 representa piedra...");
31 System.out.print("\n2 representa papel...");
32 System.out.print("\n3 representa tijera...");
33 System.out.print("\nPresiona 0 para salir...");
34 System.out.print("\n\nIntroduce tu jugada...");
35 usuario = input.nextInt();
36
37 if (usuario == 0){ // hay que salir...
38 System.out.print("\n\nPresionaste <<0>>...");
39 System.out.print("\n\nAdios...\n\n");
40 break;
41 }
42 //
43 //compu = (rand() % 3) + 1;
44 //
45 if ((usuario == 1)){
46 System.out.print("\n\nyo elijo papel....");
47 System.out.print("\n\nYo gano!!!\n");
48 continue;
49 }
50
51 if (usuario == 2){
52 System.out.print("\n\nyo elijo tijera....");
54 continue;
55 }
56
57 if (usuario == 3){
58 System.out.print("\n\nyo elijo piedra....");
60 continue;
61 }
62
63 System.out.print("\nError en Argumento...\n");
64 System.out.print("\nPor favor, intenta de nuevo...\n\n\n");
65
66 } // termina el for...
67
68 }
69 }
2.2 APROXIMACIÓN DE π

24 Códigos
1 /**
2 * @(#)cuatro.java
3 *
4 *
5 * @author: Efraín Soto Apolinar
6 * @date: 27 de marzo de 2008.
7 */
9
10 public class cuatro {
12 /**
13 * Creates a new instance of <code>cuatro</code>.
14 */
15 public cuatro() {
16 }
17
18 /**
20 */
23
24 double approx = 0, a;
25 int i,n;
26 //
27 System.out.print("\nEste programa calcula una aproximacion");
28 System.out.print("\ndel valor de PI usando la formula de");
29 System.out.print("\nBailey - Borwein - Plouffe...");
30 System.out.print("\nIntroduce el valor de n: ");
32 //
33 for (i = 0 ; i < n ; i++){
34 a = approx;
35 approx=approx+(4.0/(8.0 * i + 1.0)-2.0/(8.0 * i + 4.0)
36 - 1.0/(8.0 * i + 5.0) - 1.0/(8.0 * i + 6.0)) *
37 Math.pow(1.0/16.0,i);
38 System.out.print("\nIteracion " + (i+1) + " = " + approx);
39 if (a == approx){
40 System.out.print("\n\nSolamente se realizaron "
41 + i + " iteraciones\n");
42 System.out.print("porque el valor de la
43 aproximación no cambia.\n");
44 break;
45 }
46 }// Termina el for...
47 System.out.print("\n\n\nEl valor aproximado es: " + approx);
48 }
49 }

2.3 Factoriales y aproximación del número e 25
2.3 FACTORIALES Y APROXIMACIÓN DEL

NÚMERO e
Objetivo: Escribir en ANSI-C un programa que calcula una aproximación de e

utilizando su expansión Taylor ecuación:
1 1 1
1+1+ + + + ···
2! 3! 4!
así que el usuario controle de alguna manera la exactitud de la aproximación.
1 /**
2 * @(#)cinco.java
3 *
4 *
5 * @author: Efraín Soto Apolinar.
6 * @date: 27 de marzo de 2008
7 */
9
10 public class cinco {
12 /**
13 * Creates a new instance of <code>cinco</code>.
14 */
15 public cinco() {
16 }
17
18 /**
20 */
23 double e = 0, approx;
24 int i, j, n;
25 double factorial;
26 //
27 System.out.print("\nEste programa calcula una aproximacion");
28 System.out.print("\ndel valor de la base neperiana");
29 System.out.print("\nusando la serie de MacLaurin...");
30 System.out.print("\nIntroduce el numero de iteraciones: ");
31 //
33 //
34 for (i = 0 ; i <= n-1 ; i++){// Iteraciones...
35 // reinicio el factorial...

26 Códigos
36 factorial = 1.0;
37 approx = e;
38 for (j = 1; j <= i; j++){ // calculo el factorial...
39 factorial *= 1.0 / j;
40 }
41 e += factorial;
42 if (approx == e){
43 System.out.print("\n\nSolamente se realizaron "
44 + i + " iteraciones\n");
45 System.out.print("porque el valor de la aproximación
46 no cambia.\n");
47 break;
48 }
49 System.out.print("\nIteracion " + (i+1) + " ---> " + e);
50
51 }// Termina el for...
52 System.out.print("\n\n\nEl valor aproximado es: "
53 + e + "\n\n\n");
54 }
55 }
56
2.4 COEFICIENTES BINOMIALES Y EL TRIÁN-

GULO DE PASCAL
Objetivo: Escribir un programa en java que produce, según la elección del

usuario, o el coeficiente binomial C (n, k ), definido como:

n n!
=
k k ! (n − k )!
con valores de n y k definidos por el usuario, (por ejemplo C (31, 5) = 169 911)
o las primeras n líneas del triángulo de Pascal: el elemento número k la línea
número n del triángulo es exactamente C (n, k ).
1 /**
2 * @(#)ocho.java
3 *
4 *
5 * @author: Efraín Soto A.

2.4 Coeficientes binomiales y el triángulo de Pascal 27
6 * @date: 27 de marzo de 2008

7 */
9
10 public class ocho {
12 /**
13 * Creates a new instance of <code>ocho</code>.
14 */
15 public ocho() {
16 }
17
18 /**
20 */
22 int i,j,n; // contadores
23 long[] now = new long[100]; // coeficientes actuales
24 long[] b4 = new long[100]; // coeficientes anteriores
25 //
26 System.out.print("\n\nEste programa imprime los renglones del");
27 System.out.print("\ntriangulo de Pascal...");
28
29 for(;;){
30 System.out.print("\n\nIndique el numero de renglones a
31 imprimir: ");
33 if (n > 99){
34 System.out.print("\n\nEl valor de n no debe ser mayor
35 a 99...");
36 System.out.print("\nIntente de nuevo...");
37 }
38 else{
39 break;
40 }
41 } // endfor...
42 // reinicio los arreglos
43 for (i = 0 ; i < 100 ; i++){
44 now[i] = 0;
45 b4[i] = 0;
46 }
47
48 // inicio con los coeficientes binomiales...
49 System.out.print("\t1\n\n");
50 for (j = 1 ; j < n ; j++){ // Renglones...
51 // reinicio los valores de los arreglos...
52 now[0] = 1;
53 b4[0] = 1;
54 b4[1] = j - 1;
55 System.out.print("\t1"); // primer valor del renglon
56
57 for (i = 1 ; b4[i+1] != 0 ; i++){ // Coeficientes
58 now[i] = b4[i] + b4[i-1];
59
60 if (now[i] <= 0){ // verifico valor negativo...
61 System.out.print("\n\n\nLo siento... se sobrepaso
62 la memoria...\n");

28 Códigos
63 return;
64 }
65 System.out.print ("\t " + now[i]);
66 }
67
68 now[i+1] = 1; // imprimo el ultimo valor del renglon...
69 System.out.print("\t " + now[i+1]);
70
71 for(i = 0 ; i <= j+1 ; i++){ // transfiero la informacion
72 b4[i] = now[i];
73 }
74 System.out.print("\n");
75 }
76 }
77 }

2.5 Programas de muestra 29
2.5 PROGRAMAS DE MUESTRA

En esta sección incluyo programas sencillos que estuve elaborando en las va-
caciones de semana santa del 20092 .
2.5.1 Novia
Este programa muestra cómo mostrar información a través de la pantalla y

cómo leer datos desde el teclado.
1 /*
2 * Archivo: Novio.java
3 * Descripción:
4 * Este programa permite dar un caracter
5 * y leerlo para procesarlo.
6 * Autor: Efraín Soto Apolinar
7 * Fecha: 06/Abr/09
8 *
9 **/
10
11 import java.io.*;
12 public class Novio{
13 public static void main(String [] args){
14 BufferedReader r=new BufferedReader(new
15 InputStreamReader(System.in));
16 System.out.println("Hola a todos.");
17 System.out.println("¿Tienes novia? [S/N]");
18 char respuesta = ’ ’;
19 try{
20 respuesta = r.readLine().charAt(0);
21 }catch(Exception ex){};
22 if (respuesta == ’s’ || respuesta == ’S’){
23 System.out.println("Tu te lo pierdes...");
24 System.out.println("y yo me lo ahorro...");
25 }
26 else{
27 System.out.println("Lastima que soy ajeno...");
28 }
29 System.out.println("\n\n");
30 System.out.println("Hasta la vista, Baby.");
31
32 }
33 }
2 Del 06 al 17 de abril del 2009.

30 Códigos
2.5.2 Mensajes
Este programa manda mensajes a través de la pantalla y muestra una ventana

para enviar un mensaje al usuario.
1 /* Archivo: Mensajes.java
2 * Descripción:
3 * Este programa es una ayuda en el auxilio del
4 * aprendizaje del envio de mensajes al monitor en Java
7 **/
8
9 import java.io.*;
10 import javax.swing.*;
11
12 public class Mensajes{
13 public static void main(String[] args){
14 System.out.println("Este es un mensaje en Java...");
15 System.out.println("Java funciona muy bien...");
16 System.out.println("Java sirve para muchas cosas...");
17 System.out.println("Adios.");
18 JOptionPane.showMessageDialog(null, "Que te parece?");
19 }
20 }
2.5.3 Tu Nombre
Este programa permite al usuario introducir un nombre y envia un mensaje a

través de una ventana.
2 public class Nombre {
4 String tuNombre; // Aqui va tu nombre...
5 tuNombre = JOptionPane.showInputDialog(null,
6 "Cual es tu nombre?");
7 JOptionPane.showMessageDialog(null,
8 "Mucho gusto en conocerte, " + tuNombre);
9 }
10 }

2.5.4 Diálogo
Este programita muestra una caja con un mensaje al usuario.
1 /*
2 * Archivo: Dialogo.java
3 * Este programa indica como se pueden
4 * enviar mensajes por la pantalla a un usuario
5 * Autor: Efrain Soto Apolinar
6 * Fecha: 06 de abril de 2009
7 */
9 public class Dialogo {
12 "Este es un mensaje importante...");
13 }
14 }
2.5.5 Entero
Este programa pide al usuario un entero. En caso de que no introduzca un

entero envia un mensaje de error y vuelve a pedir el entero.
1 /*
2 * Archivo: Entero.java
3 * Descripción:
4 * Este programa verifica que la cadena
5 * ingresada por el usuario corresponda
6 * a un entero.
7 * Fuente: 00Java Manual.PDF
9 *
10 **/
12 public class Entero{
14 Verificador v = new Verificador();
15 int z = v.getInt("Introduce un numero entero...");
16 System.out.println("\n\nz = " + z);
17 }
18 }
19 class Verificador{
20 public static int getInt(String mess) {
21 int val;
22 while (true) { // hasta que obtenga un int valido
23 String s = JOptionPane.showInputDialog(null, mess);

32 Códigos
24 try {
25 val = Integer.parseInt(s);
26 break; // Salir del ciclo infinito...
27 }catch (NumberFormatException nx) {
29 "Error en argumento...");
30 }
31 }
32 return val;
33 }//end getInt
34 }
2.5.6 Fibonacci (V.2)
1 /*
2 * Archivo: Fibonacci.java
3 * Descripción:
4 * Este programa genera la sucesión de
5 * Fibonacci
7 */
9 class Fibonacci {
11 int b4 = 0;
12 int now = 1;
13 int i;
14 int n;
15 Verificador v = new Verificador();
16 System.out.println("\n\nCuantos terminos de la sucesion");
17 System.out.print("de Fibonacci desea que se impriman? ");
18 for (;;){
19 n = v.getInt("Introduce un numero entero positivo...");
20 if (n <= 0){
22 System.out.println("Por favor, intente de nuevo.");
23 System.out.println("Introduzca un entero positivo...\n");
24 }
25 break;
26 } // end for
28 for (i = 0 ; i <= n ; i++) {
29 System.out.println("a_" + i + " = " + now);
30 now = b4 + now;
31 if (now < 0){
32 System.out.println("\n\nSe ha rebasado la memoria...");
33 System.out.println("\nSe han impreso los primeros " + i);
34 System.out.println("terminos de la serie...\n\n");
35 break; // salir del ciclo...
36 }
37 b4 = now - b4;
38 }

39 System.out.println("\nAdios...\n");
40 }
41 }
42
43 class Verificador{
44 public static int getInt(String mess) {
45 int val;
46 while (true) { // hasta que obtenga un int valido
47 String s = JOptionPane.showInputDialog(null, mess);
48 try {
50 break; // Salir del ciclo infinito...
54 }
55 }
56 return val;
57 }//end getInt
58 }
2.5.7 Strings
El siguiente programa separa el cadenas de caracteres usando el espacio para

reconocer dónde empieza una palabra.
1 /**Arhivo: Names.java
2 * Descripción:
3 * este programa divide una cadena de
4 * caracteres en palabras, usando el
5 * espacio en blanco como criterio de
6 * separación.
7 * Autor: Efraín Soto Apolinar.
8 * Fecha: 08/Abr/09.
9 */
10 public class Names{
12 String nombre = "Efrain Soto Apolinar";
13 String nombrePila = "", apPat = "", apMat = "";
14 int size = nombre.length();
15 int i = 0;
16 System.out.print("\nNombre de pila: ");
17 while (nombre.charAt(i) != ’ ’){
18 System.out.print(nombre.charAt(i));
19 nombrePila = nombrePila + nombre.charAt(i);
20 i++;
21 }
22 i++;
23 System.out.print("\nApellido Paterno: ");

34 Códigos
24 while (nombre.charAt(i) != ’ ’){

26 apPat = apPat + nombre.charAt(i);
27 i++;
28 }
29 i++;
30 System.out.print("\nApellido Materno: ");
31 while (i != size){
33 apMat = apMat + nombre.charAt(i);
34 i++;
35 }
36 System.out.println("\n");
37 System.out.println("Va de nuez:");
38 System.out.println("\nNombre de pila: " + nombrePila);
39 System.out.println("\nApellido Paterno: " + apPat);
40 System.out.println("\nApellido Materno: " + apMat);
42 }
43 }
2.5.8 IgnoreSpaces
1 /**Archivo: IgnoreSpaces.java
2 * Descripción:
3 * Este programa permite reescribir
4 * una cadena de caracteres omitiendo
5 * los caracteres.
7 * Fecha: 08/Abr/09.
8 */
9
10 public class IgnoreSpaces{
12 String cadena = "2 * sin(x) + 1.5";
13 String chain = "";
14 int size = cadena.length();
15 for (int i = 0 ; i < size ; i++){
16 if (cadena.charAt(i) != ’ ’){
17 chain += cadena.charAt(i);
18 }
19 }
20 System.out.println("\ncadena = " + cadena);
21 System.out.println("\ncadena sin espacios = " + chain);
23 }
24 }

2.5.9 AlReves
1 /**Archivo: Backwards.java
2 * Descripción:
3 * Este programa reescribe una cadena de
4 * caracteres en orden inverso.
7 */
8
9 public class Backwards {
11 String cadena = "Que pex compadre... No manches!!!";
12 String alReves = "";
13 int size = cadena.length();
14 for (int i = size - 1 ; i >= 0 ; i--){
15 alReves += cadena.charAt(i);
16 }
17 System.out.println("\ncadena = " + cadena);
18 System.out.println("alReves = " + alReves);
19 }
20 }
2.5.10 CuentaPalabras
1 /**Archivo: CuentaPalabras.java
2 * Descripción:
3 * Este programa cuenta cuántas palabras tiene una cadena
4 * de caracteres usando el caracter ’ ’ como separador
5 * entre palabras: numPalabras = numEspacios + 1;
8 */
9 public class CuentaPalabras{
11 String texto = "Un dia caperucita paso ";
12 texto += "por el bosque cuando el lobo...";
13 int size = texto.length();
14 int numPalabras = 1;
15 int i = 0;
16 while (i < size){
17 if (texto.charAt(i) == ’ ’ && texto.charAt(i+1) != ’ ’){
18 numPalabras++;
19 }
20 i++;
21 }
22 System.out.println("\n\nnumPalabras = " + numPalabras);
23 System.out.println("Adios\n\n");
24 }
25 }

36 Códigos
2.5.11 CountLetter
1 /**Archivo: CountLetter.java
2 * Descripción:
3 * Este programa cuenta cuántas veces aparece
4 * una letra en una cadena.
7 */
8
10
11 public class CountLetter{
13 String cadena = "";
14 char caracter = ’ ’;
15 int total = 0;
16 cadena = JOptionPane.showInputDialog(null,
17 "Introduce una cadena de caracteres");
18 caracter = (JOptionPane.showInputDialog(null,
19 "Indica el caracter a contar en la cadena:")
20 ).charAt(0);
21 for (int i = 0 ; i < cadena.length() ; i++){
22 if (cadena.charAt(i) == caracter){
23 total++;
24 }
25 }
26 System.out.println("\nEn total aparece " + total +
27 " veces la letra ’" + caracter + "’");
28 System.out.println("en la cadena: " + cadena);
30 "En total aparece: " + total + " veces la ’"
31 + caracter + "’");
32 }
33 }
2.5.12 LetterArithmetics
1 /**Archivo: LetterArithmetics.java
2 * Descripción:
3 * Este programa muestra la forma en que se
4 * pueden hacer conversiones de tipo char a
5 * tipo int (entero)
8 */
9
10 public class LetterArithmetics{
12 char letra = ’m’;
13 int valor = (int) letra;

14 System.out.println("La letra " + letra +

15 " tiene el valor: " + valor);
16 System.out.print("En el alfabeto tiene el indice: ");
17 System.out.println(letra - ’a’);
18 }
19 }
2.5.13 Comparar
1 /**Archivo: Comparar.java
2 * Descripción:
3 * Este programa compara dos cadenas de
4 * caracteres (orden alfabético).
5 * Fuente: Think like a Computer Scientist
6 * (Java version)
7 * Modificaciones: Efraín Soto Apolinar.
9 */
11 public class Comparar{
13 String name1 = "";
14 String name2 = "";
15 name1 = JOptionPane.showInputDialog(null,
16 "Introduce un nombre (nombre1)");
17 name2 = JOptionPane.showInputDialog(null,
18 "Introduce un nombre (nombre2)");
19 if (name1.equals (name2)) {
20 System.out.println
21 ("Los nombres son el mismo.");
22 }
23 int flag = name1.compareTo (name2);
24 if (flag == 0) {
26 ("Los nombres son iguales");
28 "Los nombres son iguales");
29 } else if (flag < 0) {
31 (name1 + " va antes que " + name2);
33 name1 + " va antes que " + name2);
34 } else if (flag > 0) {
36 (name2 + " va antes que " + name1);
38 name2 + " va antes que " + name1);
39 }
40 }
41 }

38 Códigos
2.5.14 RandomArray
1 /**Archivo: RandomArray.java
2 * Descripción:
3 * Este programa genera un arreglo
4 * de n números pseudoaleatorios
5 * con distribución uniforme.
6 * Referencia: Think like a Computer Scientist
7 * (Java Version)
10 */
12 public class RandomArray{
14 int n = 0;
15 while (true) { // loop until we get a valid int
16 String s = JOptionPane.showInputDialog(null,
17 "Ingrese un numero entero:");
18 try {
19 n = Integer.parseInt(s);
20 break;
24 }
25 }
26 double[] a = new double[n];
27 for (int i = 0 ; i < a.length ; i++){
28 a[i] = Math.random();
29 }
30 System.out.println("\nNumeros pseudoaleatorios:");
31 //double[] p = new RandomArray(10);
33 System.out.println(i + " " + a[i]);
34 }
35 }
36 }
2.5.15 Distribucion
1 /**Archivo: Distribucion.java
2 * Descripción:
3 * Este programa genera 10,000 números
4 * pseudoaleatorios y calcula su
5 * histograma de frecuencias para
6 * tener una idea de su dstribución.
9 */

10
11 public class Distribucion{
12
14 int i, j;
15 double aleatorio;
16 int[] distribucion = new int[8];
17 double ancho = 1.0 / 8.0;
18 for (i = 0 ; i < 100000 ; i++){
19 // generamos un numero pseudoaleatorio
20 aleatorio = Math.random();
21 for (j = 0 ; j < 8 ; j++){
22 // generamos el histograma
23 if ((aleatorio > j * ancho) &&
24 (aleatorio < (j+1) * ancho)){
25 // está en esta clase
26 distribucion[j]++;
27 break;
28 }
29 }
30 }
31 for (j = 0 ; j < 8 ; j++){
32 System.out.println(distribucion[j]);
33 }
35
36 }
37 }
2.5.16 cloneArray
1 /**Archivo: RandomArray2.java
2 * Descripción:
3 * Este programa genera un arreglo
4 * de n números pseudoaleatorios
5 * con distribución uniforme.
6 * Referencia: Think like a Computer Scientist
7 * (Java Version)
10 */
12 public class RandomArray2{
14 int n = 0;
15 while (true) {
16 String s = JOptionPane.showInputDialog(null,
17 "Ingrese un numero entero:");
18 try {
19 n = Integer.parseInt(s);
20 break;

40 Códigos
24 }
25 }
26 double[] a = new double[n];
28 a[i] = Math.random();
29 }
30 System.out.println("\nNumeros pseudoaleatorios:");
31 //
32 // Probamos el metodo cloneArray
33 //
34 double[] clon = cloneArray(a);
35 for (int i = 0 ; i < clon.length ; i++){
36 System.out.println(i + " a[" + i + "] = " + a[i]
37 + "\tclon[" + i + "] = " + clon[i]);
38 }
39 System.out.println("\nAdios...\n\n");
40 }
41 public static double[] cloneArray(double[] a){
42 double[] b = new double[a.length];
43 for (int i = 0 ; i < b.length ; i++){
44 b[i] = a[i];
45 }
46 return b;
47 }
48 }
2.5.17 Cards
1 /**Archivo: Card.java
2 * Descripción:
3 * este programa genera un set de cartas.
6 */
7 public class Card{
8 int suit;
9 int rank;
10 // Constructor...
11 Card(){
12 this.suit = 0;
13 this.rank = 0;
14 }
15 Card(int suit, int rank){
16 this.suit = suit;
17 this.rank = rank;
18 }
20 // programa principal
21 int i, j;
22 String[] suits = { "Clubs", "Diamantes", "Corazones", "Espadas" };

23 String[] ranks = { "noUsed", "As", "2", "3", "4", "5", "6",

24 "7", "8", "9", "10", "Jack", "Reina", "Rey" };
25 // creo el juego de cartas completo...
26 Card[] deck = createCards();
27 // Imprimir las cartas...
28 System.out.println("Cartas: \n");
29 for (i = 0 ; i < 52 ; i++){
30 System.out.println(suits[deck[i].suit]
31 + " , " + ranks[deck[i].rank]);
32 }
33 }
34 public static Card[] createCards(){
35 int index = 0;
36 Card[] deck = new Card [52];
37 for (int suit = 0; suit <= 3; suit++) {
38 for (int rank = 1; rank <= 13; rank++) {
39 deck[index] = new Card (suit, rank);
40 index++;
41 }
42 }
43 return deck;
44 }
45 }
2.5.18 Cards.java
1 /**Archivo: Cards.java
2 * Descripción:
6 */
7
8 public class Cards{
9 int suit;
10 int rank;
12 Cards(){
13 this.suit = 0;
14 this.rank = 0;
15 }
16 Cards(int suit, int rank){
19 }
20
23 int i, j;
25 Cards[] deck = createCards();

42 Códigos
28 for (i = 0 ; i < 52 ; i++){
29 printCard(deck[i].suit, deck[i].rank);
30 }
31 }
32 // Funcion para crear el juego de cartas
33 public static Cards[] createCards(){
34 int index = 0;
35 Cards[] deck = new Cards [52];
38 deck[index] = new Cards (suit, rank);
39 index++;
40 }
41 }
42 return deck;
43 }
44 // Funcion para imprimir las cartas
45 public static void printCard(int suit, int rank){
48 "7", "8", "9", "10", "Jack", "Reina", "Rey" };
49 //
50 System.out.println(suits[suit] + " , " + ranks[rank]);
51 }
52 }
2.5.19 Card3.java
1 /**Archivo: Card3.java
2 * Descripción:
6 */
8 public class Card3{
9 int suit;
10 int rank;
12 Card3(){
13 this.suit = 0;
14 this.rank = 0;
15 }
16 Card3(int suit, int rank){
19 }
20
23 int i, j;

24 int s, r; // datos para la carta a buscar

25 int x;
27 Card3[] deck = createCards();
28
31 for (i = 0 ; i < 52 ; i++){
33 }
34 // pido una carta:
35 s = getInt("Introduzca el suit: ");
36 r = getInt("Introduzca el rank: ");
37 Card3 C = new Card3(s, r);
38 x = findCard(C, deck);
39 if (x != -1){
40 System.out.println("La carta esta marcada...");
41 }
42 else{
43 System.out.println("La carta no se encuentra...");
44 }
45 }
47 public static Card3[] createCards(){
48 int index = 0;
49 Card3[] deck = new Card3 [52];
52 deck[index] = new Card3 (suit, rank);
53 index++;
54 }
55 }
56 return deck;
57 }
60 String[] suits = { "Clubs", "Diamantes", "Corazones", "Espadas"};
62 "7", "8", "9", "10", "Jack", "Reina", "Rey" };
63 //
65 }
66 public static int findCard(Card3 C, Card3[] deck){
67 for(int i = 0 ; i < deck.length ; i++){
68 if (C.suit == deck[i].suit && C.rank == deck[i].rank){
69 return i;
70 }
71 }
72 return -1;
73 }
74 public static int getInt(String mensaje) {
75 int val;
76 while (true) {
77 String s = JOptionPane.showInputDialog(null, mensaje);
78 try {
80 break;

44 Códigos

84 }
85 }
86 return val;
87 }//end getInt
88
89 }
Las siguientes líneas de código muestran la función que compara dos cartas.
1 // Funcion para encontrar una carta

2 public static int findCard(Card3 C, Card3[] deck){
3 for(int i = 0 ; i < deck.length ; i++){
4 if (compareCard(C,deck[i]) == 1){
5 return i;
6 }
7 }
8 return -1;
9 }
10 //
11 // Funcion para comparar dos cartas
12 //
13 public static int compareCard(Card4 C1, Card3 C2){
14 if (C1.suit == C2.suit && C1.rank == C2.rank){
15 return 0;
16 }
17 else{
18 return -1;
19 }
20 }
Puedes agregar este código al programa anterior para probar qué tal funciona.
Recuerda eliminar la función findCard del programa original.
2.5.20 Card4.java
1 /**Archivo: Card4.java
2 * Descripción:
6 */

7 public class Card4{

8 int suit;
9 int rank;
11 Card4(){
12 this.suit = 0;
13 this.rank = 0;
14 }
15 Card4(int suit, int rank){
18 }
19
22 int i, j;
23 int s, r; // datos para la carta a buscar
24 int x, y;
26 Card4[] deck = createCards();
27 // Barajar las cartas
28 deck = swapDeck(deck);
31 for (i = 0 ; i < 52 ; i++){
33 }
34
35
36 }
38 public static Card4[] createCards(){
39 int index = 0;
40 Card4[] deck = new Card4 [52];
43 deck[index] = new Card4 (suit, rank);
44 index++;
45 }
46 }
47 return deck;
48 }
49 public static Card4[] swapDeck(Card4[] deck){
50 int i,j;
51 int x; // random number
52 int size = deck.length;
53 Card4 temp = new Card4();
54 for (i = 0 ; i < size ; i++){
55 x = (int)(Math.random() * size) % (size - 1);
56
57 // intercambio las cartas:
58 temp.suit = deck[i].suit;
59 temp.rank = deck[i].rank;
60 //
61 deck[i].suit = deck[x].suit;
62 deck[i].rank = deck[x].rank;
63 deck[x].suit = temp.suit;

46 Códigos
64 deck[x].rank = temp.rank;
65 }
66 return deck;
67 }
68
73 "7", "8", "9", "10", "Jack", "Reina", "Rey" };
74 //
76 }
77 }
2.5.21 Complex
1 /**Archivo: Complex.java
2 * Descripción:
3 * Implementa la clase Complex
4 * para trabajar con números complejos
7 */
8 public class Complex{
9 double re, im;
10 // Constructor
11 Complex(){
12 this.re = 0.0;
13 this.im = 0.0;
14 }
15 // Otro Constructor
16 Complex(double real, double imaginary){
17 this.re = real;
18 this.im = imaginary;
19 }
20
21 // Object method
22 public double modulus(){
23 return Math.sqrt(re * re + im * im);
24 }
25 // Object Method
26 public Complex conjugado(){
27 return new Complex(re, -im);
28 }
29 // Class Method
30 // Nota las diferencias:
31 // 1: static
32 // 2. c.re * c.re + c.im * c.im
33 public static double modulo(Complex c){
34 return Math.sqrt(c.re * c.re + c.im * c.im);
35 }

36 // Class Method
37 public static Complex sumar(Complex C1, Complex C2){
38 return new Complex (C1.re + C2.re, C1.im + C2.im);
39 }
40 // Class Method
41 public static Complex multiplicar(Complex C1, Complex C2){
42 return new Complex(C1.re * C2.re - C1.im * C2.im,
43 C1.re * C2.im + C1.im * C2.re);
44 }
45 // Class Method
46 public static Complex dividir(Complex C1, Complex C2){
47 if (C2.re == 0 && C2.im == 0){
48 System.out.println("Division entre cero...");
49 System.out.println(
50 "public static divide(Complex C1, Complex C2)");
51 return new Complex();
52 }
53 double r = C2.modulus();
54 Complex C = new Complex();
55 C = multiplicar(C1, C2.conjugado());
56 C.re /= r;
57 C.im /= r;
58 return C;
59 }
60 public static void printComplex(Complex c){
61 System.out.println(c.re);
62 if (c.im > 0){
63 System.out.println(" + i " + c.im + ".");
64 }
65 else{
66 System.out.println(" - i " + (-1* c.im) + ".");
67 }
68 }
69 public static boolean sonIguales(Complex z1, Complex z2){
70 if (z1 == null || z2 == null){
71 return false;
72 }
73 else{
74 return (z1.re == z2.re && z1.im == z2.im);
75 }
76
77 }
78 }
2.5.22 Fraccion
1 /**Archivo: Fraccion.java
2 * Descripción:
3 * Este archivo implementa la clase
4 * Fracción para trabajar con fracciones.

48 Códigos
7 */
8 public class Fraccion{
9 int num;
10 int den;
11 // Constructor
12 public Fraccion(){
13 num = 0;
14 den = 1;
15 }
16 // Constructor
17 public Fraccion(int n, int d){
18 den = d;
19 if (d == 0){
20 System.out.println("Error en argumento");
21 System.out.println("Fraccion.den = 0");
22 den = 1;
23 }
24 num = n;
25 }
26 // Object Method
27 // El signo:
28 // acomodarlo en el numerador
29 public Fraccion verificaSigno(){
30 if (num * den > 0){
31 num = Math.abs(num);
32 den = Math.abs(den);
33 }
34 else{
35 num = -1 * Math.abs(num);
36 den = Math.abs(den);
37 }
38 return this;
39 }
40 // Object Method
41 public Fraccion Reciproco(){
42 if (num == 0){
43 System.out.println("Error en argumento");
44 System.out.println("Fraccion.den = 0");
45 }
46 else{
47 den = num;
48 num = den;
49 }
50 this.verificaSigno();
51 return this;
52 }
53 // Object Method
54 // simplifica la fraccion
55 public Fraccion simplificar(){
56 int divisor = 3;
57 while (num % 2 == 0 && den % 2 == 0){
58 num /= 2;
59 den /= 2;
60 }
61 while(divisor >= num || divisor >= den){
62 if (num % divisor == 0 && den % divisor == 0){
63 num /= divisor;

64 den /= divisor;
65 }
66 else{
67 divisor += 2;
68 }
69 }
70 this.verificaSigno();
71 return this;
72 }
73 // Object Method
74 // Convierte la fracción a un número
75 // con parte decimal...
76 public double real(){
77 double r = 1.0 * num / (1.0 * den);
78 return r;
79 }
80
81 // Class Method
82 public static Fraccion sumar(Fraccion f1, Fraccion f2){
83 Fraccion r = new Fraccion();
84 r.num = f1.num*f2.den + f1.den*f2.num;
85 r.den = f1.num*f2.den;
86 r = r.simplificar();
87 r.verificaSigno();
88 return r;
89 }
90 // Class Method
91 public static Fraccion Restar(Fraccion f1, Fraccion f2){
93 r.num = f1.num*f2.den - f1.den*f2.num;
94 r.den = f1.num*f2.den;
97 return r;
98 }
99 // Class Method
100 public static Fraccion Multiplicar(Fraccion f1, Fraccion f2){
102 r.num = f1.num*f2.num;
103 r.den = f1.den*f2.den;
106 return r;
107 }
108 // Class Method
109 public static Fraccion Dividir(Fraccion f1, Fraccion f2){
111 r.num = f1.num*f2.den;
112 r.den = f1.den*f2.num;
115 return r;
116 }
117 public static void printFraccion(Fraccion f){
118 System.out.println(f.num + " / " + f.den + ".");
119 }
120 public static boolean sonIguales(Fraccion f1, Fraccion f2){

50 Códigos
121 f1.verificaSigno();
122 f2.verificaSigno();
123 return (f1.num == f2.num && f1.den == f2.den);
124 }
125 }
2.5.23 Estructura
1 /**Archivo: Estructura.java
2 * Descripción:
3 * Este archivo contiene la estructura
4 * de una clase.
7 */
8
9 class Estructura{
10 // variables de la isntancia (campos)
11 int i, j;
12
13 // Constructores
14 Estructura(){
15 i = 0;
16 j = 0;
17 }
18 Estructura(int x, int y){
19 i = x;
20 j =y;
21 }
22
23 // Métodos de los Objetos
24 public Estructura sumar(Estructura y){
25 return new Estructura(i+y.i, j+y.j);
26 }
27
28 // Métodos de la clase
29 public static Estructura sumar(Estructura x, Estructura y){
30 return new Estructura(x.i + y.i, x.j + y.j);
31 }
32
33 }

Tres
Gráficos

52 Gráficos
3.1 SWING
En esta sección se incluyen códigos de programas que utilizan el paquete swing
de java.
3.1.1 HelloWorld
1 /**Archivo: HelloWorld.java
2 * Descripcion:
3 * Implementa el clásico: "Hola Mundo"
4 * usando swing
7 */
8
10
11 public class HelloWorld extends JFrame{
13 new HelloWorld();
14 }
15
16 public HelloWorld(){
17 this.setSize(300,300);
18 this.setLocation(125,75);
19 this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
20 this.setTitle("Hola Mundo!");
21 //this.setResizeable(true);
22
23 this.setVisible(true);
24 }
25 }
3.1.2 HelloPanel
1 /**Archivo: HelloPanel.java
2 * Descripcion:
3 * Se ejemplifica el uso de las clases:
4 * - JFrame: para crear ventanas
5 * - JPanel: para crear paneles
6 * - JLabel: para crear etiquetas
9 */
10

3.1 Swing 53
12 import java.awt.*;
13
14 public class HelloPanel extends JFrame{
16 new HelloPanel();
17 }
18
19 public HelloPanel(){
21 this.setTitle("Este es un frame!");
23 // contuir un panel:
24 JPanel miPanel = new JPanel();
25 // Arreglo la etiqueta al centro del Panel
26 miPanel.setLayout(new BorderLayout());
27 // construir etiqueta:
28 JLabel hola = new JLabel("Mi primer etiqueta!");
29 // Agregar etiqueta al panel:
30 miPanel.add(hola, BorderLayout.NORTH);
31 // Agregar el panel al frame:
32 this.getContentPane().add(miPanel);
33 //
34 this.setLocationRelativeTo(null); // centrado...
36 }
37 }
3.1.3 MyJButton
1 /**Archivo: MyJButton.java
2 * Descripcion:
3 * Se ejemplifica el uso de las clases:
4 * - JFrame: para crear ventanas
5 * - JPanel: para crear paneles
6 * - JButton: para crear botones
9 */
10
12
13 public class MyJButton extends JFrame{
15 new MyJButton();
16 }
17
18 public MyJButton(){
20 this.setTitle("Frame con boton!");
22 // contuir un panel:

54 Gráficos
23 JPanel miPanel = new JPanel();

24 // construir un botón:
25 JButton boton = new JButton();
26 // Agrego mensaje al boton:
27 boton.setText("Un Boton!");
28 // Mensaje del botón al usuario
29 boton.setToolTipText("No hace nada!");
30 // Agregar etiqueta al panel:
31 miPanel.add(boton);
32 // Agregar el panel al frame:
33 this.getContentPane().add(miPanel);
34 //
35 this.setLocationRelativeTo(null); // centrado...
37 }
38 }

Indice alfabético
Algoritmo, 8 Lenguaje java., 23

Tarea 5
Código, 9 Lenguaje java., 25
Coeficientes binomiales, 26
Compilador, 8 Variable
Compilar, 9 Definición, 11
Correr, 9
Error
de Sintaxis, 10
Lógico, 10
Mensajes de, 10
Identificador, 10
Programa, 8
Sintaxis, 9
Tarea 1
Lenguaje java, 18
Tarea 2
Lenguaje java., 20
Tarea 3
Lenguaje java., 22
Tarea 4

56 INDICE ALFABÉTICO
TÉRMINOS DE USO
Utiliza los códigos como una guía para aprender a programar.
No hay ninguna garantía de que los códigos estén libres de cualquier tipo de
error.
Efraín Soto Apolinar no es responsable por cualesquiera daños (directos, indi-

rectos, causales, etc.) ocasionados por el uso de este material.
Tienes derecho de leer el material y de divulgarlo a otras personas, con la única

condición de que no modifiques el documento en forma alguna.
Si deseas utilizar alguna parte del material, puedes hacerlo, con la única condi-
ción de que menciones la fuente, i.e., este material y a Efraín Soto Apolinar
como el autor.
Espero que este material pueda ser de ayuda a muchas personas que desean
aprender a programar en Java.
Con estos programas estoy aprendiendo junto contigo.
En realidad el material que estas leyendo lo estoy generando como un resumen

de lo que voy aprendiendo. Voy a utilizarlo en lo futuro como una referencia.
Este material está siendo actualizado continuamente.
Te agradeceré que me envíes un mensaje en caso de que encuentres errores en

los códigos, en las definiciones o en la ortografía y/o gramática del mismo.
El material no ha tenido ninguna revisión. Utilízalo bajo tu propio riesgo.
Efraín Soto Apolinar.

efra.soto.a@gmail.com

CRÉDITOS Créditos
Autor: Efraín Soto Apolinar.
Diseño de portada: Efraín Soto Apolinar.
Edición: Efraín Soto Apolinar.
Composición tipográfica: Efraín Soto Apolinar.
Revisión técnica: Pendiente.
Año de edición: 2009
Año de publicación: Pendiente
Última revisión: 05 de abril de 2009
Software Utilizado: En la edición y composición tipográfica de este material

se han utilizado los siguientes programas:
¬ LATEX 2" Tipografía del texto y ecuaciones.

TikZ Diseño de encabezados y diagramas.
® TEXnicCenter Edición del código LATEX 2" .
¯ JCreator 3.5 LE Edición del código en lenguaje Java.
Apreciado lector, gradezco tus sugerencias y comentarios a la cuenta de correo

electrónico:
efra.soto.a@gmail.com

Codigos Java

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Codigos Java

Uploaded by

Copyright:

Available Formats

CÓDIGOS DE PROGRAMAS

Efraín Soto Apolinar

Efraín Soto Apolinar

Monterrey, N.L., México. 2009

1.1 Conceptos básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.1.1 Conceptos de programación . . . . . . . . . . . . . . . . . . . . . . 8

1.2 Palabras reservadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

1.2.1 Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

1.3 Ventajas de usar Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

1.4.1 If then else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

1.5 Clase Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.1 Programación científica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

PISIS Códigos de programas en java

2.1.1 Sucesión de Fibonacci . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.1.2 Detector de números primos . . . . . . . . . . . . . . . . . . . . . 19

2.1.3 Piedra, papel y tijera . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.3 Factoriales y aproximación del número e . . . . . . . . . . . . . . . . . . 25

2.4 Coeficientes binomiales y el triángulo de Pascal . . . . . . . . . . . . . 26

2.5 Programas de muestra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

2.5.6 Fibonacci (V.2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

Códigos de programas en java PISIS

Códigos de programas en java PISIS

PISIS Códigos de programas en java

1.1 CONCEPTOS BÁSICOS

Se presentan diversas secciones con contenidos igual de importantes. Los primeros

1.1.1 Conceptos de programación

Los conceptos que debes entender para iniciarte en el arte de la programación

Códigos de programas en java PISIS

Algunas veces el compilador no encontrará errores, pero existe la posibilidad

PISIS Códigos de programas en java

Códigos de programas en java PISIS

1.2 PALABRAS RESERVADAS

abstract default if private this

PISIS Códigos de programas en java

Para definir un identificador se deben seguir las siguientes reglas.

ii. Un identificador puede consistir de letras, dígitos, el símbolo _, o el signo

1.2.1 Tipos de datos

Variable Rango Precisión Ejemplo

Códigos de programas en java PISIS

1.3 VENTAJAS DE USAR JAVA

Si sabes programar en C o en C++ aprender java es muy sencillo.

java te ayuda porque no requieres del manejo de memoria, porque utiliza un

En otras palabras, te simplifica latarea como programador.

PISIS Códigos de programas en java

1.4.1 If then else

// codigo que se está ejecuntando...

Códigos de programas en java PISIS

1.5 CLASE MATH

En esta clase se contienen métodos (funciones matemáticas) de uso frecuente

Algunos de los métodos definidos son los siguientes:

PISIS Códigos de programas en java

Códigos de programas en java PISIS

PISIS Códigos de programas en java

2.1 PROGRAMACIÓN CIENTÍFICA

2.1.1 Sucesión de Fibonacci

La serie de Fibonacci se define por la ecuación recursiva siguiente:

Serie de Fibonacci. Este programa permite que el usuario de varios valores de

Enseguida se muestra en código en el lenguaje java.

Códigos de programas en java PISIS

2.1.2 Detector de números primos

Escribir un programa en java1 al cual el usuario define un número entero pos-

Para esta tarea considero la siguiente definición:

PISIS Códigos de programas en java

No se requiere, pero para no dejar a un lado: