Wiki Manual Java

5/12/2018 Wiki Manual Java - slidepdf.com

http://slidepdf.com/reader/full/wiki-manual-java 1/74PDF generado usando el kit de herramientas de fuente abierta mwlib. Ver http://code.pediapress.com/ para mayor información.

PDF generated at: Fri, 02 Jul 2010 18:20:52 UTC

Java WikiManual


http://slidepdf.com/reader/full/wiki-manual-java 2/74

Contenidos

Artículos

Programación en Java 1

Programación en Java/Instalación JDK 4

Programación en Java/Características del lenguaje 7

Programación en Java/Primer programa 9

Programación en Java/Variables 10

Programación en Java/Literales 13

Programación en Java/La palabra reservada final 15

Programación en Java/Secuencias de Escape 15

Programación en Java/Arrays 16

Programación en Java/Operadores 18

Programación en Java/Operadores aritméticos 18

Programación en Java/Operadores relacionales 21

Programación en Java/Operadores booleanos 22

Programación en Java/Operadores de bits 24

Programación en Java/Operadores de asignación 27

Programación en Java/Operador cast 28

Programación en Java/Precedencia de operadores 29

Programación en Java/Estructuras de control 31

Programación en Java/Estructuras de selección 31

Programación en Java/Sentencia if-else 32

Programación en Java/Sentencia switch 36

Programación en Java/Operador if-else 39

Programación en Java/Estructuras de iteración 40

Programación en Java/Sentencia while 41

Programación en Java/Sentencia do-while 43Programación en Java/Sentencia for 45

Programación en Java/Sentencia break 47

Programación en Java/Sentencia continue 48

Programación en Java/Funciones 48

Programación en Java / Parámetros de una función 50

Programación en Java/Cláusula return 53

Programación en Java/Funciones recursivas 53

Programación en Java/Programación Orientada a Objetos 55

Programación en Java/Clases 56



Programación en Java/Ejemplos de Implementación 58

Programación en Java/Ejercicios Prácticos 58

Programación en Java/Objetos 59

Programación en Java/Encapsulamiento 60

Programación en Java/Herencia 60

Programación en Java/Polimorfismo 60

Programación en Java/La clase String 61

Programación en Java/La clase Vector 62

Programación en Java/La clase Hashtable 64

Programación en Java/Imprimir en Pantalla 65

Programación en Java/Applets 65

Programación en Java/Palabras reservadas 65

Programación en Java / Prácticas 67

Referencias

Fuentes y contribuyentes del artículo 68

Fuentes de imagen, Licencias y contribuyentes 70

Licencias de artículos

Licencia 71




Programación en Java

Programación en JavaJava es un lenguaje de programación de propósito general y orientado a objetos desarrollado por Sun Microsystems.

Sobre este libroEste material es un wikilibro, puedes editarlo según las normas y políticas . Todas las sugerencias, comentarios y

modificaciones son bienvenidas siempre y cuando contribuya a mejorar la calidad del contenido.

Este libro se realiza con la intención de enseñar a programar en Java. Todo el contenido trata de una introducción al

lenguaje. En el caso de que quieras ver tópicos avanzados o de programación en general, los temas serán reservados

para otros libros.

Solo necesitas un conocimiento mínimo de computación para leer y comprender este material. Si tienes alguna duda,

o alguna parte te parece muy difícil de seguir, puedes realizar tus comentarios en la pagina de discusión. No

prometemos que serán respondidas las consultas sobre el lenguaje Java, si puedes esperar respuestas sobre los temas

aquí tratados.

Este libro no está exento de errores u omisiones. Tratamos que los ejemplos expuestos aquí, estén probados. Pero no

ofrecemos ninguna garantía. Puede ser que algún programa no funcione como se explica aquí debido a que fueron

probados en circunstancias diferentes. Te alentamos a que notifiques o edites cualquier error.

Este material se comenzó a editar con la especificación de Sun Microsystems para el JDK 1.4.2. Existen, al momento

de escribir el libro, modificaciones en el lenguaje que serán tratadas a medida que esta obra se complete.

Sun, Sun Microsystems, Java y todas las marcas comerciales que contienen los términos Sun y Java que aparecen en

este sitio son marcas comerciales o marcas registradas de Sun Microsystems, Inc. en los EE.UU. y otros países.

Se está realizando una versión para imprimir en Versión para imprimir.

Temas PendientesRecién comenzamos. Algo ya tenemos para ir revisando. Un poco de pintura por aquí, un poco de retoque por allá.

Algunas partes ni siquiera tienen los cimientos. Animamos al que quiera contribuir, es libre de hacerlo. Pero si no

tienes conocimientos o tiempo para escribir y quieres que un tema en particular aparezca en esta obra, puedes

incluirlo en este listado. Aquí enumeramos el contenido que falta. Recuerda que únicamente incluimos tópicos sobre

una introducción al lenguaje Java.

• Instalación del JDK.

• Breve explicación de los elementos de un programa.

• Prácticas de todos los temas.

• Entornos de desarrollo.

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Versi%C3%B3n_Para_Imprimir

http://es.wikibooks.org/w/index.php?title=Wikilibros:Pol%C3%ADticas_y_orientaciones

http://es.wikipedia.org/wiki/es:Sun_Microsystems

http://es.wikipedia.org/wiki/es:Lenguaje_de_programaci%E3%AE%9FJava




Índice de contenidos1. Instalación JDK

2. Características del lenguaje

3. Primer programa

4. Variables

1. Literales

2. La palabra reservada final

3. Secuencias de Escape

4. Arrays

5. Operadores

1. Operadores aritméticos

2. Operadores relacionales

3. Operadores booleanos

4. Operadores de bits

5. Operadores de asignación

6. Operador cast

7. Precedencia de operadores

6. Estructuras de control

1. Estructuras de selección

1. Sentencia if-else

2. Sentencia switch

3. Operador if-else

2. Estructuras de iteración

1. Sentencia while

2. Sentencia do-while

3. Sentencia for

3. Saltos

1. Sentencia break

2. Sentencia continue

7. Funciones

1. Parámetros de una función

2. Cláusula return

3. Funciones recursivas

8. Programación Orientada a Objetos

1. Clases

1. Ejemplos de Implementación

2. Ejercicios Prácticos

2. Objetos

3. Ciclo de vida de un objeto

4. Paquetes

5. Encapsulamiento

6. Herencia

7. Interfaces

8. Polimorfismo

9. Excepciones

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Control_de_errores

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Interfaces

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Paquetes

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Ciclo_de_vida_de_un_objeto

http://es.wikibooks.org/w/index.php?title=Archivo:00%25.png


































10. Almacenamiento en Java

1. La clase String

2. La clase StringBuffer

3. La clase StringTokenizer

4. Vectores (Arreglos)

5. Colecciones (JFC)

1. La clase ArrayList

2. La clase Vector

3. La clase Stack

4. La clase Hashtable

5. La clase HashSet

6. La clase LinkedList

7. La clase TreeMap

8. La clase StringTokenizer

11. Entrada y Salida

1. Imprimir en Pantalla

2. Lectura del Teclado

12. Interfaz Gráfica

1. Componentes Swing

2. Eventos

3. Applets

13. Threads

1. ¿Qué es un thread?

2. MPI en Java

14. Acceso a bases de datos

1. Acceso mediante JDBC

2. Acceso mediante JPA

3. Apache Derby

15. Comunicaciones mediante redes IP

16. Aplicaciones WEB

1. Servlets

2. JSP

3. Spring Framework

17. Clusters Terracota

18. Apéndices

1. Palabras reservadas

1. Ejemplos prácticos

1. Crear un PDF en Java


http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Crear_un_PDF_en_Java


http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Terracota

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/WEB




http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Red_IP

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/BasesDeDatos




http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Threads



http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Eventos

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Componentes_Swing

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Interfaz_Gr%C3%A1fica

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Lectura_del_Teclado

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Entrada_y_Salida

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/La_clase_StringTokenizer

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/La_clase_TreeMap

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/La_clase_LinkedList

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/La_clase_HashSet

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/La_clase_Stack

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/La_clase_ArrayList

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Colecciones_%28JFC%29

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Vectores_%28Arreglos%29

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/La_clase_StringTokenizer

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/La_clase_StringBuffer

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Almacenamiento_en_Java




Prácticas de JavaPara reforzar el aprendizaje del lenguaje es útil que practiquemos con él. En esta sección se están desarrollando una

serie de prácticas correspondientes a las secciones del libro. Esta parte esta en estado "experimental"

Prácticas

Programación en Java/Instalación JDK

Instalación en Windows

Guía de instalación del Java Development Kit en Windows

1. En primer lugar, descargue el archivo de la instalación desde la pestaña “downloads” desde http://java.

sun.

com/ javase/downloads/index. jsp

1. Busque el JDK 6 Update 17 (o última actualización), Development Kit, y baje el fichero de instalación para

Windows

2. (también se puede encontrar la versión para Windows x64): jdk jdk-6u17-windows-i586-p.exe

2. Trabaje como usuario Administrador.

3. Ejecute el fichero de la instalación que haya bajado, y conteste afirmativamente a lo que le pregunte el asistente

de la instalación.

1. Se le propondrá una carpeta en la que depositar la instalación, típicamente: C:\Archivos de

programa\Java\jdk6u7 (puede indicarle una ubicación alternativa).

4. El programa habrá instalado completamente la máquina virtual, pero no el compilador javac.

1. Debe poner la ruta del compilador en la variable de entorno PATH.

2. Si la instalación se ha hecho en el directorio indicado en el párrafo anterior, javac.exe se encontrará en:

C:\Archivos de programa\Java\jdk6u7\bin

5. Entre en el Panel de control, en el menú de “opciones avanzadas” del Sistema, y modifique el valor de la variable

de entorno PATH, añadiéndole al final esta ruta (hay que separarla mediante un ; de la última ruta que aparezca

escrita en la variable).

Instalación en GNU/Linux

Guía de instalación del Java Development Kit mediante repositorio:

El cambio de licencia del JDK de Sun permitió que las principales distribuciones de GNU/Linux (y BSD)

incorporasen OpenJDK en sus repositorios de software de forma que la instalación y actualizaciones se automatizan

mediante las utilidades estándar de cada distribución. Puede consultarse la documentación que acompaña a las

mismas para obtener más información, aquí se muestran unos ejemplos para algunas distribuciones populares (estos

ejemplos no significan ninguna preferencia sobre otras distribuciones no listadas).

http://java.sun.com/javase/downloads/index.jsp






Mandriva

Para instalar en Mandriva Linux como root ejecutamos:

# urpmi.update -a

El comando anterior actualiza la base de datos de software disponible en los repositorios. A continuación

ejecutamos:

# urpmi java-1.6.0-openjdk

Opcionalmente podemos instalar otros paquetes relacionados:

# urpmi java-1.6.0-openjdk-src <--- fuentes de JDK

# urpmi java-1.6.0-openjdk-javadoc

# urpmi eclipse-jdt <--- Entorno de desarrollo Java para eclipse

# urpmi tomcat6 <--- Desarrollo de aplicaciónes web con java

El proyecto Apache jakarta contiene una extensa colección de librerías java de uso frecuente. Muchas se encuentran

tambíen disponibles como paquetes. Para ver el listado de librerías disponibles:

# urpmf --name "jakarta"

jakarta-commons-collections

jakarta-commons-beanutils

jakarta-commons-pool

jakarta-commons-dbcp-tomcat5

jakarta-commons-httpclient

jakarta-commons-io

...

Las librerías (ficheros jar) quedarán instaladas bajo el directorio /usr/share/java.

Periódicamente podemos actualizar el software mediante:

# urpmi.update -a

# urpmi --auto-select

El comando urpmi --auto-select actualizará el JDK así como cualquier otro software ya instalado en la máquina de

trabajo.

Debian (Ubuntu, Mephis, etc...)

Para instalar en Debian como root ejecutamos:

# apt-get update

El comando anterior actualiza la base de datos de software disponible en los repositorios. A continuación

ejecutamos:

# apt-get install openjdk-6-jdk

Opcionalmente podemos instalar otros paquetes relacionados:

# apt-get openjdk-6-source <--- fuentes de JDK

# apt-get openjdk-6-doc

# apt-get eclipse-jdt <--- Entorno de desarrollo Java para eclipse

# apt-get tomcat6 <--- Desarrollo de aplicaciónes web con java (En Debian Stable sólo está disponible la versión 5.5)




El proyecto Apache jakarta contiene una extensa colección de librerías java de uso frecuente. Muchas se encuentran

tambíen disponibles como paquetes. Para ver el listado de librerías disponibles:

# apt-cache search "libcommons"

libcommons-collections3-java - A set of abstract data type interfaces and implementations

libcommons-beanutils-java - utility for manipulating JavaBeans

libcommons-pool-java - pooling implementation for Java objects

libcommons-dbcp-java - Database Connection Pooling Services

libcommons-httpclient-java - A Java(TM) library for creating HTTP clients

libcommons-io-java - Common useful IO related classes

...

Las librerías (ficheros jar) quedarán instaladas bajo el directorio /usr/share/java.

Periódicamente podemos actualizar el software mediante:

# apt-get update

# apt-get upgrade

El comando apt-get upgrade actualizará el JDK así como cualquier otro software ya instalado en la máquina de

trabajo.

Otros sistemas

Es importante resaltar que quizás el sistema Linux más utilizado para aplicaciones java es RedHat o su variante

Fedora, debido principalmente a que dicha compañía es propietaria de JBoss, un potente sistema basado en Java muy

utilizado en entornos profesionales financieros. Sin embargo el autor de estas líneas no disponía de información

fiable sobre la instalación de Java en dicha distribución, aunque considera oportuno mencionarla.

Guía de instalación del Java Development Kit en Linux (sin usar repositorios, directamentede Sun.com):

1. En primer lugar, descargue el archivo de instalación desde la pestaña “donwloads” desde: http://java. sun. com/

javase/downloads/index. jsp

1. Busque el JDK 6 Update 17 (o última actualización), Development Kit, y baje el fichero de instalación para

Linux (también se puede encontrar la versión para Linux x64): jdk-6u7-linux-i586.bin

2. Supóngase que este fichero se deja en el directorio temporal /tmp .

2. Entre como superusuario (root) # su (pedirá la contraseña, tecléela y siga adelante)

3. Ubíquese en el directorio a partir del que desea instalar el JDK.

1. Típicamente /opt.2. # cd /opt

4. Ejecute el fichero de la instalación # /tmp/jdk-6u7-linux-i586.bin (conteste afirmativamente a lo que le pregunte)

5. Prepare un enlace simbólico a la nueva instalación del JDK

1. # cd /usr/lib

2. # mv java java.old

3. # ln -s /opt/jdk1.6.0_07 java

4. (en el segundo paso, el mv java java.old puede sustituirse por rm -f java, si está seguro de que desea

eliminarlo)

6. Asegúrese de que la variable de entorno PATH contiene el directorio /usr/lib/java/bin.

1. Si no lo tiene, modifique el fichero correspondiente según la distribución de Linux que utilice. Habitualmente

sería en /etc/profile, y lo que habría que añadir es un par de líneas como las siguientes:






PATH="${PATH}:/usr/lib/java/bin"

export PATH

Programación en Java/Características dellenguajeEs un lenguaje sencillo de aprender. Su sintaxis es la de C++ “simplificada”. Los creadores de Java partieron de la

sintaxis de C++ y trataron de eliminar de este todo lo que resultase complicado o fuente de errores en este lenguaje.

Java es un lenguaje orientado a objetos, aunque no de los denominados puros; en Java todos los tipos, a excepción de

los tipos fundamentales de variables (int, char, long...) son clases. Sin embargo, en los lenguajes orientados a objetos

puros incluso estos tipos fundamentales son clases, por ejemplo en Smalltalk.

El código generado por el compilador Java es independiente de la arquitectura: podría ejecutarse en un entorno

UNIX, Mac o Windows. El motivo de esto es que el que realmente ejecuta el código generado por el compilador no

es el procesador del ordenador directamente, sino que este se ejecuta mediante una máquina virtual. Esto permite que

los Applets de una web pueda ejecutarlos cualquier máquina que se conecte a ella independientemente de qué

sistema operativo emplee (siempre y cuando el ordenador en cuestión tenga instalada una máquina virtual de Java).

Características• Lenguaje totalmente orientado a Objetos. Todos los conceptos en los que se apoya esta técnica, encapsulación,

herencia, polimorfismo, etc., están presentes en Java.

