Descargado 13 veces
![Universidad Autónoma de Occidente
p→ q. q → r + p→ r (ley del silogismo)
Este hecho se verifica con la siguiente tabla de verdad que muestra que la proposicion
[(p→ q) ^ (q → r)] → (p→ r)
Es una tautologia:
p
q r [(p → q) ^ (q → r)] → (p → r)
VV V V V V V V V V V V V V
VV F V V V F V F F V V F F
VF V V F F F F V V V V V V
VF F V F F F F V F V V F F
FV V F V V V V V V V F V V
FV F F V V F V F F V F V F
FF V F V F V F V V V F V V
FF F F V F V F V F V F V F
Paso 1 2 1 3 1 2 1 4 1 2 1
Equivalentemente, el argumento es valido ya que las premisas p→ q y q→ r son verdaderas
simultáneamente solo en los casos (lineas) 1, 5, 7 y 8, y en estos casos la conclusión p→ r tambien es
verdadera. (observe que la tabla de verdad requiere 2³ = 8 lineas, ya que hay tres variables p, q y r.)
Es necesario destacar que la validez del argumento no depende de los valores de verdad o del
contenido de los enunciados que aparecen en el argumento, sino solamente de la estructura formal del
argumento. Esto se ilustra con el siguiente ejemplo.
Ejemplo 10: Considere el siguiente argumento:
S1: Si un hombre es soltero, es infeliz.
S2: Si un hombre es infeliz, muere joven.
.................................................................
S: Los solteros mueren jóvenes.
En este caso el enunciado S debajo de la línea denota la conclusión del argumento, y los enunciados
S1 y S2 por encima de la línea denotan las premisas. Afirmamos que el argumento es de la forma
p→ q , q→ r + p → r
Es donde p es “El es soltero”, q es “El es infeliz” y r es “El muere joven”; y por el ejemplo 4.9 este
argumento (Ley de silogismo) es válido.
2.10 Implicación Lógica.
Se dice que una proposición P (p,q,...) implica lógicamente una proposición Q (p,q,...), escrito
P (p,q,...)⇒ Q (p, q, ...)
Si Q (p, q, ...) es verdadera cada vez que P (p,q,...) sea verdadera.
Ejemplo 11: Afirmamos que P implica lógicamente p ν q. Considere las tablas de verdad de p y de
p ν q en la tabla de abajo. Observe que p es verdadera en los casos (líneas) 1 y 2, y en estos casos
pν q también es verdadera. En otras palabras , p implica lógicamente p ν q.
Informática I. Versión 1.0 Agosto de 2004
23](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-23-320.jpg)
![Universidad Autónoma de Occidente
Carga
Disco Se carga el programa a
memoria Memoria
Verificación
En esta etapa se determina si la aplicación que se desea ejecutar tiene o no errores, principalmente de
seguridad. Esto es muy importante, considerando que las aplicaciones comúnmente son enviadas a
través de Internet.
Se verifican que el
Verificación Memoria bytecode sea válido y
aspectos de seguridad
Ejecución
Finalmente, cubiertos todos los pasos, se interpretan las instrucciones del código de bytes,
traduciéndolos a instrucciones que la máquina pueda realizar (lenguaje de máquina).
Lee cada instrucción del
Interpréte Memoria bytecode y las ejecuta
Ejemplo de una Aplicación
En Java se pueden desarrollar aplicaciones o applets.
Las aplicaciones pueden ejecutarse en cualquier ambiente, su código es sencillo y no requiere archivos
adicionales.
Ejemplo:
/* Es es un programa de prueba.
La aplicación genera una línea de impresión en la pantalla.
El archivo debe llamarse Bienvenida1.java */
class Bienvenida1 {
// Toda aplicación debe tener un método main( )
public static void main( String args[ ] ) {
System.out.println( "Bienvenido a la Tecnologia Java!!" ) ;
}
}
Observe que:
• Todo programa en JAVA debe contener al menos una clase.
• El archivo del código fuente debe tener el mismo nombre de la clase principal de la aplicación. En
este caso: Bienvenida1.java
• El JAVA es sensible al uso de Mayúsuculas, así que Bienvenida1 y bienvenida1 son dos cosas
diferentes.
• Toda aplicación debe contener, en su clase principal, un método de nombre main( ), con la
signatura (ó firma) presentada.
Informática I. Versión 1.0 Agosto de 2004
42](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-42-320.jpg)
![Universidad Autónoma de Occidente
Salida:
Ejercicios
Indique si las siguientes proposiciones son verdaderas o falsas, justifique su respuesta.
a.- Java es un lenguaje orientado a objetos híbrido.
b.- La API y la JVM se incluyen en el SDK.
c.- Existen una única JVM para todas las plataformas.
d.- La compilación, carga y verificación de un programa escrito en Java, se realizan en un solo
paso.
e.- El compilador de Java fue desarrollado en C.
f.- Java es una versión actualizada de C++.
g.- Se dice que Java es robusto porque permite al usuario depurar el código fácilmente.
h.- Java se considera portátil porque una vez escrito y compilado el programa puede ejecutarse en
cualquier plataforma.
i.- Los applets son aplicaciones pequeñas que corren a través de un browser.
j.- Java es sensible a mayúsculas.
3.7 Salida de datos estándar
// Ejemplo 1 Esta aplicación Java muestra un mensaje de Bienvenida
// en la salida estandar (pantalla), ó consola Java:
class SalidaBasica1 {
public static void main( String args[ ] ) {
System.out.println( "Bienvenido al curso de Algoritmos con Java 2" ) ;
}
} // Fin de la clase SalidaBasica1 Salida:
// Ejemplo 2 Esta aplicación Java explica la diferencia entre print y println
class SalidaBasica2 {
public static void main( String args[ ] ) {
System.out.print( "Bienvenido al curso de " ) ;
System.out.print( "Algoritmos con Java 2n" ) ; // n es el comando para nueva línea
System.out.println( "Imprime una linea en blanco, ejecuta el retorno de carro y" ) ;
System.out.println( "avanza a la linea siguiente" ) ;
}
} // Fin de la clase SalidaBasica2 Salida:
Informática I. Versión 1.0 Agosto de 2004
45](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-45-320.jpg)
![Universidad Autónoma de Occidente
3.8 Entrada de datos estándar
// Ejemplo 1 Esta aplicación Java muestra cómo ingresar una cadena de caracteres (String)
// desde el teclado.
import java.io.* ; // importa el paquete de entrada - salida básica.
class EntradaBasica1 {
public static void main( String args[ ] ) throws IOException {
/* Note que antes de la llave de apertura del método main( ), se
debe escribir 'throws IOException' para evitar mensajes
relacionados con el manejo de errores y que impiden la
correcta compilación del programa. */
InputStreamReader isr = new InputStreamReader( System.in ) ;
BufferedReader br = new BufferedReader( isr ) ;
/* Las 2 líneas anteriores habilitan la entrada de datos desde el
teclado. El proceso le puede parecer confuso, pero es necesario que
se vaya familiarizando con él. La primer línea subrayada crea un objeto, que hemos
denominado arbitrariamente isr, de la clase InputStreamReader.
Para crear el objeto isr, se le ha enviado al constructor de la
clase InputStreamReader el argumento System.in (teclado).
La segunda línea subrayada crea un objeto, que hemos denominado arbitrariamente br,
de la clase BufferedReader. Para crear el objeto br, se le ha enviado al
constructor de la clase BufferedReader el argumento isr, el cual es el
objeto que se creó en la primer línea subrayada.
El último objeto creado, br, es el que nos sirve para invocar el método
readLine( ) de la clase BufferedReader. El método readLine( ) lee la
información digitada desde el teclado hasta pulsar la tecla Return
(o Enter, o Intro, etc) y la guarda como una cadena de caracteres (String).
*/
System.out.print( "Escriba su nombre y pulse RETURN: " ) ;
String cadena = br.readLine( ) ; // Guarde el nombre en la variable cadena
// Muestre en consola el nombre ingresado, concatenado con un mensaje:
System.out.println( "Hola " + cadena + ", bienvenido a Java 2" ) ;
}
} // Fin de la clase EntradaBasica1 Salida:
Informática I. Versión 1.0 Agosto de 2004
46](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-46-320.jpg)
![Universidad Autónoma de Occidente
// Ejemplo 2 Esta aplicación Java muestra cómo ingresar una cadena de caracteres (String)
// desde el teclado.
import java.io.* ; // importa el paquete de entrada - salida básica.
class EntradaBasica2 {
public static void main( String args[ ] ) throws IOException {
/* Note que antes de la llave de apertura del método main( ), se
debe escribir 'throws IOException' para evitar mensajes
relacionados con el manejo de errores y que impiden la
correcta compilación del programa. */
/* La línea subrayada habilita la entrada de datos desde el teclado.
Ahora, se han escrito las instrucciones del proceso en una sola línea.
Repasando lo mencionado en el ejemplo anterior (clase EntradaBasica1),
note de nuevo que para recibir los datos vía teclado, debe crear un
objeto (que arbitrariamente hemos llamado br) de la clase BufferedReader.
Observe que al constructor de la clase BufferedReader se le envía como
argumento una nueva instancia (o sea, un objeto) de la clase InputStreamReader.
Para obtener esta nueva instancia de la clase InputStreamReader, se ha
enviado a su constructor la variable de clase 'in' de la clase System.
De nuevo, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader.
El método readLine( ) lee la información digitada desde el teclado hasta pulsar
la tecla Return (o Enter, o Intro, etc) y la guarda como una
cadena de caracteres (String).
*/
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
String cadena ; // Declara la variable tipo String (cadena de caracteres)
System.out.print( "Escriba su nombre y pulse RETURN: " ) ;
cadena = br.readLine( ) ; // Guarde el nombre en la variable cadena
// Muestre en consola el nombre ingresado, concatenado con un mensaje:
System.out.println( "Hola " + cadena + ", bienvenido a Java 2" ) ;
System.exit( 0 ) ; // Salga de la Aplicación
} // Fin del método main( )
} // Fin de la clase EntradaBasica2
La salida es similar a la de la aplicación EntradaBasica1.java
// Ejemplo 3 Esta aplicación Java muestra cómo ingresar un número entero
// desde el teclado.
Informática I. Versión 1.0 Agosto de 2004
47](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-47-320.jpg)
![Universidad Autónoma de Occidente
import java.io.* ; // importa el paquete de entrada - salida básica.
class EntradaBasica3 {
public static void main( String args[ ] ) throws IOException {
/* Note que antes de la llave de apertura del método main( ), se
debe escribir 'throws IOException' para evitar mensajes
relacionados con el manejo de errores y que impiden la
correcta compilación del programa. */
/* La línea subrayada habilita la entrada de datos desde el teclado.
Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader. */
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
String cadena ; // Declara la variable cadena del tipo String (cadena de caracteres)
int entero ; // Declara la variable entero del tipo int (número entero)
System.out.print( "Digite un numero entero y pulse RETURN: " ) ;
cadena = br.readLine( ) ; // Lee el número como una cadena de caracteres, pues
//el método readLine( ) lee la información digitada desde el teclado hasta pulsar
//la tecla Return (o Enter, o Intro, etc) y la guarda como una cadena de
//caracteres (String).
entero = Integer.parseInt( cadena ) ;//Convierte de String a entero (int),
//pues el método parseInt( String ) de la clase Integer recibe un parámetro
//String y lo convierte a su equivalente numérico en formato entero (int).
// Muestre en consola el número ingresado, concatenado con un mensaje:
System.out.println( "Usted ha digitado el numero entero " + entero ) ;
System.exit( 0 ) ; // Salga de la Aplicación
} // Fin del método main( )
} // Fin de la clase EntradaBasica3 Salida:
// Ejemplo 4 Esta aplicación Java también muestra cómo ingresar un número entero
// desde el teclado, pero utiliza menos instrucciones.
import java.io.* ; // importa el paquete de entrada - salida básica.
class EntradaBasica4 {
public static void main( String args[ ] ) throws IOException {
Informática I. Versión 1.0 Agosto de 2004
48](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-48-320.jpg)
![Universidad Autónoma de Occidente
/* La línea subrayada habilita la entrada de datos desde el teclado.
Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader. */
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
System.out.print( "Digite un numero entero y pulse RETURN: " ) ;
int entero = Integer.parseInt( br.readLine( ) ) ; // Notar que podemos usar
// directamente el método readLine( ) [ llamado desde el objeto br ]
// como argumento del método parseInt de la clase Integer, reduciendo todo a una
// sola instrucción. Además, no es necesario la variable auxiliar deltipo String ni
// declarar por separado la variable 'entero' del tipo int (entero).
// Muestre en consola el número ingresado, concatenado con un mensaje:
System.out.println( "Usted ha digitado el numero entero " + entero ) ;
System.exit( 0 ) ; // Salga de la Aplicación
} // Fin del método main( )
} // Fin de la clase EntradaBasica4 Salida:
/* Ejemplo 5 Esta aplicación Java ilustra cómo ingresar más números enteros
desde el teclado, los cuales han sido declarados en los otros
formatos proporcionados por Java para números enteros. */
import java.io.* ; // importa el paquete de entrada - salida básica.
class EntradaBasica5 {
public static void main( String args[ ] ) throws IOException {
/* La línea subrayada habilita la entrada de datos desde el teclado.
Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader. */
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
int i ;
long j ;
short k ;
byte m ;
System.out.print( "Digite el primer numero entero y pulse RETURN: " ) ;
Informática I. Versión 1.0 Agosto de 2004
49](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-49-320.jpg)
![Universidad Autónoma de Occidente
i = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite el segundo numero entero y pulse RETURN: " ) ;
j = Long.parseLong( br.readLine( ) ) ;
System.out.print( "Digite el tercer numero entero y pulse RETURN: " ) ;
k = Short.parseShort( br.readLine( ) ) ;
System.out.print( "Digite el cuarto numero entero y pulse RETURN: " ) ;
m = Byte.parseByte( br.readLine( ) ) ;
// Muestre en consola los números digitados:
System.out.println( "Primer numero entero: " + i ) ;
System.out.println( "Segundo numero entero: " + j ) ;
System.out.println( "Tercer numero entero: " + k ) ;
System.out.println( "Cuarto numero entero: " + m ) ;
System.exit( 0 ) ; // Salga de la Aplicación
} // Fin del método main( )
} // Fin de la clase EntradaBasica5 Salida:
// Ejemplo 6 Esta aplicación Java muestra cómo ingresar un número entero
// desde el teclado utilizando la clase Integer y su método intValue( )
import java.io.* ; // importa el paquete de entrada - salida básica.
class EntradaBasica6 {
public static void main( String args[ ] ) throws IOException {
/* La línea subrayada habilita la entrada de datos desde el teclado.
Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader. */
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
String cadena ; // Declara la variable cadena del tipo String (cadena de caracteres)
int entero ; // Declara la variable entero del tipo int (número entero)
Informática I. Versión 1.0 Agosto de 2004
50](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-50-320.jpg)
![Universidad Autónoma de Occidente
System.out.print( "Digite un numero entero y pulse RETURN: " ) ;
cadena = br.readLine( ) ; // Lee el número como una cadena de caracteres, pues
//el método readLine( ) lee la información digitada desde el teclado hasta pulsar
//la tecla Return (o Enter, o Intro, etc) y la guarda como una cadena de
//caracteres (String).
// Crea un objeto, i, de la clase Integer:
Integer i = new Integer( cadena ) ; // la cadena String se envía al constructor
// Invoca al método intValue( ) de la clase Integer:
entero = i.intValue( ) ;
// Muestre en consola el número ingresado, concatenado con un mensaje:
System.out.println( "Usted ha digitado el numero entero " + entero ) ;
System.exit( 0 ) ; // Salga de la Aplicación
} // Fin del método main( )
} // Fin de la clase EntradaBasica6 Salida:
// Ejemplo 7 Esta aplicación Java muestra cómo ingresar un número entero
// desde el teclado utilizando la clase Integer y su método intValue( )
// Se usarán menos instrucciones
import java.io.* ; // importa el paquete de entrada - salida básica.
class EntradaBasica7 {
public static void main( String args[ ] ) throws IOException {
/* La línea subrayada habilita la entrada de datos desde el teclado.
Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader. */
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
System.out.print( "Digite un numero entero y pulse RETURN: " ) ;
// Crea un objeto, i, de la clase Integer:
Integer i = new Integer( br.readLine( ) ) ; // la cadena String, retornada
// por el método readLine( ) de la clase BufferedReader, se envía directamente al constructor
// de la clase Integer
int entero = i.intValue( ) ;
Informática I. Versión 1.0 Agosto de 2004
51](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-51-320.jpg)
![Universidad Autónoma de Occidente
// Muestre en consola el número ingresado, concatenado con un mensaje:
System.out.println( "Usted ha digitado el numero entero " + entero ) ;
System.exit( 0 ) ; // Salga de la Aplicación
} // Fin del método main( )
} // Fin de la clase EntradaBasica7 Salida:
// Ejemplo 8 Esta aplicación Java muestra cómo ingresar números enteros
// desde el teclado utilizando las clases Integer, Long, Short y Byte
import java.io.* ; // importa el paquete de entrada - salida básica.
class EntradaBasica8 {
public static void main( String args[ ] ) throws IOException {
/* La línea subrayada habilita la entrada de datos desde el teclado.
Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader. */
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
System.out.print( "Digite el primer numero entero y pulse RETURN: " ) ;
// Crea un objeto, i, de la clase Integer:
Integer i = new Integer( br.readLine( ) ) ; // la cadena String, retornada
// por el método readLine( ) de la clase BufferedReader, se envía al constructor
// de la clase Integer
int entero1 = i.intValue( ) ;
System.out.print( "Digite el segundo numero entero y pulse RETURN: " ) ;
// Crea un objeto, j, de la clase Long:
Long j = new Long( br.readLine( ) ) ; // la cadena String, retornada
// por el método readLine( ) de la clase BufferedReader, se envía al constructor
// de la clase Long
long entero2 = j.longValue( ) ;
System.out.print( "Digite el tercer numero entero y pulse RETURN: " ) ;
// Crea un objeto, k, de la clase Short:
Short k = new Short( br.readLine( ) ) ;// la cadena String, retornada
// por el método readLine( ) de la clase BufferedReader, se envía al constructor
// de la clase Short
short entero3 = k.shortValue( ) ;
Informática I. Versión 1.0 Agosto de 2004
52](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-52-320.jpg)
![Universidad Autónoma de Occidente
System.out.print( "Digite el cuarto numero entero y pulse RETURN: " ) ;
// Crea un objeto, m, de la clase Byte:
Byte m = new Byte( br.readLine( ) ) ; // la cadena String, retornada
// por el método readLine( ) de la clase BufferedReader, se envía al constructor
// de la clase Byte
byte entero4 = m.byteValue( ) ;
// Muestre en consola los números ingresados:
System.out.println( "Primer numero entero: " + entero1 ) ;
System.out.println( "Segundo numero entero: " + entero2 ) ;
System.out.println( "Tercer numero entero: " + entero3 ) ;
System.out.println( "Cuarto numero entero: " + entero4 ) ;
System.exit( 0 ) ; // Salga de la Aplicación
} // Fin del método main( )
} // Fin de la clase EntradaBasica8 Salida:
// Ejemplo 9 Esta aplicación Java muestra cómo ingresar un número real (de punto flotante)
// desde el teclado.
import java.io.* ; // importa el paquete de entrada - salida básica.
class EntradaBasica9 {
public static void main( String args[ ] ) throws IOException {
/* La línea subrayada habilita la entrada de datos desde el teclado.
Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader. */
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
System.out.print( "Digite un numero real y pulse RETURN: " ) ;
double real = Double.parseDouble( br.readLine( ) ) ; /* Notar que podemos usar
directamente el método readLine( ) [ llamado desde el objeto br ]
como argumento del método parseDouble de la clase Double, reduciendo todo a una
sola instrucción.*/
Informática I. Versión 1.0 Agosto de 2004
53](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-53-320.jpg)
![Universidad Autónoma de Occidente
// Muestre en consola el número ingresado, concatenado con un mensaje:
System.out.println( "Usted ha digitado el numero real " + real ) ;
System.exit( 0 ) ; // Salga de la Aplicación
} // Fin del método main( )
} // Fin de la clase EntradaBasica9 Salida:
// Ejemplo 10 Esta aplicación Java también muestra cómo ingresar un número
// real (de punto flotante) desde el teclado.
import java.io.* ; // importa el paquete de entrada - salida básica.
class EntradaBasica10 {
public static void main( String args[ ] ) throws IOException {
/* La línea subrayada habilita la entrada de datos desde el teclado.
Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader. */
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
System.out.print( "Digite un numero real y pulse RETURN: " ) ;
float real = Float.parseFloat( br.readLine( ) ) ; /* Notar que podemos usar
directamente el método readLine( ) [ llamado desde el objeto br ]
como argumento del método parseFloat de la clase Float, reduciendo todo a una
sola instrucción.*/
// Muestre en consola el número ingresado, concatenado con un mensaje:
System.out.println( "Usted ha digitado el numero real " + real ) ;
System.exit( 0 ) ; // Salga de la Aplicación
} // Fin del método main( )
} // Fin de la clase EntradaBasica10 Salida:
Informática I. Versión 1.0 Agosto de 2004
54](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-54-320.jpg)
![Universidad Autónoma de Occidente
// Ejemplo 11 Esta aplicación Java muestra cómo ingresar números reales
// desde el teclado utilizando las clases Double y Float
import java.io.* ; // importa el paquete de entrada - salida básica.
class EntradaBasica11 {
public static void main( String args[ ] ) throws IOException {
/* La línea subrayada habilita la entrada de datos desde el teclado.
Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader. */
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
System.out.print( "Digite el primer numero real y pulse RETURN: " ) ;
// Crea un objeto, x, de la clase Double:
Double x = new Double( br.readLine( ) ) ; // la cadena String, retornada
// por el método readLine( ) de la clase BufferedReader, se envía al constructor
// de la clase Double
double real1 = x.doubleValue( ) ;
System.out.print( "Digite el segundo numero real y pulse RETURN: " ) ;
// Crea un objeto, y, de la clase Float:
Float y = new Float( br.readLine( ) ) ; // la cadena String, retornada
// por el método readLine( ) de la clase BufferedReader, se envía al constructor
// de la clase Float
float real2 = y.floatValue( ) ;
// Muestre en consola los números ingresados:
System.out.println( "Primer numero real: " + real1 ) ;
System.out.println( "Segundo numero real: " + real2 ) ;
System.exit( 0 ) ; // Salga de la Aplicación
} // Fin del método main( )
} // Fin de la clase EntradaBasica11 Salida:
Informática I. Versión 1.0 Agosto de 2004
55](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-55-320.jpg)
![Universidad Autónoma de Occidente
primitivas se inicializan a cero (salvo boolean y char, que se inicializan a false y '0').
Análogamente las variables de tipo referencia son inicializadas por defecto a un valor especial: null.
Es importante distinguir entre la referencia a un objeto y el objeto mismo. Una referencia es una
variable que indica dónde está guardado un objeto en la memoria del computador (a diferencia de
C/C++, Java no permite acceder al valor de la dirección, pues en este lenguaje se han eliminado los
punteros). Al declarar una referencia todavía no se encuentra “apuntando” a ningún objeto en
particular (salvo que se cree explícitamente un nuevo objeto en la declaración), y por eso se le asigna
el valor null. Si se desea que esta referencia apunte a un nuevo objeto es necesario crear el objeto
utilizando el operador new. Este operador reserva en la memoria del computador espacio para ese
objeto (variables y funciones). También es posible igualar la referencia declarada a otra referencia a
un objeto existente previamente.
Un tipo particular de referencias son los arrays o vectores, sean éstos de variables primitivas
(por ejemplo, un vector de enteros) o de objetos. En la declaración de una referencia de tipo array hay
que incluir los corchetes [ ]. En los siguientes ejemplos aparece cómo crear un vector de 10 números
enteros y cómo crear un vector de elementos MyClass. Java garantiza que los elementos del vector
son inicializados a null o a cero (según el tipo de dato) en caso de no indicar otro valor.
Ejemplos de declaración e inicialización de variables:
int x; // Declaración de la variable primitiva x. Se inicializa a 0
inty=5; //Declaración de la variable primitiva y. Se inicializa a 5
MyClass unaRef; // Declaración de una referencia a un objeto MyClass.
// Se inicializa a null
unaRef = new MyClass(); // La referencia “apunta” al nuevo objeto creado
// Se ha utilizado el constructor por defecto
MyClass segundaRef = unaRef; // Declaración de una referencia a un objeto MyClass.
// Se inicializa al mismo valor que unaRef
int [ ] vector; // Declaración de un array. Se inicializa a null
vector = new int[10]; // Vector de 10 enteros, inicializados a 0
double [ ] v = {1.0, 2.65, 3.1}; // Declaración e inicialización de un vector de 3
// elementos con los valores entre llaves
MyClass [ ] lista=new MyClass[5]; // Se crea un vector de 5 referencias a objetos
// Las 5 referencias son inicializadas a null
lista[0] = unaRef; // Se asigna a lista[0] el mismo valor que unaRef
lista[1] = new MyClass(); // Se asigna a lista[1] la referencia al nuevo objeto
// El resto (lista[2]…lista[4] siguen con valor null
En el ejemplo mostrado las referencias unaRef, segundaRef y lista[0] actuarán sobre el mismo objeto.
Es equivalente utilizar cualquiera de las referencias ya que el objeto al que se refieren es el mismo.
4.1.4 Visibilidad y vida de las variables
Se entiende por visibilidad, ámbito o scope de una variable, la parte de la aplicación donde dicha
variable es accesible y por lo tanto puede ser utilizada en una expresión. En Java todas las variables
deben estar incluidas en una clase. En general las variables declaradas dentro de unas llaves {}, es
decir dentro de un bloque, son visibles y existen dentro de estas llaves. Por ejemplo las variables
declaradas al principio de una función existen mientras se ejecute la función; las variables declaradas
dentro de un bloque if no serán válidas al finalizar las sentencias correspondientes a dicho if y las
variables miembro de una clase (es decir declaradas entre las llaves {} de la clase pero fuera de
cualquier método) son válidas mientras existe el objeto de la clase.
Informática I. Versión 1.0 Agosto de 2004.
63](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-63-320.jpg)
![Universidad Autónoma de Occidente
4.2.10 Operadores que actúan a nivel de bits
Java dispone también de un conjunto de operadores que actúan a nivel de bits. Las Operaciones de
bits se utilizan con frecuencia para definir señales o flags, esto es, variables de tipo entero en las
quecada uno de sus bits indican si una opción está activada o no. La Tabla 4.5 muestra los operadores
de Java que actúan a nivel de bits.
Operador Utilización Resultado
>> op1 >> op2 Desplaza los bits de op1 a la derecha una distancia op2
<< op1 << op2 Desplaza los bits de op1 a la izquierda una distancia op2
>>> op1 >>> op2 Desplaza los bits de op1 a la derecha una distancia op2 (positiva)
& op1 & op2 Operador AND a nivel de bits
| op1 | op2 Operador OR a nivel de bits
^ op1 ^ op2 Operador XOR a nivel de bits (1 si sólo uno de los operandos es 1)
~ ~op2 Operador complemento (invierte el valor de cada bit)
Tabla 4.5. Operadores a nivel de bits.
En binario, las potencias de dos se representan con un único bit activado. Por ejemplo, los números (1,
2, 4, 8, 16, 32, 64, 128) se representan respectivamente de modo binario en la forma (00000001,
00000010, 00000100, 00001000, 00010000, 00100000, 01000000, 10000000), utilizando sólo 8 bits.
La suma de estos números permite construir una variable flags con los bits activados que se deseen.
Por ejemplo, para construir una variable flags que sea 00010010 bastaría hacer flags=2+16. Para
saber si el segundo bit por la derecha está o no activado bastaría utilizar la sentencia,
if (flags&2==2){...}
La Tabla 4.6 muestra los operadores de asignación a nivel de bits.
Operador Utilización Equivalente a
&= op1 &= op2 op1 = op1 & op2
|= op1 |= op2 op1 = op1 | op2
^= op1 ^= op2 op1 = op1 ^ op2
<<= op1 <<= op2 op1 = op1 << op2
>>= op1 >>= op2 op1 = op1 >> op2
>>>= op1 >>>= op2 op1 = op1 >>> op2
Tabla 4.6. Operadores de asignación a nivel de bits.
4.2.11 Precedencia de operadores
El orden en que se realizan las operaciones es fundamental para determinar el resultado de una
expresión. Por ejemplo, el resultado de x/y*z depende de qué operación (la división o el producto) se
realice primero. La siguiente lista muestra el orden en que se ejecutan los distintos operadores en un
sentencia, de mayor a menor precedencia:
postfix operators [ ] . (params) expr++ expr--
unary operators ++expr --expr +expr -expr ~ !
creation or cast new (type)expr
multiplicative */%
additive +-
shift << >> >>>
Informática I. Versión 1.0 Agosto de 2004.
67](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-67-320.jpg)
![Universidad Autónoma de Occidente
Diseño del Algoritmo
Seamos optimistas y pensemos que vamos a tener la capacidad de tener ideas, propias o adquiridas,
para desarrollar algoritmos que nos permitan actuar ante los problemas que se nos planteen.
Para diseñar algoritmos hay que tener presente los requisitos ó caracteríticas siguientes:
• Preciso: El algoritmo debe indicar con mucha claridad el orden de realización de cada
paso.
• Definido: Si se sigue un algoritmo dos veces , se debe obtener el mismo resultado cada
vez, es decir, estar definido sin ambigüedad.
• Finito: Si se sigue un algoritmo, se debe terminar en algún momento; o sea, debe tener un
número finito de pasos.
Ejemplo:
Instrucciones para subir una escalera
[...] Las escaleras se suben de frente, pues hacia atrás o de costado resultan particularmente
incómodas. La actitud natural consiste en mantenerse de pie, los brazos colgando sin esfuerzo, la
cabeza erguida aunque no tanto tal que los ojos puedan ver los peldaños inmediatamente superiores al
que se pisa, y respirando lenta y regularmente. Para subir una escalera se comienza por levantar esa
parte del cuerpo situada a la derecha abajo, envuelta casi siempre en cuero o gamuza, y que salvo
excepciones cabe exactamente en el escalón. Puesta en el primer peldaño dicha parte, que para
abreviar llamaremos pie, se recoge la parte equivalente de la izquierda (también llamada pie, pero que
no ha de confundirse con el pie antes citado), y llevándola a la altura del pie, se le hace seguir hasta
colocarla en el segundo peldaño, con lo cual en éste descansará el pie, y en el primero descansará el
pie. (Los primeros peldaños son siempre los más difíciles, hasta adquirir la coordinación necesaria. La
coincidencia de nombre entre el pie y el pie hace difícil la explicación. Cuídese especialmente de no
levantar al mismo tiempo el pie y el pie).
Llegando en esta forma al segundo peldaño, basta repetir alternadamente los movimientos hasta
encontrarse con el final de la escalera. Se sale de ella fácilmente, con un ligero golpe de talón que la
fija en su sitio, del que no se moverá hasta el momento del descenso.
Ejemplo:
Elaborar Tortilla de patatas a la española (6 personas)
Ingredientes:
- 2 vasos (de los de agua) de aceite (1/2 litro)
- Sal
- 8 huevos
- 1 kg de patatas
Se pelan las patatas, se lavan y se secan con un paño; se parten en dos a lo largo y después se cortan
en láminas finitas. Se pone el aceite a calentar en la sartén y se fríen las patatas, moviéndolas de vez
en cuando y echándoles un poco de sal.
Una vez fritas (más o menos doradas, según gusten), se separan y se ponen a escurrir en un colador
grande. Se quita el aceite sobrante de la sartén.
Aparte se baten los huevos con tenedor y muy fuerte; se pone un poco de sal; en el mismo plato de los
huevos se echan las patatas y se mueven con un tenedor.
En una sartén grande (o en dos pequeñas) se ponen 3 cucharadas soperas de aceite para que sólo cubra
el fondo. Cuando está caliente se vierte la mezcla de huevos y patatas. Se mueve la sartén por el
mango para que no se pegue la tortilla. Cuando se vea que está bien despegada y dorada (esto depende
Informática I. Versión 1.0 Agosto de 2004.
71](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-71-320.jpg)
![Universidad Autónoma de Occidente
public static void main( String args[ ] ) throws IOException {
/*
Para recibir los datos vía teclado, debe crear un objeto (que aquí se ha
llamado br) de la clase BufferedReader
Observe que al constructor de la clase BufferedReader se le envía como
argumento una nueva instancia (= objeto) de la clase InputStreamReader
Para obtener esta nueva instancia de la clase InputStreamReader, se ha
enviado a su constructor la variable de clase in de la clase System
*/
// Si lo anterior le parece un trabalenguas, por favor no se alarme,
// no tire la toalla. por el momento, procure memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de los coeficientes, del discriminante y de las raíces:
double a, b, c ; // Coeficientes de la ecuación ( a != 0 ).
double d; // Discriminante de la cuadrática: d = b * b - 4 * a * c
double x, x1, x2 ; // Raíces de la ecuación.
// Lectura, vía teclado, de los coeficientes:
System.out.print( "Digite el valor del coeficiente a (a diferente de cero): " ) ;
a = Double.parseDouble( br.readLine( ) ) ;
System.out.print( "Digite el valor del coeficiente b: " ) ;
b = Double.parseDouble(br.readLine( ) ) ;
System.out.print( "Digite el valor del coeficiente c: " ) ;
c = Double.parseDouble(br.readLine( ) ) ;
// Calcula el discriminante:
d=b*b-4*a*c;
if( d == 0 ) {
x = - b / (2 * a) ;
System.out.println( "Dos raices iguales: X = " + x ) ;
}
else if( d > 0 ) {
x1 = ( - b + Math.sqrt( d ) ) / (2 * a) ;
x2 = ( - b - Math.sqrt( d ) ) / (2 * a) ;
System.out.println( "Raices reales diferentes: " ) ;
System.out.println( " X1 = " + x1 ) ;
System.out.println( " X2 = " + x2 ) ;
}
else
System.out.println( "La ecuacion NO tiene raices reales" ) ;
System.exit( 0 ) ; // Termine el programa (salir del sistema)
} // Fin del método main( )
} // Fin de la clase Cuadratica
Informática I. Versión 1.0 Agosto de 2004.
80](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-80-320.jpg)
![Universidad Autónoma de Occidente
normalmente la indentación (sangría en el margen izquierdo) de diferentes líneas para ayudar a
delimitar visualmente cada una de las estructuras utilizadas. El siguiente es el programa escrito en
Java:
import java.io.* ;
class EsPar1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int n ;
// Entrada de datos:
System.out.print( "Digite un numero entero positivo: " ) ;
n = Integer.parseInt( br.readLine( ) ) ;
// Ciclo while que verifica si n es par:
while(n > 2) {
n=n-2;
}
if(n == 2)
System.out.println( "El numero ingresado es par" ) ;
else
System.out.println( "El numero ingresado es impar" ) ;
System.exit( 0 ) ;
} //Fin del método main( )
} // Fin de la clase EsPar1
Variables
Una variable es una localización o casilla en la memoria principal que almacena un valor que puede
cambiar en el transcurso de la ejecución del programa. Cuando un programa necesita almacenar un
dato, necesita una variable. Toda variable tiene un nombre, un tipo de dato y un valor. Antes de
poder utilizar una variable es necesario declararla especificando su nombre y su tipo de dato. Para
declarar variables usaremos los siguientes formatos:
Informática I. Versión 1.0 Agosto de 2004.
82](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-82-320.jpg)
![Universidad Autónoma de Occidente
import java.io.* ;
class Rectangulo1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
double base, altura, area, perimetro ;
// Entrado de datos:
System.out.print( "Digite el valor de la base [cm]: " ) ;
base = Double.parseDouble( br.readLine( ) ) ;
System.out.print( "Digite el valor de la altura [cm]: " ) ;
altura = Double.parseDouble( br.readLine( ) ) ;
// Proceso de cálculo
area = base * altura ;
perimetro = 2 *(base + altura) ;
// Salida de resultados
System.out.println( "Area del rectangulo: " + area + " cm2" ) ;
System.out.println( "Perimetro del rectangulo: " + perimetro + " cm" ) ;
System.exit( 0 ) ;
} //Fin del método main( )
} // Fin de la clase Rectangulo1
Salida:
Ejercicio 2:- Diseñe un pseudocódigo para convertir una longitud dada en metros a sus equivalentes
en centímetros, pies, pulgadas y yardas. Considere que: 1 metro = 100 centímetros, 1 pulgada = 2.54
centimetros, 1 pie = 12 pulgadas, 1 yarda = 3 pies.
Algoritmo
INICIO
// Declaración de variables
REAL cmetr,ccent, cpies, cpulg, cyard
Informática I. Versión 1.0 Agosto de 2004.
88](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-88-320.jpg)
![Universidad Autónoma de Occidente
// Entrada de datos
LEER cmetr
// Proceso de cálculo
ccent = cmetr * 100
cpulg = ccent / 2.54
cpies = cpulg / 12
cyard = cpies / 3
// Salida de resultados
IMPRIMIR ccent, cpulg, cpies, cyard
FIN
Veamos el algoritmo anterior escrito en Java:
import java.io.* ;
class Conversiones1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
double cmetr,ccent, cpies, cpulg, cyard ;
// Entrado de datos:
System.out.print( "Digite la cantidad en metros: " ) ;
cmetr = Double.parseDouble( br.readLine( ) ) ;
// Proceso de cálculo
ccent = cmetr * 100 ;
cpulg = ccent / 2.54 ;
cpies = cpulg / 12 ;
cyard = cpies / 3 ;
// Salida de resultados
System.out.println( "Cantidad equivalente en centimetros: " + ccent + " cm" ) ;
System.out.println( "Cantidad equivalente en pulgadas: " + cpulg + " pulgadas" ) ;
System.out.println( "Cantidad equivalente en pies: " + cpies + " pies" ) ;
System.out.println( "Cantidad equivalente en yardas: " + cyard + " yardas" ) ;
System.exit( 0 ) ;
} //Fin del método main( )
Informática I. Versión 1.0 Agosto de 2004.
89](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-89-320.jpg)
![Universidad Autónoma de Occidente
} // Fin de la clase Conversiones1
Ejercicio 3:- Una institución benéfica europea ha recibido tres donaciones en soles, dolares y marcos.
La donación será repartida en tres rubros: 70% para la implementación de un centro de salud, 20%
para un comedor de niños y el resto para gastos administrativos. Diseñe un algoritmo que determine el
monto en euros que le corresponde a cada rubro. Considere que: 1 dólar = 3.52 soles, 1 dólar = 2.08
marcos, 1 dólar = 1.07 euros.
Algoritmo
INICIO
// Declaración de variables
REAL csoles, cdolares, cmarcos, ceuros, rubro1, rubro2, rubro3
// Entrada de datos
LEER csoles, cdolares, cmarcos
// Proceso de cálculo
ceuros = (csoles / 3.52 + cdolares + cmarcos / 2.08 ) * 1.07
rubro1 = ceuros * 0.70
rubro2 = ceuros * 0.20
rubro3 = ceuros * 0.10
// Salida de resultados
IMPRIMIR rubro1, rubro2, rubro3
FIN
Veamos el algoritmo anterior escrito en Java:
import java.io.* ;
class Euros1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
double csoles, cdolares, cmarcos, ceuros, rubro1, rubro2, rubro3 ;
// Entrada de datos:
System.out.print( "Digite la cantidad de dinero en soles: $ " ) ;
csoles = Double.parseDouble( br.readLine( ) ) ;
System.out.print( "Digite la cantidad de dinero en dolares: U$ " ) ;
Informática I. Versión 1.0 Agosto de 2004.
90](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-90-320.jpg)
![Universidad Autónoma de Occidente
// Cálculo de la velocidad en km/hr
velkmhr = espkm / thor
// Salida de resultados
IMPRIMIR velkmhr
FIN
Veamos el algoritmo anterior escrito en Java:
import java.io.* ;
class VelocidadAtleta1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int tmin, tseg, tcen ;
double espmt, thor, espkm, velkmhr ;
// Entrada de datos:
System.out.print( "Digite el tiempo empleado en minutos: " ) ;
tmin = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite el tiempo empleado en segundos: " ) ;
tseg = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite el tiempo empleado en centesimas de segundos: " ) ;
tcen = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite el espacio recorrido en metros: " ) ;
espmt = Double.parseDouble( br.readLine( ) ) ;
// Proceso de cálculo
// Cálculo del tiempo total empleado en horas:
thor = tmin / 60.0 + tseg / 3600.0 + (tcen / 100.0) / 3600.0 ; // Aquí sobran los
// paréntesis. Se dejan por claridad.
// Cálculo del espacio recorrido en kilómetros:
espkm = espmt / 1000 ;
// Cálculo de la velocidad en km/hr:
velkmhr = espkm / thor ;
// Salida de resultados
System.out.println( "Velocidad del atleta: " + velkmhr + " Km / Hr." ) ;
System.exit( 0 ) ;
} //Fin del método main( )
} // Fin de la clase VelocidadAtleta1
Informática I. Versión 1.0 Agosto de 2004.
92](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-92-320.jpg)
![Universidad Autónoma de Occidente
Ejercicio 5:- Diseñe un algoritmo que determine la cifra de las unidades de un número natural.
Solución 1
Análisis
Puede comprobarse que la cifra de las unidades de un número es igual al resto de la división del
número entre 10. Observe para ello las siguientes divisiones:
3245 | 10 768 | 10 9 | 10
5 324 8 76 9 0
Podemos concluir entonces que:
unidades = numero % 10
Siendo % el operador residuo. Este operador permite obtener el residuo de una división, así como /
permite obtener el cociente.
Algoritmo
INICIO
// Declaración de variables
ENTERO numero, unidades
// Entrada de datos
LEER numero
// Proceso de cálculo
unidades = numero % 10
// Salida de resultados
IMPRIMIR unidades
FIN
El algoritmo anterior, escrito en Java, queda así:
import java.io.* ;
class UnidadesNumero1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int num, unidades ;
// Entrada de datos:
System.out.print( "Digite un numero entero positivo: " ) ;
num = Integer.parseInt( br.readLine( ) ) ;
Informática I. Versión 1.0 Agosto de 2004.
93](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-93-320.jpg)
![Universidad Autónoma de Occidente
unidades = num % 10 ;
System.out.println( num + " tiene " + unidades +
" como cifra de las unidades." ) ;
System.exit( 0 ) ;
} //Fin del método main( )
} // Fin de la clase UnidadesNumero1
Salida:
Solución 2
Análisis
El residuo de una división entera puede obtenerse también sin recurrir al operador %, de la siguiente
forma:
unidades = numero - (numero / 10) * 10
observe para esto que en la división (numero/10) los operandos son enteros por lo que el cociente
será un entero. Así por ejemplo, si numero es igual a 3245, la división (numero/10) produce 324,
aunque matemáticamente sea 324.5; es decir, se descarta la parte decimal.
Algoritmo
INICIO
// Declaración de variables
ENTERO numero, unidades
// Entrada de datos
LEER numero
// Proceso de cálculo
unidades = numero - (numero / 10) * 10
// Salida de resultados
IMPRIMIR unidades
FIN
El algoritmo anterior, escrito en Java, queda así:
import java.io.* ;
class UnidadesNumero2 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
Informática I. Versión 1.0 Agosto de 2004.
94](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-94-320.jpg)
![Universidad Autónoma de Occidente
LEER N
// Proceso de cálculo
unidades = N % 10
cociente = N / 10
decenas = cociente % 10
cociente = cociente / 10
centenas = cociente % 10
millares = cociente/10
suma = unidades + decenas + centenas + millares
// Salida de resultados
IMPRIMIR suma
FIN
El algoritmo anterior, escrito en Java, queda así:
import java.io.* ;
class SumaCifrasNum1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int num, unidades, decenas, centenas, millares, cociente, suma ;
// Entrada de datos:
System.out.print( "Digite un numero entero positivo de 4 cifras: " ) ;
num = Integer.parseInt( br.readLine( ) ) ;
// Proceso de cálculo:
unidades = num % 10 ;
cociente = num / 10 ;
decenas = cociente % 10 ;
cociente = cociente / 10 ;
centenas = cociente % 10 ;
millares = cociente / 10 ;
suma = unidades + decenas + centenas + millares ;
System.out.println( "Suma de las cifras del numero: " + suma ) ;
Informática I. Versión 1.0 Agosto de 2004.
96](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-96-320.jpg)
![Universidad Autónoma de Occidente
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int num, unidades, decenas, centenas, millares, resto, suma ;
// Entrada de datos:
System.out.print( "Digite un numero entero positivo de 4 cifras: " ) ;
num = Integer.parseInt( br.readLine( ) ) ;
// Proceso de cálculo:
millares = num / 1000 ;
resto = num % 1000 ;
centenas = resto / 100 ;
resto = resto % 100 ;
decenas = resto / 10 ;
unidades = resto % 10 ;
suma = unidades + decenas + centenas + millares ;
System.out.println( "Suma de las cifras del numero: " + suma ) ;
System.exit( 0 ) ;
} //Fin del método main( )
} // Fin de la clase SumaCifrasNum2
Salida:
Ejercicio 7:- Diseñe un algoritmo que lea la hora actual del día HH:MM:SS y determine cuántas
horas, minutos y segundos restan para culminar el día.
Algoritmo
INICIO
// Declaración de variables
ENTERO hor1, min1, seg1, hor2, min2, seg2, segres, resto
Informática I. Versión 1.0 Agosto de 2004.
98](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-98-320.jpg)
![Universidad Autónoma de Occidente
// Entrada de datos
LEER hor1, min1, seg1
// Cálculo de la cantidad de segundos que restan para culminar el día
segres = 86400 - (hor1 * 3600 + min1 * 60 + seg1)
// Descomposición de segres en horas, minutos y segundos
hor2 = segres / 3600
resto = segres % 3600
min2 = resto / 60
seg2 = resto % 60
// Salida de resultados
IMPRIMIR hor2, min2, seg2
FIN
Así queda en Java:
import java.io.* ;
class HmsQueFaltan1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int hor1, min1, seg1, hor2, min2, seg2, segres, resto ;
// Entrada de datos:
System.out.print( "Digite la hora MILITAR actual (numero entero): " ) ;
hor1 = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite los minutos actuales (numero entero): " ) ;
min1 = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite los segundos actuales (numero entero): " ) ;
seg1 = Integer.parseInt( br.readLine( ) ) ;
// Proceso de cálculo.
// *******************
// Cálculo de la cantidad de segundos que restan para culminar el día:
segres = 86400 - (hor1 * 3600 + min1 * 60 + seg1) ;
// Descomposición de segres en horas, minutos y segundos:
hor2 = segres / 3600 ;
resto = segres % 3600 ;
min2 = resto / 60 ;
seg2 = resto % 60 ;
Informática I. Versión 1.0 Agosto de 2004.
99](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-99-320.jpg)
![Universidad Autónoma de Occidente
// Salida de resultados
System.out.println( "Para terminar el dia, hacen falta: " +
hor2 + " horas, " + min2 + " minutos y " + seg2 + " segundos." ) ;
System.exit( 0 ) ;
} //Fin del método main( )
} // Fin de la clase HmsQueFaltan1
Salida:
Ejercicio 8:- Diseñe un algoritmo para sumar dos tiempos dados en horas, minutos y segundos.
Algoritmo
INICIO
// Declaración de variables
ENTERO hor1, min1, seg1, hor2, min2, seg2, hor3, min3, seg3, totseg, resto
// Entrada de datos
LEER hor1, min1, seg1, hor2, min2, seg2
// Determina la cantidad total de segundos entre los dos tiempos
totseg = (hor1 + hor2) * 3600 + (min1 + min2) * 60 + (seg1 + seg2)
// Descompone totseg en horas, minutos y segundos
hor3 = totseg / 3600
resto = totseg % 3600
min3 = resto / 60
seg3 = resto % 60
// Salida de resultados
IMPRIMIR hor3, min3, seg3
FIN
Así queda en Java:
import java.io.* ;
class HmsQueFaltan2 {
public static void main( String args[ ] ) throws IOException {
Informática I. Versión 1.0 Agosto de 2004.
100](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-100-320.jpg)
![Universidad Autónoma de Occidente
Salida:
Ejercicio 9:- El sueldo neto de un vendedor se calcula como la suma de un sueldo básico de
$2’500.000.oo más el 12% del monto total vendido. Diseñe un algoritmo que determine el sueldo
neto de un vendedor sabiendo que hizo tres ventas en el mes.
Algoritmo
INICIO
// Declaración de variables
REAL venta1, venta2, venta3, ventatot, comision, sueldoneto
// Entrada de datos
LEER venta1, venta2, venta3
// Proceso de cálculo
ventatot = venta1 + venta2 + venta3
comision = ventatot * 12 / 100
sueldoneto = 2500000 + comision
// Salida de resultados
IMPRIMIR sueldoneto
FIN
Así queda en Java:
import java.io.* ;
class SueldoNeto1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de una constante:
final float $BASICO = 2500000 ;
// Declaración de variables:
float venta1, venta2, venta3, ventatot, comision, sueldoneto ;
// Entrada de datos:
Informática I. Versión 1.0 Agosto de 2004.
102](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-102-320.jpg)
![Universidad Autónoma de Occidente
total = varones + mujeres
porcvar = varones * 100.0 / total
porcmuj = mujeres * 100.0 / total
// Salida de resultados
IMPRIMIR porcvar, porcmuj
FIN
En Java:
import java.io.* ;
class MujHom1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
double porcvar, porcmuj ;
int varones, mujeres, total ;
// Entrada de datos:
System.out.print( "Digite el numero de Damas: " ) ;
mujeres = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite el numero de Caballeros: " ) ;
varones = Integer.parseInt( br.readLine( ) ) ;
// Proceso de cálculo:
total = varones + mujeres ;
porcvar = varones * 100.0 / total ;
porcmuj = mujeres * 100.0 / total ;
System.out.println( "**********************************************" ) ;
// Salida de resultados:
System.out.println( "Porcentaje de mujeres: " + porcmuj + " %" ) ;
System.out.println( "Porcentaje de hombres: " + porcvar + " %" ) ;
System.exit( 0 ) ;
} //Fin del método main( )
} // Fin de la clase MujHom1
Salida:
Informática I. Versión 1.0 Agosto de 2004.
104](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-104-320.jpg)
![Universidad Autónoma de Occidente
Ejercicio 11:- En países de habla inglesa es común dar la estatura de una persona como la suma de
una cantidad entera de pies más una cantidad entera de pulgadas. Así, la estatura de una persona
podría ser 3' 2" ( 3 pies 2 pulgadas ). Diseñe un algoritmo que determine la estatura de una persona
en metros, conociendo su estatura en el formato inglés. Considere que: 1 pie = 12 plg, 1 plg = 2.54
cm, 1 m = 100 cm.
Algoritmo
INICIO
// Declaración de variables
REAL estmt
ENTERO cpies, cplgs
// Entrada de datos
LEER cpies, cplgs
// Proceso de cálculo
estmt = (cpies * 12 + cplgs) * 2.54 / 100
// Salida de resultados
IMPRIMIR estmt
FIN
En Java:
import java.io.* ;
class EstaturaMts1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int cpies, cplgs ;
double estmt ;
// Entrada de datos:
System.out.print( "De la estatura, digite el numero (entero) de pies: " ) ;
cpies = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "De la estatura, digite el numero (entero) de pulgadas: " ) ;
cplgs = Integer.parseInt( br.readLine( ) ) ;
Informática I. Versión 1.0 Agosto de 2004.
105](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-105-320.jpg)
![Universidad Autónoma de Occidente
import java.io.* ;
class CapacidadDiscoDuro1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
double cgigabyte, cmegabyte, ckilobyte, cbyte ;
// Entrada de datos:
System.out.print( "Digite la capacidad del Disco Duro en Gigabytes: " ) ;
cgigabyte = Double.parseDouble( br.readLine( ) ) ;
// Proceso de cálculo:
cmegabyte = cgigabyte * 1024 ;
ckilobyte = cmegabyte * 1024 ;
cbyte = ckilobyte * 1024 ;
System.out.println( "**********************************************" ) ;
// Salida de resultados:
System.out.println( "La capacidad del Disco Duro es: " + cmegabyte +
" Megabytes,n" + ckilobyte + " Kilobytes yn" + cbyte + " Bytes." ) ;
System.exit( 0 ) ;
} //Fin del método main( )
} // Fin de la clase CapacidadDiscoDuro1
Salida:
Ejercicio 13:- Diseñe un algoritmo que intercambie las cifras de las unidades de dos números
naturales.
Algoritmo
INICIO
// Declaración de variables
ENTERO numero1, numero2, unidades1, unidades2
Informática I. Versión 1.0 Agosto de 2004.
107](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-107-320.jpg)
![Universidad Autónoma de Occidente
// Entrada de datos
LEER numero1, numero2
// Determina las cifras de las unidades
unidades1 = numero1 % 10
unidades2 = numero2 % 10
// Intercambia las cifras de las unidades
numero1 = numero1 - unidades1 + unidades2
numero2 = numero2 - unidades2 + unidades1
// Salida de resultados
IMPRIMIR numero1, numero2
FIN
En Java:
import java.io.* ;
class IntercambiarUnidades1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int numero1, numero2, unidades1, unidades2 ;
// Entrada de datos:
System.out.print( "Digite un numero entero positivo: " ) ;
numero1 = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite otro numero entero positivo: " ) ;
numero2 = Integer.parseInt( br.readLine( ) ) ;
// Proceso de cálculo:
// *******************
// Determina las cifras de las unidades en cada número:
unidades1 = numero1 % 10 ;
unidades2 = numero2 % 10 ;
// Intercambia solo las cifras de las unidades:
numero1 = numero1 - unidades1 + unidades2 ;
numero2 = numero2 - unidades2 + unidades1 ;
System.out.println( "**********************************************" ) ;
// Salida de resultados:
System.out.println( "Despues de intercambiar la cifra de las unidades,n" +
"los numeros quedan asi:nPrimer numero: " + numero1 +
Informática I. Versión 1.0 Agosto de 2004.
108](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-108-320.jpg)
![Universidad Autónoma de Occidente
class EstructuraSecuencial1 {
// Mètodo principal:
public static void main( String args[ ] ) throws IOException {
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
double a, b, c; // Declaración de las variables reales a, b y c.
// Lectura, vía teclado, de las variables a y b:
System.out.print( "Digite el valor de la variable a: " ) ;
a = Double.parseDouble( br.readLine( ) ) ;
System.out.print( "Digite el valor de la variable b: " ) ;
b = Double.parseDouble( br.readLine( ) ) ;
// suma los valores de las variables a y b y lo asigna o
// guarda en la variable c:
c=a+b;
// Muestra el valor de c:
System.out.println( " a + b = " + c ) ;
System.exit( 0 ) ; // Termine el programa (salir del sistema)
} // Fin del método main( )
} // Fin de la clase EstructuraSecuencial1
Existe una forma alternativa de expresar una estructura secuencial escribiendo varias acciones en la
misma línea pero utilizando el punto y coma ( ; ) como separador. Sin embargo, esta última notación
es desaconsejable puesto que puede llegar a hacer el código bastante difícil de leer.
leer a; leer b
c a + b; escribir c
Dado que las variables numéricas a y b ya estuvieran
declaradas y hayan sido leídas, entonces las dos últimas
instrucciones se escriben así en Java:
c = a + b ; System.out.println( “Valor de c= “ + c ) ;
En Java:
import java.io.* ; // Importa el paquete de entrada / salida (input / output)
class EstructuraSecuencial2 {
public static void main( String args[ ] ) throws IOException {
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Lectura, vía teclado, de las variables a y b:
System.out.print( "Digite el valor de la variable a: " ) ; double a =
Double.parseDouble( br.readLine( ) ) ;
System.out.print( "Digite el valor de la variable b: " ) ; double b =
Informática I. Versión 1.0 Agosto de 2004.
114](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-114-320.jpg)
![Universidad Autónoma de Occidente
En Java:
if ( radio > 0 ) {
longitud = 2 * Math.PI * radio ;
}
else {
System.out.println( “Error” ) ;
}
Ejemplo:- Informar si un estudiante ha superado o no un determinado examen consistente en 20
preguntas de igual valor y calcular su nota en caso de aprobar.
leer num_correctas
si num_correctas < 12 entonces
escribir “No ha superado Vd. el examen”
faltan = 12 - num_correctas
escribir “Le faltaron ” , faltan
si_no
nota = num_correctas * 0.25
escribir “aprobó Vd. con un ”, nota
fin_si
En Java:
import java.io.* ;
class AprobarExamen1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
String nombre ;
int numOk, faltan ;
float nota ;
// Entrada de datos:
System.out.print( "Digite su nombre : " ) ;
nombre = br.readLine( ) ;
System.out.print( "Digite el numero de respuestas correctas (1 a 20): " ) ;
numOk = Integer.parseInt( br.readLine( ) ) ;
// Sentencia de decisión if:
// *************************
if( numOk < 12 ) {
System.out.println( nombre + ", Ud. NO ha ganado el examen!!" ) ;
faltan = 12 - numOk ;
System.out.println( "Le faltaron " + faltan +
" respuestas correctas para obtener 3.0 !!" ) ;
}
else {
nota = numOk * 0.25F ;
Informática I. Versión 1.0 Agosto de 2004.
117](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-117-320.jpg)
![Universidad Autónoma de Occidente
La implementación de la estructura multialternativa se escribe así, en Java:
switch( expresión ) { // Llave de apertura del bloque switch
case valor1:
// Acción 1: secuencia de instrucciones
break ;
case valor2:
// Acción 2: secuencia de instrucciones
break ;
…
…
…
case valorN:
// Acción N: secuencia de instrucciones
break ;
default: // El caso default: es opcional
// Acción: secuencia de instrucciones
break ; // Aquí, el break ; es opcional, pues es la última del bloque switch
} // Llave de cierre del bloque switch
En el siguiente ejemplo se proporciona como salida el número de días de un mes dado:
segun mes
caso 1,3,5,7,8,10,12:
escribir ‘31’
caso 4,6,9,11:
escribir ‘30’
caso 2:
escribir ‘28’
otro caso:
escribir ‘Mes incorrecto’
fin según
A continuación, la implementación en Java:
import java.io.* ; // Importa el paquete de entrada / salida (input / output)
class EstructuraMultialternativa1_switch {
// Método principal:
public static void main( String args[ ] ) throws IOException {
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
int mes ; // Declaración de la variable entera mes
// Lectura, vía teclado, de la variable entera mes
System.out.print( "Digite un numero entero [1 a 12] para el mes: " ) ;
mes = Integer.parseInt( br.readLine( ) ) ;
// Se utilizará una instrucción switch para determinar el número de
// días del mes digitado (número entero de 1 a 12):
Informática I. Versión 1.0 Agosto de 2004.
119](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-119-320.jpg)
![Universidad Autónoma de Occidente
Estructura repetitiva
La estructura repetitiva o iterativa permite, como su propio nombre lo indica, repetir una acción (o
grupo de acciones); dicha repetición puede llevarse a cabo un número prefijado de veces o depender
de la evaluación de una expresión lógica. Existen tres tipos de estructuras repetitivas: desde-hasta (ó
Para), mientras y repetir-hasta.
Estructura desde-hasta (ó Para)
Esta estructura permite repetir la ejecución de una acción o de un grupo de acciones un número
determinado de veces; la sintáxis es la siguiente:
desde indice = inicio hasta fin [con valor de paso] hacer
acción
fin desde
La estructura repetitiva desde-hasta (ó Para) se implementa así, en Java:
for( inicialización; condición; iteración ) {
// Acción: secuencia de instrucciones
}
1. El ciclo (ó bucle) for es controlado por una variable que, por su oficio, también se denomina variable de
control.
2. En su forma más común, la parte de inicialización del ciclo asigna un valor inicial a la variable de control
del ciclo.
3. La condición es una expresión booleana que analiza la variable de control del ciclo. Si el resultado de ese
análisis es true (verdadero), el ciclo for continúa. Si es false (falso), el ciclo termina.
4. La expresión iteración determina cómo cambia el valor de la variable de control del ciclo en cada iteración
del mismo.
A continuación se muestran algunos ejemplos:
Seudocódigo:
desde n 1 hasta 10 hacer
escribir n
fin desde
Código Java:
for( int n = 1; n <= 10; n = n + 1 ) {
System.out.println( “n = “ + n ) ;
}
El ciclo anterior imprime por pantalla los números del 1 al 10.
Ahora, preste atención al siguiente seudocódigo:
desde n 10 hasta 0 hacer
escribir n
Informática I. Versión 1.0 Agosto de 2004.
121](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-121-320.jpg)
![Universidad Autónoma de Occidente
fin desde
que, escrito en código Java, es:
for( int n = 10; n <= 0; n = n + 1 ) {
System.out.println( “n = “ + n ) ;
}
El bucle anterior no se ejecuta nunca puesto que, de entrada, la condición n <= 0 (con n = 10) arroja
false. ¿Qué ocurriría si, en el ciclo anterior, se cambia < por > ? Analice y responda !!
Si queremos hacer lo anterior, por ejemplo con paso – 2, el seudocódigo se puede escribir así:
desde n 10 hasta 0 con paso –2 hacer
escribir n
fin desde
que, escrito en Java, es:
for( int n = 10; n >= 0; n = n - 2 ) {
System.out.println( “n = “ + n ) ;
}
Este bucle escribe los números pares de 10 a 0 en orden inverso.
La siguiente aplicación Java resume estos casos:
class CicloFor1 {
public static void main( String args[ ] ) {
int n ; // Declara la variable entera n. Ésta,
// será la variable de control del ciclo.
// Ciclo for con paso unitario positivo:
for( n = 1; n <= 10; n = n + 1 ) {
System.out.print( n + ", " ) ;
}
System.out.println( "n Ahora, el ciclo for con el paso negativo (-2):" ) ;
// Ciclo for con paso negativo (-2):
for( n = 10; n >= 0; n = n - 2 ) {
System.out.print( n + ", " ) ;
}
System.out.println( ) ;
System.exit( 0 ) ;
}
}
Informática I. Versión 1.0 Agosto de 2004.
122](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-122-320.jpg)
![Universidad Autónoma de Occidente
Salida:
Estructura mientras (while)
Esta estructura repite una acción o grupo de acciones
mientras una expresión lógica sea cierta; la sintáxis en la
notación algorítmica y en JAVA es la siguiente:
mientras <expresión lógica> hacer
acción
fin mientras
Así queda en Java:
while( <Condición> ) {
// Acción: conjunto de
// instrucciones que conforman el
// cuerpo del ciclo.
}
Un aspecto muy importante de la presente estructura de control es que si la expresión lógica es
inicialmente falsa el bucle no se ejecuta ni una sola vez; es decir, la estructura mientras supone que el
bucle iterará 0 ó más veces.
A continuación se muestra un ejemplo que solicita al usuario el radio de una circunferencia mientras
el radio introducido sea incorrecto:
mientras radio<0 hacer
escribir ‘Radio?’
leer radio
fin desde
En Java:
import java.io.* ; // Importa el paquete de entrada / salida (input / output)
class EstructuraMientras1 {
// Método principal:
public static void main( String args[ ] ) throws IOException {
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
double radio ; // Declaración de la variable real radio
// Lectura, vía teclado, de la variable radio:
System.out.print( "Digite el valor del radio (cm): " ) ;
radio = Double.parseDouble( br.readLine( ) ) ;
System.out.println( "Radio antes del ciclo: " + radio ) ;
Informática I. Versión 1.0 Agosto de 2004.
123](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-123-320.jpg)
![Universidad Autónoma de Occidente
System.out.println( "*******************************" ) ;
while( radio < 0 ) { // LLave de apertura del bloque while
// Lee de nuevo, vía teclado, el radio:
System.out.print( "Digite el valor [ >= 0 ] del radio (cm): " ) ;
radio = Double.parseDouble( br.readLine( ) ) ;
System.out.println( "Radio dentro del ciclo: " + radio ) ;
} // LLave de cierre del bloque while
System.out.println( "*******************************" ) ;
// Muestra el último valor del radio:
System.out.println( "Ultimo valor del radio: " + radio ) ;
System.exit( 0 ) ; // Termine el programa (salir del sistema)
} // Fin del método main( )
} // Fin de la clase EstructuraMientras1
Notar que mientras radio < 0 el ciclo se ejecuta.
Ahora, note en la siguiente salida, que si desde la primera vez se digita un radio positivo,
entonces el ciclo while no se ejecuta:
Estructura haga-mientras (do-while)
Esta estructura repite una acción o grupo de acciones mientras una expresión lógica sea verdadera.
La sintáxis en la notación algorítmica es la siguiente:
haga Así queda en Java:
acción do {
mientras <expresión lógica> // Acción: conjunto de
// instrucciones que conforman el
// cuerpo del ciclo.
} while( <Condición> ) ;
Informática I. Versión 1.0 Agosto de 2004.
124](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-124-320.jpg)
![Universidad Autónoma de Occidente
Un aspecto muy importante de la presente estructura de control es que la expresión lógica se evalúa al
final; por tanto, el bucle se ejecuta al menos una vez, como una alternativa a la estructura anterior
(while), la cual podría nunca ejecutarse. El siguiente diagrama de flujo ilustra el ciclo haga-mientras:
Punto de entrada
Acción
Verdadero
Expresión
lógica
Falso
Punto de salida
Se aplicará la estructura de control do-while del lenguaje de programación Java, en la
implementación de un sencillo menú:
import java.io.*;
class Menu3 {
public static void main( String args[] ) throws IOException {
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
int opcion;
do {
System.out.println( " Opciones del menu:" ) ;
System.out.println( " ******************" ) ;
System.out.println( ) ;
System.out.println( " 1.- Opcion 1" ) ;
System.out.println( " 2.- Opcion 2" ) ;
System.out.println( " 3.- Opcion 3" ) ;
System.out.println( " 4.- Opcion 4" ) ;
System.out.println( " 5.- Terminar" ) ;
System.out.println( ) ;
System.out.print( "n Ingrese su opcion: " ) ;
Informática I. Versión 1.0 Agosto de 2004.
125](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-125-320.jpg)
![Universidad Autónoma de Occidente
Ejercicios Resueltos
Ejercicio 1:- En una playa de estacionamiento cobran $ 2.5 por hora o fracción. Diseñe un
algoritmo que determine cuánto debe pagar un cliente por el estacionamiento de su vehículo,
conociendo el tiempo de estacionamiento en horas y minutos.
Algoritmo 1
INICIO
// Declaración de variables
ENTERO horas, minutos
REAL pago
// Entrada de datos
LEER horas, minutos
// Si hay alguna fracción de hora, incrementa las horas a pagar en una unidad
SI( minutos > 0 )
horas = horas + 1
// Determina el importe a pagar
pago = horas * 2.5
// Salida de resultados
IMPRIMIR pago
FIN
Así queda en Java:
import java.io.* ;
class CobroEstacionamiento1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int horas, minutos ;
float pago ;
// Entrada de datos:
System.out.print( "Digite el numero [entero] de horas: " ) ;
horas = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite el numero de minutos [0 a 59]: " ) ;
minutos = Integer.parseInt( br.readLine( ) ) ;
// Si hay alguna fracción de hora, incrementa las horas a
// pagar en una unidad:
if( minutos > 0 ) {
Informática I. Versión 1.0 Agosto de 2004.
127](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-127-320.jpg)
![Universidad Autónoma de Occidente
class CobroEstacionamiento2 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int horas, minutos, horasPagar ;
float pago ;
// Entrada de datos:
System.out.print( "Digite el numero [entero] de horas: " ) ;
horas = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite el numero de minutos [0 a 59]: " ) ;
minutos = Integer.parseInt( br.readLine( ) ) ;
// Determina el número de horas a pagar:
if( minutos > 0 ) {
horasPagar = horas + 1 ;
}
else {
horasPagar = horas ;
}
// Determina el importe a pagar:
pago = (float) (horasPagar * 2.5) ; // Promocione a (casting) tipo float
// Salida de resultados:
System.out.println( "Valor a pagar: $" + pago ) ;
System.exit( 0 ) ;
} //Fin del método main( )
} // Fin de la clase CobroEstacionamiento2
Salida:
Informática I. Versión 1.0 Agosto de 2004.
129](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-129-320.jpg)
![Universidad Autónoma de Occidente
Ejercicio 2:- Diseñe un algoritmo que determine si ún número es o no es, par positivo.
Algoritmo
INICIO
// Declaración de variables
REAL numero
CADENA tipoNumero
// Entrada de datos
LEER numero
// Determina si el número es o no es, par positivo
SI( (numero %2 ==0) && (numero > 0) )
tipoNumero = "El número es par positivo"
SINO
tipoNumero = "El número no es par positivo"
// Salida de resultados
IMPRIMIR tipoNumero
FIN
Así queda en Java:
import java.io.* ;
class EsParPositivo1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
float numero ;
String tipoNumero ;
// Entrada de datos:
System.out.print( "Digite un numero: " ) ;
numero = Float.parseFloat( br.readLine( ) ) ;
// Determina si el número es o no es, par positivo:
if( (numero %2 ==0) && (numero > 0) ) {
tipoNumero = "El numero es par positivo" ;
}
Informática I. Versión 1.0 Agosto de 2004.
130](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-130-320.jpg)
![Universidad Autónoma de Occidente
IMPRIMIR numeroMayor
FIN
Así queda en Java:
import java.io.* ;
class NumMay1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
float numero1, numero2, numero3, numeroMayor ;
// Entrada de datos:
System.out.print( "Digite el primer numero: " ) ;
numero1 = Float.parseFloat( br.readLine( ) ) ;
System.out.print( "Digite el segundo numero: " ) ;
numero2 = Float.parseFloat( br.readLine( ) ) ;
System.out.print( "Digite el tercer numero: " ) ;
numero3 = Float.parseFloat( br.readLine( ) ) ;
// Determina el número mayor:
numeroMayor = numero1 ;
if( numero2 > numeroMayor )
numeroMayor = numero2 ;
if( numero3 > numeroMayor )
numeroMayor = numero3 ;
// Salida de resultados:
System.out.println( "Numero mayor = " + numeroMayor ) ;
System.exit( 0 ) ;
} //Fin del método main( )
} // Fin de la clase NumMay1
Salida:
Informática I. Versión 1.0 Agosto de 2004.
132](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-132-320.jpg)
![Universidad Autónoma de Occidente
Ejercicio 4:- Una tienda ha puesto en oferta la venta al por mayor de cierto producto, ofreciendo
un descuento del 15% por la compra de más de 3 docenas y 10% en caso contrario. Además por
la compra de más de 3 docenas se obsequia una unidad del producto por cada docena en exceso
sobre 3. Diseñe un algoritmo que determine el monto de la compra, el monto del descuento, el
monto a pagar y el número de unidades de obsequio por la compra de cierta cantidad de docenas
del producto.
Algoritmo
INICIO
// Declaración de variables
REAL montopag, montocom, montodes, precio
ENTERO docenas, obsequio
// Entrada de datos
LEER docenas, precio
// Determina el monto de la compra
montocom = docenas * precio
// Determina el monto del descuento y el obsequio
SI( docenas > 3 ) {
montodes = 0.15 * montocom
obsequio = docenas - 3
}
SINO {
montodes = 0.10*montocom
obsequio = 0
}
// Determina el monto a pagar
montopag = montocom - montodes
// Salida de resultados
IMPRIMIR montocom, montodes, montopag, obsequio
FIN
Así queda en Java:
import java.io.* ;
class OfertaDocenasProducto1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
float montopag, montocom, montodes, precio ;
int docenas, obsequio ;
Informática I. Versión 1.0 Agosto de 2004.
133](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-133-320.jpg)
![Universidad Autónoma de Occidente
Ejercicio 5:- Diseñe un algoritmo que lea un número de tres cifras y determine si es o no capicúa.
Un número es capicúa si es igual al revés del número.
Observación
Como el número tiene tres cifras, para ser capicúa basta con que la cifra de las unidades sea igual
a la cifra de las centenas. Por ejemplo: 353, 878, etc.
Algoritmo
INICIO
// Salida de resultados
ENTERO numero, unidades, centenas
CADENA tipoNumero
// Entrada de datos
LEER numero
// Si el número tiene tres cifras...
SI(numero >= 100 && numero <= 999 ){
// Determina la cifra de las unidades y la cifra de las centenas
unidades = numero % 10
centenas = numero / 100
// Determina el tipo de número entre capicúa o no capicúa
SI( unidades == centenas )
tipoNumero = "El número es capicúa"
SINO
tipoNumero = "El número no es capicúa"
// Muestra el tipo de número
IMPRIMIR tipoNumero
}
SINO
IMPRIMIR "Ingrese un número de tres cifras"
FIN
Así queda en Java:
import java.io.* ;
class Capicua1 {
public static void main( String args[ ] ) throws IOException {
Informática I. Versión 1.0 Agosto de 2004.
135](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-135-320.jpg)
![Universidad Autónoma de Occidente
Ejercicio 6:- Diseñe un algoritmo que califique el puntaje obtenido en el lanzamiento de tres
dados con base a la cantidad de 6s obtenidos, de acuerdo a lo siguiente: tres seis, excelente; dos
seis, bien; un seis, regular; ningún seis, mal.
Algoritmo
INICIO
// Declaración de variables
ENTERO dado1, dado2, dado3
CADENA calificacion
// Entrada de datos
LEER dado1, dado2, dado3
// Determina la calificación
SI( dado1 + dado2 + dado3 == 18 )
calificacion = "Excelente"
SINO SI( dado1 + dado2 == 12 || dado2 + dado3 == 12 || dado3 + dado1 == 12 )
calificacion = "Bién"
SINO SI( dado1 == 6 || dado2 == 6 || dado3 == 6 )
calificacion = "Regular"
SINO
calificacion = "Mal"
// Salida de resultados
IMPRIMIR calificacion
FIN
Así queda en Java:
import java.io.* ;
class LanzarTresDados1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
Informática I. Versión 1.0 Agosto de 2004.
137](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-137-320.jpg)
![Universidad Autónoma de Occidente
Ejercicio 7:- Una compañía dedicada al alquiler de automóviles cobra un monto fijo de $ 30 para
los primeros 300 km de recorrido. Para más de 300 km y hasta 1000 km, cobra un monto
adicional de $ 0.15 por cada kilómetro en exceso sobre 300. Para más de 1000 km cobra un
monto adicional de $ 0.10 por cada kilómetro en exceso sobre 1000. Los precios ya incluyen el
18% del impuesto general a las ventas, IGV. Diseñe un algoritmo que determine el monto a pagar
por el alquiler de un vehículo y el monto incluído del impuesto.
Algoritmo
INICIO
// Declaración de variables
REAL kilomrec, montopag, montoigv, montofijo = 30, igv = 0.18
// Entrada de datos
LEER kilomrec
// Determina el monto a pagar
SI( kilomrec <= 300 )
montopag = montofijo
SINO SI( kilomrec <= 1000 )
montopag = montofijo + 0.15 * (kilomrec - 300)
SINO
montopag = montofijo + 0.15 * 700 + 0.10 * (kilomrec - 1000)
// Según el enunciado, para determinar el monto del impuesto (montoigv) tenga en
// cuenta que: x + igv * x = montopag, de donde x = montopag / (1 + igv).
// Entonces montoigv = igv * x = igv * montopag / (1 + igv); o sea:
montoigv = igv * montopag / (1 + igv)
// Salida de resultados
IMPRIMIR montopag, montoigv
FIN
Así queda en Java:
import java.io.* ;
class AlquilerAutos1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de dos constantes:
Informática I. Versión 1.0 Agosto de 2004.
139](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-139-320.jpg)
![Universidad Autónoma de Occidente
// Determina el mayor:
mayor = n1
SI( n2 > mayor )
mayor = n2
SI( n3 > mayor )
mayor = n3
// Determina el medio:
medio = n1+n2+n3-mayor-menor
// Imprime en orden ascendente:
IMPRIMIR menor, medio, mayor
// Imprime en orden descendente
IMPRIMIR mayor, medio, menor:
FIN
Ejercicio 13:- A continuación, se muestra una aplicación Java que solicita números vía teclado y
determina el menor y el mayor de ellos:
import java.io.* ;
class MinMay3A {
public static void main( String args[ ] ) throws IOException {
InputStreamReader isr = new InputStreamReader( System.in ) ;
BufferedReader br = new BufferedReader( isr ) ;
//BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
System.out.print( "Digite la cantidad de numeros que va a ingresar: " ) ;
int n = Integer.parseInt( br.readLine( ) ) ;
System.out.println( ) ; //Deje una línea en blanco.
double num = 0, min = 0, may = 0 ;
for( int k = 1; k <= n; k ++ ) {
System.out.print( "Digite un numero: " ) ;
num = Double.parseDouble( br.readLine( ) ) ;
System.out.println( ) ; //Deje una línea en blanco.
if( k == 1 ) {
min = num ; //Que el PRIMER número leído haga de
may = num ; //número menor y de número mayor.
}
if( num < min ) {
min = num ;
}
if( num > may ) {
Informática I. Versión 1.0 Agosto de 2004.
144](https://image.slidesharecdn.com/moduloinfo-120903235301-phpapp01/85/trabajo1-144-320.jpg)
trabajo1
- 1. Universidad Autónoma deOccidente UNIVERSIDAD AUTÓNOMA DE OCCIDENTE FACULTAD DE INGENIERÍAS DEPARTAMENTO DE CIENCIAS DE LA INFORMACIÓN PROGRAMA DE INGENIERÍA INFORMÁTICA INFORMÁTICA 1 (Algoritmos con Java) MATERIAL RECOPILADO POR LOS PROFESORES J. ANTONIO LEMOS B. Y EDUARDO VICTORIA Z. SANTIAGO DE CALI, AGOSTO DE 2004 Informática I. Versión 1.0 Agosto de 2004 1
- 2. Universidad Autónoma deOccidente ASIGNATURA: INFORMÁTICA 1 CODIGO: 532219 CREDITOS: 3 PRERREQUISITOS: 22 créditos aprobados CARACTERÍSTICAS: HOMOLOGABLE, VALIDABLE FACULTAD: INGENIERÍA PROGRAMA: INGENIERÎAS DEPARTAMENTO QUE FRECE: CIENCIAS DE LA INFORMACIÓN AREA: INFORMÂTICA PERIODO ACADÉMICO: Agosto – Diciembre de 2004 OBJETIVO GENERAL Capacitar al estudiante en el diseño e implementación de algoritmos computacionales, utilizando los conceptos básicos de la algoritmia, e introduciéndolo en el estudio de la programación orientada a objetos. OBJETIVOS ESPECÍFICOS identificar los sistemas básicos de numeración y sus operaciones fundamentales. Comprender las operaciones básicas de la lógica booleana. Modelar procesos mediante técnicas algorítmicas. Reconocer y aplicar correctamente las diferentes estructuras de decisión y de repetición en programación de computadores. Conocer y apropiar el paradigma Orientado a Objetos y su aplicación en la programación. CONTENIDO PROGRAMÁTICO UNIDAD 1 - Sistemas numéricos Pág. 7 1.1 Sistema binario 1.2 Sistema octal 1.3 Sistema hexadecimal 1.4 Sistema decimal 1.5 Conversión entre sistemas 1.6 Suma y resta binaria 1.7 Código ASCII y UNICODE 1.8 Clase práctica UNIDAD 2 - Sistemas lógicos Pág. 15 2.1 Conectivos relacionales y lógicos 2.2 Proposiciones lógicas simples y compuestas 2.3 Tablas de verdad para las operaciones lógicas básicas 2.4 Clase práctica UNIDAD 3 - Herramienta de Programación Pág. 29 Informática I. Versión 1.0 Agosto de 2004 2
- 3. Universidad Autónoma deOccidente 3.1 Breve historia de los estilos de Programación 3.2 Origen del paradigma Orientado a Objetos 3.3 Definiciones de clases y objetos 3.4 Características básicas del lenguaje Java 3.5 Construcción básica de una aplicación 3.6 Entrada de datos estándar 3.7 Salida de datos estándar 3.8 Descarga e instalación del lenguaje 3.9 Compilación y ejecución de una aplicación 3.10 Clase práctica UNIDAD 4 - Tipos de datos, variables y Operadores (Java) Pág. 61 4.1 Variables 4.2 Palabras reservadas 4.3 Tipos de datos 4.4 Promoción de datos (Casting) 4.5 Operadores aritméticos 4.6 Operador módulo ( % ) 4.7 Operadores de asignación 4.8 Operadores de incremento y decremento 4.9 Operadores relacionales 4.10 Operadores lógicos boléanos 4.11 Precedencia y asociatividad de los operadores 4.12 Clase práctica UNIDAD 5 – Algoritmos Pág. 69 5.1 Historia de la programación 5.2 Tipos de Algoritmos 5.3 Representación de los Algoritmos 5.4 Propiedades de los Algoritmos 5.5 Clase práctica UNIDAD 6 - Sentencias de control en Java Pág. 113 6.1 Sentencias de decisión o selección 6.1.2 Selección simple ( if ) 6.1.3 Selección doble ( if – else ; if – else - if ) 6.1.4 Selección múltiple ( switch ) 6.2 Sentencias de Repetición ( ciclos o bucles): 6.2.1 Ciclo para ( for ) 6.2.2 Ciclo mientras ( while ) 6.2.3 Ciclo haga mientras ( do – while ) 6.3 Clase práctica UNIDAD 7 – Arreglos 7.1 Definición de Arreglos 7.2 Arreglos Unidimensionales Informática I. Versión 1.0 Agosto de 2004 3
- 4. Universidad Autónoma deOccidente METODOLOGÍA El profesor dedicará 180 minutos semanales (dos bloques de 90 minutos) a las actividades presenciales, las cuales estarán compuestas por: 1) Clases teórico-prácticas en las cuales el profesor expondrá cada uno de los nuevos temas con ejemplos descriptivos y asignará las lecturas y prácticas necesarias. 2) Talleres (Prácticas Dirigidas) en los cuales, por grupo de estudio, se resolverán ejercicios. El profesor asesorará a los grupos. Al final todos los estudiantes deberán tener resueltos los ejercicios y cada grupo avanzará en el proceso de conocimiento según su particular interés y necesidad de saber. Estos ejercicios realizados en clase deberán ser implementados en computador en las prácticas de laboratorio. 3) Prácticas Independientes: para ser realizadas en las macro-salas de PC’s de la UAO en el tiempo libre del estudiante. 4) Se efectuarán 3 evaluaciones parciales de la asignatura con la ponderación que se muestra en el numeral V. De esta forma, para obtener resultados satisfactorios, el estudiante deberá ir construyendo el conocimiento a través de aproximaciones sucesivas y durante: las clases, talleres, trabajo personal y trabajo en grupo de estudio. EVALUACIÓN Mínimo: 3 talleres, 3 quices y 3 trabajos Primer Parcial 15% independientes. Se sugieren grupos de 2 Segundo Parcial 25% o de 3 estudiantes. Tercer Parcial 25% Talleres y Quices 15% (Algunos talleres como trabajo independiente) Trabajos Adicionales 20% (Trabajo independiente) REFERENCIAS BIBLIOGRÁFICAS 1. Área de Informática UAO, Módulo de Informática 1, Publicaciones UAO. 2. CEBALLOS, Francisco J., JAVA 2 Curso de Programación. Ed. Alfaomega. Ra–Ma. 2000. 3. Joyanes Aguilar Luis & Zahonero Martínez Ignacio, “Programación en Java 2 – Algoritmos, Estructuras de Datos y Programación orientada a Objetos”, Ed. McGrawHill, 2002. 4. DEITEL, H.M., DEITEL, P. J. How to program Java. 3ª Edición. Ed. Prentice Hall. 2000. 5. FROUFE, Augustín. JAVA2 Manual de Usuario y Tutorial. 2ª Edición Ed. Alfa Omega 2000. 6. WU, Thomas C. Introducción a la programación orientada a objetos con Java. Ed. Mc Graw Hill. España. 2000. 7. ARNOW, David. WEISS, Gerald, Introducción a la programación con Java. Un enfoque orientado a objetos. Ed. Addison Wesley. España.2001 ELECTRÓNICAS 1. Descargar el software – J2SE 1.4, del sitio web: http://java.sun.com/downloads 2. Descargar el editor – JCreator 3.0, del sitio web: http://www.jcreator.com 3. Documentación de JAVA (JDK 1.4) http://java.sun.com/j2se/1.4/download.html 4. Tutorial de Java (JDK1.4) http://java.sun.com/docs/books/tutorial/ 5. Free Electronic Books in Java and C++: http://www.ibiblio.org/pub/docs/books/eckel/ 6. FTP: ftp://turing.cuao.edu.co/ Informática I. Versión 1.0 Agosto de 2004 4
- 5. Universidad Autónoma deOccidente FUENTES DE DONDE SE RECOPILÓ EL MATERIAL PARA LA ELABORACIÓN DE ESTE MÓDULO DE INFORMÁTICA I. - Universidad de Valencia, España, Depto. de Informática http://informatica.uv.es/docencia/fguia/TI/Libro/PDFs/CAPI4.pdf - Universidad de Oviedo,España, Depto. de Informática Profesor Daniel Gayo. http://di002.edv.uniovi.es/~dani/asignaturas/ - Aprenda Java como si estuviera en primero, Escuela Superior de Ingenieros Industriales de San Sebastián. http://mat21.etsii.upm.es/ayudainf/aprendainf/Java/Java2.pdf - Matemáticas para Computación, Seymour Lipschutz, McGraw – Hill, 1992 - Informática III, Programación Orientada a Objetos (Java), Recopilación: Lyda Peña Paz Informática I. Versión 1.0 Agosto de 2004 5
- 6. Universidad Autónoma deOccidente Informática I. Versión 1.0 Agosto de 2004 6
- 7. Universidad Autónoma deOccidente UNIDAD 1. SISTEMAS NUMÉRICOS ARITMÉTICA Y REPRESENTACIÓN DE LA INFORMACIÓN EN EL COMPUTADOR Dos de los aspectos básicos que se presentan en el tratamiento de la información, son cómo representarla (de lo cual dependerá sus posibilidades de manipulación) y cómo almacenarla físicamente. La primera se resuelve recurriendo a un código adecuado a las posibilidades internas del computador, que abordaremos en el presente capítulo. La segunda tiene que ver con los llamados soportes de información y es una cuestión que pertenece al ámbito del soporte físico del computador. En la raíz de los desarrollos informáticos está el hecho de que todo dato puede ser representado por un conjunto de bits (Los dígitos de un número binario se conocen como bits -Binary digit – digito binario- por su nombre en inglés), circunstancia que permite a la ALU (Unidad Aritmético-Lógica) realizar un gran número de operaciones básicas utilizando su representación binaria. El paso a códigos binarios es una misión que el computador lleva a cabo automáticamente, por lo que el usuario puede despreocuparse de este proceso. Sin embargo es conveniente tener algunas ideas acerca de la forma como el computador codifica y opera internamente, cuestión indispensable para comprender determinados comportamientos de la máquina. Para ello empezaremos recordando algunos conceptos relativos al sistema de numeración binario y a las transformaciones entre éste y el sistema decimal. 1.1 Sistemas de numeración en informática Llamaremos sistema de numeración en base b, a la representación de números mediante un alfabeto compuesto por b símbolos o cifras. Así todo número se expresa por un conjunto de cifras, contribuyendo cada una de ellas con un valor que depende: a) de la cifra en sí, b) de la posición que ocupa dentro del número. En el sistema de numeración decimal, se utiliza, b = 10 y el alfabeto está constituido por diez símbolos, denominados también cifras decimales: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} (1.1) y, por ejemplo, el número decimal 278.5 puede obtenerse como suma de: 200 70 8 0.5 278 .5 es decir, se verifica que: 278.5 = 2×102 + 7×101 + 8×100 + 5×10-1 Cada posición, por tanto, tiene un peso específico (en el sistema decimal, cada posición además tiene un nombre): Valor en el ejemplo Nombre posición 0 peso b0 8 unidades 1 posición 1 peso b 7 decenas posición 2 peso b2 2 centenas posición -1 peso b-1 5 décimas Informática I. Versión 1.0 Agosto de 2004 7
- 8. Universidad Autónoma deOccidente Generalizando, se tiene que la representación de un número en una base b: N = ... n4 n3 n2 n1 n0 . n-1 n-2 n-3 ... (1.2) es una forma abreviada de expresar su valor, que es: N = ... n4b4 + n3b3 + n2b2 + n1b1 + n0b0 + n-1b-1 ... (1.3) donde el punto separa los exponentes negativos de los positivos. Nótese que el valor que tome b determina la longitud de la representación; así, por un lado, resulta más cómodo que los símbolos (cifras) del alfabeto sean los menos posibles, pero, por otra parte, cuanto menor es la base, mayor es el número de cifras que se necesitan para representar una cantidad dada. Como ejemplo veamos cual es el número decimal correspondiente de 175372, en base 8, (cuyo alfabeto es {0, 1, 2, 3, 4, 5, 6, 7} y recibe el nombre de sistema octal). 175372)8 = 1×85 + 7×84 + 5×83 + 3×82 + 7×81 + 2×80 = = 6×104 + 4×103 + 2×102 + 5×101 + 0×100 = 64250)10 1.1.1 Definición del Sistema Binario En el sistema de numeración binario b es 2, y se necesita tan sólo un alfabeto de dos elementos para representar cualquier número: {0,1}. Los elementos de este alfabeto se denominan cifras binarias o bits. En la Tabla 1.1 se muestran los números enteros binarios que se pueden formar con 3 bits, que corresponden a los decimales de 0 a 7. Tabla 1.1.- Números binarios del 0 al 7 binario 000 001 010 011 100 101 110 111 decimal 0 1 2 3 4 5 6 7 Estos números son generados así: el primer dígito de derecha a izquierda se multiplica por 20, el segundo por 21 y el tercero por 22; por lo tanto el binario 1012 sería 1x22 + 0x21 + 1x20 = 1x4 + 0x2 + 1x1 = 5. 1.1.2 Transformaciones entre bases binaria y decimal Para transformar un número binario a decimal: Basta tener en cuenta las expresiones (1.2) y (1.3), en las que b = 2. Ejemplo 1: Transformar a decimal los siguientes números binarios: 110100; 0.10100; 10100.001 110100)2 = (1×25) + (1×24) + (1×22) = 25 + 24 + 22 = 32 + 16 +4 = 52)10 0.10100)2 = 2-1 + 2-3 = (1/2) + (1/8) = 0.625)10 10100.001)2 = 24 + 22 + 2-3 = 16+4+(1/8) = 20125)10 Informática I. Versión 1.0 Agosto de 2004 8
- 9. Universidad Autónoma deOccidente Observando el Ejemplo 1 se deduce que se puede transformar de binario a decimal sencillamente sumando los pesos de las posiciones en las que hay un 1, como se pone de manifiesto en el siguiente ejemplo. Ejemplo 2: Transformar a decimal los números: 1001.001)2 y 1001101)2 1001.001)2 1 0 0 1 0 0 1 = 8 + 1 + 1/8 = 9.125)10 pesos 8 4 2 1 ½ ¼ 1/8 1001101)2 1 0 0 1 1 0 1 = 64 + 8 + 4 + 1 = 77)10 pesos 64 32 16 8 4 2 1 Para transformar un número decimal a binario: a) La parte entera del nuevo número (binario) se obtiene dividiendo la parte entera del número decimal por la base, 2, (sin obtener decimales en el cociente) de partida, y de los cocientes que sucesivamente se vayan obteniendo. Los residuos de estas divisiones y el último cociente (que serán siempre menores que la base, esto es, 1 o 0), en orden inverso al que han sido obtenidos, son las cifras binarias. Ejemplo 3: Pasar a binario el decimal 26 26 2 26)10 = 11010)2 0 13 2 1 6 2 0 3 2 1 1 2 1 0 b) La parte fraccionaria del número binario se obtiene multiplicando por 2 sucesivamente la parte fraccionaria del número decimal de partida y las partes fraccionarias que se van obteniendo en los productos sucesivos. El número binario se forma con las partes enteras (que serán ceros o unos) de los productos obtenidos, como se hace en el siguiente ejemplo. Ejemplo 4: Para pasar a binario el decimal 26.1875 separamos la parte fraccionaria: 0.1875 y la parte entera: 26 (ya transformada en el Ejemplo anterior). 0.1875 0.3750 0.7500 0.5000 ×2 ×2 ×2 x2 0.3750 0.7500 1.5000 1.0000 Por tanto, habiéndonos detenido cuando la parte decimal es nula, el número decimal 26.1875 en binario es: 26.1875)10 = 11010.0011)2 NOTA: un número real no entero presentará siempre cifras después del punto decimal, pudiendo ser necesario un número finito o infinito de éstas, dependiendo de la base en que se represente; por ejemplo el número 1.6)10 representado en binario sería 1.100110011001...)2, requiriendo infinitas cifras para ser exacto, como también ocurre con muchos números representados en decimal. Informática I. Versión 1.0 Agosto de 2004 9
- 10. Universidad Autónoma deOccidente 1.1.3 Códigos Intemedios Como acabamos de comprobar, el código binario produce números con muchas cifras, y para evitarlo utilizamos códigos intermedios que son bases mayores, que no se alejen de la binaria. Estos se fundamentan en la facilidad de transformar un número en base 2, a otra base que sea una potencia de 2 (22=4; 23=8; 24=16, etc.), y viceversa. Usualmente se utilizan como códigos intermedios los sistemas de numeración en base 8 (u octal) y en base 16 (o hexadecimal). 1.1.3.1 Base Octal Un número octal puede pasarse a binario aplicando los algoritmos ya vistos en secciones anteriores. No obstante, al ser b=8=23, el proceso es más simple puesto que, como puede verse n525 + n424 + n323 + n222 + n121 + n020 + n-12-1 + n-22-2 + n-32-3 = (n522 + n421 + n320)× 23 + (n222 + n121 + n020)× 20 + (n-122 + n-221 + n-320)× 2-3 = (m1)× 81 + (m0)× 80 + (m-1)× 8-1 Cada 3 símbolos binarios (3 bits) se agrupan para formar una cifra de la representación en octal, por tanto en general puede hacerse la conversión fácilmente, de la forma siguiente: Para transformar un número binario a octal se forman grupos de tres cifras binarias a partir del punto decimal hacia la izquierda y hacia la derecha (añadiendo ceros no significativos cuando sea necesario para completar grupos de 3). Posteriormente se efectúa directamente la conversión a octal de cada grupo individual de 3 cifras, y basta con recordar como se generaron los números en la tabla 1.1 para poder realizar rápidamente la conversión. Así por ejemplo 10001101100.1101)2 = 010 001 101 100 . 110 100 2 1 5 4 . 6 4 = 2154.64)8 De octal a binario se pasa sin más que convertir individualmente a binario (tres bits) cada cifra octal, manteniendo el orden del número original. Por ejemplo: 537.24)8 = 5 3 7 . 2 4 101 011 111 . 010 100 = 101011111.0101)2 Para transformar un número de octal a decimal se aplica la expresión (1.3) con b=8. Para transformar un número de decimal a octal se procede de forma análoga a como se hizo para pasar de decimal a binario dividiendo o multiplicando por 8 en lugar de por 2. Así se puede comprobar que 1367.25)8 = 759.328125)10 ó que 760.33)10 =1370.2507...)8 1.1.3.2 Base Hexadecimal Para representar un número en base hexadecimal (esto es, b=16) es necesario disponer de un alfabeto de 16 símbolos: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F} Tabla 1.2.- Números binarios del 0 al 7 Hexadec 0 1 2 3 4 5 6 7 8 9 A B C D E F Décimal 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Binario 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 Informática I. Versión 1.0 Agosto de 2004 10
- 11. Universidad Autónoma deOccidente Al ser b=16=24, de modo similar al caso octal, cada símbolo hexadecimal se corresponde con 4 símbolos binarios (4 bits) y las conversiones a binario se realizan agrupando o expandiendo en grupos de 4 bits. Se pueden comprobar las transformaciones siguientes: 10111011111.1011011)2 = 0101 1101 1111 . 1011 0110 5 D F . B 6 = 5DF.B6)H 1A7.C4 )H = 1 A 7 . C 4 0001 1010 0111 . 1100 0100 = 110100111.110001)2 De la misma forma que manualmente es muy fácil convertir números de binario a octal, y viceversa, y de binario a hexadecimal, y viceversa, también resulta sencillo efectuar esta operación electrónicamente o por programa, por lo que a veces el computador utiliza este tipo de notaciones intermedias como código interno o de entrada/salida, y también para visualizar el contenido de la memoria o de los registros. Para transformar un número de hexadecimal a decimal se aplica la expresión (1.3) con b=16. Para pasar un número de decimal a hexadecimal se hace de forma análoga a los casos binario y octal: la parte entera se divide por 16, así como los cocientes enteros sucesivos, y la parte fraccionaria se multiplica por 16, así como las partes fraccionarias de los productos sucesivos. Así se puede comprobar que 12A5.7C)H = 4773.484375)10 ó que 16237.25)10 = 3F6D.4)H 1.2 Operaciones Aritméticas y Lógicas El procesamiento de la información incluye realizar una serie de operaciones con los datos; estas operaciones y las particularidades de las mismas en su realización por el computador son el objeto de los próximos apartados. Operaciones Aritméticas con Números Binarios Las operaciones aritméticas básicas (suma, resta, multiplicación y división) en sistema binario se realizan en forma análoga a la decimal aunque, por la sencillez de su sistema de representación, las tablas son realmente simples: Tabla 1.3.- Operaciones básicas en binario Suma aritmética Resta aritmética Producto aritmético 0+0=0 0-0=0 0.0=0 0+1=1 0 - 1 = 1 y debo 1 (*) 0.1=0 1+0=1 1-0=1 1.0=0 1 + 1 = 0 y llevo 1(*) 1-1=0 1.1=1 (*) Llamado normalmente acarreo. En binario 1+1=10 (es 0 y me llevo 1), igual que en decimal 6+6=12 (es 2 y me llevo 1) Resta en un SC2 Se toma el sustraendo y se le hace complemento a uno (negación de cada bit). Posteriormente a este número se le suma uno, dando como resultado el complemento a dos. Este último resultado (que equivale al sustraendo negativo) se le suma al minuendo y obtendremos la respuesta. Si el número de términos excede al minuendo, se debe realizar desbordamiento de extremos. (No se toma el bit de extrema izquierda en el resultado ). Informática I. Versión 1.0 Agosto de 2004 11
- 12. Universidad Autónoma deOccidente Ejemplo 5: (minuendo) 0 1 1 1 (7) (sustraendo) -0 1 0 1 (5) Complemento a uno del sustraendo 1 0 1 0 Se suma uno + 1 Complemento a dos 1 0 1 1 (-5) Minuendo 0 1 1 1 (7) Complemento a dos + 1 0 1 1 (-5) Como se presenta acarreo se omite el bit de extrema izquierda. Respuesta 0 0 1 0 (2) Ejemplo 6: Minuendo 0 1 0 0 1 0 1 1 ( 75) Sustraendo 0 1 1 0 1 0 0 1 (105) Complemento a uno del sustraendo 1 0 0 1 0 1 1 0 Se suma uno + _______ 1 Complemento a dos 1 0 0 1 0 1 1 1 (-105) Complemento a dos 0 1 0 0 1 0 1 1 ( 75) Suma minuendo + 1 0 0 1 0 1 1 1 (-105) Respuesta 1 1 1 0 0 0 1 0 (- 30) Ejemplo 7: Efectuar las siguientes operaciones aritméticas binarias: 1110101 1101010 1101010 1010011 110.01 10 +1110110 -1010111 ×11 ×10 10 11.001 11101011 0010011 1101010 0000000 010 1101010_ 1010011_ 10 100111110 10100110 00010 10 00 A partir del ejemplo anterior, se observa que multiplicar por 10)2 (es decir, por 2 en decimal) equivale a añadir un cero a la derecha, o desplazar el punto decimal a la derecha, siendo esto similar a multiplicar por 10)10 un número decimal. De la misma forma dividir por 10)2 = 2)10 equivale a eliminar un cero a la derecha, o desplazar el punto decimal a la izquierda. Por ejemplo: 1010011)2 × 2 = 10100110)2 1010100)2 / 2 = 101010)2 10101.01)2 × 2 = 101010.1)2 110.01)2 / 2 = 11.001)2 1.101101)2 × 25 = 110110.1)2 10101.101)2 / 26 = 0.010101101)2 Informática I. Versión 1.0 Agosto de 2004 12
- 13. Universidad Autónoma deOccidente Ejercicios Llene todas las casillas en blanco, sabiendo que las columnas agrupan el sistema numérico y el número a convertir lo da la fila que tenga el dato. DECIMAL BINARIO OCTAL HEXA 230 1101001 326 BC3 A48D 1543 100100101 1872 255 Realice las siguientes operaciones : Operando 1 Operando 2 Suma Resta 11000011 10000 1001110010 11100101 1101 1100111 1101001111 101101111 1111111111111 1111 1010101011 10100001 11111100000 1010101010 101000001100 11000110010 11001010000010 10001111100011 11001010 1011111 101100110101 1110000001 10101110110 10101 11111111111 1111111111 100100000010 1011111 1001111101111110000 1111111000000000000 1.2.2 Valores Booleanos y Operaciones Lógicas Un dígito binario, además de representar una cifra en base dos, también puede interpretarse como un valor booleano o dato lógico (en honor a George Boole), entendiendo como tal una cantidad que solamente puede tener dos estados (Verdadero/Falso, SI/NO, 1/0, etc.) y por tanto con capacidad para modelizar el comportamiento de un conmutador. Así, además de las operaciones aritméticas con valores binarios, se pueden llevar a cabo operaciones booleanas o lógicas en las que estos valores se consideran señales generadas por conmutadores. Las operaciones booleanas más importantes son: OR lógico (también denominado unión, suma lógica (+) o función O), AND lógico (también intersección, producto lógico ( . ) o función Y) la complementación ( - ) (o inversión, negación, o función NOT o NO). Nótese que las dos primeras son operaciones de dos operandos o binarios mientras que la complementación es unaria. Estas operaciones se rigen según la Tabla 4.4. Informática I. Versión 1.0 Agosto de 2004 13
- 14. Universidad Autónoma deOccidente Tabla 1.4.- Operaciones lógicas OR __ AND ______ NOT 0+0=0 0.0=0 0=1 0+1=1 0.1=0 1=0 1+0=1 1.0=0 1+1=1 1.1=1 Como puede observarse, el AND y OR lógicos se corresponden parcialmente con el producto y suma binarios, y lo más significativo, es la posibilidad de implementar estas operaciones lógicas, y por tanto las aritméticas binarias, en forma de circuitos. En la siguiente unidad se revisa más ampliamente las operaciones lógicas. Informática I. Versión 1.0 Agosto de 2004 14
- 15. Universidad Autónoma deOccidente UNIDAD 2. SISTEMAS LÓGICOS LOGICA, TABLAS DE VERDAD 2.1 Introducción. Un computador puede ser programado para tomar decisiones basadas en si ciertos enunciados –por ejemplo, “El numero que se ha computado es mayor que 100”-son verdaderos o falsos. A la verdad o falsedad de un enunciado se le llama valor de verdad; un enunciado es verdadero o falso, pero no ambas cosas. Algunos enunciados son enunciados compuestos, es decir, están integrados por subenunciados y varias conectivas. Ejemplo 1: (a) “Las rosas son rojas y las violetas azules” es un enunciado compuesto por los subenunciados “las rosas son rojas” y “las violetas son azules”. (b) “El es inteligente o estudia todas las noches” es, implícitamente, un enunciado compuesto por los subenunciados “El es inteligente” y “estudia todas las noches”. (c) “¿Para donde va?” no es un enunciado ya que no es ni verdadero ni falso. La propiedad fundamental de un enunciado compuesto es que su valor de verdad esta completamente determinado por los valores de verdad de sus subenunciados junto con la manera como estan conectados para formar el enunciado compuesto. Comenzamos con un estudio de algunas de estas conectivas. En este capitulo usaremos las letras p, q, r (en minúsculas o mayúsculas, con o sin subíndices) para denotar enunciados. 2.2 Conjunción, p ^ q Dos enunciados cualesquiera se pueden combinar con la palabra “y” para formar un enunciado compuesto llamado la conjunción de los enunciados originales. Simbólicamente, p ^ q. Denota la conjunción de los enunciados p y q, que se lee “p ^ q”. La tabla de verdad del enunciado compuesto p ^ q esta dada por la siguiente tabla: p q p^q V V V V F F F V F F F F En este caso, la primera línea es una manera abreviada de decir que si p es verdadero y q es verdadero, entonces p ^ q es verdadero. Las otras líneas tienen significados análogos. Consideramos que esta tabla define precisamente el valor de verdad del enunciado compuesto p ^ q como una función de los valores de verdad de p y de q. Observe que p ^ q es verdadero solamente en el caso en que ambos subenunciados sean verdaderos. Informática I. Versión 1.0 Agosto de 2004 15
- 16. Universidad Autónoma deOccidente Ejemplo 2: Considere los cuatro enunciados siguientes: (i) Paris esta en Francia y 2+2=4. (iii) Paris esta en Inglaterra y 2+2=4. (ii) Paris esta en Francia y 2+2=5 (iv) Paris esta en Inglaterra y 2+2=5. Solamente el primer enunciado es verdadero. Cada uno de los otros enunciados es falso ya que por lo menos uno de sus subenunciados es falso. 2.3 Disyunción, p ν q Dos enunciados pueden combinarse con la palabra “o” (en el sentido de “y/o”) para formar un nuevo enunciado que se llama la disyunción de los dos enunciados originales. Simbólicamente, p ν q. Denota la disyunción de los enunciados p y q y se lee “p o q”. El valor de verdad de p ν q esta dado por la siguiente tabla de verdad, que consideramos define a p ν q: p q pνq V V V V F V F V V F F F Observe que p ^ q es falso solamente cuando ambos enunciados son falsos. Ejemplo 3: Considere los cuatro enunciados: (i) Paris esta en Francia o 2 + 2 = 4. (ii) Paris esta en Francia o 2 + 2 = 5. (iii) Paris esta en Inglaterra o 2 + 2 = 4. (iv) Paris esta en Inglaterra o 2 + 2 = 5. Solamente (iv) es falso. Cada uno de los otros enunciados es verdadero ya que por lo menos uno de sus subenunciados es verdadero. Observación: La palabra española “o” se usa comúnmente de dos maneras. Algunas veces se usa en el sentido de “p o q o ambos”, mejor dicho, por lo menos una de las dos alternativas ocurre, como antes se señaló y algunas veces se usa en el sentido de “ p o q pero no ambos”, mejor dicho, exactamente una de las dos alternativas ocurre. Por ejemplo, la frase “ El estudiara en la Universidad Nacional o en la Universidad Católica” usa el “o” en el segundo sentido llamado disyunción exclusiva. A no ser que se diga otra cosa, la “o” se usara en el primer sentido. Esta observación hace sobresalir la precisión que ganamos con nuestro lenguaje simbólico: pν q esta definido por su tabla de verdad y siempre significa “p y / o q”. 2.4 Negación, ~ p Dado cualquier enunciado p, se puede formar otro enunciado, llamado la negación de p, escribiendo “ Es falso que...” antes de p o, si es posible insertando en p la palabra “no”. Simbólicamente, ~ p, denota la negación de p (se lee “no p”). Informática I. Versión 1.0 Agosto de 2004 16
- 17. Universidad Autónoma deOccidente La tabla de verdad de ~ p esta dada por la siguiente tabla: p ~p V F F V En otras palabras, si p es verdadero entonces ~ p es falso entonces ~ p es verdadero. Así, el valor de verdad de la negación de cualquier enunciado es siempre el opuesto del valor de verdad del enunciado original. Ejemplo 4: Considere los siguientes enunciados (a) Paris esta en Francia. (d) 2 + 2= 5 (b) Es falso que Paris esta en Francia. (e) Es falso que 2 + 2=5. (c) Paris no esta en Francia. (f ) 2 + 2 ≠ 5. Entonces (b) y (c) son cada una de la negación de (a); y (e) y (f) son cada uno la negación de (d. Ya que (a) es verdadero, los enunciados (b) y (c) son falsos; y como (d) es falso, los enunciados (e) y (f) son verdaderos. Observación: La notación lógica para las conectivas “y”, “o” y “no” no es estándar. Por ejemplo, algunos textos usan: p & q. p . q o pq para p ^ q p+q para pν q p’ . p o ┐p para ~ p 2.5 Proposiciones y Tablas de Verdad Con su uso repetido de las conectivas lógicas (^, ν, ~ y otras que se discutirán adelante), podemos construir enunciados compuestos que son mas elaborados. En el caso en que los subenunciados p, q, ... de un enunciado compuesto P (p,q,...) sean variables, llamamos al enunciado compuesto una proposición. Ahora el valor de verdad de una proposición depende exclusivamente de los valores de verdad de sus variables, mejor dicho, el valor de verdad de una proposición se conoce una vez que se conozcan los valores de verdad de sus variables. La tabla de verdad de la proposición ~ (p ^ ~ q), por ejemplo, se construye como sigue: p q ~q p^~q ~(p^~q) V V F F V V F V V F F V F F V F F V F V Observe que las primeras columnas de la tabla son para las variables p,q,...y que hay suficientes líneas en la tabla para permitir todas las posibles combinaciones de V y F para estas variables. (Para 2 variables, como en el caso anterior, se necesitan 4 líneas; para 3 variables se necesitan 8 líneas; y, en general, para n variables se necesitan 2n líneas.) Hay pues una columna para cada etapa “elemental” de la construcción del enunciado el valor de verdad de cada paso es determinado por las etapas anteriores con las definiciones de las conectivas ^, ν, ~. Finalmente, obtenemos la tabla de verdad de la proposición, que aparece en la ultima columna. Informática I. Versión 1.0 Agosto de 2004 17
- 18. Universidad Autónoma deOccidente Observación: La tabla de verdad de la proposición, anterior consiste precisamente en las columnas bajo las variables y la columna bajo la proposición: p q ~(p^~q) V V V V F F F V V F F V Las otras columnas se usaron solamente en la construcción de la tabla de verdad. Otra manera de construir la tabla de verdad anterior para ~ (p ^ ~ q) es la siguiente. Primero se construye la siguiente tabla: p q ~ (p ^ ~ q) V V V F F V F F Paso Observe que la proposición se escribe en la línea superior a la derecha de sus variables, y que hay una columna bajo cada variable o conectiva de la proposición. Los valores de verdad se colocan entonces en la tabla de verdad en varios pasos como sigue: P q ~ (p ^ ~ q) p q ~ (p ^ ~ q) V V V V V V V F V V F V F V F V V F F V F V F V F F V F F F F F F F V F Paso 1 1 Paso 1 2 1 (a) (b) P q ~ (p ^ ~ q) p q ~ (p ^ ~ q) V V V F F V V V V V F F V V F V V V F F V F V V V F F V F F F V F F V F F F V F F F F V F F F V F F V F Paso 1 3 2 1 Paso 4 1 3 2 1 (c ) (d) La tabla de verdad de la proposición está formada, pues, por las columnas originales bajo las variables y la última columna colocada en la tabla, mejor dicho, el último paso. 2.6 Tautologías y Contradicciones Algunas proposiciones P(p, q,…) contienen solamente V en la última columna de sus tablas de verdad, es decir, son verdaderas para cualquier valor de verdad de sus variables. A tales proposiciones se les Informática I. Versión 1.0 Agosto de 2004 18
- 19. Universidad Autónoma deOccidente llama tautologías. Análogamente, una proposición P(p,q,…)se llama contradicción si contiene solamente F en la última columna de su tabla de verdad, o sea, es falso para cualquier valor de verdad de sus variables. Por ejemplo, la proposición “p o no p”, es decir, p ν ~ p, es una tautología y la proposición “p y no p”, es decir, p ^ ~ p, es una contradicción. Esto se verifica construyendo sus tablas de verdad. p ~p pν~p p ~ p p ^~ p V F V V F F F V V F V F Observemos que la negación de una tautología es una contradicción ya que siempre es falsa, y la negación de una contradicción es una tautología ya que siempre es verdadera. Ahora, sea P(p, q, ...) una tautología, y sean P (p, q, ...), P (p,q,...),...proposiciones cualesquiera. Como el valor de verdad de P(p,q,...) no depende de los valores de verdad particulares de sus variables p, q, ... podemos reemplazar P , q por P , ...en la tautología P(p, q, …) y tenemos aún una tautología. En otras palabras: Principio de substitución: Si P (p, q, ...) es una tautología, entonces P(P1, P2,...) es una tautología para proposiciones cualesquiera P1, P2,... Ejemplo 5: Por la anterior tabla de verdad, pν ~ p es una tautología. Reemplazando p por q ^ r obtenemos la proposición ( q ^ r ) ν ~ ( q ^ r ) que, por el principio de substitución también debiera ser una tautología. Esto se verifica con la siguiente tabla de verdad. q r q^r ~ (q^r) (q^r)ν ~(q^r) . V V V F V V F F V V F V F V V F F F V V 2.7 Equivalencia Lógica: Álgebra de Proposiciones Se dice que dos proposiciones P ( p, q, ...) y Q (p, q, ...) son lógicamente equivalentes, o sencillamente equivalentes o iguales, denotado por P (p, q, ...) ≡ Q (p, q, …) Si tienen identicas tablas de verdad. Por ejemplo, considere las tablas de verdad de ~ ( p^q) y ~ pν q: p q p^q ~ (p^q) p Q ~p ~q ~pν~q V V V F V V F F F V F F V V F F V V F V F V F V V F V F F F V F F V V V Como las tables de verdad son las mismas, mejor dicho, ambas proposiciones son falsas en el primer caso y verdaderas en los otros tres casos, las proposiciones ~ ( p ^ q) y ~ p ν ~ q son lógicamente equivalentes y podemos escribir: ~ ( p^q) ≡ ~ p ν ~ q Informática I. Versión 1.0 Agosto de 2004 19
- 20. Universidad Autónoma deOccidente Ejemplo 6: Considere el enunciado “ Es falso que las rosas son rojas y las violetas son azules”. Este enunciado se puede escribir en la forma ~ ( p ^ q) en donde p es “ las rosas son rojas” y q es “las violetas son azules”. Sin embargo, por las tablas de verdad anteriores, ~ ( pν q) es lógicamente equivalente con ~ p ν ~ q. Asi, el enunciado dado tiene el mismo significado que el ennunciado. “Las rosas no son rojas, o las violetas no son azules”. Las proposiciones satisfacen muchas equivalencias logicas, o leyes, fuera de las descritas anteriormente. Algunas de las leyes mas importantes, con sus nombres se dan en la tabla 2.1. en la tabla, t denota una tautología y f denota una contradicción. 2.8 Enunciados Condicional y Bicondicional Muchos enunciados, particularmente en la matemática, son de la forma “Si p entonces q”. Tales enunciados se llaman enunciados condicionales y se denotan por p → q El condicional p → q frecuentemente se lee “ p implica q” o “p sólo si q”. Otro enunciado común es la forma “p si y solo si q”. Tales enunciados denotados por p ↔ q se llaman enunciados bicondicionales. Los valores de verdad de p→ q y p ↔ q se dan en las siguientes tablas: p q p→ q p q p↔q V V V V V V V F F V F F F V V F V F F F V F F V Leyes de idempotencia 1a. pν p ≡ p 1b. p ^ p ≡ p Leyes Asociativas 2a (pν q) ν r≡ pν (qν r) 2b. (p ^ q) ^ r ≡ p ^ ( q ^ r) Leyes conmutativas 3a pν q≡ qν p 3b. p ^ q ≡ q ^ p Leyes distributivas 4a pν ( q ^ r) ≡ (pν q) ^ (pν r) 4b. p ^ (q ν r) ≡ (p ^ q) ν (p ^ r) Leyes de identidad 5a pν f ≡ p 5b. p ^ t ≡ p 6a pν t≡ t 6b. p ^ f ≡ f Leyes de complementos 7a pν ~ p ≡ t 7b. p ^ ~ p ≡ f 8a ~ t ≡ f 8b. ~ f ≡ t Ley de involución 9 ~ ~ p≡p Leyes de DeMorgan 10a. ~ (p ν q) ≡ ~ p ^ ~ q 10b. ~ (p ^ q) ≡ ~ p ν ~ q Tabla 2.1. Leyes del Álgebra de Proposiciones Informática I. Versión 1.0 Agosto de 2004 20
- 21. Universidad Autónoma deOccidente Observe que el condicional p→ q es falso solamente cuando la primera parte p es verdadera y la segunda parte q es falsa. En caso de que p sea falso, el condicional p→ q es verdadero sin importar el valor de verdad de q. Observe tambien que p ↔ q es verdadero cuando p y q tienen los mismos valores de verdad y falso en los demas casos. Ahora considere la tabla de verdad de la proposicion ~ pν q: p q ~p ~pνq V V F V V F F F F V V V F F V V Observe que la anterior tabla de verdad es idéntica a la tabla de verdad de p → q. Así que p→ q es lógicamente equivalente a la proposición ~ p ν q: p→q≡~pνq En otras palabras, el enunciado condicional “Si p entonces q” es lógicamente equivalente al enunciado “No p o q”, que solamente usa las conectivas ν y ~ y, por lo tanto, ya era parte de nuestro lenguaje. Considere la proposicion condicional p → q y las otras proposiciones condicionales simples que contienen p y q: q → p, ~ p → ~ q y ~ q → ~ p Estas proposiciones se llaman respectivamente la reciproca, inversa, y contrarreciproca de la proposicion p → q. En seguida presentamos las tablas de verdad de las cuatro proposiciones. Condicional Recíproca Inversa Contrarecíproca p q p→q q→ p ~p→~q ~q→ ~p V V V V V V V F F V V F F V V F F V F F V V V V Observe que un enunciado condicional y su reciproco o inverso no son lógicamente equivalentes. Por otra parte, se puede ver que un enunciado condicional y su contrarreciproco son lógicamente equivalentes. Enunciamos este resultado formalmente: Teorema 2.1: Un enunciado condicional p→ q y su contrarreciproca ~ q→ ~ p son lógicamente equivalentes. Ejemplo 7: (a) Considere los siguientes enunciados sobre un triangulo A: p→ q: Si A es equilatero, entonces A es isoseles. q→ p: Si A es Isoseles, entonces A es equilatero. En este caso p→ q es verdadero, pero su reciproco q→ p es falso. (b) Sea x un entero. Demuestre: (p→ q). Si x² es impar entonces x es impar. Demostramos que la contrarreciproca ~ q→ ~ p, “Si x es par, entonces x² es par” es verdadera. Sea x par; entonces, x = 2n en donde n es un entero. Por lo tanto, x² = (2n)(2n) = 2(2n² ) Informática I. Versión 1.0 Agosto de 2004 21
- 22. Universidad Autónoma deOccidente tambien es par. Como la contrarreciproca ~ q→ ~ p es verdadera, el enunciado condicional original p→ q es tambien verdadero. 2.9 Argumentos Un argumento es una relacion entre un conjunto de proposiciones P1,P2,..., Pn, llamadas premisas, y otra proposicion Q, llamada la conclusión; denotamos un argumento por P1,P2,..., Pn + Q Se dice que un argumento es valido si las premisas dan (como consecuencia) la conclusión; mas formalmente, damos la siguiente Definición: Un argumento P1,P2,,...., Pn + Q es válido si Q es verdadero cada vez que las premisas P1,P2,..., Pn sean verdaderas. Un argumento que no es válido se llama falacia. Ejemplo 8: (a) El siguiente argumento es válido: p.p → q + q (Ley de independencia, modus poniendo ponens.) la demostración de esta regla se sigue de la siguiente tabla de verdad. p q p→q V V V V F F F V V F F V Ya que p es verdadero en los casos (lineas) 1 y 2, y p → q es verdadero en los casos 1, 3 y 4; se sigue que p y q → q son verdaderos simultáneamente en el caso 1. como en este caso q es verdadero, el argumento es valido. (b) El siguiente argumento es una falacia: p → q, q + p. Ya que p → q y q son ambos verdaderos en el caso (linea) 3 en la anterior tabla de verdad, pero en este caso p es falso. Ahora las proposiciones P1,P2,..., Pn son verdaderas simultáneamente si y solo si la proposicion (P1 ^ P2 ^...^ Pn) es verdadera. Asi el argumento P1,P2,..., Pn + Q es valido si y solo si Q es verdadero cada vez que P1 ^ P2 ^...^ Pn sea verdadero o, equivalentemente, si y solo si la proposicion (P1 ^ P2 ^...^ Pn) → Q Es una tautologia. Establecemos este resultado formalmente. Teorema 2.2: El argumento P1,P2,..., Pn + Q es valido si y solo si (P1 ^ P2 ^...^ Pn) → Q es una tautologia. En el siguiente ejemplo aplicamos este teorema. Ejemplo 9: Un principio fundamental del racionamiento logico dice: “Si p implica q y q implica r, entonces p implica r” O sea, el siguiente argumento es valido: Informática I. Versión 1.0 Agosto de 2004 22
- 23. Universidad Autónoma deOccidente p→ q. q → r + p→ r (ley del silogismo) Este hecho se verifica con la siguiente tabla de verdad que muestra que la proposicion [(p→ q) ^ (q → r)] → (p→ r) Es una tautologia: p q r [(p → q) ^ (q → r)] → (p → r) VV V V V V V V V V V V V V VV F V V V F V F F V V F F VF V V F F F F V V V V V V VF F V F F F F V F V V F F FV V F V V V V V V V F V V FV F F V V F V F F V F V F FF V F V F V F V V V F V V FF F F V F V F V F V F V F Paso 1 2 1 3 1 2 1 4 1 2 1 Equivalentemente, el argumento es valido ya que las premisas p→ q y q→ r son verdaderas simultáneamente solo en los casos (lineas) 1, 5, 7 y 8, y en estos casos la conclusión p→ r tambien es verdadera. (observe que la tabla de verdad requiere 2³ = 8 lineas, ya que hay tres variables p, q y r.) Es necesario destacar que la validez del argumento no depende de los valores de verdad o del contenido de los enunciados que aparecen en el argumento, sino solamente de la estructura formal del argumento. Esto se ilustra con el siguiente ejemplo. Ejemplo 10: Considere el siguiente argumento: S1: Si un hombre es soltero, es infeliz. S2: Si un hombre es infeliz, muere joven. ................................................................. S: Los solteros mueren jóvenes. En este caso el enunciado S debajo de la línea denota la conclusión del argumento, y los enunciados S1 y S2 por encima de la línea denotan las premisas. Afirmamos que el argumento es de la forma p→ q , q→ r + p → r Es donde p es “El es soltero”, q es “El es infeliz” y r es “El muere joven”; y por el ejemplo 4.9 este argumento (Ley de silogismo) es válido. 2.10 Implicación Lógica. Se dice que una proposición P (p,q,...) implica lógicamente una proposición Q (p,q,...), escrito P (p,q,...)⇒ Q (p, q, ...) Si Q (p, q, ...) es verdadera cada vez que P (p,q,...) sea verdadera. Ejemplo 11: Afirmamos que P implica lógicamente p ν q. Considere las tablas de verdad de p y de p ν q en la tabla de abajo. Observe que p es verdadera en los casos (líneas) 1 y 2, y en estos casos pν q también es verdadera. En otras palabras , p implica lógicamente p ν q. Informática I. Versión 1.0 Agosto de 2004 23
- 24. Universidad Autónoma deOccidente p q pν q V V V V F V F V V F F F Ahora si Q (p, q, ...) es verdadera cada vez que P (p,q,...) sea verdadera, entonces el argumento P (p,q,...) + Q (p, q, ...) es válido, y recíprocamente. Aún más, el argumento P + Q es válido si y solo si el enunciado condicional P → Q es siempre verdadero, o sea, si es una tautología. Establecemos este resultado formalmente. Teorema 3: Para proposiciones cualesquiera P (p,q,...) y Q (p, q, ...) los tres enunciados siguientes son equivalentes: (i) P (p,q,...) implica lógicamente a Q (p, q, ...). (ii) El argumento P (p,q,...) + Q (p, q, ...) es válido. (iii) La proposición P (p,q,...) → Q (p, q, ...) es una tautología. Si P ⇒ Q y Q ⇒ P entonces P y Q deben tener la misma tabla de verdad, y por lo tanto P ≡ Q. El reciproco también es cierto. Así, la noción de implicación lógica está intimamente ligada a la de la equivalencia lógica. PROBLEMAS RESUELTOS Enunciados y Enunciados Compuestos. 2.1 Sea p “Hace frió” y sea q “Está lloviendo”. Dé una frase verbal sencilla que describa cada uno de los siguientes enunciados: (1) ~ p, (2) p ^ q, (3) p ν q, (4) qν ~p, (5) ~p ^ ~q, (6) ~ ~ q En cada caso, traduzca ^, ν y ~ para que se lea “y”, “o” y “Es falso que” o “No”, respectivamente, y luego simplifique la frase en español. (1) No hace frió. (4) Está lloviendo o no está haciendo frío. (2) Está haciendo frío y está lloviendo. (5) Ni está haciendo frío ni está lloviendo. (3) Está haciendo frío o está lloviendo (6) No es verdad que esté lloviendo. 2.2 Sea p “El es alto” y sea q “El es buen mozo”. Escriba cada uno de los siguientes enunciados en forma simbólica usando p y q. (Suponga que “El es bajo” significa “El no es alto”, o sea ~ p.). (1) El es alto y buen mozo. (4) El no es ni alto ni buen mozo. (2) El es alto pero no buen mozo. (5) El es alto, o es bajo y buen mozo. (3) Es falso que el sea bajo o buen mozo. (6) No es cierto que él sea bajo o no buen mozo. (1) p ^ q (3) ~ (~p ν q) (5) p ν (~p ^ q) (2) p ^ ~q (4) ~p ^ ~q (6) ~ (~ p ν ~q) Informática I. Versión 1.0 Agosto de 2004 24
- 25. Universidad Autónoma deOccidente Proposiciones y sus Tablas de Verdad. 2.3 Encuentre la tabla de verdad de ~ p ^ q. p q ~ p ^ q V V F V F V V F F V F F F V V F V V F F V F F F p q ~p ~p^q V V F F V F F F F V V V F F V F Paso 2 1 3 1 Método 1 Método 2 2.4 Encuentre la tabla de verdad de ~ (p ν q). p q ~ (p ν q) p q p ν q ~ (p ν q) V V F V V V V V V F V F F V V F V F V F F V F F V V F V V F F F V F F F F F F V Paso 3 1 2 1 Método 1 Método 2 2.5 Encuentre la tabla de verdad de ~ (p ν ~ q). p q ~ q p ν ~ q ~ (p ν ~ q) p q ~ (p ν ~ q) V V F V F V V F V V F V V F V V F V F F V V V F F V F F V F V V F F F V F F V V F F F F F V V F Paso 4 1 3 2 1 Método1 Método 2 (observe que esta tabla de verdad es idéntica a la del problema 2.3) Tautologías y Contradicciones. 2.6 Verifique que la proposición p ν ~ (p ^ q) es una tautología. Construya la tabla de verdad de p ν ~ (p ^ q): p q p^ q ~ (p ^ q) p ν ~ (p ^ q) V V V F V V F F V V F V F V V F F F V V Informática I. Versión 1.0 Agosto de 2004 25
- 26. Universidad Autónoma deOccidente Como la tabla de verdad de p ν ~ (p ^ q) es verdadera para todos los valores de verdad de p y de q, entonces es una tautología. 2.7 Verifique que la proposición (p ^ q) ^ ~ (p ν q) es una contradicción. Construya la tabla de verdad de (p ^ q) ^ ~ (p ν q): P q p ^ q p ν q ~ (p ν q) (p ^ q) ^ ~ (p ν q) V V V V F F V F F V F F F V F V F F F F F F V F Como la tabla de verdad de (p ^ q) ^ ~ (p ν q) es F para todos los valores de verdad de p y de q, entonces es una contradicción. Equivalencia Lógica. 2.8 Demuestre que la disyunción distribuye sobre la conjunción, o sea, demuestre la ley distributiva p ν (q ^ r) ≡ ( p ν q) ^ (p ν r). Construya las tablas de verdad requeridas. p q r q^r p ν (q ^ r) pνq pν r ( p ν q) ^ (p ν r) V V V V V V V V V V F F V V V V V F V F V V V V V F F F V V V V F V V V V V V V F V F F F V F F F F V F F F V F F F F F F F F F Como las tablas de verdad son idénticas, las proposiciones son equivalentes. 2.9 Demuestre que la operación de disyunción se puede escribir en términos de las operaciones conjunción y negación. Específicamente, p ν q≡ ~ (~ p ^ ~ q). Construya las tablas de verdad requeridas p q pνq ~p ~q ~p^~q ~ (~ p ^ ~ q) V V V F F F V V F V F V F V F V V V F F V F F F V V V F Como las tablas de verdad son idénticas, las proposiciones son equivalentes. Informática I. Versión 1.0 Agosto de 2004 26
- 27. Universidad Autónoma deOccidente 2.10 Simplifique cada proporción usando la tabla 2-1: (a) p ν (p ^ q), (b) ~( pν q) ν (~ p ^ q). (a) Equivalencia Razón (1) p ν (p ^ q) ≡ (p ^ t) ν (p ^ q) (1) Ley de Identidad (2) ≡ p ^ ( t ν q) (2) Ley distributiva (3) ≡p^t (3) Ley de Identidad (4) ≡p (4) Ley de Identidad (b) Equivalencia Razón (1) ~ (p ν q)ν (~ p ^ q) ≡ (~ p ^ ~ q) ν (~ p ^ q) (1) Ley de DeMorgan (2) ≡ ~ p ^ (~ p ν q) (2) Ley distributiva (3) ≡ ~p^t (3) Ley de complemento (4) ≡ ~p (4) Ley de Identidad Negación. 2.11 Demuestre las leyes de DeMorgan: (a) ~( p ^ q) ≡ ~ p ν ~ q; (b) ~( pν q) ≡ ~ p ^ ~ q. En cada caso construya las tablas de verdad requeridas. (a) p q p ^ q ~ (p ^ q) ~ p ~ q ~ p ν ~ q V V V F F F F V F F V F V V F V F V V F V F F F V V V V (b) p q pν q ~( pν q) ~p ~q ~p^~q V V V F F F F V F V F F V F F V V F V F F F F F V V V V 2.12 Verifique ~ ~ p≡ p p ~q ~~p V F V F V F 2.13 Use los resultados de los problemas 2.11 y 2.12 para simplificar los siguientes enunciados. (a) No es cierto que su madre sea inglesa o que su padre sea francés. (b) No es cierto que él estudie física pero no matemática. (c) No es cierto que las ventas estén bajando y los precios subiendo. (d) No es cierto que no esté haciendo frió o que esté lloviendo. Informática I. Versión 1.0 Agosto de 2004 27
- 28. Universidad Autónoma deOccidente (a) Sea p “Su madre es inglesa” y sea q “Su padre es Francés”. Entonces el enunciado dado es ~ ( pν q ). Pero ~ ( pν q ) ≡ ~ p ^ ~ q. Por lo tanto, el enunciado dado es lógicamente equivalente con el enunciado “Su madre no es inglesa y su padre no es francés”. (b) Sea p “El estudia fisica” y q “El estudia matemáticas”. Entonces el enunciado dado es ~ ( p ^ ~ q).pero ~ (p ^ ~ q) ≡ ~ pν ~ ~ q ≡ ~ p ν q. Así que el enunciado dado es lógicamente equivalente al enunciado “El no estudia fisica o estudia matemáticas”. (c) Como ~ (p ^ q) ≡ ~ p ν ~ q, el enunciado dado es lógicamente equivalente al enunciado “Las ventas estan subiendo o los precios estan bajando”. (d) Como ~ (~ p ν q) ≡ p ^ ~ q, el enunciado dado es lógicamente equivalente al enunciado “Esta haciendo frió y no esta lloviendo”. Condicionales y Bicondicionales. 2.14 Escriba de nuevo los siguientes enunciados sin usar la condicional. (a) Si hace frió, él se pone sombrero. (b) Si la productividad sube, los sueldos suben. Recuerde que “Si p entonces q” es equivalente con “No p o q”; o sea, p → q ≡ ~ p ν q. (a) No está haciendo frío o él se pone el sombrero. (b) La productividad no sube o los sueldos suben. 2.15 (a) Demuestre que “p implica q y q implica p” es lógicamente equivalente con la bicondicional “p si y sólo si q”; o sea, (p → q) ^ ( q → p) ≡ p ↔ q (c) Demuestre que la bicondicional p ↔ q se puede escribir en términos de las tres conectivas originales ν, ^ y ~. (a) p q p↔q p→q q →p (p → q) ^ ( q → p) V V V V V V V F F F V F F V F V F F F F V V V V (c) Ahora p → q ≡ ~ p ν q y q → p ≡ ~ qν p; por lo tanto por (a) p ↔ q ≡ ( p → q) ^ ( q → p)≡ (~ q ν q) ^ (~ q ν p) Informática I. Versión 1.0 Agosto de 2004 28
- 29. Universidad Autónoma deOccidente UNIDAD 3. HERRAMIENTA DE PROGRAMACIÓN. 3.1 Introducción Aunque el concepto de orientado a objetos, se ha asociado al desarrollo de software, realmente, este es una forma de concebir el mundo, de manejar conceptos y de entender el funcionamiento de sistemas, sin embargo, para el objetivo del presente módulo, se tratará solamente la acepción de orientado a objetos como paradigma de programación. El paradigma orientado a objetos se asoció durante mucho tiempo con los lenguajes y la programación orientada a objetos, sin embargo, en la actualidad, el uso de objetos debería incluir tanto el análisis como el diseño orientados a objetos, el uso de bases de datos y en general, la ingeniería de software orientada a objetos. Aunque no intencionalmente, la programación orientada a objetos implica un mayor grado de análisis, ya que de alguna forma deben estar definidas las clases, atributos y métodos que se van a implementar. Por ende, al aumentar el tiempo dedicado al análisis y concepción del software, el tiempo de las otras etapas se reduce. 3.2 Origen del paradigma Orientado a Objetos Orientado a Objetos es un término que empezó a acuñarse a finales de los 80's, cuando la programación requería nuevos paradigmas, nuevas formas de interpretarse. Durante los 90's tomó gran fuerza, pero indiscutiblemente son las dos últimas décadas las que han empezado a recoger los frutos; en otros países ya la programación orientada a objetos es un hecho y algunos programadores no podrían pensar en otra forma de desarrollar software. Autores de gran reconocimiento empezaron a trabajar de manera aislada explorando este nuevo paradigma, logrando avances tanto en lenguajes de programación como en técnicas apropiadas de análisis y diseño. Ejemplo de ello son los métodos propuestos por Grady Booch, Ivar Jacobson o James Rumbaugh entre otros. 3.2.1 Definición de Orientado a Objetos El concepto de orientado a objetos está relacionado con otros múltiples conceptos: la programación, las interfaces de usuario y la representación jerárquica de hechos, tienen todos orientación a objetos. Entonces, ¿cómo podría definirse este término?. Una definición bastante general de objeto es: todo aquello que tiene limites definidos. En ese orden, los libros, las sillas, las personas, los animales, las empresas, son todos objetos. Algunas personas afirman que la orientación a objetos es la forma natural de nuestro aprendizaje. Cuando estamos pequeños se nos enseña a distinguir y agrupar objetos acorde a sus características y/o comportamientos y es por ello que logramos distinguir una silla de un caballo aunque ambos tengan patas. La programación orientada a objetos es un "estilo" de programación bajo el cual se divide el problema a solucionar en los objetos que lo componen. Luego se verá que cada objeto de estos contiene atributos y métodos que permiten su interacción y la ejecución de diversas tareas para cumplir el propósito del programa. Existen muchos lenguajes que permiten realizar la programación orientada a objetos, entre ellos se destacan Smalltalk, Java, C++, Object Pascal, Eiffel. Informática I. Versión 1.0 Agosto de 2004 29
- 30. Universidad Autónoma deOccidente 3.3 Breve historia de los estilos de Programación Desde el principio de la programación se han intentado muchos métodos y procedimientos para lograr una programación fácil y eficiente. El primer enfoque, si se puede llamar así, es la programación no estructurada o "programación espagueti", bajo la cual el programador se sienta frente al computador y empieza a escribir líneas de código (instrucciones) sin estructura alguna, resultando en un programa largo, difícil de entender y aun más difícil de modificar. El primer enfoque formal que se formalizó fue el enfoque procedural (o procedimental), que se podría resumir como "Usted decide qué procedimiento quiere, y usa el mejor algoritmo que pueda encontrar". Aunque este enfoque resultaba muy práctico para resolver problemas particulares, no así cuando se quería reutilizar parte del código o emplear ciertas funciones en otros programas. En resumen, el enfoque procedural no permitía mejorar la productividad de la construcción del software por sus características particulares. Surge entonces un segundo enfoque o paradigma, la programación modular (o funcional). Para esta época ya se ha incrementado visiblemente el tamaño de los programas desarrollados, lo cual genera problemas adicionales de productividad. El enfoque de programación modular es algo como "Decide los módulos que quieres, de forma que las partes del programa y los datos queden ocultos tras los módulos". La intención primordial de este enfoque es dividir el problema (programa necesario) en partes independientes pero relacionadas, que se puedan solucionar de manera separada. La programación modular propicia la reutilización de código, ya que existen partes (módulos) que podrían ser empleadas en otros programas, siempre que se requiera la misma utilidad. Esta idea, aunque en apariencia buena, no surtió mucho efecto ya que los programadores normalmente se preocupaban por el código pero no por los datos y, normalmente, los módulos requerían de datos que estaban fuera de ellos. En un intento por mejorar la concepción modular surgen los llamados tipos abstractos de datos o TADs, los cuales intentan agrupar, en la misma estructura, los datos necesarios y las operaciones requeridas para su manejo. Sigiuendo el concepto de TADs pronto se encontró otro mecanismo para lograr que se crearan unidades independientes, que permitieran la reutilización de código, y la programación por componentes; ahora se podría "armar" un programa, tal como se arma un computador o una nevera, bastaría conseguir las piezas adecuadas y establecer los enlaces necesarios. A este novedoso enfoque se le conoce como programación orientada a objetos. La programación orientada a objetos presenta múltiples ventajas. Empecemos por decir que los programas ahora estarán compuestos por objetos. Cada objeto, a su vez, está compuesto por los datos o características que lo distinguen y los métodos o procedimientos necesarios para su manipulación. 3.4 Definiciones de clases y objetos Todos los estilos o enfoques de programación se encuentran basados en un marco referente, de la misma forma todas las técnicas orientadas a objetos se basan en un marco, que Grady Booch ha llamado el Modelo de Objetos. 3.4.1 El Modelo de Objetos El modelo de Objetos, según Booch, se compone de cuatro elementos esenciales, sin los cuales perdería la propiedad de orientación a objetos. Estos son: • Abstracción Informática I. Versión 1.0 Agosto de 2004 30
- 31. Universidad Autónoma deOccidente • Encapsulamiento • Modularidad • Jerarquía Igualmente incluye otros elementos que, sin ser esenciales, resultan bastante útiles dentro de este estilo de programación: • Tipos • Concurrencia La adecuada comprensión de estos conceptos no es ni exclusiva ni elemental para programar orientado a objetos. Sin embargo, si no se toman en cuenta estos elementos, la programación orientada a objetos dejaría de emplear todo el poder que otorgan los objetos. 3.4.1.1 Abstracción El primer concepto fundamental del paradigma orientado a objetos es la abstracción. Una definición bastante apropiada del término abstracción es la dictada por Booch: "Una abstracción denota las características esenciales de un objeto, que lo distingue de todas las otras clases de objetos y lo provee de conceptos definidos, relativos a la perspectiva del usuario". Dos cosas importantes deben resaltarse aquí. La primera es que lo que aprendemos, realmente son abstracciones de la realidad: la idea que tenemos de una mesa, por ejemplo, releva las características básicas de ésta, permitiéndonos diferenciarla de una silla o de un sofá aunque puedan ser parecidos. La segunda idea importante, es que las abstracciones dependen de la perspectiva del usuario: diferentes personas tienen diferentes abstracciones de los objetos, dependiendo de su experiencia e interés particular. Actividad #1: Describa las abstracciones que usted posee de computador, mesa, cama, gato. 3.4.1.2 Encapsulamiento Una característica esencial de los objetos es el encapsulamiento, por la cual, cada objeto mantiene oculto su interior. Al tratar un objeto como una “caja negra”, los otros objetos que interactúan con él no requieren conocimiento alguno sobre la forma como opera internamente, requiriendo sólo el conocimiento de los parámetros necesarios para dicha interacción. Si los objetos no mantienen el encapsulamiento, se estaría violando uno de los principios básicos de la orientación a objetos. La definición original de Booch plantea: "Encapsulamiento es el proceso de compartimentalizar los elementos de una abstracción, que constituyen su estructura y comportamiento”. Una ventaja adicional del encapsulamiento se refiere a que el interior de los objetos puede cambiarse (mejorarse) sin que se requieran cambios en la interfaz que éstos mantienen con otros objetos. Actividad #2: Enumere 10 elementos que usted emplea normalmente sin conocer realmente cómo realizan su funcionamiento, pues ellos están encapsulados. 3.4.1.3 Modularidad La modularidad es un concepto muy antiguo. Aunque es válido para la orientación a objetos no es exclusivo de ésta. Meyers mencionó la ventaja de la modularidad como: "La acción de partir un programa en componentes individuales puede reducir su complejidad en algún grado.... aunque la Informática I. Versión 1.0 Agosto de 2004 31
- 32. Universidad Autónoma deOccidente partición de un programa es útil por esto, una justificación más poderosa para partir un programa es que él sea un número de límites bien definidos y documentados. Estos límites o interfaces son invaluables en la comprensión del programa". La modularidad es básicamente la división en partes de un programa de software (para nuestro caso), considerando que estos módulos deben mantener la cohesión y el acoplamiento adecuado. Actividad #3: Normalmente las cosas que nosotros empleamos se encuentran compuestas de partes (al menos eso dice la Teoría General de Sistemas). Intenta determinar las partes que componen: una bicicleta, un computador, una casa. 3.4.1.4 Jerarquía La jerarquía se puede entender como la clasificación u ordenamiento de las abstracciones, esto permite asociar unos objetos con otros. Existen dos clases básicas de jerarquías (o clasificaciones), la que corresponde a es parte de, llamada también jerarquía de partes. Por ejemplo, el manubrio es parte de la bicicleta, o la RAM es parte del computador. La otra jerarquía es la que corresponde a es un, llamada también jerarquía de tipos. Por ejemplo, La vaca es un mamífero, la silla es un mueble. Actividad #4: Intente establecer la jerarquía entre estos elementos: Impresora, Bandeja, Epson Stylus, Cartucho, Impresora de Burbuja, Impresora Laser, Toner, Panel de Mando, Conector, HP LaserJet. Motor, Puerta, Mazda 323, Daewo Lanus, Automóvil, Llantas, Bujías, Tanque de Gasolina. 3.4.1.5 Tipos Los tipos son la representación de las jerarquías de tipos. Cuando varios elementos se agrupan de acuerdo a ciertas características específicas que ellos guardan en común, se dice que corresponden a un mismo tipo. Los tipos, definidos por Booch, son "la parte fundamental de la clase de un objeto, de forma que los objetos de tipos diferentes no pueden ser intercambiados, o a lo más pueden ser intercambiados sólo en forma muy restringida". Actividad #5: Es normal que cada cosa que conocemos la caractericemos como perteneciente a un tipo particular. En qué tipo caracterizaría usted los siguientes objetos: casa, computador, vaca, perro, silla, cuaderno, libro, universidad. 3.4.1.6 Concurrencia Normalmente los objetos deben realizar tareas simultáneas, sin que unas afecten a otras. A estos requerimientos de ejecución de varias tareas se les conoce como concurrencia. Booch la define como "La propiedad que distingue un objeto activo de uno que no está activo", entendiendo un objeto activo como una abstracción del mundo real que puede representar un hilo de control separado (una ruta diferente de ejecución). Actividad #6: Muchos de los sistemas (computacionales o no) que encontramos en la vida diaria pueden realizar procesos concurrentes (varias cosas al tiempo), intente clasificar los siguientes sistemas como concurrentes o no: un computador con windows, un computador con linux, una persona, un cajero electrónico, una máquina de hacer café, un microondas. Informática I. Versión 1.0 Agosto de 2004 32
- 33. Universidad Autónoma deOccidente 3.4.2 Definiciones de Orientación a Objetos Cuando nos referimos específicamente a la programación orientada a objetos, se emplean los conceptos vistos a través de términos que hacen referencia al programa y las partes con las que se establece. 3.4.2.1 Clases y Objetos El concepto de objetos es para muchos la forma "normal" de asociar las cosas de la vida con nombres. Cuando iniciamos nuestra educación, empleamos procesos difíciles de asociación de características y modelos a nombres determinados. Una clase es un concepto que incluye características o atributos (datos), y procedimientos de una entidad del mundo real. Ejemplos de clases son: Mueble, Auto, Medio de Transporte, Edificación, etc. De otra parte, se entiende que las clases son generalizaciones de los objetos, o lo que es lo mismo, los objetos son instancias de clase. Ejemplos de objetos son: La silla del rector, el carro de Pedro, El asiento rojo, etc. Los objetos poseen ciertas características que los hacen particulares. Tales características son: • Tiene un estado (atributos o características) • Tiene un comportamiento (métodos asociados) • Tiene una identidad (ocupa un lugar en memoria) • Tiene un ciclo de vida • Tiene una visibilidad • Se relaciona y colabora con otros objetos 3.4.2.2 Atributos Los atributos de una clase (y por ende, de un objetos) son las características relevantes de esta. Como se puede suponer, los atributos de la clase se determinan de acuerdo al problema o situación que se desea tratar; es decir, dependen de la abstracción que se haga del objeto. Por ser los objetos instancias de las clases, contienen todos los atributos de éstas. Por ejemplo: • La clase silla: tiene como atributos la clase, el número de patas, el tipo de tapizado, el estilo, el material, la fecha en que fue fabricada. • La clase carro: tiene como atributos el número de puertas, la marca, el modelo, el precio. 3.4.2.3 Operaciones, métodos y servicios Las clases, además de atributos, contienen los procedimientos que pueden manipular o procesar estos datos. A estos procedimientos se les conoce como operaciones, métodos o servicios. Estos métodos exhiben el comportamiento posible del objeto. Este comportamiento ocasionará que el objeto mismo cambie de un estado a otro. Por ejemplo: • La clase auto: tiene como métodos o servicios, arrancar, parar, frenar, aumentar velocidad, disminuir velocidad. • La clase computador: tiene como métodos o servicios, encender, iniciar, arrancar programa. Informática I. Versión 1.0 Agosto de 2004 33
- 34. Universidad Autónoma deOccidente 3.4.2.4 Identidad Los objetos deben ser creados y durante su creación deben recibir un nombre y una asignación de espacio en memoria. En este sentido, los objetos, a diferencia de las clases, existen dentro del computador por un tiempo que determinará el programador. 3.4.2.5 Ciclo de Vida Como se dijo anteriormente, los objetos cambian de estado dependiendo del comportamiento que desarrollen. A todos estos cambios de estado por los que pasa (o puede pasar) un objeto desde que es creado hasta que muere, se le denomina ciclo de vida. Actividad #7: Establezca atributos y métodos para cada uno de los conceptos mencionados a continuación, y especifique si son clases u objetos. Si es un objeto, indique a qué clase pertenecería: árbol, manzana, casa, Corporación Universitaria Autónoma de Occidente, Secretaría de Gobierno, Amigo, Estudiante, Perro, Ferrari. 3.4.2.6 Relaciones con otros objetos Los objetos han sido determinados como partes de la solución de un problema y ello implica que tengan que relacionarse para cumplir su cometido. Las relaciones entre los objetos pueden ser de muchas clases: Mensajes Los mensajes activan las operaciones y métodos de cada objeto. Un objeto envía a otro un mensaje, en el cual se indica el destino, la operación requerida y los parámetros que debe incluir. Los mensajes son el corazón del comportamiento del sistema, ya que le indica a los objetos comunicarse entre ellos para ejecutar sus operaciones. Normalmente la clase de relaciones que se establecen a través de los mensajes se les denomina relaciones de uso, ya que un objeto usa a otro. Herencia Las clases pueden heredar de otras clases sus atributos y métodos. La herencia responde a la necesidad de hacer clases nuevas que contienen características similares (o iguales) a las de otra clase ya existente. Parte (mucho) del arte de programar orientado a objetos es determinar la mejor forma de estructurar el programa “economizando” clases. Conviene aclarar que al emplear herencia, se reduce el número de líneas a implementar. Algunos lenguajes como Java resultan ser muy estrictos en términos de herencia, ya que todas las clases deben heredar de alguna. por lo anterior, JAVA tiene una "superclase" llamada Object, de la cual se derivan todas las restantes. Cuando una clase hereda de otra, puede variar los atributos y métodos que ha heredado, logrando su propia identidad respecto a la clase de la cual se originó. Algunos Lenguajes Orientados a Objetos, permiten que una clase hereda de dos o más, lo cual se conoce como herencia múltiple. Del concepto de herencia, se deriva el concepto de jerarquía de clases, que presenta esquemáticamente la herencia entre las clases. Informática I. Versión 1.0 Agosto de 2004 34
- 35. Universidad Autónoma deOccidente Agregación Cuando un objeto o clase se encuentra compuesta por otros, se dice que existe una relación de agregación entre ellos. Actividad #8: Indique que clase de relación existe entre cada conjunto de elementos (considerando que todos son objetos y que guardan alguna relación). Procesador, memoria, unidad de disco, diskette, computador, usuario. Casa, sala, Edificación, Biblioteca pública, sillas, mesas, mesa de comedor. Polimorfismo El Polimorfismo es una característica propia de los objetos, que permite que operaciones diferentes posean el mismo nombre Sobrecarga La sobrecarga es una clase de polimorfismo, en la cual los métodos se diferencian básicamente por la clase de parámetros que reciben. Al recibir el mensaje el objeto, mediante los parámetros identifica automáticamente la operación que se desea ejecutar; esto se conoce como sobrecarga de métodos. Por ejemplo: imprimir(factura), imprimir(reporte), imprimir(paz y salvo); aunque la función (método) es la misma, dependiendo el tipo de argumento que recibe se realizarán diferentes labores. Algunos lenguajes, como C++, permiten además lo que se llama sobrecarga de operadores (operator overloading) gracias a la cual se pueden redefinir los operadores aritméticos básicos ( +, - , * , / ). Por ejemplo: 3 + 5 sumará enteros, mientras "Hola" + " amigos", concatenará cadenas. Sobreescritura La sobreescritura corresponde a la otra clase de polimorfismo, llamado también polimorfismo de generalización. En éste, los métodos heredados de una superclase pueden ser sobrescritos para elaborar funciones diferentes. Sin embargo, NO se puede variar la signatura (ó firma) del método; es decir; NO se puede cambiar el nombre, el tipo de los parámetros, el número de parámetros que recibe y el tipo de dato que devuelve. Informática I. Versión 1.0 Agosto de 2004 35
- 36. Universidad Autónoma deOccidente Ejercicios 1. Indique si cada uno de los enunciado presentados a continuación es verdadero o falso y justifique su respuesta: a. Al programar orientado a objetos, lo que se definen son clases. b. Debido al encapsulamiento, los métodos de un objeto no pueden ser usados por otro. c. La programación orientada a objetos facilita la reutilización de código. d. La relación de herencia indica que un objeto es parte de otro. e. Un objeto sólo puede pertenecer a una clase. f. El polimorfismo permite que varios métodos tengan igual nombre. g. La programación “espagueti” se puede considerar modular. h. La programación procedural admite la herencia. i. Los métodos de una clase se implementan siguiendo las directrices de la programación estructurada j. La herencia especifica que una clase posee los mismos métodos y atributos de la clase de la cual hereda. k. Auto es una instanciación de Medio de Transporte. l. Pedro es un objeto de la clase Persona. m. Pedro es una clase. n. Atributos de auto son rojo, grande y mazda. o. Métodos de Teléfono son establecer comunicación y timbrar. p. Manzano hereda de Árbol. q. Manzana hereda de Manzano. r. Tablero es parte de Profesor. s. Otoño es una clase de Estación. t. Windows hereda de Sistemas Operativos. 2. Complete las siguientes frases con la palabra adecuada a. La sobrecarga es la implementación de _____________________________________. b. Un objeto es una _________________de una clase. c. La programación __________________________________se basa en partes, cada una con características y funciones específicas. d. Cuando una clase redefine un método con la misma signatura que tenía en la clase de la cual heredó se denomina __________________. e. La herencia puede ser _________________________o múltiple. f. Las características esenciales que distinguen a un objeto se conocen como ____________________del objeto. g. La primera técnica formal de programación conocida fue la programación _______________________________________. h. Si un sistema puede realizar varias tareas al tiempo, se dice que tiene procesamiento ________________. i. Los __________ son estructuras de datos que dieron origen a los objetos. j. Memoria ___________________ de Computador. k. IBM NetVista es ____________________ de Computador. l. Fuente de Poder es ______________ de Computador. m. Maria Isabel ____________ de clase Estudiante n. La clase persona usa la clase _________________ o. La clase perro _______________ la clase animal. p. Matemáticas es un objeto de la clase _________________. q. _____________ es un objeto de clase pescado. r. Arroz con pollo ______________ comida. Informática I. Versión 1.0 Agosto de 2004 36
- 37. Universidad Autónoma deOccidente 3.5 Características básicas del lenguaje Java 3.5.1 Historia de JAVA Una de las áreas reconocidas de avance para la computación e informática, es la de los dispositivos electrónicos inteligentes. En razón de esto, Sun Microsystems financió un proyecto de investigación interno con el nombre Proyecto Green en 1991. Uno de los resultados de este poyecto fue un lenguaje basado en C y C++, llamado Oak, creado por James Gosling, Patrick Naughton, Chris Warth, Ed Frank y Mike Sheridan. Poco después se descubrió que ya existía un lenguaje con este nombre, así que surgió el nombre de JAVA (una clase de café). El prototipo original, desarrollado en 18 meses, fue mejorado con la ayuda de muchas personas, lo cual tomó más de 3 años. El propósito inicial con el proyecto fue crear un lenguaje independiente de la plataforma, que facilitara el uso en diferentes dispositivos electrónicos. Hasta el momento, C y C++ eran los lenguajes más empleados, sin embargo no permitían la facilidad requerida ya que debe proveerse del compilador especifico para la CPU necesaria, lo cual puede llevar algún tiempo de construcción. Sin embargo, mientras se desarrollaba JAVA apareció el otro elemento que formaría parte esencial de su construcción, el World Wide Web; de no ser por este aspecto, JAVA probablemente no habría pasado de ser un lenguaje más empleado por los diseñadores de hardware en sus laboratorios. Es conveniente aclarar que aunque JAVA basó su desarrollo en C y C++, de ninguna manera es una versión avanzada de estos, no es compatible con alguna versión de C++, ni intenta reemplazarlo; más bien maneja otras características importantes que se requerían en su momento, dando a los programadores un ambiente familiar. Respecto a la programación, JAVA presenta muchas ventajas, como mencionan Naugthon y Schildt: "Java fue diseñado, probado y refinado por programadores auténticos. Es un lenguaje que se basa en las necesidades y experiencia de la gente que lo ha inventado.... Java es un lenguaje coherente y lógicamente consistente.... Java le permite al programador tener el control total, excepto en aquellas limitaciones impuestas por Internet. Si uno programa bien, el programa lo reflejará; si uno programa mal, el programa también lo reflejará. Dicho de otro modo, Java no es un lenguaje con ruedas de entrenamiento, sino que es un leguaje para programadores profesionales". La intención de Sun Microsystems con el desarrollo de JAVA no fue el lucro, sino facilitar sus propias labores en la construcción de dispositivos de hardware. Por tanto, el JAVA y sus herramientas asociadas siempre han sido de dominio público, de forma que basta entrar al sitio de sun (www.java.sun.com), para obtener la versión actualizada del JDK (Java Development Kit). Exactamente, en el sitio web http://java.sun.com/downloads , usted puede descargar el kit de desarrollo de Java. 3.5.2 Características Básicas de JAVA JAVA posee muchas características importantes. A continuación se mencionarán aquellas más sobresalientes. Orientado a Objetos puro Muchos lenguajes tienen como característica ser orientado a objetos, lo cual implica que permitan crear clases, manejar herencia y mantener el encapsulamiento. No obstante, existen dos clases de lenguajes orientados a objetos: aquellos que permiten las características del manejo de objetos, pero también mantienen características de otros estilos de programación (v.g. programación procedimental); a estos lenguajes se les conoce normalmente como híbridos. Un ejemplo clásico de este tipo de lengujes es el C++ que, además de soportar el manejo de objetos, también permite la escritura de código propio de C. Informática I. Versión 1.0 Agosto de 2004 37
- 38. Universidad Autónoma deOccidente La otra clase de lenguajes son los denominados puros, tal como Java o Smalltalk, en donde sólo se pueden manejar clases y objetos. Por lo tanto, cualquier fragmento de código que se quisiera escribir debe formar parte de una clase. Simple Una preocupación de SUN es mantener el lenguaje simple. Desde su comienzo, las instrucciones propuestas, similares al C, tienen por objeto facilitar al programador su comprensión, incluso con estándares muy sencillos como que las clases se escriben iniciando en mayúscula y los objetos con minúsculas. Con miras a esto, se quitaron algunos aspectos que C++ maneja; tales como sobrecarga de operadores, herencia múltiple y apuntadores; por considerar que no aportaban de manera significativa en relación con la complejidad que revestían y se adicionaron otros aspectos para facilitar la vida del programador, tal como el colector de basura. Distribuido Java ha sido diseñado para interactuar de manera sencilla con el conjunto de protocolos TCP / IP (manejados en Internet), de manera que las aplicaciones de Java puedan abrir y acceder a objetos a través de URLs de manera tan sencilla como si estuvieran en la misma máquina. Robusto La robustez de un software es una de las características de calidad más importantes y se refiere a la posibilidad del software de prevenir posibles errores que, de ocurrir, podrían interrumpir la ejecución adecuada del mismo. Java se preocupa por ello y hace un especial énfasis en la detección de problemas, chequeo dinámico (en tiempo de ejecución) y eliminar posibles situaciones de error. Seguro Una de las intenciones de Java es que éste sea empleado en entornos de red y distribuidos, pero se debe tener conciencia de la importancia de la seguridad en ambientes de este estilo. Por ello, el lenguaje mismo provee mecanismos apropiados para evitar la construcción de virus o trampas. También tiene mecanismos de autenticación basados en encriptamiento de llaves (SSL). Arquitectura Neutral Para que las aplicaciones que se hacen en java puedan efectivamente viajar a través de la red, el lenguaje debe proveer mecanismos que permitan ejecutar el software en cualquier sistema, independiente de su plataforma; por ello, Java provee una archivo en un formato de arquitectura neutra que puede ser ejecutado en diferentes procesadores con la ayuda del adecuado sistema de ejecución de java. Portable La arquitectura neutra es la base para la portabilidad, pero para lograr que el software sea portable se requiere mucho más. Por ejemplo, el manejo de los diferentes tipos de datos y las interfaces gráficas deben ser independientes de la plataforma en que se ejecutan. El sistema Java mismo es altamente portable, el compilador está escrito en JAVA y el runtime (ejecutador) está escrito en ANSI C. Interpretado El interpretador de Java puede ejecutar directamente los bytecodes (código de bytes, generado después de la compilación) directamente en la máquina en la cual se encuentra instalado. Muchas Informática I. Versión 1.0 Agosto de 2004 38
- 39. Universidad Autónoma deOccidente personas han visto esta característica como una desventaja de Java, debido a que el proceso de enlace (link, p. ej. en C / C ++) es mucho más rápido y liviano. Sin embargo, debe reconocerse que la interpretación ayuda en los procesos de depuración. Alto desempeño Aunque el desempeño del interpretador comúnmente es suficiente, si se requiere un mayor nivel de desempeño puede traducirse el bytecode a un código particular para la máquina en la cual se ejecuta. Multihilos Multihilo es es la forma de construir aplicaciones de manera que puedan realizar varias actividades (hilos) al mismo tiempo. Java tiene primitivas básicas que permiten monitorear y usar los hilos; esto logra una mejor interacción y un comportamiento de tiempo real (limitado sólo por la máquina en la cual está corriendo). Dinámico Java fue diseñado para adaptarse a un entorno cambiante. El hecho de manejar objetos permite que los cambios que se requieran en un software determinado no afecten de manera significativa los procesos existentes. Ver mas en www.java.sun.com/docs/white/langenv/ Actividad #9: Tome dos de las características básicas de JAVA, investigue más al respecto indicando en qué consisten exactamente y qué otros lenguajes de programación tienen estas características (una u otra). 3.5.3 La estructura de JAVA ¿Compilado o Interpretado? Una de las primeras inquietudes que surgen cuando se empieza a interactuar con Java es si realmente es un lenguaje compilado o interpretado; la respuesta es sencilla: los dos. La forma de operar de Java es un tanto diferente a la forma en que operan otros lenguajes más tradicionales y esto es, justamente, lo que permite que los programas desarrollados en Java puedan emplearse en diferentes plataformas. El siguiente gráfico, presenta la forma como se debería procesar un programa en Java. Procesamiento de un programa en JAVA ( Fuente: Java Tutorial) Como se puede observar, el programa fuente (myProgram.java) debe ser compilado para crear el programa en bytecode (myProgram.class), el cual puede ser ejecutado en cualquier plataforma, ya que Informática I. Versión 1.0 Agosto de 2004 39
- 40. Universidad Autónoma deOccidente la máquina que lo ejecutará en particular tiene su intepretador (diferente para cada máquina) que lee, interpreta y ejecuta cada una de las instrucciones que encuentra en el bytecode. Plataforma de Java Como plataforma se conoce al entorno Hardware – Software en el cual se ejecuta un programa. Normalmente se asocia con el sistema operativo y la máquina sobre la que este corre; así, se tienen como plataformas: Windows (en cada una de sus formas), MacOS, Linux, Uníx, Solaris, etc. La plataforma de Java se compone de dos elementos básicos: Java Application Programming Interface (Java API) y la Java Virtual Machine (JVM). Su ubicación se presenta en el siguiente gráfico. Plataforma de Java (Fuente: Java Tutorial) • El Java Virtual Machine es el intérprete de Java. Como se dijo anteriormente, existen un JVM para cada plataforma y es el que permite que un programa sea escrito una vez y ejecutado en varias plataformas sin requerir cambios. • La API de Java o Interface de Programas de Aplicación es una colección de componentes de software que provee diferentes utilidades para el programador, tal como la interfaz gráfica de usuario (GUI). La API se encuentra organizada en librerías que contienen clases o interfaces, conocidas como paquetes (packages). El siguiente gráfico muestra lo que incluye el Java 2 SDK (Standard Developer Kit). Contenido del Java 2 SDK (Fuente: Java Tutorial) El JRE o Java 2 Runtime Environment es: la máquina virtual, la plataforma de clases y los archivos de soporte. El SDK (Standard Developer Kit) incluye el JRE y las herramientas de desarrollo como compiladores y depuradores. 3.5.4 Instalación de JAVA Java pertenece al software de dominio libre, es decir que cualquier persona puede entrar al sitio de Internet y bajarlo sin pagar ningún costo. • Para iniciar la instalación de Java, entre al sitio http://java.sun.com/downloads y escoja la versión apropiada de JDK acorde a su plataforma. Informática I. Versión 1.0 Agosto de 2004 40
- 41. Universidad Autónoma deOccidente • El archivo j2sdk-1_4_2_05-windows-i586-p debe quedar en su disco, este es el instalador del SDK. Al ejecutar este programa, se instalará el Java en su disco, normalmente se instala en el directorio C:j2sdk1.4.2_05 (NOTA: los nombres de los archivos podrían variar dependiendo de la versión de Java disponible). • Aunque no es obligatorio, es mejor actualizar el Path (camino) del computador, para permitir que siempre encuentre los programas necesarios sin importar el directorio en el cual se encuentre ubicado el programador. Para ello, • Puede escoger en el menú de inicio, la opción ejecutar y dar sysedit - Enter, el sistema presenta varias pantallas, debe escogerse el AUTOEXEC.BAT (este archivo establece algunas configuraciones iniciales cada vez que se enciende el computador). Busque la instrucción PATH. Si existe, agrege al final de ésta: ;C:j2sdk1.4.2_05BIN • Si no existe, al final del archivo escriba PATH C:j2sdk1.4.2_05BIN • Para que este cambio tenga efecto, debe reiniciarse el computador, ó, ejecutar el autoexec.bat. Ahora puede empezar a utilizar su JDK y hacer sus primeros programas en Java. Una última recomendación, las instrucciones que se manejarán para la compilación y ejecución se digitan desde el DOS, por lo que puede ser útil revisar algunas instrucciones básicas de este antiguo Sistema Operativo. No obstante, se sugiere un editor gratuito de la empresa Xinox software: JCreator 3.0, el cual puede descargar del sitio web http://www.jcreator.com 3.6 Construcción Básica de una Aplicación Un programa desarrollado en JAVA pasa por cinco fases para poder ejecutarse: Edición, Compilación, Carga, Verificación, Ejecución. Edición La edición de un archivo corresponde a la escritura del código fuente. Dentro del Kit original de JAVA no se incluye un editor, por lo que el programador deberá proveerse de uno. Para el propósito sirve cualquiera. Tomando en consideración que el texto debe ser plano, se recomienda Edit en Dos, NotePad en Windows o vi en Unix. De nuevo, se sugiere el editor gratuito de la empresa Xinox software: JCreator 3.0, el cual puede descargar del sitio web http://www.jcreator.com Debe tenerse en cuenta que los programas de código fuente en JAVA deben tener la extensión .java. Edición Se crea un programa .java Disco Compilación La compilación es el proceso por el cual el código fuente es traducido a un código de bytes (bytecode) que será interpretado durante la etapa de ejecución. Esta operación se realiza mediante el comando javac, el cual revisa la sintaxis y semántica del programa fuente escrito y, si todo es correcto, creará un programa con el mismo nombre del programa fuente y la extensión .class1. Compilación Se crea un programa .class Disco Carga Para que una aplicación pueda ejecutarse, debe ser cargada, ó, subida a memoria. Lo mismo ocurre con las aplicaciones de JAVA. El comando java se encargará, en primera instancia, de esta labor aunque también realiza la verificación y la ejecución. 1 Como se verá posteriormente, puede ocurrir que un archivo .java dé origen a varios archivos .class Informática I. Versión 1.0 Agosto de 2004 41
- 42. Universidad Autónoma deOccidente Carga Disco Se carga el programa a memoria Memoria Verificación En esta etapa se determina si la aplicación que se desea ejecutar tiene o no errores, principalmente de seguridad. Esto es muy importante, considerando que las aplicaciones comúnmente son enviadas a través de Internet. Se verifican que el Verificación Memoria bytecode sea válido y aspectos de seguridad Ejecución Finalmente, cubiertos todos los pasos, se interpretan las instrucciones del código de bytes, traduciéndolos a instrucciones que la máquina pueda realizar (lenguaje de máquina). Lee cada instrucción del Interpréte Memoria bytecode y las ejecuta Ejemplo de una Aplicación En Java se pueden desarrollar aplicaciones o applets. Las aplicaciones pueden ejecutarse en cualquier ambiente, su código es sencillo y no requiere archivos adicionales. Ejemplo: /* Es es un programa de prueba. La aplicación genera una línea de impresión en la pantalla. El archivo debe llamarse Bienvenida1.java */ class Bienvenida1 { // Toda aplicación debe tener un método main( ) public static void main( String args[ ] ) { System.out.println( "Bienvenido a la Tecnologia Java!!" ) ; } } Observe que: • Todo programa en JAVA debe contener al menos una clase. • El archivo del código fuente debe tener el mismo nombre de la clase principal de la aplicación. En este caso: Bienvenida1.java • El JAVA es sensible al uso de Mayúsuculas, así que Bienvenida1 y bienvenida1 son dos cosas diferentes. • Toda aplicación debe contener, en su clase principal, un método de nombre main( ), con la signatura (ó firma) presentada. Informática I. Versión 1.0 Agosto de 2004 42
- 43. Universidad Autónoma deOccidente El siguiente paso es la compilación. Para ello, desde la ventana del DOS, ubique el directorio donde guardó su archivo con código fuente y digite javac Bienvenida1.java Si el programa ha generado algún error, revise, corrija y repita la compilación hasta que no genere errores y quede creado un archivo Bienvenida1.class en su carpeta. Los pasos de cargar, verificar y ejecutar se realizar con una sola instrucción: java. Para ejecutar el programa anterior, digite java Bienvenida1 (no debe incluirse la extensión). Ahora podrá ver la ejecución del programa en la ventana de DOS. Ejemplo de una Applet Los applets (aplicacioncitas) son aplicaciones que requieren un entorno WEB para ejecutarse, de forma que se requiere que estén insertadas en una página WEB para ser vistas. Ejemplo: // Un ejemplo de Applet // El archivo debe llamarse Ejemplo1.java import javax.swing.JApplet ; import java.awt.Graphics ; public class Ejemplo1 extends JApplet { public void paint( Graphics g ) { g.drawString( "Ejemplo de applet en java", 25, 25 ) ; } } Observe que: • Todo applet de JAVA debe contener al menos una clase. • El archivo del código fuente debe tener el mismo nombre de la clase principal del applet, en este caso Ejemplo1.java. • El JAVA es sensible al uso de Mayúsculas, así que Ejemplo1 y ejemplo1 son dos cosas diferentes. • Los applets requieren de las librerías correspondientes. Para este caso se incluye la librería javax.swing y la librería java.awt. Dentro de la primera librería se ha escogido una clase específica: JApplet. Dentro de la última librería se ha escogido una clase específica: Graphics. • Los JApplets requieren un método llamado paint( ) Como se dijo anteriormente, para ejecutar un applet debe disponerse de una página WEB. El código de las páginas web está escrito en HTML (Hypertext Markup Language). Un código apropiado para el programa anterior sería: <html> <applet code = "Ejemplo1.class" width = 275 height = 35> </applet> </html> El nombre del archivo puede ser cualquiera con extensión .html. Lo recomendable sería que tuviera el mismo nombre del applet de JAVA. Informática I. Versión 1.0 Agosto de 2004 43
- 44. Universidad Autónoma deOccidente Observe que: • El código HTML siempre inicia y termina con html. • Las terminaciones de las secciones siempre son la misma palabra de inicio con una diagonal (/) antepuesta. • El ancho y alto especificado para el applet corresponden al tamaño de la ventana donde se ejecutará el applet. La compilación para un applet es igual que para una aplicación; es decir, desde la ventana de DOS ubique el directorio donde guardo su archivo con código fuente y digite javac Ejemplo1.java Una vez se disponga del programa .html y el .class (en el mismo directorio), hay dos formas de correrlo: 1) En un Browser (Netscape, Explorer, etc.) abra el archivo .html que creó, esto activará la carga, verficación y ejecución del applet. Debido a que el applet está trabajando con swing (un manejador de GUI relativamente nuevo en Java) algunos manejadores no lo soportan, por lo que es común que no pueda verse nada en el browser. 2) Empleando el appletviewer que posee el JDK. Para ello basta digitar desde la ventana de DOS appletviewer Ejemplo1.html (suponiendo que su archivo de html se llama Ejemplo1). El Java se encarga de crear un ambiente simulador de browser donde usted puede observar la ejecución de su applet sin problema. Salida: A continuación, otro ejemplo de Aplicación Java: Informática I. Versión 1.0 Agosto de 2004 44
- 45. Universidad Autónoma deOccidente Salida: Ejercicios Indique si las siguientes proposiciones son verdaderas o falsas, justifique su respuesta. a.- Java es un lenguaje orientado a objetos híbrido. b.- La API y la JVM se incluyen en el SDK. c.- Existen una única JVM para todas las plataformas. d.- La compilación, carga y verificación de un programa escrito en Java, se realizan en un solo paso. e.- El compilador de Java fue desarrollado en C. f.- Java es una versión actualizada de C++. g.- Se dice que Java es robusto porque permite al usuario depurar el código fácilmente. h.- Java se considera portátil porque una vez escrito y compilado el programa puede ejecutarse en cualquier plataforma. i.- Los applets son aplicaciones pequeñas que corren a través de un browser. j.- Java es sensible a mayúsculas. 3.7 Salida de datos estándar // Ejemplo 1 Esta aplicación Java muestra un mensaje de Bienvenida // en la salida estandar (pantalla), ó consola Java: class SalidaBasica1 { public static void main( String args[ ] ) { System.out.println( "Bienvenido al curso de Algoritmos con Java 2" ) ; } } // Fin de la clase SalidaBasica1 Salida: // Ejemplo 2 Esta aplicación Java explica la diferencia entre print y println class SalidaBasica2 { public static void main( String args[ ] ) { System.out.print( "Bienvenido al curso de " ) ; System.out.print( "Algoritmos con Java 2n" ) ; // n es el comando para nueva línea System.out.println( "Imprime una linea en blanco, ejecuta el retorno de carro y" ) ; System.out.println( "avanza a la linea siguiente" ) ; } } // Fin de la clase SalidaBasica2 Salida: Informática I. Versión 1.0 Agosto de 2004 45
- 46. Universidad Autónoma deOccidente 3.8 Entrada de datos estándar // Ejemplo 1 Esta aplicación Java muestra cómo ingresar una cadena de caracteres (String) // desde el teclado. import java.io.* ; // importa el paquete de entrada - salida básica. class EntradaBasica1 { public static void main( String args[ ] ) throws IOException { /* Note que antes de la llave de apertura del método main( ), se debe escribir 'throws IOException' para evitar mensajes relacionados con el manejo de errores y que impiden la correcta compilación del programa. */ InputStreamReader isr = new InputStreamReader( System.in ) ; BufferedReader br = new BufferedReader( isr ) ; /* Las 2 líneas anteriores habilitan la entrada de datos desde el teclado. El proceso le puede parecer confuso, pero es necesario que se vaya familiarizando con él. La primer línea subrayada crea un objeto, que hemos denominado arbitrariamente isr, de la clase InputStreamReader. Para crear el objeto isr, se le ha enviado al constructor de la clase InputStreamReader el argumento System.in (teclado). La segunda línea subrayada crea un objeto, que hemos denominado arbitrariamente br, de la clase BufferedReader. Para crear el objeto br, se le ha enviado al constructor de la clase BufferedReader el argumento isr, el cual es el objeto que se creó en la primer línea subrayada. El último objeto creado, br, es el que nos sirve para invocar el método readLine( ) de la clase BufferedReader. El método readLine( ) lee la información digitada desde el teclado hasta pulsar la tecla Return (o Enter, o Intro, etc) y la guarda como una cadena de caracteres (String). */ System.out.print( "Escriba su nombre y pulse RETURN: " ) ; String cadena = br.readLine( ) ; // Guarde el nombre en la variable cadena // Muestre en consola el nombre ingresado, concatenado con un mensaje: System.out.println( "Hola " + cadena + ", bienvenido a Java 2" ) ; } } // Fin de la clase EntradaBasica1 Salida: Informática I. Versión 1.0 Agosto de 2004 46
- 47. Universidad Autónoma deOccidente // Ejemplo 2 Esta aplicación Java muestra cómo ingresar una cadena de caracteres (String) // desde el teclado. import java.io.* ; // importa el paquete de entrada - salida básica. class EntradaBasica2 { public static void main( String args[ ] ) throws IOException { /* Note que antes de la llave de apertura del método main( ), se debe escribir 'throws IOException' para evitar mensajes relacionados con el manejo de errores y que impiden la correcta compilación del programa. */ /* La línea subrayada habilita la entrada de datos desde el teclado. Ahora, se han escrito las instrucciones del proceso en una sola línea. Repasando lo mencionado en el ejemplo anterior (clase EntradaBasica1), note de nuevo que para recibir los datos vía teclado, debe crear un objeto (que arbitrariamente hemos llamado br) de la clase BufferedReader. Observe que al constructor de la clase BufferedReader se le envía como argumento una nueva instancia (o sea, un objeto) de la clase InputStreamReader. Para obtener esta nueva instancia de la clase InputStreamReader, se ha enviado a su constructor la variable de clase 'in' de la clase System. De nuevo, el objetivo principal es crear un objeto, br, que nos permita invocar el método readLine( ) de la clase BufferedReader. El método readLine( ) lee la información digitada desde el teclado hasta pulsar la tecla Return (o Enter, o Intro, etc) y la guarda como una cadena de caracteres (String). */ // Usted debe memorizar la siguiente línea: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; String cadena ; // Declara la variable tipo String (cadena de caracteres) System.out.print( "Escriba su nombre y pulse RETURN: " ) ; cadena = br.readLine( ) ; // Guarde el nombre en la variable cadena // Muestre en consola el nombre ingresado, concatenado con un mensaje: System.out.println( "Hola " + cadena + ", bienvenido a Java 2" ) ; System.exit( 0 ) ; // Salga de la Aplicación } // Fin del método main( ) } // Fin de la clase EntradaBasica2 La salida es similar a la de la aplicación EntradaBasica1.java // Ejemplo 3 Esta aplicación Java muestra cómo ingresar un número entero // desde el teclado. Informática I. Versión 1.0 Agosto de 2004 47
- 48. Universidad Autónoma deOccidente import java.io.* ; // importa el paquete de entrada - salida básica. class EntradaBasica3 { public static void main( String args[ ] ) throws IOException { /* Note que antes de la llave de apertura del método main( ), se debe escribir 'throws IOException' para evitar mensajes relacionados con el manejo de errores y que impiden la correcta compilación del programa. */ /* La línea subrayada habilita la entrada de datos desde el teclado. Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar el método readLine( ) de la clase BufferedReader. */ // Usted debe memorizar la siguiente línea: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; String cadena ; // Declara la variable cadena del tipo String (cadena de caracteres) int entero ; // Declara la variable entero del tipo int (número entero) System.out.print( "Digite un numero entero y pulse RETURN: " ) ; cadena = br.readLine( ) ; // Lee el número como una cadena de caracteres, pues //el método readLine( ) lee la información digitada desde el teclado hasta pulsar //la tecla Return (o Enter, o Intro, etc) y la guarda como una cadena de //caracteres (String). entero = Integer.parseInt( cadena ) ;//Convierte de String a entero (int), //pues el método parseInt( String ) de la clase Integer recibe un parámetro //String y lo convierte a su equivalente numérico en formato entero (int). // Muestre en consola el número ingresado, concatenado con un mensaje: System.out.println( "Usted ha digitado el numero entero " + entero ) ; System.exit( 0 ) ; // Salga de la Aplicación } // Fin del método main( ) } // Fin de la clase EntradaBasica3 Salida: // Ejemplo 4 Esta aplicación Java también muestra cómo ingresar un número entero // desde el teclado, pero utiliza menos instrucciones. import java.io.* ; // importa el paquete de entrada - salida básica. class EntradaBasica4 { public static void main( String args[ ] ) throws IOException { Informática I. Versión 1.0 Agosto de 2004 48
- 49. Universidad Autónoma deOccidente /* La línea subrayada habilita la entrada de datos desde el teclado. Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar el método readLine( ) de la clase BufferedReader. */ // Usted debe memorizar la siguiente línea: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; System.out.print( "Digite un numero entero y pulse RETURN: " ) ; int entero = Integer.parseInt( br.readLine( ) ) ; // Notar que podemos usar // directamente el método readLine( ) [ llamado desde el objeto br ] // como argumento del método parseInt de la clase Integer, reduciendo todo a una // sola instrucción. Además, no es necesario la variable auxiliar deltipo String ni // declarar por separado la variable 'entero' del tipo int (entero). // Muestre en consola el número ingresado, concatenado con un mensaje: System.out.println( "Usted ha digitado el numero entero " + entero ) ; System.exit( 0 ) ; // Salga de la Aplicación } // Fin del método main( ) } // Fin de la clase EntradaBasica4 Salida: /* Ejemplo 5 Esta aplicación Java ilustra cómo ingresar más números enteros desde el teclado, los cuales han sido declarados en los otros formatos proporcionados por Java para números enteros. */ import java.io.* ; // importa el paquete de entrada - salida básica. class EntradaBasica5 { public static void main( String args[ ] ) throws IOException { /* La línea subrayada habilita la entrada de datos desde el teclado. Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar el método readLine( ) de la clase BufferedReader. */ // Usted debe memorizar la siguiente línea: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; int i ; long j ; short k ; byte m ; System.out.print( "Digite el primer numero entero y pulse RETURN: " ) ; Informática I. Versión 1.0 Agosto de 2004 49
- 50. Universidad Autónoma deOccidente i = Integer.parseInt( br.readLine( ) ) ; System.out.print( "Digite el segundo numero entero y pulse RETURN: " ) ; j = Long.parseLong( br.readLine( ) ) ; System.out.print( "Digite el tercer numero entero y pulse RETURN: " ) ; k = Short.parseShort( br.readLine( ) ) ; System.out.print( "Digite el cuarto numero entero y pulse RETURN: " ) ; m = Byte.parseByte( br.readLine( ) ) ; // Muestre en consola los números digitados: System.out.println( "Primer numero entero: " + i ) ; System.out.println( "Segundo numero entero: " + j ) ; System.out.println( "Tercer numero entero: " + k ) ; System.out.println( "Cuarto numero entero: " + m ) ; System.exit( 0 ) ; // Salga de la Aplicación } // Fin del método main( ) } // Fin de la clase EntradaBasica5 Salida: // Ejemplo 6 Esta aplicación Java muestra cómo ingresar un número entero // desde el teclado utilizando la clase Integer y su método intValue( ) import java.io.* ; // importa el paquete de entrada - salida básica. class EntradaBasica6 { public static void main( String args[ ] ) throws IOException { /* La línea subrayada habilita la entrada de datos desde el teclado. Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar el método readLine( ) de la clase BufferedReader. */ // Usted debe memorizar la siguiente línea: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; String cadena ; // Declara la variable cadena del tipo String (cadena de caracteres) int entero ; // Declara la variable entero del tipo int (número entero) Informática I. Versión 1.0 Agosto de 2004 50
- 51. Universidad Autónoma deOccidente System.out.print( "Digite un numero entero y pulse RETURN: " ) ; cadena = br.readLine( ) ; // Lee el número como una cadena de caracteres, pues //el método readLine( ) lee la información digitada desde el teclado hasta pulsar //la tecla Return (o Enter, o Intro, etc) y la guarda como una cadena de //caracteres (String). // Crea un objeto, i, de la clase Integer: Integer i = new Integer( cadena ) ; // la cadena String se envía al constructor // Invoca al método intValue( ) de la clase Integer: entero = i.intValue( ) ; // Muestre en consola el número ingresado, concatenado con un mensaje: System.out.println( "Usted ha digitado el numero entero " + entero ) ; System.exit( 0 ) ; // Salga de la Aplicación } // Fin del método main( ) } // Fin de la clase EntradaBasica6 Salida: // Ejemplo 7 Esta aplicación Java muestra cómo ingresar un número entero // desde el teclado utilizando la clase Integer y su método intValue( ) // Se usarán menos instrucciones import java.io.* ; // importa el paquete de entrada - salida básica. class EntradaBasica7 { public static void main( String args[ ] ) throws IOException { /* La línea subrayada habilita la entrada de datos desde el teclado. Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar el método readLine( ) de la clase BufferedReader. */ // Usted debe memorizar la siguiente línea: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; System.out.print( "Digite un numero entero y pulse RETURN: " ) ; // Crea un objeto, i, de la clase Integer: Integer i = new Integer( br.readLine( ) ) ; // la cadena String, retornada // por el método readLine( ) de la clase BufferedReader, se envía directamente al constructor // de la clase Integer int entero = i.intValue( ) ; Informática I. Versión 1.0 Agosto de 2004 51
- 52. Universidad Autónoma deOccidente // Muestre en consola el número ingresado, concatenado con un mensaje: System.out.println( "Usted ha digitado el numero entero " + entero ) ; System.exit( 0 ) ; // Salga de la Aplicación } // Fin del método main( ) } // Fin de la clase EntradaBasica7 Salida: // Ejemplo 8 Esta aplicación Java muestra cómo ingresar números enteros // desde el teclado utilizando las clases Integer, Long, Short y Byte import java.io.* ; // importa el paquete de entrada - salida básica. class EntradaBasica8 { public static void main( String args[ ] ) throws IOException { /* La línea subrayada habilita la entrada de datos desde el teclado. Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar el método readLine( ) de la clase BufferedReader. */ // Usted debe memorizar la siguiente línea: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; System.out.print( "Digite el primer numero entero y pulse RETURN: " ) ; // Crea un objeto, i, de la clase Integer: Integer i = new Integer( br.readLine( ) ) ; // la cadena String, retornada // por el método readLine( ) de la clase BufferedReader, se envía al constructor // de la clase Integer int entero1 = i.intValue( ) ; System.out.print( "Digite el segundo numero entero y pulse RETURN: " ) ; // Crea un objeto, j, de la clase Long: Long j = new Long( br.readLine( ) ) ; // la cadena String, retornada // por el método readLine( ) de la clase BufferedReader, se envía al constructor // de la clase Long long entero2 = j.longValue( ) ; System.out.print( "Digite el tercer numero entero y pulse RETURN: " ) ; // Crea un objeto, k, de la clase Short: Short k = new Short( br.readLine( ) ) ;// la cadena String, retornada // por el método readLine( ) de la clase BufferedReader, se envía al constructor // de la clase Short short entero3 = k.shortValue( ) ; Informática I. Versión 1.0 Agosto de 2004 52
- 53. Universidad Autónoma deOccidente System.out.print( "Digite el cuarto numero entero y pulse RETURN: " ) ; // Crea un objeto, m, de la clase Byte: Byte m = new Byte( br.readLine( ) ) ; // la cadena String, retornada // por el método readLine( ) de la clase BufferedReader, se envía al constructor // de la clase Byte byte entero4 = m.byteValue( ) ; // Muestre en consola los números ingresados: System.out.println( "Primer numero entero: " + entero1 ) ; System.out.println( "Segundo numero entero: " + entero2 ) ; System.out.println( "Tercer numero entero: " + entero3 ) ; System.out.println( "Cuarto numero entero: " + entero4 ) ; System.exit( 0 ) ; // Salga de la Aplicación } // Fin del método main( ) } // Fin de la clase EntradaBasica8 Salida: // Ejemplo 9 Esta aplicación Java muestra cómo ingresar un número real (de punto flotante) // desde el teclado. import java.io.* ; // importa el paquete de entrada - salida básica. class EntradaBasica9 { public static void main( String args[ ] ) throws IOException { /* La línea subrayada habilita la entrada de datos desde el teclado. Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar el método readLine( ) de la clase BufferedReader. */ // Usted debe memorizar la siguiente línea: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; System.out.print( "Digite un numero real y pulse RETURN: " ) ; double real = Double.parseDouble( br.readLine( ) ) ; /* Notar que podemos usar directamente el método readLine( ) [ llamado desde el objeto br ] como argumento del método parseDouble de la clase Double, reduciendo todo a una sola instrucción.*/ Informática I. Versión 1.0 Agosto de 2004 53
- 54. Universidad Autónoma deOccidente // Muestre en consola el número ingresado, concatenado con un mensaje: System.out.println( "Usted ha digitado el numero real " + real ) ; System.exit( 0 ) ; // Salga de la Aplicación } // Fin del método main( ) } // Fin de la clase EntradaBasica9 Salida: // Ejemplo 10 Esta aplicación Java también muestra cómo ingresar un número // real (de punto flotante) desde el teclado. import java.io.* ; // importa el paquete de entrada - salida básica. class EntradaBasica10 { public static void main( String args[ ] ) throws IOException { /* La línea subrayada habilita la entrada de datos desde el teclado. Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar el método readLine( ) de la clase BufferedReader. */ // Usted debe memorizar la siguiente línea: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; System.out.print( "Digite un numero real y pulse RETURN: " ) ; float real = Float.parseFloat( br.readLine( ) ) ; /* Notar que podemos usar directamente el método readLine( ) [ llamado desde el objeto br ] como argumento del método parseFloat de la clase Float, reduciendo todo a una sola instrucción.*/ // Muestre en consola el número ingresado, concatenado con un mensaje: System.out.println( "Usted ha digitado el numero real " + real ) ; System.exit( 0 ) ; // Salga de la Aplicación } // Fin del método main( ) } // Fin de la clase EntradaBasica10 Salida: Informática I. Versión 1.0 Agosto de 2004 54
- 55. Universidad Autónoma deOccidente // Ejemplo 11 Esta aplicación Java muestra cómo ingresar números reales // desde el teclado utilizando las clases Double y Float import java.io.* ; // importa el paquete de entrada - salida básica. class EntradaBasica11 { public static void main( String args[ ] ) throws IOException { /* La línea subrayada habilita la entrada de datos desde el teclado. Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar el método readLine( ) de la clase BufferedReader. */ // Usted debe memorizar la siguiente línea: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; System.out.print( "Digite el primer numero real y pulse RETURN: " ) ; // Crea un objeto, x, de la clase Double: Double x = new Double( br.readLine( ) ) ; // la cadena String, retornada // por el método readLine( ) de la clase BufferedReader, se envía al constructor // de la clase Double double real1 = x.doubleValue( ) ; System.out.print( "Digite el segundo numero real y pulse RETURN: " ) ; // Crea un objeto, y, de la clase Float: Float y = new Float( br.readLine( ) ) ; // la cadena String, retornada // por el método readLine( ) de la clase BufferedReader, se envía al constructor // de la clase Float float real2 = y.floatValue( ) ; // Muestre en consola los números ingresados: System.out.println( "Primer numero real: " + real1 ) ; System.out.println( "Segundo numero real: " + real2 ) ; System.exit( 0 ) ; // Salga de la Aplicación } // Fin del método main( ) } // Fin de la clase EntradaBasica11 Salida: Informática I. Versión 1.0 Agosto de 2004 55
- 56. Universidad Autónoma deOccidente 3.8 Más información sobre Java Java surgió en 1991 cuando un grupo de ingenieros de Sun Microsystems trataron de diseñar un nuevo lenguaje de programación destinado a electrodomésticos. La reducida potencia de cálculo y memoria de los electrodomésticos llevó a desarrollar un lenguaje sencillo capaz de generar código de tamaño muy reducido. Debido a la existencia de distintos tipos de CPUs y a los continuos cambios, era importante conseguir una herramienta independiente del tipo de CPU utilizada. Desarrollaron un código “neutro” que no dependía del tipo de electrodoméstico, el cual se ejecutaba sobre una “máquina hipotética o virtual” denominada Java Virtual Machine (JVM). Era la JVM quien interpretaba el código neutro convirtiéndolo a código particular de la CPU utilizada. Esto permitía lo que luego se ha convertido en el principal lema del lenguaje: “Write Once, Run Everywhere”. A pesar de los esfuerzos realizados por sus creadores, ninguna empresa de electrodomésticos se interesó por el nuevo lenguaje. Como lenguaje de programación para computadores, Java se introdujo a finales de 1995. La clave fue la incorporación de un intérprete Java en la versión 2.0 del programa Netscape Navigator, produciendo una verdadera revolución en Internet. Java 1.1 apareció a principios de 1997, mejorando sustancialmente la primera versión del lenguaje. Java 1.2, más tarde rebautizado como Java 2, nació a finales de 1998. Aunque hoy en día (2004) existe la versión 1.5 de Java, aún se le sigue llamando Java 2. Al programar en Java no se parte de cero. Cualquier aplicación que se desarrolle “cuelga” (o se apoya, según como se quiera ver) en un gran número de clases preexistentes. Algunas de ellas las ha podido hacer el propio usuario, otras pueden ser comerciales, pero siempre hay un número muy importante de clases que forman parte del propio lenguaje (el API o Application Programming Interface de Java). Java incorpora en el propio lenguaje muchos aspectos que en cualquier otro lenguaje son ex tensiones propiedad de empresas de software o fabricantes de computadores (threads, ejecución remota, componentes, seguridad, acceso a bases de datos, etc.). Por eso muchos expertos opinan que Java es el lenguaje ideal para aprender la informática moderna, porque incorpora todos estos conceptos de un modo estándar, mucho más sencillo y claro que con las citadas extensiones de otros lenguajes. Esto es consecuencia de haber sido diseñado más recientemente y por un único equipo. El principal objetivo del lenguaje Java es llegar a ser el “nexo universal” que conecte a los usuarios con la información, esté ésta situada en el computador local, en un servidor de Web, en una base de datos o en cualquier otro lugar. Java es un lenguaje muy completo. En cierta forma casi todo depende de casi todo. Por ello, conviene aprenderlo de modo iterativo: primero una visión muy general, que se va refinando en Informática I. Versión 1.0 Agosto de 2004 56
- 57. Universidad Autónoma deOccidente sucesivas iteraciones. Una forma de hacerlo es empezar con un ejemplo completo en el que ya aparecen algunas de las características más importantes. La compañía Sun describe el lenguaje Java como “simple, orientado a objetos, distribuido, interpretado, robusto, seguro, de arquitectura neutra, portable, de altas prestaciones, multitarea y dinámico”. Además de una serie de halagos por parte de Sun hacia su propia criatura, el hecho es que todo ello describe bastante bien el lenguaje Java, aunque en algunas de esas características el lenguaje sea todavía bastante mejorable. Algunas de las anteriores ideas se irán explicando a lo largo de este manual. 3.8.1 QUÉ ES JAVA 2 Java 2 (antes llamado Java 1.2 o JDK 1.2) se le llama tambien a las últimas versiones (Java 1.3, Java 1.4 y Java 1.5) del lenguaje de programación Java. Los programas desarrollados en Java presentan diversas ventajas frente a los desarrollados en otros lenguajes como C/C++. La ejecución de programas en Java tiene muchas posibilidades: ejecución como aplicación independiente (Stand-alone Application), ejecución como applet, ejecución como servlet, etc. Un applet es una aplicación especial que se ejecuta dentro de un navegador o browser (por ejemplo Netscape Navigator o Internet Explorer) al cargar una página HTML desde un servidor Web. El applet se descarga desde el servidor y no requiere instalación en el computador donde se encuentra el browser. Un servlet es una aplicación sin interface gráfica que se ejecuta en un servidor de Internet. La ejecución como aplicación independiente es análoga a los programas desarrollados con otros lenguajes. Además de incorporar la ejecución como Applet, Java permite fácilmente el desarrollo tanto de arquitecturas cliente-servidor como de aplicaciones distribuidas, consistentes en crear aplicaciones capaces de conectarse a otros computadores y ejecutar tareas en varios computadores simultáneamente, repartiendo por lo tanto el trabajo. Aunque también otros lenguajes de programación permiten crear aplicaciones de este tipo, Java incorpora en su propio API estas funcionalidades. 3.8.2 EL ENTORNO DE DESARROLLO DE JAVA Existen distintos programas comerciales que permiten desarrollar código Java. La compañía Sun, creadora de Java, distribuye gratuitamente el Java(tm) Development Kit (JDK). Se trata de un conjunto de programas y librerías que permiten desarrollar, compilar y ejecutar programas en Java. Incorpora además la posibilidad de ejecutar parcialmente el programa, deteniendo la ejecución en el punto deseado y estudiando en cada momento el valor de cada una de las variables (con el denominado Debugger). Cualquier programador con un mínimo de experiencia sabe que una parte muy importante (muchas veces la mayor parte) del tiempo destinado a la elaboración de un programa se destina a la detección y corrección de errores. Existe también una versión reducida del JDK, denominada JRE (Java Runtime Environment) destinada únicamente a ejecutar código Java (no permite compilar). Los IDEs (Integrated Development Environment), tal y como su nombre indica, son entornos de desarrollo integrados. En un mismo programa es posible escribir el código Java, compilarlo y ejecutarlo sin tener que cambiar de aplicación. Algunos incluyen una herramienta para realizar Debug gráficamente, frente a la versión que incorpora el JDK basada en la utilización de una consola (denominada habitualmente ventana de comandos de MS-DOS, en Windows NT/95/98) bastante difícil y pesada de utilizar. Estos entornos integrados permiten desarrollar las aplicaciones de forma mucho más rápida, incorporando en muchos casos librerías con componentes ya desarrollados, los Informática I. Versión 1.0 Agosto de 2004 57
- 58. Universidad Autónoma deOccidente cuales se incorporan al proyecto o programa. Como inconvenientes se pueden señalar algunos fallos de compatibilidad entre plataformas, y archivos resultantes de mayor tamaño que los basados en clases estándar. 3.8.3 El compilador de Java Se trata de una de las herramientas de desarrollo incluidas en el JDK. Realiza un análisis de sintaxis del código escrito en los archivos fuente de Java (con extensión *.java). Si no encuentra errores en el código genera los archivos compilados (con ex tensión *.class). En otro caso muestra la línea o líneas erróneas. En el JDK de Sun dicho compilador se llama javac.exe. Tiene numerosas opciones, algunas de las cuales varían de una versión a otra. Se aconseja consultar la documentación de la versión del JDK utilizada para obtener una información detallada de las distintas posibilidades. 3.8.4 La Java Virtual Machine (JVM) Tal y como se ha comentado al comienzo del capítulo, la existencia de distintos tipos de procesadores y computadores llevó a los ingenieros de Sun a la conclusión de que era muy importante conseguir un software que no dependiera del tipo de procesador utilizado. Se planteó la necesidad de conseguir un código capaz de ejecutarse en cualquier tipo de máquina. Una vez compilado no debería ser necesaria ninguna modificación por el hecho de cambiar de procesador o de ejecutarlo en otra máquina. La clave consistió en desarrollar un código “neutro” el cual estuviera preparado para ser ejecutado sobre una “máquina hipotética o virtual”, denominada Java Virtual Machine (JVM). Es esta JVM quien interpreta este código neutro convirtiéndolo a código particular de la CPU utilizada. Se evita tener que realizar un programa diferente para cada CPU o plataforma. La JVM es el intérprete de Java. Ejecuta los “bytecodes” (archivos compilados con extensión *.class) creados por el compilador de Java (javac.exe). Tiene numerosas opciones entre las que destaca la posibilidad de utilizar el denominado JIT (Just-In-Time Compiler), que puede mejorar entre 10 y 20 veces la velocidad de ejecución de un programa. 3.8.5 Las variables PATH y CLASSPATH El desarrollo y ejecución de aplicaciones en Java exige que las herramientas para compilar (javac.exe) y ejecutar (java.exe) se encuentren accesibles. El computador, desde una ventana de comandos de MS-DOS, sólo es capaz de ejecutar los programas que se encuentran en los directorios indicados en la variable PATH del computador (o en el directorio activo). Si se desea compilar o ejecutar código en Java, el directorio donde se encuentran estos programas (java.exe y javac.exe) deberá encontrarse en el PATH. Tecleando PATH en una ventana de comandos de MS-DOS se muestran los nombres de directorios incluidos en dicha variable de entorno. Java utiliza además una nueva variable de entorno denominada CLASSPATH, la cual determina dónde buscar tanto las clases o librerías de Java (el API de Java) como otras clases de usuario. A partir de la versión 1.1.4 del JDK no es necesario indicar esta variable, salvo que se desee añadir conjuntos de clases de usuario que no vengan con dicho JDK. La variable CLASSPATH puede incluir la ruta de directorios o archivos *.zip o *.jar en los que se encuentren los archivos *.class. En el caso de los archivos *.zip hay que observar que los archivos en él incluidos no deben estar comprimidos. En el caso de archivos *.jar existe una herramienta (jar.exe), incorporada en el JDK, que permite generar estos archivos a partir de los archivos compilados *.class. Los archivos *.jar son archivos comprimidos y por lo tanto ocupan menos espacio que los archivos *.class por separado o que el archivo *.zip equivalente. Una forma general de indicar estas dos variables es crear un archivo batch de MS-DOS (*.bat) donde se indiquen los valores de dichas variables. Cada vez que se abra una ventana de MS-DOS será Informática I. Versión 1.0 Agosto de 2004 58
- 59. Universidad Autónoma deOccidente necesario ejecutar este archivo *.bat para asignar adecuadamente estos valores. Un posible archivo llamado jdk117.bat, podría ser como sigue: set JAVAPATH=C:j2sdk1.4.1_01 set PATH=.;%JAVAPATH%bin;%PATH% set CLASSPATH=.;%JAVAPATH%libclasses.zip;%CLASSPATH% lo cual sería válido en el caso de que el JDK estuviera situado en el directorio C:jdk1.1.7. Si no se desea tener que ejecutar este archivo cada vez que se abre una consola de MS-DOS es necesario indicar estos cambios de forma “permanente”. La forma de hacerlo difiere entre Windows 95/98 y Windows NT. En Windows 95/98 es necesario modificar el archivo Autoexec.bat situado en C:, añadiendo las líneas antes mencionadas. Una vez rearrancado el computador estarán presentes en cualquier consola de MS-DOS que se cree. La modificación al archivo Autoexec.bat enWindows 95/98 será la siguiente: set JAVAPATH=C: j2sdk1.4.1_01 set PATH=.;%JAVAPATH%bin;%PATH% set CLASSPATH= donde en la tercera línea debe incluir la ruta de los archivos donde están las clases de Java. En el caso de utilizar Windows NT se añadirá la variable PATH en el cuadro de diálogo que se abre con Start - > Settings -> Control Panel -> System -> Environment -> User Variables for NombreUsuario. También es posible utilizar la opción –classpath en el momento de llamar al compilador javac.exe o al intérprete java.exe. En este caso los archivos *.jar deben ponerse con el nombre completo en el CLASSPATH: no basta poner el PATH o directorio en el que se encuentra. Por ejemplo, si se desea compilar y ejecutar el archivo ContieneMain.java, y éste necesitara la librería de clases G:MyProjectOtherClasses.jar, además de las incluidas en el CLASSPATH, la forma de compilar y ejecutar sería: javac -classpath .;G:MyProjectOtherClasses.jar ContieneMain.java java -classpath .;G:MyProjectOtherClasses.jar ContieneMain Se aconseja consultar la ayuda correspondiente a la versión que se esté utilizando, debido a que ex isten pequeñas variaciones entre las distintas versiones del JDK. Cuando un archivo filename.java se compila y en ese directorio existe ya un archivo filename.class, se comparan las fechas de los dos archivos. Si el archivo filename.java es más antiguo que el filename.class no se produce un nuevo archivo filename.class. Esto sólo es válido para archivos *.class que se corresponden con una clase public. 3.8.6 NOMENCLATURA HABITUAL EN LA PROGRAMACIÓN EN JAVA Los nombres de Java son sensibles a las letras mayúsculas y minúsculas. Así, las variables masa, Masa y MASA son consideradas variables completamente diferentes. Las reglas del lenguaje respecto a los nombres de variables son muy amplias y permiten mucha libertad al programador, pero es habitual seguir ciertas normas que facilitan la lectura y el mantenimiento de los programas de computador. Se recomienda seguir las siguientes instrucciones: 1. En Java es habitual utilizar nombres con minúsculas, con las excepciones que se indican en los puntos siguientes. Informática I. Versión 1.0 Agosto de 2004 59
- 60. Universidad Autónoma deOccidente 2. Cuando un nombre consta de varias palabras es habitual poner una a continuación de otra, poniendo con mayúscula la primera letra de la palabra que sigue a otra (Ejemplos: elMayor(), VentanaCerrable, RectanguloGrafico, addWindowListener()). 3. Los nombres de clases e interfaces comienzan siempre por mayúscula (Ejemplos: Geometria, Rectangulo, Dibujable, Graphics, ArrayList, Iterator). 4. Los nombres de objetos, los nombres de métodos y variables miembro, y los nombres de las variables locales de los métodos, comienzan siempre por minúscula (Ejemplos: main(), dibujar(), numRectangulos, x, y, r). 5. Los nombres de las variables finales, es decir de las constantes, se definen siempre con mayúsculas (Ejemplo: PI) 3.8.7 ESTRUCTURA GENERAL DE UN PROGRAMA JAVA El anterior ejemplo presenta la estructura habitual de un programa realizado en cualquier lenguaje orientado a objetos u OOP (Object Oriented Programming), y en particular en el lenguaje Java. Aparece una clase que contiene el programa principal (aquel que contiene la función main()) y algunas clases de usuario (las específicas de la aplicación que se está desarrollando) que son utilizadas por el programa principal. Los archivos fuente tienen la extensión *.java, mientras que los archivos compilados tienen la extensión *.class. Un archivo fuente (*.java) puede contener más de una clase, pero sólo una puede ser public. El nombre del archivo fuente debe coincidir con el de la clase public (con la ex tensión *.java). Si por ejemplo en un archivo aparece la declaración (public class MiClase {...}) entonces el nombre del archivo deberá ser MiClase.java. Es importante que coincidan mayúsculas y minúsculas ya que MiClase.java y miclase.java serían clases diferentes para Java. Si la clase no es public, no es necesario que su nombre coincida con el del archivo. Una clase puede ser public o package (default), pero no private o protected. Estos conceptos se explican posteriormente. De ordinario una aplicación está constituida por varios archivos *.class. Cada clase realiza unas funciones particulares, permitiendo construir las aplicaciones con gran modularidad e independencia entre clases. La aplicación se ejecuta por medio del nombre de la clase que contiene la función main() (sin la extensión *.class). Las clases de Java se agrupan en packages, que son librerías de clases. Si las clases no se definen como pertenecientes a un package, se utiliza un package por defecto (default) que es el directorio activo. Los packages se estudian con más detenimiento en próximos capitulos. Informática I. Versión 1.0 Agosto de 2004 60
- 61. Universidad Autónoma deOccidente UNIDAD 4. TIPOS DE DATOS, VARIABLES Y OPERADORES. 4. PROGRAMACIÓN EN JAVA En este capítulo se presentan las características generales de Java como lenguaje de programación algorítmico. En este apartado Java es muy similar a C/C++, lenguajes en los que está inspirado. 4.1 VARIABLES Una variable es un nombre que contiene un valor que puede cambiar a lo largo del programa. De acuerdo con el tipo de información que contienen, en Java hay dos tipos principales de variables: 1. Variables de tipos primitivos. Están definidas mediante un valor único que puede ser entero, de punto flotante, carácter o booleano. Java permite distinta precición y distintos rangos de valores para estos tipos de variables (char, byte, short, int, long, float, double, boolean). Ejemplos de variables de tipos primitivos podrían ser: 123, 3456754, 3.1415, 12e-09, 'A', true, etc. 2. Variables referencia. Las variables referencia son referencias o nombres de una información más compleja: arrays u objetos de una determinada clase. Desde el punto de vista del papel o misión en el programa, las variables pueden ser: 1. Variables miembro de una clase: Se definen en una clase, fuera de cualquier método; pueden ser tipos primitivos o referencias. 2. Variables locales: Se definen dentro de un método o más en general dentro de cualquier bloque entre llaves {}. Se crean en el interior del bloque y se destruyen al finalizar dicho bloque. Pueden ser también tipos primitivos o referencias. 4.1.1 Nombres de Variables Los nombres de variables en Java se pueden crear con mucha libertad. Pueden ser cualquier conjunto de caracteres numéricos y alfanuméricos, sin algunos caracteres especiales utilizados por Java como operadores o separadores ( ,.+-*/ etc.). Existe una serie de palabras reservadas las cuales tienen un significado especial para Java y por lo tanto no se pueden utilizar como nombres de variables. Dichas palabras son: abstract boolean break byte case catch char class const* continue default do double else extends final finally float for goto* if implements import instanceof int interface long native new null package private protected public return short static super switch synchronized this throw throws transient try void volatile while (*) son palabras reservadas, pero no se utilizan en la actual implementación del lenguaje Java. Informática I. Versión 1.0 Agosto de 2004 61
- 62. Universidad Autónoma deOccidente 4.1.2 Tipos Primitivos de Variables Se llaman tipos primitivos de variables de Java a aquellas variables sencillas que contienen los tipos de información más habituales: valores boolean, caracteres y valores numéricos enteros o de punto flotante. Java dispone de ocho tipos primitivos de variables: un tipo para almacenar valores true y false (boolean); un tipo para almacenar caracteres (char), y 6 tipos para guardar valores numéricos, cuatro tipos para enteros (byte, short, int y long) y dos para valores reales de punto flotante (float y double). Los rangos y la memoria que ocupa cada uno de estos tipos se muestran en la Tabla 4.1. Tipo de variable Descripción Boolean 1 byte. Valores true y false Char 2 bytes. Unicode. Comprende el código ASCII Byte 1 byte. Valor entero entre -128 y 127 Short 2 bytes. Valor entero entre -32768 y 32767 Int 4 bytes. Valor entero entre -2.147.483.648 y 2.147.483.647 Long 8 bytes. Valor entre -9.223.372.036.854.775.808 y 9.223.372.036.854.775.807 Float 4 bytes (entre 6 y 7 cifras decimales equivalentes). De -3.402823E38 a -1.401298E-45 y de 1.401298E-45 a 3.402823E38 Double 8 bytes (unas 15 cifras decimales equivalentes). De -1.79769313486232E308 a -4.94065645841247E-324 y de 4.94065645841247E-324 a 1.79769313486232E308 Tabla 4.1. Tipos primitivos de variables en Java. Los tipos primitivos de Java tienen algunas características importantes que se resumen a continuación: 1. El tipo boolean no es un valor numérico: sólo admite los valores true o false. El tipo boolean no se identifica con el igual o distinto de cero, como en C/C++. El resultado de la ex presión lógica que aparece como condición en un bucle o en una Decisión debe ser boolean. 2. El tipo char contiene caracteres en código UNICODE (que incluye el código ASCII), y ocupan 16 bits por carácter. Comprende los caracteres de prácticamente todos los idiomas. 3. Los tipos byte, short, int y long son números enteros que pueden ser positivos o negativos, con distintos valores máximos y mínimos. A diferencia de C/C++, en Java no hay enteros unsigned. 4. Los tipos float y double son valores de punto flotante (números reales) con 6-7 y 15 cifras decimales equivalentes, respectivamente. 5. Se utiliza la palabra void para indicar la ausencia de un tipo de variable determinado. 6. A diferencia de C/C++, los tipos de variables en Java están perfectamente definidos en todas y cada una de las posibles plataformas. Por ejemplo, un int ocupa siempre la misma memoria y tiene el mismo rango de valores, en cualquier tipo de computador. 7. Existen extensiones de Java 1.2 para aprovechar la arquitectura de los procesadores Intel, que permiten realizar operaciones de punto flotente con una precisión extendida de 80 bits. 4.1.3 Cómo se definen e inicializan las variables Una variable se define especificando el tipo y el nombre de dicha variable. Estas variables pueden ser tanto de tipos primitivos como referencias a objetos de alguna clase perteneciente al API de Java o generada por el usuario. Si no se especifica un valor en su declaración, las variables Informática I. Versión 1.0 Agosto de 2004. 62
- 63. Universidad Autónoma deOccidente primitivas se inicializan a cero (salvo boolean y char, que se inicializan a false y '0'). Análogamente las variables de tipo referencia son inicializadas por defecto a un valor especial: null. Es importante distinguir entre la referencia a un objeto y el objeto mismo. Una referencia es una variable que indica dónde está guardado un objeto en la memoria del computador (a diferencia de C/C++, Java no permite acceder al valor de la dirección, pues en este lenguaje se han eliminado los punteros). Al declarar una referencia todavía no se encuentra “apuntando” a ningún objeto en particular (salvo que se cree explícitamente un nuevo objeto en la declaración), y por eso se le asigna el valor null. Si se desea que esta referencia apunte a un nuevo objeto es necesario crear el objeto utilizando el operador new. Este operador reserva en la memoria del computador espacio para ese objeto (variables y funciones). También es posible igualar la referencia declarada a otra referencia a un objeto existente previamente. Un tipo particular de referencias son los arrays o vectores, sean éstos de variables primitivas (por ejemplo, un vector de enteros) o de objetos. En la declaración de una referencia de tipo array hay que incluir los corchetes [ ]. En los siguientes ejemplos aparece cómo crear un vector de 10 números enteros y cómo crear un vector de elementos MyClass. Java garantiza que los elementos del vector son inicializados a null o a cero (según el tipo de dato) en caso de no indicar otro valor. Ejemplos de declaración e inicialización de variables: int x; // Declaración de la variable primitiva x. Se inicializa a 0 inty=5; //Declaración de la variable primitiva y. Se inicializa a 5 MyClass unaRef; // Declaración de una referencia a un objeto MyClass. // Se inicializa a null unaRef = new MyClass(); // La referencia “apunta” al nuevo objeto creado // Se ha utilizado el constructor por defecto MyClass segundaRef = unaRef; // Declaración de una referencia a un objeto MyClass. // Se inicializa al mismo valor que unaRef int [ ] vector; // Declaración de un array. Se inicializa a null vector = new int[10]; // Vector de 10 enteros, inicializados a 0 double [ ] v = {1.0, 2.65, 3.1}; // Declaración e inicialización de un vector de 3 // elementos con los valores entre llaves MyClass [ ] lista=new MyClass[5]; // Se crea un vector de 5 referencias a objetos // Las 5 referencias son inicializadas a null lista[0] = unaRef; // Se asigna a lista[0] el mismo valor que unaRef lista[1] = new MyClass(); // Se asigna a lista[1] la referencia al nuevo objeto // El resto (lista[2]…lista[4] siguen con valor null En el ejemplo mostrado las referencias unaRef, segundaRef y lista[0] actuarán sobre el mismo objeto. Es equivalente utilizar cualquiera de las referencias ya que el objeto al que se refieren es el mismo. 4.1.4 Visibilidad y vida de las variables Se entiende por visibilidad, ámbito o scope de una variable, la parte de la aplicación donde dicha variable es accesible y por lo tanto puede ser utilizada en una expresión. En Java todas las variables deben estar incluidas en una clase. En general las variables declaradas dentro de unas llaves {}, es decir dentro de un bloque, son visibles y existen dentro de estas llaves. Por ejemplo las variables declaradas al principio de una función existen mientras se ejecute la función; las variables declaradas dentro de un bloque if no serán válidas al finalizar las sentencias correspondientes a dicho if y las variables miembro de una clase (es decir declaradas entre las llaves {} de la clase pero fuera de cualquier método) son válidas mientras existe el objeto de la clase. Informática I. Versión 1.0 Agosto de 2004. 63
- 64. Universidad Autónoma deOccidente Las variables miembro de una clase declaradas como public son accesibles a través de una referencia a un objeto de dicha clase utilizando el operador punto (.). Las variables miembro declaradas como private no son accesibles directamente desde otras clases. Las funciones miembro de una clase tienen acceso directo a todas las variables miembro de la clase sin necesidad de anteponer el nombre de un objeto de la clase. Sin embargo las funciones miembro de una clase B derivada de otra A, tienen acceso a todas las variables miembro de A declaradas como public o protected, pero no a las declaradas como private. Una clase derivada sólo puede acceder directamente a las variables y funciones miembro de su clase base declaradas como public o protected. Otra característica del lenguaje es que es posible declarar una variable dentro de un bloque con el mismo nombre que una variable miembro, pero no con el nombre de otra variable local que ya existiera. La variable declarada dentro del bloque oculta a la variable miembro en ese bloque. Para acceder a la variable miembro oculta será preciso utilizar el operador this, en la forma this.varname. Uno de los aspectos más importantes en la programación orientada a objetos (OOP) es la forma en la cual son creados y eliminados los objetos. En Java la forma de crear nuevos objetos es utilizando el operador new. Cuando se utiliza el operador new, la variable de tipo referencia guarda la posición de memoria donde está almacenado este nuevo objeto. Para cada objeto se lleva cuenta de por uántas variables de tipo referencia es apuntado. La eliminación de los objetos la realiza el programa denominado garbage collector, quien automáticamente libera o borra la memoria ocupada por un objeto cuando no existe ninguna referencia apuntando a ese objeto. Lo anterior significa que aunque una variable de tipo referencia deje de existir, el objeto al cual apunta no es eliminado si hay otras referencias apuntando a ese mismo objeto. 4.1.5 Casos especiales: Clases BigInteger y BigDecimal Java 1.1 incorporó dos nuevas clases destinadas a operaciones aritméticas que requieran gran precisión: BigInteger y BigDecimal. La forma de operar con objetos de estas clases difiere de las operaciones con variables primitivas. En este caso hay que realizar las operaciones utilizando métodos propios de estas clases (add() para la suma, subtract() para la resta, divide() para la división, etc.). Se puede consultar la ayuda sobre el package java.math, donde aparecen ambas clases con todos sus métodos. Los objetos de tipo BigInteger son capaces de almacenar cualquier número entero sin perder información durante las operaciones. Análogamente los objetos de tipo BigDecimal permiten trabajar con el número de decimales deseado. 4.2 OPERADORES DE JAVA Java es un lenguaje rico en operadores, que son casi idénticos a los de C/C++. Estos operadores se describen brevemente en los apartados siguientes. 4.2.1 Operadores aritméticos Son operadores binarios (requieren siempre dos operandos) que realizan las operaciones aritméticas habituales: suma (+), resta (-), multiplicación (*), división (/) y resto de la división (%). Informática I. Versión 1.0 Agosto de 2004. 64
- 65. Universidad Autónoma deOccidente 4.2.2 Operadores de asignación Los operadores de asignación permiten asignar Operador Utilización Expresión equivalente un valor a una variable. El operador de += op1 + = op2 op1 = op1 + op2 asignación por excelencia es el operador igual -= op1 -= op2 op1 = op1 - op2 (=). La forma general de las sentencias de *= op1 *= op2 op1 = op1 * op2 asignación con este operador es: /= op1 /= op2 op1 = op1 / op2 %= op1 %= op2 op1 = op1 % op2 variable = expression; Tabla 4.2. Otros operadores de asignación. Java dispone de otros operadores de asignación. Se trata de versiones abreviadas del operador (=) que realizan operaciones “acumulativas” sobre una variable. La Tabla 4.2 muestra estos operadores y su equivalencia con el uso del operador igual (=). 4.2.3 Operadores unarios Los operadores más (+) y menos (-) unarios sirven para mantener o cambiar el signo de una variable, constante o expresión numérica. Su uso en Java es el estándar de estos operadores. 4.2.4 Operador instanceof El operador instanceof permite saber si un objeto pertenece o no a una determinada clase. Es un operador binario cuya forma general es, objectName instanceof ClassName y que devuelve true o false según el objeto pertenezca o no a la clase. 4.2.5 Operador condicional ?: Este operador, tomado de C/C++, permite realizar decisiones condicionales sencillas. Su forma general es la siguiente: booleanExpression ? res1 : res2 donde se evalúa booleanExpression y se devuelve res1 si el resultado es true y res2 si el resultado es false. Es el único operador ternario (tres argumentos) de Java. Como todo operador que devuelve un valor puede ser utilizado en una expresión. Por ejemplo las sentencias: x=1 ; y=10; z = (x<y)?x+3:y+8; asignarían a z el valor 4, es decir x+3. 4.2.6 Operadores incrementales Java dispone del operador incremento (++) y decremento (--). El operador (++) incrementa en una unidad la variable a la que se aplica, mientras que (--) la reduce en una unidad. Estos operadores se pueden utilizar de dos formas: 1. Precediendo a la variable (por ejemplo: ++i). En este caso primero se incrementa la variable y luego se utiliza (ya incrementada) en la expresión en la que aparece. 2. Siguiendo a la variable (por ejemplo: i++). En este caso primero se utiliza la variable en la expresión (con el valor anterior) y luego se incrementa. En muchas ocasiones estos operadores se utilizan para incrementar una variable fuera de una expresión. En este caso ambos operadores son equivalente. Si se utilizan en una expresión más Informática I. Versión 1.0 Agosto de 2004. 65
- 66. Universidad Autónoma deOccidente complicada, el resultado de utilizar estos operadores en una u otra de sus formas será diferente. La actualización de contadores en bucles for es una de las aplicaciones más frecuentes de estos operadores. 4.2.7 Operadores relacionales Los operadores relacionales sirven para Operador Utilización El resultado es true realizar comparaciones de igualdad, > op1 > op2 si op1 es mayor que op2 desigualdad y relación de menor o mayor. >= op1 >= op2 si op1 es mayor o igual que op2 El resultado de estos operadores es < op1 < op2 si op1 es menor que op2 siempre un valor boolean (true o false) <= op1 <= op2 si op1 es menor o igual que op2 según se cumpla o no la relación == op1 == op2 si op1 y op2 son iguales considerada. La Tabla 4.3 muestra los != op1 != op2 si op1 y op2 son diferentes operadores relacionales de Java. Tabla 4.3. Operadores relacionales. Estos operadores se utilizan con mucha frecuencia en las decisiones y en los bucles, que se verán en próximos apartados de este capítulo. 4.2.8 Operadores lógicos Los operadores lógicos se utilizan para construir expresiones lógicas, combinando valores lógicos (true y/o false) o los resultados de los operadores relacionales. La Tabla 4.4 muestra los operadores lógicos de Java. Debe notarse que en ciertos casos el segundo operando no se evalúa porque ya no es necesario (si ambos tienen que ser true y el primero es false, ya se sabe que la condición de que ambos sean true no se va a cumplir). Esto puede traer resultados no deseados y por eso se han añadido los operadores (&) y (|) que garantizan que los dos operandos se evalúan siempre. Operador Nombre Utilización Resultado && AND op1 && op2 true si op1 y op2 son true. Si op1 es false ya no se evalúa op2 || OR op1 || op2 true si op1 u op2 son true. Si op1 es true ya no se evalúa op2 ! negación ! op true si op es false y false si op es true & AND op1 & op2 true si op1 y op2 son true. Siempre se evalúa op2 | OR op1 | op2 true si op1 u op2 son true. Siempre se evalúa op2 Tabla 4.4. Operadores lógicos. 4.2.9 Operador de concatenación de cadenas de caracteres (+) El operador más (+) se utiliza también para concatenar cadenas de caracteres. Por ejemplo, para escribir una cantidad con un rótulo y unas unidades puede utilizarse la sentencia: System.out.println("El total asciendea"+result + " unidades"); donde el operador de concatenación se utiliza dos veces para construir la cadena de caracteres que se desea imprimir por medio del método println(). La variable numérica result es convertida automáticamente por Java en cadena de caracteres para poderla concatenar. En otras ocasiones se deberá llamar explícitamente a un método para que realice esta conversión. Informática I. Versión 1.0 Agosto de 2004. 66
- 67. Universidad Autónoma deOccidente 4.2.10 Operadores que actúan a nivel de bits Java dispone también de un conjunto de operadores que actúan a nivel de bits. Las Operaciones de bits se utilizan con frecuencia para definir señales o flags, esto es, variables de tipo entero en las quecada uno de sus bits indican si una opción está activada o no. La Tabla 4.5 muestra los operadores de Java que actúan a nivel de bits. Operador Utilización Resultado >> op1 >> op2 Desplaza los bits de op1 a la derecha una distancia op2 << op1 << op2 Desplaza los bits de op1 a la izquierda una distancia op2 >>> op1 >>> op2 Desplaza los bits de op1 a la derecha una distancia op2 (positiva) & op1 & op2 Operador AND a nivel de bits | op1 | op2 Operador OR a nivel de bits ^ op1 ^ op2 Operador XOR a nivel de bits (1 si sólo uno de los operandos es 1) ~ ~op2 Operador complemento (invierte el valor de cada bit) Tabla 4.5. Operadores a nivel de bits. En binario, las potencias de dos se representan con un único bit activado. Por ejemplo, los números (1, 2, 4, 8, 16, 32, 64, 128) se representan respectivamente de modo binario en la forma (00000001, 00000010, 00000100, 00001000, 00010000, 00100000, 01000000, 10000000), utilizando sólo 8 bits. La suma de estos números permite construir una variable flags con los bits activados que se deseen. Por ejemplo, para construir una variable flags que sea 00010010 bastaría hacer flags=2+16. Para saber si el segundo bit por la derecha está o no activado bastaría utilizar la sentencia, if (flags&2==2){...} La Tabla 4.6 muestra los operadores de asignación a nivel de bits. Operador Utilización Equivalente a &= op1 &= op2 op1 = op1 & op2 |= op1 |= op2 op1 = op1 | op2 ^= op1 ^= op2 op1 = op1 ^ op2 <<= op1 <<= op2 op1 = op1 << op2 >>= op1 >>= op2 op1 = op1 >> op2 >>>= op1 >>>= op2 op1 = op1 >>> op2 Tabla 4.6. Operadores de asignación a nivel de bits. 4.2.11 Precedencia de operadores El orden en que se realizan las operaciones es fundamental para determinar el resultado de una expresión. Por ejemplo, el resultado de x/y*z depende de qué operación (la división o el producto) se realice primero. La siguiente lista muestra el orden en que se ejecutan los distintos operadores en un sentencia, de mayor a menor precedencia: postfix operators [ ] . (params) expr++ expr-- unary operators ++expr --expr +expr -expr ~ ! creation or cast new (type)expr multiplicative */% additive +- shift << >> >>> Informática I. Versión 1.0 Agosto de 2004. 67
- 68. Universidad Autónoma deOccidente relational < > <= >= instanceof equality == != bitwise AND & bitwise exclusive OR ^ bitwise inclusive OR | logical AND && logical OR || conditional ?: assignment = += -= *= /= %= &= ^= |= <<= >>= >>>= En Java, todos los operadores binarios, excepto los operadores de asignación, se evalúan de izquierda a derecha. Los operadores de asignación se evalúan de derecha a izquierda, lo que significa que el valor de la derecha se copia sobre la variable de la izquierda. Informática I. Versión 1.0 Agosto de 2004. 68
- 69. Universidad Autónoma deOccidente UNIDAD 5. ALGORITMOS Este capítulo trata de ser una introducción a la metodología y tecnología de la programación, con el objetivo de proporcionar al lector los procedimientos y técnicas para el desarrollo de programas. Por obvio que parezca, no hay que olvidar que los programas se escriben con el ánimo de resolver problemas con ayuda de las computadoras y que la primera medida a considerar es el análisis del problema en cuestión y la obtención, en su caso, de un algoritmo adecuado. Por tanto, empezaremos nuestra exposición hasta llegar a los métodos y etapas a seguir para obtener una aplicación informática. Si bien los conceptos que aquí se introducen son fundamentales para la realización de programas, este capítulo no debe leerse como si se tratara de un manual de programación, sino como una fundamentación de lo que llamamos programación estructurada, más allá de la sintaxis y de la semántica de un lenguaje de programación concreto. No obstante lo anterior, es sano en este momento informarle que se le irà familiarizando con un lenguaje especìfico: el lenguaje de programación Java. O sea, irá conociendo su sintaxis. Esto debe ser así, pues una de las cosas que más estimula a un estudiante que se inicia en la informática es ver cómo sus programas funcionan al ser ejecutados en una computadora y, para lograrlo, se necesita de un lenguaje de programación. Concepto de Algoritmo Definición de algoritmo. Etimología del término algoritmo En general, Un algoritmo es una secuencia de instrucciones o pasos que es llevada a cabo de forma mecánica y sistemática por un actor que se desenvuelve en un ambiente o entorno dado, para resolver un problema determinado en un tiempo finito. Esa es una definición válida de algoritmo, otra posible definición es la siguiente: Un algoritmo es un conjunto de instrucciones combinadas de forma adecuada para resolver un determinado problema en una cantidad finita de tiempo. Cada instrucción es una indicación sencilla y no ambigua. Despues de los siguientes ejemplos, el alumno debería tener bastante claro qué es un algoritmo, en qué consiste y dar ejemplos de algoritmos; ahora es probable que se esté preguntando de dónde procede el mismo término, “ALGORITMO”, ¿por qué denominamos “algoritmos” a los algoritmos y no “recetas” o “combinaciones de indicaciones sencillas y no ambiguas...”? El término proviene de Mahommed ibn Musa al-Khowârizmî (Mahommed, hijo de Musa, natural de Kharizm), matemático persa del siglo IX; las matemáticas le deben la introducción del sistema de numeración actual y del álgebra. En su libro De numero indiorum (Sobre los números hindúes) proporciona las reglas para realizar las operaciones aritméticas (con los nuevos números, por supuesto), dichas reglas se denominaron “reglas de al-Khowârizmî” y, por deformación “algoritmos”, haciéndose extensivo el término a cualquier conjunto de reglas para resolver un problema determinado. Resolución de Problemas y el Uso del Computador Informática I. Versión 1.0 Agosto de 2004. 69
- 70. Universidad Autónoma deOccidente Antes de entrar en la codificación para la resolución de un problema por técnicas informáticas, hemos de contar con una idea bastante precisa de cómo podemos llegar a esta solución. Resolución de un problema Análisis del Diseño del Programación problema algoritmo del algoritmo Fig. 5.1. La resolución de un problema en Informática El matemático G. Poyla propuso, a finales de 1940, una metodología general para la resolución de problemas matemáticos, que ha sido adaptada para el caso en que se cuente con un computador como recurso. Esta metodología, de forma muy esquematizada, se puede dividir en tres fases (Ver Figura 3.1): 1. Análisis del problema 2. Diseño del algoritmo 3. Programación del algoritmo Análisis del problema El objetivo del análisis del problema, es ayudar al programador a llegar a una cierta comprensión de la naturaleza del mismo. Este análisis supone, en particular, la superación de una serie de pasos (Ver Figura 3.2): - Definir el problema con total precisión. - Especificar los datos de partida necesarios para la resolución del mismo (especificaciones de entrada). - Especificar la información que debe proporcionarse al resolverse (especificaciones de salida). - Análisis del problema Definición Especificiones Especificacion del problema de entrada es de salida Fig. 5.2. Análisis del problema Ejemplo : Elaborar el análisis general que responda a la pregunta: ¿Qué debo hacer para ver la película XYZ?. 1. Ir al cine donde proyectan MatriX 2. Comprar una entrada. 3. Ver la película. 4. Regresar a casa. Ejemplo : Elaborar el análisis para obtener el área y la longitud de una circunferencia. 1. Utilizar las fórmulas del área y la circunferencia en función del radio. 2. Las entradas de datos se reducen al dato correspondiente al radio del círculo. 3. Las salidas serán los datos solicitados: área y circunferencia. Informática I. Versión 1.0 Agosto de 2004. 70
- 71. Universidad Autónoma deOccidente Diseño del Algoritmo Seamos optimistas y pensemos que vamos a tener la capacidad de tener ideas, propias o adquiridas, para desarrollar algoritmos que nos permitan actuar ante los problemas que se nos planteen. Para diseñar algoritmos hay que tener presente los requisitos ó caracteríticas siguientes: • Preciso: El algoritmo debe indicar con mucha claridad el orden de realización de cada paso. • Definido: Si se sigue un algoritmo dos veces , se debe obtener el mismo resultado cada vez, es decir, estar definido sin ambigüedad. • Finito: Si se sigue un algoritmo, se debe terminar en algún momento; o sea, debe tener un número finito de pasos. Ejemplo: Instrucciones para subir una escalera [...] Las escaleras se suben de frente, pues hacia atrás o de costado resultan particularmente incómodas. La actitud natural consiste en mantenerse de pie, los brazos colgando sin esfuerzo, la cabeza erguida aunque no tanto tal que los ojos puedan ver los peldaños inmediatamente superiores al que se pisa, y respirando lenta y regularmente. Para subir una escalera se comienza por levantar esa parte del cuerpo situada a la derecha abajo, envuelta casi siempre en cuero o gamuza, y que salvo excepciones cabe exactamente en el escalón. Puesta en el primer peldaño dicha parte, que para abreviar llamaremos pie, se recoge la parte equivalente de la izquierda (también llamada pie, pero que no ha de confundirse con el pie antes citado), y llevándola a la altura del pie, se le hace seguir hasta colocarla en el segundo peldaño, con lo cual en éste descansará el pie, y en el primero descansará el pie. (Los primeros peldaños son siempre los más difíciles, hasta adquirir la coordinación necesaria. La coincidencia de nombre entre el pie y el pie hace difícil la explicación. Cuídese especialmente de no levantar al mismo tiempo el pie y el pie). Llegando en esta forma al segundo peldaño, basta repetir alternadamente los movimientos hasta encontrarse con el final de la escalera. Se sale de ella fácilmente, con un ligero golpe de talón que la fija en su sitio, del que no se moverá hasta el momento del descenso. Ejemplo: Elaborar Tortilla de patatas a la española (6 personas) Ingredientes: - 2 vasos (de los de agua) de aceite (1/2 litro) - Sal - 8 huevos - 1 kg de patatas Se pelan las patatas, se lavan y se secan con un paño; se parten en dos a lo largo y después se cortan en láminas finitas. Se pone el aceite a calentar en la sartén y se fríen las patatas, moviéndolas de vez en cuando y echándoles un poco de sal. Una vez fritas (más o menos doradas, según gusten), se separan y se ponen a escurrir en un colador grande. Se quita el aceite sobrante de la sartén. Aparte se baten los huevos con tenedor y muy fuerte; se pone un poco de sal; en el mismo plato de los huevos se echan las patatas y se mueven con un tenedor. En una sartén grande (o en dos pequeñas) se ponen 3 cucharadas soperas de aceite para que sólo cubra el fondo. Cuando está caliente se vierte la mezcla de huevos y patatas. Se mueve la sartén por el mango para que no se pegue la tortilla. Cuando se vea que está bien despegada y dorada (esto depende Informática I. Versión 1.0 Agosto de 2004. 71
- 72. Universidad Autónoma deOccidente del gusto de cada cual), se pone una tapadera encima, se vuelca la sartén y se escurre suavemente la tortilla otra vez en la sartén. Se vuelve a mover por el mango y cuando esté cuajada (a gusto) se pasa a una fuente redonda y se sirve. Ejemplo: Algoritmo “infantil”: Multiplicación de números enteros Para obtener el producto de dos números enteros utilizando lápiz y papel se debe escribir el primer factor (multiplicando) y, justo debajo y alineado a la derecha, el segundo factor (multiplicador). Se recorren todas las cifras del multiplicador de derecha a izquierda y se operan con cada una de las cifras el multiplicando, también de derecha a izquierda, escribiendo los resultados intermedios en líneas separadas; cada línea estará desplazada una posición a la izquierda respecto a la línea inmediatamente superior. Una vez se han obtenido todos los resultados intermedios se suman columna a columna obteniéndose el resultado final. Numerando cada uno de los pasos a seguir en cada uno de los algoritmos, formalizamos un poco nuestro lenguaje cotidiano para escribir algoritmos, veamos: Ejemplo: Cambiar la rueda pinchada de un automóvil teniendo un gato mecánico en buen estado, una rueda de reemplazo y una llave inglesa. Los pasos del algoritmo son: 1. Inicio 2. Aflojar los tornillos de la rueda pinchada con la llave inglesa. 3. Ubicar el gato mecánico en su sitio. 4. Levantar el gato hasta que la rueda pinchada pueda girar libremente. 5. Quitar los tornillos y la rueda pinchada. 6. Poner rueda de repuesto y los tornillos. 7. Bajar el gato hasta que se pueda liberar. 8. Sacar el gato de su sitio. 9. Apretar los tornillos con la llave inglesa. 10. Fin. Podríamos modificar este algoritmo, bien sea escribiendo más líneas de detalle ó uniendo algunos pasos, y aún así funcionaría para resolver nuestro problema. Esto quiere decir que podemos tener algoritmos diferentes, con diferente diseño, que resuelven el mismo problema. ¿Cuál de ellos es más eficiente, hablando desde el punto de vista computacional? Ese es tema de otro curso, por el momento nos debemos concentrar en cual algoritmo es más claro, cual es más fácil de entender. Ejemplo: Un cliente hace un pedido a una fábrica. La fábrica examina en su banco de datos la ficha del cliente, si el cliente es solvente entonces la empresa acepta el pedido; en caso contrario lo rechaza. Elabore el algoritmo correspondiente. Los pasos del algoritmo son: 1. Inicio. 2. Leer el pedido. 3. Examinar la ficha del cliente. 4. Si el cliente es solvente, aceptar pedido; en caso contrario, rechazarlo. 5. Fin. Informática I. Versión 1.0 Agosto de 2004. 72
- 73. Universidad Autónoma deOccidente Ejemplo: Averiguar si un número entero positivo es primo o no, dado que conocemos la definición de número primo: un número entero positivo, N, es primo si sólo puede dividirse por sí mismo y por la unidad. Un método que nos puede dar la solución sería dividir sucesivamente el número por 2, 3, 4...N, y, según el resultado, podríamos resolver el problema. Un diseño del mismo sería: 1. Inicio. 2. Poner X igual a 2 (X = 2, donde X es una variable que representa a los posibles divisores de N). 3. Dividir N por X (N/X). 4. Si el resultado de N/X es entero, entonces N no es primo (pues esto indicaría que N es divisible entre X) y saltar al punto 9; en caso contrario continuar el proceso en el siguiente punto, 5. 5. Incrementar X en una unidad (X = X + 1) 6. Si X es menor que N saltar al punto 3, en caso contrario continuar el proceso en el siguiente punto, 7. 7. Declarar que N es primo; 8. Saltar al Fin (punto 10) 9. Declarar que N no es primo 10. Fin Como parte del diseño de un algoritmo está la selección de aquél que sea razonablemente aceptable, entre todos los muchos posibles que resuelven el mismo problema (el ejemplo que acabamos de dar es claramente mejorable, pues si N no era divisible por 2 no tiene mucho sentido volverse a preguntar si lo es por 4). Durante el diseño es posible y aconsejable, realizar comparaciones entre algoritmos que resuelven el mismo problema. La bondad de un algoritmo puede medirse por dos factores: - El tiempo que se necesita para ejecutarlo. Para tener una idea aproximada de ello, basta con saber el número de instrucciones de cada tipo necesarias para resolver el problema. - Los recursos que se necesitan para implementarlo. Así, una vez diseñado un primer algoritmo, conviene realizar una evaluación del mismo, cuestión a veces nada banal y sobre la que volveremos en capítulos posteriores. Si se decide que éste no es eficiente será necesario o bien diseñar uno nuevo o bien optimizar el original. Optimizar un algoritmo consiste en introducir modificaciones en él, tendientes a disminuir el tiempo que necesita para resolver el problema o a reducir los recursos que utiliza. (En el ejemplo 2, el algoritmo se optimiza si N se declara como primo cuando X supera a N/2 y no esperar hasta que X llegue a N). Ejemplo: Realizar la suma de todos los números pares entre 2 y 1000. El problema consiste en sumar 2 + 4 + 6 + 8 + 10 + . . . + 998 + 1000. Utilizaremos las palabras SUMA y NUMERO (que llamaremos más tarde variables) para representar las sumas sucesivas (2 + 4), (2 + 4 + 6), (2 + 4 + 6 + 8), etc. La solución se puede escribir con el siguiente algoritmo: 1. Inicio. 2. Establecer SUMA a 0. 3. Establecer NUMERO a 2. 4. Sumar NUMERO a SUMA. El resultado será el nuevo valor de la suma (SUMA). 5. Incrementar NUMERO en 2 unidades. 6. Si NUMERO <= 1000 bifurcar (ó, ir) al paso 4; en caso contrario, escribir el último valor de SUMA y terminar el proceso. 7. Fin. Informática I. Versión 1.0 Agosto de 2004. 73
- 74. Universidad Autónoma deOccidente Si se estudia con atención cada uno de los algoritmos anteriores descubriremos una serie de características interesantes que definen la naturaleza de lo que es un algoritmo: - Un algoritmo resuelve un problema específico: subir una escalera, obtener una tortilla de patatas, hacer una multiplicación o determinar el máximo común divisor de dos números. - Un algoritmo es llevado a cabo por una entidad que trabaja en un entorno dado: una persona cuyo universo inmediato se reduce a su propio cuerpo y una escalera; un cocinero con una sartén, huevos, patatas, aceite, sal y cebolla; o un niño con lápiz y papel. - Un algoritmo consta de una serie de pasos que deben llevarse a cabo siguiendo una secuencia marcada: algunos de los pasos, en uno de los algoritmos anteriores, serían: dar la vuelta a la tortilla, batir los huevos, pelar las patatas o cascar los huevos; dichos pasos deben aplicarse en un orden prefijado y no de cualquier manera. - Un algoritmo se aplica de forma mecánica: un algoritmo no precisa decisiones subjetivas ni creatividad en su ejecución, cualquiera con una receta adecuada para obtener tortilla de patatas logrará una tortilla de patatas. Sin embargo, sí es necesario un acto creativo para desarrollar un nuevo algoritmo. - Un algoritmo termina en un tiempo finito: todos los algoritmos deben finalizar, pueden tardar más o menos tiempo en lograr un resultado pero dicho tiempo debe ser finito. Diseño Descendente (Top Down), ó, Modular Los problemas complejos se pueden resolver más eficazmente cuando se descomponen en subproblemas que sean más fáciles de resolver que el original. Este método se denomina divide y vencerás (Divide and conquere) y consiste en convertir un problema complejo en otros más simples que, una vez resueltos, en su conjunto nos solucionen el original. Al procedimiento de descomposición de un problema en subproblemas más simples, llamados módulos, para, a continuación, seguir dividiendo estos subproblemas en otros más simples (otros módulos), se le denomina diseño descendente (top down, en inglés). Las ventajas más importantes de este tipo de diseño son: 1. El problema se comprende más fácilmente al dividirse en módulos o partes más simples. Adelantemos que cuando demos el salto a la programación, utilizaremos esta idea constantemente, de forma que hablaremos también de procedimientos, o subprogramas. 2. Las modificaciones en los módulos son más fáciles, pues estamos ante algoritmos más sencillos. 3. La comprobación del problema se puede realizar más fácilmente, al poder localizar los posibles fallos con mayor precisión. Refinamiento por pasos Durante el diseño, entenderemos por refinamiento por pasos, la metodología por la que en un primer esbozo del algoritmo nos limitamos a señalar o describir un reducido numero de pasos, que deberán ser expresados con mayor detalle posteriormente. Tras esta primera descripción, éstos se especifican con mayor minuciosidad, de forma más extensa y con más pasos específicos. En cada nivel de refinamiento hay que considerar dos fases: ¿Qué hace el módulo? para, a continuación, responder a ¿Cómo lo hace? Como es natural, dependiendo de la complejidad del problema se necesitarán diferentes y sucesivos niveles de refinamiento antes de que pueda obtenerse un algoritmo con suficiente nivel de detalle. Así, en el Ejemplo 1, del cálculo de la longitud de una circunferencia y la superficie de su círculo, a pesar de presentar en su diseño un bajo nivel de complejidad, se puede descomponer en subproblemas más simples: 1. leer datos de entrada, 2. calcular superficie y longitud, 3. escribir resultados. Informática I. Versión 1.0 Agosto de 2004. 74
- 75. Universidad Autónoma deOccidente El ejemplo siguiente, nos muestra el diseño de un algoritmo para un problema de carácter no numérico Ejemplo 3: Diseñar un algoritmo que responda a la pregunta: ¿Qué debo hacer para ver la película XYZ?. Un primer análisis nos conduce a un esbozo de solución, descomponiéndolo en cuatro módulos sucesivos: 1. Ir al cine donde proyectan MatriX 2. Comprar una entrada 3. Ver la película 4. Regresar a casa Estos cuatro pasos se pueden refinar un poco más y así este problema lo podríamos descomponer de la siguiente forma: Algoritmo para ver la película XYZ inicio consultar la cartelera de cines si proyectan XYZ entonces ir al cine correspondiente si_no proyectan XYZ declarar el fracaso del objetivo y terminar acudir al cine correspondiente si hay cola entonces ponerse en ella mientras haya personas delante en la cola hacer avanzar en la cola preguntar si quedan entradas si hay entradas entonces comprar una entrada si_no quedan entradas declarar el fracaso del objetivo, regresar a casa y terminar encontrar el asiento correspondiente mientras proyectan la película hacer ver la película abandonar el cine regresar a casa fin Algunas de estas acciones son primitivas para nosotros, es decir, no es necesario descomponerlas más, como el abandonar el cine. Sin embargo hay otras acciones que son susceptibles de mayor descomposición. Este es el caso de la acción: “encontrar el asiento correspondiente” si los números de los asientos están impresos en la entrada, esta acción compuesta se resuelve con el siguiente algoritmo: Algoritmo para encontrar el asiento del espectador inicio caminar hasta llegar a la primera fila de asientos repetir comparar número de fila con número impreso en billete si no son iguales, entonces pasar a la siguiente fila hasta_que se localice la fila correcta Informática I. Versión 1.0 Agosto de 2004. 75
- 76. Universidad Autónoma deOccidente mientras número de asiento no coincida con número de billete hacer avanzar a través de la fila a la siguiente butaca sentarse en la butaca fin De esta forma, podríamos seguir hasta la descomposición de las distintas acciones en instrucciones susceptibles de ser interpretadas directamente por el computador. Programación del Algoritmo Una vez que el algoritmo está diseñado y representado, se debe pasar a la fase de resolución práctica del problema con el computador. Esta fase se descompone a su vez en las siguientes subfases: (Ver Figura 5.3) 1. Codificación del algoritmo en un programa. 2. Ejecución del programa. Programación 3. Comprobación del programa. del algoritmo Codificación en un Ejecución del Comprobación programa programa del programa Fig. 5.3 Programación del algoritmo La fase de conversión de un algoritmo en instrucciones de un lenguaje de programación, como sabemos, se denomina codificación. El código deberá estar escrito de acuerdo con la sintaxis del lenguaje de programación ya que solamente las instrucciones sintácticamente correctas pueden ser interpretadas por el computador. Nótese que durante el proceso de programación, se debe separar el diseño del algoritmo de su posterior implementación en un lenguaje de programación específico. Por ello distinguimos entre el concepto más general de programación y el más particular de codificación, que depende del lenguaje de programación utilizado. Al llegar a este punto, es posible que el lector conozca al menos uno de estos lenguajes y éste es el momento en el que podría mostrar sus habilidades para efectuar una codificación lo más correcta y eficiente posible. Tras la codificación del programa, éste deberá ejecutarse en un computador. El resultado de esta primera ejecución es incierto, ya que existe una alta probabilidad de que aparezcan errores, bien en la codificación, bien en el propio algoritmo. Por tanto, el paso siguiente consiste en comprobar el correcto funcionamiento del programa y en asegurarse, en la medida de lo posible, de la validez de los resultados proporcionados por la máquina. Formas de describir un algoritmo Dado que los algoritmos permiten resolver problemas de forma mecánica, está claro que resulta muy interesante compartir dicho algoritmo de tal manera que otras personas puedan conocerlo y aplicarlo; así surge el problema de describir los algoritmos de forma tal que todas las características que los definen se mantengan invariables. Lenguaje natural. La primera y más sencilla forma de describir un algoritmo es empleando el lenguaje natural; por ejemplo, el algoritmo para encontrar las raíces de una ecuación de segundo grado (ó, ecuación cuadrática) podría describirse así: 1. Definir (o, leer) los coeficientes de la ecuación de segundo grado: a, b y c. 2. Determinar el valor del discriminante: d = b 2 - 4ac. 3. Si el discriminante es cero, sólo hay una solución: -b / (2a). 4. Si el discriminante es positivo, hay dos soluciones: (-b ± √d) / (2a). Informática I. Versión 1.0 Agosto de 2004. 76
- 77. Universidad Autónoma deOccidente 5. Si el discriminante es negativo, no hay soluciones reales. La ventaja fundamental es la facilidad de comprensión, cualquier persona (hispanoparlante, por supuesto) que lea dicho algoritmo podría entenderlo y aplicarlo; sin embargo, son varios los problemas que plantea describir un algoritmo de esta forma: - El lenguaje natural no es universal, este algoritmo sería completamente inútil para los no hispanoparlantes. - El lenguaje natural es ambiguo y, por tanto, susceptible de errores. - El lenguaje natural es demasiado amplio, lo que para una persona puede ser una instrucción sencilla, puede no serlo para otra y, desde luego, no lo será para un computador. Por todo ello, se han buscado nuevas formas de describir los algoritmos que, cuando menos, sean más universales, estén mejor delimitadas y no sean ambiguas; dos técnicas que logran esto son los organigramas y las notaciones en pseudocódigo. Diagramas de Flujo (Organigramas) Los diagramas de flujo u organigramas permiten describir los algoritmos de forma gráfica; para ello utilizan una serie de bloques que indican distintas circunstancias y flechas que muestran bajo qué condiciones se pasa de un bloque a otro. Algunos de los símbolos son los siguientes: En la página siguiente se muestra un organigrama que describe el algoritmo anterior. Los organigramas presentan varias ventajas frente al lenguaje natural: - Los símbolos son universales. - Son menos propensos a la ambigüedad. - Por estar basados en un número pequeño de bloques y reglas para su empleo permiten delimitar mejor los algoritmos. - Se aproximan más a la forma en que trabaja el ordenador. Sin embargo: - El hecho de emplear símbolos supone que una persona que desconozca los símbolos puede tener dificultades para comprender el algoritmo o no entenderlo en absoluto. - Aunque los símbolos son universales el texto que se coloca en su interior sigue siendo lenguaje natural. - La representación gráfica puede resultar bastante tediosa y en el caso de algoritmos complejos - extremadamente confusa. - Un ordenador no es capaz de utilizar una representación visual como descripción de un algoritmo. Actualmente, los organigramas no son muy utilizados, aunque para mostrar el funcionamiento de algoritmos sencillos siguen siendo resultando prácticos. Informática I. Versión 1.0 Agosto de 2004. 77
- 78. Universidad Autónoma deOccidente Pseudocódigo El pseudocódigo pretende aunar en un solo tipo de representación las ventajas del lenguaje natural y de los organigramas sin ninguno de sus problemas; por tanto, el pseudocódigo: - Es fácilmente comprensible para una persona que lo vea por vez primera. - Está bien delimitado. - Elimina las ambigüedades del lenguaje natural. - Se representa de una forma compacta. De esta forma, el pseudocódigo se suele ver como un subconjunto de un lenguaje natural que proporciona un número limitado de operaciones para la construcción de algoritmos; la única finalidad del pseudocódigo (como de los organigramas) es la comunicación entre seres humanos. A continuación se muestra un ejemplo del algoritmo descrito, mediante un pseudocódigo: Ejemplo: Algoritmo para la ecuación cuadrática, escrito en seudocódigo Informática I. Versión 1.0 Agosto de 2004. 78
- 79. Universidad Autónoma deOccidente escribir ‘Deme los coeficientes y resolveré una ecuación de 2º grado’ escribir ‘¿Cuánto vale A?’ leer a escribir ‘¿Cuánto vale B?’ leer b escribir ‘¿Cuánto vale C?’ leer c discr b2-4ac si discr = 0 entonces s -b/(2a) escribir ‘Sólo hay una solución:’, s si no si discr > 0 entonces s1 (-b + √discr)/(2a) s2 (-b - √discr)/(2a) escribir ‘Las soluciones son:’, s1, s2 si no escribir ‘No hay soluciones reales.’ fin_si fin_si La ventajas del uso del pseudocódigo residen en: - Su uso en la planificación de un programa; permitiendo que el programador se pueda concentrar en la lógica y en las estructuras de control y no tenga que preocuparse, por ahora, de detalles acerca de las reglas sintácticas y semánticas de un lenguaje específico. - Consecuentemente, es más fácil de modificar en el caso de que se descubran errores o anomalías en la lógica del algoritmo. - Aunque el pseudocódigo es independiente del lenguaje de alto nivel que vaya a utilizarse, un algoritmo expresado en pseudocódigo puede ser traducido más fácilmente a muchos de dichos lenguajes. Lenguajes de programación Aunque en la unidad 4. se revisaron las definiciones de variables numéricas, literales, operadores, etc.; creemos conveniente recordar esas definicines reforzándolas con ejemplos concretos de otros textos. Un lenguaje de programación comparte las mismas características que el pseudocódigo pero, además de ser comprensible para un ser humano, resulta comprensible para un computador; esto es, un algoritmo descrito mediante un lenguaje de programación puede ser ejecutado por una máquina. A continuación, se muestra el algoritmo anterior escrito en el lenguaje de programación JAVA: /* Ecuación Cuadrática. Elaborado por: ***************************************************** */ import java.io.* ; // Importa el paquete de entrada / salida (input / output) class Cuadratica { // Mètodo principal: Informática I. Versión 1.0 Agosto de 2004. 79
- 80. Universidad Autónoma deOccidente public static void main( String args[ ] ) throws IOException { /* Para recibir los datos vía teclado, debe crear un objeto (que aquí se ha llamado br) de la clase BufferedReader Observe que al constructor de la clase BufferedReader se le envía como argumento una nueva instancia (= objeto) de la clase InputStreamReader Para obtener esta nueva instancia de la clase InputStreamReader, se ha enviado a su constructor la variable de clase in de la clase System */ // Si lo anterior le parece un trabalenguas, por favor no se alarme, // no tire la toalla. por el momento, procure memorizar la siguiente línea: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de los coeficientes, del discriminante y de las raíces: double a, b, c ; // Coeficientes de la ecuación ( a != 0 ). double d; // Discriminante de la cuadrática: d = b * b - 4 * a * c double x, x1, x2 ; // Raíces de la ecuación. // Lectura, vía teclado, de los coeficientes: System.out.print( "Digite el valor del coeficiente a (a diferente de cero): " ) ; a = Double.parseDouble( br.readLine( ) ) ; System.out.print( "Digite el valor del coeficiente b: " ) ; b = Double.parseDouble(br.readLine( ) ) ; System.out.print( "Digite el valor del coeficiente c: " ) ; c = Double.parseDouble(br.readLine( ) ) ; // Calcula el discriminante: d=b*b-4*a*c; if( d == 0 ) { x = - b / (2 * a) ; System.out.println( "Dos raices iguales: X = " + x ) ; } else if( d > 0 ) { x1 = ( - b + Math.sqrt( d ) ) / (2 * a) ; x2 = ( - b - Math.sqrt( d ) ) / (2 * a) ; System.out.println( "Raices reales diferentes: " ) ; System.out.println( " X1 = " + x1 ) ; System.out.println( " X2 = " + x2 ) ; } else System.out.println( "La ecuacion NO tiene raices reales" ) ; System.exit( 0 ) ; // Termine el programa (salir del sistema) } // Fin del método main( ) } // Fin de la clase Cuadratica Informática I. Versión 1.0 Agosto de 2004. 80
- 81. Universidad Autónoma deOccidente Al compilar y ejecutar esta aplicación Java se obtienen las siguientes salidas en la salida estandar: Ejemplo: Supongamos que tenemos un algoritmo para averiguar si un número es par, que puede ser descrito narrativamente de la siguiente forma: “Si restando consecutivamente doses (2s) del número se obtiene el numero 2, es par, si se obtiene otro valor (el 1), entonces es impar”. Este algoritmo escrito en pseudocódigo sería: leer N mientras N > 2 hacer N= N-2 si N = 2 entonces escribe “es par” sino escribe “es impar” fin_si Nótese que en este ejemplo y en otros anteriores hemos utilizado dos estructuras que son muy usadas en programación: mientras-hacer y si-entonces - si_no; y que la escritura del pseudocódigo usa Informática I. Versión 1.0 Agosto de 2004. 81
- 82. Universidad Autónoma deOccidente normalmente la indentación (sangría en el margen izquierdo) de diferentes líneas para ayudar a delimitar visualmente cada una de las estructuras utilizadas. El siguiente es el programa escrito en Java: import java.io.* ; class EsPar1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: int n ; // Entrada de datos: System.out.print( "Digite un numero entero positivo: " ) ; n = Integer.parseInt( br.readLine( ) ) ; // Ciclo while que verifica si n es par: while(n > 2) { n=n-2; } if(n == 2) System.out.println( "El numero ingresado es par" ) ; else System.out.println( "El numero ingresado es impar" ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase EsPar1 Variables Una variable es una localización o casilla en la memoria principal que almacena un valor que puede cambiar en el transcurso de la ejecución del programa. Cuando un programa necesita almacenar un dato, necesita una variable. Toda variable tiene un nombre, un tipo de dato y un valor. Antes de poder utilizar una variable es necesario declararla especificando su nombre y su tipo de dato. Para declarar variables usaremos los siguientes formatos: Informática I. Versión 1.0 Agosto de 2004. 82
- 83. Universidad Autónoma deOccidente Declaración de una variable: tipo nombre Declaración de varias variables con el mismo tipo de dato: tipo nombre1, nombre2, nombre3, ..., nombreN Donde: Tipo Es el tipo de dato de la variable que puede ser: ENTERO (si la variable almacenará un número entero) , REAL (si la variable almacenará un número con parte decimal) , CARACTER (si la variable almacenará un caracter), CADENA (si la variable almacenará un conjunto de caracteres) o LOGICO (si la variable almacenará el valor verdadero o el valor falso). nombre1, nombre2, ..., Nombres de las variables. El nombre de una variable debe comenzar nombreN con una letra, un símbolo de subrayado o un símbolo de dólar. Los demás caracteres del nombre pueden ser letras, números, símbolos de subrayado o símbolos de dólar. Debe considerarse también que una letra mayúscula se considera diferente de una letra minúscula. Ejemplo Declaración de variables. La siguiente instrucción declara la variable edad de tipo ENTERO y la variable descuento de tipo REAL. ENTERO edad REAL descuento Esto crea las casillas de memoria edad y descuento. Luego de la creación, las variables están indefinidas ( ? ). Edad ? descuento ? La siguiente instrucción declara las variables nota1, nota2 y nota3, todas de tipo ENTERO. ENTERO nota1, nota2, nota3 Esto crea los casilleros de memoria nota1, nota2 y nota3. Luego de la creación, las variables están indefinidas ( ? ). nota1 ? nota2 ? nota3 ? Literales Se denominan literales a todos aquellos valores que figuran en el pseudocódigo y pueden ser: Literales enteros 12, 20300, 15, etc. Literales reales 3.1416, 2345.456, etc. Informática I. Versión 1.0 Agosto de 2004. 83
- 84. Universidad Autónoma deOccidente Literales de carácter 'a', 'B', ';', '<', '+', etc. Literales de cadena "Hola", "Algoritmos Computacionales", etc. Literales lógicos verdadero, falso Instrucciones Algorítmicas Básicas Existen tres instrucciones algorítmicas básicas que son las siguientes: 1.- Entrada Consiste en obtener un dato de un dispositivo de entrada, como el teclado, y almacenarlo en una variable. En general, la acción de ingresar un dato a una variable se expresa en el pseudocódigo mediante la palabra LEER, de la siguiente forma: LEER variable Por ejemplo, la instrucción: LEER estatura Solicita el ingreso de un valor, desde algún dispositivo de entrada (como el teclado), para la variable estatura. 2.- Salida Consiste en mostrar el valor de una variable en un dispositivo de salida, como la pantalla. En general, la acción de mostrar el valor de una variable se expresa en el pseudocódigo mediante la palabra IMPRIMIR de la siguiente forma: IMPRIMIR variable Por ejemplo, la instrucción: IMPRIMIR importeCompra Muestra, en algún dispositivo de salida (como la pantalla), el valor de la variable importeCompra. 3.- Asignación Consiste en asignar a (ó, almacenar en) una variable el valor de una expresión. La expresión puede ser una simple variable, un simple literal o una combinación de variables, literales y operadores. La asignación se expresa en el pseudocódigo de la siguiente forma: variable = expresión Donde variable y el valor de expresión deben tener el mismo tipo de dato!! Cuando se asigna un valor ENTERO a una variable REAL, entonces el valor ENTERO se convertirá en REAL antes de almacenarse. Así, al asignar el valor ENTERO 25 a una variable REAL, se almacenará 25.0. Ejemplo:- Algoritmo para expresar en centímetros y pulgadas una cantidad dada en metros. Esta es una solución en pseudocódigo utilizando conceptos computacionales de: variable, entrada de datos y salida de resultados. La solución considera que 1 metro = 100 centímetros y que 1 pulgada = 2.54 centímetros. INICIO // Declara las variables M, C y P REAL M, C, P Informática I. Versión 1.0 Agosto de 2004. 84
- 85. Universidad Autónoma deOccidente // Solicita el ingreso de la cantidad en metros LEER M // Calcula la cantidad en centímetros y lo asigna a la variable C C = M * 100 // Calcula la cantidad en pulgadas y lo asigna a la variable P P = C / 2.54 // Muestra los valores de las variables C y P IMPRIMIR C, P FIN Expresiones Aritméticas Una expresión aritmética es una combinación de variables, literales y operadores aritméticos. Operadores Aritméticos En la tabla que sigue se muestran los operadores aritméticos que vamos a utilizar. Tabla 5.1 Operadores aritméticos Operador Significado Ejemplo + Suma a +b - Resta a-b * Multiplicación a *b / División a/b % Residuo a%b Los operadores aritméticos pueden utilizarse con tipos enteros y reales. Si en una operación con dos operandos, ambos operandos son enteros, el resultado es un entero; si alguno de ellos es real, el resultado es real. Así, 15 / 4 es 3 y no 3.75; en cambio, 15.0/4 es 3.75. Reglas de jerarquía de los operadores aritméticos Cuando una expresión aritmética tiene más de un operador aritmético, el orden de aplicación de los operadores sigue un orden preciso determinado por las reglas de jerarquía de los operadores aritméticos, que se muestran en la siguiente tabla: Tabla 5.2 Reglas de jerarquía de los operadores aritméticos Operador Orden de evaluación () Se evalúan en primer lugar *, /, % Se evalúan en segundo lugar +, - Se evalúan en tercer lugar Si existen paréntesis anidados, se evalúa primero la expresión en el paréntesis más interno. Si varios operadores o paréntesis tienen la misma jerarquía, la evaluación será de izquierda a derecha. Ejemplo:- ¿Cuál es el equivalente en pseudocódigo de la siguiente expresión algebraica? Informática I. Versión 1.0 Agosto de 2004. 85
- 86. Universidad Autónoma deOccidente Solución e=a/b/c Como todos los operadores tienen la misma jerarquía, la evaluación será de izquierda a derecha: Primero, se dividirá a entre b. Segundo, el resultado ya obtenido de a / b se dividirá entre c. Note que el orden de ejecución esta de acuerdo con la expresión algebraica, por lo que no se requiere ninguna pareja de paréntesis. Ejemplo:- ¿Cuál es el equivalente en pseudocódigo de la siguiente expresión algebraica? Solución c=a*b*c/d/e Como todos los operadores tienen la misma jerarquía, la evaluación será de izquierda a derecha: Primero, se multiplicará a por b. Segundo, el resultado ya obtenido de a * b se multiplicará por c. Tercero, el resultado ya obtenido de a * b * c se dividirá entre d. Cuarto, el resultado ya obtenido de a * b * c / d se divivirá entre e. Note que el orden de ejecución esta de acuerdo con la expresión algebraica, por lo que no se requiere ninguna pareja de paréntesis. Ejercicio:- ¿Cuál es el equivalente en pseudocódigo de la siguiente expresión algebraica? Solución e = 4 / ( (a + b) / (c / d) ) + v / (w / p) + 5 * m * n * q Aplicando las reglas de jerarquía de los operadores aritméticos: Primero, se sumará a más b. Segundo, se dividirá c entre d. Tercero, el resultado ya obtenido de a+b se dividirá entre el resultado ya obtenido de c/d. Cuarto, se dividirá 4 entre el resultado ya obtenido de ( (a+b)/(c/d) ) Quinto, se dividirá w entre p. Sexto, se dividirá v entre el resultado ya obtenido de (w/p). Séptimo, se multiplicará 5 por m. Octavo, se multiplicará el resultado ya obtenido de 5*m por n. Noveno, se multiplicará el resultado ya obtenido de 5*m*n por q. Décimo, se sumará el resultado ya obtenido de 4/( (a+b)/(c/d) ) más el resultado ya obtenido de v/(w/p). Undécimo, se sumará el resultado ya obtenido de 4/( (a+b)/(c/d) ) + v/(w/p) más el resultado ya obtenido de 5*m*n*q. Informática I. Versión 1.0 Agosto de 2004. 86
- 87. Universidad Autónoma deOccidente Se ha utilizado la mínima cantidad posible de paréntesis. Pueden usarse paréntesis adicionales, lo que no es un error. Por ejemplo, otra solución posible que arroja el mismo resultado final es: e = ( 4/( (a+b)/(c/d) ) ) + (v/(w/p)) + (5*m*n*q) Note que usando correctamente las reglas de jerarquía, es posible usar menos parejas de paréntesis. Expresiones Lógicas Una expresión lógica combina variables, literales, operadores aritméticos, operadores relacionales y operadores lógicos. Los operadores relacionales y los operadores lógicos se muestran en las tablas 1.3 y 1.4 Tabla 5.3 Operadores relacionales Operador Significado Ejemplo > mayor que a>b >= mayor o igual que a >= b < menor que a<b <= menor o igual que a <= b == igual a a == b != diferente de a != b Tabla 5.4 Operadores lógicos Operador Significado Ejemplo ! No (Not) !a && Y (And) a && b || Ó (Or) a || b EJERCICIOS RESUELTOS Ejercicio 1:- Diseñe un pseudocódigo que halle el área y el perímetro de un rectángulo. Considere que: area = base x altura, y, perimetro = 2 x (base+altura). Algoritmo INICIO // Declaración de variables REAL base, altura, area, perimetro // Entrada de datos LEER base, altura // Proceso de cálculo area = base*altura perimetro = 2*(base+altura) // Salida de resultados IMPRIMIR area, perimetro FIN Veamos el algoritmo anterior escrito en Java: Informática I. Versión 1.0 Agosto de 2004. 87
- 88. Universidad Autónoma deOccidente import java.io.* ; class Rectangulo1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: double base, altura, area, perimetro ; // Entrado de datos: System.out.print( "Digite el valor de la base [cm]: " ) ; base = Double.parseDouble( br.readLine( ) ) ; System.out.print( "Digite el valor de la altura [cm]: " ) ; altura = Double.parseDouble( br.readLine( ) ) ; // Proceso de cálculo area = base * altura ; perimetro = 2 *(base + altura) ; // Salida de resultados System.out.println( "Area del rectangulo: " + area + " cm2" ) ; System.out.println( "Perimetro del rectangulo: " + perimetro + " cm" ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase Rectangulo1 Salida: Ejercicio 2:- Diseñe un pseudocódigo para convertir una longitud dada en metros a sus equivalentes en centímetros, pies, pulgadas y yardas. Considere que: 1 metro = 100 centímetros, 1 pulgada = 2.54 centimetros, 1 pie = 12 pulgadas, 1 yarda = 3 pies. Algoritmo INICIO // Declaración de variables REAL cmetr,ccent, cpies, cpulg, cyard Informática I. Versión 1.0 Agosto de 2004. 88
- 89. Universidad Autónoma deOccidente // Entrada de datos LEER cmetr // Proceso de cálculo ccent = cmetr * 100 cpulg = ccent / 2.54 cpies = cpulg / 12 cyard = cpies / 3 // Salida de resultados IMPRIMIR ccent, cpulg, cpies, cyard FIN Veamos el algoritmo anterior escrito en Java: import java.io.* ; class Conversiones1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: double cmetr,ccent, cpies, cpulg, cyard ; // Entrado de datos: System.out.print( "Digite la cantidad en metros: " ) ; cmetr = Double.parseDouble( br.readLine( ) ) ; // Proceso de cálculo ccent = cmetr * 100 ; cpulg = ccent / 2.54 ; cpies = cpulg / 12 ; cyard = cpies / 3 ; // Salida de resultados System.out.println( "Cantidad equivalente en centimetros: " + ccent + " cm" ) ; System.out.println( "Cantidad equivalente en pulgadas: " + cpulg + " pulgadas" ) ; System.out.println( "Cantidad equivalente en pies: " + cpies + " pies" ) ; System.out.println( "Cantidad equivalente en yardas: " + cyard + " yardas" ) ; System.exit( 0 ) ; } //Fin del método main( ) Informática I. Versión 1.0 Agosto de 2004. 89
- 90. Universidad Autónoma deOccidente } // Fin de la clase Conversiones1 Ejercicio 3:- Una institución benéfica europea ha recibido tres donaciones en soles, dolares y marcos. La donación será repartida en tres rubros: 70% para la implementación de un centro de salud, 20% para un comedor de niños y el resto para gastos administrativos. Diseñe un algoritmo que determine el monto en euros que le corresponde a cada rubro. Considere que: 1 dólar = 3.52 soles, 1 dólar = 2.08 marcos, 1 dólar = 1.07 euros. Algoritmo INICIO // Declaración de variables REAL csoles, cdolares, cmarcos, ceuros, rubro1, rubro2, rubro3 // Entrada de datos LEER csoles, cdolares, cmarcos // Proceso de cálculo ceuros = (csoles / 3.52 + cdolares + cmarcos / 2.08 ) * 1.07 rubro1 = ceuros * 0.70 rubro2 = ceuros * 0.20 rubro3 = ceuros * 0.10 // Salida de resultados IMPRIMIR rubro1, rubro2, rubro3 FIN Veamos el algoritmo anterior escrito en Java: import java.io.* ; class Euros1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: double csoles, cdolares, cmarcos, ceuros, rubro1, rubro2, rubro3 ; // Entrada de datos: System.out.print( "Digite la cantidad de dinero en soles: $ " ) ; csoles = Double.parseDouble( br.readLine( ) ) ; System.out.print( "Digite la cantidad de dinero en dolares: U$ " ) ; Informática I. Versión 1.0 Agosto de 2004. 90
- 91. Universidad Autónoma deOccidente cdolares = Double.parseDouble( br.readLine( ) ) ; System.out.print( "Digite la cantidad de dinero en marcos: $ " ) ; cmarcos = Double.parseDouble( br.readLine( ) ) ; // Proceso de cálculo ceuros = ( csoles / 3.52 + cdolares + cmarcos / 2.08 ) * 1.07 ; rubro1 = ceuros * 0.70 ; rubro2 = ceuros * 0.20 ; rubro3 = ceuros * 0.10 ; // Salida de resultados System.out.println( "Rubro 1 para salud: $ " + rubro1 + " euros" ) ; System.out.println( "Rubro 2 para comedor: $ " + rubro2 + " euros" ) ; System.out.println( "Rubro 3 para gastos de admon: $ " + rubro3 + " euros" ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase Euros1 Ejercicio 4:- En una competencia atlética de velocidad el tiempo se mide en minutos, segundos y centésimas de segundo y, el espacio recorrido se mide en metros. Diseñe un algoritmo para determinar la velocidad promedio de un atleta en km/hr. Considere que: 1 hora = 60 minutos, 1 minuto = 60 segundos, 1 segundo = 100 centésimas de segundo, 1 kilómetro = 1000 metros. Algoritmo INICIO // Declaración de variables ENTERO tmin, tseg, tcen REAL thor, velkmhr, espmt, espkm // Entrada de datos LEER tmin, tseg, tcen, espmt // Cálculo del tiempo total empleado en horas thor = tmin / 60 + tseg / 3600 + (tcen / 100) / 3600 // Aquí sobran los paréntesis. Se dejan por // claridad. // Cálculo del espacio recorrido en kilómetros espkm = espmt / 1000 Informática I. Versión 1.0 Agosto de 2004. 91
- 92. Universidad Autónoma deOccidente // Cálculo de la velocidad en km/hr velkmhr = espkm / thor // Salida de resultados IMPRIMIR velkmhr FIN Veamos el algoritmo anterior escrito en Java: import java.io.* ; class VelocidadAtleta1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: int tmin, tseg, tcen ; double espmt, thor, espkm, velkmhr ; // Entrada de datos: System.out.print( "Digite el tiempo empleado en minutos: " ) ; tmin = Integer.parseInt( br.readLine( ) ) ; System.out.print( "Digite el tiempo empleado en segundos: " ) ; tseg = Integer.parseInt( br.readLine( ) ) ; System.out.print( "Digite el tiempo empleado en centesimas de segundos: " ) ; tcen = Integer.parseInt( br.readLine( ) ) ; System.out.print( "Digite el espacio recorrido en metros: " ) ; espmt = Double.parseDouble( br.readLine( ) ) ; // Proceso de cálculo // Cálculo del tiempo total empleado en horas: thor = tmin / 60.0 + tseg / 3600.0 + (tcen / 100.0) / 3600.0 ; // Aquí sobran los // paréntesis. Se dejan por claridad. // Cálculo del espacio recorrido en kilómetros: espkm = espmt / 1000 ; // Cálculo de la velocidad en km/hr: velkmhr = espkm / thor ; // Salida de resultados System.out.println( "Velocidad del atleta: " + velkmhr + " Km / Hr." ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase VelocidadAtleta1 Informática I. Versión 1.0 Agosto de 2004. 92
- 93. Universidad Autónoma deOccidente Ejercicio 5:- Diseñe un algoritmo que determine la cifra de las unidades de un número natural. Solución 1 Análisis Puede comprobarse que la cifra de las unidades de un número es igual al resto de la división del número entre 10. Observe para ello las siguientes divisiones: 3245 | 10 768 | 10 9 | 10 5 324 8 76 9 0 Podemos concluir entonces que: unidades = numero % 10 Siendo % el operador residuo. Este operador permite obtener el residuo de una división, así como / permite obtener el cociente. Algoritmo INICIO // Declaración de variables ENTERO numero, unidades // Entrada de datos LEER numero // Proceso de cálculo unidades = numero % 10 // Salida de resultados IMPRIMIR unidades FIN El algoritmo anterior, escrito en Java, queda así: import java.io.* ; class UnidadesNumero1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: int num, unidades ; // Entrada de datos: System.out.print( "Digite un numero entero positivo: " ) ; num = Integer.parseInt( br.readLine( ) ) ; Informática I. Versión 1.0 Agosto de 2004. 93
- 94. Universidad Autónoma deOccidente unidades = num % 10 ; System.out.println( num + " tiene " + unidades + " como cifra de las unidades." ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase UnidadesNumero1 Salida: Solución 2 Análisis El residuo de una división entera puede obtenerse también sin recurrir al operador %, de la siguiente forma: unidades = numero - (numero / 10) * 10 observe para esto que en la división (numero/10) los operandos son enteros por lo que el cociente será un entero. Así por ejemplo, si numero es igual a 3245, la división (numero/10) produce 324, aunque matemáticamente sea 324.5; es decir, se descarta la parte decimal. Algoritmo INICIO // Declaración de variables ENTERO numero, unidades // Entrada de datos LEER numero // Proceso de cálculo unidades = numero - (numero / 10) * 10 // Salida de resultados IMPRIMIR unidades FIN El algoritmo anterior, escrito en Java, queda así: import java.io.* ; class UnidadesNumero2 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: Informática I. Versión 1.0 Agosto de 2004. 94
- 95. Universidad Autónoma deOccidente BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: int num, unidades ; // Entrada de datos: System.out.print( "Digite un numero entero positivo: " ) ; num = Integer.parseInt( br.readLine( ) ) ; unidades = num - (num / 10) * 10 ; System.out.println( num + " tiene " + unidades + " como cifra de las unidades." ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase UnidadesNumero2 Salida: Ejercicio 6:- Diseñe un algoritmo que determine la suma de las cifras de un número entero positivo de 4 cifras. Solución 1 Análisis Las cifras pueden ser obtenidas mediante divisiones sucesivas entre 10. Para el efecto, considere el caso de un número N igual a 3245: unidades = N % 10 3245 | 10 cociente = N / 10 5 324 decenas = cociente % 10 324 | 10 cociente = cociente / 10 4 32 centenas = cociente % 10 32 | 10 millares = cociente / 10 2 3 Algoritmo INICIO // Declaración de variables ENTERO N, suma, millares, centenas, decenas, unidades // Entrada de datos Informática I. Versión 1.0 Agosto de 2004. 95
- 96. Universidad Autónoma deOccidente LEER N // Proceso de cálculo unidades = N % 10 cociente = N / 10 decenas = cociente % 10 cociente = cociente / 10 centenas = cociente % 10 millares = cociente/10 suma = unidades + decenas + centenas + millares // Salida de resultados IMPRIMIR suma FIN El algoritmo anterior, escrito en Java, queda así: import java.io.* ; class SumaCifrasNum1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: int num, unidades, decenas, centenas, millares, cociente, suma ; // Entrada de datos: System.out.print( "Digite un numero entero positivo de 4 cifras: " ) ; num = Integer.parseInt( br.readLine( ) ) ; // Proceso de cálculo: unidades = num % 10 ; cociente = num / 10 ; decenas = cociente % 10 ; cociente = cociente / 10 ; centenas = cociente % 10 ; millares = cociente / 10 ; suma = unidades + decenas + centenas + millares ; System.out.println( "Suma de las cifras del numero: " + suma ) ; Informática I. Versión 1.0 Agosto de 2004. 96
- 97. Universidad Autónoma deOccidente System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase SumaCifrasNum1 Salida: Solución 2 Análisis 2 Considerando que el número tiene 4 cifras, las cifras también pueden ser obtenidas mediante divisiones sucesivas entre 1000, 100 y 10. Para el efecto, considere el caso de un número N igual a 3245: millares = N / 1000 resto = N % 1000 3245 | 1000 245 3 centenas = resto / 100 245 | 100 resto = resto % 100 45 2 45 | 10 decenas = resto / 10 unidades = resto % 10 5 4 Algoritmo INICIO // Declaración de variables ENTERO N, suma, millares, centenas, decenas, unidades, resto // Entrada de datos LEER N // Proceso de cálculo millares = N / 1000 resto = N % 1000 centenas = resto / 100 resto = resto % 100 decenas = resto / 10 unidades = resto % 10 suma = unidades + decenas + centenas + millares // Salida de resultados IMPRIMIR suma FIN El algoritmo anterior, escrito en Java, queda así: import java.io.* ; class SumaCifrasNum2 { Informática I. Versión 1.0 Agosto de 2004. 97
- 98. Universidad Autónoma deOccidente public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: int num, unidades, decenas, centenas, millares, resto, suma ; // Entrada de datos: System.out.print( "Digite un numero entero positivo de 4 cifras: " ) ; num = Integer.parseInt( br.readLine( ) ) ; // Proceso de cálculo: millares = num / 1000 ; resto = num % 1000 ; centenas = resto / 100 ; resto = resto % 100 ; decenas = resto / 10 ; unidades = resto % 10 ; suma = unidades + decenas + centenas + millares ; System.out.println( "Suma de las cifras del numero: " + suma ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase SumaCifrasNum2 Salida: Ejercicio 7:- Diseñe un algoritmo que lea la hora actual del día HH:MM:SS y determine cuántas horas, minutos y segundos restan para culminar el día. Algoritmo INICIO // Declaración de variables ENTERO hor1, min1, seg1, hor2, min2, seg2, segres, resto Informática I. Versión 1.0 Agosto de 2004. 98
- 99. Universidad Autónoma deOccidente // Entrada de datos LEER hor1, min1, seg1 // Cálculo de la cantidad de segundos que restan para culminar el día segres = 86400 - (hor1 * 3600 + min1 * 60 + seg1) // Descomposición de segres en horas, minutos y segundos hor2 = segres / 3600 resto = segres % 3600 min2 = resto / 60 seg2 = resto % 60 // Salida de resultados IMPRIMIR hor2, min2, seg2 FIN Así queda en Java: import java.io.* ; class HmsQueFaltan1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: int hor1, min1, seg1, hor2, min2, seg2, segres, resto ; // Entrada de datos: System.out.print( "Digite la hora MILITAR actual (numero entero): " ) ; hor1 = Integer.parseInt( br.readLine( ) ) ; System.out.print( "Digite los minutos actuales (numero entero): " ) ; min1 = Integer.parseInt( br.readLine( ) ) ; System.out.print( "Digite los segundos actuales (numero entero): " ) ; seg1 = Integer.parseInt( br.readLine( ) ) ; // Proceso de cálculo. // ******************* // Cálculo de la cantidad de segundos que restan para culminar el día: segres = 86400 - (hor1 * 3600 + min1 * 60 + seg1) ; // Descomposición de segres en horas, minutos y segundos: hor2 = segres / 3600 ; resto = segres % 3600 ; min2 = resto / 60 ; seg2 = resto % 60 ; Informática I. Versión 1.0 Agosto de 2004. 99
- 100. Universidad Autónoma deOccidente // Salida de resultados System.out.println( "Para terminar el dia, hacen falta: " + hor2 + " horas, " + min2 + " minutos y " + seg2 + " segundos." ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase HmsQueFaltan1 Salida: Ejercicio 8:- Diseñe un algoritmo para sumar dos tiempos dados en horas, minutos y segundos. Algoritmo INICIO // Declaración de variables ENTERO hor1, min1, seg1, hor2, min2, seg2, hor3, min3, seg3, totseg, resto // Entrada de datos LEER hor1, min1, seg1, hor2, min2, seg2 // Determina la cantidad total de segundos entre los dos tiempos totseg = (hor1 + hor2) * 3600 + (min1 + min2) * 60 + (seg1 + seg2) // Descompone totseg en horas, minutos y segundos hor3 = totseg / 3600 resto = totseg % 3600 min3 = resto / 60 seg3 = resto % 60 // Salida de resultados IMPRIMIR hor3, min3, seg3 FIN Así queda en Java: import java.io.* ; class HmsQueFaltan2 { public static void main( String args[ ] ) throws IOException { Informática I. Versión 1.0 Agosto de 2004. 100
- 101. Universidad Autónoma deOccidente // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: int hor1, min1, seg1, hor2, min2, seg2, hor3, min3, seg3, totseg, resto ; // Entrada de datos: System.out.print( "Digite la primera hora (numero entero): " ) ; hor1 = Integer.parseInt( br.readLine( ) ) ; System.out.print( "Digite los minutos de la primera hora (numero entero): " ) ; min1 = Integer.parseInt( br.readLine( ) ) ; System.out.print( "Digite los segundos de la primera hora (numero entero): " ) ; seg1 = Integer.parseInt( br.readLine( ) ) ; System.out.println( "**********************************************" ) ; System.out.print( "Digite la segunda hora (numero entero): " ) ; hor2 = Integer.parseInt( br.readLine( ) ) ; System.out.print( "Digite los minutos de la segunda hora (numero entero): " ) ; min2 = Integer.parseInt( br.readLine( ) ) ; System.out.print( "Digite los segundos de la segunda hora (numero entero): " ) ; seg2 = Integer.parseInt( br.readLine( ) ) ; // Proceso de cálculo. // ******************* // Determina la cantidad total de segundos entre los dos tiempos: totseg = (hor1 + hor2) * 3600 + (min1 + min2) * 60 + (seg1 + seg2) ; // Descompone totseg en horas, minutos y segundos: hor3 = totseg / 3600 ; resto = totseg % 3600 ; min3 = resto / 60 ; seg3 = resto % 60 ; System.out.println( "**********************************************" ) ; // Salida de resultados System.out.println( "La suma de los dos tiempos da: " + hor3 + " horas, " + min3 + " minutos y " + seg3 + " segundos." ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase HmsQueFaltan2 Informática I. Versión 1.0 Agosto de 2004. 101
- 102. Universidad Autónoma deOccidente Salida: Ejercicio 9:- El sueldo neto de un vendedor se calcula como la suma de un sueldo básico de $2’500.000.oo más el 12% del monto total vendido. Diseñe un algoritmo que determine el sueldo neto de un vendedor sabiendo que hizo tres ventas en el mes. Algoritmo INICIO // Declaración de variables REAL venta1, venta2, venta3, ventatot, comision, sueldoneto // Entrada de datos LEER venta1, venta2, venta3 // Proceso de cálculo ventatot = venta1 + venta2 + venta3 comision = ventatot * 12 / 100 sueldoneto = 2500000 + comision // Salida de resultados IMPRIMIR sueldoneto FIN Así queda en Java: import java.io.* ; class SueldoNeto1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de una constante: final float $BASICO = 2500000 ; // Declaración de variables: float venta1, venta2, venta3, ventatot, comision, sueldoneto ; // Entrada de datos: Informática I. Versión 1.0 Agosto de 2004. 102
- 103. Universidad Autónoma deOccidente System.out.print( "Digite el valor de la primera venta: $ " ) ; venta1 = Float.parseFloat( br.readLine( ) ) ; System.out.print( "Digite el valor de la segunda venta: $ " ) ; venta2 = Float.parseFloat( br.readLine( ) ) ; System.out.print( "Digite el valor de la tercera venta: $ " ) ; venta3 = Float.parseFloat( br.readLine( ) ) ; // Proceso de cálculo: ventatot = venta1 + venta2 + venta3 ; comision = ventatot * 12 / 100 ; sueldoneto = $BASICO + comision ; System.out.println( "**********************************************" ) ; // Salida de resultados System.out.println( "Venta total: $ " + ventatot ) ; System.out.println( "Comision: $ " + comision ) ; System.out.println( "Sueldo neto: $ " + sueldoneto ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase SueldoNeto1 Salida: Nota: $ 1.2E7 = $ 1.2 x 10 7 = $ 12000000 Ejercicio 10:- Diseñe un algoritmo que determine el porcentaje de varones y de mujeres que hay en un salón de clases. Algoritmo INICIO // Declaración de variables REAL porcvar, porcmuj ENTERO varones, mujeres, total // Entrada de datos LEER varones, mujeres // Proceso de cálculo Informática I. Versión 1.0 Agosto de 2004. 103
- 104. Universidad Autónoma deOccidente total = varones + mujeres porcvar = varones * 100.0 / total porcmuj = mujeres * 100.0 / total // Salida de resultados IMPRIMIR porcvar, porcmuj FIN En Java: import java.io.* ; class MujHom1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: double porcvar, porcmuj ; int varones, mujeres, total ; // Entrada de datos: System.out.print( "Digite el numero de Damas: " ) ; mujeres = Integer.parseInt( br.readLine( ) ) ; System.out.print( "Digite el numero de Caballeros: " ) ; varones = Integer.parseInt( br.readLine( ) ) ; // Proceso de cálculo: total = varones + mujeres ; porcvar = varones * 100.0 / total ; porcmuj = mujeres * 100.0 / total ; System.out.println( "**********************************************" ) ; // Salida de resultados: System.out.println( "Porcentaje de mujeres: " + porcmuj + " %" ) ; System.out.println( "Porcentaje de hombres: " + porcvar + " %" ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase MujHom1 Salida: Informática I. Versión 1.0 Agosto de 2004. 104
- 105. Universidad Autónoma deOccidente Ejercicio 11:- En países de habla inglesa es común dar la estatura de una persona como la suma de una cantidad entera de pies más una cantidad entera de pulgadas. Así, la estatura de una persona podría ser 3' 2" ( 3 pies 2 pulgadas ). Diseñe un algoritmo que determine la estatura de una persona en metros, conociendo su estatura en el formato inglés. Considere que: 1 pie = 12 plg, 1 plg = 2.54 cm, 1 m = 100 cm. Algoritmo INICIO // Declaración de variables REAL estmt ENTERO cpies, cplgs // Entrada de datos LEER cpies, cplgs // Proceso de cálculo estmt = (cpies * 12 + cplgs) * 2.54 / 100 // Salida de resultados IMPRIMIR estmt FIN En Java: import java.io.* ; class EstaturaMts1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: int cpies, cplgs ; double estmt ; // Entrada de datos: System.out.print( "De la estatura, digite el numero (entero) de pies: " ) ; cpies = Integer.parseInt( br.readLine( ) ) ; System.out.print( "De la estatura, digite el numero (entero) de pulgadas: " ) ; cplgs = Integer.parseInt( br.readLine( ) ) ; Informática I. Versión 1.0 Agosto de 2004. 105
- 106. Universidad Autónoma deOccidente // Proceso de cálculo: estmt = (cpies * 12 + cplgs) * 2.54 / 100 ; System.out.println( "**********************************************" ) ; // Salida de resultados: System.out.println( "En metros, su estatura es: " + estmt + " mts." ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase EstaturaMts1 Salida: Ejercicio 12:- Diseñe un algoritmo que exprese la capacidad de un disco duro en megabytes, kilobytes y bytes, conociendo la capacidad del disco en gigabytes. Considere que: 1 kilobyte = 1024 bytes, 1 megabyte = 1024 kilobyte, 1 gigabyte = 1024 megabytes. Algoritmo INICIO // Declaración de variables REAL cgigabyte, cmegabyte, ckilobyte, cbyte // Entrada de datos LEER cgigabyte // Proceso de cálculo cmegabyte = cgigabyte * 1024 ckilobyte = cmegabyte * 1024 cbyte = ckilobyte * 1024 // Salida de resultados IMPRIMIR cmegabyte, ckilobyte, cbyte FIN En Java: Informática I. Versión 1.0 Agosto de 2004. 106
- 107. Universidad Autónoma deOccidente import java.io.* ; class CapacidadDiscoDuro1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: double cgigabyte, cmegabyte, ckilobyte, cbyte ; // Entrada de datos: System.out.print( "Digite la capacidad del Disco Duro en Gigabytes: " ) ; cgigabyte = Double.parseDouble( br.readLine( ) ) ; // Proceso de cálculo: cmegabyte = cgigabyte * 1024 ; ckilobyte = cmegabyte * 1024 ; cbyte = ckilobyte * 1024 ; System.out.println( "**********************************************" ) ; // Salida de resultados: System.out.println( "La capacidad del Disco Duro es: " + cmegabyte + " Megabytes,n" + ckilobyte + " Kilobytes yn" + cbyte + " Bytes." ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase CapacidadDiscoDuro1 Salida: Ejercicio 13:- Diseñe un algoritmo que intercambie las cifras de las unidades de dos números naturales. Algoritmo INICIO // Declaración de variables ENTERO numero1, numero2, unidades1, unidades2 Informática I. Versión 1.0 Agosto de 2004. 107
- 108. Universidad Autónoma deOccidente // Entrada de datos LEER numero1, numero2 // Determina las cifras de las unidades unidades1 = numero1 % 10 unidades2 = numero2 % 10 // Intercambia las cifras de las unidades numero1 = numero1 - unidades1 + unidades2 numero2 = numero2 - unidades2 + unidades1 // Salida de resultados IMPRIMIR numero1, numero2 FIN En Java: import java.io.* ; class IntercambiarUnidades1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: int numero1, numero2, unidades1, unidades2 ; // Entrada de datos: System.out.print( "Digite un numero entero positivo: " ) ; numero1 = Integer.parseInt( br.readLine( ) ) ; System.out.print( "Digite otro numero entero positivo: " ) ; numero2 = Integer.parseInt( br.readLine( ) ) ; // Proceso de cálculo: // ******************* // Determina las cifras de las unidades en cada número: unidades1 = numero1 % 10 ; unidades2 = numero2 % 10 ; // Intercambia solo las cifras de las unidades: numero1 = numero1 - unidades1 + unidades2 ; numero2 = numero2 - unidades2 + unidades1 ; System.out.println( "**********************************************" ) ; // Salida de resultados: System.out.println( "Despues de intercambiar la cifra de las unidades,n" + "los numeros quedan asi:nPrimer numero: " + numero1 + Informática I. Versión 1.0 Agosto de 2004. 108
- 109. Universidad Autónoma deOccidente "nSegundo numero: " + numero2 ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase IntercambiarUnidades1 Salida: Ejercicios sobre algoritmos 1.- ¿Defina qué es un algoritmo y cuales son sus características? 2.-¿Qué son y para qué sirven los diagramas de flujo? 3.-¿Qué es pseudocódigo? 4.-¿Cuales son los tipos de datos que existen? 5.- Diga cuál es máximo número que se puede representar con un entero sin signo de 2, 4 y 8 bytes. 6.- Defina cada uno de los operadores aritméticos, relacionales y lógicos. 7.- Defina los siguientes términos: Constante Variable Expresión 8.- Codifique en código Java las siguientes expresiones algebraicas: Informática I. Versión 1.0 Agosto de 2004. 109
- 110. Universidad Autónoma deOccidente 100 − 200 A2 a. b.15 − c. a 2 + b 2 − 35c d. 5 X 2 − 3X + 5 A−5 3 e. a + b 3 f . a 10 − 5 g. Coseno 2 (3X ) + Seno(Y ) 9.- Haga la secuencia de evaluación de la expresión algebraica que haría el computador para: (3 * 9 - 3 + 5/2 ) + 9 MOD 3 + (8 * 3 - 5) * (2/4) + (5 * 3 * 2 + 1) = 10.- Haga la codificación Java de la expresión algebraica: a 2 + b 2 58 − 3x − 54 = 3,4 x − 2,1y 11.- Evalúe el resultado para a = 7, b = 2, x = 2, y = 1. Ejercicios sobre algoritmos Secuenciales 1.- Diseñe un algoritmo que calcule el área de un triángulo en función de las longitudes de sus lados. área= p(p - a)(p - b)(p - c) donde p = (a+b+c)/2 = (semiperímetro) 2.- Elaborar un algoritmo que permita calcular el volumen de un cilindro (radio y altura se ingresan desde el teclado). (volumne cilindro => π radio 2 x altura) 3.- Haga un algoritmo que calcule a. Área de un circulo => Área = π r 2 b×h b. Área de un triángulo => Área = 2 4.- Diseñar un algoritmo a través del cual se pueda calcular la siguiente expresión algebraica : y1 − y 2 z= x1 − x 2 5.- Diseñe un algoritmo para la conversión una medida de metros a pies y pulgadas. 6.- Elabore un algoritmo que convierta una temperatura dada en centígrados a fahrenheit. Informática I. Versión 1.0 Agosto de 2004. 110
- 111. Universidad Autónoma deOccidente 7.- Dado un carácter alfabético en mayúsculas, elabore un algoritmo que imprima en pantalla su equivalente en minúscula (consulte el código ASCII). 8.- Hacer un algoritmo para calcular el IVA (16%) de un valor digitado por el teclado, mostrar este resultado y el de sumar el IVA al valor digitado. Ejemplo: valor digitado => 1000 mostrar en pantalla IVA = 160 y valor mas IVA = 1160 9.- Elabore un algoritmo para mostrar la cantidad de miles, centenas, decenas y unidades de un número entero digitado por teclado. Ejemplo: Sea 1483 el número digitado el algoritmo debe mostrar en pantalla Miles = 1 Centenas = 4 Decenas = 8 Unidades = 3 10.- Las funciones trigonométricas calculan sus valores para ángulos dados en unidades de radianes, haga un algoritmo que pase ángulos de grados a radianes, y calcule la tangente del ángulo convertido a radianes usando las funciones seno y coseno. 180 1 Radian = ; π = 3.141516 π 11.- Aplicando el teorema de Taylor a la función Seno se obtiene el siguiente polinomio que equivale a esa función: x x3 x5 x7 x9 Sen(x) = P(x) = − + − + − 1! 3! 5! 7! 9 ! 12.- Elabore un algoritmo para calcular el seno de un ángulo x usando este polinomio para siete (7) términos. 13.- Haga un algoritmo que convierta una medida de longitud en kilómetros a metros, centímetros, milímetros, pulgadas, yardas, millas y pies. 14.- Elabore un algoritmo que convierta una medida de masa en toneladas a kilogramos, quintales, gramos, libras. 15.- Realice un algoritmo que convierta unidades de fuerza en newtons a dinas. 16.- Elabore un algoritmo que convierta una unidad de presión en pascales a bares. 17.- Haga un algoritmo que calcule el área de una cara de un cubo y su volumen. Informática I. Versión 1.0 Agosto de 2004. 111
- 112. Universidad Autónoma deOccidente 3 18.- Elabore un algoritmo que convierta una unidad de volumen en metros cúbicos m a litros y centímetros cúbicos. 19.- Lea dos puntos (x, y) y calcule la distancia entre ellos. 20.- Los siguientes son los múltiplos y submúltiplos decimales (ver tabla), elabore un algoritmo que lea un número dado en unidades y lo muestre en cada uno de sus múltiplos y submúltiplos por pantalla. Símbolo Unidades tera T 1.000.000.000.0 giga G 1.000.000.000 mega M 1.000.000 kilo K 1.000 hecto H 100 deca Da 10 unidad 1 deci D 0.1 centi C 0.01 mili M 0.001 micro µ 0.000.001 nano N 0.000.000.001 pico P 0.000.000.000.01 21.- Elabore un algoritmo que convierta una medición de tiempo en segundos a horas, minutos y segundos. 1 hora = 60 minutos 1 minuto = 60 segundos Ejemplo: sea 34505 la cantidad digitada en segundos se debe mostrar en pantalla Horas = 9 Minutos = 35 Segundos = 5 Informática I. Versión 1.0 Agosto de 2004. 112
- 113. Universidad Autónoma deOccidente UNIDAD 6. SENTENCIAS DE CONTROL EN JAVA Introducción Los algoritmos vistos hasta el momento han consistido en simples secuencias de instrucciones; sin embargo, existen tareas más complejas que no pueden ser resueltas empleando un esquema tan sencillo, en ocasiones es necesario repetir una misma acción un número determinado de veces o evaluar una expresión y realizar acciones diferentes en base al resultado de dicha evaluación. Para resolver estas situaciones existen las denominadas estructuras de control que poseen las siguientes características: • Una estructura de control tiene un único punto de entrada y un único punto de salida. • Una estructura de control se compone de sentencias o de otras estructuras de control. Tales características permiten desarrollar de forma muy flexible todo tipo de algoritmos aún cuando sólo existen tres tipos fundamentales de estructuras de control: • Secuencial. • Alternativa. • Repetitiva. A lo largo de esta lección se presentarán las distintas estructuras de control, la forma de representarlas en la notación algorítmica y las correspondientes sentencias FORTRAN para poder utilizarlas en nuestros programas. Estructura secuencial La estructura secuencial es la más sencilla de todas, simplemente indica al procesador que debe ejecutar de forma consecutiva una lista de acciones (que pueden ser, a su vez, otras estructuras de control); para construir una secuencia de acciones basta con escribir cada acción en una linea diferente. A continuación se muestra una composición secuencial de acciones en notación algorítmica y su equivalente JAVA. leer a leer b c a+b escribir c Dado que las variables numéricas a y b ya estuvieran declaradas y hayan sido leídas, entonces las dos últimas instrucciones se escriben así en Java: c=a+b; System.out.println( “Valor de c= “ + c ) ; A continuación, la implementación en Java con su correspondiente salida: import java.io.* ; // Importa el paquete de entrada / salida (input / output) Informática I. Versión 1.0 Agosto de 2004. 113
- 114. Universidad Autónoma deOccidente class EstructuraSecuencial1 { // Mètodo principal: public static void main( String args[ ] ) throws IOException { BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; double a, b, c; // Declaración de las variables reales a, b y c. // Lectura, vía teclado, de las variables a y b: System.out.print( "Digite el valor de la variable a: " ) ; a = Double.parseDouble( br.readLine( ) ) ; System.out.print( "Digite el valor de la variable b: " ) ; b = Double.parseDouble( br.readLine( ) ) ; // suma los valores de las variables a y b y lo asigna o // guarda en la variable c: c=a+b; // Muestra el valor de c: System.out.println( " a + b = " + c ) ; System.exit( 0 ) ; // Termine el programa (salir del sistema) } // Fin del método main( ) } // Fin de la clase EstructuraSecuencial1 Existe una forma alternativa de expresar una estructura secuencial escribiendo varias acciones en la misma línea pero utilizando el punto y coma ( ; ) como separador. Sin embargo, esta última notación es desaconsejable puesto que puede llegar a hacer el código bastante difícil de leer. leer a; leer b c a + b; escribir c Dado que las variables numéricas a y b ya estuvieran declaradas y hayan sido leídas, entonces las dos últimas instrucciones se escriben así en Java: c = a + b ; System.out.println( “Valor de c= “ + c ) ; En Java: import java.io.* ; // Importa el paquete de entrada / salida (input / output) class EstructuraSecuencial2 { public static void main( String args[ ] ) throws IOException { BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Lectura, vía teclado, de las variables a y b: System.out.print( "Digite el valor de la variable a: " ) ; double a = Double.parseDouble( br.readLine( ) ) ; System.out.print( "Digite el valor de la variable b: " ) ; double b = Informática I. Versión 1.0 Agosto de 2004. 114
- 115. Universidad Autónoma deOccidente Double.parseDouble( br.readLine( ) ) ; // Calcule c y muéstrelo: double c = a + b ; System.out.println( " a + b = " + c ) ; System.exit( 0 ) ; // Termine el programa (salir del sistema) } // Fin del método main( ) } // Fin de la clase EstructuraSecuencial2 Por último, es necesario señalar un aspecto importante de la composición secuencial y es que no es conmutativa. Estructura alternativa La estructura alternativa permite bifurcar el “flujo” del programa en función de una expresión lógica; disponemos de tres estructuras alternativas diferentes: alternativa simple, alternativa doble y alternativa múltiple. Estructura alternativa simple Esta estructura permite evaluar una expresión lógica y en función de dicha evaluación ejecutar una acción (o composición de acciones) o no ejecutarla; también se la suele denominar SI-ENTONCES. A continuación se muestra la notación algorítmica y JAVA para la estructura alternativa simple. si <expresión lógica> entonces acciones En java es: fin_si if ( <expresión lógica> ) { acciones } Informática I. Versión 1.0 Agosto de 2004. 115
- 116. Universidad Autónoma deOccidente En el siguiente ejemplo se calcula la longitud de una circunferencia si el radio es positivo no nulo: si radio > 0 entonces longitud = 2 * PI * radio fin_si En Java: if ( radio > 0 ) { longitud = 2 * Math.PI * radio ; } Estructura alternativa doble La estructura alternativa doble es similar a la anterior con la salvedad de que en este tipo de estructura se indican acciones no sólo para la rama “verdadera” sino también para la “falsa”; es decir, en caso de que la expresión lógica evaluada sea cierta se ejecutan una acción o grupo de acciones y en el caso de que sea falsa se ejecuta un grupo diferente de acciones. La sintáxis en la notación algorítmica y en JAVA son las que se muestran a continuación: si <expresión lógica> entonces acciones si no acciones fin_si En java es: if ( <expresión lógica> ) { acciones } else { acciones } En el siguiente ejemplo se calcula la longitud de una circunferencia si el radio es positivo no nulo y, en caso contrario, se proporciona un mensaje de error: si radio>0 entonces longitud = 2·pi·radio si no escribir ‘Radio incorrecto’ fin_si Informática I. Versión 1.0 Agosto de 2004. 116
- 117. Universidad Autónoma deOccidente En Java: if ( radio > 0 ) { longitud = 2 * Math.PI * radio ; } else { System.out.println( “Error” ) ; } Ejemplo:- Informar si un estudiante ha superado o no un determinado examen consistente en 20 preguntas de igual valor y calcular su nota en caso de aprobar. leer num_correctas si num_correctas < 12 entonces escribir “No ha superado Vd. el examen” faltan = 12 - num_correctas escribir “Le faltaron ” , faltan si_no nota = num_correctas * 0.25 escribir “aprobó Vd. con un ”, nota fin_si En Java: import java.io.* ; class AprobarExamen1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: String nombre ; int numOk, faltan ; float nota ; // Entrada de datos: System.out.print( "Digite su nombre : " ) ; nombre = br.readLine( ) ; System.out.print( "Digite el numero de respuestas correctas (1 a 20): " ) ; numOk = Integer.parseInt( br.readLine( ) ) ; // Sentencia de decisión if: // ************************* if( numOk < 12 ) { System.out.println( nombre + ", Ud. NO ha ganado el examen!!" ) ; faltan = 12 - numOk ; System.out.println( "Le faltaron " + faltan + " respuestas correctas para obtener 3.0 !!" ) ; } else { nota = numOk * 0.25F ; Informática I. Versión 1.0 Agosto de 2004. 117
- 118. Universidad Autónoma deOccidente System.out.println( nombre + ", Ud. ha ganado el examen con " + "una nota de " + nota ) ; } System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase AprobarExamen1 Salida: Estructura multialternativa Esta estructura evalúa una expresión que pueda tomar n valores (enteros, caracteres y lógicos pero nunca reales) y ejecuta una acción o grupo de acciones diferente en función del valor tomado por la expresión selectora. La sintaxis de esta estructura es la siguiente: segun expresión caso valor1: acción 1 caso valor2: acción 2 ... caso valorN: acción n otro caso: acción fin según Informática I. Versión 1.0 Agosto de 2004. 118
- 119. Universidad Autónoma deOccidente La implementación de la estructura multialternativa se escribe así, en Java: switch( expresión ) { // Llave de apertura del bloque switch case valor1: // Acción 1: secuencia de instrucciones break ; case valor2: // Acción 2: secuencia de instrucciones break ; … … … case valorN: // Acción N: secuencia de instrucciones break ; default: // El caso default: es opcional // Acción: secuencia de instrucciones break ; // Aquí, el break ; es opcional, pues es la última del bloque switch } // Llave de cierre del bloque switch En el siguiente ejemplo se proporciona como salida el número de días de un mes dado: segun mes caso 1,3,5,7,8,10,12: escribir ‘31’ caso 4,6,9,11: escribir ‘30’ caso 2: escribir ‘28’ otro caso: escribir ‘Mes incorrecto’ fin según A continuación, la implementación en Java: import java.io.* ; // Importa el paquete de entrada / salida (input / output) class EstructuraMultialternativa1_switch { // Método principal: public static void main( String args[ ] ) throws IOException { BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; int mes ; // Declaración de la variable entera mes // Lectura, vía teclado, de la variable entera mes System.out.print( "Digite un numero entero [1 a 12] para el mes: " ) ; mes = Integer.parseInt( br.readLine( ) ) ; // Se utilizará una instrucción switch para determinar el número de // días del mes digitado (número entero de 1 a 12): Informática I. Versión 1.0 Agosto de 2004. 119
- 120. Universidad Autónoma deOccidente switch( mes ) { // LLave de apertura del switch case 1: case 3: case 5: case 7: case 8: case 10: case 12: System.out.println( "El mes " + mes + " tiene 31 dias." ) ; break ; case 4: case 6: case 9: case 11: System.out.println( "El mes " + mes + " tiene 30 dias." ) ; break ; case 2: System.out.println( "Si el anio NO es bisiesto, el mes " + mes + " tiene 28 dias." ) ; System.out.println( "Si el anio es bisiesto, el mes " + mes + " tiene 29 dias." ) ; break ; default: System.out.println( "ERROR al digitar el numero para el mes" ) ; break ; // Aquí, este break; es opcional. } //LLave de cierre del switch System.exit( 0 ) ; // Termine el programa (salir del sistema) } // Fin del método main( ) } // Fin de la clase EstructuraSecuencial1 Nota: Obsérvese que es posible que un caso conste de múltiples valores. Informática I. Versión 1.0 Agosto de 2004. 120
- 121. Universidad Autónoma deOccidente Estructura repetitiva La estructura repetitiva o iterativa permite, como su propio nombre lo indica, repetir una acción (o grupo de acciones); dicha repetición puede llevarse a cabo un número prefijado de veces o depender de la evaluación de una expresión lógica. Existen tres tipos de estructuras repetitivas: desde-hasta (ó Para), mientras y repetir-hasta. Estructura desde-hasta (ó Para) Esta estructura permite repetir la ejecución de una acción o de un grupo de acciones un número determinado de veces; la sintáxis es la siguiente: desde indice = inicio hasta fin [con valor de paso] hacer acción fin desde La estructura repetitiva desde-hasta (ó Para) se implementa así, en Java: for( inicialización; condición; iteración ) { // Acción: secuencia de instrucciones } 1. El ciclo (ó bucle) for es controlado por una variable que, por su oficio, también se denomina variable de control. 2. En su forma más común, la parte de inicialización del ciclo asigna un valor inicial a la variable de control del ciclo. 3. La condición es una expresión booleana que analiza la variable de control del ciclo. Si el resultado de ese análisis es true (verdadero), el ciclo for continúa. Si es false (falso), el ciclo termina. 4. La expresión iteración determina cómo cambia el valor de la variable de control del ciclo en cada iteración del mismo. A continuación se muestran algunos ejemplos: Seudocódigo: desde n 1 hasta 10 hacer escribir n fin desde Código Java: for( int n = 1; n <= 10; n = n + 1 ) { System.out.println( “n = “ + n ) ; } El ciclo anterior imprime por pantalla los números del 1 al 10. Ahora, preste atención al siguiente seudocódigo: desde n 10 hasta 0 hacer escribir n Informática I. Versión 1.0 Agosto de 2004. 121
- 122. Universidad Autónoma deOccidente fin desde que, escrito en código Java, es: for( int n = 10; n <= 0; n = n + 1 ) { System.out.println( “n = “ + n ) ; } El bucle anterior no se ejecuta nunca puesto que, de entrada, la condición n <= 0 (con n = 10) arroja false. ¿Qué ocurriría si, en el ciclo anterior, se cambia < por > ? Analice y responda !! Si queremos hacer lo anterior, por ejemplo con paso – 2, el seudocódigo se puede escribir así: desde n 10 hasta 0 con paso –2 hacer escribir n fin desde que, escrito en Java, es: for( int n = 10; n >= 0; n = n - 2 ) { System.out.println( “n = “ + n ) ; } Este bucle escribe los números pares de 10 a 0 en orden inverso. La siguiente aplicación Java resume estos casos: class CicloFor1 { public static void main( String args[ ] ) { int n ; // Declara la variable entera n. Ésta, // será la variable de control del ciclo. // Ciclo for con paso unitario positivo: for( n = 1; n <= 10; n = n + 1 ) { System.out.print( n + ", " ) ; } System.out.println( "n Ahora, el ciclo for con el paso negativo (-2):" ) ; // Ciclo for con paso negativo (-2): for( n = 10; n >= 0; n = n - 2 ) { System.out.print( n + ", " ) ; } System.out.println( ) ; System.exit( 0 ) ; } } Informática I. Versión 1.0 Agosto de 2004. 122
- 123. Universidad Autónoma deOccidente Salida: Estructura mientras (while) Esta estructura repite una acción o grupo de acciones mientras una expresión lógica sea cierta; la sintáxis en la notación algorítmica y en JAVA es la siguiente: mientras <expresión lógica> hacer acción fin mientras Así queda en Java: while( <Condición> ) { // Acción: conjunto de // instrucciones que conforman el // cuerpo del ciclo. } Un aspecto muy importante de la presente estructura de control es que si la expresión lógica es inicialmente falsa el bucle no se ejecuta ni una sola vez; es decir, la estructura mientras supone que el bucle iterará 0 ó más veces. A continuación se muestra un ejemplo que solicita al usuario el radio de una circunferencia mientras el radio introducido sea incorrecto: mientras radio<0 hacer escribir ‘Radio?’ leer radio fin desde En Java: import java.io.* ; // Importa el paquete de entrada / salida (input / output) class EstructuraMientras1 { // Método principal: public static void main( String args[ ] ) throws IOException { BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; double radio ; // Declaración de la variable real radio // Lectura, vía teclado, de la variable radio: System.out.print( "Digite el valor del radio (cm): " ) ; radio = Double.parseDouble( br.readLine( ) ) ; System.out.println( "Radio antes del ciclo: " + radio ) ; Informática I. Versión 1.0 Agosto de 2004. 123
- 124. Universidad Autónoma deOccidente System.out.println( "*******************************" ) ; while( radio < 0 ) { // LLave de apertura del bloque while // Lee de nuevo, vía teclado, el radio: System.out.print( "Digite el valor [ >= 0 ] del radio (cm): " ) ; radio = Double.parseDouble( br.readLine( ) ) ; System.out.println( "Radio dentro del ciclo: " + radio ) ; } // LLave de cierre del bloque while System.out.println( "*******************************" ) ; // Muestra el último valor del radio: System.out.println( "Ultimo valor del radio: " + radio ) ; System.exit( 0 ) ; // Termine el programa (salir del sistema) } // Fin del método main( ) } // Fin de la clase EstructuraMientras1 Notar que mientras radio < 0 el ciclo se ejecuta. Ahora, note en la siguiente salida, que si desde la primera vez se digita un radio positivo, entonces el ciclo while no se ejecuta: Estructura haga-mientras (do-while) Esta estructura repite una acción o grupo de acciones mientras una expresión lógica sea verdadera. La sintáxis en la notación algorítmica es la siguiente: haga Así queda en Java: acción do { mientras <expresión lógica> // Acción: conjunto de // instrucciones que conforman el // cuerpo del ciclo. } while( <Condición> ) ; Informática I. Versión 1.0 Agosto de 2004. 124
- 125. Universidad Autónoma deOccidente Un aspecto muy importante de la presente estructura de control es que la expresión lógica se evalúa al final; por tanto, el bucle se ejecuta al menos una vez, como una alternativa a la estructura anterior (while), la cual podría nunca ejecutarse. El siguiente diagrama de flujo ilustra el ciclo haga-mientras: Punto de entrada Acción Verdadero Expresión lógica Falso Punto de salida Se aplicará la estructura de control do-while del lenguaje de programación Java, en la implementación de un sencillo menú: import java.io.*; class Menu3 { public static void main( String args[] ) throws IOException { BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; int opcion; do { System.out.println( " Opciones del menu:" ) ; System.out.println( " ******************" ) ; System.out.println( ) ; System.out.println( " 1.- Opcion 1" ) ; System.out.println( " 2.- Opcion 2" ) ; System.out.println( " 3.- Opcion 3" ) ; System.out.println( " 4.- Opcion 4" ) ; System.out.println( " 5.- Terminar" ) ; System.out.println( ) ; System.out.print( "n Ingrese su opcion: " ) ; Informática I. Versión 1.0 Agosto de 2004. 125
- 126. Universidad Autónoma deOccidente opcion = Integer.parseInt( br.readLine( ) ) ; } while( opcion < 1 || opcion > 5 ) ; switch( opcion ) { case 1: case 2: case 3: case 4: System.out.println( "nUsted ha seleccionado la opcion No. " + opcion ) ; break; case 5: System.out.println( "nUsted ha seleccionado Terminarn" ) ; System.exit( 0 ); } //Fin del switch } //Fin del main( ) }//Fin de la clase Menu3 A continuación, la salida: Informática I. Versión 1.0 Agosto de 2004. 126
- 127. Universidad Autónoma deOccidente Ejercicios Resueltos Ejercicio 1:- En una playa de estacionamiento cobran $ 2.5 por hora o fracción. Diseñe un algoritmo que determine cuánto debe pagar un cliente por el estacionamiento de su vehículo, conociendo el tiempo de estacionamiento en horas y minutos. Algoritmo 1 INICIO // Declaración de variables ENTERO horas, minutos REAL pago // Entrada de datos LEER horas, minutos // Si hay alguna fracción de hora, incrementa las horas a pagar en una unidad SI( minutos > 0 ) horas = horas + 1 // Determina el importe a pagar pago = horas * 2.5 // Salida de resultados IMPRIMIR pago FIN Así queda en Java: import java.io.* ; class CobroEstacionamiento1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: int horas, minutos ; float pago ; // Entrada de datos: System.out.print( "Digite el numero [entero] de horas: " ) ; horas = Integer.parseInt( br.readLine( ) ) ; System.out.print( "Digite el numero de minutos [0 a 59]: " ) ; minutos = Integer.parseInt( br.readLine( ) ) ; // Si hay alguna fracción de hora, incrementa las horas a // pagar en una unidad: if( minutos > 0 ) { Informática I. Versión 1.0 Agosto de 2004. 127
- 128. Universidad Autónoma deOccidente horas += 1 ; // Equivalente a: horas = horas + 1 ; } // Determina el importe a pagar: pago = (float) (horas * 2.5) ; // Promocione a (casting) tipo float // Salida de resultados: System.out.println( "Valor a pagar: $" + pago ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase CobroEstacionamiento1 Salida: Algoritmo 2 INICIO // Declaración de variables ENTERO horas, minutos, horasPagar REAL pago // Entrada de datos LEER horas, minutos // Determina el número de horas a pagar SI( minutos > 0 ) horasPagar = horas + 1 SINO horasPagar = horas // Determina el importe a pagar pago = horasPagar * 2.5 // Salida de resultados IMPRIMIR pago FIN En Java queda así: import java.io.* ; Informática I. Versión 1.0 Agosto de 2004. 128
- 129. Universidad Autónoma deOccidente class CobroEstacionamiento2 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: int horas, minutos, horasPagar ; float pago ; // Entrada de datos: System.out.print( "Digite el numero [entero] de horas: " ) ; horas = Integer.parseInt( br.readLine( ) ) ; System.out.print( "Digite el numero de minutos [0 a 59]: " ) ; minutos = Integer.parseInt( br.readLine( ) ) ; // Determina el número de horas a pagar: if( minutos > 0 ) { horasPagar = horas + 1 ; } else { horasPagar = horas ; } // Determina el importe a pagar: pago = (float) (horasPagar * 2.5) ; // Promocione a (casting) tipo float // Salida de resultados: System.out.println( "Valor a pagar: $" + pago ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase CobroEstacionamiento2 Salida: Informática I. Versión 1.0 Agosto de 2004. 129
- 130. Universidad Autónoma deOccidente Ejercicio 2:- Diseñe un algoritmo que determine si ún número es o no es, par positivo. Algoritmo INICIO // Declaración de variables REAL numero CADENA tipoNumero // Entrada de datos LEER numero // Determina si el número es o no es, par positivo SI( (numero %2 ==0) && (numero > 0) ) tipoNumero = "El número es par positivo" SINO tipoNumero = "El número no es par positivo" // Salida de resultados IMPRIMIR tipoNumero FIN Así queda en Java: import java.io.* ; class EsParPositivo1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: float numero ; String tipoNumero ; // Entrada de datos: System.out.print( "Digite un numero: " ) ; numero = Float.parseFloat( br.readLine( ) ) ; // Determina si el número es o no es, par positivo: if( (numero %2 ==0) && (numero > 0) ) { tipoNumero = "El numero es par positivo" ; } Informática I. Versión 1.0 Agosto de 2004. 130
- 131. Universidad Autónoma deOccidente else { tipoNumero = "El numero NO es par positivo" ; } // Salida de resultados: System.out.println( tipoNumero ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase EsParPositivo1 Salida: Ejercicio 3:- Diseñe un algoritmo que lea tres números y determine el número mayor. Algoritmo INICIO // Declaración de variables REAL numero1, numero2, numero3, numeroMayor // Entrada de datos LEER numero1, numero2, numero3 // Determina el mayor numeroMayor = numero1 SI( numero2 > numeroMayor ) numeroMayor = numero2 SI( numero3 > numeroMayor ) numeroMayor = numero3 // Salida de resultados Informática I. Versión 1.0 Agosto de 2004. 131
- 132. Universidad Autónoma deOccidente IMPRIMIR numeroMayor FIN Así queda en Java: import java.io.* ; class NumMay1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: float numero1, numero2, numero3, numeroMayor ; // Entrada de datos: System.out.print( "Digite el primer numero: " ) ; numero1 = Float.parseFloat( br.readLine( ) ) ; System.out.print( "Digite el segundo numero: " ) ; numero2 = Float.parseFloat( br.readLine( ) ) ; System.out.print( "Digite el tercer numero: " ) ; numero3 = Float.parseFloat( br.readLine( ) ) ; // Determina el número mayor: numeroMayor = numero1 ; if( numero2 > numeroMayor ) numeroMayor = numero2 ; if( numero3 > numeroMayor ) numeroMayor = numero3 ; // Salida de resultados: System.out.println( "Numero mayor = " + numeroMayor ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase NumMay1 Salida: Informática I. Versión 1.0 Agosto de 2004. 132
- 133. Universidad Autónoma deOccidente Ejercicio 4:- Una tienda ha puesto en oferta la venta al por mayor de cierto producto, ofreciendo un descuento del 15% por la compra de más de 3 docenas y 10% en caso contrario. Además por la compra de más de 3 docenas se obsequia una unidad del producto por cada docena en exceso sobre 3. Diseñe un algoritmo que determine el monto de la compra, el monto del descuento, el monto a pagar y el número de unidades de obsequio por la compra de cierta cantidad de docenas del producto. Algoritmo INICIO // Declaración de variables REAL montopag, montocom, montodes, precio ENTERO docenas, obsequio // Entrada de datos LEER docenas, precio // Determina el monto de la compra montocom = docenas * precio // Determina el monto del descuento y el obsequio SI( docenas > 3 ) { montodes = 0.15 * montocom obsequio = docenas - 3 } SINO { montodes = 0.10*montocom obsequio = 0 } // Determina el monto a pagar montopag = montocom - montodes // Salida de resultados IMPRIMIR montocom, montodes, montopag, obsequio FIN Así queda en Java: import java.io.* ; class OfertaDocenasProducto1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: float montopag, montocom, montodes, precio ; int docenas, obsequio ; Informática I. Versión 1.0 Agosto de 2004. 133
- 134. Universidad Autónoma deOccidente // Entrada de datos: System.out.print( "Digite el precio de la docena del producto: $ " ) ; precio = Float.parseFloat( br.readLine( ) ) ; System.out.print( "Cuantas docenas del producto has comprado? " ) ; docenas = Integer.parseInt( br.readLine( ) ) ; // Determina el monto (ó valor) de la compra: montocom = docenas * precio ; // Determina el monto del descuento y el obsequio: if( docenas > 3 ) { montodes = 0.15f * montocom ; obsequio = docenas - 3 ; } else { montodes = 0.10f * montocom ; obsequio = 0 ; } // Determina el monto a pagar montopag = montocom - montodes ; // Salida de resultados: System.out.println( "Valor de la compra: $ " + montocom ) ; System.out.println( "Valor del descuento: $ " + montodes ) ; System.out.println( "Neto a pagar: $ " + montopag ) ; System.out.println( "Por su compra, se le ha obsequiado: " + obsequio + " docenas." ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase OfertaDocenasProducto1 Salida: Informática I. Versión 1.0 Agosto de 2004. 134
- 135. Universidad Autónoma deOccidente Ejercicio 5:- Diseñe un algoritmo que lea un número de tres cifras y determine si es o no capicúa. Un número es capicúa si es igual al revés del número. Observación Como el número tiene tres cifras, para ser capicúa basta con que la cifra de las unidades sea igual a la cifra de las centenas. Por ejemplo: 353, 878, etc. Algoritmo INICIO // Salida de resultados ENTERO numero, unidades, centenas CADENA tipoNumero // Entrada de datos LEER numero // Si el número tiene tres cifras... SI(numero >= 100 && numero <= 999 ){ // Determina la cifra de las unidades y la cifra de las centenas unidades = numero % 10 centenas = numero / 100 // Determina el tipo de número entre capicúa o no capicúa SI( unidades == centenas ) tipoNumero = "El número es capicúa" SINO tipoNumero = "El número no es capicúa" // Muestra el tipo de número IMPRIMIR tipoNumero } SINO IMPRIMIR "Ingrese un número de tres cifras" FIN Así queda en Java: import java.io.* ; class Capicua1 { public static void main( String args[ ] ) throws IOException { Informática I. Versión 1.0 Agosto de 2004. 135
- 136. Universidad Autónoma deOccidente // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Como el número tiene tres cifras, para ser capicúa basta con que // la cifra de las unidades sea igual a la cifra de las centenas. // Por ejemplo: 353, 878, etc. // Declaración de variables: int numero, unidades, centenas ; String tipoNumero ; // Entrada de datos: System.out.print( "Digite un numero entero de tres cifras: " ) ; numero = Integer.parseInt( br.readLine( ) ) ; // Si el número tiene tres cifras: if(numero >= 100 && numero <= 999 ){ // Determina la cifra de las unidades y la cifra de las centenas: unidades = numero % 10 ; centenas = numero / 100 ; // Determina el tipo de número entre capicúa o no capicúa: if( unidades == centenas ) tipoNumero = "El numero es capicua" ; else tipoNumero = "El numero no es capicua" ; // Muestra el tipo de número System.out.println( tipoNumero ) ; } else System.out.println( "El numero ingresado debe tener tres cifras!!" ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase Capicua1 Salida: Informática I. Versión 1.0 Agosto de 2004. 136
- 137. Universidad Autónoma deOccidente Ejercicio 6:- Diseñe un algoritmo que califique el puntaje obtenido en el lanzamiento de tres dados con base a la cantidad de 6s obtenidos, de acuerdo a lo siguiente: tres seis, excelente; dos seis, bien; un seis, regular; ningún seis, mal. Algoritmo INICIO // Declaración de variables ENTERO dado1, dado2, dado3 CADENA calificacion // Entrada de datos LEER dado1, dado2, dado3 // Determina la calificación SI( dado1 + dado2 + dado3 == 18 ) calificacion = "Excelente" SINO SI( dado1 + dado2 == 12 || dado2 + dado3 == 12 || dado3 + dado1 == 12 ) calificacion = "Bién" SINO SI( dado1 == 6 || dado2 == 6 || dado3 == 6 ) calificacion = "Regular" SINO calificacion = "Mal" // Salida de resultados IMPRIMIR calificacion FIN Así queda en Java: import java.io.* ; class LanzarTresDados1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de variables: Informática I. Versión 1.0 Agosto de 2004. 137
- 138. Universidad Autónoma deOccidente int dado1, dado2, dado3 ; String calificacion ; // Entrada de datos: System.out.print( "Digite el numero de puntos del primer dado: " ) ; dado1 = Integer.parseInt( br.readLine( ) ) ; System.out.print( "Digite el numero de puntos del segundo dado: " ) ; dado2 = Integer.parseInt( br.readLine( ) ) ; System.out.print( "Digite el numero de puntos del tercer dado: " ) ; dado3 = Integer.parseInt( br.readLine( ) ) ; // Determina la calificación: if( dado1 + dado2 + dado3 == 18 ) calificacion = "Excelente" ; else if( dado1 + dado2 == 12 || dado2 + dado3 == 12 || dado3 + dado1 == 12 ) calificacion = "Bien" ; else if( dado1 == 6 || dado2 == 6 || dado3 == 6 ) calificacion = "Regular" ; else calificacion = "Mal" ; // Salida de resultados System.out.println( calificacion ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase LanzarTresDados1 Salida: Informática I. Versión 1.0 Agosto de 2004. 138
- 139. Universidad Autónoma deOccidente Ejercicio 7:- Una compañía dedicada al alquiler de automóviles cobra un monto fijo de $ 30 para los primeros 300 km de recorrido. Para más de 300 km y hasta 1000 km, cobra un monto adicional de $ 0.15 por cada kilómetro en exceso sobre 300. Para más de 1000 km cobra un monto adicional de $ 0.10 por cada kilómetro en exceso sobre 1000. Los precios ya incluyen el 18% del impuesto general a las ventas, IGV. Diseñe un algoritmo que determine el monto a pagar por el alquiler de un vehículo y el monto incluído del impuesto. Algoritmo INICIO // Declaración de variables REAL kilomrec, montopag, montoigv, montofijo = 30, igv = 0.18 // Entrada de datos LEER kilomrec // Determina el monto a pagar SI( kilomrec <= 300 ) montopag = montofijo SINO SI( kilomrec <= 1000 ) montopag = montofijo + 0.15 * (kilomrec - 300) SINO montopag = montofijo + 0.15 * 700 + 0.10 * (kilomrec - 1000) // Según el enunciado, para determinar el monto del impuesto (montoigv) tenga en // cuenta que: x + igv * x = montopag, de donde x = montopag / (1 + igv). // Entonces montoigv = igv * x = igv * montopag / (1 + igv); o sea: montoigv = igv * montopag / (1 + igv) // Salida de resultados IMPRIMIR montopag, montoigv FIN Así queda en Java: import java.io.* ; class AlquilerAutos1 { public static void main( String args[ ] ) throws IOException { // Creación del objeto br de la clase BufferedReader para invocar el // método readLine( ) que lee datos ingresados vía teclado: BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; // Declaración de dos constantes: Informática I. Versión 1.0 Agosto de 2004. 139
- 140. Universidad Autónoma deOccidente final double MONTOFIJO = 30, IGV = 0.18 ; // Declaración de variables: double kilomrec, montopag, montoigv ; // Entrada de datos: System.out.print( "Digite el numero de kilometros recorridos: " ) ; kilomrec = Double.parseDouble( br.readLine( ) ) ; // Determina el monto a pagar: if( kilomrec <= 300 ) montopag = MONTOFIJO ; else if( kilomrec <= 1000 ) montopag = MONTOFIJO + 0.15 * (kilomrec - 300) ; else montopag = MONTOFIJO + 0.15 * 700 + 0.10 * (kilomrec - 1000) ; // Según el enunciado, para determinar el monto del impuesto (montoigv) tenga en // cuenta que: x + IGV * x = montopag, de donde x = montopag / (1 + IGV). // Entonces montoigv = IGV * x = IGV * montopag / (1 + IGV); o sea: montoigv = IGV * montopag / (1 + IGV) ; // Salida de resultados System.out.println( "Valor a pagar: $ " + montopag ) ; System.out.println( "Por impuesto, Ud. ha pagado $ " + montoigv ) ; System.exit( 0 ) ; } //Fin del método main( ) } // Fin de la clase AlquilerAutos1 Salida: Informática I. Versión 1.0 Agosto de 2004. 140
- 141. Universidad Autónoma deOccidente Ejercicio 8:- Diseñe un algoritmo que determine quiénes son contemporáneos entre Juan, Mario y Pedro. Algoritmo INICIO // Declaración de variables ENTERO juan, mario, pedro CADENA contemporaneos // Entrada de datos LEER juan, mario, pedro // Determina quienes son contemporáneos SI( juan == mario && mario == pedro ) contemporaneos = "Los tres son contemporáneos" SINO SI( juan == mario ) contemporaneos = "Juan y Mario son contemporáneos" SINO SI( juan == pedro ) contemporaneos = "Juan y Pedro son contemporáneos" SINO SI( mario == pedro ) contemporaneos = "Mario y Pedro son contemporáneos" SINO contemporaneos = "No hay contemporáneos" // Salida de resultados IMPRIMIR contemporaneos FIN Ejercicio 9:- El promedio de prácticas de un curso se calcula con base a cuatro prácticas calificadas de las cuales se elimina la nota menor y se promedian las tres notas más altas. Diseñe un algoritmo que determine la nota eliminada y el promedio de prácticas de un estudiante. Algoritmo INICIO // Declaración de variables REAL pc1, pc2, pc3, pc4, pcmenor, promedio // Entrada de datos LEER pc1, pc2, pc3, pc4 // Determina la nota menor pcmenor = pc1 SI( pc2 < pcmenor ) pcmenor = pc2 Informática I. Versión 1.0 Agosto de 2004. 141
- 142. Universidad Autónoma deOccidente SI( pc3 < pcmenor ) pcmenor = pc3 SI( pc4 < pcmenor ) pcmenor = pc4 // Determina el promedio promedio = (pc1 + pc2 + pc3 + pc4 - pcmenor ) / 3 // Salida de resultados IMPRIMIR promedio, pcmenor FIN Ejercicio 10:- Diseñe un algoritmo que lea tres longitudes y determine si forman o no un triángulo. Si es un triángulo, determine de qué tipo de triángulo se trata entre: equilátero (si tiene los tres lados iguales), isósceles (si tiene dos lados iguales) o escaleno (si tiene tres lados desiguales). Considere que para formar un triángulo se requiere que: "el lado mayor sea menor que la suma de los otros dos lados". Algoritmo INICIO // Declaración de variables REAL L1, L2, L3, suma CADENA tipoRectangulo L1 // Entrada de datos L3 LEER L1, L2, L3 L2 // Determina el lado mayor mayor = L1 SI( L2 > mayor ) mayor = L2 SI( L3 > mayor ) mayor = L3 // Determina la suma de los lados a excepción del lado mayor: suma = L1 + L2 + L3 - mayor // Determina de que tipo de triángulo se trata SI( mayor < suma ){ SI( ( L1 == L2 ) && ( L2 == L3 ) ) tipoRectangulo = "Triángulo equilátero" SINO SI( ( L1 == L2 ) || ( L2 == L3 ) || ( L3 == L1 ) ) tipoRectangulo = "Triángulo isósceles" SINO tipoRectangulo = "Triángulo escaleno" } SINO tipoRectangulo = "No es un triángulo" // Salida de resultados IMPRIMIR tipoRectangulo FIN Ejercicio 11:- Diseñe un algoritmo que lea tres números enteros y determine el menor valor positivo. Si los números positivos son iguales, dar como menor a cualquiera de ellos. Algoritmo Informática I. Versión 1.0 Agosto de 2004. 142
- 143. Universidad Autónoma deOccidente INICIO // Declaración de variables ENTERO a, b, c, menor // Entrada de datos LEER a, b, c // Determina el menor // **************** // Aquí a, b y c podrían ser positivos: SI( a > 0 ){ menor = a SI( b > 0 && b < menor ) menor = b SI( c > 0 && c < menor ) menor = c } // Aquí sólo b y c podrían ser positivos SINO SI( b > 0 ){ menor = b SI( c > 0 && c < menor ) menor = c } // Aquí sólo c podrían ser positivos SINO SI( c > 0 ){ menor = c } // Guardamos el indicador -1 para saber que no hay positivos: SINO menor = -1 // Salida de resultados SI( menor != -1 ) IMPRIMIR menor SINO IMPRIMIR "No se ingresó ningún número positivo" FIN Ejercicio 12:- Diseñe un algoritmo que lea tres números y los imprima de mayor a menor y de menor a mayor. Algoritmo INICIO // Declaración de variables REAL n1, n2, n3, mayor, menor, medio // Entrada de datos LEER n1, n2, n3 // Determina el menor: menor = n1 SI( n2 < menor ) menor = n2 SI( n3 < menor ) menor = n3 Informática I. Versión 1.0 Agosto de 2004. 143
- 144. Universidad Autónoma deOccidente // Determina el mayor: mayor = n1 SI( n2 > mayor ) mayor = n2 SI( n3 > mayor ) mayor = n3 // Determina el medio: medio = n1+n2+n3-mayor-menor // Imprime en orden ascendente: IMPRIMIR menor, medio, mayor // Imprime en orden descendente IMPRIMIR mayor, medio, menor: FIN Ejercicio 13:- A continuación, se muestra una aplicación Java que solicita números vía teclado y determina el menor y el mayor de ellos: import java.io.* ; class MinMay3A { public static void main( String args[ ] ) throws IOException { InputStreamReader isr = new InputStreamReader( System.in ) ; BufferedReader br = new BufferedReader( isr ) ; //BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ; System.out.print( "Digite la cantidad de numeros que va a ingresar: " ) ; int n = Integer.parseInt( br.readLine( ) ) ; System.out.println( ) ; //Deje una línea en blanco. double num = 0, min = 0, may = 0 ; for( int k = 1; k <= n; k ++ ) { System.out.print( "Digite un numero: " ) ; num = Double.parseDouble( br.readLine( ) ) ; System.out.println( ) ; //Deje una línea en blanco. if( k == 1 ) { min = num ; //Que el PRIMER número leído haga de may = num ; //número menor y de número mayor. } if( num < min ) { min = num ; } if( num > may ) { Informática I. Versión 1.0 Agosto de 2004. 144
- 145. Universidad Autónoma deOccidente may = num ; } } System.out.println( "*****************************************" ) ; System.out.println( "nValor minimo: " + min ) ; System.out.println( ) ; //Deje una línea en blanco. System.out.println( "Valor maximo: " + may ) ; System.out.println( ) ; //Deje una línea en blanco. System.exit( 0 ) ; } } Salida: Ejercicio 14:- Diseñe un algoritmo para obtener el grado de eficiencia de un operario de una fábrica de tornillos, de acuerdo a las siguientes condiciones que se le imponen para un período de prueba: - Menos de 200 tornillos defectuosos. - Más de 10000 tornillos producidos. El grado de eficiencia se determina de la siguiente manera: - Si no cumple niguna de las condiciones, grado 5. - Si sólo cumple la primera condición, grado 6. Informática I. Versión 1.0 Agosto de 2004. 145
- 146. Universidad Autónoma deOccidente - Si sólo cumple la segunda condición, grado 7. - Si cumple las dos condiciones, grado 8. Entonces, en seudocódigo, Las condiciones impuestas por la fábrica son: tordef < 200 siendo tordef el número de tornillos defectuosos torpro > 10000 siendo torpro el número de tornillos producidos Algoritmo 1 INICIO // Declaración de variables ENTERO torpro, tordef, grado // Entrada de datos LEER torpro, tordef // Determina el grado de eficiencia SI( tordef < 200 ){ SI( torpro > 10000 ) grado = 8 SINO grado = 6 } SINO{ SI( torpro > 10000 ) grado = 7 SINO grado = 5 } // Salida de resultados IMPRIMIR grado FIN Algoritmo 2 INICIO // Declaración de variables ENTERO torpro, tordef, grado // Entrada de datos LEER torpro, tordef // Determina el grado de eficiencia: SI( tordef < 200 && torpro > 10000 ) grado = 8 SINO SI( tordef < 200 ) grado = 6 SINO SI( torpro > 10000 ) grado = 7 SINO grado = 5 // Salida de resultados IMPRIMIR grado FIN Informática I. Versión 1.0 Agosto de 2004. 146
- 147. Universidad Autónoma deOccidente Ejercicio 15:- Se cuenta con los votos obtenidos por Juan, Pedro y María en una elección democrática a la presidencia de un club. Para ganar la elección se debe obtener como mínimo el 50% del total de votos más 1. En caso que no haya un ganador, se repite la elección en una segunda vuelta, yendo a ésta los dos candidatos que obtengan la más alta votación. Se anula la elección en caso de producirse un empate doble por el segundo lugar o un empate triple. Diseñe un algoritmo que determine el resultado de la elección. Algoritmo INICIO // Declaración de variables: ENTERO vjuan, vpedro, vmaria, vmingan CADENA resultado // Entrada de datos: LEER vjuan, vpedro, vmaria // Determina la votación mínima para ganar: vmingan = (vjuan + vpedro + vmaria) / 2 + 1 // Determina el resultado de la elección: SI( vjuan >= vmingan ) resultado = "Gana Juan" SINO SI( vpedro >= vmingan ) resultado = "Gana Pedro" SINO SI( vmaria >= vmingan ) resultado = "Gana María" SINO SI( vpedro > vjuan && vmaria > vjuan ) resultado = "Pasan a la segunda vuelta Pedro y María" SINO SI( vpedro > vmaria && vjuan > vmaria ) resultado = "Pasan a la segunda vuelta Pedro y Juan" SINO SI( vmaria > vpedro && vjuan > vpedro ) resultado = "Pasan a la segunda vuelta María y Juan " SINO resultado = "Elección anulada" // Salida de resultados: IMPRIMIR resultado FIN Ejercicio 16:- Diseñe un algoritmo que lea un número entero de 3 cifras, y forme el mayor número posible con las cifras del número ingresado. El número formado debe tener el mismo signo que el número ingresado. Algoritmo INICIO // Declaración de variables: ENTERO num1, num2, numaux, uni, dec, cen, menor, mayor,medio // Entrada de datos: LEER num1 // Si el número tiene tres cifras... SI( ( num1 >= 100 && num1 <= 999 ) || ( num1 >= -999 && num1 <= -100 ) ){ Informática I. Versión 1.0 Agosto de 2004. 147
- 148. Universidad Autónoma deOccidente // Guarda el número en una variable auxiliar para preservar el signo: numaux = num1 // Cambia el signo de num1 en caso de ser negativo: SI( num1 < 0 ) num1 = -num1 // Determina las cifras del número: cen = num1 / 100 dec = (num1 % 100) / 10 uni = (num1 % 100) % 10 // Determina la cifra menor: menor = cen SI( dec < menor ) menor = dec SI( uni < menor ) menor = uni // Determina la cifra mayor: mayor = cen SI( dec > mayor ) mayor = dec SI( uni > mayor ) mayor = uni // Determina la cifra del medio: medio = cen + dec + uni – mayor - menor // Forma el nuevo número: SI( numaux > 0 ) num2 = mayor * 100 + medio * 10 + menor SINO num2 = -1 * (menor * 100 + medio * 10 + mayor) // Imprime el nuevo número: IMPRIMIR num2 } SINO IMPRIMIR "El número no tiene tres cifras" FIN Ejercicio 17:- Hallar la suma de N números, a través de una estructura repetitiva algoritmo suma_números Entero cantNum, num, auxi Leer cantNum auxi = cantNum SUMA = 0 // la suma parcial es 0 al inicio MIENTRAS QUE cantNum > 0 HACER LEER num SUMA = SUMA+num Informática I. Versión 1.0 Agosto de 2004. 148
- 149. Universidad Autónoma deOccidente cantNum = cantNum - 1 FIN MIENTRAS ESCRIBIR “la suma de los” , auxi , “números es “ , SUMA Ejercicio 18:- Calcular el factorial de un número N, usando la estructura desde-hasta. Inicio Entero n, i, fact leer n fact = 1 desde i = 1 hasta n hacer fact = fact * i fin_desde escribir “el factorial del número”, n, “es”, fact Fin Ejercicio 19:- Calcular los factoriales de n números leídos por el teclado. El problema consiste en realizar una primera estructura repetitiva de n iteraciones del algoritmo de cálculo del factorial, que a su vez se efectúa con una segunda estructura repetitiva. Inicio Entero n, i, j, num, fact leer n // lectura de la cantidad de números desde i = 1 hasta n hacer leer num fact = 1 desde j = 1 hasta num hacer fact = fact * j fin_desde escribir “el factorial del número”, num, “es”, fact fin_desde Fin Ejercicio 20:- Escribir un algoritmo que permita calcular el interés producido por un capital a las tasas de interés comprendidos en el rango desde 10 a 20 % de 2 en 2 puntos, a partir de un capital dado. Utilice el ciclo mientras. Inicio Entero capital, tasa Real interes leer capital tasa = 10 mientras tasa <= 20 hacer interes = tasa * 0.01 * capital // tasa * capital / 100 = tasa * 0.01 * capital escribir “interés producido”, interes tasa = tasa + 2 fin_mientras escribir “Último valor de tasa (fuera del ciclo) = ”, tasa Fin Los sucesivos valores de la tasa serán 10, 12, 14, 16,18,20 y 22; de modo que al tomar ‘tasa’ el valor 22, se detendrá el bucle y se escribirá el último valor de tasa. Notar que NO se calculará el interés para 22, pues este valor hace que la condición sea falsa produciendo la salida y terminación del ciclo. Informática I. Versión 1.0 Agosto de 2004. 149
- 150. Universidad Autónoma deOccidente Supongamos que ahora nos interesa conocer este dato de 3 en 3 puntos; para ello se cambia la última línea del bucle por tasa = tasa + 3. Ahora los valores que tomará tasa serán 10, 13, 16, 19 saltando a 22, el cual será el último valor que ocasionará la salida del ciclo y se imprimirá fuera de él. Ejercicio 21:- Escribir un programa y una función que por medio del paso por valor obtenga el máximo común divisor de dos números. // Algoritmo Maximo_comun_divisor // Programa principal: Inicio Entero x, y, m leer x, y m = mcd (x, y) escribir x, y, m Fin // Función (en Java se denomina método): Entero mcd(entero a, entero b) Inicio Entero resp mientras a <> b hacer si a > b entonces a = a - b sino b=b-a fin_si fin_mientras resp = a fin Al ejecutarse este algoritmo se producirán los siguientes resultados: x y m a b mcd 10 25 10 25 5 15 5 5 5 Informática I. Versión 1.0 Agosto de 2004. 150
- 151. Universidad Autónoma deOccidente Ejercicios de Algoritmos de decisión (selectivos): 1. Elabore un algoritmo que lea tres valores diferentes y determine el mayor, el menor y el promedio. 2. Elabore un programa que valide mediante un mensaje si una pareja (x, y) pertenece o no a la siguiente función: y = 3x - 4. Ejemplo: la pareja (2,2) sí pertenece a esta función. 3. Diseñe un algoritmo que determine e imprima la hora correspondiente al segundo después de una hora digitada por el usuario ( hh, mm, ss ). 4. La siguiente ecuación corresponde a la ecuación general de segundo grado en la incógnita X o ecuación cuadrática aX2 + bX + c = 0 con a,b y c constantes y a ≠ 0 La formula general para hallar su solución es: −b ± b 2 − 4ac x= 2a A. Elabore un algoritmo para hallar las soluciones reales. B. Haga la prueba de escritorio para las siguientes ecuaciones. • X2 - 4X - 5 = 0 • X2 - 4X + 4 = 0 • 4X2 - 8X + 3 = 0 Nota: para efectuar la prueba de escritorio use la siguiente propiedad de las raíces de la ecuación b c de segundo grado: x1 + x 2 = − ; y x1 ⋅ x 2 = a a 5. Modifique el algoritmo de las ecuación general de segundo grado para que calcule las raíces imaginarias, si existen. 6. Escribir un algoritmo que permita determinar cuál es el ganador de la matricula de honor de entre 4 estudiantes . El algoritmo deberá hallar la nota definitiva de c/u de ellos (4 materias.) Si es mayor que 4.5 el alumno podrá aspirar a la matricula de honor, de lo contrario no. 7. Diseñe un algoritmo que determine si un año leído por el teclado es o no bisiesto. Informática I. Versión 1.0 Agosto de 2004. 151
- 152. Universidad Autónoma deOccidente 8. Diseñar un algoritmo que permita descomponer un número ( 10 <= x <= 999 ) en sus dígitos e imprimirlos. 9. Elabore un algoritmo que descomponga un número entero (máximo de tres cifras) en sus dígitos y luego imprima cada uno de ellos en letras. 10. Diseñe un algoritmo que tome un valor entero positivo (máximo cuatro cifras), lo descomponga y lo imprima invertido pero como un único número entero. Ejemplo: sea 3845 el número digitado se debe mostrar en pantalla el número 5483 Nota: para la prueba de escritorio escriba cualquier número de cifras decrecientes en uno como 8765, 6543, 3421, etc. y restele su inverso y vera que siempre dará 3087 11. Escriba un algoritmo para la resolución de una ecuación de primer grado (ax + b = 0). 12. Diseñe un algoritmo que lea una fecha como un número entero de ocho dígitos (ddmmaaaa), y luego imprima el mes en letras (ejemplo: si se digita el número 02011999 entonces imprime "2 de enero de 1999.") 13. Lea dos números por teclado y determine si uno es divisor del otro. 14. Se lee un número de máximo tres dígitos (verifique que efectivamente sea de máximo tres dígitos) y se debe determinar si es un número capicúa, es decir, que leído de izquierda a derecha es igual que leído de derecha a izquierda. Por ejemplo: 727, 343, etc. 15. Usted debe realizar un algoritmo para un cajero automático, que dispone de billetes de algunas denominaciones existentes (10000, 20000 y 50000), de forma que se le indique una cantidad a pagar y determine cuál es la combinación apropiada de billetes para formarla. La cantidad que se va a retirar debe ser un múltiplo de 10000 y el algoritmo debe chequar que así sea. 16. En una universidad se ha variado el sistema de calificaciones, por tanto se requiere un algoritmo que indique la valoración en letras cuando se tiene la nota en números, siguiendo la tabla mostrada a continuación Nota Numérica Valoración en letras 0.0 – 1.0 P (Pésimo) 1.1 – 2.0 M (Mal) 2.1 – 2.9 R (Regular) 3.0 – 4.0 B (Bien) 4.1 – 5.0 E (Excelente) 17. En una multinacional se cuenta con tres departamentos de ventas, en los cuales los empleados devengan el mismo salario. Sin embargo se tiene un incentivo de acuerdo al cual, si un departamento vende más del 50% del total de ventas, se da una bonificación del 20% del salario a los empleados de ese departamento. Considerando el total de ventas como la suma de las ventas Informática I. Versión 1.0 Agosto de 2004. 152
- 153. Universidad Autónoma deOccidente de los tres departamentos, indique cuánto devengarán los empleados de cada uno de los tres departamentos en un mes dado. 18. Realice un algoritmo que indique el valor de la función f(x) para un valor de x determinado por el usuario. La función ha sido definida de la siguiente forma: x 2 + 3 x − 10 x ≤ 10 f(x) = 0 para cualquier otro f ( x) = x − 5x + 8 10 < x < 20 valor de x. x − 3x 2 + 2x 3 x > 20 19. En una organización se tiene a los empleados agrupados por categoría, los de categoría 1 ganan $20.000, los de categoría 2, $15.000, los de categoría 3, $10.000 y los de categoría 4, $7.500. Se quiere un algoritmo que permita determinar cuanto debe pagarse a un empleado si se conoce el número de horas que trabajó durante el mes y la categoría a la que pertenece. Se sabe que a todos se les descuenta un 7.2% por concepto de salud, y si el salario total devengado (mensual) es menos de 1´000.000, se le da un subsidio del 15% sobre su salario mensual (sin descuentos). 20. Se debe leer un número y determinar en qué categoría se encuentra; se sabe que la categoría A, son los números entre 0 y 2 inclusive, la categoría B son los números entre 3 y 6 inclusive, la categoría C, los números 7 y 8, y la categoría D el número 9. (Adivinó, los números validos son entre 0 y 9). 21. Se quiere determinar el valor de depreciación de un artículo en una empresa, se sabe que el valor de depreciación anual se determina dividiendo el valor de compra del mismo, entre el número de años de vida útil; la vida útil se determina de acuerdo a la clase de artículo, los edificios tienen 20 años, la maquinaria, muebles y enseres, 10 años, los vehículos 5 años y los computadores 3. 22. En un concesionario de vehículos, se pagan las comisiones a los vendedores según el valor de la venta (ver tabla). Al final del mes se desea saber ¿Cuánto ganó un vendedor en total por todas las comisiones, si se sabe que hizo 4 ventas? Valor de Venta Comisión para el Vendedor Hasta 10.000.000 2% Más de 10 y Menos de 15 4% millones Mas de 15 millones 10% 23. En una empresa comercializadora, cada vendedor debe realizar 5 ventas al mes, por cada venta ganará una comisión de acuerdo a la tabla de comisiones. Cada vendedor tiene un salario básico (que usted debe leer) y de acuerdo a la suma del básico y las comisiones, se le genera un descuento para salud, pensiones y otros como señala la tabla de descuentos. Usted debe imprimir el código del vendedor, el total de sus ventas, el total ganado por comisiones, el total devengado (básico + comisiones), el total de descuentos, y el salario a pagar por cada empleado. Informática I. Versión 1.0 Agosto de 2004. 153
- 154. Universidad Autónoma deOccidente Valor Venta Comisión Devengado (salario+comisiones) Descuentos 0-1.000.000 5% 0-500.000 5% 1.000.001-1.500.000 7% 500.001-1.000.000 6% 1.500.001 ó más 10% 1.000.001 ó más 8% 24. El teniente encargado del planetario desea que se diseñe un algoritmo para que al digitar el nombre del día indique el astro que dio origen a ese nombre. Recuerde los astros: Nombre del día Astro Domingo Sol Sábado Saturno Viernes Venus Jueves Júpiter Miércoles Mercurio Martes Marte Lunes Luna 25. Realice el algoritmo para un algoritmo que calcule si un triángulo es isósceles, equilátero o escaleno dados sus tres lados A, B y C • Isósceles => dos lados iguales • Escaleno => A ≠ B ≠ C • Equilátero => A = B = C 26. Haga un algoritmo que muestre en pantalla si un ángulo es: recto, obtuso o agudo • Recto = 90° • Agudo < 90° • Obtuso > 90° 27. Con relación a sus ángulos un triángulo puede ser: • Rectángulo => Un ángulo recto • Acutángulo => 3 ángulos agudos • Obtusángulo => 1 ángulo obtuso Elabore un algoritmo que calcule si un triángulo es rectángulo, acutángulo u obtusángulo. 28. Elabore un algoritmo que seleccione personal para un empleo con las siguientes características: mujeres adultas, solteras y que practiquen algún deporte. 29. Para el cálculo con interés compuesto se utilizan las siguientes fórmulas: • Hallar una cuota mensual conociendo el interés efectivo mensual (i), número de meses (n), y el precio del articulo Informática I. Versión 1.0 Agosto de 2004. 154
- 155. Universidad Autónoma deOccidente i(1 + i ) n Cuota = Precio x (1 + i ) n − 1 • Hallar el precio de un articulo conociendo el valor de la cuota mensual, el interés efectivo mensual (i), y el número de meses (n) Precio = Cuota x (1 + i ) n − 1 i(1 + i ) n • Hallar el valor futuro de una precio actual conociendo el interés efectivo mensual (i), y el número de meses (n) Valor Futuro = Precio x (1 + i)n Elabore un algoritmo que permita de un menú de opciones calcular el valor deseado. (cuota, precio o valor futuro) 30% Nota: si i = 30% se debe usar i como: i = = 0.3 100% 30. Elabore un algoritmo que muestre el dígito que más se repite en un número de 5 cifras, en caso de no repetirse ninguno imprimir un mensaje que diga "no hay dígitos repetidos". 31. El recargo por trabajar horas nocturnas en una empresa es del 70%, el recargo por trabajar festivos es del 100%, haga un algoritmo que lea los días laboradas por un empleado, las horas nocturnas el valor de la hora normal laborada y calcule e imprima el sueldo a pagar junto con el nombre del empleado. 32. Elabore un algoritmo que tenga cuatro niveles de seguridad para un programa, si el usuario logra ingresar imprimir el mensaje "Bienvenido", en caso contrario imprimir "Error clave" y el nivel del error. 33. Realice un algoritmo que lea cuatro números y los muestre ordenados de mayor a menor. Ejemplo: sean los números 5, 3, 7 y 9, debe mostrar 9, 7, 5 y 3. 34. En un club deportivo se cancela la matricula según sea la categoría del deportista, elabore un algoritmo que calcule el valor de la matricula si los precios por categoría son: • Infantil 5-8 años $38.000= • Juvenil 9-17 años $40.100= • Adultos mayores a 18 años $45.800= Se debe hacer un recargo a la matricula del 10% para la liga. Los niños menores a 5 años no pueden ser matriculados Informática I. Versión 1.0 Agosto de 2004. 155
- 156. Universidad Autónoma deOccidente 35. A los profesores de cierta universidad se les paga por ‘horas cátedra’ dictadas de 45 minutos. Elabore un algoritmo que lea el número de horas dictadas en un mes, siendo estas horas de 60 minutos, y calcule el pago mensual para el profesor. Tenga en cuenta que a los profesores se les cancela según la siguiente categoría, donde se indica el precio de la ‘hora cátedra’ : 4 $ 35.400= 3 $ 29.200= 2 $ 25.000= 1 $ 22.500= Al final al profesor se le resta el 10% de retención en la fuente. Ejercicios sobre Algoritmos repetitivos (ciclos) 36. Realice un algoritmo que imprima en pantalla el conjunto de los (n) múltiplos de un número entero (x) digitado por el usuario. 37. Haga un algoritmo que imprima en pantalla el conjunto de los divisores de un número entero (x) digitado por el usuario. 38. Elabore un algoritmo que calcule el mínimo común múltiplo (m.c.m) de dos números A y B, recuerde el m.c.m. como su nombre lo indica es el menor múltiplo común de dos o mas números. Ejemplo: sean los números 8 y 6. m.c.m. (8, 6) = 24 39. Al divisor común que es mayor que todos los divisores comunes de dos números (A, B) se le llama máximo común divisor (m.c.d.). Elabore un algoritmo para calcular el m.c.d. de dos números. Ejemplo: sea 8 y 12 (investigue el algoritmo de Euclides). m.c.d. (8,12) = 4 Informática I. Versión 1.0 Agosto de 2004. 156
- 157. Universidad Autónoma deOccidente 40. Dos números son amigos, si cada uno de ellos es igual a la suma de los divisores del otro. Ejemplo: 220 y 284 son amigos por que, 284 220 1 1 2 2 4 4 Divisores 71 5 142 10 11 20 22 44 55 Suma 110 220 284 Elabore un algoritmo que calcule si dos número son amigos o no. 41. Elabore un algoritmo que calcule el número de días que existen entre dos fechas. Tenga en cuenta que existen meses de 30 y 31 días y los años bisiestos. n 42. Calcular usando cada uno de los tres ciclos el valor de X . 43. Calcule e imprima las tablas de multiplicar del 1 al 9 usando el ciclo mientras(). 44. Calcule e imprima las tablas de multiplicar del 1 al 9 usando el ciclo haga.. mientras(). 45. Calcule e imprima las tablas de multiplicar del 1 al 9 usando el ciclo para(.....). 46. Desarrolle un algoritmo que impriman las siguientes series: 1, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44. 1, 4, 9, 16, 25, 36, 49, 64, 81. 2, 4, 6, 8, 10, .....100. -2, +4, -6, +10, ....100. 47. Elabore un algoritmo que imprima las siguientes series para (n) términos : 1 3 5 7 9 1 3 5 7 9 a. − + − + − b. − + − + − 2 4 6 8 10 2 ! 4 ! 6! 8! 10! 1 34 56 7 8 9 10 1 3 5 7 9 c. − + − + − d. − − + + − − 2 4 6 8 10 5 10 15 20 25 Informática I. Versión 1.0 Agosto de 2004. 157
- 158. Universidad Autónoma deOccidente 48. Desarrolle un algoritmo que impriman la suma de los términos de las siguientes series: Suma = -1 +2 -3 +4 -5, ... hasta N términos. Suma =+1 +4 -8 +12 +16 -20 +24 +28, -... hasta N términos. 1 1 1 1 Suma = + + + + hasta N terminos 1 9 25 49 1 1 1 1 Suma = + − + − + hasta N terminos 1 9 25 49 x 2 x3 x 4 Suma = 1 + x + + + + hasta N terminos 2! 3! 4! x3 x5 x7 Suma = x − + − + hasta N terminos 3! 5! 7! x2 x4 x6 Suma = 1 + + + + hasta N terminos 2! 4! 6! x3 x5 x7 xn Suma = 1 + x + + + + (no son exactamente n términos) 3! 5! 7! n! x2 x3 x4 xn Suma = 1 + x + + + + (no son exactamente n términos) 2! 3! 4! n! 49. Escriba un algoritmo que calcule el factorial de un número N. (Ejemplo: el factorial de 4 es igual a: 1x2x3x4=24) m! 50. Determine el valor del combinatorio C(m,n), definido como n !(m − n )! 51. Escriba un algoritmo para calcular si un número es primo o no, recuerde que los números primos son aquellos que solo son divisibles por la unidad y por ellos mismos: ejemplo 5, 11, 17, etc.. 52. Calcular mediante un algoritmo cuantos números primos existen entre 1 y un número M dado por el usuario. 53. Escriba un algoritmo que muestre el cuadrado de los números del 1 al 50. Informática I. Versión 1.0 Agosto de 2004. 158
- 159. Universidad Autónoma deOccidente 54. Diseñar un algoritmo para determinar la cantidad de mujeres y de hombres que hay en un grupo de N estudiantes (máximo 45). Además se debe hallar el promedio de edad y de estatura del grupo. (el usuario digitará para cada integrante del grupo, su sexo, edad y estatura). 55. Desarrolle un algoritmo que permita seleccionar personal para un empleo de un total de N aspirantes. Los aspirantes deben cumplir las siguientes condiciones para ser aceptados: - Mayores de edad - Ser ingeniero titulado - Tener experiencia laboral Al final el algoritmo debe mostrar el total de aspirantes aceptados. 56. Desarrolle un algoritmo que permita calcular el valor de la tangente de un ángulo dado en grados usando la serie de Taylor del seno y del coseno. 57. Diseñe un algoritmo que calcule e imprima la suma de los números pares e impares comprendidos entre 1 y 100. 58. Leer N números y calcular el mayor sin importar que se repita. 59. Leer N números y calcular el menor sin importar que se repita. 60. Leer una serie de M números y mostrar al final cuantos son positivos. 61. Calcular la suma de los cuadrados de los números comprendidos entre 1 y N. 62. Leer 10 números y al final imprimir el promedio de estos. 63. Desarrolle un algoritmo que calcule el valor de π usando la siguiente serie: 2 4 4 6 6 8 8 10 π = 4⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 3 3 5 5 7 7 9 9 El número de términos debe ser dado por el usuario (entre mayor sea el número de términos mayor será la precisión del cálculo). 64. Se desea calcular la resistencia equivalente en paralelo de un circuito de N resistencias, para lo cual se le pide que diseñe un algoritmo. 1 1 1 1 Resistencia equivalente paralelo = + + + R1 R2 R3 RN 65. Se desea calcular la resistencia equivalente en serie de un circuito de N resistencias, para lo cual se le pide que diseñe un algoritmo. Resistencia equivalente serie = R1 + R2 + R3 + + RN Informática I. Versión 1.0 Agosto de 2004. 159
- 160. Universidad Autónoma deOccidente 66. Implemente un algoritmo que lea un número entero y lo muestre invertido. 67. Calcular y mostrar los N primeros términos de la serie de Leonardo Fibonacci. Fibonacci = 0,1, 1, 2, 3, 5,... 68. Calcular suma de los primeros 100 términos de la serie de Fibonacci. 69. Elaborar un algoritmo que convierta un número entero positivo, menor a 257 a sistema binario 70. Elabore un algoritmo que permita convertir un número entero positivo (máximo cuatro cifras) en su equivalente en sistema octal. 71. Escribir un algoritmo que halle el número de años bisiestos en un intervalo dado por el usuario (año bisiesto – sí es múltiplo de 4, pero sí es múltiplo de 100 deberá ser también múltiplo de 400). 72. Realizar la tabla de multiplicar de x (número digitado por el usuario, puede ser positivo o negativo), desde 1 hasta n (número digitado por el usuario, puede ser positivo o negativo). 73. Dada la siguiente serie determine el valor de la suma de sus términos. La serie termina cuando (M-N)2 sea igual a 0, El valor de M debe ser dado por el usuario. Serie: 1,2,3, (M-0)2,4,5,6,(M-1)2,7,8,9,(M-2)2,.......(M-N)2 74. Dada una fecha (mes, día, año) indicar cuantos días (exactos) han transcurrido desde ese año. 75. En un curso hay 20 alumnos, cada alumno tiene diferente número de notas, se quiere determinar el promedio de cada estudiante, y el número de estudiantes que perdieron la materia (menos de 3.0). NOTA: La nota definitiva de un estudiante corresponde al promedio simple de sus notas. 76. Se deben leer números hasta que se digite 99 (el 99 no se debe contar), y determinar cuantos primos hay, y cuantos pares. (recuerde que estas dos condiciones no son exclusivas). 77. Leer un número en base 10, y determinar su equivalente en cualquier base entre 2 y 16. (Puede escribir el número al revés en la base indicada) 78. Elabore un algoritmo para que dos personas puedan jugar tres en línea. El ganador es quien primero logre colocar tres figuras en línea (ver figura). Como ayuda muestre los cuadros numerados del 1 al 9 a los jugadores para que escojan su jugada. 1 2 3 o x o 4 5 6 o x x 7 8 9 x x o Informática I. Versión 1.0 Agosto de 2004. 160
- 161. Universidad Autónoma deOccidente 79. Que hacen los siguientes algoritmos: • ALGORITMO INICIO Entero n, i, total Imprimir "Digite un número entero: " Leer( n) Para i = 0 Hasta n total = total + (2*i) Fin Imprimir "El resultado es:" & total FIN • ALGORITMO INICIO Real n, h=0, total = 0 Imprimir "Digite un número: " Leer(n) mientras h <> n Imprimir "Digite un número " Leer (h) total=total+h fin Imprimir"El total es " & total FIN 80. Elabore un algoritmo que lea cinco notas de (n) números de estudiantes, y que calcule e imprima el promedio de cada alumno y el promedio del grupo además de la nota del estudiante de mayor y menor promedio. 81. Un número es perfecto si la suma de sus divisores excepto él mismo es igual al propio número. Ejemplos: Número: 6 28 36 Divisores---> 1 1 1 2 2 2 3 4 3 7 4 14 6 9 12 18 Informática I. Versión 1.0 Agosto de 2004. 161
- 162. Universidad Autónoma deOccidente Suma 6 28 55 De lo anterior el 6 y el 28 son números perfectos, el 36 no lo es. Desarrolle un algoritmo que Calcule si un número es perfecto o no. 82. Elabore un algoritmo que genere un número aleatorio y que les dé la posibilidad a dos jugadores de adivinar dicho número, el algoritmo debe pedir el número de partidas, intercalar los turnos para adivinar, mostrar el ganador por partida y el ganador final. El número debe estar entre 0-9. (Use la función aleatorio.) 83. Elabore un algoritmo que lea las ventas de (n) número de vendedores, para los productos (A, B, C, D y C), si los precios de los productos son ($1000, $2345, $3876, $1235 y $550) respectivamente, calcule el número individual y total de productos vendidos, las ventas totales por producto, el promedio total de ventas, el producto mas vendido, el menos vendido, el vendedor que más ventas realizó. 84. Realice un algoritmo que calcule la suma de (n) números, el producto de estos y cuantos de estos son negativos y cuantos positivos. Estos datos deben ser mostrados por pantalla. 85. Haga un algoritmo que lea las notas de (n) estudiantes, que indique el número de estudiantes que ganaron la materia (mayor o igual a 3.0), el numero de los que la perdieron (menor o igual a 3), además de indicar cuantos deben habilitar la materia (notas entre 2.5 y menores a 3.0). Todos los datos deben ser mostrados por pantalla. 86. Realice un algoritmo que lea (n) números y halle el mayor número par, el mayor impar, y el producto de estos dos números. Estos datos deben ser mostrados por pantalla. 87. Elabore un algoritmo para calcular de (n) números leídos cuantos son primos y cuantos no, y los mayores de cada grupo. 88. Haga un algoritmo que lea un número entero de 4 cifras (base 10) y que lo convierta a un binario (base 2) y un octal (base 8). Utilice instrucciones repetitivas (use el operador residuo). 89. Un profesor necesita calcular las notas finales de su curso, para ello dispone de 7 notas, las 3 primeras componen la nota definitiva de quiz y talleres con un valor de 25%, la 4 nota corresponde al primer examen parcial con un 25%, la 5 al segundo examen parcial con un 25%, las dos ultimas (6 examen escrito y 7 trabajo opcional) al examen final con un valor de 25%. El profesor desea obtener los siguientes resultados para cada estudiante: • La nota definitiva de quiz y talleres (promedio de las 3 primeras notas) • La nota definitiva del examen final (en el caso de haber presentado opcional) • La nota final del estudiante Estos datos deben ser mostrados en pantalla junto con las demás notas. Informática I. Versión 1.0 Agosto de 2004. 162
- 163. Universidad Autónoma deOccidente Desea conocer también cuantos aprobaron el curso (notas superiores a 3.0) y cuantos no cumplieron con los objetivos de este (notas menores a 3.0) y también obtener la mejor nota para promover este estudiante como monitor de la materia para el próximo semestre. (estos últimos datos se deben mostrar por pantalla al final del calculo de las notas finales de todo el curso). 90. Elabore un algoritmo que imprima cual es el vendedor del mes de una empresa. Tabla de Precios Producto Precio A $57000 B $62000 C $83000 Para lograr el cálculo se leen las cantidades de productos vendidos por cada uno de los M vendedores de la empresa y siguiendo la tabla de precios se determina el mejor como aquel que mayores ventas haya tenido. 91. Use la siguiente fórmula para calcular la raíz cuadrada de un número entero positivo: N Raíz = 0.5* ( X 1 + ) X1 Donde N es el número del que se desea conocer la raíz y X1 es una variable que se le asigna un valor inicial de 1. Con estos dos valores iniciales se obtiene el primer valor de la variable Raíz. Si el valor absoluto de |Raíz - X1| es mayor a 0.0000001 se le reasignará a X1 el contenido de la variable Raíz y se hará un nuevo calculo hasta que el valor absoluto sea menor, que es cuando se obtiene el valor real de la raíz. 92. Escriba un programa que calcule el resultado de la siguiente serie para N términos. X2 X4 X6 R = 1− + − + 3! 5! 7! 93. Algunos pueblos de Rusia emplean el siguiente método para multiplicar: escriben los dos factores uno al lado del otro y se forman con ellos dos columnas: debajo del factor que está a la izquierda se toma la mitad en números enteros, es decir despreciando fracciones, y de esta mitad se toma la mitad, y así sucesivamente hasta llegar a 1; debajo del factor que está a la derecha, y paralelamente, se escribe su duplo, y así sucesivamente hasta emparejar con el ultimo número de la columna de la izquierda, como puede verse en el ejemplo, se tachan de la columna de la derecha todos los números colocados enfrente de los número pares de la otra columna y se suman todos los números no tachados de esta columna; esta suma será el resultado de la multiplicación. Elabore un algoritmo que emplee este método para multiplicar dos números. Ejemplo: Multiplicar 22 x 6 = 132 Informática I. Versión 1.0 Agosto de 2004. 163
- 164. Universidad Autónoma deOccidente 22 X 6 11 12 5 24 2 48 1 96 132 Informática I. Versión 1.0 Agosto de 2004. 164