Vous êtes sur la page 1sur 59

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

Códigos de programas en java PISIS


Uno
Introducción

PISIS Códigos de programas en java


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.

Códigos de programas en java PISIS


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.

PISIS Códigos de programas en java


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

Definición 1.1.2.11
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 ’_’.

Códigos de programas en java PISIS


1.2 Palabras reservadas 11

Definición 1.1.2.12
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.

Definición 1.1.2.13
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.

PISIS Códigos de programas en java


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

Códigos de programas en java PISIS


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.

PISIS Códigos de programas en java


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...

Códigos de programas en java PISIS


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).

PISIS Códigos de programas en java


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).

Códigos de programas en java PISIS


Dos
Códigos

PISIS Códigos de programas en java


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;

Códigos de programas en java PISIS


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.

PISIS Códigos de programas en java


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 */
9 import java.util.Scanner;
10
11 public class primos {
12 static Scanner input = new Scanner(System.in);
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 */
22 public static void main(String[] args) {
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: ");
30 n = input.nextInt();
31 if (n <= 0){
32 System.out.println("\n\nError en argumento...");
33 System.out.println("Por favor, intente de
34 nuevo...");
35 System.out.println("Introduzca un entero positivo.");
36 continue;

Códigos de programas en java PISIS


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]);

PISIS Códigos de programas en java


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 */
8 import java.util.Scanner;
9
10 public class tres {
11 static Scanner input = new Scanner(System.in);
12 /**
13 * Creates a new instance of <code>tres</code>.
14 */
15 public tres() {
16 }
17
18 /**
19 * @param args the command line arguments
20 */
21 public static void main(String[] args) {
22 // TODO code application logic here
23 int usuario,compu;
24 //

Códigos de programas en java PISIS


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....");
53 System.out.print("\n\nYo gano!!!\n");
54 continue;
55 }
56
57 if (usuario == 3){
58 System.out.print("\n\nyo elijo piedra....");
59 System.out.print("\n\nYo gano!!!\n");
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 π

Enseguida se muestra el código de este programa en el lenguaje java:

PISIS Códigos de programas en java


24 Códigos

1 /**
2 * @(#)cuatro.java
3 *
4 *
5 * @author: Efraín Soto Apolinar
6 * @date: 27 de marzo de 2008.
7 */
8 import java.util.Scanner;
9
10 public class cuatro {
11 static Scanner input = new Scanner(System.in);
12 /**
13 * Creates a new instance of <code>cuatro</code>.
14 */
15 public cuatro() {
16 }
17
18 /**
19 * @param args the command line arguments
20 */
21 public static void main(String[] args) {
22 // TODO code application logic here
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: ");
31 n = input.nextInt();
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 }

Códigos de programas en java PISIS


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.

Enseguida se muestra el código de este programa en el lenguaje java:

1 /**
2 * @(#)cinco.java
3 *
4 *
5 * @author: Efraín Soto Apolinar.
6 * @date: 27 de marzo de 2008
7 */
8 import java.util.Scanner;
9
10 public class cinco {
11 static Scanner input = new Scanner(System.in);
12 /**
13 * Creates a new instance of <code>cinco</code>.
14 */
15 public cinco() {
16 }
17
18 /**
19 * @param args the command line arguments
20 */
21 public static void main(String[] args) {
22 // TODO code application logic here
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 //
32 n = input.nextInt();
33 //
34 for (i = 0 ; i <= n-1 ; i++){// Iteraciones...
35 // reinicio el factorial...

PISIS Códigos de programas en java


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 ).

Enseguida se muestra el código de este programa en el lenguaje java:

1 /**
2 * @(#)ocho.java
3 *
4 *
5 * @author: Efraín Soto A.

Códigos de programas en java PISIS


2.4 Coeficientes binomiales y el triángulo de Pascal 27

6 * @date: 27 de marzo de 2008


7 */
8 import java.util.Scanner;
9
10 public class ocho {
11 static Scanner input = new Scanner(System.in);
12 /**
13 * Creates a new instance of <code>ocho</code>.
14 */
15 public ocho() {
16 }
17
18 /**
19 * @param args the command line arguments
20 */
21 public static void main(String[] args) {
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: ");
32 n = input.nextInt();
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");

PISIS Códigos de programas en java


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 }

Códigos de programas en java PISIS


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.

PISIS Códigos de programas en java


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
5 * Autor: Efraín Soto Apolinar
6 * Fecha: 05/Abr/09
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.

1 import javax.swing.*;
2 public class Nombre {
3 public static void main(String[] args) {
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 }

Códigos de programas en java PISIS


2.5 Programas de muestra 31

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 */
8 import javax.swing.*;
9 public class Dialogo {
10 public static void main(String[] args) {
11 JOptionPane.showMessageDialog(null,
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
8 * Fecha: 06/Abr/09
9 *
10 **/
11 import javax.swing.*;
12 public class Entero{
13 public static void main(String[] args) {
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);

PISIS Códigos de programas en java


32 Códigos

24 try {
25 val = Integer.parseInt(s);
26 break; // Salir del ciclo infinito...
27 }catch (NumberFormatException nx) {
28 JOptionPane.showMessageDialog(null,
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
6 * Fecha: 06/Abr/09
7 */
8 import javax.swing.*;
9 class Fibonacci {
10 public static void main(String[] args) {
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){
21 System.out.println("\n\nError en argumento...");
22 System.out.println("Por favor, intente de nuevo.");
23 System.out.println("Introduzca un entero positivo...\n");
24 }
25 break;
26 } // end for
27 System.out.println("\n\n");
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 }

Códigos de programas en java PISIS


2.5 Programas de muestra 33

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 {
49 val = Integer.parseInt(s);
50 break; // Salir del ciclo infinito...
51 }catch (NumberFormatException nx) {
52 JOptionPane.showMessageDialog(null,
53 "Error en argumento...");
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{
11 public static void main(String[] args){
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: ");

PISIS Códigos de programas en java


34 Códigos

24 while (nombre.charAt(i) != ’ ’){


25 System.out.print(nombre.charAt(i));
26 apPat = apPat + nombre.charAt(i);
27 i++;
28 }
29 i++;
30 System.out.print("\nApellido Materno: ");
31 while (i != size){
32 System.out.print(nombre.charAt(i));
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);
41 System.out.println("\n");
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.
6 * Autor: Efraín Soto Apolinar.
7 * Fecha: 08/Abr/09.
8 */
9
10 public class IgnoreSpaces{
11 public static void main(String[] args){
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);
22 System.out.println("\n\n");
23 }
24 }

Códigos de programas en java PISIS


2.5 Programas de muestra 35

2.5.9 AlReves

1 /**Archivo: Backwards.java
2 * Descripción:
3 * Este programa reescribe una cadena de
4 * caracteres en orden inverso.
5 * Autor: Efraín Soto Apolinar.
6 * Fecha: 08/Abr/09
7 */
8
9 public class Backwards {
10 public static void main(String[] args){
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;
6 * Autor: Efraín Soto Apolinar.
7 * Fecha: 08/Abr/09
8 */
9 public class CuentaPalabras{
10 public static void main(String[] args){
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 }

PISIS Códigos de programas en java


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.
5 * Autor: Efraín Soto Apolinar.
6 * Fecha: 08/Abr/09
7 */
8
9 import javax.swing.*;
10
11 public class CountLetter{
12 public static void main(String[] args){
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);
29 JOptionPane.showMessageDialog(null,
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)
6 * Autor: Efraín Soto Apolinar.
7 * Fecha: 09/Abr/09
8 */
9
10 public class LetterArithmetics{
11 public static void main(String[] args){
12 char letra = ’m’;
13 int valor = (int) letra;

Códigos de programas en java PISIS


2.5 Programas de muestra 37

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.
8 * Fecha: 08/Abr/09
9 */
10 import javax.swing.*;
11 public class Comparar{
12 public static void main(String[] args){
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) {
25 System.out.println
26 ("Los nombres son iguales");
27 JOptionPane.showMessageDialog(null,
28 "Los nombres son iguales");
29 } else if (flag < 0) {
30 System.out.println
31 (name1 + " va antes que " + name2);
32 JOptionPane.showMessageDialog(null,
33 name1 + " va antes que " + name2);
34 } else if (flag > 0) {
35 System.out.println
36 (name2 + " va antes que " + name1);
37 JOptionPane.showMessageDialog(null,
38 name2 + " va antes que " + name1);
39 }
40 }
41 }

PISIS Códigos de programas en java


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)
8 * Fecha: 08/Abr/09
9 * Modificaciones: Efraín Soto Apolinar.
10 */
11 import javax.swing.*;
12 public class RandomArray{
13 public static void main(String[] args){
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;
21 }catch (NumberFormatException nx) {
22 JOptionPane.showMessageDialog(null,
23 "Error en argumento...");
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);
32 for (int i = 0 ; i < a.length ; i++){
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.
7 * Autor: Efraín Soto Apolinar.
8 * Fecha: 08/Abr/09
9 */

Códigos de programas en java PISIS


2.5 Programas de muestra 39

10
11 public class Distribucion{
12
13 public static void main(String[] args){
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 }
34 System.out.println("\n");
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)
8 * Fecha: 08/Abr/09
9 * Modificaciones: Efraín Soto Apolinar.
10 */
11 import javax.swing.*;
12 public class RandomArray2{
13 public static void main(String[] args){
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;
21 }catch (NumberFormatException nx) {

PISIS Códigos de programas en java


40 Códigos

22 JOptionPane.showMessageDialog(null,
23 "Error en argumento...");
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 //
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.
4 * Autor: Efraín Soto Apolinar.
5 * Fecha: 09/Abr/09
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 }
19 public static void main(String[] args){
20 // programa principal
21 int i, j;
22 String[] suits = { "Clubs", "Diamantes", "Corazones", "Espadas" };

Códigos de programas en java PISIS


2.5 Programas de muestra 41

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:
3 * este programa genera un set de cartas.
4 * Autor: Efraín Soto Apolinar.
5 * Fecha: 09/Abr/09
6 */
7
8 public class Cards{
9 int suit;
10 int rank;
11 // Constructor...
12 Cards(){
13 this.suit = 0;
14 this.rank = 0;
15 }
16 Cards(int suit, int rank){
17 this.suit = suit;
18 this.rank = rank;
19 }
20
21 public static void main(String[] args){
22 // programa principal
23 int i, j;
24 // creo el juego de cartas completo...
25 Cards[] deck = createCards();
26 // Imprimir las cartas...

PISIS Códigos de programas en java


42 Códigos

27 System.out.println("Cartas: \n");
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];
36 for (int suit = 0; suit <= 3; suit++) {
37 for (int rank = 1; rank <= 13; rank++) {
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){
46 String[] suits = { "Clubs", "Diamantes", "Corazones", "Espadas" };
47 String[] ranks = { "noUsed", "As", "2", "3", "4", "5", "6",
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:
3 * este programa genera un set de cartas.
4 * Autor: Efraín Soto Apolinar.
5 * Fecha: 09/Abr/09
6 */
7 import javax.swing.*;
8 public class Card3{
9 int suit;
10 int rank;
11 // Constructor...
12 Card3(){
13 this.suit = 0;
14 this.rank = 0;
15 }
16 Card3(int suit, int rank){
17 this.suit = suit;
18 this.rank = rank;
19 }
20
21 public static void main(String[] args){
22 // programa principal
23 int i, j;

Códigos de programas en java PISIS


2.5 Programas de muestra 43

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


25 int x;
26 // creo el juego de cartas completo...
27 Card3[] deck = createCards();
28
29 // Imprimir las cartas...
30 System.out.println("Cartas: \n");
31 for (i = 0 ; i < 52 ; i++){
32 printCard(deck[i].suit, deck[i].rank);
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 }
46 // Funcion para crear el juego de cartas
47 public static Card3[] createCards(){
48 int index = 0;
49 Card3[] deck = new Card3 [52];
50 for (int suit = 0; suit <= 3; suit++) {
51 for (int rank = 1; rank <= 13; rank++) {
52 deck[index] = new Card3 (suit, rank);
53 index++;
54 }
55 }
56 return deck;
57 }
58 // Funcion para imprimir las cartas
59 public static void printCard(int suit, int rank){
60 String[] suits = { "Clubs", "Diamantes", "Corazones", "Espadas"};
61 String[] ranks = { "noUsed", "As", "2", "3", "4", "5", "6",
62 "7", "8", "9", "10", "Jack", "Reina", "Rey" };
63 //
64 System.out.println(suits[suit] + " , " + ranks[rank]);
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 {
79 val = Integer.parseInt(s);
80 break;

PISIS Códigos de programas en java


44 Códigos

81 }catch (NumberFormatException nx) {


82 JOptionPane.showMessageDialog(null,
83 "Error en argumento...");
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:
3 * este programa genera un set de cartas.
4 * Autor: Efraín Soto Apolinar.
5 * Fecha: 09/Abr/09
6 */

Códigos de programas en java PISIS


2.5 Programas de muestra 45

7 public class Card4{


8 int suit;
9 int rank;
10 // Constructor...
11 Card4(){
12 this.suit = 0;
13 this.rank = 0;
14 }
15 Card4(int suit, int rank){
16 this.suit = suit;
17 this.rank = rank;
18 }
19
20 public static void main(String[] args){
21 // programa principal
22 int i, j;
23 int s, r; // datos para la carta a buscar
24 int x, y;
25 // creo el juego de cartas completo...
26 Card4[] deck = createCards();
27 // Barajar las cartas
28 deck = swapDeck(deck);
29 // Imprimir las cartas...
30 System.out.println("Cartas: \n");
31 for (i = 0 ; i < 52 ; i++){
32 printCard(deck[i].suit, deck[i].rank);
33 }
34
35
36 }
37 // Funcion para crear el juego de cartas
38 public static Card4[] createCards(){
39 int index = 0;
40 Card4[] deck = new Card4 [52];
41 for (int suit = 0; suit <= 3; suit++) {
42 for (int rank = 1; rank <= 13; rank++) {
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;

PISIS Códigos de programas en java


46 Códigos

64 deck[x].rank = temp.rank;
65 }
66 return deck;
67 }
68
69 // Funcion para imprimir las cartas
70 public static void printCard(int suit, int rank){
71 String[] suits = { "Clubs", "Diamantes", "Corazones", "Espadas" };
72 String[] ranks = { "noUsed", "As", "2", "3", "4", "5", "6",
73 "7", "8", "9", "10", "Jack", "Reina", "Rey" };
74 //
75 System.out.println(suits[suit] + " , " + ranks[rank]);
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
5 * Autor: Efraín Soto Apolinar
6 * Fecha: 09/Abr/09
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 }

Códigos de programas en java PISIS


2.5 Programas de muestra 47

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.
5 * Autor: Efraín Soto Apolinar.
6 * Fecha: 09/Abr/09

PISIS Códigos de programas en java


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;

Códigos de programas en java PISIS


2.5 Programas de muestra 49

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){
92 Fraccion r = new Fraccion();
93 r.num = f1.num*f2.den - f1.den*f2.num;
94 r.den = f1.num*f2.den;
95 r = r.simplificar();
96 r.verificaSigno();
97 return r;
98 }
99 // Class Method
100 public static Fraccion Multiplicar(Fraccion f1, Fraccion f2){
101 Fraccion r = new Fraccion();
102 r.num = f1.num*f2.num;
103 r.den = f1.den*f2.den;
104 r = r.simplificar();
105 r.verificaSigno();
106 return r;
107 }
108 // Class Method
109 public static Fraccion Dividir(Fraccion f1, Fraccion f2){
110 Fraccion r = new Fraccion();
111 r.num = f1.num*f2.den;
112 r.den = f1.den*f2.num;
113 r = r.simplificar();
114 r.verificaSigno();
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){

PISIS Códigos de programas en java


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.
5 * Autor: Efraín Soto Apolinar.
6 * Fecha: 14/Abr/09
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 }

Códigos de programas en java PISIS


Tres
Gráficos

PISIS Códigos de programas en java


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
5 * Autor: Efraín Soto Apolinar
6 * Fecha: 16/Abr/09
7 */
8
9 import javax.swing.*;
10
11 public class HelloWorld extends JFrame{
12 public static void main(String[] args){
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
7 * Autor: Efraín Soto Apolinar
8 * Fecha: 16/Abr/09
9 */
10

Códigos de programas en java PISIS


3.1 Swing 53

11 import javax.swing.*;
12 import java.awt.*;
13
14 public class HelloPanel extends JFrame{
15 public static void main(String[] args){
16 new HelloPanel();
17 }
18
19 public HelloPanel(){
20 this.setSize(300,300);
21 this.setTitle("Este es un frame!");
22 this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
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...
35 this.setVisible(true);
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
7 * Autor: Efraín Soto Apolinar
8 * Fecha: 16/Abr/09
9 */
10
11 import javax.swing.*;
12
13 public class MyJButton extends JFrame{
14 public static void main(String[] args){
15 new MyJButton();
16 }
17
18 public MyJButton(){
19 this.setSize(300,300);
20 this.setTitle("Frame con boton!");
21 this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
22 // contuir un panel:

PISIS Códigos de programas en java


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...
36 this.setVisible(true);
37 }
38 }

Códigos de programas en java PISIS


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

PISIS Códigos de programas en java


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

Códigos de programas en java PISIS


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