• Disponibilidad de un amplio conjunto de librerías. Como ya se mencionó anteriormente, Java es algo mas que

un lenguaje. La programación de aplicaciones con Java se basa no solo en el empleo del juego de instrucciones

que componen el lenguaje, sino, fundamentalmente, en la posibilidad de utilizar el amplísimo conjunto de clases

que Sun pone a disposición del programador y con las cuales es posible realizar prácticamente cualquier tipo de

aplicación.

• Lenguaje simple. Java posee una curva de aprendizaje muy rápida. Resulta relativamente sencillo escribir applets

interesantes desde el principio. Todos aquellos familiarizados con C++ encontrarán que Java es más sencillo, ya

que se han eliminado ciertas características, como los punteros. Debido a su semejanza con C y C++, y dado que

la mayoría de la gente los conoce aunque sea de forma elemental, resulta muy fácil aprender Java. Los

programadores experimentados en C++ pueden migrar muy rápidamente a Java y ser productivos en poco tiempo.

• Distribuido Java proporciona una colección de clases para su uso en aplicaciones de red, que permiten abrir

sockets y establecer y aceptar conexiones con servidores o clientes remotos, facilitando así la creación de

aplicaciones distribuidas.

• Interpretado y compilado a la vez Java es compilado, en la medida en que su código fuente se transforma en

una especie de código máquina, los bytecodes, semejantes a las instrucciones de ensamblador. Por otra parte, es

interpretado, ya que los bytecodes se pueden ejecutar directamente sobre cualquier máquina a la cual se hayan

portado el intérprete y el sistema de ejecución en tiempo real (run-time).

• Robusto Java fue diseñado para crear software altamente fiable. Para ello proporciona numerosas

comprobaciones en compilación y en tiempo de ejecución. Sus características de memoria liberan a los

programadores de una familia entera de errores (la aritmética de punteros), ya que se ha prescindido por completo

los punteros, y la recolección de basura elimina la necesidad de liberación explícita de memoria.

• Seguro (?) Dada la naturaleza distribuida de Java, donde las applets se bajan desde cualquier punto de la Red, la

seguridad se impuso como una necesidad de vital importancia. A nadie le gustaría ejecutar en su ordenador

programas con acceso total a su sistema, procedentes de fuentes desconocidas. Así que se implementaron barreras

http://es.wikipedia.org/wiki/bytecode



Programación en Java/Características del lenguaje 8

de seguridad en el lenguaje y en el sistema de ejecución en tiempo real.

• Indiferente a la arquitectura Java está diseñado para soportar aplicaciones que serán ejecutadas en los más

variados entornos de red, desde Unix a Windows Nt, pasando por Mac y estaciones de trabajo, sobre arquitecturas

distintas y con sistemas operativos diversos. Para acomodar requisitos de ejecución tan diversos o variopintos, el

compilador de Java genera bytecodes: un formato intermedio indiferente a la arquitectura diseñado para

transportar el código eficientemente a múltiples plataformas hardware y software. El resto de problemas los

soluciona el intérprete de Java.

• Portable La indiferencia a la arquitectura representa sólo una parte de su portabilidad. Además, Java especifica

los tamaños de sus tipos de datos básicos y el comportamiento de sus operadores aritméticos, de manera que los

programas son iguales en todas las plataformas. Estas dos últimas características se conocen como la Máquina

Virtual Java (JVM).

• Alto rendimiento

• Multihebra Hoy en día ya se ven como terriblemente limitadas las aplicaciones que sólo pueden ejecutar una

acción a la vez. Java soporta sincronización de múltiples hilos de ejecución (multithreading) a nivel de lenguaje,

especialmente útiles en la creación de aplicaciones de red distribuidas. Así, mientras un hilo se encarga de la

comunicación, otro puede interactuar con el usuario mientras otro presenta una animación en pantalla y otrorealiza cálculos.

• Dinámico El lenguaje Java y su sistema de ejecución en tiempo real son dinámicos en la fase de enlazado. Las

clases sólo se enlazan a medida que son necesitadas. Se pueden enlazar nuevos módulos de código bajo demanda,

procedente de fuentes muy variadas, incluso desde la Red.

• Produce applets Java puede ser usado para crear dos tipos de programas: aplicaciones independientes y applets.

Las aplicaciones independientes se comportan como cualquier otro programa escrito en cualquier lenguaje, como

por ejemplo el navegador de Web HotJava, escrito íntegramente en Java. Por su parte, las applets son pequeños

programas que aparecen embebidos en las páginas Web, como aparecen los gráficos o el texto, pero con la

capacidad de ejecutar acciones muy complejas, como animar imágenes, establecer conexiones de red, presentar

menús y cuadros de diálogo para luego emprender acciones, etc.

http://es.wiktionary.org/wiki/variopinto




Programación en Java/Primer programaNuestro primer programa será sencillo y mostrará el saludo "Hola Mundo" en la pantalla. Para crear el programa

necesitaremos realizar los siguientes pasos:

1. Crear el código fuente. Un archivo de código fuente contiene texto escrito en el lenguaje de programación Java.

Se puede utilizar un simple editor de texto para crear y editar el código.

2. Compilar el código fuente. El compilador translada el código fuente en instrucciones que la máquina virtual de

Java pueda entender. El compilador crea esas instrucciones en un archivo bytecode.

3. Ejecutar el programa. El intérprete Java, instalado en el sistema operativo, implementa la máquina virtual de

Java. Este intérprete transforma el bytecode en instrucciones que pueda entender el sistema operativo.

Escribiendo el códigoPara crear el código fuente, abrimos un editor, por ejemplo, el Bloc de Notas de Windows, o el 'vim' en cualquier

Unix, y escribimos:

/*

El programa Hola Mundo muestra un saludo en la pantalla

*/

public class HolaMundo {

public static void main(String[] args){

//Muestra "Hola Mundo!"

System.out.println("Hola Mundo!");

}

}

Hay que tener cuidado de copiar el código tal cual se muestra aquí. El lenguaje Java es sensible a las mayúsculas y

minúsculas, entonces HolaMundo no es lo mismo que holamundo. Una vez terminado lo guardamos en un archivo

con el nombre de "HolaMundo.java".

Compilando el código==public class HolaMundo {


System.out.println("Hola Mundo!");

}

}

Una vez guardado el código fuente, abrimos el MS-DOS o Command Prompt. Nos situamos en el directorio en

donde se encuentra el archivo y luego ejecutamos el siguiente comando:

javac HolaMundo.java

Si todo sale bien, el compilador genera un archivo bytecode , HolaMundo.class en el mismo directorio en donde esta

el programa. De lo contrario muestra los errores que contiene el código.




Ejecutando el CódigoEn el mismo directorio en donde estamos trabajando escribir el siguiente comando:

java HolaMundo

Esta vez escribimos el nombre del programa, pero sin la extensión. Si hemos realizado bien los pasos y tenemos

instalado correctamente el JDK , tendremos en la pantalla el saludo:

Hola Mundo!

Para saber más• Máquina virtual de Java

• Bytecode

Programación en Java/VariablesLas variables son la manera en que indicamos al compilador el espacio en memoria que debe de reservar para

almacenar la información.

Podemos acceder a un dato alojado en la memoria por medio de una variable. Toda variable tiene un nombre para

poder identificarla y realizar operaciones. Antes de trabajar con alguna variable debemos declararla en el programa.

Por ejemplo:

String cliente;

Aquí estamos reservando memoria para una variable de tipo String y la identificamos con el nombre “cliente”. De

ahora en adelante si en el programa hablamos de cliente, estamos haciendo referencia a esa porción de memoria y al

valor que contiene.Podemos asignarle algún valor en el momento de declarar una variable. Por ejemplo:

String cliente = "Isaac Newton";

Aquí reservamos memoria para una cadena de caracteres y le asignamos el valor "Isaac Newton". También podemos

declararla y en otro lugar del programa fijarle un valor :

String cliente; // declaración

... // El programa sigue

cliente = "Isaac Newton"; // le damos un valor

La sentencia para declarar una variable se resume como:

Tipo_Dato Nombre_Variable [= Valor];

Definimos el tipo de dato, el nombre y opcionalmente su valor.

Para ver como se utilizan las variables, podemos modificar el primer programa. Agregaremos una variable que

contenga el texto que se mostrará en pantalla:

public class HolaMundo {


String saludo = "¡Hola Mundo!";

System.out.println( saludo );}

}

http://es.wikipedia.org/wiki/es:Bytecode

http://es.wikipedia.org/wiki/es:M%E1%B1%B5ina_virtual_de_Java




Definimos una variable de tipo String con el nombre "saludo". En la declaración de la variable también la

inicializamos con el valor "¡Hola mundo!". Luego llamamos al método que imprimirá el texto en la pantalla

haciendo referencia a la variable. En el programa original, explícitamente introducíamos el texto que se mostraría,

ahora solo escribimos el nombre de la variable. Cuando el intérprete se encuentre con el nombre de esta variable,

tendrá que buscar valor que almacene en la memoria para mostrarlo por pantalla.

Un variable puede cambiar su valor en el transcurso del programa.

public class UsoVariables{

public static void main(String args[]){

String saludo;

saludo = "Hola Mundo!";

System.out.println( saludo );

saludo = ("Estoy utilizando variables");


}

}

Siempre debemos inicializar una variable. Al momento de leer el contenido de una variable, el compilador de Java

siempre verifica que tenga un valor. De lo contrario el programa no compilará y mostrará el error. Un ejemplo de

este caso:

if (x > 0) {

saludo = "Hola Mundo!!!";

}


En este caso el compilador mostrará un mensaje de error indicando que la variable x no se ha inicializado con ningún

valor. Como se puede observar esta variable solo se inicia cuando se cumple una condición, sin embargo se indica

que va a ser utilizada siempre. El compilador detecta este posible error. Un ejemplo de solución posible sería:

int x = 1;

if (x > 0) {

saludo = "Hola Mundo!";

}


Agregando estas líneas al final del código de la clase UsoVariables nos mostraría lo siguiente a la salida:

Hola Mundo!

Estoy utilizando variables

Hola Mundo!!!




Nombre de la variableEl nombre debe ser único en el contexto del programa. Además debe seguir las siguientes reglas:

• No debe ser una palabra reservada del lenguaje o un literal booleano (true o false)

• Puede contener cualquier caracter Unicode, pero no debe comenzar con un número

• No debe contener los símbolos que se utilicen como operadores ( + , - , ?, etc )

Por convención: Los nombres comienzan con una letra en minúscula. Si un nombre consiste en mas de una

palabra, se escribirá sin espacios y cada palabra comenzará con una letra mayúscula (por ejemplo :

estaBienEsteNombre )

Tipo de variableCada variable debe tener un tipo de dato predefinido. Esto determina el rango de valores que puede almacenar y que

operaciones se pueden realizar. Por ejemplo una variable de tipo entero puede almacenar números sin decimales y

puede realizarse operaciones aritméticas, pero no puede contener palabras.

Existen dos categorías de variables: las de tipo primitivo o las referenciadas. Una variable de tipo primitivo accede al

valor asignado directamente. Las referenciadas se accede a través de un puntero, es decir que no almacenan un valor

sino una dirección de memoria. Estas últimas son utilizadas por las matrices , las clases e interfaces.

Tipos de datos primitivos

Tipo Tamaño y formato Rango

enteros

byte 8 bits - complemento a 2

short 16 bits - complemento a 2 -

int 32 bits - complemento a 2

long 64 bits - complemento a 2

números reales

float 32 bits - IEEE 754

double 64 bits - IEEE 754

otros

char 16 bits - caracteres UNICODE '\u0000' al '\uffff'

boolean 1 bit true o false

En otros lenguajes de programación, el formato o el tamaño de los tipos primitivos dependen del microprocesador odel sistema operativo que se están ejecutando. En cambio, Java pretende ser independiente de la plataforma, y

mantiene los formatos sin cambios. Para los caracteres alfanuméricos utiliza la codificación UNICODE de 16 bits

para permitir la inclusión de varios alfabetos.

Para saber más• Variables

• Tipos de datos

http://es.wikipedia.org/wiki/es:Tipo_de_dato

http://es.wikipedia.org/wiki/es:Variable_(programaci%E3%AE%A9




Programación en Java/LiteralesPueden existir varias formas de representar un valor. Por ejemplo al tener el número 100, significa exactamente 100

en una base decimal, pero hablamos de 4 en una base binaria o 256 en hexadecimal. Para evitar ambigüedades, en

Java se establecieron algunas normas.

Literales enterosExisten 3 maneras de representar el valor de un número entero. Si se escribe el número solamente, este representa un

número en base decimal. Si tiene un cero adelante estamos escribiendo octales y si tiene el prefijo "0x" el valor está

representado en base hexadecimal. Por ejemplo:

Base de

numeración

valor valor decimal

Decimal 100 100

Octal 0100 64

Hexadecimal 0x100 256

Para indicarle al compilador que un valor dado es de tipo long debemos incluir el sufijo L:

long largo= 800L;

Literales de números realesAl tratar con números reales introducimos el punto decimal o utilizamos la notación científica. Por ejemplo:

double v = 300000.0; // notación normal

double v = 3.0e+5; // notación -científica

En el ejemplo el valor 3.0e+5 significa . La letra e denota la mantisa, y da igual si la escribimos en

mayúscula o minúscula.

Para determinar si estamos hablando de float o double, al número se le agrega un sufijo: F o f para float y D o d para

double. Si no colocamos un sufijo el compilador lo toma como double.

Literales charUna variable de tipo char almacena un carácter Unicode. Este sistema de codificación amplía la escasez de opciones

que tiene la codificación ASCII para incluir otros alfabetos. Podemos escribir en griego, hebreo o en vietnamita sin

que el compilador proteste. Un literal de tipo char se expresa encerrando el carácter entre comillas simples:

char caracter = 'z';

Otra forma de representar un carácter es indicando el código Unicode en hexadecimal, anteponiendo los símbolos \u,

todo entre comillas simples. De esta manera el símbolo arroba ( @ ) se escribe:

char arroba = '\u0040';

El primer byte de la codificación Unicode es la misma que el viejo y querido ASCII




Literales booleanSencillamente true o false (verdadero o falso) sin comillas y en minúscula. No tienen correlación con ningún número

como ocurre en el lenguaje C que teníamos al 0 como false y al 1 como true.

Literales StringEl tipo String no es un tipo de dato primitivo. Pero se comporta como si lo fuera. Para indicar una cadena de

caracteres se encierran entre comillas dobles.

String cadena = "Time is money";

Ejemplos de valores literales

Literal Tipo de dato

"Gato" String

"G" String

'G' char

123 int

8000L long

3.14 double

3.14D double

3.14f float

26.45e-45 double

'\u00ff' char

'c' char

"true" String

true boolean

En los sufijos que tenemos para identificar el tipo de dato no importa si son en minúscula o mayúscula. Pero por

convención se utilizan en mayúscula, pues se puede confundir al leer el código una ele minúscula ( l ) con un uno ( 1

). Hay que tener cuidado de no olvidarnos los sufijos cuando sean necesarios. El siguiente código da un error en

tiempo de compilación:

float f = 3.14;

El compilador nos dará el error de "possible loss of precision" (posible pérdida de precisión). Esto se debe a que sin

la F atrás, estamos indicando un valor de tipo double. El compilador se niega a comprimir un double de 64 bits en un

float de tan solo 32 bits. Lo solucionamos de esta manera:

float f = 3.14f;

Y le alegramos la vida a un compilador gruñon.



Programación en Java/La palabra reservada final 15

Programación en Java/La palabra reservada finalEn una aplicación posiblemente nos encontremos con algún valor que permanece constante durante la ejecución.

Podemos definirla como una variable común pero perderíamos el control. Por allí, en algún descuido, se cambiaría

de valor pero no nos enteraríamos. Podemos agregar a la definición de variable el modificador final. La sintaxis es la

siguiente:

final tipo_variable nombre de variable [= valor];

Por ejemplo :

final int unaConstante = 10;

Si tratamos de modificar el valor de esta constante, el compilador indicará un error. Una vez definido el valor no se

puede modificar.

Programación en Java/Secuencias de EscapeLas secuencias de escape son pequeñas constantes que nos brindan una gran utilidad, para comprenderlo mejorcito

este ejemplo (en consola):

public class SecEsc01 {

public static void main(String args[]) {

System.out.println("Este es un ejemplo de Secuencias de Escape");

}

}

Este ejemplo presenta una linea de texto, pero, ¿que pasa si queremos este texto en tres lineas?, tendriamos que

