libro de programación i contenido

Contenido ....................................................................................................................... 2 Parte Inicial

................................................................. 2 ENTENDIENDO LA PROGRAMACIÓN

1. Algoritmos ............................................................................................................... 3

2. Datos y Tipos de Datos ........................................................................................... 4

2.1. Variables ........................................................................................................... 4

2.1.1. Nombres apropiados de variables ........................................................... 5

3. Operaciones y Operadores ..................................................................................... 8

3.1. Operadores Relaciónales ................................................................................. 8

3.2. Operadores Aritméticos ................................................................................ 10

3.3. Operadores Alfanuméricos ........................................................................... 14

3.4. Operadores lógicos ......................................................................................... 15

4. Asignaciones .......................................................................................................... 16

5. Problemas propuestos .......................................................................................... 19

6. Entrada y Salida de datos .................................................................................... 21

7. Contadores ............................................................................................................ 25

8. Acumulador o Sumador ....................................................................................... 26

9. Estructuras ............................................................................................................ 27

9.1. Estructuras de Selección ............................................................................... 27

9.2. Estructuras Repetitivas ................................................................................. 33

9.2.1. Estructura de repetición Para (Desde-Hacer) ..................................... 34

9.2.2. Estructura de repetición Mientras ........................................................ 38

9.2.3. Estructura de repetición Repetir .......................................................... 41

10. Problemas propuestos ....................................................................................... 44

................................................................................................................. 47 Segunda Parte

................................................................................................... 47 FLUJO DE DATOS

11. Diagramas de flujos ........................................................................................... 48

12. Reglas para la contrucción de diagramas de flujos ........................................ 49

13. Problemas suplementarios resueltos ................................................................ 51

14. Problemas suplementarios ................................................................................ 60

15. Estructuras condicionales ................................................................................. 61

15.1. Condiciones anidadas .................................................................................... 63

Libro para el Estudio de la Programación en Java “La inteligencia no se mide por la suma de conocimientos adquiridos,

sino por la forma como se comparten esos conocimientos”.

Universidad Politécnica Salesiana del Ecuador Página 1 /620

15.2. Sentencia Case ................................................................................................ 64


17. Estructuras de Repetición ................................................................................. 69

17.1. Estructura For – Do (Para – Hacer) ............................................................ 70

17.2. Ciclo While - Do(Mientras – Hacer) ............................................................ 74

17.3. Ciclo Repeat– Until (Repita – Hasta) ........................................................... 76


19. Problemas Varios ............................................................................................... 88

20. Problemas Propuestos ....................................................................................... 90

................................................................................................................. 104 Tercera Parte

.................................................. 104 PROGRAMACIÓN ORIENTADA A OBJETOS

[LIBRO PARA EL ESTUDIO DE LA PROGRAMACIÓN EN JAVA] Es un trabajo entre estudiantes y docentes, para un mejor entendimiento de la Programación en Java, para nuestros estudiantes de la Universidad Politécnica Salesiana del Ecuador.




Parte Inicial ENTENDIENDO

LA PROGRAMACIÓN




1. Algoritmos

Un algoritmo es una serie de instrucciones para realizar una tarea específica o para obtener un resultado deseado. La forma de un algoritmo o su contenido depende mucho de la destreza o de la lógica de la persona que lo diseña. Existen muchos algoritmos para realizar una sola tarea, de allí se puede valorar a los algoritmos por su eficiencia. Por ejemplo realicemos una serie de pasos para ir al cine.

Metodología 1

Paso1: Obtener Dinero Paso2: Tomar un Taxi Paso3: Comprar los boletos Paso4: Entrar al cine

Para muchas personas este sería los pasos para ir al cine, pero dependiendo los criterios se podría ser un poco más específicos, ejemplo:

Metodología 2

Paso1: Pedir permiso a los padres Paso2: Si obtenemos permiso continuemos. Caso contrario, la tarea no tiene solución Paso3: Obtener dinero Paso4: Si obtenemos dinero continuemos. Caso contrario, la tarea no tiene solución Paso5: Hacemos fila para comprar boletos Paso6: Observamos las películas de estreno Paso7: Si hay una película que agrade, hacemos fila para comprar boletos, caso contrario dejar de hacer la tarea Paso6: Entrar al cine

Para muchas personas talvez no sean los paso adecuados para llegar a ver una película al cine, pero el lector debe simplemente tener el claro cuales son los pasos para llegar a la meta. En el mundo de la informática los pasos para realizar varias tareas son muy elementales para obtener un resultado deseado. Existen muchos lenguajes de programación que hacen esto muy fácil, otros lo hacen más complicado. Los primeros algoritmos que se presentan en este documento, son algoritmos elementales para el buen desarrollo de la lógica de un programador. Cabe recalcar que existen algoritmos mucho más eficientes y que su forma se lo estudia en cursos mas avanzados. El objetivo general de este documentos es el lector tenga los conocimientos básicos para entender un algoritmo y llevar este al lenguaje de programación Java.




2. Datos y Tipos de Datos

Las cosas se definen en la computadora mediante datos, los algoritmos que se diseñan en este documento van operar sobre esos datos. A nivel de la máquina los datos se representan como una serie de bits (dígito 1 ó 0). Los tipos de datos que vamos a manejar a lo largo de este documento son : numéricos y carácter (también llamados alfanuméricos), existen además, los datos de tipo lógicos que solo pueden tener uno de dos valores : verdadero o falso. Los datos numéricos pueden ser de varias clases: enteros, enteros largos, de doble precisión, de simple precisión, de coma flotante, reales; cuya definición depende del lenguaje de programación utilizado. Los datos de tipo carácter o alfanuméricos están compuestos por el conjunto Finito y ordenado de caracteres que la computadora reconoce:

caracteres alfabéticos : A,B,C,.......Z ; a,b,c,.......z

caracteres numéricos : 0,1,2, ......9

caracteres especiales : +, /, *, ?,%,$, #, !, ,ä,¦,{},~,etc.

Una cadena o string es una sucesión de caracteres que se encuentran delimitados por comillas ( " " ó ’ ’, dependiendo del lenguaje de programación). La longitud de la cadena es la cantidad de caracteres que la forma, incluyendo los espacios que son un carácter más. Así: "Guayaquil, Ecuador" es una cadena de longitud 18 "Miércoles 7 de Marzo de 2003" es una cadena de longitud 28 (el 7 y el 2001 no son números ya que pertenecen a la cadena e carácteres) "123456" es una cadena de longitud 6, no es el número 123.456. Sobre "123456" no se puede realizar ninguna operación aritmética como sumar, restar, etc, ya que se trata de una cadena alfanumérica, ya que está entre comillas dobles (“ “) y no entre dobles comillas simples. 145 es un numero entero. 145.254 es un número real. Si tenemos la siguiente expresión 1=2, esta expresión es falsa. La expresión toma un valor boleano. Todos estos datos descritos se llaman datos simples.

2.1. Variables

Toda representación de datos debe tener un nombre, sean estos datos numéricos, alfanuméricos o boleanos, entonces podemos definir como variable al nombre que se da la al contenido o valor de un dato. En términos computacionales podemos decir que el contenido de una variable se almacena un espacio de memoria del computador utilizando una posición específica y única para su almacenamiento. En todo programa de computadora o algoritmos se declaran tantas variables como sea necesario.




2.1.1. Nombres apropiados de variables

Por lo general en los programas de computadoras existen reglas que se deben seguir para realizar procesos, y no queda fuera el nombramiento de las variables. Por eso se debe seguir las siguientes:

El nombre de una variable no puede tener mas de 40 caracteres

El nombre de una variable debe empezar como mínimo una letra (a-z o A-Z)

No pueden contener espacios en blanco

El resto de los dígitos pueden ser números. Se pueden incluir caracteres especiales como el guión.

Nombres correctos de variables

X

C1

Total_Suma

CONTADOR-5

Y145

HF_145_Tem

Cant_Equipos

La_Suma_de_la_cantidad_Total (Suma un total de 28 caracteres)

Nombres incorrectos de variables

Tota Suma

5_contador

145Y

HF_%&

La_Suma_de_la_cantidad_Total_Asignada_1025 (Suma un total de 43 caracteres)

Debemos tomar en cuenta que en varios lenguajes de programación se exige la declaración de las variables que se utilizarán a lo largo de todo su código e inclusive es necesario en tales lenguajes que se inicialice la variable. Pero por lo general toda variable numérica se inicializa con cero, una cadena de caracteres con valor nulo y una variable boleana con falso. Para estar familiarizado con estos lenguajes en los algoritmos también lo vamos a definir.

Así tenemos que para declarar variables en Pseudocódigo se tiene:

Var

Entero N La variable N representa un dato tipo numérico específicamente entero.

Var Real Contador,Suma




También se pueden declarar dos o más variables en la misma línea. En este ejemplo declaramos que la variable Contador y Suma representan datos Tipo numérico reales. Var

String Nombre, Apellidos, Dirección

Declaramos en esta ocasión que las variables Nombres, Apellidos y Dirección son variables de tipo Cadena de Caracteres Var

Boleano bandera

La variable bandera es una variable boleana que toma un valor de verdad (Verdadero o Falso) También se pueden declarar variables de la siguiente forma Var

String Nombre, Apellidos, Dirección Real Contador,Suma

Entero N Boleano bandera

Suponiendo que en cualquier parte de nuestro algoritmo deseamos ingresar estos valores a las siguientes variables: Nombre=”Oscar” Apellidos=”Muñoz” Dirección= ”Quito 1007 y Aguirre” Contador = 5.3 N=5 Bandera = falso Las variables poseen valores adecuados para cada variable. Hay que recordar que la cadena ”1007” que se encuentra en la variable Dirección no es de tipo numérica. Claro está que las variables anteriormente mencionadas no podrán poseer valores similares a los siguientes:

Nombre = "Luis" + 10 Cualquiera de estas sentencias Bandera = 4 causará un error en la Contador = “Oscar” ejecución del programa.




Solución: Se debe verificar cada una de las variables i) 5a, no es una variable ya que no puede empezar con números ii) kL_25, si se puede definir como una variable iii) Suma 1, no es una variable ya que no pueden contener espacios iv) C1, si se puede definir como una variable v) =F_45, no es una variable ya que no puede empezar con el signo igual

Entonces: a) falso b) falso c) verdadero d) falso e)falso

Resp. Literal c

Problema 1.1 Tomando en consideración los siguientes nombres de variables:

i) 5a ii) kL_25 iii) Suma 1 iv) C1 v) =F_45 Entonces es verdad que: a) i y iv son nombres correctos de variables b) ii y v son nombres correctos de variables c) ii o i son nombres correctos de variables y v o iv son nombres correctos de variables d) i es nombre correcto de variable e) i y ii y iii y iv y v son nombres correctos de variables




3. Operaciones y Operadores

Para entender los ejemplos dados en la sección anterior se debe tener conocimiento en como realizar operaciones adecuadas utilizando las variables y operadores correspondientes a cada operación. Generalizando, los operadores son de 4 tipos:

Relacionales

Aritméticos

Alfanuméricos

Lógicos

3.1. Operadores Relaciónales

Los operadores relacionales por lo general poseen la siguiente estructura:

<Expresión1> Operador_Relacional <Expresión2> = valor lógico

Cada uno de los cuales al ser evaluadas devuelven un valor lógico (boleano) que puede ser verdadero o falso, siendo estos:

Operador Representación En Java

Mayor que > >

Menor que < <

Igual a = ==

Menor o igual que <= <=

Mayor o igual que >= >=

Distinto <> !=

Problemas Numéricos operadores lógicos

Operaciones Resultado

5 <= 5 Verdadero

5 <> 5 Falso

5 <> 11 Verdadero

10 <= 100 Verdadero

101 >= 10 Verdadero

10 = 14 Falso

Si A=5

B=4 C=1


A <= 5 Verdadero

5 <> A Falso

A <> 11 Verdadero




B <= C Falso

101 >= B Verdadero

A -B = C Verdadero

En las comparaciones de números solo se debe utilizar la regla de la recta numérica.

Cuando se comparan cadenas alfanuméricos (variables tipo String) se realiza carácter por carácter, siempre empezando desde la izquierda hacia la derecha considerando las siguientes normas:

1. Si las variables o los datos tienen diferente longitud, son diferentes 2. Una variable o dato es menor que otro si tiene una longitud menor y

que tenga el primer carácter igual. 3. Dos o mas variables o datos son iguales si tienen la misma longitud y

los mismos caracteres. 4. Las letras minúsculas son mayores que las mayúsculas. 5. Un carácter numérico es menor que cualquier letra mayúscula o

minúscula

carácter numérico < mayúsculas < minúsculas.

Ejemplos:

Operación Resultado

“A” <= “B” Verdadero

“AAAA” > “AAA” Verdadero

“B” > “AAAA” Verdadero

“B” < “b” Verdadero

“3” < “29” Falso

Toda comparación se la realiza utilizando el valor ASCII (Código Americano Estándar para Intercambio de Información) de cada carácter. El código ASCII es un código en el cual los números de 0 a 255 representan letras, números, signos de puntuación y otros caracteres. El código ASCII está estandarizado para facilitar la transmisión de texto entre varios PC o entre un PC y un dispositivo periférico En el siguiente ejemplo se muestra debajo de cada carácter el código ASCII


“A” <= “B” 65<=66

Verdadero

“B” < “b” 66<98

Verdadero




3.2. Operadores Aritméticos

Todo tipo de operación aritmética se evalúan con los siguientes operadores:

Operador Representación En Java Clase Math

Suma + +

Resta - -

Multiplicación * *

División / /

Potenciación ^ ^ Math.pow(base,expo)

Resultado entero de una división DIV /

Resto de la división entera MOD %

Teniendo la siguiente estructura de evaluación:

<Número1> Operador <Número 2> = Número3

Cuando las expresiones son largas se debe seguir las siguientes normas de prioridades de evaluaciones para los operadores

1. Paréntesis 2. Potencias 3. Productos y Divisiones 4. Sumas y restas 5. Concatenación 6. Relacionales 7. Lógicos

Ejemplos


5 + 8 13

5^2 + 2 25 + 2

27

10 mod 3 1

25 div 4 6

10/2 + 25^(1/2) 5 + 5

10

Si A =5, B=4, C=3


A+2* B 5+8

13

A ^2+2 25+2

27

10 mod 3 1

25 div B 6




Problema 1.2

Dada la siguiente Expresión

Y suponiendo que xy =x^y y que = raíz(y) es equivalente a:

a) x-7( (x^(y-1)-y)/(raiz(x^raiz(y-1))) )+y

b) x-7( (x(y-1)-y)/(raiz(x^raiz(y-1))+x) )+y

c) x-7( (x^(y-1)-y)/(raiz(x raiz(y-1))+x) )+y

d) x-7( (x^(y-1)-y)/(raiz(x^raiz(y-1))+x) )+y

e) Ninguna de las anteriores

Solución:

Si consideramos que xy =x^y y y = raíz(y)

x-7(Expresión) + y La Expresión tiene una división

x-7((Expresión1)/(Expresión2)) + y La Expresión1 consta de xy-1 - y

x-7((x^(y-1)-y)/( raiz(x^raiz(y-1))+x)) + y La Expresión2 consta de xxy

1

Es muy fácil equivocarse en estos tipos de ejercicios por la similitud de sus alternativas, entonces verificando una por una se tiene

a) x-7((x^(y-1)-y)/(raiz(x^raiz(y-1))) )+y Comparando con la ecuación original falta la variable x

x-7((x^(y-1)-y)/(raiz(x raiz(y-1))+x)) + y b) x-7((x(y-1)-y)/(raiz(x^raiz(y-1))+x) )+y

Comparando con la ecuación original falta el operador ^ x-7((x^(y-1)-y)/( raiz(x^raiz(y-1))+x)) + y

c) x-7((x^(y-1)-y)/(raiz(x raiz(y-1))+x))+y

Comparando con la ecuación original falta el operador ^ x-7((x^(y-1)-y)/( raiz(x^raiz(y-1))+x)) + y

d) x-7( (x^(y-1)-y)/(raiz(x^raiz(y-1))+x) )+y

Comparando con la ecuación original es la misma x-7( (x^(y-1)-y)/(raiz(x^raiz(y-1))+x))+y

Resp. Literal d

yxx

yxx

y

y

1

1

7

yxx

yxx

y

y

1

1

7




Problema 1.4

Se tiene el siguiente problema: “Escribir unas instrucciones que calcule el número de horas, minutos y segundos que hay en N segundos”

Solución: Paso1: Se obtiene el valor de N

Paso2: Se asigna a una variable Hora (N div 3600)

Paso3: Se asigna a una variable Minuto (( N mod 3600) div 60)

Paso4: Se asigna a una variable Segundo ( N mod 3600) +(Minutos*60) Paso5: Se Presenta Horas : Minutos : Segundos

Entonces es verdad que:

a) Si se asignaría en el Paso3 Minuto (( N mod 3600) mod 60) el algoritmo cumpliría con su objetivo

b) Si se asignaría en el Paso4 Segundo ( N mod 3600) –(Minutos*60) el algoritmo cumpliría con su objetivo

c) Si se asignaría en el Paso2 Hora (N mod 3600) el algoritmo cumpliría con su objetivo

d) Si se asignaría en el Paso4 Segundo ( N mod 3600) div (Minutos*60) el algoritmo cumpliría con su objetivo

e) El algoritmo cumple con su objetivo

Solución: Reemplazando el valor de las variables A y B se tiene

3*5+5^(6-5)-5-45/(6-5+2)-1 15+5^(1)-5-45/(3)-1

15+5-5-15-1 15+5-5-15-1

-1 comprobamos a) falso b) falso c) falso d) falso e) verdadero

Resp. Literal e

Problema 1.3

Si A=5 y B=6 la siguiente expresión 3*A+5^(B-A)-A-45/(B-A+2)-1

se obtiene:

a) 0 b) 9 c) –2 d) 5 e) -1




Solución: Se pude dar cualquier valor para N, en este caso N=3666

N 3666

Hora 3666 div 3600=1

Minuto (3666 mod 3600) div 60 66 div 60= 1

Segundo ( 3666 mod 3600) +(1*60) 66+60=120

Tendríamos que en 3666 segundos existen 1 Hora, 1 Minuto y 120 Segundos es falso, ya que en 3666 segundos existen 1 Hora, 1 Minuto y 6 Segundos. Así que el algoritmo no cumple con su objetivo.

Debemos probar todas las alternativas.

a) Si se asignaría en el Paso4 Minuto (( N mod 3600) mod 60) el algoritmo cumpliría con su objetivo

N 3666

Hora 3666 div 3600=1

Minuto ( 3666 mod 3600) mod 60 66 mod 60=0

Minuto ( 3666 mod 3600) +(1*60) 66+60=120

Tendríamos que en 3666 segundos existen 1 Hora, 0 Minuto y 120 Segundos es falso.

b) Si se asignaría en el Paso4 Segundo ( N mod 3600) –(Minutos*60) el algoritmo cumpliría con su objetivo

N 3666

Hora 3666 div 3600=1


Segundo ( 3666 mod 3600) -(1*60) 66+60=6

Tendríamos que en 3666 segundos existen 1 Hora, 1 Minuto y 6 Segundos es verdadero.

c) Si se asignaría en el Paso2 Hora (N mod 3600) el algoritmo cumpliría con su objetivo.

N 3666

Hora 3666 mod 3600=66


Segundo ( 3666 mod 3600) +(1*60) 66+60=120





d) Si se asignaría en el Paso4 Segundo ( N mod 3600) div (Minutos*60)el algoritmo cumpliría con su objetivo.

N 3666

Hora 3666 div 3600=1


Segundo ( 3666 mod 3600) div (1*60) 66 div 60=1


a) falso b) falso c) verdadero d) falso e)falso

Resp. Literal c

3.3. Operadores Alfanuméricos

El único operador alfanumérico se utiliza para “unir” o concatenar datos alfanuméricos es del siguiente tipo:

Signo Significado

+ Concatenación

Ejemplos:


"Hola" +” “+ "Mundo" "Hola Mundo"

"145" + "145" "145145"

"Esto " + "es genial !" "Esto es genial ¡"

El lector podrá utilizar este operador solo con variables alfanuméricas. Seria erróneo realizar la siguiente operación:

“HOLA” + 7 Las siguientes operaciones son correctas si consideramos que las variables A, B y C son de tipo string. Si A=”Hola”, B=”Mundo” C=”145”


A +” “+ B "Hola Mundo"

C + C "145145"




3.4. Operadores lógicos

Unas de las operaciones más interesantes a nivel computacional, son las operaciones lógicas. Los operadores lógicos combinan sus operadores de acuerdo con las reglas del álgebra de Boole para producir un nuevo valor que se convierte en el valor de la expresión, puede ser verdadero o falso.

Las expresiones lógicas tienen las siguientes estructuras:

Operador_Lógico <Expresión 1> = valor lógico <Expresión 1> Operador_Lógico <Expresión 2> = valor lógico

Representación Significado

OR Suma lógica (O)

AND Producto lógico (Y)

NOT Negación (NO)

Ejemplos:

Expresión Resultado

Verdadadero AND Falso Falso

NOT Falso Verdad

Verdad OR Falso Verdad

NOT Veradero Falso

Verdad AND Verdad Verdad

Falso OR Verdadero Verdad

Por ejemplo, la expresión: (12 + 5) < 12 OR (7 + 3) = 10 es verdadera.

(12 + 5)<12 OR (7 + 3) = 10 17<12 OR 10 = 10

falso OR verdadero verdadero

La expresión (12 * 5) = 60 AND NOT((3 + 2)=5) es falsa .

(12 * 5) = 60 AND NOT((3 + 2)=5) 60 = 60 AND NOT ((3 + 2)=5) verdadero AND NOT ((5)=5) verdadero AND NOT (verdadero) verdadero AND falso falso




4. Asignaciones

En las secciones anteriores hemos supuestos que las variables contienen algún valor, en un algoritmo la operación de dar valor a una variable se llama asignación.

En la mayoría de los pseudocódigos el símbolo representa a la asignación.

La estructura de la asignación se muestra a continuación:

Variable expresión Si tenemos las siguientes sentencias:

X 5.5 Al leer esta línea de código el lector debe entender que la variable X es de tipo numérica y que se le a asignado el valor de 5.5. al pasar esta línea de código la variable X ahora posee el valor de 5.5

Nombre “Rosita” En este caso tenemos una variable Nombre, la cual se le está asignando una

cadena de caracteres “Rosita” a través del signo

X 5.5

C 0.5 + X También se pueden realizar las asignaciones con los operadores aritméticos, si observamos detenidamente a la variable X se le asigna el valor de 5.5 en primera instancia. Luego a la variable C se le asigna el resultado de la variable X + 0.5. en otras palabras a C se le ha asignado 6.

Talvez el lector tenga la siguiente pregunta. ¿Por qué no utilizar el símbolo “=” para la asignación?. En la sección 3.1 (Operadores Relaciónales) utilizamos el símbolo “=” para comparar dos expresiones. Si utilizamos el mismo símbolo podríamos confundirnos un poco. En la mayoría de los lenguajes de programación se utilizan distintos símbolos para diferenciar la asignación de la comparación. Veamos unos ejemplos:

Leguajes de Programación Símbolo de comparación Símbolo de asignación

Java = :=

Java = = =

C = = =

Visual Basic = =

Símbolo de comparación Símbolo de asignación

Pseudocódigo =

Toda asignación es destructiva. Esto quiere decir que el valor que tuviera antes la variable se pierde y se reemplaza por el nuevo valor que asignamos, así cuando se ejecuta esta secuencia:

B 25

B 100

B 77




el valor Final que toma B será 77 pues los valores 25 y 100 han sido destruidos. Cuando una variable aparece en ambos lados del símbolo de asignación como:

C C + 1 conviene inicializarlas al comenzar el programa con cero debido a que en algunos varios lo hacen necesario. Recordemos que no se pueden asignar valores a una variable de un tipo diferente al suyo.

Pongamos atención a este ejemplo de asignaciones:

A 0

B 1

C 4

A A + 2 * B

B C - A Al Final de estas primeras acciones, A toma el valor 2 y B el valor 2.

C A+2*B La expresión tomará el valor 2 + 2 * 2 = 2 + 4 = 6 C vale entonces 6.

B C – A C vale 6, A vale 2, por lo tanto B valdrá 6 - 2 = 4 Como toda asignación es destructiva, el valor anterior de B se pierde y pasa a valer ahora 4. Otro ejemplo:

J 33 ¿Qué valor tiene J al Final ? Veamos. Primero se asigna 33 a la variable J, J vale entonces 33; luego:

J J + 5 Esto es: Sumar 5 al valor de J y asignarlo a la variable J.

J 33 + 5 ; J = 38 J vale ahora 38. El valor anterior que era 33 se destruyó. Seguimos:

J J * 3 Esto es: Multiplicar 3 al valor de J y asignarlo a la variable J.

J 38 * 3 ; J = 114 El valor Final de J es 114.




Solución: Lo primero que se debe hacer en estos casos es obtener todos los valores de las variables implicadas

A 3

B 12

C 4 Resultado de efectuar la operación 12 div 3=4

D Verdadero Resultado de efectuar la comparación A<>B

F Falso

E Verdadero

El valor de E se lo obtiene

E (B mod A=0) and D and (((C-1) = A) or ( F )) Reemplazando

E (12 mod 3=0) and Verdadero and (((4-1) = 3) or ( Falso ))

E (0=0) and Verdadero and ((3 = 3) or ( Falso ))

E Verdadero and Verdadero and (Verdadero or Falso )

E Verdadero and Verdadero and Verdadero

E Verdadero Comprobamos E = Falso; es falso ya que E es Verdadero E = Verdadero; E es Verdadero D = Falso; es falso ya que D es Verdadero B = (E and A) es una sentencia sin error es falso ya que no se puede asignar a B la operación lógica de verdadero and 3 Todas las anteriores son falsas es falso ya que el literal b es Verdadero Resp. Literal b

Problema 1.5 Considere las siguientes instrucciones:

A 3

B 12

C 12 div A

D A<>B

F Falso

E (B mod A=0) and D and (((C-1) = A) or ( F ))

donde A, B y C son variables numéricas y D, E y F booleanas. Entonces es verdad que:

a) E = Falso b) E = Verdadero c) D = Falso d) B = (E and A) es una sentencia sin error e) Todas las anteriores son falsas




5. Problemas propuestos

1. Dasos los valores correspondientes a las variables A=5 B=7 C=4 Evaluar

( 3 + A) Div B + C ( 7 Div (38 Mod C)) * 5 3 + C* A – 35/7 – B * 33/11 ((1580 MOD 6*2^7) >(7+8*3^4))>((15*2)=60*2/4)

2. Identifique cual de los siguientes nombres pueden ser identificadores (variables)

Suma1 5Suma cont 5 Contador_5 Hf_58 Real String La_Suma_Total_por_Almacen

2. Considere que A,B y C son variables numéricas de tipo entero, E y F variables de tipo real, G de tipo String, H e I de tipo boleano, entonces identifique las sentencias que no causarían errores

A H

A E

E A + F

G 5

A A + B + C*B

G “romanos”

I A – B

I A = B

H NOT (I) Para las sentencias que causarían errores, describa el tipo de error.

3. Si D y E son variables boleanas y A, B y C son variables numéricas determinar los valores de las variables al final de todos los pasos

A 0

B 10

C 10 Div (A + 4)+ A*B-10

D Not (C B)

A B – C

D NOT (A 49) OR (43 – 8* 2 DIV 4 <> 3 * 2 DIV 2)

E (A=B) AND ((C MOD A<= B) OR NOT(( C DIV B) MOD 2 = 0))




4. Describir los pasos para realizar los siguientes problemas: Hacer una llamada telefónica

Preparar una ensalada rusa

Sumar todos los totales de todas las facturas vendidas en un almacén

Obtener el promedio de las calificaciones de la materia programación de un curso dado

Obtener el perímetro y el lado de un cuadrado dado el valor de un lado

Colocar dos litros de agua en un recipiente que tiene una capacidad de cuatro litros tomando en consideración lo siguiente:

Se cuenta con otros dos envases con capacidad de 5 y 3 litros

Se puede desechar el agua al enviar agua de un recipiente a otro

Los envases no poseen medidas

Llevar a un borrego, una col y a un lobo al otro lado de la orilla de un río por medio de una canoa y acompañado de una persona tomando en consideración lo siguiente:

La canoa solo soporta el peso de la persona y a otro acompañante más

El borrego es devorado por el lobo si estos se quedan solos

Si el borrego se queda solo con la col, éste se la come.

Como es una canoa a motor, se desea realizar el número menor de viajes posibles

Colocar los discos que se encuentran en la barra A a la barra C, tal que queden ordenados de la misma manera. Puede utilizar la barra B como puente (describir el menor número de pasos para llegar a la meta)

5. Las siguientes expresiones algebraicas

1 2

3

A B C

yyx

x

2/3

2

1

2

5

yxxy

y

x

yx

x

yx

2

32

yxyx

xyx

x

yx

y

yx

x

u) v)

w) x)




6. Entrada y Salida de datos Los datos que se obtienen del usuario para ser procesados deben ser asignados a las variables declaradas en los programas y estas a los resultados requeridos deben ser presentados. Una operación de lectura por lo general realiza la tarea de leer un dato y luego asignarlo a una variable. La instrucción para la lectura de un dato es Leer o también Ingresar u Obtener. Por ejemplo:

leer (numero) Esta instrucción pide al usuario un valor que será asignado a la variable numero, es decir, en numero se almacena el valor ingresado por el usuario.

leer( Edad, Peso, Sexo) Representa la lectura de tres valores que se van a almacenar en las variables Edad, Peso y Sexo; en ese mismo orden.

Una vez procesada cualquier operación por medio del código se requiere mostrar el resultado del algoritmo, siendo estos: mensajes, valores, etc. Para realizar la operación escritura se utilizará el comando Escribir o Imprimir. Por ejemplo:

Escribir("Hola") ; muestra en la pantalla el mensaje Hola, Hola va entre comillas porque es una cadena de caracteres

Escribir (A); muestra en la pantalla el valor que está almacenado en la variable A. Si A posee el valor de 7, se muestra como resultado el número 7.

Escribir( "El valor de A es:", A); Esta instrucción muestra el mensaje que está entre comillas y luego el valor de la variable A. La coma separa el mensaje de la variable. Si A = 7, lo que se verá en la pantalla será: El valor A es: 7

También se puede mostrar un mensaje cuando solicitamos algún dato al usuario por medio del comando Leer :

Escribir( "Ingrese su edad") Leer(edad) El valor de la variable que pedimos al usuario se asigna a edad. Esta instrucción se verá así en la pantalla:

Ingrese su edad __ El símbolo __ aparece automáticamente cada vez que usamos el comando leer. La escritura de pseudocódigos. Las acciones de lectura y escritura se representan por los siguientes formatos: leer (Variable o lista de variales separadas por comas)




Ejemplos: leer (Edad) leer (Ciudad, Pais) Escribir (Variable o lista de variables separadas por comas) Ejemplos:

Escribir (promedio) Escribir( Mes, Año, Día)

Escribir ("Así se muestra un mensaje o comentario")

En resumen: Las instrucciones disponibles para escribir un programa dependen del lenguaje de programación utilizado. Existen instrucciones -o acciones- básicas que se pueden implementar de modo general en cualquier algoritmo y que soportan todos los lenguajes de programación. Estas son:

Nombre del Algoritmo Variables a utilizar Instrucciones de inicio/Fin Instrucciones de asignación Instrucciones de lectura Instrucciones de escritura

Tipo de Instrucción Pseudocódigo Nombre del Algoritmo Algoritmo Nombre_del_Algoritmo Declaración de Variables Var Entero variable1, variable2 String Nombre, Curso Comienzo de proceso Inicio Fin de proceso Fin Entrada (Lectura) Leer Salida (Escritura) Escribir o Imprimir

Asignación

Resolución de Problemas Antes de resolver un problema por medio de un pseudocódigo, es necesario definirlo y comprenderlo claramente. Leeremos con atención el enunciado del problema y una vez comprendido responderemos a las preguntas:

¿Qué información debe proporcionar la resolución del problema? ¿Cuáles son los datos que necesito para resolver el problema?

La respuesta de la primera pregunta nos dice que salidas va a proporcionar el algoritmo y la segunda qué datos se nos proporcionan para resolver el problema y cuáles debemos calcularlos.

Ejemplo: Leer las longitudes de un rectángulo y calcular la superficie y el perímetro.




Para calcular el área y el perímetro de un rectángulo, se necesitan las medidas del ancho y el alto, estas medidas serán leídas en dos variables. Las salidas serán los valores del área y el perímetro que serán calculados utilizando fórmulas.

Entradas: largo, ancho

Salidas: perímetro, área

Se recuerda que un algoritmo es una serie de pasos que se deben cumplir en forma ordenada. Realicemos los pasos para resolver el problema mensionado.

Paso 1: Obtener el largo y el ancho del rectángulo Paso 2: Asignar a una variable perímetro dos veces su lado mas dos veces su ancho Paso 3: Asignar a una variable área el lado multiplicado por su ancho Paso 4: Presentar El perímetro y el área

El pseudocódigo es:

Ejemplo Escribir un pseudocódigo que intercambie el valor de dos variables. Si se tienen, por ejemplo A = 5 y B = 10, se quiere intercambiar el valor de las variables, así: A = 10; B = 5. No podemos asignar directamente el valor de una a la otra porque uno de los valores se destruiría; de modo que esto no se puede hacer:

A B (el valor de A se pierde y quedaría A = 10 ; B = 10) . La solución consiste en asignar el valor de una de las variables a otra variable auxiliar. Paso 1: Obtener el valor de A y el de B Paso 2: Asignar a una variable Auxiliar el valor de A Paso 3: Asignar a la variable A el valor de la variable B Paso 4: Asignar a la variable A el valor de la variable B Paso 4: Presentar A y Ba

Algoritmo Area_Rectangulo Var Entero largo, ancho, área, perímetro Inicio

leer (largo) leer ( ancho)

perímetro (largo + ancho) * 2

área largo * ancho Escribir(“El perímetro es: ”, perímetro) Escribir(“El área es: ”, área)

Fin

Algoritmo Cambio Var Entero A,B, Auxiliar Inicio

leer (A,B)

Auxiliar A

A B

B Auxiliar Escribir A,B

Fin




Sigamos paso a paso el pseudocódigo: leer A,B ........ Se pide al usuario dos valores. Supongamos que se ha ingresado A = 100 ; B = 5

Auxiliar A ........ Se asigna a Auxiliar el valor 100. Auxiliar vale 100. El valor de las variables es: A B Auxiliar 100 5 100

A B ..... Se asigna a A el valor de B para intercambiar. Ahora el valor de las variables es: A B Auxiliar 5 5 100

B Auxiliar ........ El valor de A que se guardó en Auxiliar se asigna a B para el intercambio. A B Auxiliar 5 100 100

El intercambio está hecho. Luego se imprimen los respectivos valores ya intercambiados con la línea: Escribir(A,B)

Solución: Si tomamos dos valores cualquiera par i y para j en este ejemplo i=3 j =5 entonces el resultado sería i=5 j=3. veamos

Algoritmo Cambio Var Entero i,j

Inicio Leer(i) Leer(j) ---------------------------------

escribir(i) escribir(j)

fin

i i+j

j i - j

i i - j

a)

j i+j

j i - j

i i - j

b)

i i - j

j i - j

i i - j

c)

i i+j

j i+j

i i - j

d)

se tiene que asignar en las líneas las siguientes sentencias:

Problema 1.6 Para que los valores de las variables i,j intercambien sus valores en el algoritmo Cambio




Resp. Literal a

7. Contadores Un contador es una variable destinada a contener valores que se van incrementando o decrementando cada vez que se ejecuta la acción que lo contiene. El incremento o decremento es llamado paso de contador y es siempre constante. Por ejemplo; el marcador de un partido de futbol, cada vez que un equipo anota un gol, aumenta su marcador en una unidad. En las carrera de automóviles, cada vez que un vehículo pasa por la línea de meta, se incrementa en una unidad el número de vueltas dadas al circuito, o bien se hace un decremento en una unidad al número de vueltas que quedan por realizar. Aunque el incremento es siempre constante, el paso de contador no necesariamente puede ser la unidad como en los ejemplos que se han dado más arriba; también puede incrementarse o disminuirse de dos, tres, cuatro,.... n; es decir, puede ser cualquier número que conserva el mismo valor durante todo el programa.

a) Si cumple

i j

i i+j i 3+5 8 5

j i - j j 8 -5 8 3

i i - j i 8 - 3 5 3

b) No cumple

i j

j i+j j 3+5 3 8

j i - j j 3 -8 3 -5

i i - j i 3 – (-5) 8 3

c) No cumple

i j

i i - j i 3-5 -2 5

j i - j j -2 -5 -2 -7

i i - j i -2-(-7) -2 5

d) No cumple

i j

i i+j i 3+5 8 5

j i+j j 8 +5 8 13

i i - j i 8 - 13 -5 13




La sintaxis de una variable contador es:

variable variable + constante (al incrementar)

variable variable - constante (al decrementar) Ejemplos:

gol_local gol_local + 1

vueltas vueltas + 1

faltan faltan – 1

de_cinco de_cinco + 5

c c + 1

x x – 3 Observación: Cuando una variable aparece a ambos lados del símbolo de asignación, conviene inicializarlas a cero.

8. Acumulador o Sumador Es una variable que nos permite guardar un valor que se incrementa o decrementa en forma NO constante durante el proceso. En un momento determinado tendrá un valor y al siguiente tendrá otro valor igual o distinto. Por ejemplo; cuando realizamos un depósito en el banco, la cantidad depositada cada vez no es siempre la misma; unas veces será una cantidad y otras veces distinta. Lo mismo ocurre cuando realizamos algún retiro, pero decrementando la cantidad total. La sintaxis es:

acumulador acumulador + variable (al incrementar)

acumulador acumulador - variable (al decrementar) acumulador es la variable en la que se almacena el resultado. varible contiene el número que estamos incrementando o decrementando Ejemplos:

saldo saldo + entrega

saldo saldo – retiro

suma suma + numero

A A + edad




9. Estructuras Por lo general los lenguajes de programación de las últimas generaciones poseen tres tipos de estructuras:

Estructura de secuencia Estructura de Selección Estructura de Repetición

9.1. Estructuras de Selección La estructura de selección, se ejecuta condicionalmente, es decir, si una cierta condición es verdadera se ejecuta un bloque de instrucciones, si es falsa se ejecuta un bloque diferente de instrucciones. Por ejemplo, si en el cine proyectan "Star Wars Episode I", entonces hay que formar fila para comprar los billetes e ingresar al cine, si no, decidimos otra actividad como ir a bailar. Si utilizamos una selección es para indicar que según el resultado cierto o falso de una expresión vamos a tomar una decisión de realizar determinadas acciones especificadas; seleccionamos las acciones a realizar. La instrucción que permite tomar una decisión, basada en una condición es Si...Entonces. Al evaluar la condición, Si...entonces puede devolver solo dos resultados posibles: Verdadero o Falso; es decir, Si o No. El formato de la estructura de selección es:

Si condición > entonces instrucción 1 instrucción 2 ...................

instrucción n Si-no instrucción n+1 instrucción n+2 ................... instrucción m Fin-si

Observa como el sangrado permite identificar fácilmente que grupo de instrucciones se ejecutan en cada caso. Por ejemplo, Cuando realizamos una llamada telefónica:

Si {señal de ocupado} entonces Colgar el teléfono

si - no Iniciar la conversación

Fin – si

En este caso, la condición es {señal de ocupado}, que puede ser verdadera o falsa. Si es verdadera, entonces debemos colgar el teléfono y si no, podemos relizar la conversación.




Ejemplo: Si A = 5 entonces

Escribir("A es 5" ) Si - no

Escribir "A no es igual a 5" Fin – si

También puede obviarse el si - no cuando no nos interesa ejecutar un bloque de instrucciones en caso de que la condición no se cumpla.

Si {condición} entonces

instrucción 1 instrucción 2 ......... instrucción n

Fin – si

Por ejemplo:

Si {hoy es Miércoles} entonces Comprar entradas para el cine

Fin - si

Ejemplo1: Introducir un número por teclado y determinar si es positivo o negativo.

Para saber si un número es positivo o negativo, debemos saber si es menor o mayor a cero. Si es mayor, el número es positivo y si es menor resulta negativo. Utilizamos Si... para evaluar como es el número con respecto a cero y mostramos los mensajes correspondientes en cada caso. Así:

Algoritmo Mayor1

Var

Entero Numero Inicio

leer Numero Si Numero < 0 entonces

Escribir "El número es negativo" Si-no

Escribir "El número es positivo" Fin-si

Fin




Ejemplo 2. Dados dos números, establecer cuál es mayor .

Comenzamos leyendo ambos números, que en el ejemplo se llamarán NumeroA y NumeroB. Luego debemos comparar como es uno contra el otro (puede ser NumeroA contra NumeroB o bien comparar NumeroB contra NumeroA):

En este ejemplo, que pasaría si los números fueran iguales?. Hagamos la prueba Luego de leer los números, por ejemplo: NumeroA=100 y NumeroB=100 se ejecutan las instrucciones:

Si NumeroA < NumeroB entonces Escribir "El mayor es:", NumeroB El resultado de la condición

Por lo tanto, al ser falsa la condición, se ejecuta la instrucción Escribir ("El mayor es:", NumeroA). Por tanto, el algoritmo ofrecerá una solución incorrecta cuando los números son iguales. Para solucionar esto, tenemos que prever el caso de que los números sean iguales.

Algoritmo Mayor1 Var Entero NumeroA, NumeroB Inicio

leer NumeroA, NumeroB Si NumeroA < NumeroB entonces

Escribir( "El mayor es:", NumeroB ) si-no

Escribir( "El mayor es:", NumeroA ) Fin-si

Fin

Algoritmo Mayor1 Var Entero NumeroA, NumeroB Inicio

leer (NumeroA, NumeroB) Si (NumeroA < NumeroB) entonces

Escribir( "El mayor es:", NumeroB ) Si-no

Si Escribir ("El mayor es:", NumeroA)

Si-no Escribir("Los números son iguales")

Fin-si Fin-si

Fin




Esta solución contiene dos estructuras de repetición, una dentro de la otra (anidada). En caso de ser necesario podemos anidar tantas estructuras de selección como sea necesario. El algoritmo averigua si A es menor a B, si no lo es, tenemos otras dos posibilidades: que sea menor o igual, esto es lo que determina la estructura anidada.

Otro ejemplo de estructuras de repetición anidadas, consiste en dado un número del 1 al 7, establecer al día de la semana.

En esta solución notará que existen varios Si...entonces anidados, ya que si el número ingreso no es 1, se tiene que preguntar si es 2 ó 3 ó 4...etc. El último

Algoritmo Dia_Semana Var Entero numero inicio leer numero Si numero=1 entonces Escribir ("Domingo") si-no Si numero=2 entonces Escribir ("Lunes") si-no Si numero=3 Escribir( "Martes") si-no Si numero=4 entonces Escribir ("Miercoles") si-no Si Numero=5 entonces Escribir ("Jueves") si-no Si numero=6 entonces Escribir ("Viernes") si-no Si numero=7 entonces Escribir ("Sábado") si-no Escribir ("El número debe estar entre 1 y 7") Fin-si Fin-si Fin-si Fin-si Fin-si Fin-si Fin-si




Si...entonces es para verificar que el número ingresado no es 1, 2, 3, 4, 5, 6 ó 7; sino cualquier otro que no interese

Resulta bastante tedioso anidar un montón de Si ... entonces, como en el ejemplo del día de la semana. Cuando queramos o necesitemos hacer numerosas comparaciones podemos usar otra estructura de selección llamada Según Sea. El formato de estructura de selección Según sea es:

Según sea <variable> Caso = <condición> Caso = <condición> instrucción o instrucciones Otro caso instrucción o instrucciones Fin-según

Así, utilizando esta estructura, el problema del día de la semana será así:

Lo cual resulta menos engorroso que varios Si... entonces anidados. Esposible anidar Si... entonces dentro de estructuras Según sea y viceversa. Observa que la instrucción Otro Caso ejecuta una o varias instrucciones cuando no se cumple ningún caso de los contemplados más arriba. Otro Caso debe estar siempre al Final (cuando sea necesario, si no o es se puede omitir Otro Caso)

Algoritmo Dia_Semana Var Entero numero Leer numero Según sea numero Caso = 1 Escribir "Domingo" Caso = 2

Escribir="Lunes" Caso = 3 Escribir="Martes" Caso = 4 Escribir "Miercoles" Caso = 5 Escribir "Jueves" Caso = 6 Escribir "Viernes" Caso = 7 Escribir "Sábado" Otro Caso Escribir ("El número debe estar entre 1 y 7")

Fin-según Fin




El uso de una u otra estructura depende de cada persona, pero en general cuando las condiciones a evaluar son muchas, se utiliza Según sea.- La estructura según sea admite varias condiciones por ejemplo:

Según sea MES caso= 1,3,5,7,8,10,12 TDias = 31 caso = 2,4,6,11 TDias =30 caso = 2 TDias=28 Fin-según

Este pequeño ejemplo establece el número de días de un mes determinado almacenado en la variable MES (para años no bisiestos). En lugar de escribir varios Caso= 1, Caso =2, etc, se puede especificar acción o acciones (en este caso la asignación de dias a TDias) cuando la variable tome uno de los valores separados por comas. Es decir si TDias es 1 ó 3 ó 5 ó 7 ó 8 ó 10 ó 12; se ejecuta TDias=31.

Algoritmo Misterio2 Var Entero h,m,s,H2,M2,S2

Inicio Leer(h,m,s)

s s+1 Si s=60 entonces

S2 0 Si- no

S2 s Fin –Si

m ((m * 60) + s) div 60 Si m=60 entonces

M2 0 Si-No

M2 m Fin S

H2 ( (h*60)+m) div 60 Si H2 =24 entonces

H2 0 Fin -Si

Escribir(H2,”:”,M2,”:”,S2) Fin

Se Obtiene: a) 13:0:1 b) 12:0:0 c) 13:1:0 d) 13:0:0 e) Ninguna de las

Anteriores

Problema 1.7 Si se ingresa h=12, m=59, s=59 en el siguiente Algoritmo




Solución: Para resolver estos tipos de problemas no es necesario realizar la prueba de escritorio con tablas, simplemente se siguen las secuencias reemplazando las variables correspondientes

a) falso b) falso c) falso d) verdaero e) falso

9.2. Estructuras Repetitivas La estructura repetitiva se utiliza cuando se quiere que un conjunto de instrucciones se ejecuten un cierto número Finito de veces. Llamamos bucle o ciclo a todo proceso que se repite un cierto número de veces dentro de un pseudocódigo o un programa. Existen dos tipos de estructuras repetitivas; la primera es aquella en donde se tiene perfectamente establecido el número de veces que un grupo de acciones se van a ejecutar (20, 5, 2 veces), y la segunda en la que el número de repeticiones es desconocido y se hará hasta que se cumpla o no cierta condición. Un ejemplo de la primera sería Escribir los datos de los alumnos de una clase (se conoce cuantos alumnos hay) y un ejemplo de la segunda puede ser el mostrar un mensaje de error cada vez que el usuario pulse una determinada tecla (no sabemos cuantas veces pulsará esa tecla). Las acciones que forman parte del cuerpo del bucle son ejecutadas de forma repetitiva mediante la ocurrencia o no de una condición.

h=12, m=59, s=59

s s+1 Si s=60 entonces

S2 0 Si- no

S2 s Fin –Si

m ((m * 60) + s) div 60 Si m=60 entonces

M2 0 Si-No

M2 m Fin S

H2 ( (h*60)+m) div 60 Si H2 =24 entonces

H2 0 Fin -Si

Escribir(H2,”:”,M2,”:”,S2)

h=12, m=59, s=59

s 59+1 Si 60=60 entonces

S2 0 Si- no

S2 s Fin –Si

m ((59 * 60) + 60) div 60 Si 60=60 entonces

M2 0 Si-No

M2 60 Fin S

H2 ( (12*60)+60) div 60 Si 13 =24 entonces

H2 0 Fin -Si

Escribir(13,”:”,0,”:”,0)




9.2.1. Estructura de repetición Para (Desde-Hacer) Cuando conocemos de antemano el número de veces en que se desea ejecutar una acción o grupo de acciones, se utiliza la estructura repetitiva Para o Para. Esta estructura ejecuta las acciones del cuerpo del bucle un número especificado de veces, y de modo automático controla el número de iteraciones o pasos. La sintaxis es:

Para variable= Valor:inicial hasta Valor_Final [incremento] acción o acciones Fin-Para Donde: variable: variable índice Vi: valor inicial de la variable índice Vf: valor Final de la variable índice [incremento]: el número que se incrementa (o decrementa) a la variable índice en cada iteración del bucle, si se omite es 1.

Ejemplo: Escribir todos los números del 1 al 100.

i es la variable índice con un valor inicial de 1, se incrementa uno en cada paso hasta 100. Podemos notar que la estructura Para comienza con un valor inicial de la variable índice y las acciones se ejecutan hasta que el valor inicial sea MAYOR que el que el Valor Final. La variable índice se incremente en uno (en el ejemplo) y si este nuevo valor del índice no es mayor que el valor Final, se ejecuta de nuevo la acción Escribir. En este caso se visualizará los números 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ....97, 98, 99, 100 El incremento o paso de contador es siempre 1 si no es especifica lo contrario.

Algoritmo Cien Var Entero i Inicio Para i = 1 hasta 100 Escribir (i) Fin-Para Fin




Ejemplo: Escribir todos los números pares desde el 2 hasta el 300

Donde: La variable índice i comienza en 2, se imprime 2 y en el siguiente paso se incrementa (suma) 2 a la variable índice que pasa a valer 4; se imprime el 4 y como 4 es menor que

300 (valor Final) , se pasa a una nueva iteración incrementando nuevamente en 2 el índice, que ahora vale 6; y así sucesivamente... Aquí se visualizan: 2, 4, 6, 8, 10, 12, 14, 16, 18, ..... 296, 298, 300 Si deseamos mostrar los impares el algoritmo es el siguiente:

Para i= 1 hasta 300 incremento 2 Escribir (i) Fin-Para La variable índice toma estos valores:

Índice o Paso (veces que se ejecuta el ciclo) Valor de I

1 1

2 3

3 5

... ...

150 299

Vemos los valores: 1, 3, 5, 7, 9, 11, 13, .... , 299 El ciclo termina mostrando 299 puesto que en el siguiente paso, La variable I valdría 301 y es mayor al límite establecido de 300. I pasa a valer realmente 301 en el último paso, solo que la instrucción de Escribir no se ejecuta porque el limite de 300 se supera. Si diéramos la instrucción de Escribir el valor de i, inmediatamente después del Fin-Para, veíamos 301. Ejemplo 3: Escribir los valores comprendidos entre el 460 y 500 en orden inverso.

Algoritmo Dia_Semana Var Entero i Inicio

Para i= 2 hasta 300 incremento 2 Escribir(i)

Fin-Para Fin




Debemos mostrar: 500, 499, 498, 497, ..... 462, 461, 460. En este caso haremos un decremento a la variable índice (no un incremento como en los ejemplos anteriores). Tenemos que comenzar nuestra variable índice en 500 y decrementar una unidad hasta alcanzar el 460, así: Para i= 500 hasta 460 incremento -1 Escribir I Fin-Para

Indice o Paso (veces que se ejecuta el ciclo) Valor de I

1 500

2 499

3 498

... ...

40 461

41 460

Como salida tenemos, entonces: 500, 499, 498, 497, 496, 495, 494, .... 464, 463, 462, 461, 460.

El segundo tipo de estructura repetitiva se diferencia de la primera en que no se conoce el número de repeticiones o iteraciones en que se va a ejecutar una instrucción o un bloque de instrucciones. Estas estructuras son básicamente dos: Estructura mientras....Fin-mientras y la estructura repetir.... hasta. Estas dos se diferencian en que la verificación de la condición para repetir el ciclo se hace al inicio con mientras y al Final con repetir También existen estructuras repetitivas que son combinaciones de estas dos que mencionamos, pero aquí no las estudiaremos.

Algoritmo incógnita Var Entero n,i Inicio Leer(n)

Para i=2 hasta n Si i mod n <>0 Entonces Escribir(i) Fin-Si

Fin - Para Fin

Problema 1.8 Si se ingresa un número n=15 en el siguiente algoritmo




Solución: Realizando la tabla para la corrida se consideran dos variables n e i:

n=15 I i mod n<>0 Se imprime i si i mod n<>0 es verdadero

2 2 mod 15=2 2

3 3 mod 15=3 3

4 4 mod 15=4 4

5 5 mod 15=5 5

6 6 mod 15=6 6

7 7 mod 15=7 7

8 8 mod 15=8 8

9 9 mod 15=9 9

10 10 mod 15=10 10

11 11 mod 15=11 11

12 12 mod 15=12 12

13 13 mod 15=13 13

14 14 mod 15=14 14

15 15 mod 15=0

a) Falso b) Falso c) Falso d) Falso e) Verdadero

Resp. Literal e

Algoritmo incógnita Var Entero n,i,S Inicio

S 0 Leer(n)

Para i=1 hasta n Si (n mod i )= 1 entonces

S S – i Si- no

S S + i Fin - Si Fin – Para Escribir(S) Fin

Problema 1.9 Si en el algoritmo siguiente se ingresa un número par positivo para n

Entonces se imprime: a) 2,4,6,7,8,9,10 b) 11,12,13,14 c) 3,5,15 d) 2,4,6,7,8,12,13,14 e) Ninguna de las anteriores




Dando valores para el primer número par positivo

n=2 i S n mod i=1 S S-i S S+i S Se imprime

1 0 2 mod 1=1 falso S+1 0+1

2 2 2 mod 2=1 falso S+2 0+1+2 3

Probando para el siguiente número par positivo

n=4 i S n mod i=1 S S-i S S+i S Se imprime

1 0 4 mod 1=1 falso S+1 0+1

2 2 4 mod 2=1 falso S+2 0+1+2 3

3 3 4 mod 3=1 verdad S-3 0+1+2-3 0

4 0 4 mod 4=1 falso S+4 0+1+2-3+4 4

Se podría seguir probando para el siguiente número pero sería algo innecesario, puesto que se podría dar solución con estos antecedentes. Se puede observar que como n es par siempre termina la sumatoria en +n, así que el literal c es falso. Observamos adicional que cuando i = 3, este se suma con signo negativo así que el literal b y d son falsos.

Por último podemos percatarnos que cuando i = 1, este se suma con signo positivo asi que el literal a es falso y el literal e es verdadero

a) falso b) falso c) falso d) falso e) verdadero

Resp. Literal e

9.2.2. Estructura de repetición Mientras Como su nombre lo indica, esta estructura repite el cuerpo del bucle mientras se cumpla una determinada condición. Su sintaxis es:

mientras {condición} acción 1 acción 2 acción 3 ..... acción n Fin mientras instrucción X

Calcula: a) S= 0–1+2–3+4....+n b) S= 0+1+2 +3–4 ….+n c) S= 0–1–2–3–4 ….–n d) S= 0+1–2 +3–4….+n e) S= 0+1 +2–3+4….+n




Lo primero que el computador hace es examinar la condición, lo que puede dar como resultado dos posibilidades:

La condición se cumple: Se ejecutan acción 1, acción 2, acción 3, ..., acción n. Las estará repitiendo hasta que la condición no se cumpla, entonces se sale del ciclo y se siguen ejecutando la o las instrucciones que vienen a continuación y están fuera del bucle; instrucción X. La condición no se cumple: No entrará en el ciclo. Se ejecutan las instrucciones que vienen después del bucle, instrucción X, por ejemplo. De esto se deduce que el cuerpo del bucle de una estructura mientras puede repetirse cero o más veces, veces que son determinadas por el cumplimiento o no de la condición. Ejemplo mientras contraseña < > “Oscar” Escribir "La contraseña es incorrecta !" Fin-mientras Escribir ("Ha ingresado la contraseña correcta") Veremos más ejemplos de esta estructura en la sección ejercicios. Al analizarlos comprenderemos mejor como funciona.-

Problema 1.10 Si se ingresa a=3, b=2, c=1 y r =8 en el siguiente algoritmo se imprime:

a) 8 b) 8, 8, c) 8,8,8,8 d) 8,8,8 e) Algo diferente a las alternativas anteriores

Algoritmo Misterio2 Var Entero a,b,c,r,s Inicio Leer(a,b,c,r) Mientras a+b+c <> r Si a+b+c< r entonces

a a - 1 Si-No

b b - 1 Fin-Si

c a + b Escribir(r)

Fin – Mientras Fin




Solución: Analizando el algoritmo verificamos que hay una estructura de repetición Mientras, la cual siempre se genera la repetición Mientras la condición sea verdadera. La condición es a+b+c <> r

Ingresando los valores respectivos para cada variable según el problema se tiene

a=3 b=2 c=1 r=8

Realizando la respectiva prueba de escritorio

a+b+c <> r a b c r Se imprime

1 3+2+1<>8 verdadero 2 2 4 8 8

2 2+2+4<>8 falso

En la línea 1 tenemos que a,b y c se evalúan con los valores ingresados y se comparan con r. Como la condición fue verdadera se realiza la operación

a a – 1 cambiando el valor de a=3 a a=2 e imprimiendo el valor de r. Se realiza una nueva comparación con el nuevo valor de a=2 en la línea 2. la condición fue falsa y quedamos fuera del ciclo Mientras y fuera del programa Comparando las alternativas tenemos que a) verdadero b) falso c) falso d) falso e) falso Resp. Literal a

Problema 1. 11

Cuando se ingresa x=3 y n=81 en el siguiente algoritmo

Se imprime

Algoritmo Misterio Var Entero x,y,n Inicio

y 1

i 1 Leer(x) Leer(n)

Mientras i< n

i x * i

y y + 1 Fin – Mientras Escribir(y) Fin




Realizando la respectiva tabla de la corrida

X=3 n=81 i y i< n Se imprime

1 0 1<81 veradero

3 1 3<81 veradero

9 2 9<81 veradero

27 3 27<81 veradero

81 4 81<81 falso 4

a) falso b) falso c) verdadero d) falso e) falso

Resp. Literal c

9.2.3. Estructura de repetición Repetir La estructura repetir cumple la misma función que la estructura mientras. La diferencia está en que la estructura mientras comprueba la condición al inicio y repetir lo hace al Final; por eso la estructura repetir se ejecuta por lo menos una vez.La sintaxis es:

repetir intrucción 1 instrucción 2 instrucción 3 ...... hasta {condición} instrución X

Repetir es opuesta a la estructura mientras. Repetir se ejecuta hasta que se cumpla una condición que se comprueba al Final del bucle. Esto implica que las instrucciones que forman el cuerpo del bucle se ejecutan por lo menos una vez. Con la estructura mientras el bucle puede ejecutarse 0 o más veces. Lo que la computadora hace al ejecutar la estructura repetir es: Se ejecutan: instrucción 1, instrucción 2, instrucción 3, ...... Se evalúa la condición. Si esta es FALSA se vuelve a repetir el ciclo y se ejecutan instrucción 1, instrucción 2, instrucción 3, ...... Si la condición es VERDADERA se sale del ciclo y se ejecuta instrucción X. Recordemos una vez más las diferencias entre las estructuras mientras y repetir

MIENTRAS REPETIR

Comprobación de la condición al inicio, antes de entrar al bucle

Comprobación de la condición al Final, después de haber ingresado una vez al bucle

Las instrucciones del cuerpo del bucle se ejecutan en forma repetitiva si la condición es verdadera

Las instrucciones del cuerpo del bucle se ejecutan si la condición es falsa

Las acciones del bucle se pueden ejecutar 0 o más veces

Las acciones del bucle se ejecutan por lo menos una vez




Ejemplo: Repetir

Escribir ("Escriba la contraseña para ingresar al sistema" ) Leer(contraseña)

Hasta contraseña = "Seron2003"

Solución: Cuando no se tiene mucha experiencia con el manejo de algoritmos lo conveniente es hacer una prueba de escritorio para resolver estos tipos de problemas.

N=1 i=0 S=0 i S i=n Se imprime

1 0 1=1 verdadero 0

Definitivamente el algoritmo no cumple con su objetivo así que es fácil determinar que la respuesta a esta pregunta no es el literal e, ya que por lo menos debería imprimirse 1 si n=1 Entonces hay que realizar el respectivo análisis por cada literal:

El Paso4 debería ser: “Si asigna S S*S”, para que el algoritmo cumpla con su objetivo

N=1 i=0 S=0 i S i=n Se imprime

1 0 1=1 verdadero 0

Problema 1.12 Se tiene el siguiente problema: “Si se ingresa un número entero N, se desea

presentar el resultado (12 + 22 + 32 + ... N2 ) Solución Paso1: Se obtiene el valor de N Paso2: Se asigna a un contador i el valor de Cero

Paso3: Se asigna a una variable S0

Paso4: Se asigna a S S+i*i

Paso5: Se incrementa ii+1 Paso6: Se Pregunta si i=N, si es verdad ir al paso 7, si es falso ir al paso 4 Paso7: Se Presenta S Entonces es verdad que:

a) El Paso4 debería ser: “Si asigna S S*S”, para que el algoritmo cumpla con su objetivo

b) El Paso2 debería ser: “Si asigna a un contador i el valor de uno”, para que el algoritmo cumpla con su objetivo

c) El Paso3 debería ser: “Si asigna a una variable S 20”, para que el algoritmo cumpla con su objetivo

d) Si se intercambian los Pasos : Paso4 y Paso5, el algoritmo cumpla con su objetivo

e) El algoritmo cumple con su objetivo




Aquí ya deja de cumplir con el objetivo ya que si n= 1 debe imprimir 1

El Paso2 debería ser: “Si asigna a un contador i el valor de uno”, para que el algoritmo cumpla con su objetivo

N=1 I=0 S=0 i S i=n Se imprime

2 1 2=1 falso

3 5 3=1 falso

. . ..

Si n=1 existe un ciclo infinito, ya que no el valor de i se incrementa y siempre la condición es falsa. El algoritmo no cumple con su objetivo

El Paso3 debería ser: “Si asigna a una variable S 20”, para que el algoritmo cumpla con su objetivo. Realizar este análisis estaría demás, ya que no se puede encerar una variable de tipo sumador con una cantidad diferente de cero en este ejemplo

El algoritmo no cumple con su objetivo

Si se intercambian los Pasos : Paso4 y Paso5, el algoritmo cumpla con su objetivo

n=1 i=0 S=0 i S i=n Se imprime

1 1 1=1 verdadero 1


1 1 1=2 falso

2 5 2=2 verdadero 5


1 1 1=3 falso

2 5 2=3 falso

9 5 3=3 verdadero 14

El algoritmo cumple con su objetivo, con esto se llega a la conclusión de que la respuesta es el literal c Resp. Literal c




10. Problemas propuestos

Preparar un Algoritmo que solicite el nombre y el año de nacimiento y calcule la edad del usuario.

Escribir un Algoritmo que sume, reste, multiplique y divida dos números

Escribir un Algoritmo que evalúe la siguiente expresión: (a+7*c)/(b+2-a)+2*b+2

Escribir un algoritmo que determine cuántos minutos existen en n segundos.

Escribir un Algoritmo que muestre un mensaje afirmativo si el número introducido es múltiplo de 5

Dado un número determinar si es positivo, negativo o cero.

Escribir un Algoritmo que calcula el equivalente en grados Fahrenheit o Celsius {Regla de 3: Celsius / 5 = (Fahrenheit – 32) 9}

Ingresar tres valores; M, N y P. Si M es menor a N hacer R= M*N + P. En caso contrario, hacer R = (M+N) * P.

Dados dos números, dar la relación entre ellos. Señalar el mayor, el menor o especificar si son iguales

Preparar un Algoritmo que calcule la media de tres números.

Escribir un Algoritmo que dado un número del 1 a 7 escriba el correspondiente nombre del día de la semana.

Diseñar un Algoritmo para resolver una ecuación de segundo grado.

Para hallar la raíz cuadrada de un número, lo elevamos a la potencia ½ utilizando xy = x^y

Leer una serie de número que deben finalizar con –9999. Calcular e imprimir el promedio de los números ingresados.

Determinar si un número Real ingresado por teclado es Entero

Determinar si un número Entero n ingresado por teclado puede evaluar la siguiente expresión:

nn 11

1

Leer un número N que sea entero positivo, e imprimir todos los pares entre 1 y H inclusive.

Escribir un Algoritmo que calcule el equivalente en pies de una longitud de n metros. 1 metro -------------39.27 pulgadas

12 pulgadas --------1 pie

Escribir un Algoritmo que detecte si se han introducido en orden creciente tres números introducidos por el usuario

Leer un número entero n que represente una cantidad de segundos, luego presentar en formato hora, minuto y segundo

Leer un número entero positivo menor que 35 y calcular su factorial.

El factorial del número n se calcula así: 1 x*2 * 3 * 4 * ......* n-1, * n Así el factorial de 4 = 1*2*3*4 = 24 No existen factoriales de números negativos. El factorial de n = n(n-1)!. El factorial de 0 = 1. El factorial de 1 = 1.

Escribir un Algoritmo que imprima los primeros N términos de la sucesión de Fibonacci.




La serie de Fibonacci es: 0,1,1,2,3,5,8,13,21

Se inicia en 0, luego el uno, el siguiente termino será la suma de los dos anteriores:

0, 1 , 0+1 = 0, 1, 1 luego

0,1,1,1+1 = 0, 1, 1, 2 y así sucesivamente

0,1,1,2, 2+1 = 0, 1, 1, 2, 3

Escribir un Algoritmo que determine si un número ingresado es primo

Intercambiar el valor de dos variables sin utilizar una variable auxiliar

Dados dos números enteros, calcular su producto sin utilizar el operador de multiplicación (*)

Dados dos números, N y P elevar el número N a la potencia P sin utilizar el operador de potencia (^) ni el operador de multiplicación (*)

Escribir un Algoritmo que lea tres números y los imprima de forma ascendente.

Escribir un Algoritmo que pida un número y si el que se introduce por el teclado es menor de 100 que vuelva a solicitarlo

Escribir un Algoritmo que calcule la suma de los cuadrados de los n primeros números enteros

Escribir un Algoritmo que lea n datos desde el teclado y sume sólo aquellos que sean negativos.

Escribir un algoritmo que muestre la suma total de todos los números primos que existen entre m y n (n>m, m>1).

Escribir un Algoritmo que imprima el total de la siguiente cantidad:

)!1(!2

3

!1

2

!0

1 ...

n

n

Donde n se ingresa por teclado

Escriba un algoritmo que imprima el total de S y de f de la siguiente secuencia:

impar

par

n

es

es

iSifS

iSiiSf

iSifiSS

*

Donde n ingresa por teclado e i varia desde 1 hasta n

Escriba un algoritmo que encuentre el (los) valor(es) de x, tal que cumpla que f(x) sea

el mayor de todos que existe en un intervalo [a,b] donde a x b

xxx

xf 623

)(23

a,b,x son números enteros

Escribir un Algoritmo que determine Cuantas Horas, Minutos y Segundos hay después de un segundo




Segunda Parte FLUJO DE DATOS




11. Diagramas de flujos

Un diagrama de flujos representa la esquematización gráfica de un algoritmo. En realidad muestra graficamente los pasos o procesos a seguir para alcanzar la solución de un problema. Su correcta construcción es muy importante ya que a partir del mismo se escribe un programa en algún lenguaje de programación. Siel diagrama de flujos esta completo y correcto, el paso del mismo a un lenguaje de programación es relativamente simple y directo.

A continuación se presentan los siguientes simbolos y la explicación del mismo que se va a utilizar en el presente capítulo

Símbolo Explicación

Símbolo utilizado para marcar el inicio y el fin de un diagrama de flujos

Símbolo utilizado para introducir datos e impresiones de resultados. Representa entradas y salidas

Símbolo utilizado para representar un proceso. En su interior se expresan asignaciones, operaciones aritméticas .

Símbolo utilizado para representar una decisión. En su interior se almacena una condición y dependiendo del resultado de la evaluación de la misma se sigue por una de las ramas o caminos alternativos. Este símbolo representa la estructura de decisión si-entonces / si-entonces sino.

V

F

Símbolo utilizado para expresar la dirección de flujo del diagrama




12. Reglas para la contrucción de diagramas de flujos

1. Todo diagrama de flujos debe tener un inicio y un fin

2. Las líneas utilizadas para indicar la dirección del flujo del diagrama deben ser rectas, verticales u horizontales.

3. Todas la líneas utilizadas para indicar la dirección del flujo del diagrama deben estar conectadas. La conexión puede ser un símbolo que represente lectura, proceso, decisión, impresión o fin del diagrama.

INICIO

FIN

.

.

.

No deben ser inclinadas ni tampoco deben cruzarse




4. No puede llegar mas de una línea a un símbolo.

Diagramas no válidos Diagrama válidos

Etapas a seguir en un diagrama de flujos

INICIO

FIN

LECTURA

DE DATOS

PROCESAMIENTO

DE DATOS

IMPRESIÓN

DE RESULTADOS

La mayor parte de los diagramas de flujos tienes esta estructura acompañado de un bloque de decisión aunque en orden dife-rentes. Con estos diagramas de flujos se construyen ciclos de repetición, los cuales veremos en los ejemplos siguientes




13. Problemas suplementarios resueltos

i. Escribir un Diagrama de flujos que calcula el area de un rectángulo ingresando su base y su altura

ii. Escribir un Diagrama de flujos y un que calcula la cantidad de minutos que existen en S segundos

INICIO

FIN

Leer(base)

Leer(altura)

Area base * altura

Area

INICIO

FIN

Leer(S)

M S/60

M

Inicio

leer (base) leer ( altura)

Area base * altura Escribir(“El área es: ”, área)

Fin

Inicio leer (S)

M S /60 Escribir(“Minutos son: ”, M)

Fin




iii. Realice un Diagrama de flujos que determina si un número ingresado es mayor que cero

iv. Realice un Diagrama de Flujos que determina si un número es mayor que cero, menor que cero o igual a cero

INICIO

FIN

Leer(n)

n>0

“Mayor a 0” “No es mayor a 0”

V

F

Inicio

leer (n)

Si n > 0 entonces Escribir(“Mayor a cero”) Si-no Escribir(“No es mayor a cero”) Fin -Si Fin

INICIO

FIN

“Mayor a 0”

Leer(n)

n>0

V

F

“Menor a 0”

n<0

“Igual a 0”

F

V

Inicio

leer (n)

Si n > 0 entonces Escribir(“Mayor a cero”) Si-no Si n < 0 entonces Escribir(“Menor a cero”) Si-no Escribir(“Igual a cero”) Fin -Si Fin -Si Fin




v. Realice un Diagrama de Flujos que imprime la palabra fin si se ingresa el número -9999

vi. Realice un Diagrama de Flujos que calcule la suma de los primeros n números enteros

INICIO

FIN

Leer(n)

n = -9999

V

F

“Fin”

Inicio

Repetir

leer (n)

Hasta n=-9999 Escribir(“Fin”) Fin

Inicio

S 0

i 0

leer (n)

Mientras i < > n

i i + 1

S S + i Fin-Mientras Escribir(S) Fin

INICIO

FIN

Leer(n)

i < > n i i + 1

S S + i

S 0

i 0

S

F

V




vii Algoritmo que calcula el promedio de una serie de datos que termina con el -9999

viii. Escriba un Diagrama de Flujo que calcula el valor de 2n

Inicio

S 0

i 0

leer (n) Repetir

i i + 1

S S + n leer (n)

Hasta n= -9999

P S / i Escribir(P) Fin

INICIO

FIN

S 0

i 0

Leer(n)

n = -9999 i i + 1

S S + n

P S / i

P

F

V

INICIO

R 1

i 0

Leer(n)

i < n

R

R R * 2

i i + 1

F

V

FIN




ix. Escribir un Diagrama de Flujos que imprime todos los divisores de n y presente la suma de los mismos

Problema 1.13 El siguiente diagrama de flujos

Calcula: a) 2n b) 2n + 1 c) 2n – 1 d) 22n e) N.A

INICIO

S 0

i 0

Leer(n)

FIN

S

S S + i

i i + 1 i < n n mod i

V V

F F

INICI

O

FIN

var

i,n

leer(n)

i 1

j 0

i

V i 2*I

j j+1

j<n

F




Solución Realizando la prueba de escritorio para valores de se tiene

n=1 j=0 i=1 j < n i j Se imprime

0 < 1 verdadero 2 1

1 < 1 falso 2


0 < 2 verdadero 2 1

1 < 2 verdadero 4 2

2 < 2 falso 4

Con estos dos valores ya podemos ir deduciendo que alternativa podría ser, pero para estar mas seguros realizaremos una corrida mas para un valor de n


0 < 3 verdadero 2 1

1 < 3 verdadero 4 2

2 < 3 verdadero 8 3

3 < 3 falso 8

Para n=1 se tiene 2 Para n=2 se tiene 4 que es igual a 2*2 y este a su vez igual a 22 Para n=3 se tiene 8 que es igual a 2*2*2 y este a su vez igual a 23 Entonces podemos deducir que lo que calcula el algoritmo es 2n que nos lleva a deducir que la respuesta correcta es la alternativa a.

Problema 1.14 Según el siguiente diagrama de flujos

i Fin

n 32

i 1

i<n i i*2

Inicio

Var

i,n

V

F

Se obtiene a) 1,3,5,7,9 b) 5 c) 4 d) 3 e) Ninguna de las anteriores




Solución: Realizamos la prueba de escritorio correspondiente

N=32 i i<n Se imprime

1 1<32 verdadero

2 2<32 verdadero

4 4<32 verdadero

8 8<32 verdadero

16

16<32 verdadero

32

32<32 falso 32

a) falso b) falso c) falso d) falso e) verdadero

Problema 1.15 Dado el siguiente diagrama de flujos

Entonces es verdad que: a) Si se ingresa n = 6 se imprime solo el número 6 b) Si se ingresa n = 8 no se imprime el número 2 c) Si se ingresa n = 7 se imprime solo el número 7 d) Si se ingresa n = 3 se imprime solo el número -1 e) Si se ingresa n = 2 se imprime solo el número 0

INICIO

FIN

Var

i,S,n Leer(n) i 1

S 0

i = n n mod i=0 i .i+1

S S+ i

S i

V

F

V

F




Solución a) falso

N=6 i S i=n n mod i Se imprime

1 0 1=6 falso

2 2 6 mod 2=0 verdadero 2

b) falso

N=8 i S i=n n mod i Se imprime

1 0 1=8 falso


c) verdadero

N=7 I S i=n n mod i Se imprime

1 0 1=7 falso

2 2 7 mod 2=0 falso

2=7 falso

3 5 7 mod 3=0 falso

3=7 falso

4 9 7 mod 4=0 falso

4=7 falso

5 14 7 mod 5=0 falso

5=7 falso

6 20 7 mod 6=0 falso

6=7 falso


d) falso


1 0 1=3 falso

2 2 3 mod 2=0 falso

2=3 falso


e) falso


1 0 1=2 falso


a) falso b) falso c) verdadero d) falso e) falso

Resp. Literal c




Problema 1.16 ¿El diagrama de flujos siguiente tiene sentido?. Si lo tiene, ¿qué calcula?

S2 0

m m+1

Leer(h,m,s)

s = 60

V

FIN

V

V

S2 s

M2 0

h h+1

H2 0

m = 60

h = 24

M2 m

H2 h

F

F

F

H2

M2

S2

s s+1

INICIO

La solución se la dejamos al lector




14. Problemas suplementarios

i. Escribir un programa en Java que sume dos números ii. Escribir un programa en Java que sume, reste, multiplique y divida dos números iii. Escribir un programa en Java que calcule el área de un rectángulo iv. Escribir un programa que calcule la longitud y el área de una circunferencia

(longitud de la circunferencia = 2 * PI * radio) área de la circunferencia = PI * radio2

v. Escribir un programa en Java que calcule la velocidad de un proyectil que recorre 2

Km en 5 minutos. Expresar el resultado en metros/segundo. (Velocidad = espacio/tiempo)

vi. Escribir un programa en Java que calcule el volumen de una esfera: radio = 3 volumen de la esfera = 4/3 * PI * radio3 vii. Escribir un programa en Java que evalúe la siguiente expresión:

(a+7*c)/(b+2-a)+2*b viii. Escribir un programa en Java que evalúe la siguiente expresión:

(a+5) * 3 / 2 * b - b ix. Escribir un programa en Java que calcule el área y el volumen de un cono x. Escribir un programa en Java que calcule el área y el volumen de un cono

A = (PI * r * l)+ (PI * r2) V = (PI * r2 * h)/3

xi. Escribir un programa en Java que calcule la hipotenusa de un triángulo rectángulo xii. Escribir un programa que lea dos números enteros A y B, y obtenga los valores A div B, A mod B. xiii. Escribir un programa en Java que calcule el número de horas, minutos y segundos que hay en n segundos. xiv. Escribir un programa en Java que calcule el capital producido por un capital de C de dólares, al cabo de un año depositado a una tasa de interés del i. xv. Escribir un programa en Java que calcula la siguiente expresión trigonométrica para un valor angular de 90º

(sen x * cos x)/(tan x)




15. Estructuras condicionales

Una sentencia condicional en Java para ejecutar una sola instrucción se la muestra de la siguiente forma:

Se ejecuta la Instrucción1 sólo si la Expresión1 es verdadera. El punto y la coma al final de la instrucción1 cierra la estructura If - Then Ejemplo: Escribir un programa en Java que verifique si un número ingresado es mayor que cero e imprima un mensaje sólo si es.

Supongamos que se desean ejecutar mas de una instrucción en la misma condición. Se tiene lo siguiente:

El punto y la coma que se encuentra después del “End” cierra el Begin y la estructura If – Then . Ejemplo: Escribir un programa en Java que verifique si un número ingresado es mayor que cero e imprima un su raíz cuadrada .

if <Expesión> then

Instruccción1;

if <Expesión> then Instruccción1;

Program Programa1; Var i: Integer; Begin Readln( i ); If i >0 then Writeln( ‘ El Número es mayor a cero ‘); End.

if <Expesión> then Begin Instruccción1; Instrucción2; ... InstrucciónN; End;

Program Programa1;

Var i : Integer;

R: Real;

Begin

Readln( i );

If i >0 then

Begin

R := sqrt( i );

Writeln( ‘ La Raíz es: ‘ , R );

End;

End.




Ahora veamos el caso en que la condicional ejecute alguna instrucción en caso que no se cumpla. El punto y la coma que se encuentra al final de la Instrucción2 cierra la estructura de decisión. Ejemplo Escribir un programa en Java que verifique si un número ingresado es mayor que cero e imprima un mensaje si cumple o no la condición. Haciendo una miscelánea de los ejemplos anteriores tenemos: Escribir un programa en Java que verifique si un número ingresado es mayor que cero e imprima un su raíz cuadrada, si el número no es mayor que cero se debe multiplicar por (-1) y presentar un mensaje que el número fue negativo y la respectiva raíz cuadrada.

If <Expesión> then

Instruccción1

Else

Instrucción2;

Program Programa1;

Var i: Integer;

Begin

Readln( i );

If i >0 then

Writeln( ‘ El Número es mayor a cero ‘)

Else

Writeln( ‘ El Número no es mayor a cero ‘);

End.

Program Programa1;

Var i: Integer;

Begin

Readln( i );

If i >0 then

Begin

R := sqrt( i );

Writeln( ‘ La Raíz es: ‘ , R );

End

Else

Begin

i : = i *(-1);

R := sqrt( i );

Writeln( ‘ La Raíz es: ‘ , R , ‘ se ingresó un número negativo ’);

End;




15.1. Condiciones anidadas En nuestro problema anterior notamos lo siguiente: “¿Que pasaría si se ingresa el número cero?”. Bueno lo ideal sería también validar o identificar este número. Escribir un programa en Java que identifique si un número es negativo positivo o cero.

Veamos otro ejemplo Escribir un programa que lea un número e imprima el día de la semana correspondiente al número. Solución: Los días de la semana están dados desde el 1 hasta el 7, si el usuario ingresa un número que no corresponde a dicho rango hay que hacerle notar que ha introducido un número erróneo.

Program Programa1;

Var i: Integer;

Begin

Readln( i );

If i >0 then

Writeln( ‘ El Número es mayor a cero ‘)

Else if i<0 then

Writeln( ‘ El Número es menor a cero ‘)

Else

Writeln( ‘ El Número es igual a cero ‘);

End.

Program DIA;

Var i: byte;

Begin

Readln(i);

If i=1 then

Writeln('DOMINGO')

Else If i=2 then

Writeln('LUNES')

Else If i=3 then

Writeln('MARTES')

Else If i=4 then

Writeln('MIERCOLES')

Else If i=5 then

Writeln('JUEVES')

Else If i=6 then

Writeln('VIERNES')

Else If i=7 then

Writeln('SABADO')

Else

Writeln('NO ES UN DIA DE SEMANA VALIDO');

End.




15.2. Sentencia Case

En el problema anterior notamos que el programador podría tener una pequeña confusión al escribir estas líneas de código. Una manera mucho más fácil es utilizar la estructura de decisión Case

Hay que tomar en consideración que en cada grupo de expresiones es necesario la utilización de un “Begin” y “End” si se desean ejecutar varias instrucciones. Ejemplo:

Program DIA_MEJORADO;

Var i: byte;

Begin

Readln(i);

Case i of

1: Writeln ('DOMINGO');

2: Writeln ('LUNES');

3: Writeln ('MARTES');

4: Writeln ('MIERCOLES');

5: Writeln ('JUEVES');

6: Writeln ('VIERNES');

7: Writeln ('SABADOS');

Else

Writeln('NO ES UN DIA DE SEMANA VALIDO');

End;

End.

Case <variable> of

Valor1: <Grupo1 de expresiones>

Valor2: <Grupo2 de expresiones>

...

ValorN: <GrupoN de expresiones>

Else

<GrupoN de expresiones>

End;





xv. Escribir un programa en Java que muestre un mensaje afirmativo si el numero introducido es múltiplo de 5.

Program Cond1; USES CRT; Var num:Integer; Begin ClrScr; Write('Introduzca un numero : '); Readln(num); If num mod 5 = 0 Then

Write ('El numero introducido es mÿltiplo de 5') Else

Write ('El numero introducido no es mÿltiplo de 5'); End.

xvi. Escribir un programa en Java que determine si un número leído desde el teclado espar o impar.

Program Par_impar; USES CRT; Var num: Integer; Begin ClrScr; Write (Introduzca un numero entero: '); Readln (num); If num = 0 Then

Write ('El numero introducido no es par ni impar, es 0') Else If ((num mod 2 = 0)) Then

Write ('El numero introducido es par') Else

Write ('El numero introducido es impar') End.

xvii. Escribir un programa en Java que detecte si un número leído desde el teclado es mayor o menor que 100.

Program MenMay_100; USES CRT; Var num: Integer; Begin ClrScr; Write ('Escriba un numero entero:'); Readln (num); Writeln (''); If num < 100 Then Write ('El numero que ha escrito es menor de 100') Else If num > 100 Then Write ('El numero que ha escrito es mayor de 100') Else Write ('El numero es 100') End.




xviii. Escribir un programa en Java que lea dos números desde el teclado y si el primero es mayor que el segundo intercambie sus valores.

Program Vefifica; USES CRT; Var num1,num2: Integer; Begin ClrScr; Writeln ('Escriba dos numeros: '); Readln (num1); Write (''); Readln (num2); Writeln (''); If num1 > num2 Then

Begin Write (num2,' ',num1,'. El primer # introducido es mayor.'); Write (' Se cambia el orden.'); End

Else Begin Write(num1,' ',num2,'. El segundo # introducido es mayor.'); Write(' No se cambia el orden.'); End;

End.

xix. Escribir un programa en Java que dada una calificación en valor alfabético (A,B,C,D ó E) indique su equivalente en valor numérico (4,5,6,7 u 8).

Program EJER38; USES CRT; Var valor:CHAR; Begin ClrScr; Write ('Escriba una calificacion entre a y e: '); Readln (valor); Writeln (''); CASE UPCASE(valor) OF 'A': Write ('El valor correspondiente es: 4'); 'B': Write ('El valor correspondiente es: 5'); 'C': Write ('El valor correspondiente es: 6'); 'D': Write ('El valor correspondiente es: 7'); 'E': Write ('El valor correspondiente es: 8') Else Write ('La calificacion no existe'); End; End.

xx. Escribir un programa en Java que lea desde teclado el importe bruto de una factura y determine el importe neto según los siguientes criterios.

· Importe bruto menor de 2,000 -> sin descuento · Importe bruto mayor de 2,000 -> 15% de descuento




Program Factura; USES CRT; Var importe_bruto, descuento, total REAL; Begin ClrScr; Write ('Indique el importe de su factura para ver '); Writeln ('si le "descontamos" algo'); Writeln (''); Readln (importe_bruto); Writeln (''); {calcula el importe bruto con descuento del 15%} descuento:=importe_bruto * 0.15; If importe_bruto > 20000 Then Begin

Writeln ('SE MERECE UN DESCUENTO DE: ',descuento:5:2); total:=importe_bruto - descuento; Writeln ('El total es de la factura es de: ',total:5:2,' pts')

End Else

Write ('El Monto no alcanza el descuento') End.

xxi. Escribir un programa en Java que una vez leída una hora en formato (horas, minutos, segundos) indique cual será el tiempo dentro de un segundo.

Program F_hora; USES CRT; {Las variables son: horas, minutos y segundos} {Son las horas, minutos y segundos introducidos por el usuario} Var h, m, s, h2,m2,s2: Integer; {Son las horas, minutos y seguntos a los que se les sumara} Begin ClrScr; Write ('Escriba en formato horas, minutos y segundos'); Writeln (''); Write ('Horas '); Readln (h); Write ('Minutos '); Readln (m); Write ('Segundos '); Readln (s); Writeln (''); Writeln Writeln ('Se le sumara un segundo a la hora actual.'); Writeln (''); s:= s + 1; If s = 60 Then s2 := 0 Else s2 := s; m:= ((m * 60) + s) div 60; If m = 60 Then m2 := 0 Else m2 := m; h2:=((h * 60) + m) div 60; IF h2 = 24 Then h2 := 0; Writeln (h2,':',m2,':',s2); End.




xxii Escribir un programa en Java que calcule el salario semanal de un trabajador en base a las horas trabajadas y el pago por hora trabajada. · Horas ordinarias (40 primeras horas de trabajo) – 2.000 Dólares/hora · 1.5 veces precio hora ordinaria

Program Salario; USES CRT; Var htrab, ptsh:REAL; {Horas trabajadas y pts hora} nhextra, hextra:REAL; {Numero de horas extra y horas extra} salario_semanal:REAL; Begin ClrScr; Write ('Introduzca las horas trabajadas y las pts/hora que se cobran '); Writeln ('para calcular el salario semanal.'); Writeln (''); Write ('Horas trabajadas: '); Readln (htrab); Write ('Pts/hora: '); Readln (ptsh); Write ('Horas extra: '); Readln (nhextra); Writeln (''); hextra:=nhextra * (ptsh * 1.5); Salario_semanal:= (htrab) * (ptsh) + hextra; Write ('El salario semanal son ',salario_semanal:5:0,' pts.'); End.




17. Estructuras de Repetición

En la mayor parte de los programas se necesita repetir bloques de instrucciones tantas veces como lo requiera, la vida diaria de cualquier persona, animal o cosa esta repleta de ejemplos de ciclos, las computadoras solo se han encargado de copiarlos. ¿Cuando es necesario utilizar ciclos o estructuras de repetición? Veamos el siguiente ejemplo Escribir un programa en Java que imprima los números del 1 hasta el 5

Bueno el programa cumple con el objetivo. En este caso no dificulta la impresión de esos 5 números. ¿Pero qué ocurriría si la definición del problema cambia?

Escribir un programa en Java que imprima los números del 1 hasta el 100

Se tendría prácticamente que hacer una “Plana”. Este programa aunque cumple con su objetivo, el algoritmo es ineficiente. Para solucionar estos problemas se diseñaron las siguientes estructuras para Turbo Java:

For – Do Repeat - Until While – Do

En cada uno de estos daremos una solución más práctica al ejemplo anterior, cabe destacar que todos funcionan hasta que se cumple con una condición que es la encargada de hacer parar el ciclo y continuar con el resto de instrucciones del programa.

Program Numeros;

Begin

Writeln ('1');

Writeln ('2');

Writeln ('3');

Writeln ('4');

Writeln ('5');

End.

Program Numeros;

Begin

Writeln ('1');

Writeln ('2');

Writeln ('3');

Writeln ('4');

Writeln ('5');

…

Writeln ('10');

End.




17.1. Estructura For – Do (Para – Hacer)

Este ciclo ejecuta una serie de instrucciones incrementando o decrementando una variable hasta un tope determinado.

SINTAXIS GENERAL For Variable:=Valor_inicial To Valor_Final Do Begin {Bloque De Instrucciones} End; Forma Incremental For Variable:=Valor_Menor To Valor_Mayor Do Begin {Bloque De Instrucciones} End; Forma Decremental For Variable:=Valor_Menor downto Valor_Mayor Do Begin {Bloque De Instrucciones} End; La Variable controladora del ciclo es generalmente de tipo INTEGER, pero también se puede en algunas ocasiones declarar de tipo carácter así: For Letras:=’a’ to ‘z’ do Begin {En este ciclo se recorre el alfabeto de la ‘a’ a la ‘z’ de letra en letra} End; Solucionemos el problema de la impresión de los números del 1 al 100

En solo 2 líneas hemos resumido 100 comparándolo con el problema anterior . la variable controladora i toma el valor inicial de 1 y se incrementa en uno hasta llegar al valor final 100. En este problema el bloque de instrucciones de la estructura For – do no necesita de un “Begin” y un “End”, ya que solo consta de una sola sentencia. Si se desean ejecutar más de dos instrucciones dentro de la estructura de repetición es necesario colocarlas.

Program Numeros;

Begin

For I:= 1 to 100 do

Writeln (i);

End.




Ejemplo: Escribir un programa que imprima los números del 1 al 100 y muestre un mensaje por cada número es múltiplo de 4.

El punto y coma que se encuantra al final del primer “End”, cierra la estructura de repetición. Problema 2.1 Si se ingresa el número 15 para n en el siguiente programa

. Se obtiene a) 15 b) 8 c) 0 d) 1 e) No imprime algo Solución:

Realizando la respectiva corrida el lector debe notar que existe una estructura de repetición for que va desde 2 hasta un número n-1 ingresado. Según nuestro problema n es igual a 15, así que debe repetirse la estructura desde 2 hasta el 14.

n=15 i n mod i=0 s Se imprime

2 15 mod 2=0 falso 0

3 15 mod 3=0 verdad 3


5 15 mod 5=0 verdad 8





Program Numeros;

Begin

For I:= 1 to 100 do

Begin

Writeln (i)

If I mod 4 = 0 then

Writeln( ‘ ES MULTIPLO DE 4 ‘ );

End;

End.

Program Suma;

var i,j,n,s: integer;

begin

readln(n);

s:=0;

for i:=2 to n-1 do

if n mod i=0 then

s:=s+i;

writeln(s);

end.




10

15 mod 10=0 falso 8

11

15 mod 11=0 falso 8

12

15 mod 12=0 falso 8

13

15 mod 13=0 falso 8

14

15 mod 14=0 falso 8 8

Observamos que en la prueba de escritorio cuando i toma el valor de 3 y de 5 la condición es verdadera y se asigna a un sumador s el valor de i. Este algoritmo lo que presenta es la suma de todos los divisores de n que existen desde el número 2 hasta n-1. Si notamos además, los divisores que tiene el número 15 desde el 2 hasta el 14 son el número 3 y número 5 y el resultado de la suma de ambos números es 8 igual al valor impreso.

a) falso b) verdadero c) falso d) falso e) falso

Resp. Literal b Problema 2.2 Al ejecutar el siguiente programa e ingresar el número 20 para n y 10 para j

Program Numeros;

var i,j,n,s: integer;

begin

readln(n); readln(j);

s:=0;

if n>j then

for i:=j to n do

if i mod 2=0 then

n:=n-1

else

s:=s+n;

writeln(s);

end.

se obtiene

a) 20

b) 15

c) 57

d) 55

e) 48




Realizando la respectiva prueba de escritorio se tiene:

n=20 j=10 i i mod 2=0 n s Se imprime

1 15 15 mod 2 falso 20 20

2 16 16 mod 2 verdadero 19 20

3 17 17 mod 2 falso 19 39

4 18 18 mod 2 verdadero 18 39

5 19 19 mod 2 falso 18 57

6 20 20 mod 2 verdadero 17 57 57

a) falso b) falso c) verdadero d) falso e) falso Explicación:

El lector podrá notar que la condición primera (if n>j then) debe tener un valor verdadero para que se pueda ejecutar el resto del código, como se dan valores de n=20 y j=10 el resto del código se ejecuta. Existe un ciclo de repetición for que va desde el número 15 hasta 20 y por cada valor de i que varia existe otra condicional que pregunta si éste es un número

par (i mod 2=0 Verdadero). Si el valor de i es un número par n hace un decremento en uno lo que ocurre en las líneas 2, 4 y 6.

Si n no es un número par (i mod 2=0 falso), se asigna a un sumador s el valor de n lo que ocurre en las líneas 1, 3 y 5 Resp. Literal c

Problema 2.3 Si se ingresa el número 5 para la variable N en el siguiente programa

Program F;

Uses Crt;

Var n,S,F,i: Integer;

Begin

S:=0;

Readln(n);

F:=1;

For i:=1 To n Do

Begin

S:=S+F;

F:=S;

Writeln(S);

End;

End.




Se Obtiene:

1,2,4,8,16

2,4,8,16,32

4,8,12,16,5

0,1,2,4,8,16

16 Solución: Para realizar la prueba de escritorio respectiva observamos que existe una estructura de repetición for que va desde 1 hasta n almacenadas en i. Par nuestro problema n= 5 entonces tenemos

n=5 S=0 F=1 i S F Se imprime

1 1 1 1

2 2 2 2

3 4 4 4

4 8 8 8

5 16

16

16

La corrida de este problema es sencillo, ya que no hay que realizar ningún tipo de comparación y solo hay que efectuar las operaciones respectivas las cuales son S:=S+F; F:=S; Para cada valor de i Comparando con las alternativas tenemos: a) verdadero b) falso c) falso d) falso e) falso

Resp. Literal b

17.2. Ciclo While - Do(Mientras – Hacer)

SINTAXIS While ( Condición ) Do Begin <Bloque De Instrucciones> End;

Este estructura ejecuta una serie de instrucciones un número no determinado de veces hasta que se cumpla con una condición establecida , aunque también se puede hacer que trabaje de manera similar al ciclo FOR. Una de las ventajas del ciclo WHILE es que puede evaluar variables de muchos mas tipos que el ciclo FOR(Recuerda que en este solo se pueden usar variables de tipo CARÁCTER y ENTERAS) entre ellas destacamos las de tipo STRING, BOOLEAN, Integer, REAL, ARREGLO.




El ciclo WHILE evalúa y después ejecuta las instrucciones Si lleva mas de una instrucción necesita BEGIN - END

Escriba un programa que ingrese una serie de números y que termine el ingreso cuando se digita el número -9999

Problema 2.4 Cuando se ingresa 15,3,4 para a,b,c respectivamente Realizando la respectiva prueba de escritorio se tiene:

a=15 b=3 C=4 b c b>c (a > (b+c)) Se imprime

3 7 falso (15 > (3+7)) verdad 7

3 8 falso (15 > (3+8)) verdad 8

3 15

falso (15 > (3+15)) falso 15

a) falso b) verdadero c) falso d) falso e) falso

Program MIENTRAS;

var a,b,c: integer;

begin

readln(a); readln(b); readln(c);

while (a > (b+c))do

begin

if b>c then

b:=b+(a mod b)

else

c:=c+(a mod c);

writeln(c);

end;

end.

7

15

8

7

8

15

15

8

7

7

15

10

7

15

8

a)

b)

c)

d)

e)

Se imprime




Problema 2.5 Para calcular el factorial de un número en el siguiente programa

17.3. Ciclo Repeat– Until (Repita – Hasta)

EL CICLO "REPITA" (Como cariñosamente se le llama en la jerga de los programadores) actua de manera similar al ciclo WHILE – DO, con la pequeña diferencia de que en este se ejecutan las instrucciones y despues se evalua la condición. Este no necesita BEGIN ni END, aunque tampoco dice nada si se los colocas.

SINTAXIS Repeat {Bloque de instrucciones} Until (Expresión_a_evaluar)

Program Ciclo_Repeat_Until2;

Var

Numero: Integer;

Begin

Numero:= 1;

Repeat

WriteLn (Numero);

Numero := Numero + 5;

Until Numero = 200;

readln;

End.

1. Program factorial

2. Var temp,num,fac:Integer;

3. BEGIN

4. fac:=1;

5. temp:=num;

6. Write('Introduzca un numero -> ');

7. READLN(num);

8. temp:=num;

9. WHILE num>=1 DO

10. BEGIN

11.

12.

13. END;

14. Write('El factorial de '); Write(temp); Write(' es '); Write(fac);

15. END.

11. fac:=fac*num

12. num:=num-1

a)

11. num:=num-1;

12. fac:=fac*num;

b)

11. num:=num-2;

12. fac:=fac*(num+1);

c)

11. fac:=fac*num;

12. num:=num-1;

d)

Ninguna de las

anteriores

e)

Es necesario colocar el las líneas 11 y 12 las siguientes sentencias:




Problema 2.6 Si se ingresa el número 5 para la variable c en el siguiente programa Solución:

c=2 a b (a+b) div c> 10 Se imprime

1 1 (1+1) div 2> 10 falso 1

2 3 (2+3) div 2> 10 falso 2

3 6 (3+6) div 2> 10 falso 3

4 10 (4+10) div 2> 10 falso 4

5 15 (5+15) div 2> 10 falso 5

6 21 (6+15) div 2> 10 verdadero 6

Problema 2.7 Al ejecutar el siguiente programa

Program Repetir;

var a,b,c: integer;

begin

a:=0;

b:=0;

readln(c);

repeat

a:=a+1;

b:=a+b;

writeln(a);

until (a+b) div c> 10;

end.

Se obtiene

a) 1,3,5,7,9

b) 2,4,6,8,10

c) 1,2,3,4,5,6

d) 1,2,3,4,5,6,7,8,9,10

e) Ninguna de las

anteriores

Program Condicionales;

var a,b,c: integer;

begin

a:=2;

b:=2;

c:=4;

repeat

if a=0 then

if b=1 then

if (c mod 2 = 1) then

writeln('fin')

else

c:=c-1

else

b:=b-1

else

a:=a-1;

writeln(a,' ',b,' ',c);

until ((a+b)=(c mod 2)) ;

end.

a) 1 2 4

0 2 4

0 1 4

0 1 3

b) 1 2 4

0 2 4

0 1 4

0 0 3

c) 1 2 4

1 2 4

0 1 4

0 1 3

d) 1 2 4

0 2 4

0 1 4

0 0 3

e) 1 2 4

0 2 4

0 1 4

0 1 3

fin

se obtiene:




Solución : Este es un problema interesante para las personas que tienen problemas con las estructuras condicionales.

a b c c mod 2 = 1 ((a+b)=(c mod 2) Se imprime

2 2 4

1 2 4 1+2=4 mod 2 falso 1 2 4

0 2 4 0+2=4 mod 2 falso 0 2 4

0 1 4 0+1=4 mod 2 falso 0 1 4

0 1 3 4 mod 2 = 1 falso 0+1=3 mod 2 verdadero 0 1 3

a) verdadero b) falso c) falso d) falso e) falso


xii. Escribir un programa en Java que calcula el equivalente en grados Fahrenheit o Celsius de las siguientes temperaturas. {Regla de 3: Celsius / 5 = (Fahrenheit – 32)/ 9}

Program Grados; USES Crt; Var Fahrenheit, Celsius:REAL;

T1C,T2F:REAL; Respuesta:CHAR;

Begin ClrScr; Repeat Begin Write ('Desea pasarlo a Fahrenheit o Celsius? F/C: '); Readln (respuesta); Writeln (''); End; Until (respuesta='C') Or (respuesta='F') Or (respuesta='c') Or (respuesta='f'); If UPCASE(respuesta)='F' Then Begin Writeln ('Introduzca los grados para pasar a Fahrenheit: '); Write ('Celsius: '); Readln (Celsius); Fahrenheit:= ((9 * Celsius) / 5) + 32; Write (Fahrenheit:5:2,' grados Fahrenheit.'); Writeln (' '); End Else If UPCASE (respuesta)='C' Then Begin Writeln ('Introduzca los grados para pasar a Celsius: '); Write ('Fahrenheit: '); Readln (Fahrenheit); Celsius:= ((Fahrenheit - 32) / 9) * 5; Write (Celsius:5:2,' grados Celsius.'); End; End.




xiii. Escribir un programa en Java que realice un bucle con While y muestre en pantalla del 1 al 10.

Program Uno_diez; USES CRT; VAR x:Integer; Begin x:=0; ClrScr; While X <= 10 DO Begin Writeln (x); x:=x+1; End; End.

xiv. Escribir un programa en Java que realice un bucle con Repeat y muestre en pantalla del 1 al 10.

Program Uno_diez; USES CRT; VAR x:Integer; Begin x:=0; ClrScr; Repeat Writeln (x); x:=x+1; Until x=10; End.

xv. Escribir un programa en Java que realice un bucle con For y muestre en pantalla del 1 al 10.

Program Uno_diez; USES CRT; VAR x:Integer; Begin ClrScr; For x:=0 To 10 Do Writeln(x); End.

xvi. Escribir un programa en Java que visualice en pantalla los números pares entre 1 y 25.

Program pares; USES CRT; VAR num:Integer; Begin num:=2; ClrScr; Repeat Writeln (num); num:= num + 2; Until num= 26; End.




Program pares2; USES CRT; VAR sem:Integer; Begin ClrScr; sem:=1; While sem <= 25 DO Begin If sem mod 2=0 Then Writeln(sem); sem:=sem + 1; End; End.

xvii. Escribir un programa en Java que visualice en pantalla los números múltiplos de 5 comprendidos entre 1 y n.

Program Multiplo_5; USES CRT; VAR sem,n : Integer; Begin ClrScr; Readln(n); For sem:= 1 To n Do Begin If sem mod 5=0 Then Writeln(sem); End; End.

xviii. Escribir un programa en Java que sume los números comprendidos entre 1 y 10.

Program Suma10; USES CRT; VAR num, x:Integer; Begin ClrScr; num:=1; x:=1; While num <= 10 DO Begin Writeln (x); num:= num + 1; x:= x + num; End; End.




xix. Escribir un programa en Java que genere la tabla de multiplicar de un número introducido por el teclado.

Program Tabla_Mult; USES CRT; VAR tabla, x, num:Integer; Begin ClrScr; Write ('Introduzca un numero para hacer su tabla de multiplicar: '); Readln (num); Writeln (''); Repeat Writeln (tabla); x:= x + 1; tabla:= num * x; Until x=11; End.

xx. Escribir un programa en Java que realice la pregunta ¿Desea continuar S/N? y que no deje de hacerla hasta que el usuario teclee N.

Program Si_No1; USES CRT; VAR respuesta:CHAR; Begin ClrScr; Repeat Writeln ('DESEA CONTINUAR: S/N '); Readln (respuesta); Until respuesta='N'; {Java distingue entrebn n yN} End.

Program si_No2; USES CRT; VAR respuesta:STRING; Begin ClrScr; Repeat Writeln ('DESEA CONTINUAR: SI/NO '); Readln (respuesta); Until respuesta='NO'; End.

Program Si_No3; USES CRT; VAR resp:CHAR; Begin ClrScr; resp:='S'; While UPCASE(resp)='S' DO Begin Write('Desea continuar? '); Readln(resp); End; End.




xxi. Escribir un programa en Java que calcule cuantos años tarda en duplicarse un capital depositado al 5% de interés anual

Program Capital1; USES CRT; VAR tiempo, cap_ini, cap_fin:REAL; CONST interes = 0.05; Begin ClrScr; Write ('Intruduzca el capital para calcular cuanto tardara '); Write ('en duplicarse, con un interes del 5%: '); Readln (cap_ini); Writeln (''); If cap_ini < 0 Then Begin Write ('No se puede incluir un capital negativo'); Exit; End; tiempo:=0; cap_fin:= cap_ini; Repeat cap_fin:=cap_fin + (cap_fin * interes); tiempo:= tiempo + 1; Until cap_fin > (cap_ini * 2); Writeln ('Tardara',tiempo:3:0,' aÒos en duplicarse'); Writeln ('Capital final: ',cap_fin:5:2,' pts'); End. Program Capital2; USES CRT; VAR cap_ini,cap_fin:REAL; VAR num_year:Integer; const INTERES=0.05; Begin ClrScr; num_year:=0; Write('Capital inicial -----: '); Readln(cap_ini); cap_fin:=cap_ini; While cap_fin < (cap_ini*2) DO Begin cap_fin:=cap_fin+(cap_fin*interes); num_year:=num_year + 1; End; Write('Capital inicial -----: '); Writeln(cap_ini:5:2); Write('Capital final -------: '); Writeln(cap_fin:5:2); Write('Capital duplicado en '); Write(num_year); Write(' aÒos'); End.




xxii. Escribir un programa que calcule la suma de los números hasta un número dado (introducido por el usuario).

Program Suma_N; USES CRT; VAR x, y, num:Integer; Begin ClrScr; Write ('Este programa calcula la suma de los numeros hasta uno '); Write ('introducido por el usuario: '); Readln (num); Writeln (''); x:=0; While num >= 0 DO Begin Writeln (x); x:= x + num; num:=num - 1; End; End.

Program Suma_N2; USES CRT; VAR i,num:Integer; VAR suma:LONGINT; Begin ClrScr; Write('Introduzca un numero -> '); Readln(num); FOR i:=0 TO num DO suma:=suma+ i; Write('Suma '); Write('0-'); Write(num); Write('---->'); Write(suma); End.

xxiii. Escribir un programa que pida un número y si el que se introduce por el teclado es menor de 100 que vuelva a solicitarlo.

Program Verifica1; USES CRT; VAR num:Integer; Begin {Este programa no finaliza hasta que se escribe un numero mayor a 100} ClrScr; Repeat Writeln ('Introduzca un numero: '); Readln (num); Until num > 100; End.




Program Verifica2; USES CRT; VAR num:Integer; Begin ClrScr; Write('Introduzca un numero -> '); Readln(num); While num<=100 DO Begin Write('Introduzca un numero -> '); Readln(num); End; End.

xiv Escribir un programa en Java que detecte si un número es primo o no. Un número es primo si sólo es divisible por sí mismo y por la unidad. Ejemplo: 2,3,4,7,11,17,19 son números primos 9 no es número primo, es divisible por 1, 9, 3 El algoritmo para resolver este problema pasa por dividir sucesivamente el número estudiado por 2,3,4, etc., hasta el propio número.

Program primo (INPUT,OUTPUT); Uses Crt; Var num: Word; {Los numeros primos son enteros mayores que 1 sin divisores enteros positivos, exceptuando el 1 y ellos mismos. Todos los primos son impares, excepto el 2. Solo es necesario comprobar la divisibilidad por numeros superiores a la raiz cuadrada del numero.} raiznum: Integer; {Guardamos el valor de la raiz del numero} noesprimo: Boolean; {Variable para decir que un numero no es primo} par: Boolean; {Nos sirve para marcar los numeros que son pares} i: Byte; {Variable que usamos dentro del bucle} Begin {p.p} ClrScr; Repeat Write('Introduzca un numero entero para ver si es primo: '); Read(num); Writeln; Until num > 1; {Pedimos un numero y no lo aceptamos hasta que sea > 1} par := num mod 2 = 0; {par va a ser True cuando el numero sea par} If num = 2 Then Write('El 2 es primo, es el unico numero par que lo es.') Else if par Then Write('Todo numero par no es primo, excepto el 2.') Else Begin raiznum := round(sqrt(num)); {Almacenamos la raiz del numero, redondeada}




For i := raiznum To (num - 1) Do Begin If (num mod i) = 0 Then noesprimo := true End; {Comprobamos la divisibilidad de los numeros superiores a la raiz cuadrada del numero introducido. Si algun numero divide al numero, noesprimo toma el valor true.} If noesprimo Then Write(num,' no es un numero primo') Else Write(num,' es un numero primo'); {Mostramos por pantalla si el numero es primo o no} End; End. {p.p}

Program Primo2; USES CRT; VAR i,num,flag:Integer; Begin ClrScr; flag:=0; Write('Introduzca un numero -> '); Readln(num); FOR i:=2 TO (num-1) DO Begin If (num mod i)=0 Then flag:=1; End; If flag=1 Then Begin Write(num); Write(' no es un numero primo'); End Else Begin Write(num); Write(' es un numero primo'); End; End.

xxv. Escribir un programa en Java que calcule la depreciación de un objeto según el método de la línea recta. Calcular el número de años que tarda en hacerse 0. En este método el valor original del objeto se divide por su vida (número de años). El cociente resultante será la cantidad en la que el objeto se deprecia anualmente. Por ejemplo, si un objeto se deprecia 8000 dólares en diez años, entonces la depreciación anual será 8000/10=800 dólares. Por tanto, el valor del objeto habrá disminuido en 800 dólares cada año. Nótese que la depreciación anual es la misma cada año cuando se utiliza este método.

Program depre1; USES CRT;




VAR annos, valor:REAL; VAR depreciacionanno:REAL; VAR x:Integer; Begin ClrScr; Writeln ('Escriba los datos para conocer la depreciacion anual'); Writeln (''); Write ('Valor original: '); Readln (valor); Write ('Numero de aÒos: '); Readln (annos); Writeln (''); depreciacionanno:= valor / annos; x:=0; While valor > 0.1 DO Begin valor:=valor - depreciacionanno; x:= x + 1; Writeln ('A—O ',x:2,': ',valor:8:0,' pts.'); End; End.

Program depre2; USES CRT; VAR val_ini,val_dep,tas_dep:REAL; VAR i,anios:Integer; Begin ClrScr; Write('Valor inicial -----> '); Readln(val_ini); Write('Numero de a_os ----> '); Readln(anios); tas_dep:=val_ini/anios;; val_dep:=val_ini-tas_dep; For I:=1 To anios Do Begin Write('A_o '); Write(i:3); Write(' ------ '); Writeln(val_dep:10:2); val_dep:=val_dep-tas_dep; End; End.

xxvi. Escribir un programa en Java que calcule la depreciación de un objeto según el método del balance doblemente declinante. En este método, el valor del objeto disminuye cada año en un porcentaje constante. Por tanto, la verdadera cantidad depreciada, en dólares, variara de un año al siguiente. Para obtener el factor de depreciación, dividimos por dos la vida del objeto. Este factor se multiplica por el valor del objeto al comienzo de cada año (y no el valor del original del objeto) para obtener la depreciación anual. Supongamos, por ejemplo que deseamos depreciar un objeto de 8000 dólares por diez años; el factor de depreciación será 2/10=0.2. Por tanto, la depreciación el




primer año será 0,2 X 8000 = 1600 dólares, la depreciación del segundo año será 0,2 X 6400=1280 dólares; la depreciación del tercer año será 0,2 X 5120 = 1024 dólares, y así sucesivamente.

Program EJER58; USES CRT; VAR fdd:REAL; {Factor de depreciacion} VAR vidaobj:REAL; {Vida del objeto = años} VAR depreciacionanno:REAL; VAR valorobj:REAL; {Valor del objeto} VAR x:Integer; Begin ClrScr; Write ('Para calcular la depreciación por el método del balance '); Writeln ('Doblemente declinante, escriba los datos:'); Writeln (''); Write ('Valor del objeto: '); Readln (valorobj); Write ('Año: '); Readln (vidaobj); Writeln (''); fdd:= 2 / vidaobj; x:=1; Repeat depreciacionanno:= fdd * valorobj; valorobj:=valorobj - depreciacionanno; Writeln ('Año ',x:2,': ',valorobj:8:2,' dol.'); x:= x + 1; Until x > vidaobj; Writeln (''); x:= x - 1; Writeln ('El valor a Los ',x,' Años será de ',valorobj:6:2,' dol.'); End.

xxvii Escribir un programa en Java que calcule el factorial de un número.

Program factorial1 USES CRT; VAR factorial, x, num, y:REAL; Begin {Este programa hace el factorial de un numero} ClrScr; Write ('Introduzca un numero para hacer su factorial: '); Readln (num); Writeln (''); x:=1; While num > 1 DO Begin x:=x * num; num:=num - 1; Writeln (x); End; End.




Program factorial2; USES CRT; VAR temp,num,fac:LONGINT; Begin ClrScr; fac:=1; temp:=num; Write('Introduzca un numero -> '); Readln(num); temp:=num; While num>=1 DO Begin fac:=fac*num; num:=num-1; End; Write('El factorial de '); Write(temp); Write(' es '); Write(fac); End.

19. Problemas Varios

Problema 2.8 Lo verdadero que se puede decir del programa y del algoritmo siguiente: es Ambos están diseñado para resolver problemas diferentes El algoritmo y el programa no pueden tener el mismo nombre El programa tiene errores de sintaxis pero no de lógica Están mal declaradas las variables en el algoritmo y en el programa Todas las anteriores son falsas Solución:

program Hor;

Var h,m,s1,s2:integer;

begin

write('Introduzca segundos: ');

READLN(s1);

h:=s1 div 3600;

s2:=s1 mod 3600;

m:=s2 div 60;

s2:=s2 mod 60;

write(s1); write(' segundos son --> ');

write(h) write(' horas ');

write (m) write(' minutos ');

write(s2); write( 'segundos ');

end

Algoritmo Hor

Var Entero h,m,s1,s2

Inicio

Escribir('Introduzca segundos: ')

Leer(s1)

hs1 div 3600

s2s1 mod 3600

ms2 div 60

s2s2 mod 60

Escribir(s1) Escribir (“ segundos son --> “)

Escribir (h) Escribir (“ horas “)

Escribir (m) Escribir (“ minutos “)

Escribir (s2) Escribir (“segundos “)

fin




Falso, ya que el lector podrá constatar que el algoritmo y el programa tienen la misma lógica y si tienen la misma lógica de seguro están diseñados para cumplir el mismo objetivo. Falso, ya que queda a criterio del programador los nombres que se ponen el los algoritmos y en los programas Verdadero, write(h) write(' horas ');

falta el punto y coma “;” write (m) write(' minutos ');

falta el punto y coma “;” d) Falso, las variables están bien declaradas en el programa ya que primero se coloca la palabra reservada Var luego los nombres de las variables seguido de una coma por cada uno y al final el tipo de datos de las variables. En el algoritmo no hay problema en la definición de variables, ya que cada autor declara las variables a su conveniencia. Falso, ya que el literal c es verdadero. Comparando cada uno de las respuestas de los literales verificamos que la respuesta a nuestro problema es el literal c Resp. Literal c Problema 2.9 Una de las siguientes proposiciones es falsa, identifíquela Las variables son nombres que se dan a los tipos de datos Los tipos de datos Reales son diferentes a los datos enteros Si A=1, B=2 y C=4 entonces A*B(1-C)/B-B=0 El punto y coma de la línea ii cierra la línea 1 if (i=2) then j:=j+1; i:=3; Los variables booleanas solo pueden tomar dos valores: Verdadero o Falso Solución: verdadero verdadero reemplazando los valores a las variables correspondientes tenemos: 1*2(1-4)/2-2=0 2(-3)/2-2=0 -3-2=0 falso verdadero verdadero Resp. Literal c




Problema 2.10 Una de las siguientes proposiciones es falsa, identifíquela Los errores de sintaxis por lo general se lo detectan en la compilación de los programas La siguiente sentencia: “Si (A=B) o ((B<>C) y (D>F)) entonces” es equivalente a “Si((A=B) o (B<>C)) y ( (A=B) o (D>F))) entonces” Las variables en programación son nombres que se le dan a los tipos de datos y éstas cambian en la compilación y en la ejecución del programa. La siguiente estructura de repetición Mientras (Condición) ........... Fin-Mientras deja de repetirse cuando la Condición es falsa Los variables boleanas solo pueden tomar dos valores: Verdadero o Falso Solución: verdadero b) verdadero c) falso d) verdadero e)es verdadero Resp. Literal b

20. Problemas Propuestos

Dados los valores correspondientes a las variables A=5 B=7 C=4 Donde se evalúa lo siguiente

i ( 3 + A) Div B + C

ii ( 7 Div (38 Mod C)) * 5

iii 3 + C* A – 35/7 – B * 33/11

iv ((1580 MOD 6*2^7) >(7+8*3^4)) OR ((15*2)=60*2/4) entonces determine las proposiciones falsas de: iv es verdadero El valor de i es 4 ii – iii = 0 ii es igual a 15 Todas las anteriores son verdaderas Dado el siguiente bucle Se puede decir que se imprime: a) 0, 1, 2, 3, 4, 5 b) 0, 1, 2, 3, 4, 5, 6 c) 1, 2, 3, 4, 5

i 0

mientras i < 6 hacer

escribir ( i )

i i + 1

fin_mientras




d) 1, 2, 3, 4, 5, 6 e) ninguna de las anteriores Del siguiente bucle se puede decir que se ejecuta a) cinco veces b) más de seis veces c) seis veces d) menos de seis veces e) menos de cinco veces La estructura para (desde) puede realizarse con algoritmos basados en estructuras mientras y repetir, por lo que pueden ser intercambiables cuando así lo desee. ¿Cuál de las siguientes algoritmos no correspondería a una equivalencia en encontrar la solución, con la estructura para(desde)?

para i 1 hasta n incremento 1 hacer

<acciones>

fin_para

a)

inicio

i n

mientras i > 0 hacer

<acciones>

i i - 1

fin_mientras

fin

b)

inicio

i 1

mientras i <= n hacer

<acciones>

i i + 1

fin_mientras

fin

d)

inicio

i n + 1

repetir

<acciones>

i i - 1

hasta_que i = 1

fin

c)

inicio

i n

repetir

<acciones>

i i - 1

hasta_que i = 1

fin

i 0

mientras i < 6 hacer

i i + 1

escribir ( i )

fin_mientras




Si se ingresa 3 para N y 3 para P en el siguiente algoritmo se obtiene

a) 0 b) 27 c) 9 d) 6 e) N. Anteriores

Algoritmo Incógnita1

Var

Entero N, P,i,j,x

inicio

leer (N)

leer (P)

x 1

Para i 1 hasta P

suma 0

Para j 1 hasta x

suma suma + N

Fin-Para

x suma Fin-Para

Escribir( suma)

Fin

e)

inicio

i 1

repetir

<acciones>

i i + 1

hasta_que i > n

fin




Al ingresar N=9 en el siguiente algoritmo se obtiene 0,1,1,2,3,5,8,13,21 0,1,1,2,3,5,8,13 0,1,1,2,3,5,8 0,1,1,2,3,5,8,13,21,34 Ninguna de las anteriores El siguiente diagrama de flujos

Algoritmo Incógnita2 Var Entero N,i,A,B,F Inicio

A 0

B 1

Para i 1 hasta N Imprimir A

F A + B

A B

B F Fin-Para

Fin

INICIO

S 0

i 0

Leer(n)

FIN

S

S S + i

i i + 1 i < n n mod i

V V

F F

Calcula

a) 1+ 2 + 3 +. . . n

b) Suma de los números primos desde 0 hasta n

c) 2 + 3 + 4 + . . . (n+1)

d) Suma de los números que dividen a n

e) No calcula ninguna de las anteriores




Consideremos un vector X de ocho elementos:

X[1] X[2] X[3] X[4] X[5] X[6] X[7] X[8]

14.0 12.0 8.0 7.0 6.41 5.23 6.15 7.25

Al cual se realizan las siguientes acciones

X[4] 45

Suma X[1] + X[3]

Suma Suma + X[4]

X[5] X[5] + 3.5

X[6] X[1] + X[2]

Entonces el vector modificado sería:

X[1] X[2] X[3] X[4] X[5] X[6] X[7] X[8]

14.0 12.0 8.0 45.1 9.91 25.0 22.0 68.0

X[1] X[2] X[3] X[4] X[5] X[6] X[7] X[8]

14.0 12.0 8.0 45.0 9.91 26.0 23.0 67.0

X[1] X[2] X[3] X[4] X[5] X[6] X[7] X[8]

14.0 12.0 8.0 47.0 9.92 26.0 22.0 67.0

X[1] X[2] X[3] X[4] X[5] X[6] X[7] X[8]

14.0 12.0 8.0 45.0 9.91 26.0 22.0 67.0

a)

b)

c)

d)

e) Ninguna de las anteriores




Escriba un algoritmo que tenga la misma interpretación al siguiente diagrama de flujos Escriba un algoritmo que lea un número N que sea entero positivo e imprima todos los pares entre 1 y N inclusive.

INICIO

FIN

S 0

i 0

Leer(n)

n = -9999 i i + 1

S S + n

P S / i

P

F

V

Algoritmo flujo

Var

Entero S,i,n

Real P

Inicio

Fin

Algoritmo Suma_par

Fin




Si D y E son variables boleanas y A, B y C son variables numéricas determinar los valores de las variables al final de todos los pasos

A 0

B 10

C 10 Div (A + 4)+ A*B-10

D Not (C B)

A B – C

D NOT (A 49) OR (43 – 8* 2 DIV 4 <> 3 * 2 DIV 2)

E (A=B) AND ((C MOD A<= B) OR NOT(( C DIV B) MOD 2 = 0))

Escriba el resultado de salida del siguiente algoritmo si se ingresa 5, 10 para n y m respectivamente Dado el siguiente Problema “Si se dan dos números enteros positivos X y Y, se desea presentar el resultado XY ” y su solución: Paso1: Se obtienen los valores de X y Y enteros Paso2: Se asigna a un contador i el valor de Cero Paso3: Se asigna a una Variable R = 1 Paso4: Se asigna a R = R*X Paso5: Se incrementa i = i + 1 Paso6: Se pregunta si i = Y, si es verdadero ir al paso 7, si es falso ir al paso 4 Paso7: Se presenta R Determine los valores de Verdad para cada proposición siguiente: Si a i se le asignaría 1 en el paso dos, el algoritmo cumpliría con su objetivo Si a R se le asignaría X*X en el paso tres, el algoritmo cumpliría con su objetivo Si se preguntaría es i < X en el paso 6, el algoritmo cumpliría con su objetivo Si se incrementaría i = i + R en el paso 5, el algoritmo cumpliría con su objetivo Si se incrementaría i = i + X en el paso 5, el algoritmo cumpliría con su objetivo El algoritmo cumple con su objetivo

Algoritmoprueba

Var Entero i,j,n,m

Inicio

j0

i0

Leer(n)

Leer(m)

Para i n hasta m

Si i>i then

ji+j

Si-no

ij+i

Fin –Si

Fin-Para

Escribir(i,,j)

Fin




Determine los valores de verdad para cada proposición Las variables cambian en la compilación de un programa Los tipo de datos reales ocupan el mismo espacio de memoria que los tipo de datos enteros La ejecución de un programa solo sirve para detectar errores de lógica El punto y coma de la línea iv cierra la estructura de repetición for de la línea i for j:=1 to 10 do if j mod 2 = 0 then R:=2; Valor:=0; Los errores de sintaxis en el siguiente programa están en la línea i,iii,vii Program menu var S: String; integer i,j; Begin for i:= 1 to Length(S) do writelm(S[i]); end. Determine el valor de verdad para cada proposición correspondiente a cada pregunta Del Siguiente programa se puede decir que: Existe un error en la línea 3 La variable N y J no necesitan ser declaradas El punto y coma de la línea 10 cierra la concisión If de la línea 7 Es necesario colocar un Begin dentro de la estructura Repeat para que se ejecute la asignación Existen 3 errores de sintaxis en el programa tipo

1. Program tipo;

2. Uses Crt;

3. Var i:Int;

4. Begin

5. Readln(i);

6. For I:=1 to N do

7. if N=j then

8. Repeat

9. I:=j+1;

10. Until j=N;

11. end;




De las estructuras y definiciones de puede decir que: La estructura de repetición While no necesita de la sentencia begin-end cuando se desean ejecutar mas de dos sentencias internas a esta estructura Existe diferencias cuando se declaran variables con letras mayúsculas y minúsculas La estructura siguiente no tiene errores de sintaxis If a=2 then i:=2 else if a=5 then a:=8 else a:=5; La estructura siguiente no tiene errores de sintaxis If a=2 then i:=2; else .j:=5; Todos las dimensiones de los arreglos se pueden cambiar mientras se ejecutan los programas Se tiene el siguiente problema: “Si se da un número entero N, se desea presentar el resultado (1+2+3+....+N)/N ” Solución Paso1: Se obtiene el valor de N Paso2: Se asigna a un contador i el valor de Cero Paso3: Se asigna a una Variable S = 0 Paso4: Se asigna a S = S + i Paso5: Se incrementa i = i + 1 Paso6: Se pregunta si i >= N, si es verdadero ir al paso 7, si es falso ir al paso 4 Paso7: Se asigna a una variable P = (S+N)/N Paso8: Se presenta P Entonces es verdad que Si a i se le asignaría 1 en el paso 2, el algoritmo cumpliría con su objetivo El algoritmo cumple con su objetivo Si se asigna a S=1 en el paso3 y se presenta P-1 en el paso8, el algoritmo cumpliría con su objetivo. Si se asignaría P=S/N en el paso7, el algoritmo cumpliría con su objetivo Todas las proposiciones anteriores son falsas

Se utiliza Sqrt(x) para calcular x y Pow(x,y) para calcular x y , represente en forma

de ecuación para representar lo siguiente




Si se ingresa n igual a 34 en el siguiente diagrama de flujos Se obtiene: a) 34,17,52,26,13,40,10,5,16,8,4,2,1 b) 22,34,17,52,26,13,40,20,10,5,16,8,4,2,1 c) 17,52,26,40,20,10,16,8,4,2,1 d) 17,52,26,13,40,1 e) 17,52,26,13,40,20,10,5,16,8,4,2,1 Si se ingresa un número entero positivo n en el siguiente algoritmo

Program Incognita;

var

n: integer;

begin

Readln(n);

repeat

if (n mod 2 = 0) then

begin

n:=n div 2;

writeln(n);

end

else

begin

n:=n*3 + 1;

writeln(n);

end;

until n=1;

end.

Program incognita;

var

n:Real; i:integer;

begin

readln(n);

i:=1;

while (i>n) do

begin

n:=n*n;

i:=i+1;

end;

writeln(n);

end.

yx

y

xxa




Una de las siguientes proposiciones es verdadera identifíquelas Las variables cambian en la compilación de un programa Los tipo de datos reales ocupan el mismo espacio de memoria que los tipo de datos enteros La ejecución de un programa solo sirve para detectar errores de lógica El punto y coma de la línea 4 cierra la estructura de repetición for de la línea 1 for j:=1 to 10 do if j mod 2 = 0 then R:=2; Valor:=0; Los errores de sintaxis en el siguiente programa están en la línea 1,3,7 Program menu var S: String; integer i,j; Begin for i:= 1 to Length(S) do writelm(S[i]); end. El siguiente diagrama de flujos

Entonces , se imprime:

a) ni

b) nn

c) nn-1

d) n

e) No imprime algo

INICI

O

FIN

leer(n

)

i 1

i

i <n V

V

F

i 1+1

n mod i= 0

F




Calcula: Los múltiplos de n Los divisores de n comprendidos entre 1 y n-1 Los divisores de n comprendidos entre 1 y n Los divisores de n comprendidos entre 1 y n+1 Los números pares comprendidos entre 1y n Si se tiene el siguiente diagrama de flujos y el algoritmo F1 Entonces las sentencias que faltan en la línea 8 y 11 para que el algoritmo y el diagrama realicen lo mismo es:

a) 8 Repetir

11 Hasta i=f

b) 8 Repetir

11 Hasta i=n

c) 8 Mientras i<>n

11 Fin-Mientras

d) Las sentencias

correcta no se encuentra

en las alternativas

e) 8 Mientras i=n

11 Fin -Mientras

INICIO

FIN

Leer(n)

f f*i

ii+1

f1

i1

f

n = i

1. Algoritmo F1

2. Var

3. Entero n,i,f

4. Inicio

5. Leer(n)

6. f 1

7. i 0

8.

9. i i + 1

10. f f * i

11.

12. Escribir (f)

13. Fin

F

V




Escriba un programa en Java que evalué la siguiente función

Se realiza un examen, se piden las notas del número de alumnos introducidos por el usuario, las cuales pueden ser únicamente enteras entre 0 y 10. Debe decirse cuantos 0, 5 y 10 han aparecido. También deben decirse las notas introducidas que no sean 0, 5 o 10.

Realizar un programa que calcule el producto de dos números sin utilizar el operador de multiplicación (*)

Realizar un programa que sume los primeros n números enteros positivos donde n se ingresa por el teclado.

Escribir un programa que, dados dos números, N y P elevar el número N a la potencia P sin utilizar el operador de potencia (^) ni el operador de multiplicación (*)

Escribir un programa que imprima cuantas horas, minutos y segundos que hay en N segundos ingresados por el teclado

Complete el siguiente programa que está diseñado para verificar si una cadena de caracteres de longitud 5 es igual a la inversa de otra cadena de longitud 5, cada una de ellas ingresadas carácter por carácter.

Escriba un programa en Java que muestre la suma y el promedio de los factores primos de un número entero positivo mayor que 2.

Escribir un programa en Java que transforme números entre 1 y 999 a números romanos.

Escribir un Programa en Java que lea 2 números reales positivos y devuelva la potencia entera a la que hay que elevar el primero para que de el número más próximo posible del segundo.

El valor de PI se puede calcular sabiendo que la serie:

1 - 1/3 + 1/5 - 1/7 + 1/9 - 1/11 + 1/13 - 1/15..... tiende a PI/4. Escriba un programa en Java que calcule una aproximación al número PI/3 usando un Número de términos suministrado por el Usuario

Escribir un programa en Java que pida al usuario el año, mes y día correspondiente a cualquier fecha. El programa debe validar si los valores ingresados corresponden a una fecha valida.

Escribir un Programa en Java que determine el número que mas veces se repite de n valores ingresados.

Escribir un programa en Java que reciba un numero del 1 al 12 desde el teclado y muestre el número de días correspondiente al mes que corresponda con ese día

Hacer un programa que lea los 3 lados de un triangulo desde el teclado y nos diga si es equilátero (3 lados iguales), isósceles (2 lados iguales) o escalano (3 lados desiguales).

Decir si una frase es o no un palíndromo, es decir, si se lee igual de derecha a izquierda que de izquierda a derecha.

Escribir un programa, que con funciones, verifique si un carácter introducido es un número o no.

1;1

11;

01;1

)(3

2

xx

xxx

xx

xf




Tercera Parte PROGRAMACIÓN

ORIENTADA A OBJETOS




Java Introducción.- Presentaremos la Programación en Java. Hay dos tipos de programas en Java: aplicaciones y applets. APLICACIONES: Una aplicación en Java es un programa que se ejcuta utilizando el intérprete de java. Consta de un solo archivo .java que genera un archivo .class al ser compilado. El código fuente de nuestro programa llamado en éste ejemplo HolaMundo.java y se muestra a continuación: /*Programa para imprimir texto*/ //Nombre de la clase public class HolaMundo { /* El método main es invocado cuando la aplicación comienza*/ public static void main (String args []) { System.out.print ("Hola Mundo"); } //fin del método main } //fin de la clase HolaMundo NOTA: Los programas en Java siempre deben tener un procedimiento main. En éste ejemplo el archivo debe llamarse "HolaMundo.java". El nombre de la clase en public class HolaMundo, siempre debe coincidir con el nombre del archivo. También es importante el uso de comentarios ya que nos permitirá tener más organizado nuestro programa. Los comentarios siempre deben de ir precedidos de // o también entre /*Comentario*/, él último se lo utiliza comúnmente para comentar varias líneas. No olvidar que en éste caso no es necesario el uso de librerías, porque es un programa muy sencillo, pero no olvidar que las librerías principales deben ir: import java.io.*; import java.lang.*; Entonces el programa quedaría así: import java.io.*; import java.lang.*; /*Programa para imprimir texto*/




//Nombre de la clase public class HolaMundo { /* El método main es invocado cuando la aplicación comienza*/ public static void main (String args []) { System.out.print ("Hola Mundo"); } //fin del método main } //fin de la clase HolaMundo LIBRERÍAS El uso de las librerías es importante y ese puede ser un error común al olvidarnos de colocarlos en el programa. Siempre van al pricipio del programa. Cuando utilizamos una librería, realmente lo que estamos haciendo es importar métodos, sentencias, que permitarán la compilación correcta del programa. import java.io.*; Es comunmente usada con la siguiente línea: public static void main (String args [])throws IOException{ Es decir si colocamos esa línea debe ir a la labrería que contiene ese método para poder ejecutarla. public static void main (String args[ ]) { La segunda línea de este programa en java es complicada por el diseño de Java, que obliga a que no haya funciones globales, solo clases. Esta línea es igual en todos los programas, entonces vamos a estudiarla con detenimiento. public Esta palabra es un especificador de acceso que permite que el programador controle la visibilidad de cada variable o metodo. En este caso public indica que cualquier clase puede ver el método main. Hay otros dos especificadores de acceso: private y protected. static En Java existen otra clasificación de variables y métodos que pueden dividirse en variables y metodos de clase y de instancia. Cuando las variables y los métodos se aplican a la clase y no a la instancia se declaran como static. void Significa que la función no retorna ningún valor. main El nombre de la función. Java es sensible a mayúscular por ello será diferente main a Main. Cuando se le dice a la máquina virtual que implemente una clase el sistema




busca una función main para ejecutar en primer lugar. El compilador puede compilar clases que no tengan una función main, sin embargo, el interpretador de Java será incapaz de ejecutarlo. String args[ ] Es el vector de parámetros que se le pasa a la clase al momento de ejecución, args es un vector de cadenas de caracteres. Para más información sobre la clase String vea java.lang.String

PAQUETES La palabra clave package permite agrupar clases e interfaces. Los nombres de los paquetes son palabras separadas por puntos y comas se almacenan en directorios que coinciden con esos nombres. Por ejemplo, los ficheros siguientes, que contienen código fuente Java: Applet.java, AppletContext.java, AppletStub.java, AudioClip.java contienen en su código la línea: package java.applet; Y las clases que se obtienen de la compilación de los ficheros anteriores, se encuentran con el nombre nombre_de_clase.class, en el directorio: java/applet Import Los paquetes de clases se cargan con la palabra clave import, especificando el nombre del paquete como ruta y nombre de clase (es lo mismo que #include de C/C++). Se pueden cargar varias clases utilizando un asterisco. import java.Date; import java.awt.*; Si un fichero fuente Java no contiene ningún package, se coloca en el paquete por defecto sin nombre. Es decir, en el mismo directorio que el fichero fuente, y la clase puede ser cargada con la sentencia import: import MiClase; Paquetes de Java El lenguaje Java proporciona una serie de paquetes que incluyen ventanas, utilidades, un sistema de entrada/salida general, herramientas y comunicaciones. En la versión actual del JDK, los paquetes Java que se incluyen son: java.applet Este paquete contiene clases diseñadas para usar con applets. Hay una clase Applet y tres interfaces: AppletContext, AppletStub y AudioClip. java.awt El paquete Abstract Windowing Toolkit (awt) contiene clases para generar widgets y componentes GUI (Interfaz Gráfico de Usuario). Incluye las clases Button, Checkbox, Choice, Component, Graphics, Menu, Panel, TextArea y TextField. java.io El paquete de entrada/salida contiene las clases de acceso a ficheros: FileInputStream y FileOutputStream. java.lang

http://www.altatorre.com/webclase/java/api/java.lang.String.html




Este paquete incluye las clases del lenguaje Java propiamente dicho: Object, Thread, Exception, System, Integer, Float, Math, String, etc. java.net Este paquete da soporte a las conexiones del protocolo TCP/IP y, además, incluye las clases Socket, URL y URLConnection. java.util Este paquete es una miscelánea de clases útiles para muchas cosas en programación. Se incluyen, entre otras, Date (fecha), Dictionary (diccionario), Random (números aleatorios) y Stack (pila FIFO).

Tipos de Clases Hasta ahora sólo se ha utilizado la palabra clave public para calificar el nombre de las clases que hemos visto, pero hay tres modificadores más. Los tipos de clases que podemos definir son: public Las clases public son accesibles desde otras clases, bien sea directamente o por herencia, desde clases declaradas fuera del paquete que contiene a esas clases públicas, ya que, por defecto, las clases solamente son accesibles por otras clases declaradas dentro del mismo paquete en el que se han declarado. Para acceder desde otros paquetes, primero tienen que ser importadas. La sintaxis es: public class miClase extends SuperClase implements miInterface,TuInterface { // cuerpo de la clase } Aquí la palabra clave public se utiliza en un contexto diferente del que se emplea cuando se define internamente la clase, junto con private y protected. abstract Una clase abstract tiene al menos un método abstracto. Una clase abstracta no se instancia, sino que se utiliza como clase base para la herencia. Es el equivalente al prototipo de una función en C++. final Una clase final se declara como la clase que termina una cadena de herencia, es lo contrario a una clase abstracta. Nadie puede heredar de una clase final. Por ejemplo, la clase Math es una clase final. Aunque es técnicamente posible declarar clases con varias combinaciones de public, abstract y final, la declaración de una clase abstracta y a la vez final no tiene sentido, y el compilador no permitirá que se declare una clase con esos dos modificadores juntos. synchronizable Este modificador especifica que todos los métodos definidos en la clase son sincronizados, es decir, que no se puede acceder al mismo tiempo a ellos desde distintos threads; el sistema se encarga de colocar los flags necesarios para evitarlo. Este mecanismo hace que desde threads diferentes se puedan modificar las mismas variables sin que haya problemas de que se sobreescriban. Si no se utiliza alguno de los modificadores expuestos, por defecto, Java asume que una clase es:




No final No abstracta Subclase de la clase Object No implementa interfaz alguno

Manejo de excepciones A continuación se muestra cómo se utilizan las excepciones, reconvirtiendo en primer lugar el applet de saludo a partir de la versión iterativa de HolaIte.java: import java.awt.*; import java.applet.Applet; public class HolaIte extends Applet { private int i = 0; private String Saludos[] = { "Hola Mundo!", "HOLA Mundo!", "HOLA MUNDO!!" }; public void paint( Graphics g ) { g.drawString( Saludos[i],25,25 ); i++; } } Normalmente, un programa termina con un mensaje de error cuando se lanza una excepción. Sin embargo, Java tiene mecanismos para excepciones que permiten ver qué excepción se ha producido e intentar recuperarse de ella. Vamos a reescribir el método paint() de esa versión iterativa del saludo: EJERCICIO 1 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE EL MENEJO DE EXCEPCIONES. public void paint( Graphics g ) { try { g.drawString( Saludos[i],25,25 ); } catch( ArrayIndexOutOfBoundsException e ) { g.drawString( "Saludos desbordado",25,25 ); } catch( Exception e ) { // Cualquier otra excepción System.out.println( e.toString() ); } finally { System.out.println( "Esto se imprime siempre!" ); } i++; }




La palabra clave finally define un bloque de código que se quiere que sea ejecutado siempre, de acuerdo a si se capturó la excepción o no. try Es el bloque de código donde se prevé que se genere una excepción. Es como si dijésemos "intenta estas sentencias y mira a ver si se produce una excepción". El bloque try tiene que ir seguido, al menos, por una cláusula catch o una cláusula finally. La sintaxis general del bloque try consiste en la palabra clave try y una o más sentencias entre llaves. try { // Sentencias Java } Puede haber más de una sentencia que genere excepciones, en cuyo caso habría que proporcionar un bloque try para cada una de ellas. Algunas sentencias, en especial aquellas que invocan a otros métodos, pueden lanzar, potencialmente, muchos tipos diferentes de excepciones, por lo que un bloque try consistente en una sola sentencia requeriría varios controladores de excepciones. También se puede dar el caso contrario, en que todas las sentencias, o varias de ellas, que puedan lanzar excepciones se encuentren en un único bloque try, con lo que habría que asociar múltiples controladores a ese bloque. Aquí la experiencia del programador es la que cuenta y es el propio programador el que debe decidir qué opción tomar en cada caso. Los controladores de excepciones deben colocarse inmediatamente después del bloque try. Si se produce una excepción dentro del bloque try, esa excepción será manejada por el controlador que esté asociado con el bloque try. catch Es el código que se ejecuta cuando se produce la excepción. Es como si dijésemos "controlo cualquier excepción que coincida con mi argumento". No hay código alguno entre un bloque try y un bloque catch, ni entre bloques catch. La sintaxis general de la sentencia catch en Java es la siguiente: catch( UnTipoTrhowable nombreVariable ) { // sentencias Java } El argumento de la sentencia declara el tipo de excepción que el controlador, el bloque catch, va a manejar. En este bloque tendremos que asegurarnos de colocar código que no genere excepciones. Se pueden colocar sentencias catch sucesivas, cada una controlando una excepción diferente. No debería intentarse capturar todas las excepciones con una sola cláusula, como esta: catch( Excepcion e ) { ... Esto representaría un uso demasiado general, podrían llegar muchas más excepciones de las esperadas. En este caso es mejor dejar que la excepción se propague hacia arriba y dar un mensaje de error al usuario.




MOSTRAR TEXTO EN JAVA Es importante recalcar que para mostrar texto en Java se utiliza: System.out.print Pero, también tenemos otra instrucción que sirve para mostrar texto y dar salto de línea al mismo tiempo y es la siguiente: System.out.println

NOTE QUE LA LÍNEA 3 ES UNA LÍNEA EN BLANCO, LOS PROGRAMADORES USUALMENTE DEJAN ESAS LÍNEAS EN BLANCO PARA FACILITAR LA LECTURA DEL PROGRAMA. EJERCICIO 1 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE EL MENSAJE SIGUIENTE: Hola Mundo. import java.io.*;




import java.lang.*; public class HolaMundo { public static void main (String args []) { System.out.print ("Hola Mundo"); } }

ERROR COMÚN OMITIR EL PUNTO Y COMA(;) AL FINAL DE LA INSTRUCCIÓN. System.out.print ("Hola Mundo"); EJERCICIO 2 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE UN MENSAJE CON VARIAS INSTRUCCIONES. import java.io.*; import java.lang.*; public class HolaMundo2 { public static void main (String args []) { System.out.print ("Hola "); System.out.println ("Mundo"); } }

NOTE QUE: System.out.print ("Hola "); System.out.println ("Mundo"); DESPUÉS DE ESCRIBIR HOLA HAY UN ESPACIO EN BLANCO, ESE ESPACIO ES NECESARIO PARA QUE EL MENSAJE DE HOLA MUNDO NO SALGA JUNTO, POR EJEMPLO: HolaMundo




TAMBIÉN COMO SE LO MENCIONÓ ANTERIORMENTE ACERCA DE LA LÍNEA DE System.out.println, NOS SIRVE PARA DAR SALTO DE LÍNEA, ES IMPORTANTE NO OLVIDARLO PORQUE SINO EL MENSAJE VA A SALIR COMO EN EL EJERCICIO UNO.

NOTE LAS DIFERENCIAS. EJERCICIO 3 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE UN MENSAJE CON VARIAS INSTRUCCIONES, UNA PALABRA POR MENSAJE. import java.io.*; import java.lang.*; public class HolaMundoln { public static void main (String args []) { System.out.print ("Bienvenido"); System.out.print (" a"); System.out.print (" la"); System.out.print (" Programacion"); System.out.print (" en"); System.out.println (" Java"); } } NOTA: Se pueden realizar varias sentencias para mostrar mensajes en el mismo médoto Main.

NOTE EL ESPACIO QUE SE DEJA EN EL MENSAJE DESDE LA LÍNEA : System.out.print (" a"); ESTE MENSAJE SE LO PUDO HABER HECHO EN UNA SÓLA LÍNEA COMO EN EL EJERCICIO UNO Y DA EL MISMO RESULTADO. EJERCICIO 4




REALIZAR EL MISMO PROGRAMA DEL EJERCICIO 3, QUE MUESTRE EL MISMO RESULTADO PERO EN UNA SÓLA LÍNEA MUESTRE EL MENSAJE. import java.io.*; import java.lang.*; public class HolaMundoln1 { public static void main (String args []) { System.out.println ("Bienvenido a la Programacion en Java"); } }

SECUENCIAS DE ESCAPE \n -----> Nueva Línea. \t -----> Tabulador. \r -----> Retroceso de Carro. \f -----> Comienzo de Pagina. \b -----> Borrado a la Izquierda. \\ -----> El caracter "\". \' -----> El caracter "'". \" -----> El caracter '"'. LA BARRA DIAGONAL INVERSA SE CONOCE COMO CARÁCTER DE ESCAPE. ESTE CARÁCTER INDICA A LOS MÉTODOS PRINT Y PRINTLN DE SYSTEM.OUT QUE SE VA A IMPRIMIR UN CARACTER ESPECIAL. EJERCICIO 5 MOSTRAR VARIAS LÍNEAS DE TEXTO CON UNA SÓLA INSTRUCCIÓN, UTILIZANDO LAS SECUENCIAS DE ESCAPE NECESARIAS. import java.io.*; import java.lang.*; public class HolaMundo3 { public static void main (String args []) { System.out.println ("Bienvenido\na\nla\nprogramacion\nen Java!!!"); } }




EJERCICIO 6 MOSTRAR UNA LÍNEA DE TEXTO USANDO LA SECUENCIA DE ESCAPE PARA TABULAR O DAR ESPACIOS (\t). import java.io.*; import java.lang.*; public class HolaMundo4 { public static void main (String args []) { System.out.println ("Hola\tMundo"); } }

EJERCICIO 7 MOSTRAR UNA LÍNEA DE TEXTO QUE VAYA ENTRE COMILLAS DOBLES. import java.io.*; import java.lang.*; public class HolaMundo5 { public static void main (String args []) { System.out.println ("\"Hola Mundo\""); } }

EJERCICIO 8 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE UNA LÍNEA DE TEXTO QUE VAYA ENTRE COMILLAS SIMPLES. import java.io.*; import java.lang.*; public class HolaMundo5 { public static void main (String args []) { System.out.println ("\'Hola Mundo\'"); } }




EJERCICIO 9 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE UNA LÍNEA DE TEXTO PERO QUE BORRE UN CARÁCTER A LA IZQUIERDA. import java.io.*; import java.lang.*; public class HolaMundo9 { public static void main (String args []) { System.out.println ("Hola\bMundo"); } }

EJERCICIO 10 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE UNA LÍNEA DE TEXTO PERO QUE MUESTRE EL CARÁCTER \ EN EL MENSAJE. import java.io.*; import java.lang.*; public class HolaMundo10 { public static void main (String args []) { System.out.println ("Hola\\Mundo"); } }

USO DE CONSTANTES




Las constantes almacenan valores o cadenas de texto que se utilzarán en todo el programa de manera fija, y para no estar escribiendo a cada momento se los almacena en una constante. Y si se requiere mostrar el contenido de la constante, sólo se utiliza el nombre de la variable en el mensaje (Vea el ejercicio 11.) EJERCICIO 11 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE EL USO DE LAS VARIABLES Y TAMBIÉN DE LOS TIPOS DE DATOS. /*Programa para mostrar el uso de variables y tipos de datos*/ class MaximosDeVariablesApli{ public static void main(String[]args){ //Enteros. byte masGrandeByte=Byte.MAX_VALUE; short masGrandeShort=Short.MAX_VALUE; int masGrandeInt=Integer.MAX_VALUE; long masGrandeLong=Long.MAX_VALUE; //numeros de punto flotante. float masGrandeFloat=Float.MAX_VALUE; double masGrandeDouble=Double.MAX_VALUE; //otros tipos primitivos. char unChar='S'; boolean unBoolean=true; //desplegarlos todos. System.out.println("El valor mas grande de un byte es " +masGrandeByte); System.out.println("El valor mas grande de un short es " +masGrandeShort); System.out.println("El valor mas Grande de un int es " +masGrandeInt); System.out.println("El valor mas grande de un long es " +masGrandeLong); System.out.println("El valor mas grande de un float es " +masGrandeFloat); System.out.println("El valor mas grande de un double es " +masGrandeDouble); System.out.println("El valor de un caracter puede ser " +unChar); System.out.println("El valor de un boolean puede ser " +unBoolean+" o false"); } }

NOTA: UN TIPO DE DATO SIEMPRE ESTÁ RELACIONADO CON UNA VARIABLE. EJEMPLO:




int dato= 0;//Inicializo una variable con cero int= tipo de dato dato= variable Los tipos de tos enteros, double se inicializan con cero para que no almacenen valor basura a lo largo del programa.

La clase StringTokenizer La clase StringTokenizer nos ayuda a dividir un string en substrings o tokens, en base a otro string (normalmente un carácter) separador entre ellos denominado delimitador. Supongamos un string consistente en el nombre, y los dos apellidos de una persona separados por espacios en blanco. La clase StringTokenizer nos ayuda a romper dicho string en tres substrings basado en que el carácter delimitador es un espacio en blanco. EJERCICIO package tokens; import java.util.StringTokenizer; public class TokenApp { public static void main(String[] args) { String nombre="Angel Franco García"; StringTokenizer tokens=new StringTokenizer(nombre); while(tokens.hasMoreTokens()){ System.out.println(tokens.nextToken()); } String strDatos="6.3\n6.2\n6.4\n6.2"; tokens=new StringTokenizer(strDatos, "\n"); int nDatos=tokens.countTokens(); double[] datos=new double[nDatos]; int i=0; while(tokens.hasMoreTokens()){ String str=tokens.nextToken();




datos[i]=Double.valueOf(str).doubleValue(); System.out.println(datos[i]); i++; } try { //espera la pulsación de una tecla y luego RETORNO System.in.read(); }catch (Exception e) { } } } Un control área de texto, permite varias líneas de texto, cada línea está separada de la siguiente mediante un carácter nueva línea '\n' que se obtiene pulsando la tecla Enter o Retorno. Mediante una función denominada getText obtenemos todo el texto que contiene dicho control. La clase StringTokenizer nos permite dividir el string obtenido en un número de substrings o tokens igual al número de líneas de texto, basado en que el carácter delimitador es '\n'. Para usar la clase StringTokenizer tenemos que poner al principio del archivo del código fuente la siguiente sentencia import. import java.util.*; o bien import java.util.StringTokenizer; Los constructores Creamos un objeto de la clase StringTokenizer llamando a uno de los tres constructores que tiene la clase. Al primer constructor, se le pasa el string nombre que va a ser dividido teniendo en cuenta que el espacio en blanco es el delimitador por defecto. String nombre="Angel Franco García"; StringTokenizer tokens=new StringTokenizer(nombre); Supongamos ahora que en un control área de texto introducimos los siguientes datos, resultado de ciertas medidas, tal como se ve a la izquierda en la figura.

Obtenemos el texto del control área de texto. Creamos un objeto tokens de la clase StringTokenizer, pasándole el string strDatos y el delimitador "\n"

http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/clases1/paquetes.htm#El comando import

http://www.sc.ehu.es/sbweb/fisica/cursoJava/applets/ejemplos/error/error.html#Diseño del applet




String strDatos="6.3\n6.2\n6.4\n6.2"; StringTokenizer tokens=new StringTokenizer(strDatos, "\n"); Obtención de los tokens La clase StringTokenizer implementa el interface Enumeration, por tanto define las funciones nextElement y hasMoreElements. public class StringTokenizer implements Enumeration { //... public boolean hasMoreElements() { //... } public Object nextElement() { //... } } Para el programador es más cómodo usar las funciones miembro equivalentes nextToken y hasMoreTokens. Para extraer el nombre, el primer apellido y el segundo apellido en el primer ejemplo, escribiremos

String nombre="Angel Franco García"; StringTokenizer tokens=new StringTokenizer(nombre); while(tokens.hasMoreTokens()){ System.out.println(tokens.nextToken()); }

El segundo ejemplo, requiere un poco más de trabajo, ya que además de extraer los tokens del string strDatos, hemos de convertir cada uno de los substrings en un valor numérico de tipo double y guardarlos en el array datos del mismo tipo. Véase la sección convertir un string en un valor numérico. String str=tokens.nextToken(); datos[i]=Double.valueOf(str).doubleValue(); El número de tokens o de datos nDatos que hay en un string strDatos, se obtiene mediante la función miembro countTokens. Con este dato establecemos la dimensión del array datos. int nDatos=tokens.countTokens(); double[] datos=new double[nDatos]; Una vez guardados los datos introducidos en el control área de texto en el array datos, podemos operar con ellos, obteniendo su valor medio, y el error cometido en las medidas efectuadas. El código completo para extraer los tokens del string strDatos y guardarlos en un array datos, es el siguiente.

String strDatos="6.3\n6.2\n6.4\n6.2"; StringTokenizer tokens=new StringTokenizer(strDatos, "\n"); int nDatos=tokens.countTokens(); double[] datos=new double[nDatos]; int i=0; while(tokens.hasMoreTokens()){

http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/colecciones/vector.htm#Acceso a los elementos de un vector

http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/clases1/string.htm#Convertir un string en número




String str=tokens.nextToken(); datos[i]=Double.valueOf(str).doubleValue(); System.out.println(datos[i]); i++; }

La clase String Dentro de un objeto de la clases String o StringBuffer, Java crea un array de caracteres de una forma similar a como lo hace el lenguaje C++. A este array se accede a través de las funciones miembro de la clase. Los strings u objetos de la clase String se pueden crear explícitamente o implícitamente. Para crear un string implícitamente basta poner una cadena de caracteres entre comillas dobles. Por ejemplo, cuando se escribe System.out.println("El primer programa"); Java crea un objeto de la clase String automáticamente. Para crear un string explícitamente escribimos String str=new String("El primer programa"); También se puede escribir, alternativamente String str="El primer programa"; Para crear un string nulo se puede hacer de estas dos formas String str=""; String str=new String(); Un string nulo es aquél que no contiene caracteres, pero es un objeto de la clase String. Sin embargo, String str; está declarando un objeto str de la clase String, pero aún no se ha creado ningún objeto de esta clase. Cómo se obtiene información acerca del string Una vez creado un objeto de la clase String podemos obtener información relevante acerca del objeto a través de las funciones miembro. Para obtener la longitud, número de caracteres que guarda un string se llama a la función miembro length. String str="El primer programa"; int longitud=str.length(); Podemos conocer si un string comienza con un determinado prefijo, llamando al método startsWith, que devuelve true o false, según que el string comience o no por dicho prefijo String str="El primer programa"; boolean resultado=str.startsWith("El"); En este ejemplo la variable resultado tomará el valor true. De modo similar, podemos saber si un string finaliza con un conjunto dado de caracteres, mediante la función miembro endsWith. String str="El primer programa"; boolean resultado=str.endsWith("programa"); Si se quiere obtener la posición de la primera ocurrencia de la letra p, se usa la función indexOf.




String str="El primer programa"; int pos=str.indexOf('p'); Para obtener las sucesivas posiciones de la letra p, se llama a otra versión de la misma función pos=str.indexOf('p', pos+1); El segundo argumento le dice a la función indexOf que empiece a buscar la primera ocurrencia de la letra p a partir de la posición pos+1. Otra versión de indexOf busca la primera ocurrencia de un substring dentro del string. String str="El primer programa"; int pos=str.indexOf("pro"); Vemos que una clase puede definir varias funciones miembro con el mismo nombre pero que tienen distinto número de parámetros o de distinto tipo. Comparación de strings La comparación de strings nos da la oportunidad de distinguir entre el operador lógico == y la función miembro equals de la clase String. En el siguiente código String str1="El lenguaje Java"; String str2=new String("El lenguaje Java"); if(str1==str2){ System.out.println("Los mismos objetos"); }else{ System.out.println("Distintos objetos"); } if(str1.equals(str2)){ System.out.println("El mismo contenido"); }else{ System.out.println("Distinto contenido"); } Esta porción de código devolverá que str1 y str2 son dstintos objetos pero con el mismo contenido. str1 y str2 ocupan posiciones distintas en memoria pero guradan los mismos datos. Cambiemos la segunda sentencia y escribamos String str1="El lenguaje Java"; String str2=str1; System.out.prinln("Son el mimso objeto "+(str1==str2); Los objetos str1 y str2 guardan la misma referencia al objeto de la clase String creado. La expresión (str1==str2) devolverá true. Asñi pues, el método equals compara un string con un objeto cualquiera que puede ser otro string, y devuelve true cuando dos strings son iguales o false si son distintos. String str="El lenguaje Java"; boolean resultado=str.equals("El lenguaje Java"); La variable resultado tomará el valor true. La función miembro comapareTo devuelve un entero menor que cero si el objeto string es menor (en orden alfabético) que el string dado, cero si son iguales, y mayor que cero si el objeto string es mayor que el string dado. String str="Tomás"; int resultado=str.compareTo("Alberto");




La variable entera resultado tomará un valor mayor que cero, ya que Tomás está después de Alberto en orden alfabético. String str="Alberto"; int resultado=str.compareTo("Tomás"); La variable entera resultado tomará un valor menor que cero, ya que Alberto está antes que Tomás en orden alfabético. Extraer un substring de un string En muchas ocasiones es necesario extraer una porción o substring de un string dado. Para este propósito hay una función miembro de la clase String denominada substring. Para estraer un substring desde una posición determinada hasta el final del string escribimos String str="El lenguaje Java"; String subStr=str.substring(12); Se obtendrá el substring "Java". Una segunda versión de la función miembro substring, nos permite extraer un substring especificando la posición de comienzo y la el final. String str="El lenguaje Java"; String subStr=str.substring(3, 11); Se obtendrá el substring "lenguaje". Recuérdese, que las posiciones se empiezan a contar desde cero. Convertir un número a string Para convertir un número en string se emplea la función miembro estática valueOf (más adelante explicaremos este tipo de funciones). int valor=10; String str=String.valueOf(valor); La clase String proporciona versiones de valueOf para convertir los datos primitivos: int, long, float, double. Esta función se emplea mucho cuando programamos applets, por ejemplo, cuando queremos mostrar el resultado de un cálculo en el área de trabajo de la ventana o en un control de edición. Convertir un string en número Cuando introducimos caracteres en un control de edición a veces es inevitable que aparezcan espacios ya sea al comienzo o al final. Para eliminar estos espacios tenemos la función miembro trim String str=" 12 "; String str1=str.trim(); Para convertir un string en número entero, primero quitamos los espacios en blanco al principio y al final y luego, llamamos a la función miembro estática parseInt de la clase Integer (clase envolvente que describe los números enteros) String str=" 12 "; int numero=Integer.parseInt(str.trim()); Para convertir un string en número decimal (double) se requieren dos pasos: convertir el string en un objeto de la clase envolvente Double, mediante la función miembro

http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/estatico/estatico1.htm




estática valueOf, y a continuación convertir el objeto de la clase Double en un tipo primitivo double mediante la función doubleValue String str="12.35 "; double numero=Double.valueOf(str).doubleValue(); Se puede hacer el mismo procedimiento para convertir un string a número entero String str="12"; int numero=Integer.valueOf(str).intValue(); La clase StringBuffer En la sección dedicada a los operadores hemos visto que es posible concatenar cadenas de caracteres, es, decir, objetos de la clase String. Ahora bien, los objetos de la clase String son constantes lo cual significa que por defecto, solamente se pueden crear y leer pero no se pueden modificar. Imaginemos una función miembro a la cual se le pasa un array de cadenas de caracteres. Los arrays se estudiarán en la siguiente página.

public class CrearMensaje{ public String getMensaje(String[] palabras){ String mensaje=""; for(int i=0; i<palabras.length; i++){ mensaje+=" "+palabras[i]; } return mensaje; } //... }

Cada vez que se añade una nueva palabra, se reserva una nueva porción de memoria y se desecha la vieja porción de memoria que es más pequeña (una palabra menos) para que sea liberada por el recolector de basura (grabage collector). Si el bucle se realiza 1000 veces, habrá 1000 porciones de memoria que el recolector de basura ha de identificar y liberar. Para evitar este trabajo extra al recolector de basura, se puede emplear la clase StringBuffer que nos permite crear objetos dinámicos, que pueden modificarse.

public class CrearMensaje{ public String getMensaje(String[] palabras){ StringBuffer mensaje=new StringBuffer(); for(int i=0; i<palabras.length; i++){ mensaje.append(" "); mensaje.append(palabras[i]); } return mensaje.toString(); } //... }

http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/introduccion/operadores.htm#Concatenación de strings

http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/introduccion/operadores.htm#Concatenación de strings

http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/clases1/arays.htm

http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/clases1/clases.htm#La vida de un objeto




La función append incrementa la memoria reservada para el objeto mensaje con una palabra más sin crear nueva memoria, cada vez que se ejecuta el bucle. La función toString, que veremos más adelante, convierte un objeto en una cadena de caracteres. EJERCICIO 12 MOSTRAR UN MENSAJE UTILIZANDO UNA CONSTANTE QUE ALMACENE DICHO MENSAJE Y LUEGO MOSTRARLO POR PANTALLA. import java.io.*; import java.lang.*; public class Hola { public static void main(String[] args){ String saludo = "Hola Mundo!!!"; System.out.println( saludo ); } }

El mensaje que contiene la constante de tipo String debe ir entre comillas. String saludo = "Hola Mundo!!!"; Las constantes pueden ser de tipo String(Cadena de Caracteres), Int(enteros), double, float(coma flotante). NOTA: CUANDO SE REQUIERE INICIALIZAR LA VARIABLE DE TIPO STRING SE INICIALIZA CON COMILLAS DOBLES. String saludo = ""; Se inicializan las variables para que no almacenen valor basura a lo largo del programa. EJERCICIO 13 MOSTRAR DOS MENSAJES CON EL USO DE CONSTANTES. import java.io.*; import java.lang.*; public class UsoDeConstantes{ public static void main(String args[]){ String mensaje; mensaje = "Hola Mundo!!!";

http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/herencia/herencia.htm#La clase base Object




System.out.println( mensaje ); mensaje = ("Estoy utilizando variables"); System.out.println( mensaje ); } }

NOTA: VEA EL EJERCICIO 13, EL RESULTADO ES EL MISMO PERO LA DIFERENCIA ES QUE NUNCA TENDRÁ ERROR EN MOSTRAR EL MENSAJE EN EL EJ. 13, PERO PUEDE SER QUE SI PUEDA SUCEDER ALGÚN ERROR EN EL EJ. 12 EN CUALQUIER MOMENTO. EJERCICIO 14 REALIZAR EL MISMO PROGRAMA DEL EJERCICIO 12, PERO ÉSTA VEZ INICIALIZE LA VARIABLE STRING.+ import java.io.*; import java.lang.*; public class UsoDeConstantes1{ public static void main(String args[]){ String mensaje=""; mensaje = "Hola Mundo!!!"; System.out.println( mensaje ); mensaje = ("Estoy utilizando variables"); System.out.println( mensaje ); } }

EJERCICIO 15 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE POR PANTALLA UN CÓDIGO. import java.io.*; import java.lang.*;




public class Hola19 { public static void main(String[] args){ String codigo = "00402"; System.out.println(codigo); } }

NOTA: Cuando se muestra un número entero en un tipo String se presenta todos los números, pero cuando el tipo de dato es entero no presenta los primeros números que son ceros, es por eso que el número de la cédula tiene que ser de tipo String para mostrar todos los números. (Vea el ejercicio 16) EJERCICIO 16 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE POR PANTALLA UN CÓDIGO DE TIPO ENTERO EN UN MENSAJE. import java.io.*; import java.lang.*; public class Hola18 { public static void main(String[] args){ int codigo = 0; codigo=02; System.out.println(codigo); } }

EJERCICIO 17 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE POR PANTALLA UN MENSAJE UTILIZANDO EL CONCATENADOR DE CADENAS DE CARACTERES(+).




import java.io.*; import java.lang.*; public class Hola20 { public static void main(String[] args){ String saludo = "Bienvenido"; String saludo1 = "Java"; System.out.println(saludo+saludo1); } }

NOTA: Para unir texto, palabras o caracteres se utiliza el signo +, es para concatenar como usualmente se lo conoce en Java. EJERCICIO 18 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE POR PANTALLA UN MENSAJE UTILIZANDO EL CONCATENADOR DE CADENAS DE CARACTERES(+). import java.io.*; import java.lang.*; public class Hola21 { public static void main(String[] args){ String saludo = "H"; String saludo1 = "O"; String saludo2 = "L"; String saludo3 = "A"; System.out.println(saludo+saludo1+saludo2+saludo3); } }




Nota: Se puede concatenar más de 2 variables. EJERCICIO 19 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA MOSTRAR EL MENSAJE: HOLA JAVA. import java.io.*; import java.lang.*; public class Hola22 { public static void main(String[] args){ String saludo = "H"; String saludo1 = "O"; String saludo2 = "L"; String saludo3 = "A"; String saludo4 = " "; String saludo5 = "J"; String saludo6 = "A"; String saludo7 = "V"; String saludo8 = "A"; System.out.println(saludo+saludo1+saludo2+saludo3+saludo4+ saludo5+saludo6+saludo7+saludo8); } }

NOTA: TAMBIÉN SE PUEDE UTILIZAR LA VARIABLE STRING PARA ALMACENAR UN ESPACIO String saludo4 = " "; CUIDADO SE PUEDE CONFUNDIR CON LA INICIALIZACIÓN DE UNA VARIABLE, PARA INICIALIZAR LAS COMILLAS DOBLES VAN JUNTAS. String saludo4 = ""; // SIN ESPACIO EJERCICIO 20 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE POR PANTALLA UN VALOR CONSTANTE DE TIPO ENTERO.




import java.io.*; import java.lang.*; public class Hola1 { public static void main(String[] args){ int valor = 2; System.out.println( valor ); } }

NOTA: SE INICIALIZA CON UN VALOR ES PORQUE ÉSTE VALOR VA A SER CONSTANTE DYRANTE TODO EL PROGRAMA. EJERCICIO 21 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA MULTIPLICAR EL VALOR CONSTANTE CON OTRO NÚMERO. MOSTRAR RESULTADO POR PANTALLA. import java.io.*; import java.lang.*; public class Hola1 { public static void main(String[] args){ int valor = 2; int proceso=0; proceso=valor*2; System.out.println( proceso ); } }

EJERCICIO 22 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA MULTIPLICAR EL VALOR CONSTANTE CON OTRO valor CONSTANTE. MOSTRAR RESULTADO POR PANTALLA. import java.io.*; import java.lang.*;




public class Hola2 { public static void main(String[] args){ int valor = 2, valor2=4, proceso=0; proceso=valor*valor2; System.out.println( proceso ); } }

EJERCICIO 23 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA MULTIPLICAR EL VALOR DE UNA CONSTANTE CON OTRO VALOR DE COMA FLOTANTE. MOSTRAR RESULTADO POR PANTALLA. import java.io.*; import java.lang.*; public class Hola16 { public static void main(String[] args){ int valor = 2; float proceso=0f; proceso=valor*5.23f; System.out.println( proceso ); } }

Los tipos de datos float deben especificarse con una f al final, como lo muestra el ejercicio 16. Los de tipo double no es necesario (Vea Ejercicio 24). EJERCICIO 24 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA MULTIPLICAR EL VALOR DE UNA CONSTANTE CON OTRO VALOR DE COMA FLOTANTE. MOSTRAR RESULTADO POR PANTALLA. import java.io.*; import java.lang.*; public class Hola17 { public static void main(String[] args){ int valor = 2; double proceso=0; proceso=valor*3.141592654; System.out.println( proceso );




} }

EJERCICIO 25 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA CONCATENAR UN VALOR ENTERO CON UNA DE CARACTERES. import java.io.*; import java.lang.*; public class Hola22 { public static void main(String[] args){ String saludo = "HOLA "; int saludo4 = 45689; String saludo5 = " CHAO!!!!"; System.out.println(saludo+saludo4+saludo5); } }

NOTA: SE PUEDE CONCATENAR STRINGSº, ENTEROS, DOUBLES, ETC.

CUADROS DE DÍALOGOS Para cuadros de diálogos se usa la librería: import javax.swing.JOptionPane; Para mostrar un mensaje en el cuadro de diálogo: JOptionPane.showMessageDialog Para mostrar un mensaje con un cuadro para ingresar texto se utiliza: JOptionPane.showInputDialog CONVERTIR UNA CADENA DE CARACTERES A ENTERO (STRING A INT)




Se utiliza Integer.parseInt, para convertir porque cuando ingresamos información en un cuadro de texto, Java lo reconoce como String, para poder hacer cualquier operación matemática es necesario convertirlo a entero, float o double.Ejemplo: num1=Integer.parseInt(primerNumero); TIPO DE CUADRO DE DIÁLOGO DE MENSAJE JOptionPane.PLAIN_MESSAGE. - SIN ICONO JOptionPane.ERROR_MESSAGE.- Presenta un cuadro de diálogo con el icono de error. JOptionPane.WARNING_MESSAGE.- Presenta un cuadro de diálogo con el icono de advertencia. JOptionPane.QUESTION_MESSAGE.- Presenta un cuadro de diálogo con el icono de pregunta. Generalmente el cuadro de diálogo tiene un botón de SI o NO para que de clic el usuario. JOptionPane.INFORMATION_MESSAGE.- Muestra una información al usuario. EJERCICIO 26 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA MOSTRAR TEXTO EN UN CUADRO DE DIÁLOGO. //Paquete de Java import javax.swing.JOptionPane; /*El programa usa JOptionPane*/ public class Cuadro0 { /* El método main es invocado cuando la aplicación comienza*/ public static void main (String args []) { JOptionPane.showMessageDialog(null,"Bienvenido a Java!!!"); System.exit (0); /*terminar la aplicación con la ventana*/ } }

EJERCICIO 27 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA MOSTRAR TEXTO EN VARIOS CUADROS DE DIÁLOGO, UNA PALABRA POR CUADRO DE DIÁLOGO. //Paquete de Java import javax.swing.JOptionPane; /*El programa usa JOptionPane*/ public class Cuadro1 { /* El método main es invocado cuando la aplicación comienza*/




public static void main (String args []) { JOptionPane.showMessageDialog(null,"Bienvenido"); JOptionPane.showMessageDialog(null,"a"); JOptionPane.showMessageDialog(null,"la"); JOptionPane.showMessageDialog(null,"Programación"); JOptionPane.showMessageDialog(null,"en"); JOptionPane.showMessageDialog(null,"Java"); System.exit (0); /*terminar la aplicación con la ventana*/ } }




EJERCICIO 28 MOSTRAR TEXTO EN UN CUADRO DE DIÁLOGO, UTILIZANDO SECUENCIAS DE ESCAPE. //Paquete de Java import javax.swing.JOptionPane; /*El programa usa JOptionPane*/ public class Cuadro { /* El método main es invocado cuando la aplicación comienza*/ public static void main (String args []) { JOptionPane.showMessageDialog(null,"Bienvenido\na\nla\nprogramacion\nen Java!!!"); System.exit (0); /*terminar la aplicación con la ventana*/ } }

EJERCICIO 29 ELABORAR UN PROGRAMA QUE PERMITA EL INGRESO DE UN NÚMERO EN UN CUADRO DE DIÁLOGO Y LUEGO MOSTRARLO. //Paquete de Java import javax.swing.JOptionPane; public class Cuadro { public static void main (String args []) { String primerNumero; String segundoNumero; int num1;




/*Lee el primer número como una cadena de texto*/ primerNumero=JOptionPane.showInputDialog ("Escriba un número número"); /*Convierte los números de tipo String a tipo int*/ num1=Integer.parseInt(primerNumero); JOptionPane.showMessageDialog (null,"El número ingresado es: "+num1); System.exit (0); } }

EJERCICIO 30 ELABORAR UN PROGRAMA QUE PERMITA EL INGRESO DE DOS NÚMEROS EN UN CUADRO DE DIÁLOGO Y LUEGO MOSTRARLOS. //Paquete de Java import javax.swing.JOptionPane; public class Cuadro { public static void main (String args []) { String primerNumero; String segundoNumero; int num1; int num2;




/*Lee el primer número como una cadena de texto*/ primerNumero=JOptionPane.showInputDialog ("Escriba el primer número"); /*Lee el segundo número como una cadena de texto*/ segundoNumero=JOptionPane.showInputDialog ("Escriba el segundo número"); /*Convierte los números de tipo String a tipo int*/ num1=Integer.parseInt(primerNumero); num2=Integer.parseInt(segundoNumero); JOptionPane.showMessageDialog (null,"Los números ingresados son: "+num1 +" y "+num2); System.exit (0); } }

NOTA: CUANDO LEEMOS UN DATO, UTILIZEMOS O NO CUADROS DE DIÁLOGOS, POR DEFECTO SE LEE EL DATO QUE SE INGRESA COMO TIPO STRING, ENTONCES SE NECESITA CONVERTIRLOS AL TIPO DE DATO QUE EL PROGRAMADOR DECIDA.




EJERCICIO 31 Elaborar un programa que permita el ingreso de su nombre y apellido y después mostrarlos en pantalla utilizando cuadros de diálogos. import java.io.*; import java.lang.*; /*Librería utilizada para cuadros de diálogos*/ import javax.swing.JOptionPane; public class CuadroNombre { public static void main (String args []) { String nombre; String apellido; /*Lee como una cadena de texto*/ nombre=JOptionPane.showInputDialog ("Escriba su Nombre"); apellido=JOptionPane.showInputDialog ("Escriba su Apellido"); JOptionPane.showMessageDialog (null,"Los datos ingresados son: "+"\n"+nombre +"\n"+apellido); System.exit (0); } }




INTERACCIÓN CON EL USUARIO Ejemplo muy básico de como interactuar con el usuario del programa. EJERCICIO 32 import java.io.*; public class j006 { public static void main(String[]args)throws IOException { BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); System.out.println("Escribe tu nombre:"); String nom=in.readLine(); System.out.println("Adios "+nom); } }

EJERCICIO 33 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA INGRESAR UN NÚMERO POR TECLADO Y MOSTRARLO DESPUÉS POR PANTALLA. import java.io.*; public class j0006 { public static void main(String[]args)throws IOException {




BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); System.out.println("Ingrese un numero:"); String num=in.readLine(); System.out.println("El numero ingresado es "+num); } }

NOTA: EN ÉSTE EJERCICIO NOTE QUE UTILIZAMOS UN TIPO DE DATO STRING PARA ALMACENAR EL VALOR ENTERO, ESTO SE PUEDE HACER SINO SE VA A SUMAR O REALIZAR ALGUNA OPERACIÓN MATEMÁTICA. EJRCICIO 34 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA INGRESAR UN NÚMERO POR TECLADO Y MOSTRARLO DESPUÉS POR PANTALLA. import java.io.*; public class j0023 { public static void main(String[]args)throws IOException { BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); System.out.println("Ingrese su nombre:"); String nom=in.readLine(); System.out.println("Ingrese su edad:"); String edad=in.readLine(); System.out.println("Hola "+nom+" Tienes:"+edad+""); } }

EJERCICIO 35




REALIZAR UN PROGRAMA EN JAVA QUE PERMITA INGRESAR UN NÚMERO POR TECLADO Y MOSTRARLO DESPUÉS POR PANTALLA. import java.io.*; public class j0023 { public static void main(String[]args)throws IOException { BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); System.out.println("Ingrese su ID"); String id=in.readLine(); System.out.println("Su numero de cedula es:"+id); } }

EJERCICIO 36 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA INGRESAR UN NÚMERO POR TECLADO Y MOSTRARLO DESPUÉS POR PANTALLA. import java.io.*; public class j0023 { public static void main(String[]args)throws IOException { BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); System.out.println("Ingrese un valor decimal"); String decimal=in.readLine(); System.out.println("El valor con punto decimal es:"+decimal); } }




NOTA: UNA VARIBALE STRING PUEDE ESTAR ASOCIADO CON VALORES ENTEROS O DOUBLES, PERO TENER CUIDADO PORQUE SON VALORES COMO CADENAS DE CARACTERES, NO SON VALORES PARA REALIZAR OPERACIONES MATEMÁTICAS COMO SE LO MENCIONA EN EL CAPÍTULO DE OPERACIONES MATEMÁTICAS.

OPERACIONES MATEMÁTICAS EJERCICIO 37 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA MOSTRAR import java.io.*; public class j0062 { public static void main(String[]args)throws IOException { BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); System.out.println("Ingrese dos numeros enteros:"); String num=in.readLine(); String num1=in.readLine(); int valor= Integer.parseInt(num); int valor1= Integer.parseInt(num1); int suma=valor+valor1; System.out.println("La suma es: "+suma); } }




NOTA: CUANDO UTILIZAMOS TIPOS DE DATOS STRING PARA ALMACENAR DATOS DE TIPO ENTEROS O DOUBLES SE TIENE QUE CONVERTIR DE TIPO STRING A TIPO ENTERO SI SE DESEA REALIZAR ALGUNA OPERACIÓN CON LOS DATOS. POR EJEMPLO: int valor= Integer.parseInt(num); double valor= Double.parseDouble(num); VEA EL EJERCICIO 29 CON CUADROS DE DIÁLOGOS, SE REALIZA EL MISMO PROCEDIMIENTO. TAMBIÉN VEA EL EJERCICIO SIGUIENTE, EL EJERCICIO 34, SE MUESTRA UNA SUMA DE NÚMEROS INGRESADOS POR TECLADO PERO SE LO HACE DE OTRA MANERA, PERO ES LO MISMO. NOTE LAS DIFERENCIAS. EJERCICIO 38 REALIZAR UN PROGRAMA QUE PERMITA SUMAR DOS NÚMEROS INGRESADOS POR TECLADO. import java.lang.*; import java.io.*; public class SumNum { /*Main es invocado cuando la aplicación comienza*/ public static void main(String args[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num1=0, num2=0, suma; System.out.println("Suma de dos numeros"); System.out.print("Ingrese el primer numero: "); num1=Integer.parseInt(temp.readLine()); System.out.print("Ingrese el segundo numero: "); num2=Integer.parseInt(temp.readLine()); suma= num1+num2; System.out.println("Resultado= "+ suma);




} }

EJERCICIO 39 REALIZAR EL MISMO PROGRAMA DEL EJERCICIO 34, PERO ÉSTA VEZ UTILIZE CUADROS DE DIÁLOGOS. //Paquete de Java import javax.swing.JOptionPane; public class SumaCuadro { public static void main (String args []) { String primerNumero; String segundoNumero; int num1; int num2; int suma; primerNumero=JOptionPane.showInputDialog("Escriba el primer número"); segundoNumero=JOptionPane.showInputDialog("Escriba el segundo número"); /*Convierte los números de tipo String a tipo int*/ num1=Integer.parseInt(primerNumero); num2=Integer.parseInt(segundoNumero); suma=num1+num2; JOptionPane.showMessageDialog(null,"La suma es: "+suma,"Resultados",JOptionPane.INFORMATION_MESSAGE); System.exit(0); } }




EJERCICIO 40 REALIZAR UN PROGRAMA QUE PERMITA INGRESAR 3 NÚMEROS Y PRESENTAR EL PROMEDIO EN PANTALLA. import java.io.*; import java.lang.*; class Promedio { public static void main (String arg[]) throws IOException{ BufferedReader temp = new BufferedReader (new InputStreamReader (System.in)); int num1, num2, num3, suma; float prom=0f; System.out.println ("PROMEDIO"); System.out.println ("Ingrese tres numeros: "); num1=Integer.parseInt (temp.readLine ()); num2=Integer.parseInt (temp.readLine ()); num3=Integer.parseInt (temp.readLine ());




suma=num1+num2+num3; prom=suma/3; System.out.println ("El promedio de los numeros ingresados es: "+ prom); } }

EJERCICIO 41 REALIZAR EL MISMO PROGRAMA DEL EJERCICIO 28 (PROMEDIO), PERO ÉSTA VEZ HACERLO CON CUADROS DE DIÁLOGOS. //Paquete de Java import javax.swing.JOptionPane; public class PromedioC { public static void main (String args []) { String primerNumero=""; String segundoNumero=""; String tercerNumero=""; int num1=0; int num2=0; int num3=0; int suma=0; float prom=0.f; primerNumero=JOptionPane.showInputDialog("Escriba el primer número"); segundoNumero=JOptionPane.showInputDialog("Escriba el segundo número"); tercerNumero=JOptionPane.showInputDialog("Escriba el tercer número"); /*Convierte los números de tipo String a tipo int*/




num1=Integer.parseInt(primerNumero); num2=Integer.parseInt(segundoNumero); num3=Integer.parseInt(tercerNumero); suma=num1+num2+num3; prom=suma/3; JOptionPane.showMessageDialog(null,"El promedio es:"+prom,"Resultados",JOptionPane.INFORMATION_MESSAGE); System.exit(0); } }




TIPOS DE DATOS EN JAVA Las variables en Java deben tener un tipo de dato asociado. El tipo de dato de esa variable indicara los valores que la variable puede contener y las operaciones que se pueden realizar con ella. Podemos diferenciar los datos en Java en dos categorías de datos principales: los tipos primitivos y los tipos referenciados. Los tipos primitivos contienen un sólo valor e incluyen los tipos como los enteros, coma flotante, los caracteres, de tipo booleano etc... Los tipos referenciados se llaman así porque el valor de una variable de referencia es una referencia (un puntero) hacia el valor real. En Java tenemos los arrays, las clases y los interfaces como tipos de datos referenciados. 1. Enteros: Estos tipos son byte, short, int y long, que guardan el signo valor, estos representan un número y no pueden representar elementos fraccionarios. 2. Números en coma flotante: Estos son float y double y pueden almacenar números en coma flotante y con signo, esto quiere decir que nos permiten representar números decimales. El valor 2.6 es de tipo float pero debe especificarse con una f al final 2.6f, así: valor=2.6f 3. El tipo Caracter: Estos son de tipo char, que almacena la representación de los caracteres (letras o números), un carácter esta almacenado en 16 bits, y siguen un estándar que es el Unicoide. Los caracteres en Java se pueden especificar de forma normal o con secuencias de escape, utilizando la barra invertida "\" seguida de una letra:( \r) o utilizando la barra invertida con una "u" seguida de un numero hexadecimal (\u0000d), en este caso hemos especificado la secuencia de escape \r y su código unicoide correspondiente del retorno de carro. TABLA DE TIPOS DE DATOS

Tipos de datos Rango de valores Descripción

Números enteros

byte 8-bit complemento a 2 Entero de un Byte

short 16-bit complemento a 2 Entero corto

int 32-bit complemento a 2 Entero

long 64-bit complemento a 2 Entero largo

Números reales

float 32-bit IEEE 754 Coma flotante de precisión simple

double 64-bit IEEE 754 Coma flotante de precisión doble

otros tipos

char 16-bit Caracter Un sólo carácter




boolean true o false Un valor booleano (verdadero o falso)

Tipos de datos string (las cadenas) En realidad una variable de tipo string, más que un típo propio de Java es una clase tratada con todo rigor como un objeto más de Java. EJERCICIO 42 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE LOS TIPOS DE DATOS ENTEROS. import java.io.*; import java.lang.*; public class Enteros { public static void main(String[] arg) { byte midato1 = 1; short midato2 = 100; int midato3 = 10000; long midato4 = 100000000; System.out .println("Tipo de dato byte = " + midato1); System.out .println("Tipo de dato short = " + midato2); System.out .println("Tipo de dato int= " + midato3); System.out .println("Tipo de dato long = " + midato4); } }

NOTA: EN ESTOS EJERCICIOS SE INICIALIZA LAS VARIABLES CON UN NÚMERO, ESTAS VARIABLES SE LES PUEDE CAMBIAR EL VALOR DURANTE EL PROGRAMA Y NO DARÁ ERROR, EN CAMBIO UTILIZANDO LA PALABRA RESERVADA FINAL QUE SE VE EN EL CAPÍTULO SIGUIENTE SI DARÁ UN ERROR AL TRATAR DE MODIFICAR EL VALOR INICIAL. EJERCICIO 43




REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE LOS TIPOS DE DATOS FLOAT. import java.io.*; import java.lang.*; public class ComaFlotante { public static void main(String[] arg) { float valor; valor = 2.6f; System.out .println("Valor del dato= " + valor); } }

EJERCICIO 44 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE EL TIPO DE DATO BYTE. import java.io.*; import java.lang.*; public class Nuevo { public static void main(String[] arg) { /* no se modificará el valor durante la ejecución del programa, si tratamos de modificarla el compilador dará un error*/ byte unaConstante =4; System.out.println(unaConstante); } }

EJERCICIO 45 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE EL TIPO DE DATO INT.




import java.io.*; import java.lang.*; public class Nuevo1 { public static void main(String[] arg) { // se puede modificar el valor durante la ejecución del programa// //si tratamos de modificarla el compilador no dará ningún error// int unaConstante = 20; System.out.println(unaConstante); } }

EJERCICIO 46 REALIZAR EL MISMO PROGRAMA DEL EJERCICIO ANTERIOR PERO ÉSTA VEZ MODIFIQUE EL VALOR DE LA VARIABLE ENTERA.

import java.io.*; import java.lang.*; public class Nuevo2 { public static void main(String[] arg) { // se puede modificar el valor durante la ejecución del programa// //si tratamos de modificarla el compilador no dará ningún error// int unaConstante = 20; unaConstante = 10*8; System.out.println(unaConstante); } }

Nota: Al modificar el valor de la variable, se perdió el valor inicial.




EJERCICIO 47 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE EL TIPO DE DATO CHAR.

import java.io.*; import java.lang.*; public class Nuevo3 { public static void main(String[] arg) { /* no se modificará el valor durante la ejecución del programa, si tratamos de modificarla el compilador dará un error*/ char unaconstante ='J'; System.out.println(unaconstante); } }

EJERCICIO 48 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE EL TIPO DE DATO CHAR, PERO MODIFIQUE SU CONTENIDO. import java.io.*; import java.lang.*; public class Nuevo3 { public static void main(String[] arg) { /* no se modificará el valor durante la ejecución del programa, si tratamos de modificarla el compilador dará un error*/ char unaconstante ='J'; unaconstante ='H'; System.out.println(unaconstante); } }




Nota: Al modificar el valor de la variable, se perdió el valor inicial. EJERCICIO 49 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE EL TIPO DE DATO STRING. import java.io.*; import java.lang.*; public class Nuevo4 { public static void main(String[] arg) { /* no se modificará el valor durante la ejecución del programa, si tratamos de modificarla el compilador dará un error*/ String unaConstante = "Bienvenido a Java"; System.out.println(unaConstante); } }

EJERCICIO 50 REALIZAR EL MISMO PROGRAMA DEL EJERCICIO ANTERIOR, PERO ÉSTA VEZ MODIFIQUE EL VALOR DE LA VARIABLE STRING. import java.io.*; import java.lang.*; public class Nuevo4 { public static void main(String[] arg)




{ /* no se modificará el valor durante la ejecución del programa, si tratamos de modificarla el compilador dará un error*/ String unaConstante = "Bienvenido a Java"; unaConstante = "Hola Mundo"; System.out.println(unaConstante); } }

Nota: Al modificar el valor de la variable, se perdió el valor inicial. EJERCICIO 51 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE EL TIPO DE DATO FLOAT. import java.io.*; import java.lang.*; public class Nuevo5 { public static void main(String[] arg) { /* no se modificará el valor durante la ejecución del programa, si tratamos de modificarla el compilador dará un error*/ float unaConstante = 1e-10f; System.out.println(unaConstante); } }

EJERCICIO 52




REALIZAR EL MISMO PROGRAMA DEL EJERCICIO ANTERIOR, PERO ÉSTA VEZ MODIFIQUE EL VALOR DE LA VARIABLE FLOAT. import java.io.*; import java.lang.*; public class Nuevo5 { public static void main(String[] arg) { /* no se modificará el valor durante la ejecución del programa, si tratamos de modificarla el compilador dará un error*/ float unaConstante = 1e-10f; unaConstante = 400f; System.out.println(unaConstante); } }

Nota: Al modificar el valor de la variable, se perdió el valor inicial. EJERCICIO 53 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE EL TIPO DE DATO DOUBLE. import java.io.*; import java.lang.*; public class Nuevo6 { public static void main(String[] arg) { /* no se modificará el valor durante la ejecución del programa, si tratamos de modificarla el compilador dará un error*/ double unaConstante = 3.112455454215461; System.out.println(unaConstante); } }




EJERCICIO 54 REALIZAR EL MISMO PROGRAMA DEL EJERCICIO ANTERIOR, PERO ÉSTA VEZ MODIFIQUE EL VALOR DE LA VARIABLE DOUBLE.

import java.io.*; import java.lang.*; public class Nuevo6 { public static void main(String[] arg) { /* no se modificará el valor durante la ejecución del programa, si tratamos de modificarla el compilador dará un error*/ double unaConstante = 3.11245545421546462323; unaConstante = 45.45456456121542; System.out.println(unaConstante); } }

Nota: Al modificar el valor de la variable, se perdió el valor inicial.

LA PALABRA RESERVADA FINAL En una aplicación posiblemente nos encontremos con algún valor que permanece constante durante la ejecución. Podemos definirla como una variable común pero perderíamos el control. Por allí, en algún descuido, se cambiaría de valor pero no nos enteraríamos. Podemos agregar a la definición de variable el modificador final. La sintaxis es la siguiente: final tipo_variable nombre de variable [= valor]; Por ejemplo : final int unaConstante = 10;




EJERCICIO 55 LA PALABRA RESERVADA FINAL UTILIZANDO UNA VARIBALE DE TIPO BYTE Y TRATE DE MODIFICAR SU VALOR. import java.io.*; import java.lang.*; public class PalabraReservada { public static void main(String[] arg) { /* no se modificará el valor durante la ejecución del programa, si tratamos de modificarla el compilador dará un error*/ final byte unaConstante =4; unaConstante =10; //ERROR System.out.println(unaConstante); } }

NOTA:CUANDO SE UTILIZA LA PALABRA RESERVADA FINAL EN LA DECLARACIÓN DE LA VARIABLE NO SE PUEDE MODIFICAR EL VALOR DURANTE LA EJECUCIÓN DEL PROGRAMA, CONVIRTIENDO LA VARIABLE EN CONSTANTE. EJERCICIO 56 LA PALABRA RESERVADA FINAL UTILIZANDO UNA VARIBALE DE TIPO BYTE. import java.io.*; import java.lang.*; public class PalabraReservada { public static void main(String[] arg) { /* no se modificará el valor durante la ejecución del programa, si tratamos de modificarla el compilador dará un error*/ final byte unaConstante =4; System.out.println(unaConstante);




} }

EJERCICIO 57 LA PALABRA RESERVADA FINAL UTILIZANDO UNA VARIABLE TIPO INT. import java.io.*; import java.lang.*; public class PalabraReservadaI { public static void main(String[] arg) { // no se modificará el valor durante la ejecución del programa //si tratamos de modificarla el compilador dará un error final int unaConstante = 20; System.out.println(unaConstante); } }

EJERCICIO 58 LA PALABRA RESERVADA FINAL UTILIZANDO UNA VARIABLE TIPO CHAR. import java.io.*; import java.lang.*; public class PalabraReservada {




public static void main(String[] arg) { /* no se modificará el valor durante la ejecución del programa, si tratamos de modificarla el compilador dará un error*/ final char unaconstante ='J'; System.out.println(unaconstante); } }

EJERCICIO 59 LA PALABRA RESERVADA FINAL UTILIZANDO VARIAS VARIABLES TIPO CHAR. import java.io.*; import java.lang.*; public class PalabraReservada { public static void main(String[] arg) { /* no se modificará el valor durante la ejecución del programa, si tratamos de modificarla el compilador dará un error*/ final char cons ='J'; final char cons1 ='A'; final char cons2 ='V'; final char cons3 ='A'; System.out.println(cons+""+cons1+""+cons2+""+cons3); } }

EJERCICIO 60 LA PALABRA RESERVADA FINAL UTILIZANDO UNA VARIABLE TIPO STRING.




import java.io.*; import java.lang.*; public class PalabraReservadaS { public static void main(String[] arg) { /* no se modificará el valor durante la ejecución del programa, si tratamos de modificarla el compilador dará un error*/ final String unaConstante = "Bienvenido a Java"; System.out.println(unaConstante); } }

EJERCICIO 61 LA PALABRA RESERVADA FINAL UTILIZANDO UNA VARIABLE TIPO FLOAT. import java.io.*; import java.lang.*; public class PalabraReservadaF { public static void main(String[] arg) { /* no se modificará el valor durante la ejecución del programa, si tratamos de modificarla el compilador dará un error*/ final float unaConstante = 1e-10f; System.out.println(unaConstante); } }




OPERADORES ARITMÉTICOS EJERCICIO 62 REALIZAR UNA SUMA UTILIZANDO EL OPERADOR ARITMÉTICO ADECUADO CON VALORES INICIALIZADOS. import java.io.*; import java.lang.*; public class OSuma{ public static void main(String[] args){ int i = 12; int j = 10; int suma = i + j; System.out.println("Suma"); System.out.println("Respuesta: "+i+"+"+j+"="+suma ); } }




EJERCICIO 63 MOSTRAR LAS UMA DE DOS NÚMEROS ASIGNANDO VALORES INICIALES.NOTE LAS DIFERENCIAS CON ELE EJERCICIO ANTERIOR (EJERCICIO 38). import java.io.*; import java.lang.*; class suma { public static void main (String args []) throws IOException { int a=4, b=3, suma; suma = a+b; System.out.println ("La suma de "+a+" + "+b+" es "+suma); } }

EJERCICIO 64 REALIZAR UNA RESTA UTILIZANDO EL OPERADOR ARITMÉTICO ADECUADO CON VALORES INICIALIZADOS. import java.io.*; import java.lang.*; public class OResta{ public static void main(String[] args){ int i = 12; int j = 10; int resta = i - j; System.out.println("Resta"); System.out.println("Respuesta: "+i+"-"+j+"="+resta ); } }




EJERCICIO 65 REALIZAR UNA RESTA UTILIZANDO EL OPERADOR ARITMÉTICO ADECUADO CON VALORES INICIALIZADOS. NOTE LAS DIFERENCIAS CON EL EJERCICIO ANTERIOR (EJERCICIO 40) import java.io.*; import java.lang.*; public class OResta{ public static void main(String[] args){ int i = 12; int j = 10; int resta = 0; resta = i - j; System.out.println("Resta"); System.out.println("Respuesta: "+i+"-"+j+"="+resta ); } }

EJERCICIO 66 REALIZAR UNA MULTIPLICACIÓN UTILIZANDO EL OPERADOR ARITMÉTICO ADECUADO CON VALORES INICIALIZADOS. import java.io.*; import java.lang.*;




public class OMullt{ public static void main(String[] args){ int i = 12; int j = 10; int mult = i * j; System.out.println("Multiplicacion"); System.out.println("Respuesta: "+i+"*"+j+"="+mult ); } }

EJERCICIO 67 REALIZAR UNA MULTIPLICACIÓN UTILIZANDO EL OPERADOR ARITMÉTICO ADECUADO CON VALORES INICIALIZADOS. NOTE LAS DIFERENCIAS CON EL EJERCICIO ANTERIOR (EJERCICIO 42). import java.io.*; import java.lang.*; public class OMullt{ public static void main(String[] args){ int i = 12; int j = 10; int mult = 0; mult = i * j; System.out.println("Multiplicacion"); System.out.println("Respuesta: "+i+"*"+j+"="+mult ); } }




EJERCICIO 68 REALIZAR UNA DIVISIÓN UTILIZANDO EL OPERADOR ARITMÉTICO ADECUADO CON VALORES INICIALIZADOS. import java.io.*; import java.lang.*; public class ODivi{ public static void main(String[] args){ int i = 12; int j = 10; float divi = i / j; System.out.println("Division"); System.out.println("Respuesta: "+i+"/"+j+"="+divi ); } }

EJERCICIO 69 REALIZAR UNA DIVISIÓN UTILIZANDO EL OPERADOR ARITMÉTICO ADECUADO CON VALORES INICIALIZADOS. NOTE LAS DIFERENCIAS CON EL EJERCICIO ANTERIOR (EJERCICIO 44). import java.io.*; import java.lang.*; public class ODivi{




public static void main(String[] args){ int i = 12; int j = 10; float divi = 0f; divi = i / j; System.out.println("Division"); System.out.println("Respuesta: "+i+"/"+j+"="+divi ); } }

EJERCICIO 70 REALIZAR UN PROGRAMA QUE PERMITA OBTENER EL RESIDUO DE UN ADIVISIÓN CON VALORES INICIALIZADOS. import java.io.*; import java.lang.*; public class OResi{ public static void main(String[] args){ int i = 12; int j = 10; int resi = i % j; System.out.println("Residuo"); System.out.println("Respuesta: "+i+"%"+j+"="+resi ); } }




EJERCICIO 71 REALIZAR UN PROGRAMA QUE PERMITA OBTENER EL RESIDUO DE UN ADIVISIÓN CON VALORES INICIALIZADOS. NOTE LAS DIFERENCIAS CON EL EJERCICIO ANTERIOR (EJERCICIO 46). import java.io.*; import java.lang.*; public class OResi{ public static void main(String[] args){ int i = 12; int j = 10; int resi = 0; resi = i % j; System.out.println("Residuo"); System.out.println("Respuesta: "+i+"%"+j+"="+resi ); } }

EJERCICIO 72 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA REALIZAR LAS OPERACIONES FUNDAMENTALES ( SUMA, RESTA, MULTIPLICACIÓN, DIVISIÓN Y RESIDUO), UTILIZANDO LOS OPERADORES ARITMÉTICOS. import java.io.*; import java.lang.*; public class Matematica{ public static void main(String[] args){ int i = 12; int j = 10; int suma = i + j; int resta = i - j; int mult = i * j; int div = i / j;




int modulo = i % j; System.out.println("Suma :"); System.out.println("Respuesta: "+i+"+"+j+"="+suma ); System.out.println("Resta :"); System.out.println("Respuesta: "+i+"-"+j+"="+resta); System.out.println("Multiplicacion :"); System.out.println("Respuesta: "+i+"*"+j+"="+mult); System.out.println("Division :"); System.out.println("Respuesta: "+i+"/"+j+"="+div); System.out.println("Modulo :"); System.out.println("Respuesta: "+i+"%"+j+"="+modulo); } }

OPERADORES RELACIONALES Error con los operadores relacionales Uno de los errores más frecuentes es invertir el orden de los operadores relacionales. Ejemplo: CORRECTO INCORRECTO != (DIFERENTE) =! >= (MAYOR IGUAL) => <= (MENOR IGUAL) <= NOTA.- IMPORTANTE: = = IGUALDAD = ASIGNACIÓN EJEMPLO: ASIGNAR A LA VARIABLE N UN VALOR DE 100




N = 100 LA VARIABLE N ES IGUAL A LA VARIABLE M N = = M Comúnmente la igualdad se la realiza para comparar lo que contenga cada variable.

EJERCICIO 73 REALIZAR UN PROGRAMA QUE COMPARE TIPOS DE DATOS CHAR INICIALIZADOS Y QUE MUESTRE POR PANTALLA SI ES VERDADERA O FALSA LA COMPARACIÓN. LAS LETRAS SON IGUALES. import java.io.*; import java.lang.*; public class New0 { public static void main(String args[]){ char letra= 'a'; char letra2='b'; boolean b1 = letra==letra2; System.out.println( letra + " == " + letra2 + " = " + b1); } }

EJERCICIO 74 REALIZAR UN PROGRAMA QUE COMPARE TIPOS DE DATOS BYTE INICIALIZADOS Y QUE MUESTRE POR PANTALLA SI ES VERDADERA O FALSA LA COMPARACIÓN. LOS NÚMEROS SON DIFERENTES. import java.io.*; import java.lang.*; public class New2 { public static void main(String args[]){ byte num1=8; byte num2=10; boolean b1 = num1!=num2;




System.out.println( num1 + " != " + num2 + " = " + b1); } }

EJERCICIO 75 REALIZAR UN PROGRAMA QUE COMPARE TIPOS DE DATOS INT INICIALIZADOS Y QUE MUESTRE POR PANTALLA SI ES VERDADERA O FALSA LA COMPARACIÓN. EL PRIMER NÚMERO ES MAYOR AL SEGUNDO. import java.io.*; import java.lang.*; public class New3 { public static void main(String args[]){ int num1=8956; int num2=1000; boolean b1 = num1>num2; System.out.println( num1 + " > " + num2 + " = " + b1); } }

EJERCICIO 76 REALIZAR UN PROGRAMA QUE COMPARE TIPOS DE DATOS INT INICIALIZADOS Y QUE MUESTRE POR PANTALLA SI ES VERDADERA O FALSA LA COMPARACIÓN. EL NÚMERO 8956 ES MENOR QUE 1000. import java.io.*; import java.lang.*; public class New4 { public static void main(String args[]){ int num1=8956; int num2=1000;




boolean b1 = num1<num2; System.out.println( num1 + " < " + num2 + " = " + b1); } }

EJERCICIO 77 REALIZAR UN PROGRAMA QUE COMPARE TIPOS DE DATOS INT INICIALIZADOS Y QUE MUESTRE POR PANTALLA SI ES VERDADERA O FALSA LA COMPARACIÓN. LOS NÚMEROS SON MAYORES O IGUALES. import java.io.*; import java.lang.*; public class New5 { public static void main(String args[]){ int num1=1000; int num2=1000; boolean b1 = num1>=num2; System.out.println( num1 + " >= " + num2 + " = " + b1); } }

EJERCICIO 78 REALIZAR UN PROGRAMA QUE COMPARE TIPOS DE DATOS INT INICIALIZADOS Y QUE MUESTRE POR PANTALLA SI ES VERDADERA O FALSA LA COMPARACIÓN. EL PRIMER NÚMERO ES MENOR O IGUAL. import java.io.*; import java.lang.*; public class New6 { public static void main(String args[]){ int num1=1000;




int num2=1000; boolean b1 = num1<=num2; System.out.println( num1 + " <= " + num2 + " = " + b1); } }

EJERCICIO 79 REALIZAR UN PROGRAMA QUE COMPARE TIPOS DE DATOS FLOAT INICIALIZADOS Y QUE MUESTRE POR PANTALLA SI ES VERDADERA O FALSA LA COMPARACIÓN. AMBOS NÚMEROS SON IGUALES. import java.io.*; import java.lang.*; public class New7 { public static void main(String args[]){ float num1=102.5f; float num2=50.23f; boolean b1 = num1==num2; System.out.println( num1 + " == " + num2 + " = " + b1); } }

EJERCICIO 80 REALIZAR UN PROGRAMA QUE COMPARE TIPOS DE DATOS FLOAT INICIALIZADOS Y QUE MUESTRE POR PANTALLA SI ES VERDADERA O FALSA LA COMPARACIÓN. EL PRIMER NÚMERO ES MAYOR QUE EL SEGUNDO. import java.io.*; import java.lang.*;




public class New8 { public static void main(String args[]){ float num1=100.4855f; float num2=54.1258f; boolean b1 = num1>num2; System.out.println( num1 + " > " + num2 + " = " + b1); } }

EJERCICIO 81 REALIZAR UN PROGRAMA QUE COMPARE TIPOS DE DATOS sTRING INICIALIZADOS Y QUE MUESTRE POR PANTALLA SI ES VERDADERA O FALSA LA COMPARACIÓN. LAS CADENAS DE TEXTO SON IGUALES. import java.io.*; import java.lang.*; public class New9 { public static void main(String args[]){ String a="Bienvenido a Java"; String b="Bienvenido a Jav"; boolean b1 = a==b; System.out.println( a + " == " + b + " = " + b1); } }

EJERCICIO 82 REALIZAR UN PROGRAMA QUE COMPARE TIPOS DE DATOS STRING INICIALIZADOS Y QUE MUESTRE POR PANTALLA SI ES VERDADERA O FALSA LA COMPARACIÓN. LAS CADENAS DE TEXTO SON IGUALES.




import java.io.*; import java.lang.*; public class New10 { public static void main(String args[]){ String a="Bienvenido a Java"; String b="Bienvenido a Java"; boolean b1 = a==b; System.out.println( a + " == " + b + " = " + b1); } }

EJERCICIO 83 REALIZAR UN PROGRAMA QUE COMPARE TIPOS DE DATOS DOUBLE INICIALIZADOS Y QUE MUESTRE POR PANTALLA SI ES VERDADERA O FALSA LA COMPARACIÓN. EL PRIMER VALOR ES MAYOR QUE EL SEGUNDO. import java.io.*; import java.lang.*; public class New11 { public static void main(String args[]){ double a=-1.23552; double b=3.1245586; boolean b1 = a<b; System.out.println( a + " < " + b + " = " + b1); } }

EJERCICIO 84 REALIZAR UN PROGRAMA QUE COMPARE VALORES INICIALIZADOS Y QUE MUESTRE POR PANTALLA SI ES VERDADERA O FALSA LA COMPARACIÓN.




import java.io.*; import java.lang.*; public class Relacionales { public static void main(String args[]){ int i = -3; byte b = 5; float f = 1e-10f; double d = 3.14; boolean b1 = i > i; boolean b2 = i < b; boolean b3 = b <= f; boolean b4 = f >= d; boolean b5 = d != 0; boolean b6 = 1 == f; System.out.println( i + " > " + i + " = " + b1); System.out.println( i + " < " + b + " = " + b2); System.out.println( b + " <= " + f + " = " + b3); System.out.println( f + " >= " + d + " = " + b4); System.out.println( d + " != " + 0 + " = " + b5); System.out.println( 1 + " == " + f + " = " + b6); } }

OPERADORES BOOLEANOS

Nombre Operador Utilización Resultado

AND && A && B verdadero cuando A y B son verdaderos. Evaluación condicional.

OR || A || B verdadero cuando A o B son verdaderos. Evaluación condicional.




NOT ! !A verdadero si A es falso.

AND & A & B verdadero cuando A y B son verdaderos. Siempre evalúa ambos operandos.

OR | A | B verdadero cuando A o B son verdaderos. Siempre evalúa ambos operandos.

XOR ^ A ^ B verdadero cuando A y B son diferentes

OPERADOR AND Y OR Existen dos operadores AND, uno con dos símbolos && y el otro con uno solo (&). También tenemos dos operadores OR. Se obtiene la misma tabla de verdad. boolean x1 = operando1 && operando2; boolean x2 = operando1 & operando2; boolean y1 = operando1 || operando2; boolean y2 = operando1 | operando2; Parece extraño, sobre todo porque tienen la misma tabla de verdad. Pero internamente tienen un comportamiento diferente. Cuando estamos en presencia de un operador con un solo símbolo, siempre se evalúan ambos operandos. En cambio para el operador con el símbolo repetido, su evaluación cambia según el valor del primer operando, es decir evalúa sólo la primera condición. (Revise Ejercicio 9 y 10) EJERCICIO 85 REALIZAR UN PROGRAMA QUE MUESTRE LA TABLA DE VERDAD DEL OPERADOR AND. import java.io.*; import java.lang.*; public class OperadorAnd { public static void main(String args[]){ boolean x = true; boolean y = false; boolean a1 = x && x; boolean a2 = x && y; boolean a3 = y && x; boolean a4 = y && y; System.out.println("Tabla de verdad del Operador And"); System.out.println( x + " AND " + x + " = " + a1 ); System.out.println( x + " AND " + y + " = " + a2 ); System.out.println( y + " AND " + x + " = " + a3 ); System.out.println( y + " AND " + y + " = " + a4 ); }




}

EJERCICIO 86 REALIZAR UN PROGRAMA QUE MUESTRE LA TABLA DE VERDAD UTILIZANDO UN SOLO OPERADOR BOOLEANO. NOTE LAS DIFERENCIAS CON EL EJERCICIO ANTERIOR import java.io.*; import java.lang.*; public class OperadorAnd { public static void main(String args[]){ boolean x = true; boolean y = false; boolean a1 = x & x; boolean a2 = x & y; boolean a3 = y & x; boolean a4 = y & y; System.out.println("Tabla de verdad del Operador And"); System.out.println( x + " AND " + x + " = " + a1 ); System.out.println( x + " AND " + y + " = " + a2 ); System.out.println( y + " AND " + x + " = " + a3 ); System.out.println( y + " AND " + y + " = " + a4 ); } }

NOTA: APARENTEMENTE NO HAY DIFERENCIAS, PERO AL PRINCIPIO DE ESTE CAPÍTULO SE MENCIONA QUE EL DOBLE OPERADOR AND (&&) EVALÚA LA PRIMERA CONDICIÓN , SI SE CUMPLE YA NO EVALÚA LA SEGUNDA CONDICIÓN, SI LA PRIMERA CONDICIÓN NO SE CUMPLE AHÍ EVALUARÁ LA SEGUNDA CONDICIÓN. EL OPEARADOR SIMPLE AND (&) EVLÚA LAS DOS CONDICIONES OBLIGATORIAMENTE. LO MISMO CON EL OPERADOR OR. EJERCICIO 87 REALIZAR UN PROGRAMA QUE MUESTRE LA TABLA DE VERDAD DEL OPERADOR OR. import java.io.*;




import java.lang.*; public class TablaOr { public static void main(String args[]){ boolean x = true; boolean y = false; boolean a1 = x || x; boolean a2 = x || y; boolean a3 = y || x; boolean a4 = y || y; System.out.println("Tabla de verdad del Operador Or"); System.out.println( x + " OR " + x + " = " + a1 ); System.out.println( x + " OR " + y + " = " + a2 ); System.out.println( y + " OR " + x + " = " + a3 ); System.out.println( y + " OR " + y + " = " + a4 ); } }

SI TIENE DUDAS VUELVA A REVISAR LA NOTA DEL EJERCICIO 86. EJERCICIO 88 REALIZAR UN PROGRAMA QUE MUESTRE LA TABLA DE VERDAD UTILIZANDO UN SOLO OPERADOR BOOLEANO. NOTE LAS DIFERENCIAS CON EL EJERCICIO ANTERIOR. import java.io.*; import java.lang.*; public class TablaOr1 { public static void main(String args[]){ boolean x = true; boolean y = false; boolean a1 = x | x; boolean a2 = x | y; boolean a3 = y | x; boolean a4 = y | y; System.out.println("Tabla de verdad del Operador Or"); System.out.println( x + " OR " + x + " = " + a1 ); System.out.println( x + " OR " + y + " = " + a2 ); System.out.println( y + " OR " + x + " = " + a3 ); System.out.println( y + " OR " + y + " = " + a4 ); }




}

EJERCICIO 89 REALIZAR UN PROGRAMA QUE EVALÚE UNA CONDICIÓN UTILIZANDO EL DOBLE CONDICIONAL AND (&&). import java.io.*; import java.lang.*; public class CondiAnd1 { public static void main(String args[]){ int x = 0; int y = 2; boolean b = ( x != 0 ) && ( ( y / x ) != 0 ); System.out.println (b); } } /*No sale un error porque solo evalúa la primera condición cuando se utiliza &&*/

EJERCICIO 90 REALIZAR UN PROGRAMA QUE EVALÚE UNA CONDICIÓN UTILIZANDO EL SIMPLE CONDICIONAL AND (&). import java.io.*; import java.lang.*; public class Old1 { public static void main(String args[]){ int x = 0; int y = 2; boolean b = ( x != 0 ) & ( ( y * x ) == 0 ); System.out.println (b); } }




/*El condicional & evalúa las dos condiciones obligatoriamente, si la primera condición se cumple, pero la segunda condición no dará falso o viceversa*/ EJERCICIO 91 REALIZAR UN PROGRAMA QUE EVALÚE UNA CONDICIÓN UTILIZANDO EL DOBLE CONDICIONAL OR (||). import java.io.*; import java.lang.*; public class Old2 { public static void main(String args[]){ int x = -1; int y = 2; boolean b = ( x == -1 ) || ( y <0 ) ; System.out.println (b); } }

/*El operador || or Compara la primera condición, si ésta es verdadera ya no compara la segunda condición*/ EJERCICIO 92 REALIZAR UN PROGRAMA QUE EVALÚE UNA CONDICIÓN UTILIZANDO EL DOBLE CONDICIONAL OR (&&). import java.io.*; import java.lang.*; public class Old2 { public static void main(String args[]){ int x = -1; int y = 2; boolean b = ( x > 0 ) || ( y >0 ) ; System.out.println (b); } }

EJERCICIO 93 REALIZAR UN PROGRAMA QUE EVALÚE UNA CONDICIÓN UTILIZANDO EL SIMPLE CONDICIONAL OR (|). import java.io.*; import java.lang.*;




public class Old2 { public static void main(String args[]){ int x = -1; int y = 2; boolean b = ( x > 0 ) | ( y >0 ) ; System.out.println (b); } }

EJERCICIO 94 REALIZAR UN PROGRAMA QUE EVALÚE UNA CONDICIÓN UTILIZANDO EL DOBLE CONDICIONAL AND (&&). import java.io.*; import java.lang.*; public class Old2 { public static void main(String args[]){ int x = -1; int y = 2; boolean b = ( x > 0 ) && ( y <0 ) ; System.out.println (!b); } }

EJERCICIO 95 REALIZAR UN PROGRAMA QUE EVALÚE UNA CONDICIÓN UTILIZANDO EL DOBLE CONDICIONAL AND (&&). import java.io.*; import java.lang.*; public class Old2 { public static void main(String args[]){ int x = -1; int y = 2; boolean b = ( x > 0 ) && ( y <0 ) ; System.out.println (b); } }




EJERCICIO 96 REALIZAR UN PROGRAMA QUE EVALÚE UNA CONDICIÓN UTILIZANDO EL DOBLE CONDICIONAL AND (&&). import java.io.*; import java.lang.*; public class Old2 { public static void main(String args[]){ int x = 0; int y = 2; boolean b = ( x != 0 ) && ( y!=5 ) ; System.out.println (b); } }

EJERCICIO 97 REALIZAR UN PROGRAMA QUE EVALÚE UNA CONDICIÓN UTILIZANDO EL SIMPLE CONDICIONAL OR (|). import java.io.*; import java.lang.*; public class Old2 { public static void main(String args[]){ int x = 0; int y = 2; boolean b = ( x != 0 ) | ( y!=5 ) ; System.out.println (b); } }

EJERCICIO 98 REALIZAR UN PROGRAMA QUE EVALÚE UNA CONDICIÓN UTILIZANDO EL SIMPLE CONDICIONAL AND (&). import java.io.*; import java.lang.*;




public class Old2 { public static void main(String args[]){ int x = 0; int y = 2; boolean b = ( x == 0 ) & ( y!=2 ) ; System.out.println (b); } }

EJERCICIO 99 REALIZAR UN PROGRAMA EN JAVA QUE EVALÚE UNA CONDICIÓN UTILIZANDO UN SOLO CONDICIONAL AND (&). import java.io.*; import java.lang.*; public class CondiAnd2 { public static void main(String args[])throws IOException { int x = 0; int y = 2; boolean b = ( x != 0 ) & ( ( y / x ) != 0 ); System.out.println(b); } } /*Salió un error porque al tratar de evaluar la segunda condición no puede dividirse para cero cuando se utiliza &*/

EJERCICIO 100 REALIZAR UN PROGRAMA EN JAVA QUE EVALÚE UNA CONDICIÓN UTILIZANDO UN SOLO CONDICIONAL AND (&). import java.io.*; import java.lang.*; public class Old2 { public static void main(String args[]){ int x = 5; int y = 2;




boolean b = ( x < 0 ) || (( y*x)>=10 ) ; System.out.println (b); } }

VARIOS EJERCICIO 101 ELABORAR UN PROGRAMA QUE PERMITE EL INGRESO DE TRES NÚMEROS Y MOSTRARLOS POR PANTALLA. import java.io.*; import java.lang.*; class Numeros { public static void main (String arg[]) throws IOException{ BufferedReader temp = new BufferedReader (new InputStreamReader (System.in)); int valor1, valor2, valor3; System.out.println ("Ingrese tres numeros: "); valor1=Integer.parseInt (temp.readLine ()); valor2=Integer.parseInt (temp.readLine ()); valor3=Integer.parseInt (temp.readLine ()); System.out.println ("El numero 1 es: "+ valor1); System.out.println ("El numero 2 es: "+ valor2); System.out.println ("El numero 3 es: "+ valor3); } }




EJERCICIO 102 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA ENCONTRAR EL ÁREA DEL CUADRADO INGRESANDO EL LADO, PRESENTAR EL RESULTADO POR PANTALLA. import java.io.*; import java.lang.*; class AreaCuadrado{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); float lado, area; System.out.println("Area del cuadrado"); System.out.println("Ingrese el lado: "); lado=Float.parseFloat(temp.readLine()); area=lado*lado; System.out.println("El area del cuadrado es: "+ area); } }

EJERCICIO 103




REALIZAR UN PROGRAMA EN JAVA QUE PERMITA ENCONTRAR EL ÁREA DEL CUADRADO CON VALORES INICIALIZADOS, PRESENTAR EL RESULTADO POR PANTALLA. import java.io.*; import java.lang.*; class AreaCuadradoI{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); float lado=5f, area=0f; System.out.println("Area del cuadrado"); area=lado*lado; System.out.println("El area del cuadrado es: "+ area); } }

EJERCICIO 104 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA CALCULAR EL ÁREA DE UN TRIÁNGULO CON VALORES INICIALIZADOS. Área= (base*altura)/2 import java.io.*; import java.lang.*; class AreaTriangI{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); float b=4f, h=5f, area=0f; area=(b*h)/2; System.out.println("El area del triangulo es: "+ area);




} }

EJERCICIO 105 REALIZAR UN PROGRAMA QUE PERMITA OBTENER LA LONGITUD DE UNA CIRCUNFERENCIA. LONGITUD = 2*∏*R import java.io.*; import java.lang.*; public class LongitudCir{ public static void main(String[] args){ int radio = 4; final float pi = 3.14f; float l =0f; l = 2*pi*radio; System.out.println("Longitud de la Circunferencia"); System.out.println("Respuesta: "+l); } }

EJERCICIO 106 REALIZAR UN PROGRAMA QUE PERMITA OBTENER EL AREA DE UNA CIRCUNFERENCIA. AREA = ∏*R^2. import java.io.*; import java.lang.*; public class AreaCir{ public static void main(String[] args){




int radio = 4; final float pi = 3.14f; float area =0f; area = pi*(radio*radio); System.out.println("Area de la Circunferencia"); System.out.println("Respuesta: "+area); } }

EJERCICIO 107 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA CALCULAR EL ÁREA DE UN TRIÁNGULO CON VALORES INGRESADOS POR TECLADO. Área= (base*altura)/2 import java.io.*; import java.lang.*; class AreaTriang{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); float b=0f, h=0f, area=0f; System.out.println("Area del triangulo"); System.out.println("Ingrese la base: "); b=Float.parseFloat(temp.readLine()); System.out.println("Ingrese la altura: "); h=Float.parseFloat(temp.readLine()); area=(b*h)/2; System.out.println("El area del triangulo es: "+ area); } }




EJERCICIO 108 REALIZAR UN PROGRAMA QUE PRESENTE POR PANTALLA EL MAYOR NÚMERO DE LOS NÚMEROS INGRESADOS POR PANTALLA. import java.io.*; import java.lang.*; class Maximo{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num1 =0, num2=0, mayor=0; System.out.print("Ingrese el primer numero: "); num1=Integer.parseInt(temp.readLine()); System.out.print("Ingrese el segundo numero: "); num2=Integer.parseInt(temp.readLine()); mayor=Math.max(num1,num2); System.out.println("\n"+"El numero mayor entre " +num1+ " y " +num2+ " es: "+mayor); } }

EJERCICIO 109 REALIZAR UN PROGRAMA QUE PRESENTE POR PANTALLA EL MENOR NÚMERO DE LOS NÚMEROS INGRESADOS POR PANTALLA.




import java.io.*; import java.lang.*; class Minimo{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num1 =0, num2=0, mayor=0; System.out.print("Ingrese el primer numero: "); num1=Integer.parseInt(temp.readLine()); System.out.print("Ingrese el segundo numero: "); num2=Integer.parseInt(temp.readLine()); mayor=Math.min(num1,num2); System.out.println("\n"+"El numero menor entre " +num1+ " y " +num2+ " es: "+mayor); } }

EJERCICIO 110 REALIZAR UN PROGRAMA QUE MUESTRE POR PANTALLA EL COSENO DE UN NÚMERO INGRESADO POR PANTALLA. EL NÚMERO QUE SEA ENTERO. import java.io.*; import java.lang.*; class Coseno{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num=0;




double cose=0; System.out.print("Ingrese un numero numero: "); num=Integer.parseInt(temp.readLine()); cose=Math.cos(num); System.out.println("\n"+"El coseno de " +num+ " es: " +cose); } }

OPERACIONES CON MATH. La Clase Math La clase Math representa la librería matemática de Java. Las funciones que contiene son las de todos los lenguajes, parece que se han metido en una clase solamente a propósito de agrupación, por eso se encapsulan en Math, y lo mismo sucede con las demás clases que corresponden a objetos que tienen un tipo equivalente (Character, Float, etc.). El constructor de la clase es privado, por los que no se pueden crear instancias de la clase. Sin embargo, Math es public para que se pueda llamar desde cualquier sitio y static para que no haya que inicializarla. Funciones Matemáticas Si se importa la clase, se tiene acceso al conjunto de funciones matemáticas estándar: Math.abs( x ) para int, long, float y double Math.sin( double a ) devuelve el seno del ángulo a en radianes Math.cos( double a ) devuelve el coseno del ángulo a en radianes Math.tan( double a ) devuelve la tangente del ángulo a en radianes Math.asin( double r ) devuelve el ángulo cuyo seno es r




Math.acos( double r ) devuelve el ángulo cuyo coseno es r Math.atan( double r ) devuelve el ángulo cuya tangente es r Math.atan2(double a,double b) devuelve el ángulo cuya tangente es a/b Math.exp( double x ) devuelve e elevado a x Math.log( double x ) devuelve el logaritmo natural de x Math.sqrt( double x ) devuelve la raíz cuadrada de x Math.ceil( double a ) devuelve el número completo más pequeño mayor o igual que a Math.rint( double a ) devuelve el valor double truncado de a Math.pow( double x,double y ) devuelve y elevado a x Math.round( x ) para double y float Math.random() para double y float, GENERA NÚMEROS ALEATORIOS Math.max( a,b ) para int, long, float y double Math.min( a,b ) para int, long, float y double Math.E para la base exponencial, aproximadamente 2.72 Math.PI para PI, aproximadamente 3.14




EJERCICIO 111 REALIZAR UN PROGRAMA QUE PERMITA REDONDEAR UN NÚMERO INGRESADO POR PANTALLA. import java.io.*; import java.lang.*; class Redondear{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); double num=0,redondeo=0; System.out.print("Ingrese un numero: "); num=Double.parseDouble(temp.readLine()); redondeo=Math.round(num); System.out.println("\n"+"Redondeando el numero es: " +redondeo); } }

EJERCICIO 112 REALIZAR UN PROGRAMA QUE MUESTRE POR PANTALLA EL SENO DE UN NÚMERO INGRESADO POR PANTALLA, EL NÚMERO QUE SEA DOUBLE. import java.io.*; import java.lang.*; class NumSeno{ public static void main(String arg[]) throws IOException{




BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); double num=0,seno=0; System.out.print("Ingrese un numero: "); num=Double.parseDouble(temp.readLine()); seno=Math.sin(num); System.out.println("\n"+"El seno del numero es: " +seno); } }

EJERCICIO 113 REALIZAR UN PROGRAMA QUE MUESTRE POR PANTALLA EL VALOR ABSOLUTO DE CUALQUIER NÚMERO INGRESADO POR TECLADO. EJEMPLO: -8 VALOR ABSOLUTO ES 8. import java.io.*; import java.lang.*; class NumAbs{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); double num=0,proc=0; System.out.print("Ingrese un numero: "); num=Double.parseDouble(temp.readLine()); proc=Math.abs(num); System.out.println("\n"+"El seno del numero es: " +proc); } }




EJERCICIO 114 REALIZAR UN PROGRAMA QUE MUESTRE POR PANTALLA LA TANGENTE DE CUALQUIER NÚMERO INGRESADO POR TECLADO. import java.io.*; import java.lang.*; class NumAbs{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); double num=0,tangente=0; System.out.print("Ingrese un numero: "); num=Double.parseDouble(temp.readLine()); tangente=Math.tan(num); System.out.println("\n"+"La tangente del número es: "+tangente); } }

EJERCICIO 115 REALIZAR UN PROGRAMA QUE MUESTRE POR PANTALLA EL LOGARITMO NATURAL DE UN NÚMERO INGRESADO POR PANTALLA. import java.io.*; import java.lang.*; class NumLn{ public static void main(String arg[]) throws IOException{




BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); double num=0,lognatural=0; System.out.print("Ingrese un numero: "); num=Double.parseDouble(temp.readLine()); lognatural=Math.log(num); System.out.println("\n"+"El logaritmo natural del numero es: "+lognatural); } }

EJERCICIO 116 REALIZAR UN PROGRAMA QUE MUESTRE POR PANTALLA EL COSENO INVERSO DE UN NÚMERO INGRESADO POR PANTALLA. import java.io.*; import java.lang.*; class CosenoInverso{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); double num=0,cosinv=0; System.out.print("Ingrese un numero: "); num=Double.parseDouble(temp.readLine()); cosinv=Math.acos(num); System.out.println("\n"+"El coseno inverso del numero es: "+cosinv); } }




EJERCICIO 117 REALIZAR UN PROGRAMA QUE MUESTRE POR PANTALLA EL SENO INVERSO DE UN NÚMERO INGRESADO POR PANTALLA. import java.io.*; import java.lang.*; class SenoInverso{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); double num=0,seninv=0; System.out.print("Ingrese un numero: "); num=Double.parseDouble(temp.readLine()); seninv=Math.asin(num); System.out.println("\n"+"El seno inverso del numero es: "+seninv); } }

EJERCICIO 118 REALIZAR UN PROGRAMA QUE MUESTRE POR PANTALLA LA TANGENTE INVERSA DE UN NÚMERO INGRESADO POR PANTALLA. import java.io.*; import java.lang.*; class TangenteInversa{




public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); double num=0,taninv=0; System.out.print("Ingrese un numero: "); num=Double.parseDouble(temp.readLine()); taninv=Math.atan(num); System.out.println("\n"+"La tangente inversa del numero es: "+taninv); } }

EJERCICIO 119 REALIZAR UN PROGRAMA QUE CONVIERTA UN NÚMERO INGRESADO POR PANTALLA DE GRADOS A RADIANES. import java.io.*; import java.lang.*; class GradosRadian{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); double num=0,proc=0; System.out.print("Ingrese un numero: "); num=Double.parseDouble(temp.readLine()); proc=Math.toRadians(num); System.out.println("\n"+"El numero en radianes es: "+proc); }




}

EJERCICIO 120 REALIZAR UN PROGRAMA QUE CONVIERTA UN NÚMERO INGRESADO POR PANTALLA DE RADIANES A GRADOS. import java.io.*; import java.lang.*; class RadianGrados{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); double num=0,proc=0; System.out.print("Ingrese un numero: "); num=Double.parseDouble(temp.readLine()); proc=Math.toDegrees(num); System.out.println("\n"+"El numero en grados es: "+proc); } }

EJERCICIO 121 REALIZAR UN PROGRAMA QUE PERMITA ENCONTRAR LA RAÍZ CUADRADA DE UN NÚMERO ASUMIENDO QUE EL NÚMERO ES POSITIVO. import java.io.*; import java.lang.*; class RaizCuadrada{




public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); double num, raiz; System.out.println("Raiz Cuadrada"); System.out.println("Ingrese un numero positivo: "); num=Float.parseFloat(temp.readLine()); raiz=Math.sqrt(num); System.out.println ("La raiz cuadrada es: "+ raiz); } }

EJERCICIO 122 Realizar un programa que permita elevar al cuadrado cualquier número ingresado por pantalla. import java.io.*; import java.lang.*; class Cuadrado{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); double num, cuad; System.out.println("Cuadrado de un Numero"); System.out.println("Ingrese un numero positivo o negativo: ");




num=Double.parseDouble(temp.readLine()); cuad=Math.pow(num,2); System.out.println("Elevado al cuadrado es: "+ cuad); } }

EJERCICIO 123 Realizar un programa en Java que permitaconvertir de grados Celsius a grados Fahrenheit. //Programa de conversion de temperaturas, de C° a F°. import java.io.*; import java.text.*; public class j008 { public static void main(String[]args)throws IOException { System.out.println("Programa de conversion de temperaturas en Celsius a Farenheit."); BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); System.out.println("Dame la temperatura en grados Celsius:"); double temp=Double.valueOf(in.readLine().trim()).doubleValue(); double f; f=((9/5)*temp)+32; System.out.println("La temperatura de "+temp+" grados Celsius es igual a "+f+" grados Farenheit"); } }




SENTENCIA DE CONTROL CONDICIÓN IF SIMPLE Esta construcción provoca que la ejecución atraviese un conjunto de estados booleanos que determinan que se ejecuten distintos fragmentos de código. La cláusula else es opcional. Cada una de las sentencias puede ser una sentencia compuesta y la expresión-booleana podría ser una variable simple declarada como boolean, o una expresión que utilice operadores relacionales para generar el resultado de una comparación. SINTAXIS CONDICIÓN IF 1. if (condición) sentencia; 2. if (condición) sentencia 1; else sentencia 2; 3. if (condición) { sentencia; } else { sentencia; } Conjunción if (condición1 && condición2){ sentecia1; } else { sentencia2; } 2. if ( condición1 ) { if ( condición2 ) { sentencia1; } else { sentencia2; } } else { sentencia2; } Disyunción 1. if ( condición1 || condición2 ) { sentencia1; } else {




sentencia2; } 2. if ( condición1 ){ sentencia1; } else { if ( condición2 ) { sentencia1; } else { sentencia2; } } Negación 1. if ( ! condición1) { sentencia1; } else { sentencia2; } 2. if ( condición1) { sentencia2; } else { sentencia1; } EJERCICIO 124 Realizar un programa que realice una división siempre y cuando y=0. if (condición) sentencia; public class DivisionSegura { public static void main(String args[]){ int x = 12; int y = 0; int z = 0; if( y !=0 ) z = x / y; System.out.println("El resultado es : " + z); } }




EJERCICIO 125 Realizar un programa que realice la división de un número utilizando la condición: if (condición) sentencia 1; else sentencia 2; public class DivisionSegura { public static void main(String args[]){ int x = 12; int y = 0; int z = 0; if( y !=0 ) z = x / y; else System.out.println("Atencion! se pretende dividir por 0"); System.out.println("El resultado es : " + z); } }

EJERCICIO 126 Realizar un programa que realice la división de un número utilizando la condición: if (condición) sentencia 1; else sentencia 2; public class DivisionSegura { public static void main(String args[]){ int x = 12; int y = 2; int z = 0; if( y !=0 ) { z = x / y; System.out.println("El resultado es : " + z); } else { System.out.println("Atención! se pretende dividir por 0"); } } }




EJERCICIO 127 REALIZAR UN PROGRAMA COMPARANDO DOS NÚMEROS INGRESADOS, UTILIZANDO LOS OPERADORES RELACIONALES. //Paquete de Java import javax.swing.JOptionPane; public class Comparacion { public static void main (String args []) { String primerNumero; String segundoNumero; String resultado; int numero1;//primer número a comparar int numero2;//segundo número a comparar primerNumero=JOptionPane.showInputDialog("Escriba el primer número"); segundoNumero=JOptionPane.showInputDialog("Escriba el segundo número"); /*Convierte los números de tipo String a tipo int*/ numero1=Integer.parseInt(primerNumero); numero2=Integer.parseInt(segundoNumero); //Inicializar el resultado con cadena vacía resultado=""; if(numero1==numero2) resultado= resultado +numero1+"=="+numero2; if(numero1!=numero2) resultado= resultado +numero1+"!="+numero2; if(numero1<numero2) resultado= resultado+"\n" +numero1+"<"+numero2; if(numero1>numero2) resultado= resultado+"\n"+numero1+">"+numero2;




if(numero1<=numero2) resultado= resultado+"\n" +numero1+"<="+numero2; if(numero1>=numero2) resultado= resultado+"\n" +numero1+">="+numero2; //Mostrar los resultados JOptionPane.showMessageDialog (null, resultado,"Resultados de la comparación: ",JOptionPane.INFORMATION_MESSAGE); System.exit(0); } }

EJERCICIO 128 REALIZAR UN PROGRAMA QUE PERMITA VALIDAR UNA CLAVE DE ACCESO COMPARANDO EL USUARIO CON LA CLAVE, SOLAMENTE SI SON IGUALES PRESENTARÁ UN MENSAJE DE ACCESO PERMITIDO, CASO CONTRARIO MOSTRARÁ ACCESO DENEGADO.




import java.io.*; import java.lang.*; class Clave{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int usuario, clave=24654; System.out.println("Ventana de Acceso"); System.out.println("Ingrese su usuario: "); usuario=Integer.parseInt(temp.readLine()); if(usuario==clave) System.out.println("Acceso Permitido"); else System.out.println("Acceso Denegado"); } }

EJERCICIO 129 REALIZAR UN PROGRAMA QUE PERMITA VERIFICAR SI UN NÚMERO INGRESADO POR EL USUARIO ES POSITIVO O NEGATIVO. import java.io.*; import java.lang.*; class PosiNega{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); float numero;




System.out.println("Ingrese un numero"); numero=Float.parseFloat(temp.readLine()); if(numero>0) System.out.println("El numero es positivo"); else System.out.println("El numero es negativo"); } }

EJERCICIO 130 ELABORAR UN PROGRAMA EN JAVA QUE CALCULE EL MAYOR DE LOS DOS NÚMEROS INGRESADOS POR TECLADO. CONDICIÓN IF……..ELSE import java.io.*; import java.lang.*; class Mayor { public static void main (String args[]) throws IOException{ BufferedReader temp = new BufferedReader ( new InputStreamReader (System.in)); int a, b, mayor; System.out.println("Ingrese los valores de a y b"); a=Integer.parseInt(temp.readLine()); b=Integer.parseInt(temp.readLine()); if(a>b) mayor=a; else




mayor=b; System.out.println("El número mayor es:"+mayor); } } EJERCICIO 131 CALCULAR EL SALDO FINAL DE UN TRABAJADOR, SI SU SULEDO ES INFERIOR A $200 TENDRÁ UN AUMENTO DEL 12%, SI SU SUELDO ESTÁ ENTRE $200 Y $300 TENDRÁ UN AUMENTO DEL 10%, SI NO TENDRÁ UN AUMENTO DEL 8%. import java.io.*; import java.lang.*; class Sueldo{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); float sueldo, p=0,sfinal=0; System.out.println("Ingrese su sueldo"); sueldo=Float.parseFloat(temp.readLine()); if(sueldo<200){ p=(sueldo*12)/100; sfinal=(p+sueldo); System.out.println("El sueldo final es: "+sfinal); }else if(( sueldo>=200) && (sueldo <=300)){ p=(sueldo*10)/100; sfinal=(p+sueldo); System.out.println("El sueldo final es: "+sfinal); } else{ p=(sueldo*8)/100; sfinal=(p+sueldo); System.out.println("El sueldo final es: "+sfinal); } }




}

EJERCICIO 132 REALIZAR UN PROGRAMA EN JAVA QUE CALCULE LA DISTANCIA ENTRE DOS NÚMEROS. import java.io.*; import java.lang.*; public class Distancia{ public static void main(String args[]){ int a = 23; int b = 12; int j; if ( a > b ) { j = a - b; } else { j = b - a; } System.out.println("El resultado es: " + j ); } }

EJERCICIO 133 REALIZAR UN PROGRAMA EN JAVA QUE REALICE LO MISMO DEL EJERCICIO 84 (ANTERIOR) CON EL OPERADOR IF-ELSE Y VEA LAS DIFERENCIAS. import java.io.*; import java.lang.*;




public class Distancia1{ public static void main(String args[]){ int a = 23; int b = 12; int j = a > b ? a - b : b - a; System.out.println("El resultado es: " + j ); } }

EJERCICIO 134 RELIZAR EL MISMO EJERCICIO 33 CON EL OPERADOR IF – ELSE CON UNA VARIANTE. import java.io.*; import java.lang.*; public class Distancia2{ public static void main(String args[]){ int a = 11; int b = 12; int j = (a > b ? a : b ) - ( a <= b ? a : b); System.out.println("El resultado es: " + j ); } }

EJERCICIO 135




Vamos a desarrollar una calculadora totalmente elemental. Sin muchas características salvo de realizar operaciones aritméticas con dos operandos. Disponemos de una variable de tipo char que nos indicará que tipo de operación se debe efectuar. Realizamos la operación y mostramos el resultado en la pantalla. import java.io.*; import java.lang.*; public class MiniCalculadora { public static void main(String args[]){ int a = 16; int b = 8; char op = '*'; System.out.print("El resultado es : "); if ( op == '+' ) { System.out.println( a + b); } else if ( op == '-') { System.out.println( a - b); } else if ( op == '*') { System.out.println( a * b); } else if ( op == '/') { System.out.println( a / b); } } }

EJERCICIO 136 COLOCAR DISCOS EN UNA TORRE ORDENADAMENTE, HAY 3 TORRES. UNA CONDICIÓN ES QUE NO DEBE QUEDAR UN DISCO GRANDE SOBRE UNO PEQUEÑO. TORRES DE HANOI import java.io.*; import java.text.*;




/** * Programa recursivo para resolver <I>Las Torres de Hanoi</I> * @author CTE, Javier Ruiz **/ public class TowersOfHanoi { private final static BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in)); private final static PrintWriter stdOut = new PrintWriter(System.out, true); private final static PrintWriter stdErr = new PrintWriter(System.err, true); //private static void main(String[] args) throws IOException, NumberFormatException public static void main(String[] args) throws IOException, NumberFormatException { stdErr.print("Cuantos discos son? "); stdErr.flush(); int numDisks = Integer.parseInt(stdIn.readLine()); move(numDisks, 1, 3, 2); } protected static void move(int n, int from, int to, int temp) { if (n==1) { System.out.println("Mover el disco superior de la torre " + from + " a la torre " + to); } else { move(n-1, from, temp, to); move(1, from, to, temp); move(n-1, temp, to, from); } } }




SENTENCIA SWITCH La sentencia switch proporciona una forma limpia de enviar la ejecución a partes diferentes del código en base al valor de una única variable o expresión. La expresión puede devolver cualquier tipo básico, y cada uno de los valores especificados en las sentencias case debe ser de un tipo compatible. En Java no se puede realizar una comprobación contra caracteres como en C++, porque el tipo char en C++ es en realidad un entero de 8 bits, lo que no es cierto en Java. La sentencia switch funciona de la siguiente manera: el valor de la expresión se compara con cada uno de los valores literales de las sentencias case. Si coincide con alguno, se ejecuta el código que sigue a la sentencia case. Si no coincide con ninguno de ellos, entonces se ejecuta la sentencia default (por defecto), que es opcional. Si no hay sentencia default y no coincide con ninguno de los valores, no hace nada. Al igual que en otros lenguajes, cada constante en sentencia case debe ser única. SINTAXIS




switch( expresión ) { case constante1: sentencia1; ... break; ... case constanteN: sentenciaN; ... break; default: sentencia; ... break }

EJERCICIO 137 RELIZAR EL MISMO PROGRAMA DEL EJERCICIO 36 PERO UTILIZANDO LA ESTRUCTURA DE SELCCIÓN MÚLTIPLE SWITCH. public class MiniCalculadora1{ public static void main(String args[]){ int a = 16; int b = 8; char op = '/'; System.out.print("El resultado es : "); switch ( op ) { case '+': System.out.println( a + b ); break; case '-': System.out.println( a - b ); break; case '*': System.out.println( a * b ); break; case '/': System.out.println( a / b ); break; default: System.out.println("error" ); break;




} } }

EJERCICIO 138 REALIZAR UN PROGRAMA QUE PERMITA EJECUTAR MÁS DE UNA ALTERNATIVA AL MISMO TIEMPO. public class Lineas{ public static void main(String args[]){ int j = 3; switch (j) { case 5: System.out.println("********"); case 4: System.out.println("********"); case 3: System.out.println("********"); case 2: System.out.println("********"); case 1: System.out.println("********"); } } }

EJERCICIO 139




MOSTRAR UN DÍA DE LA SEMANA, DE ACUERDO AL DÍA QUE INGRESÓ POR TECLADO, UTILIZANDO LA SENTENCIA SWITCH. import java.io.*; import java.lang.*; class DiasSemana{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int dia; System.out.println("Dias de la semana"); System.out.println("Ingrese el dia: "); dia=Integer.parseInt(temp.readLine()); switch (dia ) { case 1: System.out.println("Lunes"); break; case 2: System.out.println("Martes"); break; case 3: System.out.println("Miércoles"); break; case 4: System.out.println("Jueves"); break; case 5: System.out.println("Viernes"); break; case 6: System.out.println("Sabado"); break; case 7: System.out.println("Domingo"); break; default: System.out.println("No es un día de la semana"); break;




} } }




ESTRUCTURAS DE ITERACIÓN WHILE El bucle while es la sentencia de bucle más básica en Java. Ejecuta repetidamente una vez tras otra una sentencia, mientras una expresión booleana sea verdadera. Las partes de inicialización e iteración, que se presentan entre corchetes, son opcionales. Esta sentencia while se utiliza para crear una condición de entrada. El significado de esta condición de entrada es que la expresión condicional que controla el bucle se comprueba antes de ejecutar cualquiera de las sentencias que se encuentran situadas en el interior del bucle, de tal modo que si esta comprobación es false la primera vez, el conjunto de las sentencias no se ejecutará nunca. SINTAXIS [inicialización;] while( terminación-expresión-booleana ) { sentencias; [iteración;] } EJERCICIO 140 REALIZAR UN PROGRAMA QUE PERMITA PRESENTAR UN MENSAJE SÓLO SI EL VALOR ES MAYOR A CERO. import java.io.*; import java.lang.*; class Prueba1{ public static void main(String arg[]) throws IOException{ int num=0; while ( num > 0 ) System.out.println("Esto nunca lo verás"); }




}

EJERCICIO 141 REALIZAR UN PROGRAMA QUE MUESTRE UN MENSAJE SÓLO SI LA CONDICIÓN ES VERDADERA, PERO SÓLO UNA VEZ. import java.io.*; import java.lang.*; class Prueba3{ public static void main(String arg[]) throws IOException{ boolean prueba = true; while ( prueba ) { System.out.println("Esto lo veras una vez"); prueba = false; } } }

EJERCICIO 142 REALIZAR EL MISMO PROGRAMA DEL EJERCICIO 41, PERO ÉSTA VEZ EL MENSAJE TIENE QUE PRESENTARSE INFINITAS VECES. import java.io.*; import java.lang.*;




class Prueba3{ public static void main(String arg[]) throws IOException{ boolean prueba = true; while ( prueba ) { System.out.println("Esto lo veras infinitas veces"); } } }

EJERCICIO 143 REALIZAR UN PROGRAMA QUE CONVIERTA UN NÚMERO DECIMAL A BINARIO, MIENTRAS EL DECIMAL SEA MAYOR A CERO. import java.io.*; import java.lang.*; public class DecABin{ public static void main(String args[])throws IOException{ int decimal = 252222; String binario = ""; while ( decimal > 0 ) { binario = decimal % 2 + binario; decimal /= 2; } System.out.println(binario); } }




EJERCICIO 144 REALIZAR UN PROGRAMA QUE MUESTRA POR PANTALLA UNA LÍNEA DE CARACTERES MIENTRAS EL CONTADOR SEA IGUAL A CINCO. import java.io.*; import java.lang.*; public class Asterisco{ public static void main(String args[]){ int contador = 1; while ( contador <= 5 ) { System.out.println("*****"); contador++; } } }

EJERCICIO 145 REALIZAR EL MISMO PROGRAMA DEL EJERCICIO 44, PERO COLOCANDO UN SOLO CARÁCTER EN EL MENSAJE (UTILIZE UN SEGUNDO CONTADOR). import java.io.*; import java.lang.*; class Asterisco2{ public static void main (String args []) throws IOException { int contador = 1; while (contador <= 5)




{ int contador2 = 1; while (contador2 <= 5) { System.out.print ("*"); contador2++; } System.out.println (); contador++; } } }

EJERCICIO 146 REALIZAR UN PROGRAMA QUE PERMITA PRESENTAR LOS 5 PRIMEROS NÚMEROS POSITIVOS. import java.io.*; import java.lang.*; class Positivos{ public static void main(String arg[]) throws IOException{ int n =0; while (n<5){ n=n+1; System.out.println("Los numeros son: "+n); } } }




EJERCICIO 147 GENERAR LOS 15 PRIMEROS NÚMEROS PARES. import java.io.*; import java.lang.*; class Pares{ public static void main(String arg[]) throws IOException{ int par =0, cont=0; while (cont<15){ par=par+2; cont=cont+1; System.out.println("Los numeros pares son: "+par); } } }

EJERCICIO 148 REALIZAR UN PROGRAMA QUE GENERE LOS 5 PRIMEROS NÚMEROS PARES Y LOS 5 PRIMEROS NÚMEROS IMPARES DENTRO DE UN MISMO CICLO. import java.io.*; import java.lang.*; class ParesImpares{ public static void main(String arg[]) throws IOException{ int par =0, impar=-1, cont=0; while (cont<5){ par=par+2; impar=impar+2; cont=cont+1;




System.out.println("Impar: "+impar); System.out.println("Par: "+par); } } }

EJERCICIO 149 SE DESEA INTRODUCIR POR TECLADO TRES NÚMEROS A, B, C, SUMARLOS. SI LA SUMA ES IGUAL A 100 PRESENTAR POR PANTALLA DICHO RESULTADO Y FINALIZAR EL PROGRAMA, CASO CONTRARIO INTRODUCIR NUEVOS VALORES. import java.io.*; import java.lang.*; class SumaPrueba{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int a,b,c,suma =0; while (suma<100){ System.out.println("Ingrese el primer numero: "); a=Integer.parseInt(temp.readLine()); System.out.println("Ingrese el segundo numero: "); b=Integer.parseInt(temp.readLine()); System.out.println("Ingrese el tercer numero: "); c=Integer.parseInt(temp.readLine()); suma= a+b+c; } System.out.println("El resultado de la suma: "+suma); } }




EJERCICIO 150 REALIZAR UN PROGRAMA QUE PERMITA OBTENER LA SUMATORIA DE LOS 10 PRIMEROS NÚMEROS IMPARES. import java.io.*; import java.lang.*; class SumaImpares{ public static void main(String arg[]) throws IOException{ int cont=0, acu=-1, suma=0; while (cont<10){ cont=cont+1; acu=acu+2; suma=suma+acu; } System.out.println("Resultado: "+suma); } }

EJERCICIO 151 REALIZAR UN PROGRAMA QUE PERMITA OBTENER LA SUMATORIA DE LOS 10 PRIMEROS NÚMEROS PARES.




import java.io.*; import java.lang.*; class SumaPares{ public static void main(String arg[]) throws IOException{ int cont=0, acu=0, suma=0; while (cont<10){ cont=cont+1; acu=acu+2; suma=suma+acu; } System.out.println("Resultado: "+suma); } }

EJERCICIO 152 REALIZAR UN PROGRAMA QUE PRESENTE LA SUMATORIA DE TODOS LOS NÚMEROS ENTEROS POSITIVOS DESDE EL CERO HASTA EL DATO INGRESADO POR TECLADO. import java.io.*; import java.lang.*; class SumaPositivos{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int cont=-1, num=0, suma=0; System.out.println("Ingrese un numero positivo:"); num=Integer.parseInt(temp.readLine()); while (cont<num){ cont=cont+1; suma=suma+cont; } System.out.println("Resultado: "+suma);




} }

EJERCICIO 153 REALIZAR UN PROGRAMA QUE PERMITA SUMAR 5 VECES EL NÚMERO INGRESADO POR EL USUARIO. import java.io.*; import java.lang.*; class SumaNum{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num=0, cont=0, sum=0; System.out.println("Ingrese un numero positivo:"); num=Integer.parseInt(temp.readLine()); while (cont<5){ sum=sum+num; cont=cont+1; } System.out.println("Resultado: "+sum); } }

EJERCICIO 154 REALIZAR UN PROGRAMA QUE PERMITA MOSTRAR LA SIGUIENTE SUCESIÓN: 4,8,16,32,64,128. import java.io.*; import java.lang.*;




class Sucesion{ public static void main(String arg[]) throws IOException{ int a=2; while (a<128){ a=a*2; System.out.println(a); } } }

EJERCICIO 155 REALIZAR UN PROGRAMA QUE PERMITA MOSTRAR POR PANTALLA SÓLO LOS NÚMEROS INGRESADOS POR EL USUARIO QUE SEAN DE TRES DÍGITOS. (MAYORES A 99 Y MENORES A 1000) import java.io.*; import java.lang.*; class TresDigitos{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int n=0; System.out.println("Ingrese un numero de tres digitos: "); n=Integer.parseInt(temp.readLine()); while ((n>99) &&(n<1000)){ System.out.println("El numero ingresado fue:"+n); n=0; } } }




EJERCICIO 156 REALIZAR UN PROGRAMA QUE MUESTRE LA TABLA DE MULTIPLICAR DEL 5. import java.io.*; import java.lang.*; class Tabla{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int acu =0, cont=0; while (cont<12){ cont=cont+1; acu=cont*5; System.out.println(acu); } } }




EJERCICIO 157 REALIZAR UN PROGRAMA QUE MUESTRE EL PROMEDIO DE LOS NÚMEROS INGRESADOS POR TECLADO. import java.io.*; import java.lang.*; class PromedioPrueba{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int x=0,num=0, cont=0, acu=0; float prom=0f; System.out.println("Ingrese cuantos numeros va a ingresar"); x=Integer.parseInt(temp.readLine()); while (cont<x){ System.out.println("Ingrese un numero"); num=Integer.parseInt(temp.readLine()); cont=cont+1; acu=acu+num; prom=acu/x; } System.out.println("El promedio es:"+prom); } }

EJERCICIO 158 INGRESE DOS NÚMEROS, SIENDO EL PRIMERO MAYOR QUE EL SEGUNDO. SE TRATA DE ELABORAR UN PROGRAMA QUE OBTENGA LA SUMA DE TODOS LOS NÚMEROS ENTEROS COMPRENDIDOS ENTRE ESOS DOS NÚMEROS, INCLUÍDOS ÉSTOS. import java.io.*; import java.lang.*;




class PromedioPrueba{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int a=0,b=0,acu=0; System.out.print("Ingrese el primer numero:"); a=Integer.parseInt(temp.readLine()); System.out.print("Ingrese el segundo numero:"); b=Integer.parseInt(temp.readLine()); while (b<=a){ acu=acu+b; b=b+1; } System.out.println("\n"+"La suma del rango es: "+acu); } }

EJERCICIO 159 REALIZAR UN PROGRAMA QUE CUENTE LA CANTIDAD DE DIGITOS QUE POSEE UN NÚMERO. PARA ELLO TENDREMOS QUE DIVIDIR POR DIEZ EL NÚMERO QUE NOS HAN DADO, HASTA QUE EL RESULTADO SE VUELVA CERO. public class CuentaDigitos{ public static void main(String args[]){ int número = 4557888; int dígitos = 0; while ( número > 0 ) { número /=10; dígitos++; } System.out.println(dígitos); } }




EJERCICIO 160 REALIZAR UN PROGRAMA QUE PRESENTE POR PANTALLA LA SERIE DE ULAM. LA SERIE DE ULAM: SI EL NUMERO ES PAR: N=N/2 SI EL NÚMERO ES IMPAR: N=N*3+1 import java.io.*; import java.lang.*; class SerieUlam{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader(new InputStreamReader(System.in)); int num; System.out.println("Ingrese un numero: "); num = Integer.parseInt(temp.readLine()); while(num!=1){ System.out.print(" "+num+" "); if((num%2)==0) num = num / 2; else num = num * 3 + 1; } System.out.println(" "+num+" "); } }




ESTRUCTURAS DE ITERACIÓN DO-WHILE A veces se puede desear el ejecutar el cuerpo de un bucle while al menos una vez, incluso si la expresión booleana de terminación tiene el valor false la primera vez. Es decir, si se desea evaluar la expresión de terminación al final del bucle en vez de al principio como en el bucle while. Esta construcción do-while hace eso exactamente. SINTAXIS [inicialización;] do { sentencias; [iteración;] }while( terminación-expresión-booleana ); EJERCICIO 161 REALIZAR UN PROGRAMA SENCILLO CON DO-WHILE, PRESENTANDO SÓLO UN MENSAJE. import java.io.*; import java.lang.*; class MensajeD{ public static void main(String arg[]) throws IOException{ do System.out.println("Se ejecuta al menos una vez"); while ( false ); } }




EJERICIO 162 REALIZAR EL MISMO PROGRAMA DEL EJERCICIO 60, PERO ÉSTA VEZ EL MENSAJE TIENE QUE PRESENTARSE INFINITAS VECES. import java.io.*; import java.lang.*; class MensajeD{ public static void main(String arg[]) throws IOException{ do System.out.println("Se ejecuta al menos una vez"); while ( true ); } }

EJERCICIO 163 REALIZAR UN PROGRAMA QUE PERMITA PRESENTAR LOS PRIMEROS 10 NÚMEROS ENTEROS POSITIVOS. import java.io.*; import java.lang.*; public class EnterosPosi{ public static void main(String args[]) throws IOException{ int a=0; System.out.println("Presentar los 10 primeros numeros enteros"); do { a++; System.out.println("\t"+a); }while(a<10);




} }

EJERCICIO 164 REALIZAR UN PROGRAMA QUE PRESENTE LOS 5 PRIMEROS NÚMEROS PARES. import java.io.*; import java.lang.*; class Par{ public static void main(String arg[]) throws IOException{ int par =0, cont=0; do{ par=par+2; cont=cont+1; System.out.println(par); }while (cont<5); } }

EJERCICIO 165 REALIZAR UN PROGRAMA QUE PERMITA MOSTRAR LOS SIGUIENTES NÚMEROS 4,8,16,32,64,128.




import java.io.*; import java.lang.*; class Sucesion{ public static void main(String arg[]) throws IOException{ int x=2; do{ x=x*2; System.out.println(x); }while (x<128); } }

EJERCICIO 166 REALIZAR UN PROGRAMA QUE GENERE 4 NÚMEROS CONSECUTIVOS DESPUÉS DEL NÚMERO INGRESADO POR TECLADO Y LUEGO SUMARLOS. import java.io.*; import java.lang.*; class Sucesion{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num=0, cont=0, sum=0; System.out.println("Ingrese un numero:"); num=Integer.parseInt(temp.readLine()); do{ num=num+1; sum=sum+num; cont++; }while (cont<4); System.out.println("Total: "+sum); }




}

EJERCICIO 167 REALIZAR UN PROGRAMA QUE GENERE UN LISTADO DE LOS 5 PRIMEROS NÚMEROS MÚLTIPLOS DE 5. import java.io.*; import java.lang.*; class Multi5{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int n =0, cont=0; System.out.println("Multiplos de 5"); do{ cont=cont+1; n=n+5; System.out.println("\t"+n); }while (cont<5); } }

EJERCICIO 168 SE DESEA INGRESAR POR TECLADO 3 NÚMEROS A, B, C SUMARLOS. SI LA SUMA ES IGUAL A 100 PRESENTAR POR PANTALLA DICHO RESULTADO Y FINALIZAR EL PROCESO, CASO CONTRARIO, INTTRODUCIR NUEVOS VALORES. REALIZAR UN PROGRAMA QUE PERMITA AUTOMATIZAR DICHO PROCESO.




import java.io.*; import java.lang.*; class SumaPrueba2{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int a,b,c,suma =0; do{ System.out.println("Ingrese el primer numero: "); a=Integer.parseInt(temp.readLine()); System.out.println("Ingrese el segundo numero: "); b=Integer.parseInt(temp.readLine()); System.out.println("Ingrese el tercer suma= a+b+c; }while (suma<100); System.out.println("El resultado de la suma: "+suma); } }

EJERCICIO 169 SE DESEA OBTENER LA SUMATORIA DE LOS 10 PRIMEROS NÚMEROS IMPARES. REALIZAR UN PROGRAMA EN JAVA QUE AUTOMATIZE DICHO PROCESO. import java.io.*; import java.lang.*; class SumaNum2{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num=0, cont=-1, acu=0; System.out.println("Suma de los 5 primeros # impares"); do{ cont=cont+2; acu=acu+cont; num=num+1; }while (num<5);




System.out.println("\n"+"\t"+"Resultado: "+acu); } }

EJERCICIO 170 RFALIZAR UN PROGRAMA QUE PERMITA GENERAR LOS 10 PRIMEROS NÚMEROS PARES. import java.io.*; import java.lang.*; class Pares2{ public static void main(String arg[]) throws IOException{ int par =0, cont=0; System.out.println("Los 10 primeros numeros pares"); do{ par=par+2; cont=cont+1; System.out.println("\t"+par); }while (cont<10); } }

EJERCICIO 171 RUN HACENDADO DESEA SABER CUÁL ES EL ÁREA DE SUS 10 HACIENDAS QUE TIENEN LA FORMA DE UN TRIÁNGULO. INGRESE LOS DATOS POR TECLADO Y PRESENTAR CADA UNO DE LOS RESULTADOS. REALIZAR UN PROGRAMA EN JAVA QUE AUTOMATIZE DICHO PROCESO.




import java.io.*; import java.lang.*; class SumaPrueba{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int a,b,cont=0; float area=0f; do{ System.out.println("Ingrese la altura: "); a=Integer.parseInt(temp.readLine()); System.out.println("Ingrese la base: "); b=Integer.parseInt(temp.readLine()); cont=cont+1; area= (b*a)/2; System.out.println("Area: "+area); }while (cont<5); } }

EJERCICIO 172 REALIZAR UN PROGRAMA QUE PRESENTE DE FORMA AUTOMÁTICA TODOS LOS NÚMEROS ENTEROS POSITIVOS DESDE EL CERO HASTA EL DATO INGRESADO POR TECLADO. import java.io.*; import java.lang.*; class NumPosi{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num=0,c=-1;




System.out.print("Ingrese un numero positivo: "); num=Integer.parseInt(temp.readLine()); do{ c++; System.out.println("\t"+c); }while (c<num); } }

EJERCICIO 173 REALIZAR UN PROGRAMA QUE PERMITA EL INGRESO DE 5 NÚMEROS POSITIVOS, SI EL NÚMERO INGRESADO ES NEGATIVO PRESENTARÁ UN MENSAJE Y TENDRÁ QUE INGRESAR UN NÚMERO POSITIVO. import java.io.*; import java.lang.*; class Negativos{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num=0,cont=0; do{ System.out.print("Ingrese un numero: "); num=Integer.parseInt(temp.readLine()); cont++; if(num<0) System.out.println("Ingrese un numero positivo: "); }while(cont<5); } }




EJEERCICIO 174 REALIZAR EL MISMO PROGRAMA DEL EJERCICIO 72, PERO ÉSTA VEZ SE TERMINA EL PROGRAMA SI EL NÚMERO INGRESADO ES CERO O ES NEGATIVO import java.io.*; import java.lang.*; class Negativos2{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num=0,cont=0; do{ System.out.print("Ingrese un numero: "); num=Integer.parseInt(temp.readLine()); cont++; }while((cont<5)&&(num>0)); } }

EJERCICIO 175 REALIZAR UN PROGRAMA QUE MUESTRE LOS 5 PRIMEROS NÚMEROS PARES E IMPARES EN EL MISMO CICLO. import java.io.*; import java.lang.*;




class ParesImpares2{ public static void main(String arg[]) throws IOException{ int par =0, impar=-1, cont=0; do{ par=par+2; impar=impar+2; cont=cont+1; System.out.println("Impar: "+impar); System.out.println("Par: "+par); }while (cont<5); } }

ESTRUCTURA DE ITERACIÓN CICLO FOR Un bucle for, normalmente involucra a tres acciones en su ejecución: Inicialización de la variable de control Comprobación del valor de la variable de control en una expresión condicional Actualización de la variable de control La cláusula de inicio y la cláusula de incremento pueden estar compuestas por varias expresiones separadas mediante el operador coma (,), que en estos bucles Java también soporta. for( a=0,b=0; a < 7; a++,b+=2 ) El operador coma garantiza que el operando de su izquierda se ejecutará antes que el operando de su derecha. Las expresiones de la cláusula de inicio se ejecutan una sola vez, cuando arranca el bucle. Cualquier expresión legal se puede emplear en esta




cláusula, aunque generalmente se utiliza para inicialización. Las variables se pueden declarar e inicializar al mismo tiempo en esta cláusula: for( int cnt=0; cnt < 2; cnt++ ) SINTAXIS for({valor inicial};{condición de termino};{factor de incremento del valor inicial}){ //acá va lo que se repetirá n veces de acuerdo a la condición de termino } FOR INFINITO Bucle infinito: no hay control, entonces no se detiene SINTAXIS for ( ;;){}

EJERCICIO 176 REALIZAR UN PROGRAMA EN JAVA QUE PRESENTE EL MENSAJE “HOLA” 10 VECES. import java.io.*; import java.lang.*; class HolaF{ public static void main(String arg[]) throws IOException{ int cont=0; for(cont=0;cont<5;cont=cont+1){ System.out.println("Hola"); } } }

EJERCICIO 177 REALIZAR UN PROGRAMA EN JAVA QUE PRESENTE LA SERIE DEL 5 HASTA LLEGAR A 20.




import java.io.*; import java.lang.*; class Serie{ public static void main(String arg[]) throws IOException{ int cont=0; for(cont=5;cont<=50;cont=cont+5){ System.out.println("\t"+cont); } } }

EJERCICIO 178 REALIZAR UN PROGRAMA QUE MUESTRE UN LISTADO DE LOS 20 PRIMEROS NÚMEROS PARES. import java.io.*; import java.lang.*; class ParesF{ public static void main(String arg[]) throws IOException{ int par =0, cont=0; for(cont=0;cont<10;cont++){ par=par+2; System.out.println("Los numeros pares son: "+par); } } }




EJERCICIO 179 REALIZAR UN PROGRAMA QUE PERMITA EL INGRESO DE UN NÚMERO Y SUMAR LOS 4 NÚMEROS ENTEROS POSITIVOS QUE LE SIGUEN. PRESENTAR EL RESULTADO Y FINALIZAR. import java.io.*; import java.lang.*; class SumaF{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num =0, cont=0, sum=0; System.out.println("Ingrese un numero: "); num=Integer.parseInt(temp.readLine()); for(cont=0;cont<4;cont++){ num=num+1; sum=sum+num; } System.out.println("Resultado: "+sum); } }

EJERCICIO 180 REALIZAR UN PROGRAMA QUE PERMITA PRESENTAR LA SIGUIENTE SERIE: 4,8,16,32,64,128. import java.io.*;




import java.lang.*; class SerieF{ public static void main(String arg[]) throws IOException{ for(int x=4;x<=128;x=x*2){ System.out.println(x); } } }

EJERCICIO 181 UN HACENDADO DESEA SABER CUÁL ES EL ÁREA DE LAS 5 HACIENDAS QUE TIENEN LA FORMA DE UN TRIÁNGULO. INGRESE LOS DATOS POR TECLADO Y PRESENTAR CADA UNO DE LOS RESULTADOS. import java.io.*; import java.lang.*; class HaciendaF{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int a,b,cont=0; float area=0f; for(cont=0;cont<5;cont++){ System.out.print("Ingrese la altura: "); a=Integer.parseInt(temp.readLine()); System.out.print("Ingrese la base: "); b=Integer.parseInt(temp.readLine()); area= (b*a)/2; System.out.println("Area: "+area); }




} }

EJERCICIO 182 SE DESEA VISUALIZR EL RESULTADO DE LA TABLA DE MULTIPLICAR DE UN NÚMERO INGRESADO POR TECLADO. import java.io.*; import java.lang.*; class TablaF{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num=0, acu =0, cont=0; System.out.print("Ingrese un número: "); num=Integer.parseInt(temp.readLine()); for(cont=0;cont<12;cont++){ acu=cont*num; System.out.println(cont+"*"+num+"="+acu); } } }




EJERCICIO 183 REALIZAR UN PROGRAMA QUE PERMITA VISUALIZAR LOS 10 PRIMEROS MÚLTIPLOS DE UN VALOR INGRESADO POR EL TECLADO. import java.io.*; import java.lang.*; class MultiF{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int n =0, cont=0, r=0; System.out.print("Ingrese cualquier numero positivo: "); n=Integer.parseInt(temp.readLine()); System.out.println("Primeros multiplos de 5"); for(cont=0;cont<5;cont++){ r=r+n; System.out.println(r); } } }




EJERCICIO 184 REALIZAR EL MISMO PROGRAMA DEL EJERCICIO 82 PERO ESTA VEZ UTILIZANDO SECUENCIAS DE ESCAPE PARA MEJORAR LA APRIENCIA DEL PROGRAMA. import java.io.*; import java.lang.*; class Multiplo{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int n =0, cont=0, r=0; System.out.print("\t"+"Ingrese cualquier numero positivo: "); n=Integer.parseInt(temp.readLine()); System.out.println("\n"+"\t"+"5 Primeros multiplos de 5"); for(cont=0;cont<5;cont++){ r=r+n; System.out.println("\n"+"\t"+r); } } }




EJERCICIO 185 REALIZAR UN PROGRAMA QUE MUESTRE EL FACTORIAL DE UN NÚMERO INGRESADO POR TECLADO. import java.io.*; import java.lang.*; class factorial1{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader ( new InputStreamReader(System.in)); int n, i, acum=1; System.out.println("Ingrese un numero: "); n = Integer.parseInt(temp.readLine()); for(i=1; i<=n; i++){ acum = acum * i; } System.out.println("El factorial es: "+acum); } }




EJERCICIO 186 REALIZAR UN PROGRAMA QUE PERMITA MOSTRAR LA SUMATORIA DE LOS 10 PRIMEROS NÚMEROS. import java.io.*; import java.lang.*; class sumatoria{ public static void main (String a[]) throws IOException{ int i, suma=0; for(i=1; i<=10; i= i + 1){ suma = suma + i; } System.out.println("La sumatoria es "+suma); } }

EJERCICIO 187 REALIZAR UN PROGRAMA QUE PERMITA PRESENTAR POR PANTALLA LA SERIE FIBONACCI, PERO SÓLO HASTA EL NÚMERO INGRESADO POR TECLADO. POR EJEMPLO: INGRESO EL DOS, SÓLO SE PRESENTARÁ 2 NÚMEROS DE LA SERIE FIBONACCI. import java.io.*; import java.lang.*; class fibonacci{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num,i=0; int a=-1, b=1, c=0; System.out.println("Ingrese un numero: "); num=Integer.parseInt(temp.readLine()); for(i=1; i<=num; i++){ c = a + b;




a = b; b = c; System.out.println("Fibonacci: "+" "+c+" "); } } }

EJERCICIO 188 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA PRESENTAR DESDE EL CERO HASTA EL NÚMERO INDICADO POR EL USUARIO. //Uso de un ciclo for import java.text.*; import java.io.*; import java.lang.*; public class j007 { public static void main(String[]args)throws IOException { System.out.println("Programa para ilustrar el uso del ciclo for en Java."); BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); System.out.println("Hasta que numero deseas que se imprima?"); double num=Double.valueOf(in.readLine().trim()).doubleValue(); for(int i=0;i<=num;i++) { System.out.println(i); } System.out.println("Como se observa el ciclo for tiene un inicio,fin,y paso."); } }




EJERCICIO 189 Imprime una etiqueta en pantalla las veces que quieras. import java.text.*; import java.io.*; import java.lang.*; class j019 { public static void main(String [] args) throws IOException { BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); System.out.print("Numero de etiquetas: "); double etiq=Double.valueOf(in.readLine().trim()).doubleValue(); System.out.println(); for (int i=0;i<etiq;i++) { System.out.println("================"); System.out.println("| H O L A |"); System.out.println("================"); System.out.println("\n\n"); } } }




EJERCICIO 190 Muestra una tabla de temperaturas de Celsius a Fahrenheit. import java.io.*; import java.lang.*; class j021 { /* Tabla de temperaturas Celsius Farenheit */ public static void main(String [] args) { System.out.println("Tabla de conversion de Temperaturas"); System.out.println("==================================="); System.out.println(); System.out.println("C\tF"); for (int c=5;c<=20;c++) { System.out.print(c+"\t"); System.out.println(Math.round(c*9/5+32)); } } }

EJERCICIO 191 VARIACIÓN DEL CÓDIGO ANTERIOR import java.io.*; import java.lang.*;




class j022 { static final int colsPorLinea=5; static final int maxNoLinea=10; static final String hueco="\t"; public static void main(String[]args) { System.out.println("\tTabla conversion temperaturas"); System.out.println("\t============================="); System.out.println(); for(int col=0;col<colsPorLinea;col++) System.out.print("C F"+hueco); System.out.println(); for(int linea=0;linea<maxNoLinea;linea++) impLinea(linea); } static void impLinea(int estalinea) { for(int col=0;col<colsPorLinea;col++) { int c=estalinea*colsPorLinea+col; System.out.print(c+" "); System.out.print(fahrenheit(c)+hueco); } System.out.println(); } static int fahrenheit(int Celsius) { return Math.round(Celsius*9/5+32); } }




EJERCICIO 191 SUMAR LOS ENTEROS PARES DEL 2 AL 100, UTILIZANDO CUADROS DE DIÁLOGOS. //Paquete de Java import javax.swing.JOptionPane; public class SumaFor { public static void main (String args []) { int total=0;//inicializar el total //sumar los enteros pares del 2 al 100 for(int numero=2;numero<=100; numero+=2 ) total+=numero; //mostrar el resultado JOptionPane.showMessageDialog(null,"La suma es: "+total, "Suma de los enteros pares del 2 al 100 ",JOptionPane.INFORMATION_MESSAGE); System.exit(0); } }

CÁLCULO DEL INTERÉS COMPUESTO




UNA PERSONA INVIERTE $1000.00 EN UN ACUENTA DE AHORRO QUE PRODUCE EL 5% DE INTRÉS. SUPONIENDO QUE TODO EL INTERÉS SE DEPOSITA EN LACUENTA, CALCULE E IMPRIMA EL MONTO DE LA CUENTA AL FINAL DE CADA AÑO, DURANTE 10 AÑOS. USE LA SIGUIENTE FÓRMULA PARA CALCULAR ,LOS MONTOS: C= P(1+T)^N EN DONDE P ES EL MONTO QUE SE INVIRTIÓ INICIALMENTE (ES DECIR EL MONTO PRINCIPAL) T ES LA TASA DE INTERÉS ANUAL N ES EL NÚMERO DE AÑOS C ES LA CANTIDAD DEPOSITADA AL FINAL DEL N-ÉSIMO AÑO. //Paquete de Java import java.text.NumberFormat; //calse para el formato numérico import java.util.Locale; //clase para información específica de cada país. import javax.swing.JOptionPane; import javax.swing.JTextArea; public class InteresFor { public static void main (String args []) { double cantidad=0; //cantidad depositada al final de cada año double principal=1000.0; //cantidad inicial sin intereses double tasa=0.05; //tasa de interés //Crear NumberFormat para la moneda en dólares NumberFormat formatoMoneda=NumberFormat.getCurrencyInstance(Locale.US); //Crear JTextArea para mostrar la salida JTextArea areaTextoSalida=new JTextArea(); areaTextoSalida.setText("Año\tCantidad en Depósito\n"); //Calcular la cantidad de depósito para cada uno de los 10 años for(int anio=2;anio<=10; anio++ ) { //Calcular la nueva cantidad para el año especificado cantidad= principal*Math.pow(1.0+tasa, anio); //Anexar una línea de texto a areaTextoSalida areaTextoSalida.append(anio+"\t"+formatoMoneda.format(cantidad)+"\n"); } //mostrar el resultado




JOptionPane.showMessageDialog(null,areaTextoSalida, "Interés Compuesto",JOptionPane.INFORMATION_MESSAGE); System.exit(0); } }

SALTOS SENTENCIA BREAK La sentencia break puede utilizarse en una sentencia switch o en un bucle. Cuando se encuentra en una sentencia switch, break hace que el control del flujo del programa pase a la siguiente sentencia que se encuentre fuera del entorno del switch. Si se encuentra en un bucle, hace que el flujo de ejecución del programa deje el ámbito del bucle y pase a la siguiente sentencia que venga a continuación del bucle.




EJERCICIO 192 Este programa cuenta los dígitos de un número y en caso de que dicho número tenga 5 o más dígitos nos muestra por consola el mensaje "el número tiene 5 o más dígitos". Véase la línea "if (dígitos ==5) break;" cuya presencia hace que en caso de que el número haya llegado a los 5 dígitos se rompa la iteración del bucle. import java.io.*; import java.lang.*; public class CuentaDigitosBr{ public static void main(String args[]){ int número = 4557888; int dígitos = 0; while ( número > 0 ) { número /=10; dígitos++; if (dígitos ==5) break; } if (dígitos ==5) System.out.println("El numero tiene 5 o mas digitos"); } }

EJERCICIO 193 REALIZAR UN PROGRAMA QUE PRESENTE POR PANTALLA EL MAYOR NÚMERO DE LOS NÚMEROS INGRESADOS POR PANTALLA. import java.io.*; import java.lang.*;




class Maximo{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num1 =0, num2=0, mayor=0; System.out.print("Ingrese el primer numero: "); num1=Integer.parseInt(temp.readLine()); System.out.print("Ingrese el segundo numero: "); num2=Integer.parseInt(temp.readLine()); mayor=Math.max(num1,num2); System.out.println("\n"+"El numero mayor entre " +num1+ " y " +num2+ " es: "+mayor); } }

EJERCICIO 194 REALIZAR UN PROGRAMA QUE SIMULE UN CAJERO AUTOMÁTICO. import java.io.*; import java.lang.*; class cajero{ public static void main(String a[]) throws IOException{ BufferedReader t=new BufferedReader(new InputStreamReader(System.in)); int i; String nombre; System.out.println(" CAJERO AUTOMATICO"); System.out.println(""); System.out.print(" NOMBRE: "); nombre=t.readLine(); System.out.println(""); System.out.println(" (1) $10 (2) $20"); System.out.println(" (3) $30 (4) $40"); System.out.println("");




System.out.println(""); //INGRESO DE LA OPCION System.out.print(" OPCION: "); i=Integer.parseInt(t.readLine()); System.out.println(""); System.out.println(""); switch(i) {case 1:System.out.println(" Ud. "+nombre+" ha retirado $10. Gracias por su preferencia");break; case 2:System.out.println(" Ud. "+nombre+" ha retirado $20. Gracias por su preferencia");break; case 3:System.out.println(" Ud. "+nombre+" ha retirado $30. Gracias por su preferencia");break; case 4:System.out.println(" Ud. "+nombre+" ha retirado $40. Gracias por su preferencia");break; } } }




Declaración de Paquetes Los paquetes se declaran utilizando la palabra package seguida del nombre del paquete. Esto debe estar al comienzo del fichero fuente, en concreto, debe ser la primera sentencia ejecutable del código Java, excluyendo, claro está, los comentarios y espacios en blanco. Por ejemplo: package mamiferos; class Ballena { . . . } En este ejemplo, el nombre del paquete es mamiferos. La clase Ballena se considera como parte del paquete. La inclusión de nuevas clases en el paquete es muy sencilla, ya que basta con colocar la misma sentencia al comienzo de los ficheros que contengan la declaración de las clases. Como cada clase se debe colocar en un fichero separado, cada uno de los ficheros que contengan clases pertenecientes a un mismo paquete, deben incluir la misma sentencia package, y solamente puede haber una sentencia package por fichero. También se pueden incluir varias clases en uno o más paquetes. Por ejemplo: package mamiferos.acuaticos; La clase Ballena pertenece al paquete mamiferos.acuaticos, acuaticos es un subpaquete del paquete mamíferos. EJERCICIO 195 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA MOSTRAR POR PANTALLA EL MENSAJE Hola Mundo, PERO COLOQUELO EN UN PAQUETE. package saludos; import java.io.*; import java.lang.*; public class HolaMundo { public static void main (String args []) { System.out.print ("Hola Mundo"); } } /*El nombre del paquete es saludos y nuestra clase HolaMundo pertenece a ese paquete*/




EJERCICIO 196 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA MOSTRAR POR PANTALLA EL MENSAJE Hola Mundo EN DOS SENTENCIAS, PERO COLOQUELO EN EL MISMO PAQUETE SALUDOS. package saludos; import java.io.*; import java.lang.*; public class HolaMundo2 { public static void main (String args []) { System.out.print ("Hola "); System.out.println ("Mundo"); } }

EJERCICIO 197 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE UN MENSAJE CON VARIAS INSTRUCCIONES, UNA PALABRA POR MENSAJE Y COLOQUELO EN EL MISMO PAQUETE SALUDOS. package saludos; import java.io.*; import java.lang.*; public class HolaMundoln { public static void main (String args []) { System.out.print ("Bienvenido"); System.out.print (" a"); System.out.print (" la"); System.out.print (" Programacion");




System.out.print (" en"); System.out.println (" Java"); } } NOTA: Se pueden realizar varaias sentencias para mostrar mensajes en el mismo médoto Main.

EJERCICIO 198 MOSTRAR VARIAS LÍNEAS DE TEXTO CON UNA SÓLA INSTRUCCIÓN, UTILIZANDO LAS SECUENCIAS DE ESCAPE NECESARIAS. Y COLOQUELO EN EL PAQUETE SENTENCIAS. package sentencias; import java.io.*; import java.lang.*; public class HolaMundo3 { public static void main (String args []) { System.out.println ("Bienvenido\na\nla\nprogramacion\nen Java!!!"); } }

EJERCICIO 199 MOSTRAR UNA LÍNEA DE TEXTO QUE VAYA ENTRE COMILLAS DOBLES. Y COLOQUELO EN EL PAQUETE SENTENCIAS. package sentencias;




import java.io.*; import java.lang.*; public class HolaMundo5 { public static void main (String args []) { System.out.println ("\"Hola Mundo\""); } }

EJERCICIO 200 MOSTRAR UNA LÍNEA DE TEXTO QUE VAYA ENTRE COMILLAS DOBLES. Y COLOQUELO EN EL PAQUETE SENTENCIAS. package sentencias; import java.io.*; import java.lang.*; public class HolaMundo5 { public static void main (String args []) { System.out.println ("\"Hola Mundo\""); } }

EJERCICIO 201 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE UNA LÍNEA DE TEXTO QUE VAYA ENTRE COMILLAS SIMPLES. package sentencias.escape; import java.io.*; import java.lang.*; public class HolaMundo5 {




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

EJERCICIO 202 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE UNA LÍNEA DE TEXTO PERO QUE BORRE UN CARÁCTER A LA IZQUIERDA. package sentencias.escape; import java.io.*; import java.lang.*; public class HolaMundo9 { public static void main (String args []) { System.out.println ("Hola\bMundo"); } }

EJERCICIO 203 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE UNA LÍNEA DE TEXTO PERO QUE MUESTRE EL CARÁCTER \ EN EL MENSAJE. package sentencias.escape; import java.io.*; import java.lang.*; public class HolaMundo10 { public static void main (String args []) { System.out.println ("Hola\\Mundo"); }




}

PROGRAMACIÓN ORIENTADA A OBJETOS El elemento fundamental de la OOP es, como su nombre lo indica, el objeto. Podemos definir un objeto como un conjunto complejo de datos y programas que poseen estructura y forman parte de una organización. Esta definición especifica varias propiedades importantes de los objetos. En primer lugar, un objeto no es un dato simple, sino que contiene en su interior cierto número de componentes bien estructurados. En segundo lugar, cada objeto no es un ente aislado, sino que forma parte de una organización jerárquica o de otro tipo. ESTRUCTURA DE UN OBJETO Un objeto puede considerarse como una especie de cápsula dividida en tres partes: 1 - RELACIONES 2 - PROPIEDADES 3 - METODOS Cada uno de estos componentes desempeña un papel totalmente independiente: Las relaciones permiten que el objeto se inserte en la organización y están formadas esencialmente por punteros a otros objetos. Las propiedades distinguen un objeto determinado de los restantes que forman parte de la misma organización y tiene valores que dependen de la propiedad de que se trate. Las propiedades de un objeto pueden ser heredadas a sus descendientes en la organización. Los métodos son las operaciones que pueden realizarse sobre el objeto, que normalmente estarán incorporados en forma de programas (código) que el objeto es capaz de ejecutar y que también pone a disposición de sus descendientes a través de la herencia. Encapsulamiento y ocultación Esta propiedad (encapsulamiento), es una de las características fundamentales en la OOP, el hecho de que cada objeto sea una cápsula facilita enormemente que un objeto determinado pueda ser transportado a otro punto de la organización, o incluso a otra organización totalmente diferente que precise de él. Si el objeto ha sido bien construído, sus métodos seguirán funcionando en el nuevo entorno sin problemas. Esta cualidad hace que la OOP sea muy apta para la reutilización de programas. HERENCIA La herencia es específica de la programación orientada a objetos, donde una clase nueva se crea a partir de una clase existente. La herencia (a la que habitualmente se denomina subclases) proviene del hecho de que la subclase (la nueva clase creada)

http://www.monografias.com/trabajos11/basda/basda.shtml

http://www.monografias.com/Computacion/Programacion/

http://www.monografias.com/trabajos15/todorov/todorov.shtml#INTRO

http://www.monografias.com/trabajos6/napro/napro.shtml

http://www.monografias.com/trabajos5/recicla/recicla.shtml#papel



http://www.monografias.com/trabajos14/nuevmicro/nuevmicro.shtml

http://www.monografias.com/trabajos16/romano-limitaciones/romano-limitaciones.shtml



http://www.monografias.com/trabajos6/diop/diop.shtml


http://www.monografias.com/trabajos13/heren/heren.shtml

http://www.monografias.com/trabajos16/romano-limitaciones/romano-limitaciones.shtml

http://www.monografias.com/trabajos10/carso/carso.shtml



http://www.monografias.com/trabajos11/metods/metods.shtml

http://www.monografias.com/trabajos15/calidad-serv/calidad-serv.shtml#PLANT





contiene las atributos y métodos de la clase primaria. La principal ventaja de la herencia es la capacidad para definir atributos y métodos nuevos para la subclase, que luego se aplican a los atributos y métodos heredados. Esta particularidad permite crear una estructura jerárquica de clases cada vez más especializada. La gran ventaja es que uno ya no debe comenzar desde cero cuando desea especializar una clase existente. Como resultado, se pueden adquirir bibliotecas de clases que ofrecen una base que puede especializarse a voluntad (la compañía que vende estas clases tiende a proteger las datos miembro usando la encapsulación). Jerarquía de clase La relación primaria-secundaria entre clases puede representarse desde un punto de vista jerárquico, denominado vista de clases en árbol. La vista en árbol comienza con una clase general llamada superclase (a la que algunas veces se hace referencia como clase primaria, clase padre, clase principal, o clase madre; existen muchas metáforas genealógicas). Las clases derivadas (clase secundaria o subclase) se vuelven cada vez más especializadas a medida que van descendiendo el árbol. Por lo tanto, se suele hacer referencia a la relación que une a una clase secundaria con una clase primaria mediante la frase "es una" x o y.

Herencia múltiple Algunos lenguajes orientados a objetos, como C++ permiten herencias múltiples, lo que significa que una clase puede heredar los atributos de otras dos superclases. Este método puede utilizarse para agrupar atributos y métodos desde varias clases dentro de una sola.

http://es.kioskea.net/contents/poo/encapsul.php3




POLIMORFISMO Se denomina polimorfismo a la capacidad que tienen los objetos de una clase de responder al mismo mensaje o evento en función de los parámetros utilizados durante su invocación. Un objeto polimórfico es una entidad que puede contener valores de diferentes tipos durante la ejecución del programa. EJERCICIO CLASE 1: NOMBRE DE LA CLASE 1. ATRIBUTOS DE LA CLASE. CLASE 2: NOMBRES DE LA CLASE: TRIANGULO 1. ATRIBUTOS: BASE Y ALTURA. CLASE 3: EN DÓNDE SE CREEN OBJETOS TRIÁNGULOS, SE PUEDE OBTENER EL ÁREA Y EL PERÍMETRO. TAMBIÉN DEBE DECIR COMO OBTENER LA NORMA DEL VECTOR QUE GENERA EL PUNTO Y LA DISTANCIA ENTRE LOS OBJETOS DE TIPO PUNTO. CLASE PUNTO package IOp; class Punto{ int a=0,b=0; Punto(int x, int y){ a=x; b=y; } }

http://es.wikipedia.org/wiki/Clase_(inform%C3%A1tica)




CLASE TRIÁNGULO package IOp; public class Triangulo{ public int Base; public int Altura; public Triangulo(int base, int altura){ Base=base; Altura=altura; } void Area(){ float a; a=(Base*Altura)/2; System.out.println(a); } void Perimetro(){ float r,n,h; n=(float)(Math.sqrt(Math.pow(Base,2))+(Math.pow(Altura,2))); r= Base+Altura +n; System.out.println(r); } } CLASE APLICACIÓN package IOp; class Aplicacion{ public static void main(String arg[]) { Triangulo triangulo1= new Triangulo(8,9); triangulo1.Area(); triangulo1.Perimetro(); Punto p1=new Punto (2,8); Punto p2=new Punto(3,5); float p; p=(float)(Math.sqrt(Math.pow((p1.a-p2.a),2)+ (Math.pow((p1.b-p2.b),2)))); System.out.println(p); }




}

HERENCIA EJERCICIO 204 package Militar2.Clases.Deber; public class Persona{ public String nombre,sexo; public int edad,cedula; public Persona(String n, int e, String s,int c){ nombre=n; edad=e; sexo=s; cedula=c; } } NOTA: LO QUE ESTÁ ENCERRADO ES EL MÉTODO CONSTRUCTOR, LAS VARIABLES QUE SE ENCUENTRAN EN PARÉNTESIS SON VARIABLES DEL MÉTODO CONSTRUCTOR QUE SE LAS DEBE ASIGNAR A LAS VARIABLES ASIGNADAS EN LA CLASE EN ESTE CASO LA CLASE PERSONA.

ERROR COMÚN El método constructor tien que tener el mismo nombre de la clase. Por ejemplo: La clase se llama “Persona”, el método constructor debe llamarse también “Persona”. CLASE TRABAJADORES package Militar2.Clases.Deber; public class Trabajadores extends Persona{ public double sueldo; public Trabajadores(String n, int e, String s, int c,double su){ super(n,e,s,c); sueldo=su; } } NOTA: LO QUE ESTÁ ENCERRADO EN UN CÍRCULO ES EL MÉTODO CONSTRUCTOR DE LA CLASE TRABAJADORES, LO QUE ESTÁ EN UN CUADRADO ES LO QUE SE DENOMINA HERENCIA, YA QUE LA CLASE TRABAJDORES TIENE ATRIBUTOS QUE TIENE LA CLASE PERSONA.




LA HERENCIA TAMBIÉN CONOCIDO COMO REUTILIZACIÓN DE CÓDIGO, UN TRABAJDOR ES UNA PERSONA POR LO TANTO TIENE ATRIBUTOS QUUE TIENE UNA PERSONA, ATRIBUTOS SON LAS VARIABLES, PERO EN LA PROGRAMACIÓN ORIENTADA A OBJETOS SE DENOMINA ATRIBUTOS. EN ESTE CASO SUPER LLAMA A TODOS LOS ATRIBUTOS DE LA CLASE PERSONA. /*Método Constructor de la Clase Persona*/ public Persona(String n, int e, String s,int c){ nombre=n; edad=e; sexo=s; cedula=c; } } super(n,e,s,c); Los atributos que coloco en el método constructor debe coincidir con los que ponga con super en la clase del método constructor que quiero que herede. CLASE POLÍTICO public class Politico extends Trabajadores{ public String partido; public Politico(String n, int e, String s, int c, double su, String p){ super(n,e,s,c,su); partido=p; } } NOTA: LA CLASE POLÍTICO HEREDA DE LA CLASE TRABAJADORES, SE DEBEN COLOCAR TODOS LOS ATRIBUTOS QUE SE HAN VENIDO HEREDANDO CON EL MÉTODO SUPER, ES LA FORMA MÁS FÁCIL DE PROGRAMAR REUTILIZANDO CÓDIGO. CLASE MILITAR package Militar2.Clases.Deber; public class Militar extends Trabajadores{ public String rango; public Militar(String n, int e, String s, int c,double su, String r){ super(n,e,s,c,su); rango=r; } }




NOTA: LA CLASE MILITAR NO PUEDE HEREDAR DE LA CLASE POLÍTICO PORQUE NO TIENE UNA SECUENCIA LÓGICA, EN CAMBIO SI SE PUEDE DECIR QUE UN MILITAR SI ES UN TRABAJADOR Y TIENE ATRIBUTOS DE UN TRABAJADOR. CLASE LEER ÉSTA CLASE ES REUTILIZABLE, PORQUE PERMITE LEER EN CUADROS DE DIÁLOGOS, CADENAS DE TEXTO, ENTEROS Y DOUBLES. VEA SU UTILIZACIÓN EN LA CLASE APLICACIÓN. package Militar2.Clases.Deber; public class Leer{ public String leerTexto(String texto){ return javax.swing.JOptionPane.showInputDialog(null,texto); } public int leerInt(String texto ) { String t= javax.swing.JOptionPane.showInputDialog(null,texto); return Integer.parseInt(t); } public double leerDouble(String texto ){ String t= javax.swing.JOptionPane.showInputDialog(null,texto); return Double.parseDouble(t); } } CLASE MOSTRAR ÉSTA CLASE EVITA TENER QUE ESCRIBIR DENTRO DE LA MISMA CLASE JOptionPane.showMessageDialog. package Militar2.Clases.Deber; public class Mostrar{ public void mensaje(String m){ javax.swing.JOptionPane.showMessageDialog(null,m); } } Se coloca javax.swing si no se coloca la librería también se puede hacer así: package Militar2.Clases.Deber;




import javax.swing.*; public class Mostrar{ public void mensaje(String m){ JOptionPane.showMessageDialog(null,m); } } CLASE APLICACIÓN - linea.leerTexto—llama al método en la clase leer y lo mismo hace leerInt ya que se encuentra en la clase leer, esto ayuda a tener un orden en el programa, ya que las clase leer y mostrar se las puede utilizar con todos los programas muchas veces, pero si lo hicieramos en el mismo programa lo utilizaríamos una sóla vez. package Militar2.Clases.Deber public class Aplicacion{ public static void prueba(){ Leer linea = new Leer(); Mostrar m= new Mostrar(); String n= linea.leerTexto("Ingrese el nombre"); int e= linea.leerInt("Ingrese la edad"); String s= linea.leerTexto("Ingrese su sexo: "); int c=linea.leerInt("Ingrese su número de cédula: "); Persona p= new Persona(n,e,s,c); n="El nombre es:" +p.nombre+"\nEdad:"+p.edad+"\nSexo:"+p.sexo+"\nCédula:"; m.mensaje(n); } public static void main(String arg[]){ Mostrar m = new Mostrar(); Leer linea= new Leer(); m.mensaje("Bienvenido"); m.mensaje("\tSistema de Ingreso \t\nAutor: Gabriela Montesdeoca"); String n=linea.leerTexto("Ingrese el nombre"); m.mensaje(" Su nombre es: " +n); int x=linea.leerInt("Ingrese la edad"); m.mensaje(" Su edad es:" +x); String b=linea.leerTexto("Ingrese su sexo"); m.mensaje(" Su sexo es: " +b); String a=linea.leerTexto("Ingrese el número de la cédula: "); m.mensaje(" Su cedula es:" +a); double z=linea.leerDouble("Ingrese el sueldo");




m.mensaje(" Su sueldo es: " +z); String r=linea.leerTexto("Ingrese el rango"); m.mensaje(" Su rango es: " +r); String p=linea.leerTexto("Ingrese el partido"); m.mensaje(" Su partido es: " +p); m.mensaje("Gracias por preferirnos"); } }

MULTIHILOS Considerando el entorno multithread (multihilo), cada thread (hilo, flujo de control del programa) representa un proceso individual ejecutándose en un sistema. A veces se les llama procesos ligeros o contextos de ejecución. Típicamente, cada hilo controla un único aspecto dentro de un programa, como puede ser supervisar la entrada en un determinado periférico o controlar toda la entrada/salida del disco. Todos los hilos comparten los mismos recursos, al contrario que los procesos, en donde cada uno tiene su propia copia de código y datos (separados unos de otros). Gráficamente, los hilos (threads) se parecen en su funcionamiento a lo que muestra la figura siguiente:

Hay que distinguir multihilo (multithread) de multiproceso. El multiproceso se refiere a dos programas que se ejecutan "aparentemente" a la vez, bajo el control del Sistema Operativo. Los programas no necesitan tener relación unos con otros, simplemente el hecho de que el usuario desee que se ejecuten a la vez. Multihilo se refiere a que dos o más tareas se ejecutan "aparentemente" a la vez, dentro de un mismo programa. Se usa "aparentemente" en ambos casos, porque normalmente las plataformas tienen una sola CPU, con lo cual, los procesos se ejecutan en realidad "concurrentemente", sino que comparten la CPU. En plataformas con varias CPU, sí es posible que los procesos se ejecuten realmente a la vez. Tanto en el multiproceso como en el multihilo (multitarea), el Sistema Operativo se encarga de que se genere la ilusión de que todo se ejecuta a la vez. Sin embargo, la multitarea puede producir programas que realicen más trabajo en la misma cantidad de tiempo que el multiproceso, debido a que la CPU está compartida entre tareas de un mismo proceso. Además, como el multiproceso está implementado a nivel de sistema operativo, el programador no puede intervenir en el planteamiento de su ejecución; mientras que en el caso del multihilo, como el programa debe ser diseñado




expresamente para que pueda soportar esta característica, es imprescindible que el autor tenga que planificar adecuadamente la ejecución de cada hilo, o tarea. Actualmente hay diferencias en la especificación del intérprete de Java, porque el intérprete de Windows '95 conmuta los hilos de igual prioridad mediante un algoritmo circular (round-robin), mientras que el de Solaris 2.X deja que un hilo ocupe la CPU indefinidamente, lo que implica la inanición de los demás. EJERCICIO 205 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA MOSTRAR POR PANTALLA UN HOLA MUNDO CON UN HILO. // Definimos unos sencillos hilos. Se detendrán un rato // antes de imprimir sus nombres y retardos class TestTh extends Thread { private String nombre; private int retardo; // Constructor para almacenar nuestro nombre // y el retardo public TestTh( String s,int d ) { nombre = s; retardo = d; } // El metodo run() es similar al main(), pero para // threads. Cuando run() termina el thread muere public void run() { // Retasamos la ejecución el tiempo especificado try { sleep( retardo ); } catch( InterruptedException e ) { ; } // Ahora imprimimos el nombre System.out.println( "Hola Mundo! "+nombre+" "+retardo ); } } CLASE MULTIHOLA public class MultiHola { public static void main( String args[] ) { TestTh t1,t2,t3;




// Creamos los threads t1 = new TestTh( "Thread 1",(int)(Math.random()*2000) ); t2 = new TestTh( "Thread 2",(int)(Math.random()*2000) ); t3 = new TestTh( "Thread 3",(int)(Math.random()*2000) ); // Arrancamos los threads t1.start();//SE INICIALIZA t2.start(); t3.start(); } }

NOTA: EL HILO 2 LLEGÓ PRIMERO.

NOTA: EL HILO 1 LLEGÓ PRIMERO

POLIMORFISMO CLASE FORMAS




EJEMPLO 206 package Pol; import java.io.*; import java.awt.*; class Forma { void dibujar() {} void borrar() {} } public class Formas { public static Forma formaAleatoria() { switch((int)(Math.random() * 3)) { default: case 0: return new Circulo(); case 1: return new Cuadrado(); case 2: return new Triángulo(); } } public static void main(String[] args) { Forma[] s = new Forma[9]; // Rellenar el array con varias formas: for(int i = 0; i < s.length; i++) s[i] = formaAleatoria(); // llamar a los método para ver el polimorfismo: for(int i = 0; i < s.length; i++) s[i].dibujar(); } } CLASE CIRCULO class Circulo extends Formas { void dibujar() { System.out.println("Circulo.dibujar()"); } void borrar() { System.out.println("Circulo.borrar()"); } }




CLASE CUADRADO class Cuadrado extends Formas { void dibujar() { System.out.println("Cuadrado.dibujar()"); } void borrar() { System.out.println("Cuadrado.borrar()"); } } CLASE TRIANGULO class Triángulo extends Formas { void dibujar() { System.out.println("Triangulo.dibujar()"); } void borrar() { System.out.println("Triangulo.borrar()"); } }

TRABAJO CON PANELES EJERCICIO PRUEBA REALIZAR UN PROGRAMA QUE MUESTRE UNA VENTANA. UTILIZE SÓLO UNA APLICACIÓN. LUEGO VEA EL EJERCICIO 1 QUE UTILIZA DOS APLICACIONES. import java.awt.*;




public class Ventana extends Frame{ public Ventana(){ show(); } public static void main(String arg[]){ new Ventana(); } }

NOTA: EL PROGRAMA QUE SE EJECUTA EN DONDE ESTÉ EL MÉTODO MAIN. /*show(), se debe poner para mostrar la ventana*/ EJERCICIO 207 REALIZAR UN PROGRAMA PARA CREAR DOS APLICACIONES Y QUE UNA DE LAS APLICACIONES LLAME A LA OTRA. CREE UNA VENTANA SIMPLE. package awt.Ejemplo1; import java.awt.*; public class Ventana extends Frame{ public Ventana(){ show(); } } package awt.Ejemplo1; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }

/* SE EJECUTA LA CLASE APLICACIÓN*/ /* CREA UNA VENTANA SIN NINGÚN TAMAÑO, ES POR ESO QUE APARECE SÓLO CON LOS BOTONES DE MINIMIZAR, MAXIMIZAR Y CERRAR, PARA ESTABLECER UN TAMAÑO A LA VENTANA SE UTILIZA LA OPCIÓN setsize (ANCHO,LARGO). VEA EL EJERCICIO 2*/ EJERCICIO 153




REALIZAR EL MISMO PROGRAMA DEL EJERCICIO 1, PERO ÉSTA VEZ COLOQUE UN TAMAÑO FIJO EN LA VENTANA. package awt.Ejemplo2; import java.awt.*; public class Ventana extends Frame{ public Ventana(){ setSize(250,150); show(); } } package awt.Ejemplo2; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }

EJERCICIO 208 CON REFERENCIA AL EJERCICIO 2, COLOCAREMOS UN TÍTULO EN LA VENTANA. package awt.Ejemplo3; import java.awt.*; public class Ventana extends Frame{ public Ventana(){ setTitle("MI PRIMERA VENTANA"); setSize(250,150); show(); } } package awt.Ejemplo3; public class Aplicacion{ public static void main(String arg[]){




new Ventana(); } }

/* PARA AGREGAR TÍTULO A LA VENTANA UTILIZE setTitle(“Hola”); */ EJERCICIO 209 CON REFERENCIA AL EJERCICIO 3 REALIZAR UN PROGRAMA QUE PERMITA AÑADIR UN BOTÓN A LA VENTANA. package awt.Ejemplo4; import java.awt.*; public class Ventana extends Frame{ public Ventana(){ setTitle(" Ventana con un boton"); Button A; A=new Button("Aceptar"); setSize(250,150); show(); } } package awt.Ejemplo4; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } } /* NO APARECE EL BOTÓN PORQUE CUANDO SE CREA UN BOTÓN DEBE AÑADIRSE AL PANEL CON LA OPCIÓN ADD QUE SE VERÁ EN EL EJERCICIO 5 COMPARE LOS EJERCICIOS 4 Y 5 Y VEA LAS DIFERENCIAS. */




EJERCICIO 209 CON REFERENCIA AL EJERCICIO 4, CORRIJA EL ERROR PARA QUE APAREZCA EL BOTÓN. package awt.Ejemplo5; import java.awt.*; public class Ventana extends Frame{ public Ventana(){ setTitle(" Ventana con un boton"); Button A; A=new Button("Aceptar"); add(A); setSize(300,400); show(); } } package awt.Ejemplo5; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }

EJERCICIO 210 HAGA REFERENCIA AL EJERCICIO ANTERIOR, ÉSTA VEZ AÑADA DOS BOTONES AL PANEL.




package awt.Ejemplo6; import java.awt.*; public class Ventana extends Frame{ public Ventana(){ setTitle(" Ventana con un boton"); Button A; A=new Button("Aceptar"); add(A); Button B=new Button("Cancelar"); add(B); setSize(250,150); show(); } } package awt.Ejemplo6; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }

/* NO APARECE EL BOTÓN ACEPTAR PORQUE EL BOTÓN CANCELAR ESTÁ SOBRE EL BOTÓN ACEPTAR, PARA PONER DOS BOTONES EN EL PANEL SE NECESITA DIVIDIR EL PANEL, VEA EL EJERCICIO 7*/ EJERCICIO 211 HAGA REFERENCIA AL EJERCICIO 6 Y AÑADA LOS DOS BOTONES CORRIEGIENDO EL ERROR DEL EJERCICIO 6. COMPARE LAS DIFERENCIAS ENTRE EL EJERCIO ANTERIOR Y ÉSTE. package awt.Ejemplo7; import java.awt.*; public class Ventana extends Frame{ public Ventana(){




setTitle(" Ventana con dos botones"); setLayout(new GridLayout(1,2)); Button A; A=new Button("Aceptar"); add(A); Button B=new Button("Cancelar"); add(B); setSize(250,150); show(); } } package awt.Ejemplo7; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }

/* setLayout(new GridLayout(1,2)); Esta línea crea dos columnas y 1 fila en el panel, esto debe hacerse para añadir más objetos al panel. */ EJERCICIO 213 HAGA REFERENCIA AL EJERCICIO 7, PERO ÉSTA VEZ AÑADA 4 BOTONES AL PANEL. package awt.Ejemplo8; import java.awt.*; public class Ventana extends Frame{ public Ventana(){ setLayout(new GridLayout (2,2)); setSize(250,150); setTitle(" Ventana con cuatro botones"); Button A=new Button("A");




add(A); Button B=new Button("B"); add(B); Button C=new Button("C"); add(C); Button D=new Button("D"); add(D); //setSize(250,150);/*SE PUEDE COLOCAR TAMBIÉN AQUÍ O ARRIBA*/ show(); } } package awt.Ejemplo8; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }

/* ESTA VEZ AGREGAMOS UNA FILA MÁS, ES DECIR HAY DOS FILAS Y DOS COLUMNAS. setLayout(new GridLayout (2,2));*/ EJERCICIO 214 SE NECESITAN CREAR 20 BOTONES PARA ÉSTO UTILIZE LA AYUDA DE UNA ESTRUCTURA DE ITERACIÓN, PONGA MUCHA ATENCIÓN TAMBIÉN SE UTILIZA UN ARREGLO DE BOTONES PARA AGREGARLOS AL PANEL. package awt.Ejemplo9; import java.awt.*; public class Ventana extends Frame{ public Ventana(){ setLayout(new GridLayout (5,4)); setSize(300,400); setTitle(" Ventana con 20 botones"); Button [] A =new Button[20];




for(int i=0;i<=19;i++) { A[i]=new Button("A-"+i); add(A[i]); } show(); } } package awt.Ejemplo9; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }

EJERCICIO 215 REALIZAR UN PROGRAMA QUE MUESTRE UNA ETIQUETA EN UNA VENTANA. package awt.Ejemplo10; import java.awt.*; public class Ventana extends Frame{ public Ventana(){ setLayout(new GridLayout (1,1)); setTitle(" Ventana con una etiqueta"); Label L1=new Label("Etiqueta 1"); add(L1); pack(); show(); } } package awt.Ejemplo10; public class Aplicacion{ public static void main(String arg[]){




new Ventana(); } } /* UTILIZAMOS PACK(); PORQUE ÉSTE SIRVE PARA DARLE UN TAMAÑO A LA VENTANA DE ACUERDO A LOS OBJETOS QUE SE LE COLOQUE, ES DECIR EL TAMAÑO VA AUMENTANDO A MEDIDA QUE AGREGAMOS MÁS OBJETOS A LA VENTANA. POR ESO YA NO SE UTILIZA SETSIZE.*/

EJERCICIO 216 HAGA REFERENCIA AL EJERCICIO 10, PERO ÉSTA VEZ AGREGAMOS UNA ETIQUETA MÁS. package awt.Ejemplo11; import java.awt.*; public class Ventana extends Frame{ public Ventana(){ setLayout(new GridLayout (2,1)); setTitle(" Ventana con dos etiquetas"); Label L1=new Label("Etiqueta 1"); add(L1); Label L2=new Label("Etiqueta 2"); add(L2); pack(); show(); } } package awt.Ejemplo11; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }




EJERCICIO 217 HAGA REFERENCIA AL EJERCICIO 11, PARA ÉSTA VEZ CREAR 25 ETIQUETAS EN LA VENTANA. package awt.Ejemplo12; import java.awt.*; public class Ventana extends Frame{ public Ventana(){ setLayout(new GridLayout (5,5)); setTitle(" Ventana con 25 botones"); Label [] L =new Label[25]; for(int i=0;i<=24;i++) { add(L[i]=new Label("Etiqueta -"+(i+1))); } pack(); show(); } } package awt.Ejemplo12; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }

/* SE UTILIZA UNA ESTRUCTURA DE ITERACIÓN FOR Y UN ARREGLO PARA GENERRAR LAS 25 ETIQUETAS. */ EJERCICIO 218 REALIZAR UN PROGRAMA QUE MUESTRE UNA CAJA DE TEXTO EN LA VENTANA.




package awt.Ejemplo13; import java.awt.*; public class Ventana extends Frame{ public Ventana(){ setLayout(new GridLayout (1,1)); setTitle(" Ventana con caja de texto"); TextField T1=new TextField(); add(T1); pack(); show(); } } package awt.Ejemplo13; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }

EJERCICIO 219 HAGA REFERENCIA AL EJERCICIO 13 PERO ÉSTA VEZ COLOQUE DOS CAJAS DE TEXTO A LA VENTANA. package awt.Ejemplo14; import java.awt.*; public class Ventana extends Frame{ public Ventana(){ setLayout(new GridLayout (2,1)); setTitle(" Ventana con cajas de texto"); TextField T1=new TextField(); add(T1); TextField T2=new TextField(); add(T2); pack(); show(); } }




package awt.Ejemplo14; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }

EJERCICIO 220 TOME COMO REFERENCIA EL EJERCICIO 14, PERO ÉSTA VEZ CREE 25 CAJAS DE TEXTO. package awt.Ejemplo15; import java.awt.*; public class Ventana extends Frame{ public Ventana(){ setLayout(new GridLayout (5,5)); setTitle(" Ventana con caja de texto"); TextField [] T1 =new TextField[25]; for(int i=0;i<=24;i++) add(T1[i]=new TextField("Texto -"+(i+1))); pack(); show(); } } package awt.Ejemplo15; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }




/* SE UTILIZA UNA ESTRUCTURA DE ITERACIÓN FOR Y UN ARREGLO PARA GENERRAR LAS 25 CAJAS DE TEXTOS. */ EJERCICIO 221 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE UNA ETIQUETA DE NOMBRE, UNA CAJA DE TEXTO PARA INGRESAR EL NOMBRE Y UN BOTÓN PARA GUARDAR Y OTRO PARA SALIR. import java.awt.*; public class Ventana extends Frame{ public Ventana(){ setLayout(new GridLayout (2,2)); setTitle(" Registro"); Label L1=new Label("NOMBRE"); add(L1); TextField T1=new TextField(); add(T1); Button B1= new Button ("Guardar"); add(B1); Button B2= new Button ("Salir"); add(B2); pack(); show(); } } public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }

EJERCICIO 222




REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE UNA ETIQUETA DE NOMBRE, APELLIDO, UNA CAJA DE TEXTO PARA INGRESAR EL NOMBRE Y APELLIDO Y DOS BOTONES, UNO PARA GUARDAR Y OTRO PARA SALIR. import java.awt.*; public class Ventana extends Frame{ public Ventana(){ setLayout(new GridLayout (3,2)); setTitle(" Registro"); Label L1=new Label("NOMBRE"); add(L1); TextField T1=new TextField(); add(T1); Label L2=new Label("APELLIDO"); add(L2); TextField T2=new TextField(); add(T2); Button B1= new Button ("Guardar"); add(B1); Button B2= new Button ("Salir"); add(B2); pack(); show(); } } public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }

EJERCICIO 223 REALIZAR UN PROGRAMA QUE MUESTRE POR PANTALLA UN EJEMPLO SENCILLO DE REGISTRO QUE CONTENGA COMO ETIQUETAS EL CODIGO, NOMBRE, DIRECCIÓN Y QUE TENGA 4 BOTONES CONSULTAR, GUARDAR, ELIMINAR Y SALIR.




import java.awt.*; public class Ventana extends Frame{ public Ventana(){ setLayout(new GridLayout (5,2)); setTitle(" Registro"); Label L1=new Label("CODIGO"); add(L1); TextField T1=new TextField(); add(T1); Label L2=new Label("NOMBRES"); add(L2); TextField T2=new TextField(); add(T2); Label L3=new Label("DIRECCION"); add(L3); TextField T3=new TextField(); add(T3); Button B1= new Button ("Consultar"); add(B1); Button B2= new Button ("Eliminar"); add(B2); Button B3= new Button ("Guardar"); add(B3); Button B4= new Button ("Salir"); add(B4); pack(); show(); } } public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }




VARIOS PANELES EN UNA VENTANA EJERCICIO 224 REALIZAR UN PROGRAMA EN JAVA PARA MOSTRAR LA INTERFAZ DEL JUEGO DE TRES EN RAYA, COLOQUE TAMBIÉN DOS BOTONES PARA JUGAR Y SALIR. package Estandarizacion.Ejemplo1; import java.awt.*; public class Ventana extends Frame{ Panel P1,P2; Button[] B=new Button[11]; public Ventana(){ setTitle(" JUEGO EN TRES EN RAYA "); setLayout(new GridLayout(2,1)); P1=new Panel(); P2=new Panel(); P1.setLayout(new GridLayout(3,3)); P2.setLayout(new GridLayout(1,2)); for(int i=0;i<=8;i++) P1.add(B[i]=new Button()); P2.add(B[9]=new Button ("JUGAR")); P2.add(B[10]=new Button("SALIR")); add(P1); add(P2); setSize(250,150); show(); } } package Estandarizacion.Ejemplo1; public class Aplicacion{




public static void main(String arg[]){ new Ventana(); } }

/* SE PUEDEN COLOCAR DOS PANELES EN UNA VENTANA, EN EL EJERCICIO 19, UN PANEL LO UTILIZAMOS PARA COLOCAR LOS BOTONES DE TRES EN RAYA Y EL OTRO PANEL LO UTILIZAMOS PARA COLOCAR LOS BOTONES DE JUGAR Y SALIR. */ EJERCICIO 225 REALIZAR UN PROGRAMA EN JAVA QUE PRESENTE LA SIGUIENTE INTERFAZ.

package Estandarizacion.Ejemplo2; import java.awt.*; public class Ventana extends Frame{ Panel P1,P2,P3,P4; Button O1,O2,O3,O4,N1,N2,N3,N4,S1,S2,S3,S4; List L; Label L1,L2,L3,meta,acumulado; public Ventana(){ setTitle(" JUEGO DE CIFRAS ");




setLayout(new GridLayout(4,1)); P1=new Panel(); P2=new Panel(); P3=new Panel(); P4=new Panel(); P1.setLayout(new GridLayout(2,4)); P2.setLayout(new GridLayout(2,2)); P3.setLayout(new GridLayout(1,2)); P4.setLayout(new GridLayout(2,2)); P1.add(O1=new Button("+")); P1.add(O2=new Button("-")); P1.add(O3=new Button("x")); P1.add(O4=new Button("/")); P1.add(N1=new Button()); P1.add(N2=new Button()); P1.add(N3=new Button()); P1.add(N4=new Button()); P2.add(L1=new Label ("NUMERO")); P2.add(meta=new Label()); P2.add(L2=new Label ("APROXIMADO")); P2.add(acumulado=new Label()); P3.add(L3=new Label ("POSICIONES")); P3.add(L=new List()); P4.add(S1=new Button ("REESTABLECER")); P4.add(S2=new Button("NUEVO JUEGO")); P4.add(S3=new Button ("MEJOR")); P4.add(S4=new Button("SALIR")); add(P1); add(P2); add(P3); add(P4); setSize(250,200); show(); } } package Estandarizacion.Ejemplo2; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }




EJERCICIO 226 REALIZAR UN PROGRAMA EN JAVA QUE PRESENTE LA SIGUIENTE INTERFAZ.

package Estandarizacion.Ejemplo3; import java.awt.*; public class Ventana extends Frame{ Panel P1,P2,P3; Button O1,O2,O3,O4,O5,O6; Label L1,L2,L3,L4,L5,L6; public Ventana(){ setTitle(" DEBER "); setLayout(new GridLayout(3,2)); P1=new Panel(); P2=new Panel(); P3=new Panel();




P1.setLayout(new GridLayout(1,3)); P2.setLayout(new GridLayout(3,2)); P3.setLayout(new GridLayout(1,3)); P1.add(O1=new Button()); P1.add(O2=new Button()); P1.add(O3=new Button()); P2.add(L1=new Label ("ACIERTOS")); P2.add(L2=new Label()); P2.add(L3=new Label ("FRACASOS")); P2.add(L4=new Label()); P2.add(L5=new Label ("TOTAL")); P2.add(L5=new Label()); P3.add(O4=new Button("JUGAR")); P3.add(O5=new Button("BORRAR")); P3.add(O6=new Button("SALIR")); add(P1); add(P2); add(P3); setSize(250,250); show(); } } package Estandarizacion.Ejemplo3; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } } EJERCICIO 227 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE LA SIGUIENTE INTERFAZ.




package Estandarizacion.Ejemplo4; import java.awt.*; public class Ventana extends Frame{ Panel P1,P2,P3; TextField O1,O2,O3; Label L1,L2,L3; Button O4,O5; public Ventana(){ setTitle(" DEBER "); setLayout(new GridLayout(3,2)); P1=new Panel(); P2=new Panel(); P3=new Panel(); P1.setLayout(new GridLayout(1,3)); P2.setLayout(new GridLayout(1,3)); P3.setLayout(new GridLayout(1,2)); P1.add(O1=new TextField()); P1.add(O2=new TextField()); P1.add(O3=new TextField()); P2.add(L1=new Label ()); P2.add(L2=new Label()); P2.add(L3=new Label ()); P3.add(O4=new Button("A-Z")); P3.add(O5=new Button("Z-A")); add(P1); add(P2); add(P3);




setSize(250,150); show(); } } package Estandarizacion.Ejemplo4; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } } EJERCICIO 228 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE LA SIGUIENTE INTERFAZ.

package Estandarizacion.Ejemplo5; import java.awt.*; public class Ventana extends Frame{ Panel P1,P2,P3,P4; Label L1,L2,L3,L4,L5,L6,L7,L8,L9,L10,L11,L12,L13,L14,L15; Button O4,O5,O6,O7; public Ventana(){ setTitle("Juego del 21"); setLayout(new GridLayout(4,2)); P1=new Panel(); P2=new Panel(); P3=new Panel(); P4=new Panel(); P1.setLayout(new GridLayout(1,2)); P2.setLayout(new GridLayout(3,2)); P3.setLayout(new GridLayout(2,4));




P4.setLayout(new GridLayout(1,2)); P1.add(O4=new Button("Pedir Carta")); P1.add(O5=new Button("Parar")); P2.add(L1=new Label ("Carta")); P2.add(L2=new Label()); P2.add(L3=new Label ("Acumulado")); P2.add(L4=new Label()); P2.add(L6=new Label("Datos del jugador 1")); P2.add(L7=new Label("Datos del jugador 2")); P3.add(L8=new Label ("Partidas Ganadas")); P3.add(L9=new Label()); P3.add(L10=new Label ("Partidas Ganadas")); P3.add(L11=new Label()); P3.add(L12=new Label ("Partidas Perdidas")); P3.add(L13=new Label()); P3.add(L14=new Label ("Partidas Perdidas")); P3.add(L15=new Label()); P4.add(O6=new Button("Nuevo Juego")); P4.add(O7=new Button("Salir")); add(P1); add(P2); add(P3); add(P4); setSize(500,200); show(); } } package Estandarizacion.Ejemplo5; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }




COLOCANDO OBJETOS CON BORDERLAYOUT EJERCICIO 229 COLOCAR BOTONES ARRIBA, ABAJO, A LA DERECHA, IZQUIERDA Y EN EL CENTRO DE LA VENTANA. package Estandarizacion.Ejemplo6; import java.awt.*; public class Ventana extends Frame{ Button B1,B2,B3,B4,B5; public Ventana(){ setTitle(" DEBER "); setLayout(new BorderLayout()); add(B1=new Button("Al NORTE"),BorderLayout.NORTH); add(B2=new Button("Al SUR"),BorderLayout.SOUTH); add(B3=new Button("Al CENTRO"),BorderLayout.CENTER); add(B4=new Button("Al ESTE"),BorderLayout.EAST); add(B5=new Button("Al OESTE"),BorderLayout.WEST); setSize(200,200); show(); } } package Estandarizacion.Ejemplo6; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }




/* setLayout(new BorderLayout()); add(B1=new Button("Al NORTE"),BorderLayout.NORTH); Éstas dos líneas permiten agregar en éste caso un botón al norte del panel, esto es importante ya que podemos colocar objetos en un lugar específico dentro del panel. */ EJERCICIO 230 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE LA SGUIENTE INTERFAZ. package Estandarizacion.Ejemplo7; import java.awt.*; public class Ventana extends Frame{ Panel P1,P2,P3; TextField T1,T2; Choice C1; Label L1,L2,L3; Button O4,O5,O6,O7,O8,O9,O10,O11,O12; public Ventana(){ setTitle("Juego del 21"); setLayout(new BorderLayout()); add(P1=new Panel(), BorderLayout.NORTH); add(P2=new Panel(), BorderLayout.CENTER); add(P3=new Panel(), BorderLayout.SOUTH); P1.add(O4=new Button("Jugador1")); P1.add(O6=new Button("Jugador2")); P1.add(O5=new Button("Jugador3")); P1.add(O7=new Button("Jugador4")); P1.add(O8=new Button("Jugador5")); P2.add(L1=new Label ("Nombre")); P2.add(T1=new TextField());




P2.add(L2=new Label ("Ciudad")); P2.add(C1=new Choice()); P2.add(L3=new Label("Telefono")); P2.add(T2=new TextField()); P3.add(O9=new Button("Nuevo")); P3.add(O10=new Button ("Cancelar")); P3.add(O11=new Button("Salir")); C1.add("Guayaquil"); C1.add("Quito"); C1.add("Cuenca"); P1.setLayout(new GridLayout(1,5)); P2.setLayout(new GridLayout(3,2)); P3.setLayout(new GridLayout(1,3)); pack(); show(); } } package Estandarizacion.Ejemplo7; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }




EVENTOS EN JAVA EJERCICIO 231 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA MOSTRAR UN MENSAJE SI PRESIONO UN BOTÓN, EN ESTE CASO SE LLAMARÁ EL BOTÓN SALUDO.

package Eventos.Ejemplo1; import java.awt.*; public class Ventana extends Frame{ Mostrar m=new Mostrar(); public Ventana(){ setTitle(" Ventana con un Botón "); Button B=new Button("Saludo"); add(B); pack(); show(); } public boolean action(Event evt, Object ar){ if(evt.target instanceof Button){ m.mensaje(" Hola Mundo "); return true; } return false; } }




package Eventos.Ejemplo1; public class Mostrar{ public void mensaje(String m){ javax.swing.JOptionPane.showMessageDialog(null ,m); } } package Eventos.Ejemplo1; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } } /* ÉSTE EJEMPLO TIENE TRE CLASES: * VENTANA * MOSTRAR * APLICACIÓN */ /*LOS EVENTOS SON LOS PROCESOS O LOS RESULTADOS QUE SE VAN A PRESENTAR O REALIZAR CUANDO PRESIONAMOS O DAMOS CLIC SOBRE UN BOTÓN. */ /*PRIMERO SE EJECUTA MOSTRAR, LUEGO VENTANA Y AL FINAL LA CLASE APLICACIÓN QUE ES LA CLASE QUE TIENE EL MÉTODO MAIN*/

EJERCICIO 232 REALIZAR EL MISMO PROGRAMA DEL EJERCICIO 27 PERO EN UNA SÓLA CLASE. package Eventos.Ejemplo1; import java.awt.*;




public class Ventana extends Frame{ Mostrar m=new Mostrar(); public Ventana(){ setTitle(" Ventana con un Botón "); Button B=new Button("Saludo"); add(B); pack(); show(); } public boolean action(Event evt, Object ar){ if(evt.target instanceof Button){ m.mensaje(" Hola Mundo "); return true; } return false; } public class Mostrar{ public void mensaje(String m){ javax.swing.JOptionPane.showMessageDialog(null ,m); } } public static void main(String arg[]){ new Ventana(); } }

EJERCICIO 233 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA MOSTRAR UN MENSAJE SI PRESIONO UN BOTÓN, EN ESTE CASO SE AGREGARÁN DOS BOTONES Y MOSTRARÁN LOS DOS BOTONES EL MISMO MENSAJE AL SER PRESIONADOS. package Eventos.Ejemplo2;




import java.awt.*; public class Ventana extends Frame{ Mostrar m=new Mostrar(); public Ventana(){ setLayout(new GridLayout(1,2)); Button A=new Button("Salir"); add(A); Button B=new Button("Saludo"); add(B); pack(); show(); } public boolean action(Event evt, Object ar){ if(evt.target instanceof Button){ m.mensaje(" Hola Mundo "); return true; } return false; } } package Eventos.Ejemplo2; public class Mostrar{ public void mensaje(String m){ javax.swing.JOptionPane.showMessageDialog(null ,m); } } package Eventos.Ejemplo2; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }




EJERCICIO 234 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA MOSTRAR UN MENSAJE SI PRESIONO UN BOTÓN, EN ESTE CASO SE AGREGARÁN DOS BOTONES Y MOSTRARÁN LOS DOS BOTONES COMO MENSAJE EL MISMO NOMBRE QUE TIENEN LOS BOTONES. EJEMPLO SI EL BOTÓN SE LLAMA SALIR EL MENSAJE DEBERÁ DECIR SALIR. package Eventos.Ejemplo3; import java.awt.*; public class Ventana extends Frame{ Mostrar m=new Mostrar(); public Ventana(){ setLayout(new GridLayout(1,2)); Button A=new Button("Salir"); add(A); Button B=new Button("Saludo"); add(B); pack(); show(); } public boolean action(Event evt, Object ar){ if(evt.target instanceof Button){ m.mensaje(ar.toString()); return true; } return false; } } package Eventos.Ejemplo3; public class Mostrar{ public void mensaje(String m){ javax.swing.JOptionPane.showMessageDialog(null ,m); } }




package Eventos.Ejemplo3; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }

EJERCICIO 235 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE UN MENSAJE SÓLO SI PRESIONO EL BOTÓN SALUDO, SI PRESIONO EL BOTÓN SALIR SALDRÁ DE LA VENTANA. package Eventos.Ejemplo4; import java.awt.*; public class Ventana extends Frame{ Mostrar m=new Mostrar(); public Ventana(){ setLayout(new GridLayout(1,2)); Button A=new Button("Salir"); add(A); Button B=new Button("Saludo"); add(B);




pack(); show(); } public boolean action(Event evt, Object ar){ if(evt.target instanceof Button){ if(ar.toString().equals("Salir")) System.exit(0); if(ar.toString().equals("Saludo")) m.mensaje(" Hola Mundo"); return true; } return false; } } package Eventos.Ejemplo4; public class Mostrar{ public void mensaje(String m){ javax.swing.JOptionPane.showMessageDialog(null ,m); } } package Eventos.Ejemplo4; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }

EJERCICIO 236 REALIZAR EL MISMO PROGRAMA DEL EJERCICIO 30, NOTE LAS DIFERENCIAS. EN ÉSTE EJERCICIO UTILIZAREMOS EL EVT.TARGET PARA COMPARAR EL EVENTO DE CADA BOTÓN. package Eventos.Ejemplo5; import java.awt.*;




public class Ventana extends Frame{ Mostrar m=new Mostrar(); Button A,B; public Ventana(){ setLayout(new GridLayout(1,2)); A=new Button("Salir"); add(A); B=new Button("Saludo"); add(B); pack(); show(); } public boolean action(Event evt, Object ar){ if(evt.target instanceof Button){ if(evt.target==A) System.exit(0); if(evt.target==B) m.mensaje(" Hola Mundo"); return true; } return false; } } package Eventos.Ejemplo5; public class Mostrar{ public void mensaje(String m){ javax.swing.JOptionPane.showMessageDialog(null ,m); } } package Eventos.Ejemplo5; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } } /* if(evt.target==A)/* A ES EL BOTÓN SALIR*/ System.exit(0);/* PARA SALIR DE LA VENTANA*/




if(evt.target==B)/* B ES EL BOTÓN SALUDO*/ m.mensaje(" Hola Mundo");*/PARA MOSTRAR EL MENSAJE*/ */

EJERCICIO 237 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA COPIAR TEXTO DE UN CUADRO DE TEXTO A OTRO. package Eventos.Ejemplo6; import java.awt.*; public class Ventana extends Frame{ Mostrar m=new Mostrar(); Button A,B; TextField t,t1; public Ventana(){ setLayout(new GridLayout(2,2)); t=new TextField(); add(t); t1=new TextField(); add(t1); A=new Button("Pasar el contenido de t a t1"); add(A); B=new Button("Mostrar el contenido de t1"); add(B); pack(); show(); } public boolean action(Event evt, Object ar){ if(evt.target instanceof Button){ if(evt.target==A){ String texto=t.getText(); t1.setText(texto); } if(evt.target==B) m.mensaje(t1.getText()); return true; } return false;




} } package Eventos.Ejemplo6; public class Mostrar{ public void mensaje(String m){ javax.swing.JOptionPane.showMessageDialog(null ,m); } } package Eventos.Ejemplo6; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } }

/* String texto=t.getText(); Esta línea permite capturer el texto t1.setText(texto);




Esta línea asigna el texto al otro cuadro de texto. */ /* setText .- ASIGNA TEXTO getText .- CAPTURA TEXTO */ EJERCICIO 238 REALIZAR EL SIGUIENTE PROGRAMA EN JAVA: LOS BOTONES SON: +,-,*,/,DIV,%,RAIZ(X), ALEATORIO ENTRE X y Y Y SALIR.

package Eventos.Ejemplo7; import java.awt.*; public class Ventana extends Frame{ Label label1,label2,label3,lblResultado; TextField txtX,txtY; Button btnSuma,btnResta,btnMultiplicacion,btnDivision,btnDiv; Button btnMod,btnXY,btnAleatorio,btnAleatorioX,btnAleatorioXY; Button btnSalir,btnRaizX; Panel p1,p2; public Ventana(){ setTitle("PRIMEROS EVENTOS"); setLayout(new GridLayout(2,1)); add(p1= new Panel()); add(p2= new Panel()); p1.setLayout(new GridLayout(3,2)); p2.setLayout(new GridLayout(3,4)); p1.add(label1=new Label("X")); p1.add(this.txtX= new TextField()); p1.add(this.label2= new Label("Y")); p1.add(this.txtY= new TextField()); p1.add(this.label3= new Label("Resultado")); p1.add(this.lblResultado= new Label()); p2.add(this.btnSuma= new Button("+")); p2.add(this.btnResta= new Button("-"));




p2.add(this.btnMultiplicacion= new Button("X")); p2.add(this.btnDivision = new Button("/")); p2.add(this.btnDiv= new Button("DIV")); p2.add(this.btnMod= new Button("%")); p2.add(this.btnRaizX= new Button("Raiz(x)")); p2.add(this.btnXY= new Button("X^Y")); p2.add(this.btnAleatorio= new Button("ALEATORIO")); p2.add(this.btnAleatorioX= new Button("ALEATORIO X")); p2.add(this.btnAleatorioXY= new Button("ALEATORIO ENTRE X y Y")); p2.add(this.btnSalir= new Button("SALIR")); pack(); show(); } public boolean action(Event evt, Object ar){ if(evt.target instanceof Button){ double x= Double.parseDouble(this.txtX.getText()); double y= Double.parseDouble(this.txtY.getText()); double r= 0; if(evt.target==this.btnSuma) r=x+y; if(evt.target==this.btnResta) r=x-y; if(evt.target==this.btnMultiplicacion) r=x*y; if(evt.target==this.btnDivision) r=x/y; if(evt.target==this.btnSalir) System.exit(0); if(evt.target==this.btnAleatorio) r=Math.random(); if(evt.target==this.btnRaizX) r=Math.sqrt(x); if(evt.target==this.btnXY) r=Math.pow(x,y); if(evt.target==this.btnAleatorioX) r=(int)((Math.random()*x)+1);




if(evt.target==this.btnAleatorioXY) {if(x<y) r=(int)((Math.random()*(y-x)+1)+x); else r=(int)((Math.random()*(x-y)+1)+y); } if(evt.target==this.btnDiv) r=(int)(x/y); if(evt.target==this.btnMod) r=(int)(x%y); this.lblResultado.setText(String.valueOf(r)); return true; } return false; } } package Eventos.Ejemplo7; public class Aplicacion{ public static void main(String arg[]){ new Ventana(); } } /*EJEMPLO CON EL BOTÓN +*/

EJERCICIO 239 Escriba una clase en java que cumpla con los siguientes requisitos: Nombre de la clase:




Pull Atributos: Nombre del jugador Puntos Acumulados Método Constructor Que reciba el atributo Nombre Método Juega p.juega(puntos); // puntos es un entero desde 6 hasta 15 y debe generarse aleatoriamente q.juega(puntos); el método juega debe aumentar los puntos a cada objeto cada vez que se lo llame. Métodos Imprimir Debe imprimir el nombre del objeto que posea el mayos puntaje. Todos los valores son ingresados por teclado. package Prog.EjerciciosNormales.Ejercicio_5; import java.awt.*; public class Llamadas extends Frame{ Pull p,q; Button b,b1; int ppuntos,qpuntos; public Llamadas() { setLayout(new GridLayout(1,2)); add(b=new Button("LLamar")); add(b1=new Button("Salir")); show(); pack(); } public static void main(String arg[]){ new Llamadas(); } void jugar(){ p=new Pull("Mariana A."); ppuntos += p.puntos; q=new Pull("Maria C."); qpuntos += q.puntos; if(ppuntos==qpuntos) System.out.println("Sus puntajes son iguales p="+ppuntos+" y q="+qpuntos); else{ if(ppuntos>qpuntos)




System.out.println("P="+ppuntos+" Q="+qpuntos+" Objeto Mayor p="+ppuntos); else System.out.println("P="+ppuntos+" Q="+qpuntos+" Objeto Mayor q="+qpuntos); } } public boolean action(Event evt,Object ar){ if(evt.target instanceof Button){ if(evt.target==b) {jugar();} if(evt.target==b1){dispose(); System.exit(0);} return true; } else return false; } } package Prog.EjerciciosNormales.Ejercicio_5; public class Pull { public int puntos=0; public Pull(){} public Pull(String nombre) { puntos=aleatorio(); } int aleatorio(){ int c=0; while(c<6) c=(int)(Math.random()*15); return c; } }

EJERCICIO 240 Escriba un programa en Java que simule el Juego siguiente:

Bi U

M




Interfase Cuando se presiona cualquiera de los botones Bi, En el Label U aparece el texto del Botón presionado Se genera de forma aleatoria en el Label M la palabra roca, papel o tijera Se realiza una comparación entre los dos Jugadores y se los asignan en los Label correspondiente al ganador o si existe empates. El botón salir, sale del juego Eñ Botón nuevo juego restablece todo para inicializar el juego package Ej1; import java.awt.*; public class PiedraPapelTijera extends Frame{ String v1="",v2=""; int cont1=0,cont2=0,emp=0; Button bpiedra,bpapel,btijera,bn,bs; Panel p1,p2,p3,p21,p22; Label l1,l2,l3,l4,l5,l6; public PiedraPapelTijera() { setLayout(new BorderLayout()); p1=new Panel(); p1.setLayout(new GridLayout(1,3)); p1.add(bpiedra=new Button("piedra")); p1.add(bpapel=new Button("papel")); p1.add(btijera=new Button("tijera")); add("North",p1); p2=new Panel();




p2.setLayout(new BorderLayout()); p21=new Panel(); p21.setLayout(new GridLayout(2,1)); p21.add(l1=new Label("Usuario: "+v1)); p21.add(l2=new Label("Máquina: "+v2)); p22=new Panel(); p22.setLayout(new GridLayout(3,1)); p22.add(l4=new Label("Usuario: "+cont1)); p22.add(l5=new Label("Máquina: "+cont2)); p22.add(l6=new Label("Empates: "+emp)); p2.add("North",p21); p2.add("Center",l3=new Label("-----------Resultados-----------")); p2.add("South",p22); add("Center",p2); p3=new Panel(); p3.setLayout(new GridLayout(1,2)); p3.add(bn=new Button("Nuevo")); p3.add(bs=new Button("Salir")); add("South",p3); setSize(150,200); show(); } public boolean action(Event evt,Object ar){ if(evt.target instanceof Button){ if(evt.target==bs){dispose(); System.exit(0);} if(evt.target==bn){ cont1=0; emp=0; cont2=0; v1=""; v2=""; l1.setText("Usuario: "+v1); l2.setText("Máquina: "+v2); l4.setText("Usuario: "+cont1); l5.setText("Máquina: "+cont2); l6.setText("Empates: "+emp); } if(evt.target==bpiedra || evt.target==bpapel || evt.target==btijera){ v1=ar.toString(); l1.setText("Usuario: "+v1); jugar(); } return true;




} else return false; } void jugar(){ int c=0; while(c==0){ c=(int)(Math.random()*3); } switch(c){ case 1:v2="piedra";break; case 2:v2="papel";break; case 3:v2="tijera";break; } l2.setText("Máquina: "+v2); if(v1.equals(v2)) emp++; else{ if(v1.equals("piedra") && v2.equals("tijera")) cont1++; else{ if(v1.equals("tijera")&&v2.equals("papel")) cont1++; else{ if(v1.equals("papel") && v2.equals("piedra")) cont1++; else cont2++; } } } l4.setText("Usuario: "+cont1); l5.setText("Máquina: "+cont2); l6.setText("Empates: "+emp); } public static void main(String arg[]){ new PiedraPapelTijera().setLocation(400,300); } }




EJERCICIO 243 Escriba una clase en java que realice el siguiente juego: Juego de tres en raya Metodología: El boton Nuevo habilta todos los 9 botones y borra el contenido de sus etiquetas Al presionar cualquier boton de los 9 para jugar, y si es pro primera vez, aparece una “X” es su etiqueta y se deshabilta el botón. Si se presiona un segundo botón, aparece un “0” y se deshabilita el botón. Si se presiona otro botón “X”, así susesivamente hasta que uno de los dos signos hagan tres en raya.

package Ej11; import java.awt.*; public class TresEnRaya extends javax.swing.JFrame{ Button B[]=new Button[9]; int K[]=new int[9]; Button b1,b2; Panel p1,p2; int vez=0; int cont=0; public TresEnRaya() { getContentPane().setLayout(new BorderLayout()); p1=new Panel(); p1.setLayout(new GridLayout(3,3)); for(int i=0;i<9;i++){ p1.add(B[i]=new Button()); } p2=new Panel(); p2.setLayout(new GridLayout(2,1)); p2.add(b1=new Button("Nuevo Juego")); p2.add(b2=new Button("Salir")); getContentPane().add("North",p1); getContentPane().add("South",p2); pack(); show();

Nuevo




} public static void main(String arg[]){ new TresEnRaya().setLocation(400,300); } public boolean action(Event evt,Object ar){ if(evt.target instanceof Button){ if(evt.target==b2){dispose(); System.exit(0);} if(evt.target==b1){ for(int i=0;i<9;i++){ B[i].setLabel(""); B[i].enable(); } vez=0; } for(int i=0;i<9;i++){ if(evt.target==B[i]){ if(B[i].getLabel().equals("")){ if(vez==0){ B[i].setLabel("X"); K[i]=1; vez=1; B[i].disable(); } else{ if(vez==1){ B[i].setLabel("0"); K[i]=0; vez=0; B[i].disable();} } } b1.requestFocus(); cont++; } } if(cont>=5){ ganador("X"); ganador("0"); } return true; }




else return false; } void ganador(String ic){ boolean ok=false; if(B[0].getLabel().equals(ic) && B[1].getLabel().equals(ic) && B[2].getLabel().equals(ic)){ ok=true; } if(B[0].getLabel().equals(ic) && B[4].getLabel().equals(ic) && B[8].getLabel().equals(ic)){ ok=true; } if(B[0].getLabel().equals(ic) && B[3].getLabel().equals(ic) && B[6].getLabel().equals(ic)){ ok=true; } if(B[3].getLabel().equals(ic) && B[4].getLabel().equals(ic) && B[5].getLabel().equals(ic)){ ok=true; } if(B[1].getLabel().equals(ic) && B[4].getLabel().equals(ic) && B[7].getLabel().equals(ic)){ ok=true; } if(B[6].getLabel().equals(ic) && B[7].getLabel().equals(ic) && B[8].getLabel().equals(ic)){ ok=true; } if(B[2].getLabel().equals(ic) && B[5].getLabel().equals(ic) && B[8].getLabel().equals(ic)){ ok=true; } if(ok){ for(int i=0;i<9;i++){ B[i].disable(); } javax.swing.JOptionPane.showMessageDialog(null,"Ganó "+ic); } }




} EJERCICIO 244 Escriba una clase en java que realice el siguiente juego: Juego del Siete afortunado Metodología: El Salir, sale del sistema El botón restablecer borra el contenido de las etiquetas L1, L2, L3, L4 y L5. El botón jugar genera tres números aleatorios que se muestran en los los Label L1, L2 y L3. Si alguno de estos números es siete, se suma a los aciertos que se encapsula en L4, y si ninguno de los números es siete, se suma en L5. package Ej7; import java.awt.*; public class Juego7 extends javax.swing.JFrame{ Button b1,b2,b3,b4,b5,b6,b7; Label L1,L2,L3; Panel p1,p2,p3; int ac=0,fra=0; public Juego7() { getContentPane().setLayout(new BorderLayout()); p1=new Panel(); p1.setLayout(new GridLayout(1,3)); p1.add(L1=new Label("")); p1.add(L2=new Label("")); p1.add(L3=new Label("")); p2=new Panel();

JUGAR

RESTABLECER

SALIR

FRACASOS

ACIERTOS

L1 L2 L3

L4

L5




p2.setLayout(new GridLayout(2,2)); b4=new Button("Aciertos"); b4.setBackground(new java.awt.Color(51, 51, 51)); b4.setForeground(new java.awt.Color(255, 255, 255));//BLANCO COLOR AL TEXTO p2.add(b4); p2.add(b5=new Button("")); b6=new Button("Fracasos"); b6.setBackground(new java.awt.Color(51, 51, 51)); b6.setForeground(new java.awt.Color(255, 255, 255)); p2.add(b6); p2.add(b7=new Button("")); b4.disable(); b5.disable(); b6.disable(); b7.disable(); p3=new Panel(); p3.setLayout(new GridLayout(3,1)); p3.add(b1=new Button("JUGAR")); p3.add(b2=new Button("RESTABLECER")); p3.add(b3=new Button("SALIR")); getContentPane().add("North",p1); getContentPane().add("Center",p2); getContentPane().add("South",p3); pack(); show(); } public static void main(String arg[]){ new Juego7().setLocation(400,300); } void jugar(){ L1.setText(String.valueOf(aleatorio())); L2.setText(String.valueOf(aleatorio())); L3.setText(String.valueOf(aleatorio())); if(L1.getText().equals("7") || L2.getText().equals("7") || L3.getText().equals("7")) ac++; else fra++; b5.setLabel(String.valueOf(ac)); b7.setLabel(String.valueOf(fra)); }




void reestablecer(){ ac=0; fra=0; L1.setText(""); L2.setText(""); L3.setText(""); b5.setLabel(""); b7.setLabel(""); } public boolean action(Event evt,Object ar){ if(evt.target instanceof Button){ if(evt.target==b1) jugar(); if(evt.target==b2) reestablecer(); if(evt.target==b3){dispose(); System.exit(0);} return true; } else return false; } int aleatorio(){ int c=(int)(Math.random()*8); return c; } } EJERCICIO 245 Escriba un Programa que simule el juego de Traga-Monedas.

Interfaz Cuando presiona el botón jugar se presentan en forma aleatoria en cada Botón B1, B2 y B3 las letras X, Y o Z La letra Z tiene que tener 6/10 posibilidad de salir La letra Y tiene que tener 3/10 posibilidad de salir La letra X tiene que tener 1/10 posibilidad de salir

Boton B1, B2, B3




En el Label Mensaje debe presentarse la cantidad ganada considerando las ganancias descritas en el Frame package Ej15; import java.awt.*; public class Ejercicio15 extends Frame{ Button b[]=new Button[3]; Button b4,b5; Label l1,l2,l3,l4,l5,l7; javax.swing.JLabel l6; Panel p1,p2; String s[]=new String[10]; public Ejercicio15() { setLayout(new BorderLayout()); p1=new Panel(); p1.setLayout(new GridLayout(6,1)); p1.add(l7=new Label(" Ganancias")); p1.add(l1=new Label(" 3 - X 1000")); p1.add(l2=new Label(" 3 - Y 500")); p1.add(l3=new Label(" 3 - Z 250")); p1.add(l4=new Label(" 2 - X 100")); p1.add(l5=new Label(" 2 - Y 50")); add("North",p1); Panel p11=new Panel(); p11.setLayout(new GridLayout(1,3)); for(int i=0;i<3;i++) p11.add(b[i]=new Button("")); Panel p12=new Panel(); p12.setLayout(new GridLayout(1,2)); p12.add(b4=new Button("Jugar")); p12.add(b5=new Button("Salir")); p2=new Panel(); p2.setLayout(new GridLayout(3,1)); p2.add(p11); p2.add(p12); p2.add(l6=new javax.swing.JLabel("Mensaje")); l6.setHorizontalAlignment(javax.swing.SwingConstants.CENTER); add("South",p2); setTitle("Traga-Monedas"); pack(); show(); }




String letras(int n){ s[0]="Y"; s[1]="Z"; s[2]="Y"; s[3]="Y"; s[4]="Z"; s[5]="Z"; s[6]="Z"; s[7]="X"; s[8]="Z"; s[9]="Z"; return s[n]; } void jugar(){ int c=0,contx=0,conty=0,contz=0; l6.setText(""); for(int i=0;i<3;i++){ c=(int)(Math.random()*9); b[i].setLabel(letras(c)); } for(int i=0;i<3;i++){ if(b[i].getLabel().equals("X")) contx++; if(b[i].getLabel().equals("Y")) conty++; if(b[i].getLabel().equals("Z")) contz++; } if(contx==3) l6.setText("1000"); if(conty==3) l6.setText("500"); if(contz==3) l6.setText("250"); if(contx==2) l6.setText("100"); if(conty==2) l6.setText("50"); } public static void main(String arg[]){ new Ejercicio15().setLocation(400,300); } public boolean action(Event evt,Object ar){ if(evt.target instanceof Button){ if(evt.target==b4)jugar(); if(evt.target==b5){dispose(); System.exit(0);} return true; } else return false; } } EJERCICIO 246




Construir una clase en java que posea lo siguiente: Nombre de la Clase Estudiante Atributos: Nombres Apellidos Materia Nota1 Nota2 Promedio Métodos: 2 métodos constructores aplicando sobrecarga ( no se debe ingresar notas en los métodos) 1 método que imprima los atributos del objeto 1 método que asigne la nota, en cada nota correspondiente (se debe realizar el cálculo del promedio) 1 método que se rectifique la nota por otra x El método main donde se creen 3 objetos de tipo Estudiante y se apliquen los métodos creados package Ej19; import java.awt.*; public class Ejercicio19 extends javax.swing.JFrame{ Button b1,b2,b3; Panel p1,pp; javax.swing.JPanel PR; Label l1,l11,l2,l3,l4,l5; TextField t1,t2,t3,t4; double nota1,nota2; double prom; String nomb,mater; public Ejercicio19(String nombre) { init(); l11.setText(nombre); nomb=nombre; pack(); show(); } void panelrectificador(){ try{




String x=javax.swing.JOptionPane.showInputDialog(null,"Nota 1="+nota1+" por "); if(!x.equals("")) nota1=Double.parseDouble(x); String y=javax.swing.JOptionPane.showInputDialog(null,"Nota 1="+nota2+" por "); if(!y.equals("")) nota2=Double.parseDouble(y); prom=(nota1+nota2)/2; this.t1.setText(String.valueOf(nota1)); this.t2.setText(String.valueOf(nota2)); this.t3.setText(String.valueOf(prom)); } catch(Throwable e){ javax.swing.JOptionPane.showMessageDialog(null,"Ingrese solo numeros"); } } public Ejercicio19(String nombre,String Materia) { init(); l11.setText(nombre); t4.setText(Materia); nomb=nombre; mater=Materia; pack(); show(); } void init(){ p1=new Panel(); p1.setLayout(new GridLayout(6,2)); p1.add(l1=new Label("Nombre")); p1.add(l11=new Label("")); p1.add(l2=new Label("Materia")); p1.add(t4=new TextField()); p1.add(l3=new Label("Nota 1")); p1.add(t1=new TextField()); p1.add(l4=new Label("Nota 2")); p1.add(t2=new TextField()); p1.add(l5=new Label("Promedio Total")); p1.add(t3=new TextField()); p1.add(b1=new Button("Rectificar")); p1.add(b2=new Button("Imprimir")); pp=new Panel(); pp.setLayout(new BorderLayout()); pp.add("Center",p1); pp.add("South",b3=new Button("Salir")); getContentPane().add(pp);




show(); } void imprimir(){ System.out.println(":::::::::::::::::::::::::::::::::::::::"); System.out.println("---------------------------------------"); System.out.println("Nombre : "+nomb); System.out.println("Materia: "+mater); System.out.println("Nota 1 : "+nota1); System.out.println("Nota 2 : "+nota2); System.out.println("Promedio: "+prom); } public static void main(String arg[]){ new Ejercicio19("Mariana").setLocation(400,300);

new Ejercicio19("Mariana","Programacion II").setLocation(400,300); new Ejercicio19("Cualquier nombre").setLocation(400,300); } public boolean action(Event evt,Object ar){ if(evt.target instanceof Button){ if(evt.target==b3){dispose();} if(evt.target==b2) imprimir(); if(evt.target==b1) this.panelrectificador(); return true; } if(evt.target instanceof TextField){ if(evt.target==t4){mater=t4.getText(); t1.requestFocus();} if(evt.target==t1){nota1=Integer.parseInt(t1.getText()); t2.requestFocus();} if(evt.target==t2){nota2=Integer.parseInt(t2.getText()); prom=(double)((nota1+nota2)/2); t3.setText(String.valueOf(prom));} return true; } else




return false; } } EJERCICIO 247 Escriba un Programa que simule el juego de Traga-Monedas. El Sobre tiene que tener 6 veces o menos posibilidad de salir El Sofá tiene que tener 3 veces o menos posibilidad de salir La carta tiene que tener 1 veces o menos posibilidad de salir package Ej23; import java.awt.*; public class Ejercicio23 extends javax.swing.JFrame{ Label l1,l2,l3,l4,l5,l7; int contcarta=0,contfoco=0,contsofa=0; Panel p1,p2,p3,p4; javax.swing.JLabel jL[]=new javax.swing.JLabel[3]; javax.swing.JLabel l6; Button b1,b2; String dir=""; public Ejercicio23() { getContentPane().setLayout(new BorderLayout()); p1=new Panel(); p1.setLayout(new GridLayout(6,1)); p1.add(l7=new Label(" Ganancias")); p1.add(l1=new Label(" 3 Focos 1000")); p1.add(l2=new Label(" 3 Sofá 500")); p1.add(l3=new Label(" 3 Sobres 250")); p1.add(l4=new Label(" 2 Focos 100")); p1.add(l5=new Label(" 2 Sofá 50")); getContentPane().add("West",p1); Panel p11=new Panel(); p11.setLayout(new GridLayout()); for(int i=0;i<3;i++) p11.add(jL[i]=new javax.swing.JLabel()); p2=new Panel(); p2.setLayout(new GridLayout(1,2)); Panel p3=new Panel();




p3.setLayout(new GridLayout(1,2)); p3.add(b1=new Button("Jugar")); p3.add(b2=new Button("Salir")); p2.add(l6=new javax.swing.JLabel("Mensaje")); l6.setHorizontalAlignment(javax.swing.SwingConstants.CENTER); p2.add(p3); getContentPane().add("Center",p11); getContentPane().add("South",p2); setTitle("Traga-Monedas"); setSize(450,200); show(); } public static void main(String arg[]){ new Ejercicio23().setLocation(400,300); } int aleatorio(){ int c=0; c=(int)(Math.random()*9); return c; } String direcciones(int y){ String d=""; if(y==0 || y==2 || y==3 || y==4 || y==6 || y==8){ d="/Prog/EjerciciosNormales/carta.jpg"; contcarta++; } if(y==1 || y==5 || y==9){ d="/Prog/EjerciciosNormales/sofa.jpg"; contsofa++; } if(y==7){ d="/Prog/EjerciciosNormales/foco.jpg"; contfoco++; } return d; }




void jugar(){ l6.setText(""); contfoco=0; contsofa=0; contcarta=0; dir=""; jL[0].setIcon(new javax.swing.ImageIcon(getClass().getResource(direcciones(aleatorio())))); jL[1].setIcon(new javax.swing.ImageIcon(getClass().getResource(direcciones(aleatorio())))); jL[2].setIcon(new javax.swing.ImageIcon(getClass().getResource(direcciones(aleatorio())))); if(contfoco==3) l6.setText("1000"); if(contsofa==3) l6.setText("500"); if(contcarta==3) l6.setText("250"); if(contfoco==2) l6.setText("100"); if(contsofa==2) l6.setText("50"); } public boolean action(Event evt,Object ar){ if(evt.target instanceof Button){ if(evt.target==b2){dispose(); System.exit(0);} if(evt.target==b1){jugar();} return true; } else return false; } } EJERCICIO 248 Escriba una clase en java que cumpla con los siguientes requisitos Metodología: ingresar tres números en tres Texfield, y cuando se presionan los botones A-Z o Z-A se mostrarán sus respectivas ordenaciones en los Label

A-Z Z-A




package Ej6; import java.awt.*; public class Ejercicio6 extends javax.swing.JFrame{ TextField t1,t2,t3; Button b1,b2,b3; Label l1,l2,l3; Panel p1,p2,p3; int mayor,intermedio,menor; public Ejercicio6() { this.getContentPane().setLayout(new GridLayout(4,1)); setTitle("Ejercicio6::Juego"); p1=new Panel(); p1.setLayout(new GridLayout(1,3)); p1.add(t1=new TextField()); p1.add(t2=new TextField()); p1.add(t3=new TextField()); p2=new Panel(); p2.setLayout(new GridLayout(1,2)); p2.add(b1=new Button("A-Z")); p2.add(b2=new Button("Z-A")); p3=new Panel(); p3.setLayout(new GridLayout(1,3)); p3.add(l1=new Label()); p3.add(l2=new Label()); p3.add(l3=new Label()); getContentPane().add(p1); getContentPane().add(p2); getContentPane().add(p3); getContentPane().add(b3=new Button("Salir")); pack(); show(); } public static void main(String arg[]){ new Ejercicio6().setLocation(400,300); } void ubicar(int a,int b,int c,int m){ mayor=0;




intermedio=0; menor=0; if(a>=b){ if(a>=c){ if(b>=c){ mayor=a; intermedio=b; menor=c; } } else{ mayor=c; intermedio=a; menor=b; } } else{ if(b>=c){ if(a>=c){ mayor=b; intermedio=a; menor=c; } else{ mayor=b; intermedio=c; menor=a; } } } if(m==1){ this.l1.setText(String.valueOf(mayor)); this.l2.setText(String.valueOf(intermedio)); this.l3.setText(String.valueOf(menor)); } else{ this.l1.setText(String.valueOf(menor)); this.l2.setText(String.valueOf(intermedio)); this.l3.setText(String.valueOf(mayor)); } } public boolean action(Event evt, Object ar){ if(evt.target instanceof Button){ if(evt.target==b3){dispose(); System.exit(0);} if(evt.target==b1){ try{ if(!(t1.getText().equals("") && t2.getText().equals("") && t3.getText().equals(""))){ ubicar(Integer.parseInt(t1.getText()),Integer.parseInt(t2.getText()),Integer.parseInt(t3.getText()),1); }




} catch(Throwable e){ javax.swing.JOptionPane.showMessageDialog(null,"Ingrese solo numeros enteros"); } } if(evt.target==b2){ try{ if(!(t1.getText().equals("") && t2.getText().equals("") && t3.getText().equals(""))){ ubicar(Integer.parseInt(t1.getText()),Integer.parseInt(t2.getText()),Integer.parseInt(t3.getText()),0); } } catch(Throwable e){ javax.swing.JOptionPane.showMessageDialog(null,"Ingrese solo numeros enteros"); } } return true; } if(evt.target instanceof TextField){ if(evt.target==t1){ t2.requestFocus(); } if(evt.target==t2) t3.requestFocus(); if(evt.target==t3) b1.requestFocus(); return true; } else return false; } } EJERCICIO 249 Escriba una clase con las siguientes características: Nombre de la clase : Tarjeta Atributos : Nombre Número Saldo //disponible para comprar




Cupo //cupo total de la tarjeta Métodos: : Compra(double c) //Método que resta el saldo de la tarjeta Pago(double p) //Método que aumenta el saldo de la tarjeta El programa debe validar que solo pueda comprar un valor menor al saldo El método pago debe validar que se pueda pagar el valor correspondiente para que se aumente su saldo(El pago No puede ser mayor al cupo-saldo) package Ej14; import java.awt.*; public class Tarjeta extends javax.swing.JFrame{ double cupo=300, saldo=300; Button b1,b2,b3; Label l1,l2,l3,l4,l5,l6,l7; TextField t1,t2,t3; Panel p1; /*Nombre de la clase : Tarjeta Atributos : Nombre Número Saldo //disponible para comprar Cupo //cupo total de la tarjeta Métodos : Compra(double c) //Método que resta el saldo de la tarjeta Pago(double p) //Método que aumenta el saldo de la tarjeta a) El programa debe validar que solo pueda comprar un valor menor al saldo b) El método pago debe validar que se pueda pagar el valor correspondiente para que se aumente su saldo (El pago No puede ser mayor al cupo-saldo) */ public Tarjeta() { getContentPane().setLayout(new BorderLayout()); setTitle("Tarjeta"); p1=new Panel(); p1.setLayout(new GridLayout(6,2)); p1.add(l1=new Label("Nombre")); p1.add(t1=new TextField()); p1.add(l2=new Label("Número")); p1.add(t2=new TextField()); p1.add(l3=new Label("Saldo")); p1.add(l4=new Label("$ "+String.valueOf(saldo))); p1.add(l5=new Label("Cupo")); p1.add(l6=new Label("$" +String.valueOf(cupo)));




p1.add(l7=new Label("Valor")); p1.add(t3=new TextField()); p1.add(b1=new Button("Compra")); p1.add(b2=new Button("Pago")); getContentPane().add("North",p1); getContentPane().add(b3=new Button("Salir")); setSize(150,200); show(); } void compra(double c){ if(c<=saldo && c<=cupo) saldo -= c; else{ javax.swing.JOptionPane.showMessageDialog(null,"Su saldo no es suficiente"); t3.setText(""); t3.requestFocus(); } l4.setText("$ "+String.valueOf(saldo)); } void pago(double p){ if(p<=cupo && (saldo+p)<=cupo) saldo +=p; else{ javax.swing.JOptionPane.showMessageDialog(null,"Pago sobrepasa su saldo-cupo"); t3.setText(""); t3.requestFocus(); } l4.setText("$ "+String.valueOf(saldo)); } public boolean action(Event evt,Object ar){ if(evt.target instanceof Button){ if(evt.target==b3){dispose(); System.exit(0);} try{ if(evt.target==b1) compra(Double.parseDouble(t3.getText())); if(evt.target==b2) pago(Double.parseDouble(t3.getText())); t3.requestFocus();




} catch(Throwable e){ javax.swing.JOptionPane.showMessageDialog(null,"No digito ningun valor"); t3.requestFocus();} return true; } if(evt.target instanceof TextField){ if(evt.target==t1) t2.requestFocus(); if(evt.target==t2) t3.requestFocus(); return true; } else return false; } public static void main(String arg[]){ new Tarjeta().setLocation(400,300); } } EJERCICIO 250 (Paseo del caballo) Uno de los enigmas mas interesantes para los entusiastas del ajedrez es el problema del Paseo del caballo, propuesto originalmente por el matemático Euler. ¿Puede la pieza de ajedrez , conocida como caballo, moverse alrededor de un tablero de ajedrez vacío y tocar cada una de las 64 posiciones una y sola una vez? A continuación estudiaremos detalladamente este intrigante problema. El caballo realiza solamente movimientos en forma de L (dos espacios en una dirección perpendicular). Por lo tanto, como se muestra en la figura, desde una posición cerca del centro de un tablero de ajedrez vacío, el caballo (etiquetado como C) puede hacer ocho movimientos distintos (numerados del 0 al 7)

0 1 2 3 4 5 6 7

0

1 2 1

2 3 0

3 k

4 4 7

5 5 6

6

7




Dibuje un tablero de ajedrez de ocho por ocho en una hoja de papel, e intente realizar un Paseo del caballo en forma manual. Ponga un 1 en la posición inicial, un 2 en la segunda posición, un 3 en la tercera, etc. Antes de empezar el paseo, estime qué tan lejos podrá avanzar, recordando que un paseo completo consta de 64 movimientos. ¿Qué tan lejos llegó? ¿Estuvo esto cerca de su estimación? Ahora desarrollaremos un programa para mover el caballo alrededor de un tablero de ajedrez. El tablero estará presentado por un arreglo bidiminsional llamado tablero, de ochopor ocho. Cada posición se inicializará con cero. Describiremos cada uno delos ocho posibles package Ej24; public class Juego { int x, y; int nuevax = 0, nuevay = 0, solx = 0, soly = 0, total = 0; public Juego(int x, int y) { this.x = x; this.y = y; } public boolean jugar(Tablero tabla) { for (int num = 1; num < tabla.longitud * tabla.longitud + 1; num++) { tabla.tabla[x][y] = num; if ( (mover(tabla, x, y, num) == false && num < tabla.longitud * tabla.longitud - 1)) return false; } return true; } public boolean mover(Tablero tabla, int xx, int yy, int num) { int acesible, minacesible; minacesible = 9; solx = xx; soly = yy; for (int i = 1; i < 9; i++) { if (saltar(tabla, i, x, y, nuevax, nuevay) == true) { acesible = contar(tabla, nuevax, nuevay);




if ( (acesible < minacesible) && ((acesible > 0) || ((acesible == 0) && (num ==tabla.longitud * tabla.longitud - 1)) ) ) { minacesible = acesible; solx = nuevax; soly = nuevay; } } } x = solx; y = soly; return (minacesible < 9); } public boolean saltar(Tablero tabla, int i, int valex, int valey, int nx,int ny) { nuevax = nx; nuevay = ny; switch (i) { case 1: nuevax = valex - 1; nuevay = valey - 2; break; case 2: nuevax = valex - 2; nuevay = valey - 1; break; case 3: nuevax = valex - 2; nuevay = valey + 1; break; case 4: nuevax = valex - 1; nuevay = valey + 2; break; case 5: nuevax = valex + 1; nuevay = valey + 2; break; case 6: nuevax = valex + 2; nuevay = valey + 1; break; case 7: nuevax = valex + 2; nuevay = valey - 1; break;




case 8: nuevax = valex + 1; nuevay = valey - 2; break; default: javax.swing.JOptionPane.showMessageDialog(null,"La opcion elegida es incorrecta." + "\n"); } return ( (0 <= nuevax) && (nuevax < tabla.longitud) && (0 <= nuevay) && (nuevay < tabla.longitud) && (tabla.tabla[nuevax][nuevay] == 0)); } public int contar(Tablero tabla, int x, int y) { int accion = 0, i, nx = 0, ny = 0; for (i = 1; i < 9; i++) { if (saltarSimulado(tabla, i, x, y, nx, ny)) accion++; } return accion; } public boolean saltarSimulado(Tablero tabla, int i, int valex, int valey, int nx, int ny) { switch (i) { case 1: nx = valex - 1; ny = valey - 2; break; case 2: nx = valex - 2; ny = valey - 1; break; case 3: nx = valex - 2; ny = valey + 1; break; case 4: nx = valex - 1; ny = valey + 2; break; case 5:




nx = valex + 1; ny = valey + 2; break; case 6: nx = valex + 2; ny = valey + 1; break; case 7: nx = valex + 2; ny = valey - 1; break; case 8: nx = valex + 1; ny = valey - 2; break; default: javax.swing.JOptionPane.showMessageDialog(null,"La opcion elegida es incorrecta." + "\n"); } return ( (0 <= nx) && (nx < tabla.longitud) && (0 <= ny) && (ny < tabla.longitud) && (tabla.tabla[nx][ny] == 0)); } } package Ej24; import java.io.*; public class Principal { BufferedReader teclado = new BufferedReader(new InputStreamReader(System.in)); Tablero tablero; int longitud, inix, iniy; Juego juego; public Principal() { try { do { javax.swing.JOptionPane.showMessageDialog(null,"Bienvenido");




String y=javax.swing.JOptionPane.showInputDialog(null,"introduzca el tamano del tablero: (n debe ser mayor que4)"); longitud = Integer.parseInt(y); } while (longitud < 5); tablero = new Tablero(longitud); do { String x1=javax.swing.JOptionPane.showInputDialog(null,"introduzca la posicion inicial del caballo: (x,y) \n"+ "x (numero de fila: 0..n-1)=>"); inix = Integer.parseInt(x1); } while (inix >= longitud); do{ String y1=javax.swing.JOptionPane.showInputDialog(null,"y (numero de fila: 0..n-1)=>"); iniy = Integer.parseInt(y1); } while(iniy >= longitud); } catch (Exception e) { javax.swing.JOptionPane.showMessageDialog(null,"Hay un error al introducir los datos"); } tablero.mostrar(longitud); juego = new Juego(inix-1, iniy-1); if (juego.jugar(tablero) == true) { System.out.print("\n" + "\n"); tablero.mostrar(longitud); tablero.mostrarb(); } else { System.out.print("\n" + "\n"); tablero.mostrar(longitud); tablero.mostrarb(); javax.swing.JOptionPane.showMessageDialog(null,"no es posible recorrer el tablero");




} } public static void main(String[] args) { Principal principal1 = new Principal(); } } package Ej24; import java.awt.*; public class Tablero extends javax.swing.JFrame{ Panel p1; int busqueda; int[][] tabla; Button[][] b; int g =0; int longitud; public Tablero(int longitud) { tabla = new int[longitud][longitud]; this.longitud = longitud; } public void mostrar(int longitud) { for (int i = 0; i < longitud; i++) for (int j = 0; j < longitud; j++) { if (j < longitud - 1) { if (tabla[i][j] < 10){ g++; } else { if (tabla[i][j] < 100) g++; else g++; } } else g++; } } //Mostrar en el output




//***Mostrar en interfaz***// public void mostrarb() { getContentPane().setLayout(new GridLayout(1,1)); p1=new Panel(); b=new Button[longitud][longitud]; p1.setLayout(new GridLayout(longitud,longitud)); for(int i=0;i<longitud;i++){ for(int j=0;j<longitud;j++){ p1.add(b[i][j]=new Button(String.valueOf(this.tabla[i][j]))); b[i][j].disable(); if(b[i][j].getLabel().equals("1")){ b[i][j].setBackground(new Color(51, 0, 255)); b[i][j].setForeground(new Color(204, 255, 255)); b[i][j].enable(); } } } addWindowListener(new java.awt.event.WindowAdapter() { public void windowClosing(java.awt.event.WindowEvent evt) { exitForm(evt); } }); getContentPane().add(p1); pack(); setLocation(400,300); show(); } private void exitForm(java.awt.event.WindowEvent evt) { dispose(); System.exit(0); } public boolean action(Event evt,Object ar){ if(evt.target instanceof Button){ for(int m=0;m<longitud;m++){ for(int k=0;k<longitud;k++){ if(evt.target==b[m][k]){ busqueda=Integer.parseInt(b[m][k].getLabel()); busqueda(busqueda); } }




} return true; } else return false; } void busqueda(int x){ int y=x+1; for(int m=0;m<longitud;m++){ for(int k=0;k<longitud;k++){ if(b[m][k].getLabel().equals(String.valueOf(y))){ b[m][k].enable(); b[m][k].setBackground(new Color(153, 0, 51)); b[m][k].setForeground(new Color(255,255,255)); } } } } public static void main(String arg[]){ } }

MÉTODOS EN JAVA EJERCICIO 251




REALIZAR UN PROGRAMA EN JAVA QUE PRESENTE UN NÚMERO UTILIZANDO UN MÉTODO. import java.io.*; import java.lang.*; class Metodo1{ public static void main(String arg[]) throws IOException{ int num=10, valor; numero(num); } public static void numero(int num){ System.out.println("El numero es: "+num); } }

EJERCICIO 252 REALIZAR UN PROGRAMA EN JAVA QUE PRESENTE UN NOMBRE Y UN APELLIDO UTILIZANDIO MÉTODOS. import java.io.*; import java.lang.*; class Metodo2{ public static void main(String arg[]) throws IOException{ nombre(); apellido(); } public static void nombre(){ System.out.print("Ana"); } public static void apellido(){ System.out.println(" Molina"); }




}

EJERCICIO 253 REALIZAR UN PROGRAMA EN JAVA QUE REALICE LA SUMA DE DOS NÚMEROS EN UN MÉTODO. import java.io.*; import java.lang.*; class MetodoSuma{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int a=0,b=0,r=0; System.out.print("Ingrese el primer numero: "); a=Integer.parseInt(temp.readLine()); System.out.print("Ingrese el segundo numero: "); b=Integer.parseInt(temp.readLine()); r=suma(a,b); System.out.println("\nResultado: "+r); } public static int suma(int num1,int num2){ int resultado_local=0; resultado_local=num1+num2; return resultado_local; } }




EJERCICIO 254 REALIZAR UN PROGRAMA EN JAVA QUE REALICE LA RESTA DE DOS NÚMEROS EN UN MÉTODO. import java.io.*; import java.lang.*; class MetodoResta{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int a=0,b=0,r=0; System.out.print("Ingrese el primer numero: "); a=Integer.parseInt(temp.readLine()); System.out.print("Ingrese el segundo numero: "); b=Integer.parseInt(temp.readLine()); r=resta(a,b); System.out.println("\nResultado: "+r); } public static int resta(int num1,int num2){ int resultado_local=0; resultado_local=num1-num2; return resultado_local; } }

EJERCICIO 255 REALIZAR UN PROGRAMA EN JAVA QUE REALICE LA MULTIPLICACIÓN DE DOS NÚMEROS EN UN MÉTODO. import java.io.*;




import java.lang.*; class MetodoMult{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int a=0,b=0,r=0; System.out.print("Ingrese el primer numero: "); a=Integer.parseInt(temp.readLine()); System.out.print("Ingrese el segundo numero: "); b=Integer.parseInt(temp.readLine()); r=multiplicacion(a,b); System.out.println("\nResultado: "+r); } public static int multiplicacion(int num1,int num2){ int resultado_local=0; resultado_local=num1*num2; return resultado_local; } }

EJERCICIO 256 REALIZAR UN PROGRAMA EN JAVA QUE REALICE LA DIVISIÓN DE DOS NÚMEROS EN UN MÉTODO. import java.io.*; import java.lang.*; class MetodoDiv{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int a=0,b=0,r=0;




System.out.print("Ingrese el primer numero: "); a=Integer.parseInt(temp.readLine()); System.out.print("Ingrese el segundo numero: "); b=Integer.parseInt(temp.readLine()); r=division(a,b); System.out.println("\nResultado: "+r); } public static int division(int num1,int num2){ int resultado_local=0; resultado_local=num1/num2; return resultado_local; } }

EJERCICIO 257 REALIZAR UN PROGRAMA QUE PERMITA OBTENER LA POTENCIA DE UN NÚMERO. import java.io.*; import java.lang.*; public class Potencia1 { public static void main(String[] args) { double a= 10.0, b; int x= 3; System.out.println("Main: a= " + a + ", x= " + x); b= potencia(a, x); System.out.println("Main: Result b= " + b); } public static double potencia(double d, int i){ System.out.println("Potencia: d= " + d + ", i= " + i); double x= d; for (int j= 1; j < i; j++) x *= d; // x = x * d; return x;} }




EJERCICIO 258 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA OBTENER EL RESIDUO DE DOS NÚMEROS EN UN MÉTODO. import java.io.*; import java.lang.*; class MetodoResiduo{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int a=0,b=0,r=0; System.out.print("Ingrese el primer numero: "); a=Integer.parseInt(temp.readLine()); System.out.print("Ingrese el segundo numero: "); b=Integer.parseInt(temp.readLine()); r=residuo(a,b); System.out.println("\nResultado: "+r); } public static int residuo(int num1,int num2){ int resultado_local=0; resultado_local=num1%num2; return resultado_local; } }




EJERCICIO 259 REALIZAR UN PROGRAMA EN JAVA QUE ELEEVE CUALQUIER NÚMERO AL CUADRADO EN UN MÉTODO. import java.io.*; import java.lang.*; class MetodoPotencia{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int a=0,r=0; System.out.print("Ingrese un numero entero positivo: "); a=Integer.parseInt(temp.readLine()); r=cuadrado(a); System.out.println("\nResultado: "+r); } public static int cuadrado(int num1){ int resultado_local=0; resultado_local=num1*num1; return resultado_local; } }

EJERCICIO 260 REALIZAR UN PROGRAMA EN JAVA QUE ENCUENTRE EL FACTORIAL DE CUALQUIER NÚMERO INGRESADO POR TECLADO. FACTORIAL DE 5 ES : 1*2*3*4*5= 120 import java.io.*; import java.lang.*; class MetodoFactor{




public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int a=0; double p=0; System.out.print("Ingrese un numero: "); a=Integer.parseInt(temp.readLine()); p=factorial(a); System.out.println("\nFactorial de "+a+" es: "+p); } public static double factorial(int n){ double fac=1; int i=1; for(i=1;i<=n;i++) fac=fac*i; return fac; } }

EJERCICIO 261 CODIFIQUE UN MÉTODO EN JAVA QUE PERMITA ENCONTRAR LA SOLUCIÓN DEL SIGUIENTE POLINOMIO: y=x^3-x^2+1 import java.io.*; import java.lang.*; class MetodoEcua{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int x=0,r=0;




System.out.println("\ty=x^3-x^2+1"); System.out.print("Ingrese elvalor de x: "); x=Integer.parseInt(temp.readLine()); r=polinomio(x); System.out.println("\nEl resultado del polinomio es: "+r); } public static int polinomio(int num1){ int y=0; y=(num1*num1*num1)-(num1*num1)+1; return y; } }

EJERCICIO 262 CODIFIQUE UN MÉTODO EN JAVA QUE PERMITA ENCONTRAR EL AREA Y EL PERIMETRO DE UN CUADRADO. AREA=L*L PERIMETRO=L+L+L+L import java.io.*; import java.lang.*; class MetodoCuadro{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int lado=0,area=0, perimetro=0,r=0,r2=0; System.out.print("Ingrese el lado: "); lado=Integer.parseInt(temp.readLine());




r=area(lado); r2=perimetro(lado); System.out.println("\n\tArea del Cuadrado: "+r); System.out.println("\tPerimetro del Cuadrado: "+r2); } public static int area(int l){ return(l*l); } public static int perimetro(int l){ return(l+l+l+l); } }

SOBRECARGA DE MÉTODOS Se denomina sobrecarga de métodos cuando en una misma clase existen dos o más métodos con el mismo nombre, pero con diferentes parámetros. Vea el siguiente ejemplo: EJERCICIO 263 REALIZAR UN PROGRAMA EN JAVA QUE TENGA DOS MÉTODOS CON EL MISMO NOMBRE PERO DIFERENTES ARGUMENTOS(UN MÉTODO CON ARGUMENTOS ENTEROS Y OTRO MÉTODO CON ARGUMENTOS DOUBLE) Y QUE PERMITA OBTENER EL ÁREA DE UN CUADRADO. import java.io.*; import java.lang.*; class MetodoCuadro{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int intlado=0,doublelado=0,area=0;




System.out.println("El cuadrado del valor Integer 7 es: "+area(7)); System.out.println("El cuadrado del valor double 7.5 es : "+area(7.5)); } public static int area(int intlado){ System.out.println("\t\nSe llamo al Metodo Cuadrado con argumentos int"); return(intlado*intlado); } public static double area(double doublelado){ System.out.println("\t\nSe llamo al Metodo Cuadrado con argumentos double"); return(doublelado*doublelado); } }

EJERCICIO 264 REALIZAR UN PROGRAMA EN JAVA QUE CONTENGA 4 MÉTODOS: SUMA, RESTA, MULTIPLICACIÓN Y DIVISIÓN. import java.io.*; import java.lang.*; class MetodoFactor{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int a=0,b=0,s=0,r=0,m=0; float d=0f; System.out.print("Ingrese el primer numero: "); a=Integer.parseInt(temp.readLine()); System.out.print("Ingrese el segundo numero: ");




b=Integer.parseInt(temp.readLine()); s=suma(a,b); r=resta(a,b); m=multiplicacion(a,b); d=division(a,b); System.out.println("\n\tSuma: "+s); System.out.println("\tResta: "+r); System.out.println("\tMultiplicacion: "+m); System.out.println("\tDivision: "+d); } public static int suma(int x, int y){ return(x+y); } public static int resta(int x, int y){ return(x-y); } public static int multiplicacion(int x, int y){ return(x*y); } public static float division(int x, int y){ return(x/y); } }

EJERCICIO 265 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA INGRESAR UN NÚMERO Y QUE PRESENTE POR PANTALLA SI EL NÚMERO ES POSITIVO O NEGATIVO. import java.io.*; import java.lang.*; class MetodoPosi_Nega{




public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num=0; System.out.print("Ingrese un numero: "); num=Integer.parseInt(temp.readLine()); Posi_Nega(num); } public static void Posi_Nega(int x){ if(x>0) System.out.println("El numero es positivo"); else System.out.println("El numero es negativo"); } }

EJERCICIO 266 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA INGRESAR UN NÚMERO Y QUE PRESENTE POR PANTALLA SI EL NÚMERO ES PAR O IMPAR. import java.io.*; import java.lang.*; class MetodoParOImpar{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num=0; System.out.print("Ingrese un numero: ");




num=Integer.parseInt(temp.readLine()); Par_Impar(num); } public static void Par_Impar(int x){ int p=0; p=x%2; if(p==0) System.out.println("El numero es par"); else System.out.println("El numero es impar"); } }

EJERCICIO 267 REALIZAR UN MÉTODO QUE PERMITA INGRESAR UN NÚMERO Y QUE PRESENTE POR PANTALLA LA RAÍZ CUADRADA DEL NÚMERO INGRESADO. import java.io.*; import java.lang.*; class MetodoRaiz{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num=0; double raiz=0; System.out.print("Ingrese un numero: "); num=Integer.parseInt(temp.readLine()); raiz=Raiz(num); System.out.println("La raiz de "+num+" es: "+raiz); } public static double Raiz(int x){ double r=0;




r=Math.sqrt(x); return r; } }

EJERCICIO 268 REALIZAR UN MÉTODO QUE PERMITA INGRESAR UN NÚMERO Y QUE PRESENTE POR PANTALLA EL CUBO DEL NÚMERO INGRESADO.(EJEMPLO: 2 ELEVADO AL CUBO ES 8.) import java.io.*; import java.lang.*; class MetodoCubo{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num=0; double cubo=0; System.out.print("Ingrese un numero: "); num=Integer.parseInt(temp.readLine()); cubo=Cubo(num); System.out.println("El cubo de "+num+" es: "+cubo); } public static double Cubo(int x){ double r=0; r=Math.pow(x,3); return r; } }

EJERCICIO 269




REALIZAR UN PROGRAMA QUE PERMITA ENCONTRAR EL VALOR DE LA HIPOTENUSA DE UN TRIÁNGULO RECTÁNGULO. import java.io.*; import java.lang.*; class MetodoHipotenusa{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int x,y; double hipotenusa=0; System.out.print("Ingrese el valor de a: "); x=Integer.parseInt(temp.readLine()); System.out.print("Ingrese el valor de b: "); y=Integer.parseInt(temp.readLine()); hipotenusa=Hipotenusa(x,y); System.out.println("El valor de la hipotenusa es: "+hipotenusa); } public static double Hipotenusa(int a, int b){ double r=0; r=Math.sqrt((Math.pow(a,2)+Math.pow(b,2))); return r; } }

EJERCICIO 270 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA INGRESAR DOS NÚMEROS, EL PROGRAMA MOSTRARÁ QUE NÚMERO INGRESADO ES EL MAYOR. import java.io.*; import java.lang.*; class MetodoMayor{ public static void main(String arg[]) throws IOException{




BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num1=0,num2=0; System.out.print("Ingrese el primer numero: "); num1=Integer.parseInt(temp.readLine()); System.out.print("Ingrese el segundo numero: "); num2=Integer.parseInt(temp.readLine()); Mayor(num1,num2); } public static void Mayor(int x, int y){ if(x>y) System.out.println("El numero mayor es:"+x); else System.out.println("El numero mayor es:"+y); } }

EJERCICIO 271 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA INGRESAR UN NÚMERO, EL PROGRAMA MOSTRARÁ SI EL NÚMERO INGRESADO ES POSITIVO O NEGATIVO Y SI ES PAR O IMPAR. import java.io.*; import java.lang.*; class MetodoM{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num1=0,num2=0; System.out.print("Ingrese el primer numero: "); num1=Integer.parseInt(temp.readLine());




Par_Impar(num1); Posi_Nega(num1); } public static void Par_Impar(int x){ int p=0; p=x%2; if(p==0) System.out.println("El numero es par"); else System.out.println("El numero es impar"); } public static void Posi_Nega(int x){ if(x>0) System.out.println("El numero es positivo"); else System.out.println("El numero es negativo"); } }

EJERCICIO 272 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA INGRESAR UN NÚMERO Y PRESENTAR EL NÚMERO 10 VECES. import java.io.*; import java.lang.*; class MetodoMultiplo{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int num1=0,num2=0; System.out.print("Ingrese un numero: "); num1=Integer.parseInt(temp.readLine());




Numero(num1); } public static void Numero(int x){ int cont=0; do{ cont=cont+1; System.out.println(x); }while(cont<5); } }

EJERCICIO 273 REALIZAR UN PROGRAMA EN JAVA QUE GENERE LOS 5 PRIMEROS NÚMEROS PARES. import java.io.*; import java.lang.*; class MetodoPares{ public static void main(String arg[]) throws IOException{ System.out.println("Primeros 5 numeros pares"); Par(); } public static void Par(){ int cont=0, acu=0; do{ cont=cont+1; acu=acu+2; System.out.println("\t"+acu); }while(cont<5); } }




EJERCICIO 274 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA OBTENER EL PROMEDIO DE LOS NÚMEROS INGRESADOS POR TECLADO. import java.io.*; import java.lang.*; class MetodoPromedio{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int cont=0,n1=0,n2,n3; float r=0.f; System.out.print("Ingrese un numero: "); n1=Integer.parseInt(temp.readLine()); System.out.print("Ingrese un numero: "); n2=Integer.parseInt(temp.readLine()); System.out.print("Ingrese un numero: "); n3=Integer.parseInt(temp.readLine()); r=Promedio(n1,n2,n3); System.out.println("El promedio es: "+r); } public static float Promedio(int x, int y, int z){ int cont=0, acu=0,p=0; p=(x+y+z)/3; return p; }




}

ARREGLOS EN JAVA Introducción: Un arreglo es una colección de objetos numerados del mismo tipo, en donde cada variable o celda en el arreglo tiene un índice. Las celdas están numeradas del 0 al N-1, donde N es el número de celdas del arreglo es decir su capacidad. Los índices de un arreglo en Java deben estar dentro de los límites, 0 – N-1, de lo contrario se generará un error durante la ejecución. Java implementa los arreglos como objetos que pueden ser tratados como cualquier otro objeto. Para utilizar un arreglo en Java: Declare una variable para que contenga el arreglo Cree un nuevo arreglo de objeto y asígnelo a la variable de arreglo Almacene información en ese arreglo Realice operaciones de almacenamiento y recuperación con los elementos del arreglo Declaración: Se agrega un par de corchetes vacíos [ ] al objeto o tipo de datos, o al nombre de variable. Ejemplos: String palabrasDificiles [ ]; Point hits [ ];




int donaciones [ ]; O bien: String [ ] palabrasDificiles; Point [ ] hits; int [ ] donaciones; Creación de objetos de arreglos: Después de haber declarado la variable arreglo, el siguiente paso es crear un arreglo de objetos y asignarlo a esa variable. Las formas de hacerlo son: a través del operador new inicializando directamente el contenido del arreglo Ejemplos: String [ ] nombreJugadores = new String [10]; int [ ] temps = new int [99]; Todas las posiciones se inicializan automáticamente (0 para arreglos numéricos, false para booleanos, ‘\0’ para arreglos de carácter y null para objetos) También se puede crear e inicializar un arreglo al mismo tiempo. Encierre los elementos del arreglo entre llaves, separándolos con comas: String [ ] chiles = { “jalapeno”, “de árbol”, “serrano”, “habanero”}; Al crear elementos con valores iniciales, el arreglo es del mismo tamaño que la cantidad de elementos que ha incluido en las llaves. El tamaño de un arreglo se almacena en la variable length, que puede ser accesada a través del operador . y el nombre del arreglo: nombreArreglo.length EJERCICIO 275 EN ESTE EJERCICIO SE UTILIZA LA PALABRA NEW PARA CREAR UN ARREGLO DE 10 ELEMENTOS INT, LOS CUALES INICIALMENTE TIENEN EL VALOR DE CERO. import java.io.*; import java.lang.*; class Arreglo1{ public static void main(String arg[]) throws IOException{ int arreglo[]; arreglo=new int[10];




String salida ="indice\tvalor\n"; for(int contador=0;contador<arreglo.length;contador++) salida+=contador+"\t"+arreglo[contador]+"\n"; System.out.print(salida); } }

EJERCICIO 276 EN ESTE EJERCICIO NO ES NECESARIO LA PALABRA NEW PARA CREAR UN ARREGLO, A ÉSTE SE LE DENOMINA LISTA INICIALIZADORA, YA QUE EL TAMAÑO DEL ARREGLO DEPENDERÁ DE LOS ELEMENTOS PUESTOS EN EL ARREGLO. import java.io.*; import java.lang.*; class Arreglo2{ public static void main(String arg[]) throws IOException{ int arreglo[]={32,27,64,18,95,14,90,70,60,37}; String salida ="indice\tvalor\n"; for(int contador=0;contador<arreglo.length;contador++) salida+=contador+"\t"+arreglo[contador]+"\n"; System.out.print(salida); } }




EJERCICIO 277 REALIZAR UN PROGRAMA EN JAVA PARA CREAR UN ARREGLO DE 10 ELEMENTOS Y ASIGNA A CADA UNO DE ELLOS UNO DE LOS ENTEROS PARES DEL 2 AL 20 (2,4,6…20). import java.io.*; import java.lang.*; class Arreglo2{ public static void main(String arg[]) throws IOException{ final int LONGITUD_ARREGLO= 10; //constante int arreglo[];//referencia a un arreglo int arreglo=new int [LONGITUD_ARREGLO];//crea el arreglo for(int contador=0;contador<arreglo.length;contador++) arreglo[contador]=2+2*contador; //calcular el valor para cada elemento del arreglo String salida ="indice\tvalor\n"; for(int contador=0;contador<arreglo.length;contador++) salida+=contador+"\t"+arreglo[contador]+"\n"; System.out.print(salida); } }




EJERCICIO 278 REALIZAR UN PROGRAMA EN JAVA QUE SUME LOS ELEMNTOS DE UN ARREGLO. import java.io.*; import java.lang.*; class Arreglo4{ public static void main(String arg[]) throws IOException{ int arreglo[]={1,2,3,4,5,6,7,8,9,10};//declara,crea e inicializa int total=0; //sumar el valor de cada elemento al total for(int contador=0;contador<arreglo.length;contador++) total += arreglo[contador]; System.out.println("Suma de los elementos del arreglo es: "+total); } }

EJERCICIO 279 REALIZAR UN PROGRAMA EN JAVA QUE MUESTRE LOS DATOS REPRESENTADOS EN UN HISTOGRAMA. import java.io.*; import java.lang.*; class Arreglo5{ public static void main(String arg[]) throws IOException{ int arreglo[]={19,3,15,7,11,9,13,5,17,1};/*declara,crea e inicializa*/ int total=0; String salida ="#\tValor\tHistograma"; /*para cada elemento del arreglo, mostrar una barra en el histograma*/ for(int contador=0;contador<arreglo.length;contador++){




salida += "\n"+contador+"\t"+arreglo[contador]+"\t"; //imprimir barra de asteriscos for(int estrellas=0;estrellas<arreglo[contador];estrellas++) salida += "*"; }//fin del for externo System.out.println(salida); } }

EJERCICIO 280 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA LANZAR UN DADO DE 6 LADOS 6000 VECES Y QUE MUESTRE CUANTAS VECES EL LADO 1, LADO2….LADO6, SALIERON. import java.io.*; import java.lang.*; class Arreglo6{ public static void main(String arg[]) throws IOException{ int frecuencia[]= new int [7];/*declara, crea*/ /*Tirar un dado 6000 veces; usar el valor del dao como indice de frecuencia*/ for(int tiro=1;tiro<=6000;tiro++) ++frecuencia[1+(int)(Math.random()*6)]; String salida ="Cara\tFrecuencia"; /*anexar frecuencias al String salida*/ for(int cara=1;cara<frecuencia.length;cara++) salida+="\n"+cara+"\t"+frecuencia[cara]; System.out.println(salida); } }




EJERCICIO 281 SE PIDIÓ A 40 ESTUDIANTES QUE CALIFICARAN LA CALIDAD DE LA COMIDA EN LA CAFETERÍA EN UNA ESCALA DEL 1 AL 10(EN DONDE EL UNO SIGINIFICA PÉSIMO Y EL 10 EXCELENTE). COLOQUE LAS 40 RESPUESTAS EN UN ARREGLO ENTERO Y SINTETICE LOS RESULTADOS DE LA ENCUESTA. import java.io.*; import java.lang.*; class Arreglo7{ public static void main(String arg[]) throws IOException{ int respuestas[]= {1,2,6,4,8,5,9,7,8,10,1,6,3,8,6,10,3,8,2,7,6,5,7,6, 8,6,7,5,6,6,5,6,7,6,5,4,8,6,8,10}; int frecuencia[]=new int[11]; /* para cada respuesta, seleccionar el elemento de respuestas y usar ese valor como indice en frecuencia para determinar elemento a incrementar*/ /*Tirar un dado 6000 veces; usar el valor del dao como indice de frecuencia*/ for(int respuesta=1;respuesta<respuestas.length;respuesta++) ++frecuencia[respuestas[respuesta]]; String salida ="Calificacion\tFrecuencia\n"; /*anexar frecuencias al String salida*/ for(int calificacion=1;calificacion<frecuencia.length;calificacion++) salida+=calificacion+"\t\t"+frecuencia[calificacion]+"\n"; System.out.println(salida); } }




EJERCICIO 282 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA OBTENER LA VARIANZA, LA MEDIANA, EL PROMEDIO Y QUE ORDENE LOS ELEMNTOS DEL ARREGLO. import java.io.*; public class Estadistica { double a[]; /* Constructor */ public Estadistica(double arr[]) { if (arr.length > 0) { a = new double[arr.length]; for(int i = 0; i < a.length; i++) { a[i] = arr[i]; } } } private void ordenar() { double tmp; int i,k;




/* algoritmo de la burbuja */ for(k = 0; k < a.length; k++) for(i = 0; i < a.length - 1 ; i++) { if (a[i] > a[i+1]) { /* intercambio de posicion */ tmp = a[i]; a[i] = a[i+1]; a[i+1] = tmp; } } } public void verArreglo() { System.out.print("Arreglo : "); for (int i = 0; i < a.length; i++) System.out.print(a[i] + " "); System.out.println(); } /* retorna la mediana en funcion de la paridad del numero de elementos. Los ordena previamente */ public double mediana() { ordenar(); if (a.length % 2 == 0) { return (a[(a.length / 2) - 1] + a[a.length / 2]) / 2.0; } else { return a[(a.length - 1) / 2]; }




} public static double promedio(double arr[]) { double sum = 0.0; for(int i = 0; i < arr.length; i++) { sum += arr[i]; } /* realiza un cast o conversion de tipo a la variable arr.length */ return sum / (double) arr.length; } public static double varianza(double arr[]) { double prom = promedio(arr); double sum = 0.0; for(int i = 0; i < arr.length; i++) { sum += Math.pow(arr[i] - prom,2); } return sum / arr.length; } public static void main(String args[]) throws IOException { BufferedReader in = new BufferedReader( new InputStreamReader(System.in)); int seguir = 1;




int numDatos; double arreglo[]; while(seguir == 1) { System.out.print("Cantidad de datos a ingresar : "); numDatos = Integer.parseInt(in.readLine()); if (numDatos > 0) { arreglo = new double[numDatos]; for(int i = 0; i < numDatos; i++) { System.out.print("A[" + i + "] : "); arreglo[i] = Double.parseDouble(in.readLine()); } /* Crea instancia de clase u objeto */ Estadistica e = new Estadistica(arreglo); System.out.println("Mediana : " + e.mediana()); e.verArreglo(); /* accesa metodos estáticos que no necesitan instancia */ System.out.println("Promedio : " + Estadistica.promedio(arreglo)); System.out.println("Varianza : " + Estadistica.varianza(arreglo)); } else { System.out.println("Se necesita una cantidad de datos mayor que cero"); } System.out.print("\nSalir(0) , Seguir(1) : "); seguir = Integer.parseInt(in.readLine()); } // fin while } // fin main




} // fin class

EJERCICIO 283 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA MOSTRAR LOS ELEMENTOS DE UN ARREGLO Y QUE DESPUÉS PERMITA REEMPLAZAR EL ÚLTIMO VALOR INGRESADO ENE LE ARREGLO. import java.io.*; class Invertir { public static void main(String arg[]) throws IOException { BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); System.out.print("Ingrese numero de elementos : "); int n = Integer.parseInt(in.readLine()); int a[] = new int[n]; /* lectura del arreglo por teclado */ int i; for(i = 0; i < a.length; i++) { System.out.print("Ingrese elemento " + (i + 1) + " : "); a[i] = Integer.parseInt(in.readLine()); } System.out.print("Arreglo ingresado : ");




for(i = 0; i < a.length; i++) System.out.print(a[i] + "\t"); System.out.print("\nIngrese elemento a insertar : "); int x = Integer.parseInt(in.readLine()); int tmp; i = 0; while(a[i] < x) i++; /* se busca posicion i a insertar */ while(i < a.length) { tmp = a[i]; /* se guarda lo que que hay en posicion i */ a[i] = x; /* se asigna el elemento a insertar x a la posicion i */ x = tmp; /* el nuevo elemento a insertar es tmp */ i++; /* como x tiene que insertarse en la siguiente posicion se incrementa el indice */ } System.out.print("Arreglo final : "); for(i = 0; i < a.length; i++) System.out.print (a[i] + "\t"); System.out.println(); } }

EJERCICIO 284 REALIZAR UN PROGRAMA EN JAQ UE PERMITA MOSTRAR POR PANTALLA LA SUMA DE LAS FILAS DEL UNA MATRIZ DE 4x4. import java.io.*;




import java.lang.*; public class fabrica { public static void main ( String args[] ) throws IOException { BufferedReader max = new BufferedReader ( new InputStreamReader (System.in)); int auto[][] = new int[5][5]; float v[] = new float[5]; float suma_v; int cantidad[] = new int[5]; int suma_cantidad, i,j; // porcentajes de cada centro float x[] = new float[5]; float y[] = new float[5]; float z[] = new float[5]; float w[] = new float[5]; System.out.println("Ingreso de los valores: "); for( i=0; i<4; i++) for (j=0; j<4; j++) { System.out.print("Centro "+(i+1)+" Modelo "+(j+1)+"..: "); auto[i][j]=Integer.parseInt(max.readLine()); } cantidad[1]=0; cantidad[2]=0; cantidad[3]=0; cantidad[4]=0; for( i=0; i<4; i++) for (j=0; j<4; j++) cantidad[i] = cantidad[i] + auto[i][j]; for( i=0; i<4; i++) { for (j=0; j<4; j++) { System.out.print(auto[i][j]+" "); }; System.out.println(cantidad[i]); } }




}

El ejemplo java403.java, intenta ilustrar un aspecto interesante del uso de arrays en Java. Se trata de que Java puede crear arrays multidimensionales, que se verían como arrays de arrays. Aunque esta es una característica común a muchos lenguajes de programación, en Java, sin embargo, los arrays secundarios no necesitan ser todos del mismo tamaño. En el ejemplo, se declara e instancia un array de enteros, de dos dimensiones, con un tamaño inicial (tamaño de la primera dimensión) de 3. Los tamaños de las dimensiones secundarias (tamaño de cada uno de los subarrays) es 2, 3 y 4, respectivamente. En este ejemplo, también se pueden observar alguna otra cosa, como es el hecho de que cuando se declara un array de dos dimensiones, no es necesario indicar el tamaño de la dimensión secundaria a la hora de la declaración del array, sino que puede declararse posteriormente el tamaño de cada uno de los subarrays. También se puede observar el resultado de acceder a elementos que se encuentran fuera de los límites del array; Java protege la aplicación contra este tipo de errores de programación. EJERCICIO 285 /** * Ejemplo para ilustrar la creación y manipulación de un array de dos * dimensiones en donde los subarrays tienen diferente tamaño */ class java403 { public static void main( String args[] ) { // Declaramos un array de dos dimensiones con un tamaño de 3 en la // primera dimensión y diferentes tamaños en la segunda




int miArray[][] = new int[3][]; // No especificamos el tamaño de la // segunda dimensión miArray[0] = new int[2]; // El tamaño de la segunda dimensión es 2 miArray[1] = new int[3]; // El tamaño de la segunda dimensión es 3 miArray[2] = new int[4]; // El tamaño de la segunda dimensión es 4 // Rellenamos el array con datos for( int i=0; i < 3; i++ ) { for( int j=0; j < miArray[i].length; j++ ) miArray[i][j] = i * j; } // Visualizamos los datos que contiene el array for( int i=0; i < 3; i++ ) { for( int j=0; j < miArray[i].length; j++ ) System.out.println( miArray[i][j] ); System.out.println(); } // Hacemos un intento de acceder a un elemento que se encuentre // fuera de los límites del array System.out.println( "Acceso a un elemento fuera de limites" ); miArray[4][0] = 7; // Esa sentencia originará el lanzamiento de una excepción de // tipo ArrayIndexOutOfBounds } }

PASAR ARREGLOS A MÉTODOS Para pasar un arreglo como argumento a un método, se especifica el nombre del arreglo sin corchetes. Por ejemplo, si el arreglo temperaturaPorHora se declara como:




int temperaturaPorHora[]=new int [24]; Entoces la llamada al método: modificarArreglo(temperaturaPorHora); Pasa al método modificarArreglo una referencia al arreglo temperaturaPorHora. EJERCICIO 286 EN ÉSTE EJEMPLO DEMOSTRAREMOS COMO PASAR ARREGLOS Y ELEMENTOS DE ARREGLOS COMO ARGUMENTOS PARA LOS MÉTODOS. /*Paso de arreglos y elementos individuales de un arreglo a metodos */ import java.io.*; import java.lang.*; class Arreglo7{ public static void main(String arg[]) throws IOException{ int arreglo[]= {1,2,3,4,5}; int frecuencia[]=new int[11]; String salida ="Efectos de pasar el arreglo completo por referencia:\n"+ "Los valores del arreglo original son:\n"; /*anexar los elementos del arreglo original al String salida */ for(int contador=0;contador<arreglo.length;contador++) salida += " "+arreglo[contador]; modificarArreglo(arreglo);/*arreglo pasado por referencia*/ salida+="\n\nLos valores del arreglo modoficado son:\n"; /*anexar los elementos del arreglo modificado al String salida */ for(int contador=0;contador<arreglo.length;contador++) salida+=" "+arreglo[contador]; salida+="\n\nEfectos de pasar el elemento de un arreglo por valor \n"+ "arreglo[3] antes de modificarElemento:" +arreglo[3]; modificarElemento(arreglo[3]);/*intento de modificar arreglo[3]*/ salida+="\narreglo[3] despues de modificarElemento:"+arreglo[3]; System.out.println(salida); }




/*Multiplicar cada elemento de un arreglo por 2 */ public static void modificarArreglo(int arreglo2[]){ for(int contador=0; contador<arreglo2.length;contador++) arreglo2[contador]*=2; } /*Multiplicar argumento por 2*/ public static void modificarElemento(int elemento){ elemento*=2; } }

ORDENAMIENTO DE ARREGLOS MÉTODO BURBUJA EJERCICIO 287 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA ORDENAR LOS ELEMNTOS DE UN ARREGLO EN FORMA ASCENDENTE. import java.io.*; import java.lang.*; class Arreglo9{ public static void main(String arg[]) throws IOException{ int arreglo[]= {2,6,4,8,10,12,89,68,45,37}; int frecuencia[]=new int[11];




String salida ="Elementos de datos en su orden original\n"; /*anexar los valores originales al String salida */ for(int contador=0;contador<arreglo.length;contador++) salida += " "+arreglo[contador]; ordenamBurbuja(arreglo); salida+="\n\nElementos de datos en orden ascendente \n"; /*anexar los valores ordenados del arreglo al String salida */ for(int contador=0;contador<arreglo.length;contador++) salida+=" "+arreglo[contador]; System.out.println(salida); } /*Ordenar elementos del arreglo con el Método Burbuja */ public static void ordenamBurbuja(int arreglo2[]){ /*Ciclo para controlar número de pasadas */ for(int pasada=1; pasada<arreglo2.length;pasada++){ /*Ciclo para controlar número de comparaciones*/ for(int elemento=0; elemento<arreglo2.length-1;elemento++){ /*Comparar elementos uno a uno e intercambiarlos si el primer elemento es mayor que el segundo */ if(arreglo2[elemento]>arreglo2[elemento+1]) intercambiar(arreglo2,elemento,elemento+1); }/*Fin del ciclo para controlar las comparaciones*/ }/*Fin del ciclo para controlar las pasadas*/ } /*Intercambiar dos elementos de un arreglo*/ public static void intercambiar(int arreglo3[], int primero, int segundo){ int almacen; /*Area temporal de almacenamiento para intercambiar */ almacen= arreglo3[primero]; arreglo3[primero]=arreglo3[segundo]; arreglo3[segundo]=almacen; } }




MATRICES EJERCICIO 288 EN ÉSTE EJEMPLO SE DEMUSTRA COMO INICIALIZAR ARREGLOS BIDIMENSIONALES O MATRICES CON INICIALIZADORES DE ARREGLOS, Y COMO UTILIZAR CICLOS FOR ANIDADOS PAR RECORRER LOS ARREGLOS, ES DECIR MANIPULAR CADA ELEMNTO DE LOS ELEMENTOS DE LOS ARREGLOS. import java.io.*; import java.lang.*; class Matriz1{ public static void main(String arg[]) throws IOException{ int arreglo1[][]={{1,2,3},{4,5,6}}; int arreglo2[][]={{1,2},{3},{4,5,6}}; System.out.println("Los valores en arreglo1 por fila son\n"); crearSalida(arreglo1); System.out.println("\nLos valores en arreglo2 por fila son\n"); crearSalida(arreglo2); } /*Anexar filas y columnas de un arreglo*/ public static void crearSalida(int arreglo[][]){ /*Iterar a través de las columnas de la fila actual*/ for(int fila=0; fila<arreglo.length;fila++){ /*Iterar a través de las columnas de la fila actual*/ for(int columna=0; columna<arreglo[fila].length;columna++) System.out.println(arreglo[fila][columna]+" "); System.out.println("\n"); } }




}

APPLETS EN JAVA

Creación de un Applet Los applets se ejecutan a traves de una pagina web, es decir, se debe crear un archivo .java y luego un archivo .htm o.html. Luego se debe compilar el .java y se debe crear un archivo con el bloc de notas y se lo debe guardar .html así: <html> <applet code="NombredelPrograma.class" width="300" height="45"> </applet> </html FORMA COMPLETA <HTML> <HEAD> <TITLE> Un applet de Java </TITLE> </HEAD> <BODY> Aquí está la salida de mi programa: <APPLET CODE="NombreDelPrograma.class" WIDTH=150 HEIGHT=25> </APPLET> </BODY> </HTML>

Llamando la página con el applet:




Busque la página web que acaba de hacer y ábrala dando doble clic. Anatomía del Applet de Java Ahora que su applet de Java se ha ejecutado, se estará preguntando cómo funciona. Recuerde que un applet de Java es un programa que se adhiere a un conjunto de convenciones que le permiten correr a través de un navegador compatible. Importando las clases y paquetes Las primeras dos líneas importan dos clases usadas en este applet: Applet y Graphics. import java.applet.Applet; import java.awt.Graphics; public class miapplet extends Applet { public void paint(Graphics g){ g.drawString("Hola tu", 50, 25); } } Para entender esas líneas vamos a hablar de qué pasaría si no estuvieran. Si se quitaran esas primeras dos líneas, el applet podría también ejecutarse, pero solo si cambia el llamado a las clases de la siguiente forma: public class miapplet extends java.applet.Applet { public void paint(java.awt.Graphics g){ g.drawString("Hola tu", 50, 25); } } Como se puede ver al importar las clases Applet y Graphics el programa le permite llamarlas sin todo el prefijo (p.e. java.applet.Applet). Los prefijos le dicen al compilador cuales paquetes debería buscar para encontrar las clases Applet y Graphics. Ambos java.applet y java.awt son parte del API de java - El API es el conjutno de programas de java con que se puede contar en el ambiente. El paquete java.applet contiene clases que son esenciales para los applets de java. El paquete java.awt contiene las clases más frecuentemente usadas en el Abstract Window Toolkit (AWT), que permite a Java tener una Interfaz gráfica (GUI) como los programas de Windows. Además de importar clases individuales, usted puede importar el paquete entero. A continuación un ejemplo que funciona también: import java.applet.*; import java.awt.*; public class miapplet extends Applet { public void paint(Graphics g){ g.drawString("Hola tu", 50, 25); }




} En el Lenguaje Java, todas las clases están en un paquete o package. Si el código fuente para una clase no tiene una importación entonces la clase debe pertenecer al grupo por defecto de Java. Dentro del mismo paquete, todas las clases pueden referirse a las otras sin prefijos. Vea una lista de todos los paquetes disponibles en packages.html Definiendo una subclase de Applet La primera línea en negrilla del código que está a continuación define la clase miapplet: import java.applet.Applet; import java.awt.Graphics; public class miapplet extends Applet { public void paint(Graphics g){ g.drawString("Hola tu", 50, 25); } } La palabra extends indica que miapplet es una subclase de la clase nombrada a continuación: Applet. Subclase significa que es un derivado de una clase anterior. A partir de la clase Applet, los applets heredan una gran cantidad de funcionalidad. Quizás lo más importante es la habilidad de responder a peticiones del navegador de Internet. Por ejemplo, un navegador capaz de manejar Java carga una página que contiene un applet, el navegador envía una petición al applet, diciendole que se inicialice y comience a ejecutarse. Un applet no está restingido a definir solo una clase. Además de la subclase de Applet, un applet puede definir clases adicionales creadas por el programador. Cuando el applet intenta usar una clase, la aplicación que está ejecutandose primero mira en el host local. Si la clase no está disponible localmente, es cargada desde una localización de donde viene la subclase del Applet. Implementando los métodos del Applet Las líneas en negrilla del código implementan el método paint. import java.applet.Applet; import java.awt.Graphics; public class miapplet extends Applet { public void paint(Graphics g){ g.drawString("Hola tu", 50, 25); } } Todos los applets deben implementar uno o más de los métodos init, start, y paint.

http://www.altatorre.com/webclase/java/api/packages.html




Además de los métodos init, start, y paint, los applets pueden implementar dos métodos más que el browser llama cuando un evento importante ocurre (tal como salir de la página del applet): stop y destroy. Los Applets pueden implementar cualquier número de otros métodos, también. En el programa que hicimos el objeto Graphics pasado dentro del método paint representa el contexto de dibujo en pantalla del applet. El primer argumento para el método drawString de Graphics es la cadena para dibujar en pantalla. El segundo y tercer parámetro son la posición (x,y) de la esquina izquierda del texto en pantalla. g.drawString("Hola tu", 50, 25); Esta instrucción entonces dibuja la cadena "Hola tu" comenzando en la posición (50,25). El sistema de coordenadas comienza en (0,0), que está en la esquina superior izquierda del área de despliegue del applet. EJERCICIO 289 REALIZAR UN PROGRAMA EN JAVA QUE PRESENTE UN MENSAJE UTILIZANDO UN APPLET. import java.awt.Graphics; import javax.swing.JApplet; public class SubprogramaBienvenido extends JApplet{ public void paint(Graphics g){ super.paint(g); g.drawString("Bienvenido a la Programacion en Java",25,25); } } CÓDIGO ESCRITO EN UN BLOC DE NOTAS, PERO SE LO GUARDA CON EXTENSIÓN .HTML. PARA ESTE EJEMPLO SE LO GUARDÓ COMO: SUBPROGRAMABIENVENIDO.HTML. EL JAVA .CLASS Y EL .HTML DEBEN ESTAR EN EL MISMO DIRECTORIO PARA PODER EJECUTAR. CUANDO SE GUARDA COMO HTML EL ARCHIVO DE TEXTO SE TRANSFORMA COMO EN UNA PÁGINA WEB. DOCUMENTO HTML PARA CARGAR ESTE APPLET EN UN CONTENEDOR DE APPLETS. <html> <applet code="SubprogramaBienvenido.class" width="300" height="45"> </applet> </html>




EJERCICIO 290 REALIZAR UN APPLET EN JAVA PARA MOSTRAR VARIAS LÍNEAS DE TEXTO. import java.awt.Graphics; import javax.swing.JApplet; public class SubprogramaBienvenido2 extends JApplet{ public void paint(Graphics g){ super.paint(g); /*Dibujar 2 valores String en diferentes ubicaciones*/ g.drawString("Bienvenido a ",25,25); g.drawString("la Programacion en Java",25,40); } } DOCUMENTO HTML PARA CARGAR ESTE APPLET EN UN CONTENEDOR DE APPLETS. <html> <applet code="SubprogramaBienvenido2.class" width="300" height="60"> </applet> </html>




EJERCICIO 291 REALIZAR UN APPLET EN JAVA QUE DIBUJE 2 LÍNEAS Y UNA CADENA DE TEXTO. import java.awt.Graphics; import javax.swing.JApplet; public class LineasBienvenido extends JApplet{ /*Dibujar lineas y una cadena en el fondo del applet*/ public void paint(Graphics g){ super.paint(g); /*Dibujar una linea horizontal, desde (15,10)hasta(250,10) */ g.drawLine(15,10,250,10); /*Dibujar una linea horizontal desde (15,30) hasta (250,30) */ g.drawLine(15,30,250,30); /*Dibujar String entre líneas en la ubicación (25,25)*/ g.drawString("!Bienvenido a la Programacion en Java!",25,25); } } DOCUMENTO HTML PARA CARGAR ESTE APPLET EN UN CONTENEDOR DE APPLETS. <html> <applet code="LineasBienvenido.class" width="300" height="40"> </applet> </html>




EJERCICIO 292 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA SUMAR DOS NÚMEROS DE COMA FLOTANTE Y QUE MUESTRE POR PANTALLA EL RESULTADO UTILIZANDO UN APPLET. import java.awt.Graphics; import javax.swing.*; public class SubprogramaSuma extends JApplet{ double suma;/*La suma de los valores introducidos por teclado*/ /*Inicializar el applet, obteniendo los valores del usuario*/ public void init(){ String primerNumero;/*Primera cadena introducida por el usuario*/ String segundoNumero;/*Segunda cadena introducida por el usuario*/ double numero1;/*Primer número a sumar*/ double numero2;/*Segundo número a sumar*/ /*Obtener el primer número del usuario*/ primerNumero=JOptionPane.showInputDialog("Escriba el primer valor de punto flotante:"); /*Obtener el segundo número del usuario*/ segundoNumero=JOptionPane.showInputDialog("Escriba el segundo valor de punto flotante:"); /*Escribir los números de tipo String a tipo double*/ numero1=Double.parseDouble(primerNumero); numero2=Double.parseDouble(segundoNumero); /*Sumar los números*/ suma=numero1+numero2; }




/*Dibujar los resultados en un rectángulo en el fondo del applet*/ public void paint(Graphics g){ /*Llamar a la versión del método paint de la superclase*/ super.paint(g); /*Dibujar un rectángulo, empezando desde (15,10), que tenga 270 pixeles de ancho y 20 pixeles de alto*/ g.drawRect(15,10,270,20); /*Dibujar los resultados como String en (25,25) */ g.drawString("La suma es:"+suma,25,25); } }

EJERCICIO 293 ESTE APPLET DIBUJA 10 LÍNEAS DESDE EL MÉTODO PAINT.




import java.awt.*; import javax.swing.JApplet; public class ContadorWhile extends JApplet{ public void paint(Graphics g){ super.paint(g); int contador=1; while (contador<=10){ g.drawLine(10,10,250, contador * 10); ++contador; } } }

VARIOS EJERCICIO 294




REALIZAR UN PROGRAMA EN JAVA QUE PERMITA CALCULAR EL FACTORILA DE UN NÚMERO. FACTORIAL DE 5=1*2*3*4*5=120 import java.io.*; import java.lang.*; class Factorialn { public static void main(String[]args) throws IOException { int numero; double factorial=1; BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in)); String cadenaLeida = null; System.out.println("De que numero entero decea calcular el factorial?"); cadenaLeida = entrada.readLine(); try{ numero = Integer.parseInt(cadenaLeida); if(numero<0){ System.out.println("No existe el factorial de numeros negativos "); return; } System.out.print("El factorial de "+numero+" es: "); while(numero>0){ factorial*=numero--; } System.out.println(factorial); } catch(NumberFormatException e){ System.out.println("el argumento que se resibio no es un numero entero"); } } }




EJERCICIO 295 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA OBTENER EL VOLUMEN DE UN TETRAEDRO. import java.io.*; import java.lang.*; class VolumenTetraedroEntradaEstandarApli { public static void main(String[] args) throws IOException { //declaramos las variables necesarias y asignamos valores a los datos de entrada del algoritmo double longitudArista; double volumenTetraedro; //podria asignarle el valor de cero se se desea //construimos los objetos que toman la informacion de la entrada estandar InputStreamReader lectorEntrada = new InputStreamReader(System.in); BufferedReader entrada = new BufferedReader(lectorEntrada); String cadenaLeida = null; //leemos los datos desde la entrada estandar y convertimos la cadena obtenida en su //valor numerico System.out.println("Cual es la longitud de la arista del tetraedro?"); cadenaLeida = entrada.readLine(); longitudArista = Double.parseDouble(cadenaLeida); volumenTetraedro = Math.pow(longitudArista,3)*0.1178; System.out.println("El volumen de un tetraedro con aristas de longitud "); System.out.print(longitudArista + " unidades es igual a "); System.out.println(volumenTetraedro + " unidades.");




} }

EJERCICIO 296 EJEMPLO BÁSICO DEL USO DE JAVA PARA DIBUJO. import java.awt.*; import java.awt.event.*; class j002 extends Frame { public j002() { setTitle("Dos Circunferencias.\n"); } public static void main(String[]args) { Frame f=new j002(); f.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); f.setSize(300,200); f.setVisible(true); } public void paint(Graphics g) { g.setColor(Color.red); g.drawOval(10,30,50,50); g.setColor(Color.blue); g.drawOval(60,30,50,50); g.drawString("Dos Circunferencias.",40,100); } }




EJERCICIO 297 Muestra un programa para dibujar dos elipses. //dibuja 2 elipses import java.awt.*; import java.awt.event.*; class j009 extends Frame { public j009() { setTitle("Dos Elipses"); } public static void main(String [] args) { Frame f=new j009(); f.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); f.setSize(300,200); f.setVisible(true); } public void paint(Graphics g){ g.setColor(Color.green); g.drawOval(10,30,250,150); g.setColor(Color.yellow); g.drawOval(40,55,200,125); g.setColor(Color.black); g.drawString("Dos Elipses",100,100); } }




EJERCICIO 298 Un ejemplo de dibujo diferente en java. import java.awt.*; import java.awt.event.*; class j10 extends Frame { public j10() { setTitle("Dibujito"); } public static void main(String [] args) { Frame f=new j10(); f.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); f.setSize(300,300); f.setVisible(true); } public void paint(Graphics g) { g.drawOval(80,100,150,150); g.drawOval(80,100,30,30); g.drawOval(130,50,50,50); g.drawOval(200,100,30,30); g.drawOval(140,60,5,5); g.drawOval(160,60,5,5); g.drawOval(150,75,10,3); } }




MANEJO DE ARCHIVOS EJERCICIO 299 REALIZAR UN PROGRAMA EN JAVA QUE OBTENGA: LA SUMA DE TODOS LOS NÚMEROS DE UN ARCHIVO LA SUMA DE LOS MÚLTIPLOS DE 4: 4,8,12,16… package Deberes10.Ejercicio1; import java.io.*; import java.awt.*; public class Ventana1 extends Frame{ Label lblImpares,lblSuma,lblSu,lblImpares2,lblSuma2,lblSu2;




Button btnSumar,btnSalir; List lstImpar,lstImpar2; double suma=0.0,s=0; void Sumar(){ try{ java.io.RandomAccessFile archivo=new RandomAccessFile("C:\\Numeros.txt","rw"); archivo.seek(0); while(true){ lblSu.setText(""); String linea = archivo.readLine(); if (linea ==null) break; s=s+Double.parseDouble(linea); double a= Double.parseDouble(linea); if((a % 4)==0) suma =suma+a; } archivo.close(); lblSu.setText(""); lblSu2.setText(""); lblSu2.setText(String.valueOf(s)); lblSu.setText(String.valueOf(suma)); s=0; suma=0; } catch(Throwable e){ javax.swing.JOptionPane.showMessageDialog(null,e); } } void mostrarImpares(){ try{ RandomAccessFile archivo= new RandomAccessFile("C:\\Numeros.txt","rw"); archivo.seek(0); while(true){ String linea= archivo.readLine(); if(linea==null) break;




lstImpar.add(linea); } archivo.close(); } catch(Throwable e){ javax.swing.JOptionPane.showMessageDialog(null,e); } } void mostrarImpares2(){ try{ RandomAccessFile archivo= new RandomAccessFile("C:\\Numeros.txt","rw"); archivo.seek(111); while(true){ String linea= archivo.readLine(); if(linea==null) break; lstImpar2.add(linea); linea= archivo.readLine(); } archivo.close(); } catch(Throwable e){ javax.swing.JOptionPane.showMessageDialog(null,e); } } public Ventana1() { setLayout(new GridLayout(5,2)); add(lblImpares= new Label("Lista de Números")); add(lstImpar= new List()); add(lblImpares2= new Label("Impares mayores a 30")); add(lstImpar2= new List()); add(lblSuma2= new Label("Suma Total")); add(lblSu2= new Label()); add(lblSuma= new Label("Suma Múltiplos de 4")); add(lblSu= new Label()); add(btnSumar=new Button("Sumar")); add(btnSalir=new Button("Salir")); mostrarImpares(); mostrarImpares2(); setSize(300,300);




setTitle("Ventana"); show(); } public boolean action(Event evt,Object ar){ if(evt.target instanceof Button){ if(evt.target == btnSalir) System.exit(0); if(evt.target==btnSumar) { Sumar(); } return true; } return false; } public static void main(String arg[]){ new Ventana1(); }

EL ARCHIVO ESTÁ EN EL DISCO LOCAL C://, ESTO SE PUEDE MODIFICAR YA QUE EL ARCHIVCO PUEDE ESTAR EN CUALQUIER LUGAR, PERO SE TANDRÁ QUE ESPECIFICAR EN EL PROGRAMA.




archivo.seek(0); Busca el archive hasta la última línea, es lo mismo decir hasta dónde se encuantre el cursor o al final del archivo. RandomAccessFile archive Ésta línea permite acceder al archive de manera aleatoria, para realizar algún cálculo o el manejo de los datos según lo determine el programador. archivo.readLine(); Lee cada línea del archivo. EJERCICIO 300 REALIZAR UN PROGRAMA EN JAVA QUE PERMITE CALCULAR EL TOTAL DE VENTAS POR VENDEDOR, ASÍ MISMO SE LE DARÁ UN RECONOCIMIENTO AL EMPLEADO QUE HAYA REALIZADO MÁS VENTAS PAR ESTO SE NECESITA MOSTRAR AL EMPLEADO CON MAYOR VENTAS Y EL NÚMERO DE VENTAS REALIZADO POR EL EMPLEADO GANADOR. TAMBIÉN OBTENER EL PROMEDIO DE VENTA DE LOS EMPLEADOS. package Deberes10.Ejercicio2; import java.io.*; import java.awt.*; public class Ventana1 extends Frame{ Button btnSumar,btnPromedio,btnSalir,btnMejor,btnCon; TextField txtResultado,txtEmpleado,txtVen1; Label lblEmpleados,lblResultado,lblRe,lblPr,lblPr1; TextField txtEm; Label lblEmpleado,lblPromedio,lbl1,lblVentas,lblVenta,lblVen; List lstEmpleados; Choice Cventas; double suma=0.0,sum=0.0; int cont=0; String mejor,b,c; double promedio=0,prom=0.0; double[] em=new double[3]; double [] a= new double[1]; double cont1;




void mostrarEmpleados(){ try{ RandomAccessFile archivo= new RandomAccessFile("C:\\Vendedor.txt","rw"); archivo.seek(0); while(true){ String linea= archivo.readLine(); if(linea==null) break; lstEmpleados.add(linea); } archivo.close(); } catch(Throwable e){ javax.swing.JOptionPane.showMessageDialog(null,e); } } void Sumar1(){ try{ RandomAccessFile archivo=new RandomAccessFile("C:\\Ventas.txt","rw"); archivo.seek(0); while(true){ archivo.readLine(); String linea = archivo.readLine(); if (linea ==null){ break; } double valor=Double.parseDouble(linea); suma +=valor; cont++; } lblRe.setText(String.valueOf (suma)); archivo.close(); javax.swing.JOptionPane.showMessageDialog(null,"Suma resultado"); } catch(Throwable e){ javax.swing.JOptionPane.showMessageDialog(null,e); } }




//***********PROMEDIO DE LOS EMPLEADOS********************************************************// void Sumar2(){ try{ RandomAccessFile archivo=new RandomAccessFile("C:\\Ventas.txt","rw"); archivo.seek(0); lblPr1.setText(""); while(true){ String linea = archivo.readLine(); if (linea ==null){ break; } b= txtVen1.getText(); if(linea.equals(b)){ linea = archivo.readLine(); double val=Double.parseDouble(linea); sum +=val; cont++; linea = archivo.readLine(); linea = archivo.readLine(); } linea = archivo.readLine(); } prom=sum/cont; lblPr1.setText(String.valueOf (prom)); sum=0.0; cont=0; prom=0.0; archivo.close(); javax.swing.JOptionPane.showMessageDialog(null,"Suma resultado"); } catch(Throwable e){ javax.swing.JOptionPane.showMessageDialog(null,e); } } //**************************************************************/ void Promedio(){ try{ promedio=suma/cont; lblPromedio.setText(String.valueOf(promedio)); } catch(Throwable e){




javax.swing.JOptionPane.showMessageDialog(null,""+promedio); } } //**************************************************** void Mejor(){ double suma=0.0; em[0]=0; em[1]=0; em[2]=0; try{ RandomAccessFile archivo=new RandomAccessFile("C:\\Ventas.txt","rw"); archivo.seek(0); String linea1="",linea2=""; while(true){ linea1=archivo.readLine(); if(linea1==null){ break; } linea2=archivo.readLine(); if(linea1.equals("CARLOS")){ em[0]=em[0]+ Double.parseDouble(linea2); } if(linea1.equals("PEDRO")){ em[1]=em[1]+ Double.parseDouble(linea2); } if(linea1.equals("JOSE")){ em[2]=em[2]+ Double.parseDouble(linea2); cont1++; } } if(em[0] >= em[1]){ if(em[0] >= em[2]) mejor="CARLOS"; else mejor="JOSE"; } else{ if(em[1] >= em[2] ) mejor="PEDRO"; else




mejor="JOSE"; } javax.swing.JOptionPane.showMessageDialog(null,"CARLOS "+em[0]+" PEDRO "+em[1]+" JOSE "+em[2]); this.txtEmpleado.setText(mejor); } catch(Throwable e){ javax.swing.JOptionPane.showMessageDialog(null,e); } } void Mejor1(){ em[0]=0; em[1]=0; em[2]=0; try{ RandomAccessFile archivo=new RandomAccessFile("C:\\Ventas.txt","rw"); archivo.seek(0); String linea1="",linea2=""; while(true){ linea1=archivo.readLine(); if(linea1==null){ break; } if(linea1.equals("JOSE")){ em[2]=em[2]+ Double.parseDouble(linea2); } } javax.swing.JOptionPane.showMessageDialog(null," JOSE "+em[2]); } catch(Throwable e){ } } public Ventana1(){ setTitle("Ventas"); this.setLayout(new GridLayout(10,2)); add(lblEmpleados=new Label("Lista de Empleados")); add(lstEmpleados=new List());




add(lblVen=new Label("Nombre del Vendedor")); add(txtVen1=new TextField()); add(lblResultado=new Label("Total de Ventas")); add(lblRe=new Label()); add(lbl1=new Label("Promedio total de Ventas")); add(lblPromedio=new Label()); add(lblEmpleado=new Label("Mejor empleado")); add(txtEmpleado=new TextField()); add(lblVentas=new Label(" N. de Ventas del Mejor Empleado")); add(lblVenta=new Label()); add(lblPr=new Label(" Promedio de los empleados")); add(lblPr1=new Label()); add(btnSumar=new Button("Sumar")); add(btnPromedio=new Button("Promedio")); add(btnCon=new Button("Consultar")); add(btnMejor=new Button("Mejor Empleado")); add(btnSalir=new Button("Salir")); mostrarEmpleados(); setSize(430,400); show(); } public boolean action(Event evt, Object ar){ if(evt.target instanceof Button){ if(evt.target==btnSalir) System.exit(0); if(evt.target==btnSumar){ Sumar1(); btnSumar.disable();} if(evt.target==btnPromedio) Promedio(); if(evt.target==btnCon) Sumar2(); if(evt.target==btnMejor) Mejor(); return true; } return false; } public static void main(String arg[]){




new Ventana1(); } }

EJERCICIO 301 REALIZAR UN PROGRAMA EN JAVA QUE SÓLO PERMITA EL INGRESO DE LO SIGUIENTE:




La vivienda son de tipo A,B,C yel trabajo también se divide por clases A,B Y C. package Deberes10.Ejercicio3.Interfaz1; import java.io.*; import java.awt.*; public class Seguro1 extends Frame{ Label lblNombres,lblApellidos,lblEdad,lblValor,lblPorcentaje,lblPor,lblTipo,txtTi,lblVi,lblVivienda,lblTrabajo; TextField txtNom,txtApe,txtEd,txtVa; Button btnGuardar,btnSalir,btnAdicional,btnTipo; Choice chcTipo,chcTra; double valor,r,rr; String a,b; String idVivie(String Vivie){ try{ RandomAccessFile archivo= new RandomAccessFile("c:\\Vivie.txt","rw"); archivo.seek(0); while(true){ String linea= archivo.readLine(); if (linea==null) break; if (Vivie. equals (linea)){ archivo.close(); return linea; } } archivo.close(); }




catch (Throwable e){ javax.swing.JOptionPane.showMessageDialog(null, e); } return ""; } String idTraba(String Tra){ try{ RandomAccessFile archivo= new RandomAccessFile("c:\\Vivie.txt","rw"); archivo.seek(0); while(true){ String linea= archivo.readLine(); if (linea==null) break; if (Tra. equals (linea)){ archivo.close(); return linea; } } archivo.close(); } catch (Throwable e){ javax.swing.JOptionPane.showMessageDialog(null, e); } return ""; } void CargarTipo(){ try{ RandomAccessFile archivo= new RandomAccessFile("c:\\Vivie.txt","rw"); archivo.seek(0); while(true){ String linea= archivo.readLine(); if (linea==null) break; chcTipo.add(linea); }




} catch (Throwable e){ javax.swing.JOptionPane.showMessageDialog(null, e); } } void CargarTipo1(){ try{ RandomAccessFile archivo= new RandomAccessFile("c:\\Vivie.txt","rw"); archivo.seek(0); while(true){ String linea= archivo.readLine(); if (linea==null) break; chcTra.add(linea); } } catch (Throwable e){ javax.swing.JOptionPane.showMessageDialog(null, e); } } void Comprobar(){ try{ RandomAccessFile archivo=new RandomAccessFile("C:\\seguro.txt","rw"); archivo.seek(0); while(true){ String linea = archivo.readLine(); archivo.readLine(); archivo.readLine(); if (linea ==null){ break; } double a=Double.parseDouble(txtEd.getText()); if((a>0)&&(a<6)){




r=((a*15)/100); } archivo.readLine(); } lblPor.setText(String.valueOf (r)); archivo.close(); javax.swing.JOptionPane.showMessageDialog(null,"Suma resultado"); } catch(Throwable e){ javax.swing.JOptionPane.showMessageDialog(null,e); } } void Comprobar1(){ try{ RandomAccessFile archivo=new RandomAccessFile("C:\\seguro.txt","rw"); archivo.seek(0); while(true){ String linea = archivo.readLine(); archivo.readLine(); archivo.readLine(); archivo.readLine(); archivo.readLine(); if (linea ==null){ break; } double b=Double.parseDouble(txtTi.getText()); if(linea.equals("A")){ rr=((b*5)/100); }




archivo.readLine(); } lblVi.setText(String.valueOf (rr)); archivo.close(); javax.swing.JOptionPane.showMessageDialog(null,"Suma resultado"); } catch(Throwable e){ javax.swing.JOptionPane.showMessageDialog(null,e); } } public Seguro1() { setLayout(new GridLayout(7,2)); add(lblNombres= new Label("Nombres")); add(txtNom= new TextField()); add(lblApellidos= new Label("Apellidos")); add(txtApe= new TextField()); add(lblEdad= new Label("Edad")); add(txtEd= new TextField()); add(lblValor= new Label("Valor seguro")); add(txtVa= new TextField()); add(lblVivienda= new Label("Vivienda")); add(chcTipo= new Choice()); add(lblTrabajo= new Label("Trabajo")); add(chcTra= new Choice()); add(btnGuardar=new Button("Guardar")); add(btnSalir=new Button("Salir")); CargarTipo(); CargarTipo1(); setSize(200,200); setTitle("Ingreso"); show(); } public boolean action(Event evt,Object ar){




if(evt.target instanceof Button){ if(evt.target == btnSalir) System.exit(0); if(evt.target == btnAdicional) Comprobar(); if(evt.target == btnTipo) Comprobar1(); if(evt.target == btnGuardar) guardar(); return true; } return false; } void guardar(){ try{ RandomAccessFile archivo = new RandomAccessFile("C:\\seguro.txt","rw"); archivo.seek(archivo.length()); archivo.writeBytes(txtNom.getText()+"\n"); archivo.writeBytes(txtApe.getText()+"\n"); archivo.writeBytes(txtEd.getText()+"\n"); archivo.writeBytes(txtVa.getText()+"\n"); archivo.writeBytes(idVivie(chcTipo.getSelectedItem())+"\n"); archivo.writeBytes(idTraba(chcTra.getSelectedItem())+"\n"); archivo.close(); javax.swing.JOptionPane.showMessageDialog(null,"Ingreso Exitoso"); txtNom.setText(""); txtApe.setText(""); txtEd.setText(""); txtVa.setText(""); txtVa.requestFocus(); } catch(Throwable e){ javax.swing.JOptionPane.showMessageDialog(null,e); } } public static void main(String arg[]){ new Seguro1(); } }




EJERCICIO 302 REALIZAR EN PROGRAMA EN JAVA QUE PERMITA MOSTRAR UNA BARRA DE DESPLAZAMIENTO. SCROLLBAR /** * Este programa implementa un ejemplo de uso de la clase Scrollbar. * Crea una barra de desplazamiento horizontal, que permite la selección * de valores entre 0 y 255, con un ancho del indicador de 64 pixels */ import java.awt.*; import java.awt.event.*; class java1310 extends Frame { public static void main( String args[] ) { // Se instancia un objeto del tipo de la clase new java1310(); } public java1310() { Scrollbar rango; rango = new Scrollbar( Scrollbar.HORIZONTAL,0,64,0,255 ); Frame miFrame = new Frame( "Tutorial de Java, AWT" ); // Se incorpora la barra de desplazamiento al objeto Frame miFrame.add( rango,"Center" ); // Se fija el tamaño del Frame y se hace que aparezca todo // en pantalla miFrame.setSize( 300,50 ); miFrame.setVisible( true ); // Se instancia y registra un objeto receptor de eventos de la // ventana para poder concluir la aplicación cuando el usuario // cierre el Frame Conclusion conclusion = new Conclusion(); miFrame.addWindowListener( conclusion ); } } // Concluye la ejecucion de la aplicacion cuando el usuario cierra la




// ventana, porque se genera un evento windowClosing class Conclusion extends WindowAdapter { public void windowClosing( WindowEvent evt ) { System.exit( 0 ); } }

NÚMEROS ALEATORIOS CON RANDOM EJERCICIO 303 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA GENERAR UN NÚMERO ALEATORIO ENTRE EL 0-2. import java.io.*; import java.lang.*; class Aleatorio{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in));




double aleatorio=0; aleatorio=Math.random()*3; System.out.println("Numero aleatorio: " +aleatorio); } }

EJERCICIO 304 MUESTRA DISTINTAS FUNCIONES DELM MÉTODO MATH. class java800 { public static void main( String args[] ) { int x; double rand,y,z; float max; rand = Math.random(); x = Math.abs( -123 ); y = Math.round( 123.567 ); z = Math.pow( 2,4 ); max = Math.max( (float)1e10,(float)3e9 ); System.out.println( rand ); System.out.println( x ); System.out.println( y ); System.out.println( z ); System.out.println( max ); } }

EJERCICIO 305




REALIZAR UN PROGRAMA EN JAVA QUE PERMITA GENERAR UN NÚMERO ALEATORIO DEL 0. import java.io.*; import java.lang.*; class Aleatorio1{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); double aleatorio=0; aleatorio=Math.random()*1; System.out.println("\n"+"Numero aleatorio: " +aleatorio); } }

EJERCICIO 306 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA GENERAR UN NÚMERO ALEATORIO ENTRE EL 1-3. import java.io.*; import java.lang.*; class Aleatorio2{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); double aleatorio=0; aleatorio=Math.random()*3+1; System.out.println("\n"+"Numero aleatorio: " +aleatorio); }




}

EJERCICIO 307 REALIZAR UN PROGRAMA EN JAVA QUE PERMITA GENERAR UN NÚMERO ALEATORIO ENTRE EL 1-10. import java.io.*; import java.lang.*; class Aleatorio3{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); double aleatorio=0; aleatorio=Math.random()*10+1; System.out.println("\n"+"Numero aleatorio: " +aleatorio); } }

EJERCICIO 308 REALIZAR UN PROGRAMA QUE SIMULE 6 LANZAMIENTOS DE DOS DADOS. import java.io.*; import java.lang.*; class Dados{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int c=1; int num1=0, num2=0;




while(c<7){ num1=(int)(Math.random()*6)+1; num2=(int)(Math.random()*6)+1; System.out.println("Lanzamiento: "+c); System.out.println("Dado1: "+num1); System.out.println("Dado2: "+num2); c++; } } }

EJERCICIO 309 REALIZAR UN PROGRAMA EN JAVA QUE SIMULE EL SALTO DE UNA RANA. PASOS: NO DA SALTO SALTA 1MT. SALTA 2MT TIENE QUE RECORRER 20 METROS, ES LA META. import java.io.*; import java.lang.*; class SaltoRana{ public static void main(String arg[]) throws IOException{ BufferedReader temp = new BufferedReader( new InputStreamReader(System.in)); int numero=0,m=0,c=1;




System.out.println("\t\t\tSalto de la Rana"); while(m<=20){ numero=(int)(Math.random()*3); System.out.print(numero+"\t"); c++; if(numero==0)m=m+0; if(numero==1)m=m+1; if(numero==2)m=m+2; } System.out.println("\n\n"+"La rana llego en: "+c+" saltos"); } }

EJERCICIO 310 ADIVINA UN NÚMERO. /* * Adivina.java * * Created on 28 de diciembre de 2005, 09:47 PM */ package Deberes; /** * * @author Susana E. Vaque Guzmán * @version */ public class Adivina extends java.awt.Frame { int a; /** Creates new form Adivina */ public Adivina() { initComponents (); setSize (500, 300); setTitle ("Susana - Adivina el numero"); a = aleatorio ();




} /** This method is called from within the constructor to * initialize the form. * WARNING: Do NOT modify this code. The content of this method is * always regenerated by the FormEditor. */ private void initComponents() {//GEN-BEGIN:initComponents L = new java.awt.Label(); T = new java.awt.TextField(); button1 = new java.awt.Button(); setLayout(new java.awt.GridLayout(3, 1)); addWindowListener(new java.awt.event.WindowAdapter() { public void windowClosing(java.awt.event.WindowEvent evt) { exitForm(evt); } } ); L.setFont(new java.awt.Font ("Vladimir Script", 0, 24)); L.setBackground(new java.awt.Color (204, 204, 204)); L.setForeground(java.awt.Color.red); L.setText("Adivine un n\u00famero entre 1 y 1000 "); L.setAlignment(java.awt.Label.CENTER); add(L); T.setBackground(java.awt.Color.white); T.setFont(new java.awt.Font ("Times New Roman", 3, 48)); T.setForeground(java.awt.Color.green); T.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { TActionPerformed(evt); } } ); T.addKeyListener(new java.awt.event.KeyAdapter() { public void keyPressed(java.awt.event.KeyEvent evt) { textField1KeyPressed(evt); } } ); add(T);




button1.setFont(new java.awt.Font ("Dialog", 0, 11)); button1.setLabel("S A L I R"); button1.setBackground(new java.awt.Color (157, 185, 200)); button1.setForeground(java.awt.Color.black); button1.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { button1ActionPerformed(evt); } } ); add(button1); }//GEN-END:initComponents private void TActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_TActionPerformed // Add your handling code here: }//GEN-LAST:event_TActionPerformed private void textField1KeyPressed(java.awt.event.KeyEvent evt) {//GEN-FIRST:event_textField1KeyPressed if (evt.getKeyCode() == 10) { int val = Integer.parseInt(T.getText()); if (val < a) L.setText("¡M U Y B A J O!"); else if (val > a) L.setText("¡M U Y A L T O!"); else { L.setText("** E X C E L E N T E **"); javax.swing.JOptionPane.showMessageDialog(null, "¡Felicidades. Adivino el Número!"); javax.swing.JOptionPane.showMessageDialog(null, "=> N u e v o n u m e r o <="); L.setText("Adivine un número entre 1 y 1000 "); a = aleatorio (); } T.setText(""); } // Add your handling code here: }//GEN-LAST:event_textField1KeyPressed int aleatorio () { return (int) ((Math.random()*1000) + 1); }




private void button1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_button1ActionPerformed System.exit(0);// Add your handling code here: }//GEN-LAST:event_button1ActionPerformed /** Exit the Application */ private void exitForm(java.awt.event.WindowEvent evt) {//GEN-FIRST:event_exitForm System.exit (0); }//GEN-LAST:event_exitForm /** * @param args the command line arguments */ public static void main (String args[]) { new Adivina ().show (); } // Variables declaration - do not modify//GEN-BEGIN:variables private java.awt.Label L; private java.awt.TextField T; private java.awt.Button button1; // End of variables declaration//GEN-END:variables }




EJERCICIO 311 EJERCICIO DE LA RULETA RUSA. ALEATORIO /* * Empleado.java * * Created on 26 de diciembre de 2005, 04:17 PM */ package Deberes; /** * * @author Susana E. Vaque Guzmán * @version */ public class Ruleta_Rusa { int Bala;//[6]; Arreglo int Disparo(){ return (int)(Math.random()*2); } Ruleta_Rusa() { Bala = Disparo(); if (Bala == 1) System.out.println("1er. Disparo"); else { Bala = Disparo(); if (Bala == 1)




System.out.println("2do. Disparo"); else { Bala = Disparo(); if (Bala == 1) System.out.println("3er. Disparo"); else { Bala = Disparo(); if (Bala == 1) System.out.println("4to. Disparo"); else { Bala = Disparo(); if (Bala == 1) System.out.println("5to. Disparo"); else System.out.println("6to. Disparo"); } } } } } public static void main (String arg[]) { new Ruleta_Rusa(); } }

EJERCICIO 312 PARA MOSTRAR QUE JAVA VA SERVIRTE DE MUCHA UTILIDAD. EJEMPLO QUE PERMITE EL USO DEL MOUSE PARA MOVER LA ETIQUETA EN EL PANEL. /** * Este ejemplo permite desplazar una etiqueta por la ventana que se * genera. Se utilizan los eventos de posicionamiento del rattón, * tanto cuando se está arrastrando como cuando se ha movido de * sitio el puntero */




import java.awt.*; import java.awt.event.*; public class java1110 { public static void main( String args[] ) { // Aqui se instancia un objeto de tipo Interfaz Hombre-Maquina IHM ihm = new IHM(); } } // Esta clase se utiliza para instaciar un objeto de tipo interfaz de // usuario class IHM { // Variables de referencia pasadas como parámetros Label miEtiqueta; LabelInfo miEtiquetaInfo; // Posición inicial de la etiqueta int posicionX = 50; int posicionY = 25; public IHM() { // Crea un objeto visual Etiqueta (Label) miEtiqueta = new Label( "Etiqueta" ); miEtiqueta.setBackground( Color.yellow ); // Crea un objeto Panel para contener la etiqueta Panel miPanel = new Panel(); miPanel.setLayout( null ); miPanel.add( miEtiqueta ); // Fijamos la posición y ancho y alto de la etiqueta miEtiqueta.setBounds( posicionX,posicionY,125,100 ); // Crea un objeto visual Frame para contenerlo todo Frame miFrame = new Frame(); miFrame.setSize( 300,200 ); miFrame.setTitle( "Tutorial de Java, Eventos" ); miFrame.add( "Center",miPanel ); miFrame.setVisible( true ); // Crea un objeto para mantener información acerca de la // etiqueta miEtiquetaInfo = new LabelInfo(); miEtiquetaInfo.labelX = posicionX; miEtiquetaInfo.labelY = posicionY;




// Se instancia y registra un objeto MouseMotionListener // y otro MouseListener que procesarán los eventos de // movimiento del ratón y de los botones del ratón miEtiqueta.addMouseMotionListener( new ProcesoMovimientoRaton( miEtiquetaInfo ) ); miEtiqueta.addMouseListener( new ProcesoRaton( miEtiquetaInfo,miEtiqueta ) ); // Se instancia y registra un objeto receptor de eventos // para terminar la ejecucion del programa cuando el // usuario decida cerrar la ventana Conclusion procesoVentana = new Conclusion(); miFrame.addWindowListener( procesoVentana ); } } // Esta es una clase auxiliar que se utiliza para guardar las // posiciones en que se encuentra la etiqueta y también las // coordenadas en las que se mueve el ratón y las coordenadas // en que se encontraba el cursor al pulsar uno de los botones // del ratón class LabelInfo { int labelX; int labelY; int ratonPulsadoX; int ratonPulsadoY; int ratonMovidoX; int ratonMovidoY; } // Esta clase receptor se utiliza para monitorizor los eventos // de pulsacion de los botones del raton y los eventos que se // producen al soltar el botón. Los dos eventos se utilizan para // determinar la posición inicial y final en que se encuentra la // etiqueta class ProcesoRaton extends MouseAdapter { LabelInfo labelInfo; Label label; ProcesoRaton( LabelInfo iLabelInfo,Label iLabel ) { labelInfo = iLabelInfo; label = iLabel; }




public void mousePressed( MouseEvent evt ) { // Guarda la posición inicial en que se pulsa el ratón labelInfo.ratonPulsadoX = evt.getX(); labelInfo.ratonPulsadoY = evt.getY(); } // Al soltar el botón se calcula la nueva posición de la // etiqueta, en función de su posición inicial, el punto en // que se encontraba el ratón al pulsar el botón y el punto // final cuando se suelta el botón. Hay pulsar y soltar dentro // de la etiqueta, sino no se realiza ningún movimiento public void mouseReleased( MouseEvent evt ) { int nuevaPosicionX = labelInfo.labelX + labelInfo.ratonMovidoX - labelInfo.ratonPulsadoX; int nuevaPosicionY = labelInfo.labelY + labelInfo.ratonMovidoY - labelInfo.ratonPulsadoY; // Movemos la etiqueta a la nueva posición label.setLocation( nuevaPosicionX,nuevaPosicionY ); // Guarda la posición actual de la etiqueta labelInfo.labelX = nuevaPosicionX; labelInfo.labelY = nuevaPosicionY; } } // Esta clase receptor se utiliza para monitorizor los eventos // de movimiento del raton class ProcesoMovimientoRaton extends MouseMotionAdapter { LabelInfo labelInfo; ProcesoMovimientoRaton( LabelInfo iLabelInfo ) { labelInfo = iLabelInfo; } public void mouseDragged( MouseEvent evt ) { System.out.println( "Arrastre = "+evt ); // Guarda la posición durante el movimiento del ratón labelInfo.ratonMovidoX = evt.getX(); labelInfo.ratonMovidoY = evt.getY(); } public void mouseMoved( MouseEvent evt ) { System.out.println( "Movido = "+evt ); } }




// Este repector de eventos de la ventana se utiliza para concluir // la ejecucion del programa cuando el usuario pulsa sobre el boton // de cierre del Frame class Conclusion extends WindowAdapter { public void windowClosing( WindowEvent evt ) { System.exit( 0 ); } }




Webliografía REEMPLAZAR Arboles de Java http://java.cs.tamu.edu/docs/jdk1.2/api/java/lang/ Clase System de java.lang http://java.cs.tamu.edu/docs/jdk1.2/api/java/lang/System.html Hoja de los prodcutos Java http://java.sun.com/products/products.a-z.html Tutorial de Java http://java.sun.com/docs/books/tutorial/index.html http://wwww.itapizaco.edu.mx Java http://jcca007.iespana.es/codigosjava.htm http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Java_/_Versi%C3%B3n_Para_Imprimir#Operadores_2 ESTRUCTURA DE CONTROL http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Java_/_Estructuras_de_selecci%C3%B3n if http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Java_/_Sentencia_if-else TIPOS DE DATOS http://usuarios.lycos.es/jjmurias/java/Tipos%20de%20datos.htm CREACION DE OBJETOS http://altatorre.com/webclase/java/ejemplosconstructores.htm BASICO http://www.altatorre.com/webclase/java/ejerciciosvarobj_resueltos.htm TUTORIAL JAVA http://www.programacion.com/java/tutorial/java_basico/2/

http://www.altatorre.com/webclase/java/api/packages.html

http://java.cs.tamu.edu/docs/jdk1.2/api/java/lang/

http://java.cs.tamu.edu/docs/jdk1.2/api/java/lang/System.html

http://java.sun.com/products/products.a-z.html

http://java.sun.com/docs/books/tutorial/index.html

http://wwww.itapizaco.edu.mx/

http://jcca007.iespana.es/codigosjava.htm

http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Java_/_Estructuras_de_selecci%C3%B3n

http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Java_/_Estructuras_de_selecci%C3%B3n

http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Java_/_Sentencia_if-else

http://usuarios.lycos.es/jjmurias/java/Tipos%20de%20datos.htm

http://altatorre.com/webclase/java/ejemplosconstructores.htm

http://www.altatorre.com/webclase/java/ejerciciosvarobj_resueltos.htm

http://www.programacion.com/java/tutorial/java_basico/2/




http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte5/cap5-4.html http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parteE/cape-1.html POLIMORFISMO http://foro.elhacker.net/java/ejercicios_java_teoriaejemplos-t34891.0.html

http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte5/cap5-4.html

http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parteE/cape-1.html

http://foro.elhacker.net/java/ejercicios_java_teoriaejemplos-t34891.0.html

libro de programación i contenido

Documents