Embed Size (px)
Citation preview
INFORME FUNDAMENTOS DE PROGRAMACION EN JAVA
JENNY CATALINA SUA QUIMBAYO
DIEGO MANUEL MONTERO MEJIA
ANDRES DAVID GOMEZ TOLEDO
PRESENTADO A:
AMPARO OLAYA BENAVIDES
UNIVERSIDAD CENTRAL
FACULTAD DE INGENIERÍA
INEGENIERÍA DE SISTEMAS
PROGRAMACION ORIENTADA A OBJETOS
BOGOTÁ D.C., COLOMBIA
2016
2
Índice
2. Estructura de un programa de java…………………………………….. 4
La estructura de un programa java ………………………………………………… 4
Los elementos de un programa java………………………………………………... 5
Comentarios………………………………………………………………… 5
Comentarios de bloque………………………………………....................... 5
Comentarios de documentación……………………………………………. 6
Comentarios de línea……………………………………………………….. 6
Variables y valores…………………………………………………........................ 6
Expresiones…………………………………………………………........................ 6
Expresiones aritmético-lógicas…………………………………………………….. 7
3. Clases y objetos…………………………………………………………. 8
Clases………………………………………………………………………………. 8
Atributos…………………………………………………………………………… 9
Métodos y constructores…………………………………………………………… 9
Representación de clases y objetos……………………………………………….. 12
Objetos……………………………………………………………………………. 13
La referencia null…………………………………………………………………. 14
Referencias compartidas por varios objetos……………………………………… 14
Operaciones………………………………………………………………………. 17
Invocación de métodos…………………………………………………………… 18
El método main()…………………………………………………………………. 19
Las variables locales de un método………………………………………………. 20
Sobrecarga de métodos…………………………………………………………… 21
Constructores……………………………………………………………………… 22
4. Extensión de clases……………………………………………………… 25
Composición………………………………………………………………………. 25
3
Herencia…………………………………………………………………………… 29
Polimorfismo……………………………………………………………………… 35
5. Ampliación de clases……………………………………………………. 39
Elemento de clase (static)…………………………………………………………. 39
Derechos de acceso……………………………………………………………….. 41
Paquetes……………………………………………………………………………42
6. Estructuras de control………………………………………………….. 43
Estructuras de selección…………………………………………………………... 43
Estructura if……………………………………………………………….. 43
Estructura if else…………………………………………………………... 43
Estructuras de selección anidadas………………………………………................ 43
Estructura if else if………………………………………………………… 46
Estructura switch………………………………………………………….. 47
El operador condicional…………………………………………………………… 51
Estructuras de repetición………………………………………………………….. 51
Estructura while…………………………………………………………… 51
Estructura do-while……………………………………………………….. 53
Estructura for……………………………………………………………… 54
Estructuras de salto…..…………………………………………………………… 57
Sentencias break y continue……………………………………………………… 57
7. Estructuras de almacenamiento………………………………………... 61
Arrays……………………………………………………………………………... 61
Arrays multidimensionales………………………………………………………... 62
El algoritmo de ordenación “Bubble Sort”………………………………………... 64
8. Entrada y salida…………………………………………………………. 65
Entrada de datos desde el teclado…………………………………………………. 65
4
2. Estructura de un programa de JAVA
En este código podemos ver que el autor comienza con un comentario de bloque, seguido
por la definición de la clase HolaMundo, dentro de la definición de clase encontramos la
definición del método main( ) y finalmente dentro del método main hay una sentencia
para mostrar en la consola el mensaje: “Hola Mundo” mediante el método
System.out.println(“mensaje”).
La estructura de un programa Java
5
Este código comienza con un comentario de bloque, seguido por la definición de la clase
PerimetroCircunferencia, dentro de la definición de clase encontramos la definición del
método main( ) y dentro del método main hay un comentario de línea que se representa
mediante dos //, luego se declaran las variables PI, radio y perímetro que son de tipo
double.
A la variable PI, se le asigna un valor exacto al igual que a la variable radio, a la variable
perímetro se le asigna los valores de las variables PI y radio para operarlos y así hallar el
perímetro de la circunferencia con la fórmula 2*π * r.
Finalmente se muestran los resultados con el método System.out.print(). Para imprimir
mensajes es entre comillas System.out.print(“mensaje”) y para imprimir variables es sólo
el nombre de la variable System.out.print(variable).
Para evitar la ejecución de cuatro métodos se podría sintetizar en uno sólo, utilizando el
operador + para enlazar los textos con las variables de esta manera, ya sea con salto de
línea o no:
System.out.println(“El perímetro de la circunferencia de radio ” + radio + “ es ”
+perimetro);
System.out.print(“El perímetro de la circunferencia de radio ” + radio + “ es ” +perimetro);
Los elementos de un programa Java
Comentarios
Los comentarios ayudan a explicar detalles importantes de un programa, se debe decir qué
se hace, para qué y cuál es el fin del programa, hacen más entendible el programa. En un
programa de Java hay 3 tipos de comentarios:
Comentarios de bloque
Los comentarios de bloque comienzan por /* y terminan con */ . El compilador ignora todo
el texto y se usa generalmente para informar o brindar información principal del programa.
6
Comentarios de documentación
Los comentarios de documentación comienzan con /** y terminan con */. Por lo general se
indica el autor, la fecha, y otros aspectos con los que cuenta la herramienta javadoc de Java.
Comentarios de línea
Los comentarios de línea comienzan con // y termina al final de la línea.
Variables y valores
Las variables almacenan valores únicos, se definen por un nombre, un tipo de dato y el
rango de valores que puede almacenar. Una vez declarada se puede usar en cualquier parte
del programa.
Si declarara una constante, se usa la palabra final, el tipo de dato, el nombre de la constante
y obligatoriamente se indica su valor.
Expresiones
Las expresiones permiten realizar operaciones entre valores utilizando distintos operadores
. Este código nos permite convertir grados Fahrenheit en grados Centígrados mediante una
fórmula matemática que representamos con la expresión:
7
Puede ser de tipo int o tipo double, el orden de los cálculos depende de la jerarquía de los
operadores comenzando de izquierda a derecha.
En esta expresión podemos ver que como no hay paréntesis que permitan ordenar de cierto
modo la operación, de acuerdo a la jerarquía de operadores…
Si hay operadores de la misma jerarquía se comienzan a resolver de izquierda a derecha, así
que resolvemos primero la multiplicación entre 2 y 4 y luego la división entre 12 y 6
teniendo como resultado parcial . Por último se resuelven los
operadores de adición y sustracción de izquierda a derecha y se obtiene como resultado 8.
Expresiones aritmético-lógicas
Una expresión aritmético-lógica devuelve un valor verdadero o falso. Esta expresión es
verdadera ya que el resultado de la expresión del lado derecho (10 - 2) es mayor que la del
lado izquierdo (5 – 3).
En esta expresión se evalúan primero expresiones aritméticas, obteniendo así la expresión
lógica . Luego se evalúan los operadores relacionales para
obtener . A continuación se evalúa el operador lógico con los
operandos (false && true) y se obtiene y luego finalmente se obtiene que la
expresión es verdadera.
8
3. Clases y objetos
Clases
Basicamente este pequeño fragmento de programa nos indica tres cosas, la primera, la
palabra designada para crear una clase es “class”, la segunda, seguido de la palabra “class”
utilizamos el nombre de la clase el cual debe empezar en mayúscula en este caso la clase se
llama “Circulo” y la tercera, utilizamos el numero de atributos que necesitemos pero estos
deben ser características de la clase, en este caso utilizamos 3 x, y, radio, cada uno con su
tipo de dato especifico.
Una vez creamos la clase, podemos crear los objetos de esta clase en este caso se crearon 2
pero el número es acorde a la necesidad.
9
Es necesario instanciar el objeto para ello utilizamos el operador “new” al igual que “class”
es una palabra reservada, esto nos ayudara a crear un espacio de memoria.
Atributos
Otro ejemplo de clase, en el cual podemos notar que los tipos de datos de los atributos no
son todos iguales, unos son String, double o boolean.
Métodos y constructores
10
En el siguiente ejemplo se puede notar el comentario realizado debajo de los atributos, en el
cual nos explica que se ha creado un constructor sobrecargado el cual ayuda a inicializar los
atributos del objeto que se instancia, este se define una o más veces. Y dentro del
constructor por defecto están los atributos y sus identificadores, para diferenciar entre ellos
se usa la palabra “this.” De esta manera cuando escribo “this.marca” se refiere al atributo
del objeto y el solo “marca” al parámetro del método. Antes de continuar debo hacer
mención de un error encontrado en el código, se encuentra en el primer identificador dentro
del constructor sobrecargado, no se escribe “this,matricula = matricula;” sino this.matricula
= matricula; siempre es con punto (.).
Para instanciar un objeto se ejecuta el método constructor de esta manera. Otros métodos
importantes que se utilizan con el pasar del tiempo de forma autómata pues se utilizan
demasiado, son los métodos get (recibir) se define para cada uno de sus atributos pues el
get se define para consultar el estado de un objeto y se usa de la siguiente manera
Y set (dar), los set solo se definen para los atributos que pueden ser modificados
11
Después de haber creado el objeto, en el siguiente ejemplo vemos la manera de utilizar
estos métodos.
12
Representación de clases y objetos
Este es el modelo de una clase utilizando un programa de modelamiento como Enterprise o
StarUml, estos son solo 2 ejemplos de los muchos programas de modelamiento que existen,
en la parte superior se encuentran los atributos y en la parte inferior los métodos.
Y de esta manera se instancian los objetos, en este caso hay 2 objetos de la clase vehículo.
13
Objetos
Un objeto se compone de atributos y métodos, en el ejemplo se muestra la manera correcta
pata mostrar los elementos de un objeto de forma directa para ello usamos el método
System.out.println (“mensaje”).
14
La referencia null
Por ejemplo si un objeto fue declarado pero no se instancio, existe un valor especial
llamado “null” que se usa para esta situación, el null nos indica que un objeto no se ha
instanciado eso quiere decir que no se ha usado la palabra new seguido del constructor. En
el ejemplo vemos dos “if” el primero el cual no está instanciado y el segundo en el que sí,
se usa esta comparación para comprobar si esta instanciado o no, seguido de un mensaje.
Referencias compartidas por varios objetos
Un alias es una referencia que se crea de más en el mismo espacio de memoria del objeto
original, este alias se crea con un objeto que no está instanciado, por ejemplo se crea
vehiculo1 y se asigna a vehiculo3 que es un objeto no instanciado, el espacio de memoria
de estos dos objetos será el mismo.
15
16
El alias es usado para mostrar el estado de un objeto y también para modificarlo, si
cambiamos algo de vehiculo3 inmediatamente vehiculo1 también se modificara
17
Operaciones
Podemos denominar método de operaciones a aquel método que realiza un cálculo o
modifica el estado de un objeto, en el ejemplo anterior podemos ver que la clase Circulo
tiene 2 métodos de operación, calcularPerimetro y calcularArea, las operaciones dependen
de lo requerido en este caso área y perímetro se hayan de distintas maneras, pero como
podemos observar ambas utilizan “this.radio”.
18
Invocación de métodos
Los métodos se pueden indicar tanto dentro como fuera de la clase donde se declaró, en el
ejemplo podemos ver que el método fue creado en la misma clase donde fue declarado por
esta razón solo basta con indicar su nombre, dentro del método observamos que fueron
invocados los “get” de los diferentes atributos de la clase esto se podría reemplazar
utilizando la referencia directa de los atributos “this.marca” por ejemplo.
19
Si el método se invoca fuera de la clase donde se declaro es necesario indicar el nombre
del objeto y el nombre del método, en el ejemplo podemos ver que el método
“getAtributos” sirve para mostrar los valores de vehículo.
El método main()
Cada vez que se vaya a crear un programa en java es necesario utilizar el método main este
método se declara de la siguiente manera, public static void, no devuelve un valor de
retorno y los comandos String[] args se refieren a la línea de comandos de la aplicación,
cuando el programa es ejecutado este es el método que ejecuta todos los demás métodos de
la aplicación.
20
Las variables locales de un método
Las variables locales de un método sirven para guardar temporalmente valores utilizados
por el método, en el ejemplo anterior no estamos usando una variable local eso quiere decir
que esa es una manera de utilizar el método sin variables, pues el valor de retorno se calcula
al momento de hacer return, ahora veamos el siguiente ejemplo.
En este caso estamos utilizando la variable local atributos para guardar los valores del
método getAtributos, esta variable se crea dentro del mismo método y retornamos a
atributos, ambos métodos son equivalentes pero en el primero se evita el uso de una
variable innecesaria.
21
Sobrecarga de métodos
En este ejemplo vemos cómo funciona la sobrecarga de métodos la cual es útil para que el
mismo método opere parámetros de distinto tipo, esto quiere decir que pueden haber dos o
más métodos con el mismo nombre pero realizan operaciones distintas, como podemos ver
en el ejemplo los métodos se diferencian en la manera en la que fueron declarados, en el
primer método simplemente devuelve los atributos de un vehículo, mientras que en el
segundo método realiza una operación de la tarifa reducida en un 10%.
22
Constructores
Existen 2 tipos de constructores, el constructor por defecto el cual asigna valores
predeterminados por java a los atributos de la clase, como la inicialización de estos cuando
el tipo de dato es int, o float etc. Y el constructor sobrecargado el cual es creado con el fin
de inicializar los valores de un objeto con valores distintos de los valores por defecto de
java, en el ejemplo de arriba podemos ver como se declara el constructor por defecto,
también podemos notar que los atributos no tienen ningún tipo de visibilidad especificada
23
esto indica que tiene visibilidad de paquete la cual permite que se acceda mediante una
instancia, pero únicamente desde clases que hagan parte del mismo paquete, los paquetes
son creados para guardar clases y por supuesto puede haber interacción entre paquetes.
En este ejemplo se están utilizando dos constructores, tienen un número distinto de
parámetros, por lo que java mismo reconoce aunque se llamen igual, cual constructor
24
estamos pidiendo pues el número y el tipo de argumentos que recibe son distintos, los
parámetros son la clave para la utilización de este método, cabe destacar que los atributos
están privados, esto quiere decir que a través de una instancia no es posible acceder a estos
atributos.
De esta manera se instancia vehiculo1 y vehiculo2 utilizando los 2 constructores, como
podemos ver java reconoce que constructor utilizar por el número de parámetros.
25
4. Extensión de clases
Composición
La composición es una relación fuerte entre clases, básicamente agrupa elementos de una
clase existente a una clase nueva, de manera que la instancia de esta clase contiene
elementos de otras, en este ejemplo podemos ver como se crea una clase con todo lo visto
anteriormente no ha sido alterada en lo absoluto (a excepción de que han sido omitidos los
métodos get y set por espacio).
26
Creamos otra clase para poder utilizar la composición, y dar lugar a la nueva clase,
recuerde que para utilizar la composición la relación entre clases debe estar ligada al hecho
de que una clase “a” compuesta a otra clase “b” no podría existir sin la clase “b”.
27
La clase vehiculoAlquilado es aquella que contiene la relación de composición pues
contiene un objeto de la clase cliente y un objeto de la clase vehiculo en otras palabras, la
clase vehiculoAlquilado es contenedora de las clases cliente y vehiculo, estas clases se
llaman por su tipo de dato y el nombre del objeto en este caso por ejemplo seria cliente de
tipo Cliente.
28
29
De esta manera mostramos las instancias de la clase, en la cual utilizamos las 2 clases
vehiculo y cliente contenidas en vehiculoAlquilado, creando el respectivo numero de
instancias en este caso un solo cliente y 2 opciones de vehículo
Y por último se muestran los valores almacenados, pero aquí se utilizó algo distinto, el
objeto alquiler1 de la clase vehiculoAlquilado requiere mostrar los datos de Cliente NIF,
nombre y apellidos (por ejemplo alquiler1.getCliente().getNombre+” “) y de vehiculo
únicamente la matricula, así que cuando vemos la salida de consola vemos que los datos de
vehiculo y cliente efectivamente fueron usados por vehiculoAlquilado.
Herencia
Es la capacidad de hacer que una clase con ciertos atributos pueda extenderlos a otras
clases que requieran de estos mismos atributos para su funcionamiento, esta clase original
se denomina superclase y las que heredan los atributos se denominan subclases, la
extensión de una clase tiene la siguiente sintaxis: Public class nombre-subclase extends
nombre-superclase {
}
30
Aquí vemos el comportamiento de las clases, donde las clases turismo, deportivo y
furgoneta heredan los atributos de vehiculo, este es un programa que nos muestra los
vehículos disponibles según el tipo de vehiculo que elija el usuario y por supuesto una
introducción para entender la relación de herencia en el lenguaje de java, a continuación se
mostrara el código de cada clase.
31
La declaración de la superclase vehiculo:
32
La subclase turismo, teniendo en cuenta la sintaxis correcta explicada anteriormente y la
agregación de los atributos de la superclase, esta explicita en el constructor, el proceso se
repite para todas las demás subclases.
33
La subclase Deportivo:
34
Y la subclase Furgoneta:
35
Polimorfismo
Se presenta cuando existen métodos que requieren de comportamiento diferente en cada
clase específica, si nos devolvemos al ejemplo anterior podemos notar que en cada subclase
utilizamos un método llamado getAtributos(), esto significa que el método getAtributos()
de las subclases sobrescribe el método de la superclase pues requiere un comportamiento
distinto para cada subclase.
Este es el comportamiento de las clases, aquí podemos ver de una manera más clara el
método getAtributos() y a continuación un ejemplo del comportamiento de los métodos
sobrescritos en las subclases.
36
37
38
Basicamente se utilizó todo lo referente al capítulo 2, 3 y 4 para mostrar este código,
tenemos que tener en cuenta ciertos detalles, primero, la instancia de las distintas clases que
utilizamos en este código, como lo es el deportivo, la furgoneta etc. Segundo, la invocación
del método getAtributos () para cada objeto. Existe otra manera de realizar el código y es
una a la que me acomodo más y es la utilización del método set, pues este me permite
cambiar los datos si lo requiero y por supuesto este iría ligado a un JOptionPane para que
me permita pedir los datos que requiero.
39
5. Ampliación de clases
Elemento de clase (Static).
El primer cuadro que resalta este código se debe a que la sintaxis utilizada en la definición
de la constante PI (public static final double PI = 31415926536) también es correcto
escribirlo definiendo primero “final” y luego “static”, quedaría, (public final static double
PI = 31415926536).
“final”: en este contexto indica que una variable es de tipo constante, después de su
declaración y asignación no admitirá cambios.
“static”: es utilizada para abrir un espacio de memoria el cual guarde la constante, de esta
manera se evita crear un nuevo lugar en la memoria para cada objeto ya que esto no tendría
sentido.
El segundo cuadro resala el retorno, ya que en el método no se crea una variable a la que se
le asigne el proceso para luego retornar esa variable, sino que directamente el retorno es el
mismo proceso, diferente a como se había visto hasta hora.
De igual manera pasa en el siguiente método.
En el siguiente ejemplo es posible evidenciar lo antes mencionado:
40
En comparación con el anterior código en este se crea una variable dentro del método a la
que se le asigna el proceso y luego esta misma es la que se retorna.
En este caso también varían algunos aspectos, principalmente es que se evita crear variables
para asignar los métodos, en cambio simplemente en la impresión del mensaje se llaman los
métodos directamente.
41
Aquí se puede ver la diferencia en el aspecto mencionado, se crea una nueva variable para
asignarle el método creado, y en la impresión del mensaje se llama a la variable, no al
método.
Derechos de acceso.
42
En este código es posible ver que todos los atributos tienen el método ‘get’, sin embargo
solo los atributos ‘tarifa’ y ‘disponible’ tienen el método ‘set’; dependiendo de las
necesidades la información se puede dejar fija o editable, tomando como ejemplo este caso
la única información que el usuario puede cambiar es la tarifa y la disponibilidad del objeto,
mientras que los otros atributos solo se podrán ver en caso de ser necesario.
Paquetes.
En este código observamos cómo se importa un componente de un paquete; los paquetes
pueden agrupar clases, interfaces que se relacionan entres sí, entre muchas otras cosas; para
hacer efectivo este proceso se debe llamar al paquete antes de la declaración de la clase, se
puede importar todo el paquete o solo un componente del paquete.
“import java.util.Calendar”, solo importamos el componente “Calendar”, pero si fuera
necesario importar todo el paquete se escribiría de la siguiente manera:
“import java.util.*”, no se coloca el nombre del componente del paquete sino un asterisco,
de esta manera podremos utilizar todos los componentes del paquete sin necesidad de
declararlos uno por uno.
43
6. Estructuras de control
Estructuras de selección
Permiten modificar el flujo de un programa. Mediante una condición la cual es una
expresión que evalúa un valor lógico, se decide si se ejecuta o no un bloque de sentencias.
Estructura if
Este código nos permite mostrar por consola el mensaje “Matrícula de honor” si la
calificación del estudiante es igual a 10. Para esto el autor crea una variable de tipo int
llamada calificacion para crear la condición que manejará la estructura. La estructura if sólo
ejecuta el bloque de sentencias, es decir sólo muestra por consola el mensaje si se cumple la
condición (calificación == 10), sólo si la calificación del estudiante es igual a 10 se
mostrará el mensaje, de lo contrario continuaría ejecutando las sentencias posteriores al if.
Estructura if else
A diferencia de la estructura if, la estructura if-else permite seleccionar entre dos bloques
de sentencias dependiendo también de la condición. En este código podemos determinar si
un número es par o impar y se muestra por consola. La variable de tipo int, numero, permite
manejar la condición del if else. Si el residuo de un número es igual a cero, quiere decir que
el número sí es par, entonces se ejecuta el bloque de sentencias del if, las cuales consisten
en mostrar por consola, mediante el método System.out.println(), el mensaje “El número es
par”. Si el residuo de un número no es igual a cero, quiere decir que el número no es par, o
sea que no cumple la condición, así que éste ejecuta el bloque de sentencias del else, las
44
cuales muestran por consola, mediante el método System.out.println(), el mensaje “El
número es impar”.
La sintaxis de dicha estructura cuenta con unas llaves que abren y cierran cada bloque de
sentencias, las cuales NO vemos en este código, es sumamente importante incorporarlas o
de lo contrario nos encontraremos con un error.
Estructuras de selección anidadas
Si es necesario evaluar más de una condición se utilizan varias estructuras de selección
anidadas.
45
Este código nos permite mostrar por consola la descripción de una nota según la nota que se
le asigna a un estudiante. Para ello en éste código encontramos varias estructuras if-else
anidadas. Principalmente no debemos olvidar las llaves que abren y cierran cada bloque de
sentencias.
Tendremos para mostrar por consola diferentes descripciones para diferentes notas. Primero
se declara una variable de tipo entero con el nombre calificacion a la cual se le asigna un
valor 7. Luego se comienza con las estructuras anidadas else-if las cuales llevarán como
condición (calificacion == valor){ y como bloque de sentencias mostrará mediante el
método System.out.println(); se mostrará por consola el mensaje de descripción para dicha
nota. En este caso a la variable calificacion se le asignó el valor 7, por lo cual no entrará en
el primer bloque de sentencias, es decir el más interno ya que así se resuelven las
estructuras anidadas. Comienza por la condición (7 == 5), como no se cumple continúa con
la siguiente (7 == 6) como tampoco se cumple continúa con la siguiente que es (7 >= 7)
como en esta ocasión si se cumple la condición entra a realizar el bloque de sentencias.
Finalmente muestra por consola mediante el método System.out.println() el mensaje
“Notable” y se sale de todas las estructuras de selección.
46
Estructura if else if
La estructura if-else-if se puede aplicar en los mismos casos que en la if-else. Esta
estructura permite abreviar y ordenar mejor el código realizando las mismas instrucciones,
funciona de igual manera que el código anterior.
47
Estructura switch
Este código nos muestra la sintaxis que maneja una estructura switch. Esta estructura es
manejada por una expresión la cual permitirá el “acceso” a cada case (caso) de la estructura
la cual debe estar entre paréntesis obligatoriamente seguida de una llave abierta. Luego
veremos los case de la estructura acompañados de un default. Primero se evalúa la
expresión y luego se comprueba con cuál case coincide. Cada case tiene uno o más valores
constantes del mismo tipo ya sean (int) o (char), si el valor del case coincide con el valor de
la expresión se empieza a realizar el bloque de sentencias que contiene hasta encontrarse
con la sentencia break; que interrumpe el bloque de instrucciones y finaliza la estructura
switch continuando con la sentencia posterior a ella. Si no se encuentra un case que
coincida con el valor de la expresión se ejecuta el bloque de sentencias que contiene la
etiqueta default.
48
Suponiendo que en una empresa de consultoría la categoría profesional de un empleado se
calcula a partir de su tasa de coste. La siguiente tabla muestra los valores de las tasas y sus
categorías:
Este programa nos permite seleccionar la descripción correspondiente a cada categoría. A
simple vista podemos ver que tiene varios errores, por ejemplo las llaves que abren y
cierran en las estructuras if-else , la ausencia de la sentencia break en cada case y el orden
que maneja no es muy adecuado.
Inicialmente se le asigna el valor de 150 a la variable de tipo (int), tasaEstandar, por lo cual
según la estructura if-else como la tasaEstandar no es menor de 120 se le asigna el valor de
‘A’ a la variable categoriaProfesional.
49
Luego en la estructura switch, la variable que se evalúa es categoriaProfesional, y
anteriormente como venía con el valor de ‘A’ se cumple el primer case y se supone que
muestra por consola sólo el mensaje “Socio”, pero como no está la sentencia break en cada
uno, se seguirán cumpliendo los bloques de sentencias de los demás case, así:
Tasa 150 euros, categoría ‘A’ de Socio Senior Junior ¡Indefinida!
Lo correcto sería que en la estructura case fuera de la siguiente manera, para así evitar la
ejecución de los demás bloques de sentencias:
Si en el primer código la estructura fuera de esa manera si sería un programa correcto
mostrando como mensaje:
Tasa 150 euros, categoría ‘A’ de Socio
50
Este código nos permite mostrar por consola la descripción de una nota según la nota que se
le asigna a un estudiante como lo habíamos visto anteriormente pero en este caso se emplea
la estructura switch.
El autor realiza un código muy completo ya que comienza con la definición de la clase
Calificaciones y dentro de ésta la definición del método main. Dentro del método main
encontramos que se declara la variable de tipo (int), calificacion inicializándola con el valor
de 9. Luego tenemos la estructura switch, teniendo a la variable calificacion para evaluar
cada case.
51
El case 0, 1, 2, 3, y 4 muestran por pantalla mediante el método System.out.println() el
mensaje “Suspenso”, y es el mismo para los 5 ya que la sentencia break se presenta sólo en
el case 4, así que se cumplirá el mismo bloque de sentencias para los 5. El case 6, 7, 8 y 9 y
default tienen cada uno su bloque de sentencias con su respectivo break, así que cada caso
después de ser cumplido saldrá del switch. Este código nos mostrará por consola el mensaje
“Sobresaliente” ya que tiene como valor 9.
El operador condicional
El operador condicional (?:) se relaciona con la estructura if-else, es el único de Java que
utiliza tres operandos y tiene dicha sintaxis.
Primero se declara una variable de tipo (int) denominada edad a la cual se le asigna el valor
de 16 y ésta controlará el operador condicional. Luego se declara una variable de tipo
(string) denominada txt que guardará el resultado del operador condicional. El operador
condicional de esta parte de código tiene como condición lógica (edad >= 18), el valor que
toma dicha expresión cuando es true (verdadera) “Mayor de edad” y el valor que toma la
expresión cuando es false (falsa) “Menor de edad”. En este caso la variable edad tiene
como valor 16, si 16 es mayor o igual de 18 mostrará por consola el mensaje “Menor de
edad” y si el valor no es mayor o igual 18 mostrará el mensaje “Menor de edad”. Como 16
es menor de 18, esto quiere decir que la expresión es falsa. Finalmente mediante el método
System.out.println() se mostrará por consola lo que guarda la variable txt que es el mensaje
“Menor de edad” ya que la condición es false.
Estructuras de repetición
Estructura while
Esta estructura repite el bloque de sentencias mientras que una condición es verdadera.
Esa es la sintaxis general de esta estructura, la condición debe estar siempre entre
paréntesis.
52
Este código nos permite calcular la función factorial de un número “n” mediante una
estructura repetitiva con una variable que controlará el while comenzando en 1 hasta un
número “n”. La actualización de la variable controladora del while suma uno cada vez.
El autor comienza con la definición de la clase, luego del método main, después declara 3
variables de tipo (int) y las inicializa, i = 1; factorial = 1; y n =5; Luego estará el While
teniendo a i como una variable de control, la condición será (i <= n) y en el bloque de
sentencias tendremos a la variable factorial multiplicada por i y luego ésta se incrementará
en 1. Sabemos que el valor inicial de i es 1 y el de n es 5, así en la condición tendremos (1
<= 5) lo cual es válido así que entra al bloque de sentencias. A la expresión factorial se le
asigna el valor de factorial por el de i, primero se calcula el producto y luego se le asigna el
resultado a la variable. En un principio, tanto factorial como i vienen asignadas con el valor
de 1, por lo cual el valor de dicha expresión será 1, dejándole este valor a factorial. La
siguiente sentencia incrementa a i en 1 así, i ahora tendrá como valor 2, lo que significa que
se sigue cumpliendo la condición y ocurre el mismo proceso hasta cuándo el valor de i es 6
y ahí ya no se cumple la condición así que se saldrá del while continuando con la sentencia
posterior. Finalmente mediante el método System.out.println() se muestra por consola el
mensaje (“El factorial de 5 es 120”).
53
Estructura do-while
Esta estructura ejecuta el bloque de sentencias al menos una vez, luego comprueba la
condición y repite el bloque de sentencias mientras la condición sea verdadera.
Este código también calcula la función factorial de un número pero utilizando la estructura
do-while. Comienza con el do y ejecutando su bloque de sentencias, a la expresión factorial
se le asigna el valor de factorial por el de i, primero se calcula el producto y luego se le
asigna el resultado a la variable que será 1 y luego se incrementa a i en 1, o sea pasa a ser 2.
Luego se vuelve a evaluar la condición y continúa ejecutando el bloque de sentencias hasta
que ésta no se cumpla. Luego muestra mediante el método System.out.println() por consola
el mensaje
(“El factorial de 5 es 120”).
54
Estructura for.
Cuando se ejecuta un for primero se evalúa la condición, si ésta es verdadera se ejecuta el
bloque de sentencias de lo contrario finaliza el for.
Este código nos permite al igual que en el código anterior calcular la función factorial de un
número pero mediante una estructura for, manejando las mismas variables. La variable i
controlará el for y se inicializa en 1, la condición es (i <= n), la misma que se utilizó en las
estructuras while y do-while y luego incrementa a i en 1 en cada iteración. Dentro del for
está la misma sentencia de los otros ciclos cumpliendo la misma función para al final,
cuando el for no se ejecute muestre por con sola el mensaje (“El factorial de 5 es 120”).
55
Éste código es un claro ejemplo de 3 estructuras for anidadas. Cuenta con la definición de
la clase ForAnidado y definición del método main(). En los for anidados encontramos tres
variables distintas e inicializadas en con valores distintos. Para saber cuántas veces se
cumplirá la sentencia que muestra por consola el mensaje “Hola mundo” debemos primero
saber cuántas veces se repite cada for. El for de k se repite 4 veces ya que comienza desde 3
va hasta 6, el for de j se repite 3 veces ya que comienza desde 2 y va hasta 4 y el for de i se
repite 5 veces ya que va desde 1 hasta 5. Las estructuras anidadas se deben ejecutar desde la
más interna, es decir de adentro afuera. Así como el for de k está dentro del de j y este
dentro del de i, el mensaje se imprimirá 60 veces ya que al multiplicar las veces que se
repite cada for 5 por 3 por 4 igual a 60.
Este código nos permite determinar si un número es par o impar mediante restas sucesivas.
Comenzando con la definición de la clase y el método main que son indispensables.
Utilizamos tan sólo una variable llamada numero de tipo (int). Luego de declarar esta
variable con el valor de 12, tenemos una estructura while que tiene como condición
(numero >= 2) y en su bloque de sentencias tiene la expresión: numero = numero – 2 que
indica que a la variable numero le restemos 2 hasta que sea mayor o igual a 2. Así numero
que es igual a 12, cumple la condición del while y ejecuta la sentencia restándole 2 y
dejando a numero con el valor de 10, y así sucesivamente hasta que numero quedé con el
valor de 0, por lo cual saldrá del while y continuará ejecutando el if posterior. Como
numero si es igual a cero muestra por consola el mensaje de “El número es par” de lo
contrario mostraría el mensaje “El número es impar”.
56
Este código nos muestra por consola números enteros del 0 al 100 aleatoriamente hasta que
salga el 50. Para esto se utiliza una estructura do-while, y un método que genera números
aleatorios. Primero que todo no puede faltar la definición de la clase y del método main,
luego viene la estructura do-while, dentro del do tenemos la sentencia que genera números
aleatorios, a la variable numero, de tipo (int), le asignamos numero = (100 *
Math.random()). Para generar un número entre 0 y 100 debemos multiplicar el método
Math.random() por 100 ya que el rango de números es de 0 a 100. Cada número que genera
el método aleatoriamente se muestra por consola hasta que sea 50, ya que la condición del
while es (numero != 50). Finalmente cuando numero es 50, se muestra por consola y sale
de la estructura do-while.
57
Este código nos permite calcular la potencia de un numero entero utilizando productos
mediante una estructura for. Inicialmente la definición de la clase y del método main que no
pueden faltar, para este código se calculará 210
(2 elevado a la 10). Para esto utilizamos tres
variables, todas de tipo (int), las cuales declaramos e inicializamos desde un principio, a
base se le asigna el valor de 2, puesto que es la base de nuestra potencia, a exponente se le
asigna el valor de 10, ya que es el exponente de nuestra base y a potencia el valor de 1 ya
que si la base llegará a ser 0, el resultado se sabe que es 1. Luego viene el for, manejado por
la variable i comenzando en 1, como condición (i <= exponente) e incrementando en 1 cada
iteración. Como el exponente es 10, si cumple dicha condición y entra a ejecutar la
expresión potencia = potencia * base, la base tiene como valor 2 y potencia 1, así que
potencia queda con valor de 2 y se sigue cumpliendo la condición porque ahora i es 2, y así
será sucesivamente hasta que i será 11 y no se cumplirá la condición por lo cual saldrá del
for. Finalmente muestra por consola el mensaje (“ La
potencia es 1024”).
Estructuras de salto
En Java existen 2 sentencias que permiten modificar la secuencia del flujo de un programa
generando un salto en la ejecución, éstas 2 se utilizan con estructuras de repetición para
interrumpir la ejecución con break y para volver al principio con continue.
Sentencias break y continue
58
Este código nos permite contar el número de vocales, consonantes y espacios de una cadena
de caracteres.
Para ello el autor comienza con la definición de la clase ConsonantesVocales y el método
main(). A continuación se crea una variable de tipo (string) llamada frase, la cual
almacenara la cadena de caracteres a evaluar, en este caso “Hola Mundo”. También se
crean las variables vocales, consonantes y espacios de tipo (int) que deberán inicializarse en
0 ya que harán de contador y la variable letra de tipo char que permitirá determinar si es
vocal, consonante o es un espacio. Luego se utiliza un for para evaluar letra por letra de la
cadena de caracteres, el cual será manejado por la variable de tipo (int) i. Ésta se inicializa
en 0, como condición i< frase.length() y como actualización se incrementa
en 1 por iteración. El método .length() nos permite determinar cuál es la longitud de nuestra
cadena de caracteres (string), es decir cuántas letras hay incluyendo espacios. En el bloque
de sentencias del for, encontramos que a la variable letra se le asigna el método
frase.charAt(i), este método nos devuelve el carácter situado en la posición de la variable
(i)que pasamos por parámetro, así que a la variable frase se le asignará el carácter que está
en la posición i. Luego encontramos una estructura switch que será usada para realizar la
cuenta de vocales, consonantes y/o espacios. Finalmente al salir de la estructura for
mostrará por consola el mensaje con todos los resultados:
(“La frase ‘Hola Mundo’ tiene 4 vocales, 5 consonantes y 1 espacios.”)
59
Este código como el anterior nos permite generar números aleatorias hasta que salga el
numero 25 o el numero 50.
Comienza con la definición de la clase y del método main(), luego en la estructura do-while
tendremos en el bloque de sentencias del do la variable numero de tipo (int) se le asigna un
numero aleatorio que se genera gracias al método Math.random(). La siguiente sentencia
mostrará por consola el número generado y la siguiente es una estructura if que tiene como
condición que la variable numero sea igual a 25, si se cumple la condición la sentencia
break interrumpirá el do-while, de lo contrario si se continúa en el while la variable numero
debe ser igual a 50 para salir del mismo, si no lo es seguirá repitiéndose. En conclusión sólo
cuando el número que se genere aleatoriamente sea 25 o 50 hará que se finalice la
estructura do-while.
60
Este código nos muestra por consola los números pares entre 2 y 10.
El autor comienza con la definición de la clase NumerosPares y la definición del método
main(), dentro de éste método hay una estructura for comenzando en 1 hasta 10, con
incremento de 1 por iteración. Dentro del for hay una estructura if que permite determinar
si el numero es par o no, esto lo hace mediante la condición que indica el residuo de la
división por 2, entre la variable i que maneja el ciclo for. Si ésta condición se cumple quiere
decir que el número es impar, así que la sentencia continue permite que se interrumpan las
iteraciones impares y continuar ejecutando el programa. De esa manera, el código sólo se
ejecutará cuando “i” sea par y mostrará por consola el mensaje de “Números pares:” y cada
número par.
61
7. Estructuras de almacenamiento
Arrays.
Cuando se utiliza la instrucción repetitiva ‘para todo (for)’, es correcto escribirla de dos
maneras, primera:
Aquí se están indicando los límites de la variable de control; para indicar el límite superior
se hace uso del atributo “lenght”, el cual guarda el tamaño del arreglo, por ejemplo si el
arreglo es de 5 posiciones el límite se da “nombre_del_arreglo.lenght - 1”, como se inicia
desde la posición 0 es necesario restarle una unidad para que el recorrido del arreglo sea
correcto si se utiliza el comparador ‘<=’, utilizando ‘<’ se ahorra esta aclaración.
Pero hay una segunda forma de escribir esta misma instrucción:
Es una forma simplificada para mostrar los valores de un array, en este caso la variable de
control toma el valor de todos los elementos de la estructura de almacenamiento, esto
quiere decir que cuando se utiliza un “for” no es necesario especificar los límites de la
variable de control, es suficiente con que esta variable sea del tipo almacenado en el array.
Un array puede contener diversos tipos de datos tales como int, double, String, objetos, etc.,
a continuación algunos ejemplos:
Aquí se inicializa el arreglo indicando la lista de valores que se van a almacenar, dichos
valores son de tipo String.
62
En este caso igual que el anterior se inicializa indicando los valores que se almacenarán
pero variando en el tipo de dato, que es de tipo entero.
Aquí el tipo de dato es una instancia de la clase vehículo, es decir el arreglo está compuesto
de objetos.
Arrays multidimensionales.
Los arrays multidimensionales se escriben de la misma manera de un array unidimensional.
Este es un ejemplo de un array bidimensional indicando los límites de la variable de
control.
Y como ya se ha mencionado en un “for” para mostrar los datos del arreglo no es necesario
indicar los límites de la variable de control.
63
En este ejemplo en el constructor de la clase se indican tres arreglos especificando el
tamaño, es decir, el arreglo “Cliente [50]”, no puede contener más de 50 elementos de la
manera en la que está indicado en este caso. Con el uso de arrays redimensiónales es
posible evitar indicar el tamaño del array, quedaría expresado de la siguiente manera:
64
De esta manera el arreglo queda creado y se irán agregando los datos necesarios sin indicar
el tamaño del array, usando la librería “java.util.List” y “java.util.ArrayList”
El algoritmo de ordenación “Bubble Sort”.
Este algoritmo ordena los números de un arreglo de menor a mayor pero hay una etiqueta
que permite realizar este proceso de manera automática por llamarlo de alguna manera;
quedaría escrito de la siguiente manera:
Utilizando el método “sort” se realiza el mismo proceso de ordenar los números de un
arreglo en forma ascendente del anterior código. Java define varios métodos que permiten
realizar operaciones de organización y búsqueda.
65
8. Entrada y salida
Entrada de datos desde el teclado.
En Java es posible leer los datos que se introducen por teclado, para leer una palabra se usa
el método “next ()”, para leer una línea “nextLine ()”, y un número entero con el método
“nextInt ()”, es necesario también la librería “Scanner” la cual habilita estos métodos y el
flujo de entrada “System.in” lee los datos que se introducen desde el teclado.