escribir :



System.out.println("Este es un ejemplo");

System.out.println("de");

System.out.println("Secuencias de Escape");

}

}

Es algo mas tedioso, menos mal que existen las secuencias de escape en Java, la cual nos ahorraria el trabajo de la

siguiente manera



System.out.println("Este es un ejemplo\nde \nSecuencias de Escape");

}

}

Pero este es solo un ejemplo, pero que pasa si queremos una pequeña tabulacion, tendriamos que teclear la barra

espaciadora hasta una medida de espacio de la que queremos, java tamabien solucion esto de la siguiente manera:



Programación en Java/Secuencias de Escape 16



System.out.println("\tTexto tabulado");

}

}

A continuación hay una lista de secuencias de escape:

• \n -----> Nueva Linea.

• \t -----> Tabulador.

• \r -----> Retroceso de Carro.

• \f -----> Comienzo de Pagina.

• \b -----> Borrado a la Izquierda.

• \\ -----> El caracter "\".

• \' -----> El caracter "'".

• \" -----> El caracter '"'.

Programación en Java/ArraysEn java a diferencia del lenguaje C, existe un tipo de variable “especial”, el Array. Este tipo de variables no es más

que un conjunto secuencial de memoria a las que se accede a través de un índice de posición.

Los arreglos en Java son objetos, por lo que cuentan con propiedades y métodos para manipularlos. Se pueden

declarar arreglos de tipos de datos primitivos y de objetos.

Más abajo tienes la sintaxis básica de declaración de arrays.

Sintaxis:

• tipodedato nombre [] [= new tipodedato[capacidad]] o

• tipodedato[] nombre [= new tipodedato[capacidad]]

Como puedes observar puedes inicializar un array al momento de declararlo o postergar esta operación para cuando

sea necesario.

Para inicializar un array existen 2 maneras:

• int[] arreglo= new int[4] o

• int[] arreglo={100,200,302,400}

Como podrás concluir la primera declaras el array nada más diciéndole la cantidad de memoria secuencial que se

debe reservar, en el segundo ejemplo se inicializa el array dándole los valores que va a contener (obviamente la

cantidad de memoria secuencial reservada sera igual a la cantidad de elementos insertados).

Al momento de inicializar un arreglo de la manera :

• int[] arreglo= new int[4]

cada posición del arreglo sera inicializada con el valor por defecto del tipo de variable. Por ejemplo si el arreglo si el

arreglo es de tipo boolean, todas las posiciones del arreglo serán inicializadas con el valor false (ya que este es valor

por defecto de este tipo de dato), por el contrario si el arreglo fuese de un tipo no primitivo, el valor que contendrá

cada casilla sera null. A continuación tienes una lista de los valores por defecto de cada tipo de dato Tipo de

Dato-->Valor

byte-->0

short-->0

int-->0



Programación en Java/Arrays 17

long-->0

float-->0.0

double-->0.0

char-->/u0000

boolean-->false

Object (Cualquier tipo de Objeto)-->null

Para obtener el tamaño de un array de manera dinámica se utiliza la propiedad .length, esta propiedad es común para

todos los array . También es importante saber que los arreglos se empiezan a enumerar desde el numero (0) cero por

tanto para acceder al valor almacenado en la ultima posición deberás colocar el tamaño del arreglo menos 1 unidad.

Al momento de tratar de acceder a una posición fuera del rango del arreglo se lanzara un exception de tipo

java.lang.ArrayIndexOutOfBoundsException (esta exception es una exception no chequeada es por eso que no es

necesario colocar un bloque try/catch en el código)

Pasaremos con un ejemplo:

public class Arrays01 {

public static void main(String args[]) { int ita_nro[] = new int[4];

int it_cont;

for (it_cont = 0;it_cont < 4; it_cont ++){

ita_nro[it_cont] = it_cont * 2;

System.out.println(ita_nro[it_cont]);

}

}

}

Joe Herbert Arroyo Peña

Jesus M. Baez R.

Alberto Ladrón de Guevara Herrero.



Programación en Java/Operadores 18

Programación en Java/OperadoresUn operador realiza una función, toma uno o más argumentos y devuelve un resultado. Cuando vimos las variables,

definimos un tipo de dato con un conjunto de operaciones asociadas. Es de esperar que podamos realizar operaciones

aritméticas con números y lógicas con los booleanos. Estas operaciones se representan mediante operadores.

Los operadores, al igual que los métodos, se pueden sobrecargar, es decir se puede redefinir su funcionalidad

dependiendo de los tipos de datos de los operandos que reciba. Así, podemos indicar que el operador (+) realice una

suma aritmética si los operandos que recibe son dos enteros y una concatenación si recibe una cadena y otro objeto.

Programación en Java/Operadores aritméticosRealizan las operaciones aritméticas básicas: suma (+), resta (-), multiplicación (*) ,división (/) y módulo(%) para

datos de tipo numérico, tanto enteros como reales. Estas son operaciones binarias porque admiten dos operandos.

Ejemplo de utilización de estos operadores:

public class Aritmetica{


int i = 12;

int j = 10;

int suma = i + j;

int resta = i - j;

int mult = i * j;

int div = i / j;

int modulo = i % j;

System.out.print("Suma :");

System.out.println(suma );

System.out.print("Resta :");

System.out.println(resta);

System.out.print("Multiplicacion :");

System.out.println(mult);

System.out.print("Division :");

System.out.println(div);

System.out.print("Modulo :");

System.out.println(modulo);

}

}

El resultado de estas operaciones no puede quedar almacenado en una variable de tipo short o byte, por más pequeño

que sea. Si tramos de compilar esto:

short i = 1;

short j = 1;

short x = i + j;




Tendremos un "possible lost of precision" como respuesta, por mas que el pequeñito 2 entra holgadamente en una

variable short. El compilador evita que al utilizar estos tipos de datos no nos pasemos de largo. Pero de todas formas

me voy a vengar. Analicemos el siguiente código:

public class IntGrande{


int j = 2147483647;

int i = j + 1;

System.out.println("El valor obtenido es " + i);

}

}

El valor 2147483647 (es decir 2^31 - 1 ) es el más grande que puede tolerar un int. Pero veamos que pasa al sumarle

uno más. El compilador se queda mudo y cae en nuestra trampa. Ejecutamos el programa y obtenemos:

El valor obtenido es -2147483648

Desastroso, ¿Verdad? Veamos lo que pasó: Teníamos el valor máximo para los int:

01111111111111111111111111111111 : 2147483647 en números binarios.

00000000000000000000000000000001 : le sumamos 1

10000000000000000000000000000000 : Resultado: -2147483648 complemento a 2

Esta anomalía se la conoce como “overflow” (desbordamiento). El procesador puede identificar un resultado con este

problema comparando los signos. Es de esperar que si sumamos dos números positivos, no nos de como resultado un

número negativo. Pero el intérprete de Java no nos avisa, por lo tanto tenemos que cuidarnos al trabajar cerca de los

extremos.

Sigamos metiéndonos en embrollos. Veamos ahora que ocurre si tratamos de dividir cualquier numero por cero. Para

la verificación escribimos este programa:

public class DivCero{


int x = 5;

int y = 0;

int z = x/y;

System.out.println(z);

}

}

No tenemos noticias al compilar. Pero al ejecutar el programa, el intérprete nos manda a pasear con la siguiente nota:

Exception in thread "main" java.lang.ArithmeticException: / by zero

Veremos mas adelante como controlar el ánimo del interprete cuando ocurren estos errores, aquí conocidos como

excepciones. La moraleja es que no se puede dividir un entero por cero.

Sigamos dando pelea, no nos dejemos intimidar. Probemos que ocurre con los números reales:

public class DivCeroFloat{public static void main(String[] args){




float x = 5.0f;

float y = 0.0f;

float z = x/y;

System.out.println(z);

}

}

Compilamos y no escuchamos nada. Ejecutamos el programa...

Infinity

Ni error ni cosas raras, el float se aguantó los malos tratos. Esto ocurre porque los números reales en su

representación binaria soportan el valor infinito.

Operadores aritméticos unarios

Dentro de los operadores aritméticos tenemos los unarios + y – que simplemente operan con el signo de un valordado. Por ejemplo:

int h = -1;

int m = +h; // es equivalente a m = h * (+1)

int n = -h; // es equivalente a n = h * (-1)

El operador – se encarga de cambiar el signo, y el + sencillamente deja el signo como está. Nuevamente no podemos

almacenar el resultado en enteros cortos, los tipos byte y short los transforma en int. Dentro del catálogo de

operadores tenemos algunos unarios más. Se trata del auto incremental ++ y del auto decremental --.

Respectivamente, suma y resta una unidad al valor. Ambos operadores pueden ser sufijos, es decir se coloca antes

del operando o posfijo que se sitúa detrás. Veamos algunos ejemplos:

int i = 1;

i++;

++i;

i--;

--i;

En este ejemplo estamos incrementado y decrementando el valor de i. A priori parece que los operadores funcionan

igual, tanto como posfijo como sufijo, pero su comportamiento es diferente. Observemos lo que ocurre en este

ejemplo:

public class Diferentes{


int i = 2;

int j = 2;

System.out.println(i++);

System.out.println(++j);

System.out.print("Estado Final (i) :");

System.out.println(i);

System.out.print("Estado Final (j) :");

System.out.println(j);

}

}




Partiendo del mismo valor, vemos que j se incrementó, mientras que la variable i se mostró sin cambios. Si

colocamos el operador como sufijo, primero se evalúa la variable y luego se realiza la operación. En el caso de la

variable i, antes de incrementar su valor se mostró por pantalla. Para la variable j el procedimiento fue inverso. Antes

de mostrar su valor se incrementó.

Programación en Java/Operadores relacionalesRevisando algunas definiciones matemáticas, nos enteramos que los números conforman un conjunto ordenado.

Cada uno tiene una posición relativa. Sabemos que el 2 "es menor que" el 4 y que el 6 "es mas grande que" el 1. Al

comparar dos números, realizamos una función de relación.

En java disponemos de los operadores relacionales para verificar si se cumple una relación. Por ejemplo el operador

de equivalencia ( == ) nos devuelve un valor de verdadero si los operandos son iguales. Estas operaciones comparan

dos valores númericos y retorna con un valor booleano.

Operadores relacionalesOperador Utilización Resultado

> A > B verdadero si A es mayor que B

>= A >= B verdadero si A es mayor o igual que B

< A < B verdadero si A es menor que B

<= A <= B verdadero si A es menor o igual que B

== A == B verdadero si A es igual a B

!= A != B verdadero si A es distinto de B

Aquí tenemos un programa para ver el funcionamiento de estos operadores :

public class Relaciones {


int i = -3;

byte b = 5;

float f = 1e-10f;

double d = 3.14;

boolean b1 = i > i;

boolean b2 = i < b;

boolean b3 = b <= f;boolean b4 = f >= d;

boolean b5 = d != 0;

boolean b6 = 1 == f;

System.out.println( i + " > " + i + " = " + b1);

System.out.println( i + " < " + b + " = " + b2);

System.out.println( b + " <= " + f + " = " + b3);

System.out.println( f + " >= " + d + " = " + b4);

System.out.println( d + " != " + 0 + " = " + b5);

System.out.println( 1 + " == " + f + " = " + b6);

}



Programación en Java/Operadores relacionales 22

}

No nos olvidemos de los char, que también participan. Podemos comparar caracteres, pues internamente están

almacenados como números.

char a = 'A';

char b = 'B';

boolean x = a > b;

Entre los booleanos solo se permiten los operadores de equivalencia, es igual (==) o es distinto (!= )

boolean x = true;

boolean y = x == x;

boolean z = x != y;

Programación en Java/Operadores booleanosComo deben suponer, trabajan con operandos booleanos. Realizan las operaciones lógicas de conjunción

(AND),disyunción (OR) ,negación ( NOT ) y la disyunción exclusiva ( XOR ).

Operadores booleanos

Nombre Operador Utilización Resultado

AND && A && B verdadero cuando A y B son verdaderos. Evaluación condicional.

OR || A || B verdadero cuando A o B son verdaderos. Evaluación condicional.

NOT ! !A verdadero si A es falso.

AND & A & B verdadero cuando A y B son verdaderos. Siempre evalúa ambos operandos.

OR | A | B verdadero cuando A o B son verdaderos. Siempre evalúa ambos operandos.

XOR ^ A ̂ B verdadero cuando A y B son diferentes

Cada una de estas operaciones tiene asociada una tabla de verdad. Esto nos permite ver el resultado de un operador

aplicado a las distintas combinaciones de valores que pueden tener los operandos. A continuación mostraremos

como se comporta el operador AND mediante su tabla de verdad.

public class TablaAnd {


boolean x = true;

boolean y = false;

boolean a1 = x && x;

boolean a2 = x && y;

boolean a3 = y && x;

boolean a4 = y && y;

System.out.println("Tabla de verdad de la conjuncion");

System.out.println( x + " AND " + x + " = " + a1 );

System.out.println( x + " AND " + y + " = " + a2 );

System.out.println( y + " AND " + x + " = " + a3 );




System.out.println( y + " AND " + y + " = " + a4 );

}

}

Si probamos de quitar un ampersand ( & ) del operador, vemos que obtenemos los mismos resultados. Existen dos

operadores AND, uno con dos símbolos & y el otro con uno solo. También tenemos dos operadores OR.

boolean x1 = operando1 && operando2;

boolean x2 = operando1 & operando2;

boolean y1 = operando1 || operando2;

boolean y2 = operando1 | operando2;

Parece extraño, sobre todo porque tienen la misma tabla de verdad. Pero internamente tienen un comportamiento

diferente.

Cuando estamos en presencia de un operador con un solo símbolo, siempre se evalúan ambos operandos. En cambio

para el operador con el símbolo repetido, su evaluación cambia según el valor del primer operando. Por ejemplo

tenemos la siguiente operación.

boolean x = true && false;

El resultado es falso, pero el intérprete tiene que mirar el segundo operando para saberlo.

boolean x = false && true

Aquí ni se molesta en mirar el último operando, porque la operación AND es verdadera solamente cuando ambos

operandos son verdaderos.

En el caso del operador OR, se evalúa el segundo operador si el primero es falso. Cuando es verdadero, no tiene encuenta el otro operando. El resultado es verdadero sin importar el valor del segundo.

Veamos un caso extremo para mostrar como funciona la evaluación condicional. Tenemos el siguiente programa en

donde pretendemos hacer saltar al intérprete con un error.

public class Condicional {


int x = 0;

int y = 2;

boolean b = ( x != 0 ) && ( ( y / x ) != 0 );

System.out.println(b);

}

}

Sin ningún tipo de emoción, aburridamente el intérprete nos avisa que el resultado es "false". Ahora verá. Quitemos

un símbolo & y quedémonos con uno solo. El resultado es otro :

java.lang.ArithmeticException: / by zero

La primera vez verificó que x!=0 era falso, entonces dio por terminada la operación con el resultado falso. Cuando

cambiamos de operador, evaluó los dos operandos y cayó en nuestra trampa. Tuvo que calcular cuanto es y / x dando

luego un error de división por cero.

Los operadores booleanos son muy amigos de los relacionales. Se llevan bien porque los últimos dan resultados

booleanos. Entre ambos tipos de operadores se pueden construir instrucciones mas complejas.




Por ejemplo, queremos saber si un número está dentro de un rango. Solo tenemos que compararlo con los extremos:

int y = 4;

boolean x = ( y > 3 ) && ( y < 6 );

Ahora deseamos saber si una variable tiene el valor "a" no importando si es mayúscula o minúscula.

char c = 'b';

boolean x = ( c == 'a' ) || ( c == 'A' );

No olviden que el operador de equivalencia (==) tiene dos símbolos igual (=), si colocan uno solo les dará un error

de asignación.

Programación en Java/Operadores de bitsComo sabrán, los datos en una computadora internamente se representan en código binario. El microprocesador solo

entiende de ceros y unos. Luego mediante una serie de procesos nosotros vemos a este código ya transformado ennúmeros, caracteres , imágenes y sonido. Pero en realidad en la trastienda todo sigue siendo binario.

Los BitsEl método mas sencillo de representación son los números naturales. Por ejemplo, si tengo el número 85 en decimal,

solo tengo que llevarlo a binario y obtengo una serie de unos y ceros. :

1010101 = 85 en binario

Cada dígito (un cero o un uno) de este número se llama bit. Java tiene una serie de operadores capaces de manipular

estos dígitos, son los operadores de bits.

Operadores de bits

Operador Utilización Resultado

<< A << B Desplazamiento de A a la izquierda en B posiciones

>> A >> B Desplazamiento de A a la derecha en B posiciones, tiene en cuenta el signo.

>>> A >>> B Desplazamiento de A a la derecha en B posiciones, no tiene en cuenta el

signo.

& A & B Operación AND a nivel de bits

| A | B Operación OR a nivel de bits

^ A ̂ B Operación XOR a nivel de bits

~ ~A Complemento de A a nivel de bits

Para operar a nivel de bit es necesario tomar toda la longitud predefinida para el tipo de dato. Estamos

acostumbrados a desechar los ceros a la izquierda en nuestra representación de números. Pero aquí es importante. Si

trabajamos una variable de tipo short con un valor de 3, está representada de la siguiente manera :

0000000000000011

Aquí los 16 bits de un short se tienen en cuenta.




DesplazamientosLos operadores de desplazamiento, mueven los bits a la izquierda o a la derecha. El primer operando será la victima

a sacudir. El segundo indicará cuantas posiciones.

Desplazamiento a la izquierda con signo (cíclico)

Deseamos correr el número 33 dos posiciones a la izquierda. Entonces realizamos :

int j = 33;

int k = j << 2;

Este es el resultado:

00000000000000000000000000100001 : j = 33

00000000000000000000000010000100 : k = 33 << 2 ; k = 132

Cada "hueco" que queda a la derecha tras correr este número se rellena con los dígitos que van saliendo por la

izquierda (ceros en este caso). Si prestamos atención, observaremos que esta operación multiplicó a j por 2 tantas

veces como posiciones se ha desplazado. En este caso se multiplicó por 4 ( 2 x 2 ). Como el signo del número puede

cambiar tras la operación, se denomina desplazamiento con signo.

Desplazamiento a la derecha con signo (cíclico)

Volvamos a colocar como estaban los bits del caso anterior. Queremos obtener nuevamente el número 33. Para esto

desplazamos el número 132 dos posiciones a la derecha.

int k = 132;

int m = k >> 2;

Como resultado obtenemos el número original.

00000000000000000000000010000100 : k = 132

00000000000000000000000000100001 : m = 132 >> 2 ; m = 33

Podemos ver que el corrimiento a la derecha realiza una división de enteros. Divide por 2, tantas veces como

posiciones desplazadas. Los huecos que quedan por la izquierda se cubren con los bits que van saliendo por la

derecha (es cíclico).

Veamos que ocurre si pretendemos realizar un desplazamiento a la derecha con un número negativo. Tengan en

cuenta que la representación de números es de complemento a 2. Si tengo una variable de tipo int con el valor – 1 ,

internamente está almacenada de la siguiente forma :

11111111111111111111111111111111 : -1 complemento a 2

Ahora realicemos un programa para ver que ocurre con el desplazamiento.

public class CorreNeg {


int x = -1;

int y = x >> 2;

System.out.println("El resultado es: " + String.valueOf(y));

}

}

La salida del programa nos indica que:




El resultado es: -1

Quedó exactamente igual. Prueben de correr el número tantas posiciones como tengan ganas y obtendrán el mismo

resultado. Esto ocurre porque en el desplazamiento, los "huecos" que quedan a la izquierda se rellenan con el bit uno

(1), quedando inalterable.

Este operador desplaza el conjunto de bit a la derecha y agrega a la izquierda los bits que faltan según el signo. Si se

encuentra con un número positivo, agrega ceros, en cambio si son negativos agrega unos. Se lo conoce como

desplazamiento con signo.

Desplazamiento a la derecha sin signo

Modifiquemos ligeramente el programa anterior agregándole al operador un símbolo >. Nos queda de esta manera :

int x = -1;

int y = x >>> 2;

Si ejecutamos el programa nos dice lo siguiente :

El resultado es: 1073741823

Veamos de donde salió este número raro. Si lo llevamos a binario tenemos :

00111111111111111111111111111111 : 1073741823 en binario

Ahora nos damos cuenta que se han agregado dos ceros a la izquierda. Este operador desplaza a la derecha, pero no

tiene en cuenta el signo. Siempre agrega bit con el valor cero, por lo que se llama desplazamiento sin signo.

Operadores lógicos de bitsEstos operadores extienden las operaciones booleanas a los enteros. Para comprender como trabajan debemos

descomponer los enteros en un conjunto de bits. El operador aplicará una operación lógica bit por bit, tomando el

valor de uno como verdadero y el valor de cero como falso. De un operando toma un bit y aplica la operación al bit

que tiene la misma posición del segundo operando. Como resultado obtenemos otro entero.

Operador AND de Bits

Si ambos bits comparados son 1, establece el resultado en 1. De lo contrario da como resultado 0.

int k = 132; // k: 00000000000000000000000010000100

int l = 144; // l: 00000000000000000000000010010000

int m = k & l; // m: 00000000000000000000000010000000

El resultado da 128

Operador XOR de Bits

Si uno de los bits comparados es 0 y el otro 1, el resultado es 1. Si ambos bits comparados son iguales, el resultado

es 0.

int k = 132; // k: 00000000000000000000000010000100

int l = 144; // l: 00000000000000000000000010010000

int m = k ^ l; // m: 00000000000000000000000000010100

El resultado da 20




Operador NOT de Bits

Sólo invierte los bits, es decir, convierte los ceros en unos y viceversa. Observemos que es el único de esta familia

que tiene un solo operando.

int k = 132; // k: 00000000000000000000000010000100

int m = ~k; // m: 11111111111111111111111101111011

El resultado da -133

Como los enteros negativos en Java se representan con el método del complemento a dos, podemos realizar un

sencillo experimento de cambiarle el signo a un número. Para realizarlo debemos aplicar a un entero el operador

NOT y sumarle uno.

int x = 123;

int y = ~x;

int z = y + 1;

El resultado da -123,

Para saber más• Bit

• Lógica binaria

Programación en Java/Operadores de asignación

Prácticamente lo hemos utilizado en todos los ejemplos de variables y operadores. Es el operador de asignación. Este

aparece con un signo igual (=). Cambia el valor de la variable que está a la izquierda por un literal o el resultado de

la expresión que se encuentra a la derecha.

par = 2;

perímetro = Pi * diámetro;

En el ejemplo vemos la variable par toma el valor de 2 y perímetro el resultado de una expresión.

Veamos un ejemplo de una instrucción tonta, que en realidad no hace nada.

algo = algo;

La variable algo toma el valor de algo; todo queda como antes. Ahora aumentemos el valor de la variable en 3

unidades.

algo = algo + 3;

Aquí la variable toma el valor que tenía mas 3 unidades. Existe una forma de simplificar la notación anterior. Es la

siguiente:

algo += 3; // equivalente a algo = algo + 3

Se juntaron el operador de suma con el de asignación. Este atajo se puede realizar para otras operaciones además de

la suma. Es útil cuando la operación contiene como primer operando al valor de la misma variable en la que se

almacena el resultado.

http://es.wikipedia.org/wiki/es:L%E3%A7%A9ca_binaria

http://es.wikipedia.org/wiki/es:Bit



Programación en Java/Operadores de asignación 28

Operadores de asignación

Operación Operador Utilización Operación equivalnte

Suma += A += B A = A + B

Resta -= A -= B A = A - B

Multiplicación *= A *= B A = A * B

División /= A /= B A = A / B

Resto de división %= A %= B A = A % B

Desplazamiento a la izquierda <<= A <<= B A = A << B

Desplazamiento a la derecha >>= A >>= B A = A >> B

Desplazamiento a la derecha sin signo >>>= A >>>= B A = A >>> B

AND de bits &= A &= B A = A & B

OR de bits |= A |= B A = A | B

XOR de bits ^= A ^= B A = A ^ B

Programación en Java/Operador castCada vez que realizamos una operación obtenemos un resultado. Este resultado podrá tener un tipo de dato diferente

de los operandos. Veamos esto:

public class CambioTipo {


byte unByte = 2;

byte otroByte = 3;

byte result = unByte + otroByte;

}

}

Nos da un error en la compilación. Se debe a que se produjo un cambio de tipo en el resultado, en vez de un byte se

nos apareció un int. Este es un cambio de tipo implícito.

Pero no queremos que quede así. Podemos forzar al compilador que nos entregue un byte. Lo haremos de la

siguiente forma :

byte result = (byte)(unByte + otroByte);

Estamos realizando un cambio explícito de tipo, realizado con un operador cast. Este operador aparece como el

nombre del tipo a obtener entre paréntesis; siempre antepuesto al resultado que se debe modificar.

Nos encontraremos ahora con un viejo conocido que nos ha molestado antes, es el literal descarriado:

float f = 3.14;

Sabemos ya que nos dará un error debido a que es un literal double que trata de disfrazarse de float. Pero le daremos

un cast así lo transformamos en float.

float f = (float)3.14;

De esta manera el compilador no protestará porque colocamos peras con manzanas. El operador cast se ocupó de

convertir un double en un float.



Programación en Java/Operador cast 29

Existe un cierto peligro en la utilización indiscriminada de este operador. Observemos el siguiente programa :

public class Int2Byte {


int unInt = 5000;

byte unByte = (byte)unInt;

System.out.println("el resultado es : " + unByte);

}

}

Aquí intentamos meter a empujones un valor en un byte , cuyo valor es mas grande de lo soportado. Pero en este

caso Java tomas las cosas con indiferencia. Si ejecutamos el programa nos indicará :

el resultado es : -120

El resultado dista mucho del valor original. El operador cast se comportó como una picadora de bits. Si miramos con

lupa ambos valores, nos damos cuenta que ocurrió:

00000000000000000001001110001000 : un int de valor 5000

10001000 : un byte de valor -120, complemento a 2

Resulta que al aplicar el cast "cortamos" la variable int en los primeros 8 bits que corresponden al tamaño del byte.

Programación en Java/Precedencia de operadoresYa que conocimos a los operadores, vamos tratar de colocarlos todos juntos en una sola expresión. Vamos a ver

como se organizan para trabajar:

int j = 10;

boolean esCierto = j/j*j>j-j+j&&j<<j>>>j==j%j||++j<--j+j--;

Civilizadamente se organizan de acuerdo al nivel del precedencia de cada uno. Primeramente proceden los unarios,

luego los aritméticos, después los de bits, posteriormente los relacionales, detrás vienen los booleanos y por último el

operador de asignación. La regla de precedencia establece que los operadores de mayor nivel se ejecuten primero.

Precedencia de operadores

Descripción Operadores

operadores posfijos op++ op--

operadores unarios ++op --op +op -op ~ !

multiplicación y división * / %

suma y resta + -

desplazamiento << >> >>>

operadores relacionales < > <= =>

equivalencia == !=

operador AND &

operador XOR ^

operador OR |

AND booleano &&



Programación en Java/Precedencia de operadores 30

OR booleano ||

condicional ?:

operadores de

asignación

= += -= *= /= %= &= ^= |= <<= >>= >>>=

En la tabla se muestra el nivel de precedencia de los operadores. Los de mayor nivel se encuentran arriba. Podemosver que los últimos son los de asignación. Esto es lógico, ya que se debe calcular primeramente la expresión antes de

asignar un resultado a una variable.

Veamos unos ejemplos de cómo actúa esta regla.

int j = 1 + 3 * 4; // resultado j = 13

Desde que aprendimos aritmética básica, conocemos la regla que nos obliga a calcular la multiplicación antes de una

suma. Esto también se cumple en Java.

int j = 1 + 3 – 4; resultado j= 0;

Si todos los operadores tienen un nivel idéntico de precedencia se evalua la expresión de izquierda a derecha.

Utilización de paréntesisSe utilizan para aislar una porción de la expresión de forma que el cálculo se ejecute de forma independiente. Puede

forzar a una expresión a ignorar las reglas de precedencia.

int j = 1 + 3 * 4; // resultado j = 13

int h = (1 + 3) * 4 // resultado j = 16

Tomando el primer ejemplo, forzamos al compilador a realizar la suma antes que la multiplicación.

En este ejemplo es imprescindible la utilización de paréntesis :

int k = 1 + (h = 3);

Si quitamos los paréntesis el compilador protestará. Porque al establecer un nivel muy bajo para la asignación,

procede primero la suma. Pero estamos sumando con una variable sin valor.

Como en matemáticas, podemos anidar los paréntesis. Se comenzara a evaluar los internos hasta llegar a los

externos.

Cabe agregar que los paréntesis no disminuyen el rendimiento de los programas. Por lo tanto, agregar paréntesis no

afecta negativamente al programa.

int k = ((12 - 2) * ( 21 - 11)) / ((1+1)*(15-10)) + 1 ;



Programación en Java/Estructuras de control 31

Programación en Java/Estructuras de controlHasta el momento, el intérprete se dio un paseo por los ejemplos que hemos visto sin alterar el curso de ejecución.

Una por una ejecutaba las sentencias sin detenerse, ni repetir y sin saltearse ninguna, salvo si se producía un error.

Esto produce programas con poca utilidad y totalmente aburridos.

public class Secuencia {


System.out.println("Primero se ejecuta esto");

System.out.println("Luego esto");

System.out.println("Por último esto");

}

}

En el ejemplo se muestra una ejecución en secuencia.

Existen ciertas sentencias que permiten modificar el curso de ejecución. Debido a ciertas condiciones que se dan en

el programa podemos decidir que instrucciones se ejecutarán y que cantidad de veces. Para lograr esto disponemos

de un conjunto de estructuras de control.

Programación en Java/Estructuras de selecciónA menudo nos encontremos con programas o algoritmos en donde las acciones se ejecutarán de acuerdo a una

condición. Tenemos dos o mas alternativas de acción y solo una de estas tendrá lugar.

Por ejemplo, supongamos que estamos conduciendo un vehículo y en un cruce de calles nos encontramos con un

semáforo. Si la luz del semáforo es roja nos detenemos. De otro modo seguiremos manteniendo la velocidad. Aquí senos presentan dos alternativas : continuar con la marcha o frenar. Estas acciones se realizarán según una condición:

si la luz del semáforo es roja. Podemos especificar este ejemplo mediante un pseudolenguje que describa la

condición.

si luz_del_semáforo = rojo entonces

velocidad_del_vehículo = 0

Estamos frente a una selección simple: tenemos dos alternativas. Este tipo de selección la condición toma un valorlógico de verdadero o falso. Se tienen que especificar las acciones que deben ocurrir si la condición es verdadera.

Opcionalmente se puede indicar que debe ocurrir si la condición es falsa. Para lo último veamos un ejemplo.

si luz = rojo entonces frenar

de otro modo seguir con la misma velocidad.

Imaginemos que estamos en un día de mucho calor y deseamos tomar un refresco. Para ello nos dirigimos a una

máquina expendedora de gaseosas, insertamos una moneda y elegimos el tipo de bebida. Generalmente una máquina

expendedora tiene un panel con botones para realizar la elección. Internamente dispone de un programa que suelta

una lata de acuerdo al botón pulsado. El algoritmo puede ser similar a esto:

Selección de acuerdo al botón presionado:



Programación en Java/Estructuras de selección 32

En el caso de "1" expulsar lata de Orange Duke.

En el caso de "2" expulsar lata de Lemmon Duke.

En el caso de "3" expulsar lata de Cola Duke.

En el caso de "4" expulsar lata de Coffee Duke.

En el caso de "5" expulsar lata de Cherry Duke.

Tenemos varias alternativas y la acción realizada dependerá de un valor discreto. Esta es una selección múltiple.

Programación en Java/Sentencia if-elseQueremos realizar una división de enteros. Es fácil, ya sabemos como hacerlo, utilizando variables y operadores.

Pero nos queda un mal recuerdo con la división por cero. Podemos establecer una condición que permita la división

para todos los números y que rechace cualquier divisor con cara de cero. Disponemos de dos opciones : realizar o no

la división. También una condición: el divisor sea distinto de cero. Esto se parece mucho a una selección simple.

La estructura de selección simple en Java se realiza mediante la sentencia if (si, en ingles). La sintaxis es la siguiente

:

if (condición) sentencia;

La condición es una expresión booleana. La sentencia se ejecuta solamente si la expresión booleana es verdadera.

Retomando el problema de la división, incorporamos una estructura de selección para realizar la operación libre de

ceros.

public class DivisionSegura {


int x = 12;

int y = 0;

int z = 0;

if( y !=0 ) z = x / y;

System.out.println("El resultado es : " + z);

}

}

En el programa, la variable x tiene el valor del dividendo, la y el divisor y la z el cociente. La condición es una

expresión que arroja un valor booleano. En este caso se utiliza un operador relacional que verifica si y es distinto de

0. Si esta condición se cumple realiza la división. En caso contrario se saltea la división y solo imprime el valor de z,

que hemos inicializado convenientemente antes de la operación.




¿Qué ocurre si la condición no se cumple? En este caso nada. Podemos agregar una serie de instrucciones que se

ejecutarán solo si la condición no se cumple. Para esto tendremos que agregar la sentencia else. La estructura de

selección quedará así:

if (condición) sentencia 1;

else sentencia 2;

Si la condición es verdadera se ejecuta la sentencia 1 en caso contrario se ejecuta la sentencia 2. Ambas sentencias

nunca se ejecutarán al mismo tiempo, son excluyentes.

Ahora ampliemos el programa para mostrar una advertencia en el caso que se encuentre cara a cara con un cero

siniestro.



int x = 12;

int y = 0;

int z = 0;

if( y !=0 ) z = x / y;

else System.out.println("Atención! se pretende dividir por 0");

System.out.println("El resultado es : " + z);

}

}

El programa nos quedó mas completo. Con la cláusula else incluimos otra alternativa de acción. Pero algo anda

suelto. Este programa siempre muestra un resultado, se cumpla o no la condición. El mensaje por pantalla no está

incluido en la estructura de selección. Tendremos que colocarlo dentro del sector de sentencias que se ejecutarán

cuando la condición sea verdadera. Para agrupar las sentencias se utilizan las llaves ( { } ) Indicarán el inicio y el fin

de un bloque de sentencias.

Probemos como queda con un bloque



int x = 12;

int y = 2;

int z = 0;

if( y !=0 ) {

z = x / y;

System.out.println("El resultado es : " + z);} else {

System.out.println("Atención! se pretende dividir por 0");

}

}

}

Las buenas prácticas en defensa de un código mantenible han dictaminado que utilicemos las llaves en todo

momento, aún en el caso que utilicemos una sola sentencia.

if (condición) {

sentencia;} else {




sentencia;

}

Lamentablemente no siempre nos encontraremos con condiciones tan sencillas. Muchas veces tendremos que

recurrir a proposiciones compuestas para formar una condición. Para ello podemos recurrir a operadores relacionales

o lógicos. Recuerden que siempre debe dar como resultado un valor booleano.

Supongamos que deseamos saber si un año es bisiesto. Sabemos que debe ser múltiplo de 4. Para esto tendremos que

verificar si el módulo es igual a cero.

año % 4 == 0

Pero no debe ser múltiplo de 100.

( año % 4 == 0 ) && ( año % 100 != 0 )

A menos que sea múltiplo de 400.

((( año % 4 == 0 ) && ( año % 100 != 0 )) || ( año % 400 == 0 ))

Formamos una proposición compuesta con conectores lógicos. Ahora vamos a incorporarlo en una estructura se

selección.

if ((( año % 4 == 0 ) && ( año % 100 != 0 )) || ( año % 400 == 0 )) {

System.out.println("Es bisiesto");

} else {

System.out.println("No es bisiesto");

}

Los conectores lógicos nos permiten simplificar la estructura. Sin ellos nos veríamos en la necesidad de anidar las

sentencias. Veamos que ocurre si en elejemplo anterior descartamos el AND y el OR.

if ( x % 4 == 0 ) {

if ( x % 100 == 0 ) {

if ( x % 400 == 0 ) {


} else {


}

} else {


}

} else {


}

Parece complicado, pero nos demuestra muchas cosas. En primer lugar observamos que se pueden anidar las

sentencias if-else. Cada resultado de una condición puede caer en una nueva comprobación para formar una

estructura compleja de selección.

También vemos que hay cierta relación entre conectores lógicos y la estructura.




Conjunción

if (condición1 && condición2){

sentecia1;

} else {

sentencia2;

}

if ( condición1 ) {


sentencia1;

} else {

sentencia2;

}

} else {

sentencia2;

}

Disyunción

if ( condición1 || condición2 ) {

sentencia1;

} else {

sentencia2;

}

if ( condición1 ){

sentencia1;

} else {


sentencia1;

} else {

sentencia2;

}

}

Negación

if ( ! condición1) {

sentencia1;

} else {

sentencia2;

}

if ( condición1) {

sentencia2;

} else {

sentencia1;

}




Programación en Java/Sentencia switchVamos a desarrollar una calculadora totalmente elemental. Sin muchas características salvo de realizar operaciones

aritméticas con dos operandos. Disponemos de una variable de tipo char que nos indicará que tipo de operación se

debe efectuar. Realizamos la operación y mostramos el resultado en la pantalla. Después de luchar con las sentencias

if-else nos quedó algo parecido a esto:

public class MiniCalculadora {


int a = 1;

int b = 1;

char op = '/';

System.out.print("El resultado es : ");

if ( op == '+' ) {

System.out.println( a + b);

} else if ( op == '-') {System.out.println( a - b);

} else if ( op == '*') {

System.out.println( a * b);

} else if ( op == '/') {

System.out.println( a / b);

}

}

}

Ya nos alejamos bastante de las decisiones simples. Aquí tenemos de una cadena de sentencias if-else que realizan

un selección múltiple. La condición general tiene mas dos alternativas. Tendremos que acudir a la sentencia switch

que se encarga de este tipo de selección.

public class MiniCalculadora{


int a = 1;

int b = 1;

char op = '/';

System.out.print("El resultado es : ");

switch ( op ) {

case '+':

System.out.println( a + b );

break;

case '-':

System.out.println( a - b );

break;

case '*':

System.out.println( a * b );

break;

case '/':

System.out.println( a / b );

break;




default:

System.out.println("error" );

break;

}

}

}

La sentencia switch se encarga de estructurar una selección múltiple. Al contrario del enunciado if-else que sólo

podemos indicar dos alternativas, maneja un número finito de posibilidades. La estructura general del enunciado

switch es la siguiente:

switch( expresión ) {

case constante1:

sentencia1;

...

break;

...case constanteN:

sentenciaN;

...

break;

default:

sentencia;

...

break

}

El valor de la expresión y de las constantes tiene que ser de tipo char, byte, short o int. No hay lugar para booleanos,

reales ni long porque, en la ejecución, todos los valores que incorporamos se transforman en valores de tipo int.

Al evaluar la expresión de switch, el intérprete busca una constante con el mismo valor. Si la encuentra, ejecuta las

sentencias asociadas a esta constante hasta que tropiece con un break. La sentencia break finaliza la ejecución de esta

estructura. Si no encuentra ninguna constante que coincida con la expresión, busca la línea default. Si existe, ejecuta

las sentencias que le siguen. La sentencia default es opcional.

Volviendo a la mini calculadora, vemos como se organiza las distintas alternativas de acuerdo al valor de una

constante char. Estas alternativas representan las distintas operaciones que están disponibles y solo se ejecutará una

sola. Por ejemplo, si el valor del operador (en el programa figura op) es igual al signo de la suma , la sentencia

switch ejecutará solamente la línea que corresponde con esta operación.

¿Que ocurre si cambiamos la variable op por algún carácter distinto a los especificados? Entra en juego la alternativa

default y todas las setencias que le siguen. En este caso imprime por pantalla el mensaje "error". Si nos olvidamos

de incorporar esta alternativa, no pasa nada. Ninguna sentencia dentro de la estructura switch se ejecutará.

Ya que hablamos de default, es conveniente mencionar que no es necesario que quede relegado al final de la

estructura. Podemos situarla al comienzo , en el medio, en definitiva, en donde nos quede mas útil según la lógica

que apliquemos o donde queramos.

switch ( op ) {

default :

System.out.println("error");break;




case '+':


break;

...

En el ejemplo presentado, funciona de la misma manera un default al principio. Obviamente no debe existir mas de

una alternativa default.

Las sentencias break son opcionales. Se utilizan con el propósito de separar las alternativas. Pero fieles a nuestro

estilo de meternos en problemas decidimos que algunos break deben desaparecer. Probemos que ocurre con este

código:

switch ( op ) {

case '+':


case '-':

System.out.println( a - b );

break;

...

Es el mismo que el original, solo "olvidamos" de agregarle un break al final de la alternativa suma. Si cambiamos el

valor de op por el carácter '+' y ejecutamos el programa, nos responde de esta manera:

El resultado es : 2

0

Nos dio los resultados de la suma y la resta. Al no tener un break en la suma, se pasó de largo y ejecuto la de abajo ,

que justamente era la resta.

En algunas circunstancias, el break está de mas. Es posible contruir una estructura en donde se ejecuten mas de unaalternativa al mismo tiempo. Vemos un ejemplo:

public class Lineas{


int j = 2;

switch (j) {

case 5:

System.out.println("********");

case 4:


case 3:


case 2:


case 1:


}

}

}

El programa tiene por objetivo listar un número dado de líneas. Se pueden dibujar hasta 5 líneas trazadas con el

símbolo *. La cantidad dependerá del valor de la variable j. Por ejemplo, si j vale 2, activa la alternativa que tiene




esta constante y como no tiene un break que la obstaculice sigue con la alternativa de abajo.

Programación en Java/Operador if-elseSalvo ciertos detalles, el programador que conozca el lenguaje C, no notará la diferencia con este "dialecto". Sobre

todo a esta altura del curso, que sólo sometemos a Java a una programación de tipo imperativa. Entre todas las

construcciones sintácticas que Java heredó del C, existe un curioso operador ternario. Se lo llama operador if-else.

Su función es abreviar la notación de la cláusula de selección simple. La sintaxis es la siguiente.

variable = op1?op2:op3

El operando op1 debe ser de tipo booleano. Los operandos op2 y op3 pueden ser de cualquier tipo, pero compatibles

entre si y con la variable que almacene el resultado. Funciona como una selección simple. De acuerdo al valor lógico

del operando op1, si es verdadero el resultado de la operación es igual al valor del operando op2. De lo contrario, si

op1 es falso, el resultado es el valor del operando op3.

Probemos este nuevo operando. Supongamos que debemos realizar un programa que calcule la distancia entre dosnúmeros. Para lograrlo, tomamos el mayor y le restamos el menor. Para empezar, veremos como se realiza con la

cláusula if-else, que ya conocemos.

public class Distancia{


int a = 23;

int b = 12;

int j;

if ( a > b ) {

j = a - b;

} else {

j = b - a;

}

System.out.println("El resultado es: " + j );

}

}

La construcción equivalente, utilizando el operador, es la siguiente :

public class Distancia2{


int a = 23;

int b = 12;

int j = a > b ? a - b : b - a;

System.out.println("El resultado es: " + j );

}

}

Como verán, redujo bastante la notación. La expresión booleana, que conforma la condición de selección, pasó al

primer operando, la operación verdadera al segundo y la falsa al tercero.

Como cualquier operador silvestre, se puede combinar tranquilamente con el resto para formar expresiones

compuestas. Para verlo, mostramos una expresión equivalente a la anterior.

int j = (a > b ? a : b ) - ( a <= b ? a : b);



Programación en Java/Operador if-else 40

Se han utilizado los paréntesis debido a que su orden de precedencia es bajísima. De otra forma se hubiera evaluado

la resta antes de las selecciones.

Programación en Java/Estructuras de iteraciónSupongamos que nos piden que realicemos un dibujo sencillo que se despliegue por pantalla. El objetivo es mostrar

un cuadrado de 5 filas por 5 columnas trazado con cualquier carácter. Con los elementos de programación que ya

conocemos, realizamos un programa que cumpla con este requisito.

public class Cuadrado{


System.out.println("*****");





}

}

Básicamente este programa cumple con el objetivo. Pero... ¿No notan que algo anda mal? Se repitió cinco veces una

instrucción. ¿Qué ocurriría sin nos solicitaran una figura más grande? Tendríamos que agregar más líneas de código.

Y si en vez de una figura , se les ocurría pedirnos que listáramos una lista de números del uno al millón, el código

sería inmenso. También imagínense lo que tardaríamos en escribirlo.

Sin embargo tenemos un recurso para acudir en cuanto surjan estos problemas. Son las estructuras de iteración. Una

iteración consiste en una repetición de un bloque de sentencias un numero determinando de veces o hasta que se

cumpla una condición.

De esta forma el código puede simplificarse notablemente. Antes de entrar en los detalles de la implementación con

Java, veremos como podemos realizar algunas rutinas en pseudocódigo:

Repetir 5 veces :

Imprimir ("*****");

Le pasamos al intérprete la tarea de reiterar una acción. Nosotros solamente escribimos una vez lo que hay que hacer.

Siguiendo con una segunda aproximación, podríamos agregarle un registro que cuente el número de iteraciones.

Además adicionamos una condición para que indicar que el registro no debe pasar de cierto número. De esta manera,

el pseudocódigo quedará así:

N = 1;

Mientras que N <= 5

Imprimir ("*****");

N = N + 1;

Lo que hicimos fue inicializar el contador, agregar una condición de corte, indicar que sentencia se debe repetir y

finalmente incrementamos el contador. La condición es una expresión lógica que debe tener un valor de verdadero o

falso. En la ejecución, cada vez que termina la última sentencia vuelve a evaluar la condición, si se cumple sigue la

iteración, de lo contrario termina.

Esta es una estructura de iteración útil para los casos en donde sabemos a priori cuantas repeticiones se debenejecutar. Con pocos retoques se pueden realizar iteraciones desconociendo el número de ciclos.



Programación en Java/Estructuras de iteración 41

Realicemos un programa que transforme un número decimal en binario. En la vida real, para hacer esto, realizamos

sucesivas divisiones por 2 al numero decimal. A cada división tomamos el resto y continuamos hasta que el resultado

sea cero.

Por ejemplo: Tenemos que pasar el número 25 a binario

25 mod 2 = 1; 25 div 2 = 12;

12 mod 2 = 0; 12 div 2 = 6;

6 mod 2 = 0; 6 div 2 = 3;

3 mod 2 = 1; 3 div 2 = 1;

1 mod 2 = 1; 1 div 2 = 0;

(NOTA: en java actualmente se usa el signo "%" para hacer el mod)

El resultado es 11001

En general, no sabemos cuantas divisiones tendremos que realizar. Pero si sabemos que debemos llegar a cero con la

división. Las tareas que repetimos son las de tomar el resto y el resultado de la división. Con estos datos en mente,

podremos realizar un algoritmo.

DECIMAL = 25;

Mientras que DECIMAL > 0 :

BINARIO = DECIMAL % 2 + BINARIO;

DECIMAL = DECIMAL / 2;

Programación en Java/Sentencia while

La sentencia while es la más sencilla de las estructuras de iteración. La iteración continuará hasta que su condiciónsea falsa.

while ( condición ) sentencia ;

La condición tiene que tomar un valor booleano (verdadero o falso). Si este valor es verdadero, se ejecutará la

sentencia. Concluida esta acción se vuelve a evaluar la condición. Proseguirán los ciclos hasta que la condición no

cambie a falso.

Esta es una estructura de iteración preprueba, es decir primero se evalúa la condición antes de realizar cualquier

acción. Si de entrada la condición es falsa nunca ejecutará el conjunto de sentencias.

int n = 0;while ( n > 0 ) System.out.println("Esto nunca lo verás");

Dentro del conjunto de sentencia que controla, debe existir alguna que cambie el valor de la condición que se está

evaluando.

boolean prueba = true;

while ( prueba ) {

System.out.println("Esto lo verás una vez");

prueba = false;

}

Entraríamos en un ciclo infinito si nunca se modifica la condición y permanece verdadera.




boolean prueba = true;

while ( prueba ) {

System.out.println("Esto lo verás muchas veces");

}

Generalmente esta estructura se utiliza en situaciones en donde desconocemos la cantidad de ciclos que se deben

ejecutar para producir un resultado. Mostraremos como se utiliza en estas circunstancias con el ejemplo de pase a

binario, mostrado en el capítulo anterior.

Teníamos que transformar un número decimal a binario. El programa en java nos queda de esta manera:

public class Dec2Bin{


int decimal = 252222;

String binario = "";

while ( decimal > 0 ) {

binario = decimal % 2 + binario;

decimal /= 2;

}

System.out.println(binario);

}

}

Como no sabemos de antemano cuantas vueltas debe dar, simplemente esperamos que el resultado de las divisiones

sucesivas sea igual a cero.

También se pueden realizar ciclos con while en donde ya conocemos, antes de entrar en la estructura, cuantas vueltas

debe dar para terminar. Para esto nos auxiliamos con un contador de vueltas. Previamente tiene que inicializarse

antes de ingresar al ciclo. Luego en cada vuelta se modificara según la lógica del algoritmo.

Realicemos el programa que despliegue por pantalla cinco líneas de caracteres.

public class Cuadrado{


int contador = 1;

while ( contador <= 5 ) {


contador++;

}

}

}

En este algoritmo, inicializamos el contador a 1 y luego en cada ciclo se incrementa. La condición de corte tiene

como objetivo no permitir mas vueltas si el contador superó el valor 5.

Para tener varias veces el asterisco sin necesidad de imprimirlo asi "*****", utilizamos otro ciclo while y otra

variable que inicializaremos dentro del ciclo para que se cumpla la cual llamaremos "contador2", obtendremos el

mismo resultado que el anterior, el codigo quedaria asi:

public class Cuadrado {

public static void main (String args [])

{

int contador = 1;




while (contador <= 5)

{

int contador2 = 1;

while (contador2 <= 5)

{

System.out.print ("*");

contador2++;

}

System.out.println ();

contador++;

}

}

}

(copian la parte que queda fuera del recuadro punteado al principio, y la llave que queda fuera al final del mismo, lo

pegan en ready to program y lo corren)

Programación en Java/Sentencia do-whileLa sentencia de iteración do-while es de tipo posprueba. Primero realiza las acciones luego pregunta. La sintaxis es

la siguiente:

do sentencia while ( condición );

Observamos que es como un while pero al revés. Primeramente se ejecuta la sentencia y luego evalúa la condición.

Si la expresión de la condición es verdadera vuelve a dar un ciclo. De lo contrario, termina. Esto nos garantiza que la

sentencia se ejecute al menos una vez.

do System.out.println("Lo veras una vez");

while ( false );

Resulta útil para los casos en donde tendremos que realizar ciertas acciones antes de verificar una condición.

Realicemos un programa que cuente la cantidad de dígitos que posee un número. Para ello tendremos que dividir por

diez el número que nos han dado, hasta que el resultado se vuelva cero. Entonces recurrimos al while para realice los

ciclos necesarios.

public class CuentaDigitos{


int número = 4557888;

int dígitos = 0;

while ( número > 0 ) {

número /=10;

dígitos++;

}

System.out.println(dígitos);

}

}



Programación en Java/Sentencia do-while 44

¿Qué ocurre si el número que nos dan es el cero? El resultado nos dará cero. Obviamente es erróneo, debería

devolver un dígito. Pero no entra en el ciclo debido a que de entrada no satisface la condición. Podríamos

implementar una solución "ad hoc".

número /=10;

dígitos++;


número /=10;

dígitos++;

}

Realizamos primeramente las operaciones y luego entramos en el bucle si se verifica la condición. Pero no hace falta

mirar mucho para darnos cuenta que es una solución poco elegante. En realidad quedará mejor con la sentencia

do-while




int dígitos = 0;

do {

número /=10;

dígitos++;

}

while ( número > 0 );

System.out.println(dígitos);

}

}



Programación en Java/Sentencia for 45

Programación en Java/Sentencia forTrabajamos con casos de interacción en donde a priori no conocíamos la cantidad de ciclos que se ejecutaban hasta

cumplir con una condición. Para esto utilizamos la sentencia while. Pero ahora estudiaremos con más detalle

aquellos casos en donde se sabe de antemano cuantos ciclos se deben cumplir para terminar la ejecución.

Imprimiremos una tabla de multiplicar hasta el factor noveno. Si no utilizamos ninguna estructura de interacción,

deberíamos imprimir nueve líneas de código secuencial.

System.out.println("3 x 1 = 3");









Pero ya conocemos las estructuras que nos ahorran el esfuerzo de escribir tanto código. Utilizaremos una sentencia

que ya conocemos: el while

int factor = 1;

while ( factor <= 9 ) {

System.out.println("3 x " + factor + " = " + 3*factor );

factor++;

}

Utilizamos la variable factor para contar la cantidad de líneas que imprimimos. Primeramente la inicializamos en

uno. Cuando se ejecuta la interacción se controla que no supere su valor de 9. Si el valor es menor o igual que nueve,

imprime una línea de la tabla e incrementa a uno el valor de factor. Cualquier caso de interacción que se complete en

una cantidad prefijada de ciclos, necesitamos una variable de control. Si utilizamos la sentencia while, esta variable

se debe definir e inicializar antes del bucle y contar con una instrucción que modifique su valor dentro del bucle.

Veremos como este código cambia ligeramente si en lugar de while presentamos una nueva sentencia denominada

for

for ( int factor = 1; factor <= 9; factor ++ ) {

System.out.println("3 x " + factor + " = " + 3*factor );

}

la sentencia for me permite repetir un ciclo n veces, en donde se debe determinar el valor inicial y cuantas veces se

repetira.

sintaxis

for({valor inicial};{condición de termino};{factor de incremento del valor inicial}){

//acá va lo que se repetirá n veces de acuerdo a la condición de termino

}

Bucle infinito: no hay control, entonces no se detiene

for ( ;;){}



Programación en Java/Sentencia for 46

Operador coma :

for ( int k=1, j=10 ;k < j ;k++ ,j-- ){

System.out.println(k + " " + j);

}

for mejoradoSupongamos que tenemos un arreglo de enteros que deseamos presentar en pantalla, usando la orden for tradicional,

el código, podría quedar así:

int[] laiEnteros = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

for (int i = 0; i < 10; i ++)

System.out.println (laiEnteros[i]);

Java ofrece una funcionalidad extra para la orden for, mediante la que se puede simplificar notablemente el codigo

anterior, quedando así:

int[] laiEnteros = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

for (int liElemento : laiEnteros)

System.out.println (liElemento);

En este caso, liElemento toma el valor de cada uno de los elementos de laiEnteros, permitiendo una navegación más

simple, puesto que se evitan posibles errores derivados del uso de los arreglos en forma directa. También se puede

usar esta forma, para estructuras más complejas como objetos de la clase Collection

public void Presenta (Collection <Integer> poConjunto){

for (Iterator <Integer> loElemento : poConjunto)

System.out.println (loElemento)

}



Programación en Java/Sentencia break 47

Programación en Java/Sentencia breakLa sentencia de 'break' es de tipo de control de bucles. Dentro de la iteracion en un bucle, de cualquiera de los tipos

(while, do-while, for), el uso de esta sentencia rompe la iteracion de dicho bucle.

for(int j = 0; j<10; j++){

sentencia 1;

sentencia 2;

sentencia 3;

break;

};

Este bucle debería ejecutarse 10 veces, desde j = 0 hasta j = 9, sin embargo la utilización de la sentencia break,

rompe la iteración del bucle, de tal manera que tras la primera ejecución el bucle acaba habiéndose ejecutado una

sola vez.

Resulta útil la utilización de condiciones para la ruptura del bucle, de tal manera que un código como el anterior

indicado no sirve para nada. Recurrimos para ejemplificarlo al ejemplo anterior de contar dígitos). Pero en este caso

queremos que cuente los dígitos de un número pero solamente hasta llegar a 5 dígitos, en caso de que tenga más

dejaremos de contarlos:




int dígitos = 0;


número /=10;

dígitos++;

if (dígitos ==5) break;

}

if (dígitos ==5) System.out.println("El numero tiene 5 o más dígitos");;

}

}

Este programa cuenta los dígitos de un número y en caso de que dicho número tenga 5 o más dígitos nos muestra por

consola el mensaje "el número tiene 5 o más dígitos". Véase la línea "if (dígitos ==5) break;" cuya presencia hace

que en caso de que el número haya llegado a los 5 dígitos se rompa la iteración del bucle.



Programación en Java/Sentencia continue 48

Programación en Java/Sentencia continueLa sentencia de continue es de tipo de control de bucles. Dentro de la iteracion en un bucle, de cualquiera de los

tipos (while, do-while, for), el uso de esta sentencia rompe la iteracion de dicho bucle. Provocando que se ejecute la

siguiente iteracion de dicho bucle, ignorando las sentencias posteriores a "continue"

for(int j = 0; j<10; j++){

sentencia 1;

sentencia 2;

sentencia 3;

continue;

sentencia 4;

};

Este bucle se ejecuta 10 veces, pero con la salvedad de que la sentencia 4 no se ejecuta ninguna vez. Es decir, se

ejecutan las sentencias 1, 2 y 3 y cuando se llega a la sentencia de control continue se vuelve de nuevo a comprobar

la condicion del for y en caso de cumplirse de nuevo a la sentencia 1 y así sucesivamente.

Programación en Java/FuncionesQueremos depositar todo nuestro dinero ganado como programadores. Hay dos bancos que compiten por nuestros

dividendos. El primero, lo llamamos "Banco A", nos ofrecen un interés con una tasa mensual del 1 % mas una

bonificación final del 5%. El segundo, el "Banco B", nos ofrece una tasa del 1,5 %.

Como buenos programadores realizamos un algoritmo para obtener el mayor beneficio. El programa calculará el

monto obtenido en un período de 12 meses con un cálculo de interés compuesto. Para darnos una mejor idea de lo

que tenemos que hacer realizamos el algoritmo principal.

monto = 10000;

meses = 12;

for ( int n = 1; n <= meses; n++){

monto = monto + monto * interés / 100;

}

Al monto inicial le sumamos las sucesivas capitalizaciones que ganamos mes a mes, hasta llegar a un período de 12

meses.

Con este algoritmo probado, realizamos el programa:

public class ShowMeTheMoney{


int meses = 12;

float interesBanco1 = 1f;

float bonificBanco1 = 5f;

float interesBanco2 = 1.5f;

double monto = 10000;

double montoBanco1 = monto;



montoBanco1 += montoBanco1 * interesBanco1 / 100;




}

montoBanco1 += montoBanco1 * bonificBanco1 /100;


montoBanco2 += montoBanco2 * interesBanco2 / 100;

}

System.out.println("Importe final del banco1 : " + montoBanco1);


}

}

Si observamos el código, notaremos que repetimos el mismo algoritmo por cada banco. Esto ocurrirá cada vez que

tengamos que realizar un cálculo de intereses. Si la elección se extendiera a, por ejemplo, cinco bancos, tendríamos

que copiar el algoritmo para cada uno de ellos. Para no tener que repetir una y otra vez lo mismo, podemos recurrir a

una técnica muy utilizada en programación: dividir el código en funciones.

Una función es un conjunto de instrucciones que ejecutan una rutina y devuelven un resultado. El resultado puede

depender de parámetros de entrada.

Un función se construye de la siguiente manera:

tipo_resultado nombre_función (tipo_parámetro nombre_parámetro, ... ) {

sentencia1;

sentencia2;

...

sentenciaN;

}

Se debe definir el tipo de dato del resultado y el nombre que identifica a la función. Ademas, opcionalmente se

pueden definir parámetros de entrada con el tipo de dato y su nombre.

Una función permite que reutilicemos un algoritmo. En el caso de nuestro problema bancario, podemos reutilizar el

cálculo de interés aplicándolo a cada banco. Veamos como se construye esta función:

double interesCompuesto(double monto, float tasa, int períodos){

for(int n = 1; n <= períodos; n++ ){

monto += monto * tasa / 100;

}

return monto;

}

Necesitamos definir ciertos datos de entrada para ejecutar el algoritmo. Vamos a necesitar el monto inicial, la tasa de

interés y el período. A su vez definimos el tipo de datos del resultado. La función nos devuelve el monto final,

entonces el tipo de dato es double. Para identificar a la función le hemos puesto el nombre de interesCompuesto.

Para utilizar la función en el programa la llamamos por su nombre. Como esta nos devuelve un resultado, tendremos

que almacenarlo en una variable que tenga un tipo de dato compatible con el resultado.

double montoBanco2 = interesCompuesto(10000 , interesBanco2, meses);

Debemos pasar los parámetros como se han definido, en el mismo orden y con el mismo tipo de dato.

Conociendo como se arma y se invoca una función, estamos prestos para utilizarla en nuestro programa.

public class ShowMeTheMoney2{

static double interesCompuesto(double monto, float tasa, int períodos){




for(int n = 1; n <= períodos; n++ ){

monto += monto * tasa / 100;

}

return monto;

}


int meses = 12;

float interesBanco1 = 1f;

float bonificBanco1 = 5f;

float interesBanco2 = 1.5f;

double monto = 10000;



montoBanco1 = interesCompuesto( montoBanco1, interesBanco1, meses );

montoBanco1 += montoBanco1 * bonificBanco1 /100;

montoBanco2 = interesCompuesto( montoBanco2, interesBanco2, meses );System.out.println("Importe final del banco1 : " + montoBanco1);


}

}

Programación en Java / Parámetros de unafunciónLos parametros de una función son los valores que esta recibe por parte del código que la llama. Pueden ser tipos

simples u objetos.

En la declaración de la función se escriben después del nombre entre paréntesis indicándose el tipo de cada uno y su

nombre. Veamos esto a modo de ejemplo:

int dividir(int dividendo, int divisor) {

...

}

Está función recibe dos parámetros, ambos de tipo entero, uno el divisor y otro el dividendo.

A la hora de llamar a la función, los parametros se escriben también a continuación del nombre entre parentesis; pero

en este caso no se indica el tipo de estos. Veamoslo en un ejemplo:

int resultado = dividir(8,4);

En esta linea, se asigna a la variable entera resultado el retorno de la función dividir pasandole como parametros 8 y

4. dividir será una función de la clase a la cual pertenece nuestro objeto. Si queremos llamar a una función pública de

un objeto externo utilizaríamos un código similar a:

MyClaseMatematica objInstancia = new MyClaseMatematica();

int resultado = objInstancia.dividir(8,4);

Es importante recordar que en java, los parametros de los tipos primitivos (int, long, etc.) SIEMPRE se pasan por

valor. Los objetos y arrays se pasan por referencia.




Si no queremos que la función devuelva ningún parámetro debemos utilizar el tipo void. P.ej:

void print(String mensajeAImprimir) {

....

}

Funciones estáticasSupongamos que tenemos una clase de funciones matemáticas llamada Calculadora. La misma puede contener

métodos para el cálculo de logarítmos, cosenos, etc... Es un poco molesto tener que instanciar un objeto de dicha

clase para poder utilizar la misma tal y como se muestra en el siguiente ejemplo:

Calculadora objetoCalculadora = new Calculadora();

float resultado = objetoCalculadora.logaritmo(33.4);

Para solucionar esto podemos crear funciones estáticas. Estas funciones pueden ser invocadas utilizando

directamente la clase, no un objeto instancia de la misma. Para ello basta añadir el atributo static a la función. En el

caso anterior:

class Calculadora {

...

float logaritmo(float entrada){

float resultado;

...

return resultado;

}

}

Entonces el ejemplo anterior se simplifica y queda simplemente como:

float resultado = Calculadora.logaritmo(33.4);

No se debe abusar de las funciones estáticas ya que entonces perdemos la orientación a objetos de Java. Debe ser

el sentido común quien nos indique cuando realmente merece la pena utilizar las mismas. Un ejemplo donde suele

ser conveniente crear funciones estáticas es en las "fábricas" de objetos. Las fábricas de objetos crean y retornan un

nuevo objeto de forma similar al constructor de una clase, pero teniendo en cuenta el contexto de la aplicación. Las

fábricas de objetos al tener información sobre el contexto/estado de la aplicación pueden realizar tareas que un

constructor no es capaz. P.ej, la conexión por red suele estar asociada a un objeto. Las creación de una nueva

conexión por red es un proceso lento (en comparación a la velocidad de proceso de una CPU moderna) y es mejor

reutilizar conexiones de red creadas anteriormente antes de crear una nueva. En tal caso creamos una fábrica de

conexiones con una función estática getNuevaConexion:

class FabricaDeConexiones {

static java.util.ArrayList listaDeConexiones = new java.util.ArrayList();

static void Conexion getNuevaConexion(){

for (int indice=0; indice<listaDeConexiones.size(); indice++){

if listaDeConexiones.get(indice).estaLibre = true {

return listaDeConexiones.get(indice);

}

}

Conexion nuevaConexion = new Conexion(....);




listaDeConexiones.add(nuevaConexion);

}

}

En el ejemplo anterior FabricaDeConexiones.getNuevaConexion() consulta un listado de conexiones. Antes de crear

una nueva conexión recorre el listado de conexiones ya existentes y si hay alguna conexión libre devuelve la misma

antes de crear una nueva.

Así en vez de utilizar el código:

Conexion miConexion = new Conexion();

lo reemplazamos con:

Conexion miConexion = FabricaDeConexiones.getNuevaConexion();

que será mucho más rápido y fiable.

Buenas prácticas• En algunos lenguajes sin soporte para excepciones es común utilizar un entero como valor de retorno para indicar

si hubo o no error. En general 0 significa que no paso nada y un valor distinto de cero indica un error. En Java (y

cualquier otro lenguaje con control de excepciones) es una mala práctica utilizar un entero para devolver un

error. Es mejor generar y lanzar un objeto excepción para indicar un error en la función. Es fácil olvidar

comprobar el valor retornado de una función, especialmente si la función invocada pertenece a una librería y va a

ser utilizada por terceros que pueden NO ser conscientes de que la función devuelve error. Entonces el error

quedaría oculto y se manifestaría aleatóreamente en otra parte del código haciendo muy difícil su depuración y

mantenimiento.

En vez de escribir:

int imprimeTodo(String nombre, String apellido1, String apellido2){

if (nombre ==null || nombre =="") return 1;

if (apellido1==null || apellido1=="") return 2;

if (apellido2==null || apellido2=="") return 3;

System.out.println(nombre+" "+apellido1+" "+apellido2);

return 0;

}

escribiremos:

void imprimeTodo(String nombre, String apellido1, String apellido2){

String errores="";

if (nombre ==null || nombre =="") errores += "nombre no puede ser nulo/vacio,";

if (apellido1==null || apellido1=="") errores += "apellido1 no puede ser nulo/vacio,";

if (apellido2==null || apellido2=="") errores += "apellido2 no puede ser nulo/vacio,";

if (errores!="") throw new Excepcion(errores);

System.out.println(nombre+" "+apellido1+" "+apellido2);

}




• El valor de los parámetros enviados a la función deben comprobarse antes de ejecutar la lógica de la función. Si

los mismos no son válidos debe lanzarse una excepción e interrumpir la ejecución de la misma. Esto ayuda a

detectar errores y hace el código más comprensible y fácil de leer.

Programación en Java/Cláusula returnUna función puede o no devolver un resultado, según cómo haya sido declarada. La siguiente función no devuelve

nada, puesto que se pone void delante, al declararla

// Esta función no devuelve nada

void funcion ( /* parámetros */)

Sin embargo, esta otra sí devuelve un valor entero

// Esta función devuelve un valor entero

int funcion ( /* parámetros */ )

Si la función devuelve algún tipo de resultado, es obligatorio en java poner en el código de la función return

valordevuelto.

Si dentro de la función hay condicionales, es también obligatorio que en todos los posibles caminos por los que se

termine el código de la función, se ponga el return y el valor devuelto.

Lógicamente, cuando la función devuelve el resultado, finaliza la ejecución de la misma, y de cualquier estructura de

control iterativa (for, while...) aunque no se haya cumplido su condición de salida.

Programación en Java/Funciones recursivasLas funciones recursivas son aquellas que se invocan a si mismas en algún momento de su ejecución.

En análisis de Algoritmos las técnicas recursivas se usan mucho para la solución de Problemas. Esta forma en

analisis de Algoritmos es llamada Divide y Venceras.

Para poder resolver un problema de forma recursiva es necesario saber alguna solucion no recursiva para alguno de

los casos mas sencillos. "Usamos la solucion mas simple para resolver un problema mas complejo."

Así, todo método recursivo debe tener al menos una sentencia que devuelva un resultado (la solución del caso más

sencillo) y las sentencias necesarias para acercarse en cada invocación a ese caso.

La recursión permite programar algoritmos aparentemente complicados con un código simple y claro, ahorrando

trabajo al programador. A simple vista parece la solución perfecta para muchos problemas, pero hay que tener en

cuenta que en ocasiones ralentizará el programa en exceso. Por ejemplo, la función factorial en forma recursiva:

public class Factoriales {

static int factorial(int numero){

if ( numero <= 1 ) {

return 1;

} else {

return numero*factorial(numero-1);

}

}


System.out.println(factorial(5));



Programación en Java/Funciones recursivas 54

}

}

La misma función en forma iterativa:

public class Factoriales{

static int factorial(int numero){

int resultado = 1;

while(numero > 0){

resultado = resultado*numero;

número--;

}

}


System.out.println(factorial(5));

}

}

Como puede observarse, la función iterativa sólo recorre un bucle while, mientras que la recursiva invoca un método

nuevo hasta que número vale 1 (Esto requiere un trabajo considerablemente mayor por parte del ordenador).

La recursión es por lo tanto una potente herramienta en programación, pero hay que saber diferenciar cuando es útil

y cuando no.

Recursión mutuaEste en un ejemplo de recursión mutua. Se trata de un programa que devolverá true o false si el parámetro número es

respectivamente, impar o par (en el caso de que invoquemos la función impar(número)).

public class Paridad{

public static boolean impar (int numero){

if (numero==0)

return false;

else

return par(numero-1);

}

public static boolean par (int numero){

if (numero==0)return true;

else

return impar(numero-1);

}

}

Al leer el código de una sola de las funciones, no se aprecia la recursión pero existe igualmente.

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java_/_Sentencia_while



Programación en Java/Programación Orientada a Objetos 55

Programación en Java/Programación Orientadaa ObjetosFrase principal: En Java TODO es un objeto.

Tal vez has escuchado esta frase en algun foro, o incluso de un amigo, pero realmente ¿Que es un objeto?.

Pues bien, un objeto es cualquier cosa que puedas pensar o ver en este instante, un perro, una silla, una pelota, un

misil teledirigido, un enemigo en ese videojuego que ayer acabaste :), etc, etc.

Pero que tiene que ver esto con Java, podras pensar..., Pues el detalle es que Java es un lenguaje orientado a objetos.

Esto quiere decir que si lo puedes pensar, entonces lo puedes programar. Retomando el ejemplo del perro, podemos

hacer notar algunos detalles que nos ayudaran a entender ese misterioso mundo de "los objetos":

1. Los perros son animales.

2. Los perros pertenecen a una raza (aunque en algunos casos mezcla de ellas :D).

3. Los perros ladran (aunque en algunos su ladrido no se escuche).

4. Los perros comen.5. Los perros toman agua.

6. Los perros corren.

7. Los perros duermen.

8. Algunos perros tienen pulgas.

9. Algunos perros tienen dueño.

10. Algunos perros tienen nombre.

Bueno, vamos a dejar tranquilos a los perritos hasta aquí, y ahora explicar el por que enumere estas características de

nuestros amigos caninos.

En primer lugar podemos darnos cuenta que "el objeto perro" tiene características (1, 2), puede realizan acciones (3,

4, 5, 6, 7) y tienen cierto tipo de relación con otros objetos (8, 9).

Ahora no perdamos el detalle, de que ningún perro es igual a otro, es decir, aunque compartan características, no

todos pertenecerían a la misma raza, o al mismo dueño, o no vivirían en el mismo lugar, etc.

Es aquí cuando surge algo llamado "Clase". Todos los perros del mundo, pertenecen a la "Clase Perro". Y cada uno

de los perros es en si un "Objeto Perro", que pertenece a la "Clase Perro".

Ahora profundizando un poco mas en estos términos. Cuando uno programa con Java, lo que principalmente hace es

crear clases, de las cuales se crean objetos. Un código de ejemplo para entender esto seria:

class Perro{

String nombre;

String raza;

boolean pulgas;

}

Perro perrito1=new Perro();

Perro perrito2=new Perro();




Programación en Java/Clases

IntroducciónLa programación orientada a objetos (POO), se rige por ciertos principios de desarrollo de software que permiten

una implementación limpia, segura y entendible de los programas.

Dentro de la limpieza, eficiencia y calidad que exige el desarrollo de software mediante la programación por objetos,

se encuentran las Clases. Las Clases comprenden el estilo de diseño e implementación más utilizado en el modelado

por objetos, aunque no es el único.

Para empezar a utilizar Clases, entender su funcionamiento y como consecuencia, su utilización e importancia, es

necesario recordar algunos principios básico de la Programación en Java.

En el lenguaje Java existen distintos Tipos. Un Tipo es, como su nombre lo indica un "tipo" de elemento

programable ya definido dentro del lenguaje.

Los principales Tipos Primitivos de Java son: boolean (falso o verdadero), byte, short, int, float, double, long y char.

Ahora pensemos un momento: ¿qué sucede si necesitamos representar o utilizar en nuestros programas "Tipos" no

definidos? ¿qué sucedería si lo que necesito guardar o manipular es la información de una persona? ¿cómo manejo

fechas? ¿cómo declaro horarios? ¿cómo represento un auto? Son muchas las preguntas que se responden mediante la

implementación de la programación de Clases.

DefiniciónUna Clase puede considerarse como la representación programada de un objeto o situación real y existente del

mundo cotidiano. Las Clases son la forma abstracta de manejar la información de manera computacional.

Mejor veamos un ejemplo muy sencillo:

Si un programador necesita manejar la información de los clientes de la empresa para la cual trabaja, sería muy

incódomo estar declarando, inicializando y manipulando mil nombre, mil apellidos, mil direcciones, mil números de

teléfono, mil números de identificación, mil ...

La solución que plantea la POO es la utilización de Clases para representar aquellos elementos o tipos no

pertenecientes al lenguaje mismo de programación. Pues de hecho no existe un tipo primitivo que se llame "cliente".

La solución exacta que se propone es crear todos los tipos necesarios a partir, o mediante la utilización, de los tipos

ya existentes. En este caso en particular, debemos utilizar los tipos primitivos de Java para crear nuestro propio

"Tipo" (Clase).

Si desea más información, específicamente técnica, puede visitar el sitio: http:/ / es. wikipedia. org/ wiki/

Clase_(inform%C3%A1tica)

Implementación en JavaYa es momento de ver cómo funcionan las clases en Java. Para nuestra primera implementación vamos a utilizar el

ejemplo anterior.

Supóngase que necesitamos manejar la información de n cliente, si tomamos en cuenta que necesitamos n nombres,

n apellidos, n edades, y n elementos de cualquier tipo de información que deseemos almacenar o manipular con

respecto al cliente, haría muy tedioso y sucio (computacionalmente hablando) el trabajo con la información, las

variables, y por ende el programa en general.

1. Primero debemos analizar qué tipo de información queremos manipular con respecto al cliente:

http://es.wikipedia.org/wiki/Clase_(inform%C3%A1tica)

http://es.wikipedia.org/wiki/Clase_(inform%C3%A1tica)




a. Nombre

b. Apellido

c. Identificación

d. Edad

e. Dirección

f. Número de Teléfono

2. Ahora debemos analizar el tipo primitivo o no primitivo que vamos a asignarle a cada elemento de información de

nuestro cliente:

a. Nombre Es una cadena de caracteres, String

b. Apellido Es una cadena de caracteres, String

c. Identificación Es un valor numérico, int (otros programadores podrían usar String)

3. Ahora pensemos en las funciones (la funcionabilidad) que queremos darle a nuestros clientes, eso es, por ejemplo,

que podamos ver su nombre, cambiar el nombre, ver edad, etc:

a. ObtenerNombre Nos daría el nombre del clienteb. PonerNombre Nos permite cambiar o poner el nombre del cliente

c. ObtenerApellido Nos daría el apellido del cliente

d. PonerApellido Nos permite cambiar o poner el apellido del cliente

e. ObtenerID Nos daría la identificación del cliente

f. PonerID Nos permite cambiar o poner la identificación del cliente

Todas las funciones en Java siguen el siguiente modelo:

tipoFuncion tipoValorDevolver nombreFuncion ( elementosUtilizadosPorLaFuncion ) {

operacionesRealizar;

}

Explicando lo anterior, tenemos que:

tipoFuncion: especifica el grado de encapsulamiento que le vamos a dar a nuestra función, o sea, que tan accesible

va a estar para el programa. Existen dos tipos principales de funciones en Java; public, o sea, de acceso público,

queriendo decir que puede ser llamada o invocada por cualquier entidad dentro o fuera de la clase. El tipo private

indica una exclusividad mayor de funcionabilidad, lo que quiere decir que solamente puede ser invocado, en

condiciones normales, dentro de otra función.

tipoValorDevolver: indica el tipo de elemento que deseamos obtener de nuestra funcion. Por ejemplo, si deseamos

saber el nombre de un cliente usamos como tipoValorDevolver un String o cadena de caracteres.

nombreFuncion: corresponde al nombre que el programador quiere darle a la funcion.

elementosUtilizadosPorLaFuncion; corresponde a todos los elementos que necesita la función para trabajar

adecuadamente. Ejemplo sencillo, para poner el nombre de un cliente necesitamos una String como

elementoUtilizadosPorLaFuncion.

operacionesRealizar: corresponde a las operaciones matemáticas, lógicas o computacionales en genera que se

deseen aplicar a la información de la clase y a su contenido en sí.

4. Definidos los tipos y funciones, pasamos a la declaración e implementación de la Clase: (Recuerden que se utiliza

código en Lenguaje Java)

public class Cliente {

String nombre;

String apellido;




int identificacion;

}

Programación en Java/Ejemplos deImplementación

//Inicialización de la clase

public class Persona{

// Inicio de los atributos de la clase

String Nombre; int Edad;

//Inicio de la declaración de los métodos de la clase

public int MostrarEdad (){

System.out.println("La edad es: "+Edad); return Edad;

}

}

Programación en Java/Ejercicios Prácticospublic class array1{

public static void main (String []args){

String nombre[]; // Todas estas sentencias se resumen

nombre=new String[3]; // como la de abajo:

nombre[0]="Ana"; //

nombre[1]="Elisa"; // String nombre[]={"Ana", "Elisa", "Juan"};

nombre[2]="Juan"; //

for (int i=0; i<nombre.length; i++){

System.out.println(nombre[i]);

}

}

}



Programación en Java/Objetos 59

Programación en Java/ObjetosUn objeto es la instancia de una clase. Por ejemplo, si tenemos una clase perro definida de la siguiente manera:

public class Perro

{

private String color; // a traves de esta variable almacenaremos

el color del perro

private int numPatas; // a traves de esta otra almacenaremos el

numero de patas

public Perro(String col, int numP) // cabecera del constructor

de la funcion

{

color=col; // ponemos los valores que nos pasan por

parametro a las variables del objetonumPatas=numP;

}

}

Una instancia de la clase sería un perro en particular:

Perro snoopy = new Perro("blanco", 4);

En este caso estamos definiendo una nueva instancia de la clase "Perro" que llamamos snoopy, que definimos con

pelo blanco y 4 patas (si, según esto podríamos crear perros o aberraciones de la naturaleza con otro número, XD).

http://es.wikibooks.org/w/index.php?title=Clase



Programación en Java/Encapsulamiento 60

Programación en Java/EncapsulamientoJava, como lenguaje orientado a objetos puro que es, implementa la encapsulación (o encapsulamiento)

perfectamente. Este concepto consiste en la ocultación del estado, o lo que es lo mismo, de los datos miembro de un

objeto, de forma que sólo es posible modificar los mismos mediante las operaciones (métodos, en Java) definidos

para dicho objeto.

Cada objeto está aislado del exterior, de forma que la aplicación al final es un conjunto más o menos extenso de

objetos que colaboran entre sí mediante el paso de mensajes entre ellos, es decir, mediante la invocación de sus

operaciones o métodos. De esta forma, los detalles de implementación permanecen "ocultos" a las personas que usan

las clases, evitando así modificaciones o accesos indebidos a los datos que almacenan las clases.

Además, el usuario de la clase no se tiene que preocupar de cómo están implementados los métodos y propiedades,

concentrándose sólo en cómo debe usarlos.

La encapsulación es una de las principales ventajas que proporciona la programación orientada a objetos.

Programación en Java/HerenciaLa herencia es un principio fundamental de la Programación Orientada a Objetos (POO) ya que esta permite la

creacion jerarquias. Con el uso de la herencia puedes crear una clase general para definir los atributos comunes de

objetos relacionados.

Programación en Java/Polimorfismo

Son muchas formas de implementar un mismo metodo.

Es La posiblilidad de utilizar una misma expresion para invocar a diferentes versiones de un mismo método



Programación en Java/La clase String 61

Programación en Java/La clase StringLa clase String nos permite con todos sus métodos el manejo de cadenas de caracteres de forma facil.

Un String no es más que un array de caracteres. He aqui un ejemplo de creación de un String a partir de un array de

caracteres:

char data[] = {'a', 'b', 'c'};

String str = new String(data);

Siendo equivalente a:

String str = "abc";

ConstructoresLos más utilizados son:

Constructor por defecto:

String s = new String();

Crea un objeto de tipo String y lo inicializa a "vacio".

String s = new String("texto");

Es un constructor que recibe como parámetro una cadena de texto, guardándola en la variable (da igual el tamaño de

dicha cadena).

MétodosAlgunos de los métodos más utilizados son:

Método charAt, que recibe un entero como parámetro y devuelve el carácter que ocupe dicha posición en el objeto

String que lo invoque.

Ejemplo con el String s de los ejemplos del constructor:

char a = s.charAt(2);

En la variable a, quedaría guardado el carácter 'x'.

EnlacesPuedes consultar esta clase en el manual original en ingles aquí

[1]

Referencias[1] http://java. sun. com/javase/6/docs/api/java/lang/String.html

http://java.sun.com/javase/6/docs/api/java/lang/String.html

http://java.sun.com/javase/6/docs/api/java/lang/String.html




Programación en Java/La clase Vectorimport java.io.*; public class programa {

/** Creates a new instance of programa */

public static void main( String [] args ) throws IOException {

int i,n,num,op,a,ndt,x,z,sw,j;

int v[];

v=new int[10];

BufferedReader in= new BufferedReader (new InputStreamReader (System.in) );

System.out.println ("digite dimension de vector:");

n = Integer.parseInt (in.readLine());

for(i=1;i<=n;i++)

{

System.out.println("digite un numero:");

num=Integer.parseInt (in.readLine());v[i]=num;

}

System.out.println("el vector almacenado:");

for(i=1;i<=n;i++)

{

System.out.println(v[i] + " ");

}

do{

System.out.println("menu principal");

System.out.println("ingresar nota");System.out.println("buscar nota");

System.out.println("eliminar nota");

System.out.println("actualizar nota");

System.out.println("salir");

System.out.println("digite una opcion:");

op=Integer.parseInt(in.readLine());

switch(op){

case 1:

System.out.println("digite cantidad de elementos a insertar:");

j = Integer.parseInt(in.readLine());

a=n+j;

for (i=(n+1);i<=a;i++)

{

System.out.println("digite nuevo dato:");

ndt = Integer.parseInt(in.readLine());

v [i]=ndt;

}

for (i=1;i<=a;i++)

{

System.out.print(v [ i ] + " ");




}

break;

case 2:

System.out.println("digite dato a buscar:");

x=Integer.parseInt (in.readLine());

i=1;

sw=0;

while(i<=n && sw==0)

{

if(v[i]==x)

{

System.out.println("el dato se encontro:");

System.out.println("en la posicion:" + i);

sw=1;

}

i=i+1;}

if(sw==0)

{

System.out.println("el dato no existe:");

}

break;

case 3:

System.out.println("### eliminar nota ###");

break;case 4:

System.out.println("digite dato a buscar:");

x = Integer.parseInt(in.readLine());

i=1;

sw=0;

while(i<=n && sw==0)

{

if(v[i]==x)

{

System.out.println("el dato se encontro:" + i);

sw=1;

System.out.println("digite nuevo dato");

z = Integer.parseInt(in.readLine());

v[i]=z;

}

i=i+1;

}

if(sw==0)

{

System.out.println("el dato no existe:");

}




for (i=1;i<=n;i++)

{

System.out.print(v [ i ] + " ");

}

break;

case 5:

System.out.println("### salir ###");

break;

default:

System.out.println("opcion invalida");

break;

}

}while(op!=5);

System.out.println("fin del programa");

}

}

Programación en Java/La clase HashtableUna tabla hash no es más que una estructura de datos para asociar valores con llaves. Imagínate algo así:

Llave => Valor

Carlos => México José => China Juan => USA Ernesto => Perú

Ahí estaríamos relacionando un grupo de nombres con su pais de origen.

En java la implementación seria con la clase Hashtable, aunque mas recientemente se ha favorecido el uso de

Hashmap que es muy similar pero con pequeñas diferencias.

Esta es una implementación de una hashtable en java, no hace nada en especial... solo relaciona números con mas

números de forma automútica



Programación en Java/Imprimir en Pantalla 65

Programación en Java/Imprimir en PantallaComando para imprimir por pantalla y dar un salto de línea:

System.out.println("Esto sale en pantalla\n");

Lo siguiente imprime el texto por pantalla y no hay salto de línea.

System.out.println("caracteres");

Programación en Java/Appletsimport java.io.*; import java.util.*;

class CascaronIO { public static void main(String[] args) throws IOException,NumberFormatException {

BufferedReader teclado=new BufferedReader(new InputStreamReader(System.in)); PrintStream

pantalla=System.out; //aca va nuestro programa a partir de esta linea

} }

Programación en Java/Palabras reservadasLas palabras clave y las palabras reservadas son utilizadas por el lenguaje y no pueden ser usadas como nombres

de identificadores

A continuación mostramos una lista con estos identificadores y las secciones del libro en donde podemos encontrar

su definición.

Palabras clave• abstract

• boolean

• Tipo de variable

• break

• byte


• case

• Sentencia switch

• catch

• char


• class

• const (sin uso)

• continue

• default

• do

• double


http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Variables%23Tipo_de_variable







• else

• Sentencia if-else

• extends

• final

• La variable final

• finally

• float


• for

• goto (sin uso)

• if

• Sentencia if-else

• implements

• import

• instanceof

• int


• interface

• long


• native

• new

• package

• private

• protected

• public

• return

• short


• static

• strictfp

• super

• switch

• Sentencia switch

• synchronized

• this

• throw

• throws

• transient

• try

• Sentencia try

• void

• volatile

• while• wesureal

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/Sentencia_try





http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java/La_variable_final




• true (literal booleano)

• Literales boolean

• false (literal booleano)

• Literales boolean

• null (literal nulo)

Programación en Java / Prácticas• Programación en Java / Prácticas / Variables

• Programación en Java / Prácticas / Sentencias if-else

• Programación en Java / Prácticas / Operador if-else

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java_/_Pr%C3%A1cticas_/_Operador_if-else

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java_/_Pr%C3%A1cticas_/_Sentencias_if-else

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java_/_Pr%C3%A1cticas_/_Variables

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java_/_Literales%23Literales_boolean

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_Java_/_Literales%23Literales_boolean




Fuentes y contribuyentes del artículoProgramación en Java Fuente: http://es.wikibooks.org/w/index.php?oldid=149785 Contribuyentes: Bastie, Boldoc, Bufalo 1973, Earizon, EnriqueJopia, Ferk, Ihck, ManuelGR, Mike.lifeguard,

Oleinad, Pirenne, Rutrus, Vegarede, 41 ediciones anónimas

Programación en Java/Instalación JDK Fuente: http://es.wikibooks.org/w/index.php?oldid=147371 Contribuyentes: Earizon, Oleinad, Wilfredor, 5 ediciones anónimas

Programación en Java/Características del lenguaje Fuente: http://es.wikibooks.org/w/index.php?oldid=135148 Contribuyentes: Ihck, ManuelGR, Oleinad, 2 ediciones anónimas

Programación en Java/Primer programa Fuente: http://es.wikibooks.org/w/index.php?oldid=144812 Contribuyentes: Aguila3000, Albert Ovide, Albmont, Luckas Blade, ManuelGR, Oleinad,

Pirenne, 7 ediciones anónimas

Programación en Java/Variables Fuente: http://es.wikibooks.org/w/index.php?oldid=142299 Contribuyentes: Guevonaso, H, ManuelGR, Pirenne, 11 ediciones anónimas

Programación en Java/Literales Fuente: http://es.wikibooks.org/w/index.php?oldid=143265 Contribuyentes: Guevonaso, Pirenne, 5 ediciones anónimas

Programación en Java/La palabra reservada final Fuente: http://es.wikibooks.org/w/index.php?oldid=134216 Contribuyentes: Boldoc, Pedvi, Pirenne, 1 ediciones anónimas

Programación en Java/Secuencias de Escape Fuente: http://es.wikibooks.org/w/index.php?oldid=150798 Contribuyentes: Morza, Yoearroyo, 28 ediciones anónimas

Programación en Java/Arrays Fuente: http://es.wikibooks.org/w/index.php?oldid=134222 Contribuyentes: H, Jarisleif, ManuelGR, 26 ediciones anónimas

Programación en Java/Operadores Fuente: http://es.wikibooks.org/w/index.php?oldid=134226 Contribuyentes: H, ManuelGR, Pedvi, Pirenne

Programación en Java/Operadores aritméticos Fuente: http://es.wikibooks.org/w/index.php?oldid=134228 Contribuyentes: Pirenne, 4 ediciones anónimas

Programación en Java/Operadores relacionales Fuente: http://es.wikibooks.org/w/index.php?oldid=134230 Contribuyentes: Pirenne

Programación en Java/Operadores booleanos Fuente: http://es.wikibooks.org/w/index.php?oldid=134232 Contribuyentes: Pirenne, 1 ediciones anónimas

Programación en Java/Operadores de bits Fuente: http://es.wikibooks.org/w/index.php?oldid=134236 Contribuyentes: ManuelGR, Oleinad, Pirenne, 24 ediciones anónimas

Programación en Java/Operadores de asignación Fuente: http://es.wikibooks.org/w/index.php?oldid=134238 Contribuyentes: Pirenne

Programación en Java/Operador cast Fuente: http://es.wikibooks.org/w/index.php?oldid=134240 Contribuyentes: Dferg, Pirenne, Triki, 2 ediciones anónimas

Programación en Java/Precedencia de operadores Fuente: http://es.wikibooks.org/w/index.php?oldid=134242 Contribuyentes: Pirenne, 1 ediciones anónimas

Programación en Java/Estructuras de control Fuente: http://es.wikibooks.org/w/index.php?oldid=134244 Contribuyentes: Pirenne

Programación en Java/Estructuras de selección Fuente: http://es.wikibooks.org/w/index.php?oldid=134246 Contribuyentes: Pirenne, 1 ediciones anónimas

Programación en Java/Sentencia if-else Fuente: http://es.wikibooks.org/w/index.php?oldid=134248 Contribuyentes: Dferg, Pirenne, 1 ediciones anónimas

Programación en Java/Sentencia switch Fuente: http://es.wikibooks.org/w/index.php?oldid=134250 Contribuyentes: Luckas Blade, Pirenne, 5 ediciones anónimas

Programación en Java/Operador if-else Fuente: http://es.wikibooks.org/w/index.php?oldid=134254 Contribuyentes: Pirenne

Programación en Java/Estructuras de iteración Fuente: http://es.wikibooks.org/w/index.php?oldid=134256 Contribuyentes: Pirenne, 1 ediciones anónimas

Programación en Java/Sentencia while Fuente: http://es.wikibooks.org/w/index.php?oldid=134258 Contribuyentes: Luckas Blade, Pirenne, 8 ediciones anónimas

Programación en Java/Sentencia do-while Fuente: http://es.wikibooks.org/w/index.php?oldid=134262 Contribuyentes: Pirenne

Programación en Java/Sentencia for Fuente: http://es.wikibooks.org/w/index.php?oldid=147278 Contribuyentes: ManuelGR, Pirenne, 5 ediciones anónimas

Programación en Java/Sentencia break Fuente: http://es.wikibooks.org/w/index.php?oldid=134266 Contribuyentes: Pirenne, 4 ediciones anónimas

Programación en Java/Sentencia continue Fuente: http://es.wikibooks.org/w/index.php?oldid=134268 Contribuyentes: 3 ediciones anónimas

Programación en Java/Funciones Fuente: http://es.wikibooks.org/w/index.php?oldid=152584 Contribuyentes: Oscarlondono, Pillou, Pirenne, 2 ediciones anónimas

Programación en Java / Parámetros de una función Fuente: http://es.wikibooks.org/w/index.php?oldid=152580 Contribuyentes: Earizon, Oscarlondono, 4 ediciones anónimas

Programación en Java/Cláusula return Fuente: http://es.wikibooks.org/w/index.php?oldid=152582 Contribuyentes: Oscarlondono, VictorRS, 1 ediciones anónimas

Programación en Java/Funciones recursivas Fuente: http://es.wikibooks.org/w/index.php?oldid=152585 Contribuyentes: Baiji, NaitoNeko, Oscarlondono, Pirenne, VictorRS, 5 ediciones

anónimas

Programación en Java/Programación Orientada a Objetos Fuente: http://es.wikibooks.org/w/index.php?oldid=109518 Contribuyentes: Bufalo 1973, Elingedgar, Ferk, Roqueorts, Vinikike, 1

ediciones anónimas

Programación en Java/Clases Fuente: http://es.wikibooks.org/w/index.php?oldid=148007 Contribuyentes: Ferk, 22 ediciones anónimas

Programación en Java/Ejemplos de Implementación Fuente: http://es.wikibooks.org/w/index.php?oldid=148008 Contribuyentes: Ferk, Hawk ray, 1 ediciones anónimas

Programación en Java/Ejercicios Prácticos Fuente: http://es.wikibooks.org/w/index.php?oldid=110697 Contribuyentes: 1 ediciones anónimas

Programación en Java/Objetos Fuente: http://es.wikibooks.org/w/index.php?oldid=141988 Contribuyentes: 2 ediciones anónimas

Programación en Java/Encapsulamiento Fuente: http://es.wikibooks.org/w/index.php?oldid=124239 Contribuyentes: 3 ediciones anónimas

Programación en Java/Herencia Fuente: http://es.wikibooks.org/w/index.php?oldid=148124 Contribuyentes: XXkasperXx

Programación en Java/Polimorfismo Fuente: http://es.wikibooks.org/w/index.php?oldid=131069 Contribuyentes: Josias, 1 ediciones anónimas

Programación en Java/La clase String Fuente: http://es.wikibooks.org/w/index.php?oldid=148060 Contribuyentes: Maximossj, Oleinad, 1 ediciones anónimas

Programación en Java/La clase Vector Fuente: http://es.wikibooks.org/w/index.php?oldid=133385 Contribuyentes: Wutsje, 2 ediciones anónimas

Programación en Java/La clase Hashtable Fuente: http://es.wikibooks.org/w/index.php?oldid=151243 Contribuyentes: 3 ediciones anónimas

Programación en Java/Imprimir en Pantalla Fuente: http://es.wikibooks.org/w/index.php?oldid=122963 Contribuyentes: Morza, Oleinad, 5 ediciones anónimas

Programación en Java/Applets Fuente: http://es.wikibooks.org/w/index.php?oldid=104195 Contribuyentes: 1 ediciones anónimas

Programación en Java/Palabras reservadas Fuente: http://es.wikibooks.org/w/index.php?oldid=146971 Contribuyentes: Drini, Pirenne, 12 ediciones anónimas




Programación en Java / Prácticas Fuente: http://es.wikibooks.org/w/index.php?oldid=19170 Contribuyentes: Pirenne



Fuentes de imagen, Licencias y contribuyentes 70

Fuentes de imagen, Licencias y contribuyentesArchivo:75%.png Fuente: http://es.wikibooks.org/w/index.php?title=Archivo:75%.png Licencia: GNU Free Documentation License Contribuyentes: Chris 73, Cwbm (commons), Kilom691,

Ksd5, Marcelo Reis, Siebrand, 1 ediciones anónimas

Archivo:50%.png Fuente: http://es.wikibooks.org/w/index.php?title=Archivo:50%.png Licencia: GNU Free Documentation License Contribuyentes: Chris 73, Cwbm (commons), Kilom691,

Ksd5, Marcelo Reis, Siebrand, 2 ediciones anónimas

Archivo:100%.png Fuente: http://es.wikibooks.org/w/index.php?title=Archivo:100%.png Licencia: GNU Free Documentation License Contribuyentes: Abujoy, Cwbm (commons), Kilom691,

Ksd5, Loyna, ManuelGR, Siebrand, Vincnet, 2 ediciones anónimas

Archivo:00%.png Fuente: http://es.wikibooks.org/w/index.php?title=Archivo:00%.png Licencia: GNU Free Documentation License Contribuyentes: Kilom691, ManuelGR, Siebrand



Licencia 71

LicenciaCreative Commons Attribution-Share Alike 3.0 Unportedhttp://creativecommons.org/licenses/by-sa/3.0/

http://creativecommons.org/licenses/by-sa/3.0/

Documents

Wiki Manual Java