Programacion-Basica-En Java
Programacion-Basica-En Java
93 pag.
(3)
(5)
(6)
(I.vii.ix) limpiar 67
(I.vii.x) exportar preferencias 69
(I.viii) creación de javadoc con Eclipse __________________________________ 70
Apéndice (II) Netbeans 73
(II.i) introducción ______________________________________________________ 73
(II.ii) instalación _______________________________________________________ 73
(II.ii.i) comprobación de la plataforma Java instalada 76
(II.iii) aspecto inicial de Netbeans ______________________________________ 76
(II.iii.i) cerrar y abrir paneles 77
(II.iii.ii) iconizar un panel 77
(II.iii.iii) mover paneles 77
(II.iii.iv) mostrar y quitar barras de herramientas 77
(II.iv) proyectos de Netbeans __________________________________________ 78
(II.iv.i) crear proyectos 78
(II.iv.ii) la ventana del proyecto 79
(II.iv.iii) crear paquetes 80
(II.iv.iv) crear nuevas clases 80
(II.iv.v) vistas del proyecto 81
(II.iv.vi) propiedades del proyecto 82
(II.iv.vii) borrar un proyecto 83
(II.iv.viii) importar un proyecto de Eclipse 83
(II.v) compilar y ejecutar programas ___________________________________ 84
(II.v.i) compilar 84
(II.v.ii) ejecutar la clase principal del proyecto 84
(II.v.iii) preparar la distribución 84
(II.vi) javadoc _________________________________________________________ 85
(II.vi.i) añadir la documentación Java a Netbeans 85
(II.vi.ii) generar la documentación Javadoc del proyecto 85
(II.vii) edición de código _______________________________________________ 86
(II.vii.i) aspecto de la ventana de código 86
(II.vii.ii) ayudas al escribir código 87
(II.vii.iii) búsqueda y reemplazo de texto en el código 87
(II.vii.iv) dar formato al código 88
(II.vii.v) modificación de opciones del editor 88
(II.vii.vi) reestructurar 89
(II.vii.vii) plantillas generales 90
(II.vii.viii) comparar archivos 91
(II.vii.ix) exportar e importar las opciones 92
(7)
(8)
Sin embargo C t ambién t iene sus problemas. Uno de los principales es que
cuando la aplicación crece, el código es muy difícil de manej ar. Las t écnicas
de programación est ruct urada y programación modular, que en C pueden ser
aplicadas, paliaban algo el problema. Pero fue la programación orient ada a
obj et os (POO u OOP) la que mej oró not ablement e el sit uación.
No obst ant e C sigue siendo uno de los lenguaj es más ut ilizados y
académicament e sigue ut ilizándose por su versat ilidad, que permit e aprender
t odas las caract eríst icas de la programación clásica. De hecho a un buen
programador de lenguaj e C no le debería ser difícil aprender a programar en
ot ros lenguaj es (una vez que conozca las bases de la programación orient ada a
obj et os).
la influencia de la programación orientada a objetos
La POO permit e f abricar programas de forma más parecida al pensamient o
humano. De hecho simplifica el problema dividiéndolo en obj et os y
permit iendo cent rarse en cada obj et o, para de esa forma eliminar la
complej idad. Cada obj et o se programa de forma aut ónoma y esa es la
principal virt ud.
Al aparecer la programación orient ada a obj et os (en los años set ent a),
aparecieron varios lenguaj es orient ados a obj et os y t ambién se realizaron
versiones orient adas a obj et os (o semiorient adas a obj et os) de lenguaj es
clásicos.
Una de las más famosas adapt aciones f ue la que capacit ó al lenguaj e C a
ut ilizar obj et os. A ese lenguaj e se le llamó C++ indicando con esa simbología
que era un increment o del lenguaj e C (en el lenguaj e C, como en Java, los
símbolos ++ significan increment ar). Las vent aj as que añadió C++ a C fueron:
♦ Añadir soport e para obj et os (POO)
♦ Librerías de clases de obj et os (como MFC1 por ej emplo) que
facilit aban el uso de código ya creado para las nuevas aplicaciones.
♦ Todo lo bueno del C (incluso compat ibilidad con est e lenguaj e)
1
Mi crosof t Foundat ion Classes, librería creada por Microsof t para facilit ar la creación
de programas para el sist ema Windows.
(9)
La llegada de Int ernet propició la creación de lenguaj es más apt os para su uso
en est a red de redes.
(3.1.2) la llegada de Java
En 1991, la empresa Sun Microsyst ems crea el lenguaj e Oak (de la mano del
llamado proyect o Green). Mediant e est e lenguaj e se pret endía crear un
sist ema de t elevisión int eract iva. Est e lenguaj e sólo se llegó a ut ilizar de
forma int erna. en la empresa. Su propósit o era crear un lenguaj e
independient e de la plat aforma para uso en disposit ivos elect rónicos.
Se int ent aba con est e lenguaj e paliar uno de los problemas fundament ales
del C++; que consist e en que al compilar se produce un fichero ej ecut able
cuyo código sólo vale para la plat aforma en la que se realizó la compilación.
Sun deseaba un lenguaj e para programar pequeños disposit ivos elect rónicos.
La dificult ad de est os disposit ivos es que cambian cont inuament e y para que
un programa f uncione en el siguient e disposit ivo aparecido, hay que rescribir
el código. Por eso Sun quería crear un lenguaj e independient e del
disposit ivo.
En 1995 Oak pasa a llamarse Java. Java es un import ant e export ador de
café; por eso en EEUU se conoce como Java al café, t omarse una t aza de Java
(10)
La últ ima vent aj a (quizá la más import ant e) se consigue ya que el código Java
no se compila, sino que se precompila, de t al forma que se crea un código
int ermedio que no es direct ament e ej ecut able. No es código máquina. Para
ej ecut arle hace f alt a pasarle por un int érpret e que va int erpret ando cada
línea. Ese int érpret e suele ser la máquina virt ual de Java. Por lo que
cualquier sist ema que posea máquina virt ual de Java, podrá ej ecut ar código
precompilado en Java. Más adelant e se explica est e proceso en det alle.
2
La simbología del caf é sigue present e en Java. El logot ipo of icial de Java es una t aza
humeant e de caf é. Mucho sof t ware desarrollado para Java ha mant enido esa simbología:
Visual Caf é, Kawa (caf é en ruso),…
(11)
(12)
(13)
(3.2.2) seguridad
Al int erpret ar el código, el JRE puede delimit ar las operaciones peligrosas, con
lo cual la seguridad es fácilment e cont rolable. Además, Java elimina las
inst rucciones dependient es de la máquina y los punt eros que generaban
t erribles errores en C y la posibilidad de generar programas para at acar
sist emas. Tampoco se permit e el acceso direct o a la memoria y recursos del
ordenador.
La primera línea de seguridad de Java es un verificador del byt ecode que
permit e comprobar que el comport amient o del código es correct o y que sigue
las reglas del lenguaj e Java. Normalment e los compiladores de Java no pueden
generar código que se salt e las reglas de seguridad de Java. Pero un
programador malévolo podría generar art ificialment e byt ecode que se salt e
las reglas. El verif icador int ent a eliminar est a posibilidad.
Hay un segundo paso que verifica la seguridad del código que es el
verificador de clase que es el programa que proporciona las clases necesarias
al código. Lo que hace es asegurarse que las clases que se cargan son
realment e las del sist ema original de Java y no clases creadas reemplazadas
art if icialment e.
Finalment e hay un administ rador de seguridad que es un programa
configurable que permit e al usuario indicar niveles de seguridad a su sist ema
para t odos los programas de Java.
Hay t ambién una forma de seguridad relacionada con la confianza. Est o se
basa es saber que el código Java procede de un sit io de confianza y no de una
fuent e no ident ificada. Se consigue gracias a que en Java se permit e añadir
firmas digit ales al código para verificar la aut oría del mismo.
(14)
3
En el moment o de escribir est e manual
(15)
Java EE
Java Ent er pr ise Edit ion. Todavía conocida como J2EE. Pensada para la
creación de aplicaciones Java empresariales y del lado del servidor. Su últ ima
versión es la 1.4
Java ME
Java Mobile Edit ion. También conocida como J2ME. Pensada para la creación
de aplicaciones Java para disposit ivos móviles.
(16)
(17)
(18)
(19)
Ilust ración 3-3, El cuadro de las variables del Sist ema en Windows Server
2008
(2) Dent ro de est e cuadro, ya est ará la variable PATH. Habrá que elegirla y
pulsar en modificar. Sin borrar nada de lo que cont iene, debemos
añadir al f inal del t ext o el símbolo ; y después la rut a al direct orio bin
dent ro de la carpet a del SDK (por ej emplo C:\"Program
Files"\Java\j dk1.6. 14\bin).
(3) Tras acept ar el cuadro ant erior, podremos pulsar en Nueva para añadir
la variable JAVA_HOME indicando como valor la rut a al SDK.
Para comprobar la versión de Java bast a con ir al símbolo del sist ema Windows
y escribir j ava –version
(20)
en Linux
Ilust ración 3-5, El gest or de paquet es Synapt ic en el sist ema Linux Ubunt u,
most rando inf ormación sobre los paquet es Java
Casi t odas las versiones act uales de Linux incluyen el ent orno de ej ecución
(JRE) de Java y la mayoría el ent orno de desarrollo (SDK). Est o signif ica que
segurament e no haya que inst alar nada. Para conocer la versión inst alada
habría que ej ecut ar el comando j ava –version.
Si deseamos inst alar Java o act ualizarlo, hay que inst alar el últ imo
paquet e, una opción es ut ilizar el gest or Synapt ic para descargar la últ ima
versión del paquet e de desarrollo en Java (ver Ilust ración 3-5).
También podemos inst alar desde la línea de comandos, sería algo como
(21)
Gracias a ello podremos colocar programas Java y ej ecut arlos sin problemas en
la carpet a raíz del SDK y en la carpet a act ual en la que nos encont remos.
instalación del código fuente de las bibliotecas
Como ot ros lenguaj es, Java se compone de una serie de bibliot ecas. En el
caso de Java est as bibliot ecas son inmensas y est án comprimidas en el
archivo src.j ar.
Es muy habit ual en Java el uso de archivos JAR. En realidad son archivos
que aglut inan código f uent e en j ava, comprimiéndoles en format o ZIP. Para
poder acceder al código fuent e en sí debemos descomprimir dicho archivo. Lo
cual se hace (en cualquier sist ema):
(1) Yendo a la carpet a o direct orio en el que se encuent ra el SDK (es decir
yendo a JAVA_HOME).
(2) Allí se encuent ra el archivo src.j ar
(3) Descomprimirle con la orden j ar xvf src.j ar
(22)
(23)
/ * Co m en t a r io
d e v a r ia s lín e a s */
/ / Co m en t a r io d e u n a lín e a
También se pueden incluir coment arios j avadoc (se explican en det alle
más adelant e)
4
Para más inf ormación acudir a ht t p:/ / www.unicode.org
(24)
{
...có d i g o d e n t r o d el b lo q u e
}
có d ig o f u e r a d e l b lo q u e
(3.4.3) el primer programa en Java
p u b lic cla s s P r im e r P r o gr a m a
{
p u b lic s t a t ic vo id m ain( St r in g[ ] args)
{
Sys t e m .out.println(“¡Mi prim er program a!”);
}
}
Est e código sirve para escribir ¡Mi pr imer pr ogr ama! en la pant alla. Para
empezar a ent ender el código:
♦ La primera línea (public class Pr imer Pr ogr ama) declara el nombre de
la clase del código. Más adelant e se explicará que significa el concept o
de clase; por ahora ent enderemos que el nombre de la clase es el
nombre del programa.
♦ La línea public st at ic void main(St r ing ar gs[ ] ), sirve para indicar el
inicio del mét odo main. Est e mét odo cont iene las inst rucciones que
se ej ecut arán cuando el programa arranque. Es decir lo que est á t ras
las llaves del main, es el programa en sí.
♦ La inst rucción Syst em.out .pr int ln sirve para escribir en pant alla.
Como lo que escribimos es un t ext o, se encierra ent re comillas.
(25)
ja va c archivo.java
El result ado de est o es un archivo con el mismo nombre que el archivo j ava
pero con la ext ensión class. Est o ya es el archivo con el código en forma de
byt ecode. Es decir con el código precompilado.
Si el programa es ej ecut able (sólo lo son si cont ienen el mét odo main), el
código se puede int erpret ar usando el programa j ava del kit de desarrollo (que
se encuent ra en el mismo sit io que j avac). Sint axis:
ja va archivoClass
(26)
(3.6) javadoc
Javadoc es una herramient a muy int eresant e del kit de desarrollo de Java para
generar aut omát icament e document ación Java. genera document ación para
paquet es complet os o para archivos j ava. Su sint axis básica
es:
ja va d o c archivo.java o paquete
El código j avadoc hay que colocarle en t res sit ios dist int os dent ro del código
j ava de la aplicación:
♦ Al principio del código de la clase (ant es de cualquier código Java).
En est a zona se colocan coment arios generales sobre la clase o
int erfaz que se crea mediant e el código Java. Dent ro de est os
coment arios se pueden ut ilizar las et iquet as: @aut hor, @version,
@see, @since y @deprecat ed
(27)
♦ Delant e de cada mét odo. Los mét odos describen las cosas que puede
realizar una clase. Delant e de cada mét odo los coment arios j avadoc se
usan para describir al mét odo en concret o. Además de los
coment arios, en est a zona se pueden incluir las et iquet as: @see,
@param, @except ion, @ret urn, @since y @deprecat ed
♦ Delant e de cada at ribut o. Se describe para qué sirve cada at ribut o en
cada clase. Puede poseer las et iquet as: @since y @deprecat ed
Ej emplo:
/ ** E s t o es u n co m e n t a r io p a r a p r o b a r e l ja v a d o c
* e s t e t e x t o a p a r e ce r á en el a r ch iv o H T M L g e n e r a d o .
* <s t r o n g >R e a liz a d o e n a g o s t o 2 0 0 3 </ s t r o n g >
*
* @a u t h o r J o r g e S á n ch e z
* @v e r s io n 1.0
*/
p u b lic cla s s pru eba1 {
/ / E s t e co m en t a r io n o a p a r e ce r á e n e l ja v a d o c
/ ** E s t e m é t o d o co n t ien e e l có d ig o e je cu t a b le d e la cla s e
*
* @p a r a m a r g s L is t a d e a r g u m e n t o s d e la lín e a d e co m a n d o s
* @r e t u r n v o id
*/
Tras ej ecut ar la aplicación j avadoc, aparece como result ado la página web de
la página siguient e.
(28)
(3.7) import
En cualquier lenguaj e de programación exist en librerías que cont ienen código
ya escrit o que nos facilit a la creación de programas. En el caso de Java no se
llaman librerías, sino paquet es. Los paquet es son una especie de carpet as que
cont ienen clases ya preparadas y más paquet es.
Cuando se inst ala el kit de desarrollo de Java, además de los programas
necesarios para compilar y ej ecut ar código Java, se incluyen miles de clases
dent ro de cient os de paquet es ya list os que facilit an la generación de
programas. Algunos paquet es sirven para ut ilizar funciones mat emát icas,
(29)
im p o r t paqu ete.subpaquete.subsubapquete....clase
Est a inst rucción se coloca arriba del t odo en el código. Para la clase Dat e
sería:
im p o r t java.util.D a t e ;
im p o r t java.util.*;
Est o significa que se va a incluir en el código t odas las clases que est án dent ro
del paquet e ut il de j ava.
En realidad no es obligat orio incluir la palabra import para ut ilizar una
clase dent ro de un paquet e, pero sin ella deberemos escribir el nombre
complet o de la clase. Es decir no podríamos ut ilizar el nombre Dat e, sino
j ava.ut il.Dat e.
(3.8) variables
(3.8.1) introducción
Las variables son cont enedores que sirven para almacenar los dat os que ut iliza
un programa. Dicho más sencillament e, son nombres que asociamos a
det erminados dat os. La realidad es que cada variable ocupa un espacio en la
memoria RAM del ordenador para almacenar el dat o al que se refiere. Es decir
cuando ut ilizamos el nombre de la variable realment e est amos haciendo
referencia a un dat o que est á en memoria.
Las variables t ienen un nombre (un ident ificador) que sólo puede cont ener
let ras, números (pero no puede empezar el nombre con un número) y el
caráct er de subrayado. El nombre puede cont ener cualquier caráct er Unicode
(30)
que simbolice let ras (valen símbolos como la ñ, á,… no permit idos en la
mayoría de lenguaj es por no ser part e del ASCII est ándar)
(3.8.2) declaración de variables
Ant es de poder ut ilizar una variable, ést a se debe declarar. Lo cual se debe
hacer de est a forma:
in t días; / / d ía s es u n n ú m e r o e n t e r o , s in d e cim a le s
b o o le a n decisión; / / d e cis ió n s ó lo p u e d e s e r v er d a d e r a o f a ls a
in t días=365;
Y se puede declarar más de una variable a la vez del mismo t ipo en la misma
línea si las separamos con comas
in t a=13, b=18;
in t c=a+b; / / es v á lid o , c v a le 3 1
Java es un lenguaj e muy est rict o al ut ilizar t ipos de dat os. Variables de dat os
dist int os son incompat ibles. Algunos aut ores hablan de lenguaj e f uer t ement e
t ipado o incluso lenguaj e muy t ipif icado. Se debe a una t raducción muy
direct a del inglés st r ongly t yped referida a los lenguaj es que, como Java, son
muy rígidos en el uso de t ipos.
El caso cont rario sería el lenguaj e C en el que j amás se comprueban de
manera est rict a los t ipos de dat os.
Part e de le seguridad y robust ez de las que hace gala Java se deben a est a
caract eríst ica.
(3.8.3) asignación
En Java para asignar valores a una variable, bast a con ut ilizar el signo =. Ya se
ha vist o en el apart ado ant erior que al declarar se puede asignar un valor:
in t x=7;
(31)
in t x;
x=7;
x=x*2;
Como se ve en la últ ima línea ant erior, la expresión para dar el valor a la
variable puede ser t an complej a como queramos.
A dif erencia de lenguaj es como C, en Java siempre se asigna una valor
inicial a las variables en cuant o se declaran. En el caso de los números es el
cero.
in t x; / / x y a v a le cer o
(3.9.1) enteros
Los t ipos byt e, short , int y long sirven para almacenar dat os ent eros. Los
ent eros son números sin decimales. Se pueden asignar ent eros normales o
ent eros oct ales y hexadecimales. Los oct ales se indican ant eponiendo un cero
al número, los hexadecimales ant eponiendo 0x.
Normalment e un número lit eral se ent iende que es de t ipo int salvo si al f inal
se le coloca la let ra L; se ent enderá ent onces que es de t ipo long.
No se acept a en general asignar variables de dist int o t ipo. Sí se pueden
asignar valores de variables ent eras a variables ent eras de un t ipo superior
(por ej emplo asignar un valor int a una variable long). Pero al revés no se
puede:
in t i=12;
(32)
in t i=12;
b yt e b=(b yt e ) i; / / E l ( ca s t ) e v it a el e r r o r
Hay que t ener en cuent a en est os cast ings que si el valor asignado sobrepasa el
rango del element o, el valor convert ido no t endrá ningún sent ido ya que no
puede almacenar t odos los bit s necesarios para represent ar ese número:
in t i=120 0 ;
b yt e b=(b yt e ) i; / / E l v a lo r d e b n o t ien e s en t id o
(3.9.2) números en coma flotante
Los decimales se almacenan en los t ipos float y double. Se les llama de coma
flot ant e por como son almacenados por el ordenador. Los decimales no son
almacenados de forma exact a por eso siempre hay un posible error. En los
decimales de coma flot ant e se habla, por t ant o de precisión. Es mucho más
preciso el t ipo double que el t ipo float .
Para asignar valores lit erales a una variable de coma flot ant e, hay que
t ener en cuent a que el separador decimal es el punt o y no la coma. Es decir
para asignar el valor 2, 75 a la variable x se haría:
x=2.75;
A un valor lit eral (como 1.5 por ej emplo), se le puede indicar con una f al f inal
del número que es float (1.5f por ej emplo) o una d para indicar que es
double. Si no se indica nada, un número lit eral siempre se ent iende que es
double, por lo que al usar t ipos float hay que convert ir los lit erales.
Los valores decimales se pueden represent ar en not ación decimal:
1.345E+3 signif icaría 1, 345·10 3 o lo que es lo mismo 1345.
Lógicament e no podemos asignar valores decimales a t ipos de dat os
ent eros:
in t x=9.5; / / e r r o r
in t x=(in t ) 9.5;
pero perderemos los decimales (en el ej emplo, x vale 9). El caso cont rario sin
embargo sí se puede hacer:
in t x=9;
d o u b le y=x; / / co r r e ct o
(33)
la razón es que los t ipos de coma flot ant e son más grandes que los ent eros,
por lo que no hay problema de pérdida de valores.
Al declarar números del t ipo que sean, si no se indican valores iniciales, Java
asigna el valor cero.
(3.9.3) booleanos
Los valores booleanos (o lógicos) sirven para indicar si algo es verdadero (t rue)
o falso (false).
b o o le a n b=t r u e ;
b o o le a n b=(b o o le a n ) 9; / / n o t ien e s e n t id o
(3.9.4) caracteres
Los valores de t ipo caráct er sirven para almacenar símbolos de escrit ura (en
Java se puede almacenar cualquier código Unicode). Los valores Unicode son
los que Java ut iliza para los caract eres. Ej emplo:
ch a r letra;
letra=’C’; / / L o s ca r a ct er e s v a n e n t r e co m illa s
letra=67; / / E l có d ig o Un ico d e d e la C e s el 6 7. E s t a lín e a
/ / h a ce lo m is m o q u e la a n t e r io r
También hay una serie de caract eres especiales que van precedidos por el
símbolo \, son est os:
carácter significado
\b Ret roceso
\t Tabulador
\n Nueva línea
\f Aliment ación de página
\r Ret orno de carro
\” Dobles comillas
\’ Comillas simples
\\ Barra inclinada (backsl ash)
\udddd Las cuat ro let ras d, son en realidad números en hexadecimal.
Represent a el caráct er Unicode cuyo código es represent ado
por las dddd
(34)
in t a;b yt e b=12;
a=b;
El código ant erior es correct o porque un dat o byt e es más pequeño que uno
int y Java le convert irá de forma implícit a. Lo mismo pasa de int a double por
ej emplo. Sin embargo en:
in t a=1;
b yt e b;
b=a;
in t a=1;
b yt e b;
b= (b yt e ) a; / / co r r e ct o
En el siguient e ej emplo:
b yt e n1=10 0 , n 2=10 0 , n 3;
n3= n1 * n2 / 10 0 ;
Aunque el result ado es 100, y ese result ado es válido para un t ipo byt e; lo que
ocurrirá en realidad es un error. Eso es debido a que la mult iplicación 100 *
100 da como result ado 10000, es decir un número de t ipo int . Aunque luego
se divide ent re 100, no se vuelve a convert ir a byt e; ya que ant e cualquier
operación el t ipo result ant e siempre se corresponde con el t ipo más grande
que int ervenga en la operación. Lo correct o sería:
n3 = (b yt e ) (n1 * n 2 / 10 0 );
(3.9.6) ámbito de las variables
Toda variable t iene un ámbit o. Est o es la part e del código en la que una
variable se puede ut ilizar. De hecho las variables t ienen un ciclo de vida:
(1) En la declaración se reserva el espacio necesario para que se puedan
comenzar a ut ilizar (digamos que se avisa de su fut ura exist encia)
(2) Se la asigna su primer valor (la variable nace)
(3) Se la ut iliza en diversas sent encias
(35)
{
in t x=9;
}
in t y=x; / / er r o r , y a n o e x is t e x
(3.10) operadores
(3.10.1) introducción
Los dat os se manipulan muchas veces ut ilizando operaciones con ellos. Los
dat os se suman, se rest an, ... y a veces se realizan operaciones más
complej as.
(3.10.2) operadores aritméticos
Son:
operador significado
+ Suma
- Rest a
* Product o
/ División
% Módulo (rest o)
Hay que t ener en cuent a que el result ado de est os operadores varía
not ablement e si usamos ent eros o si usamos números de coma flot ant e.
Por ej emplo:
resultado1= d1 / d2;
resultado2= i1 / i2;
(36)
Es más incluso:
d o u b le resultado;
in t i1=7,i2=2;
resultado=i1/ i2; / / R e s u lt a d o v a ld r á 3
resultado=(d o u b le )i1/ i2; / / R es u lt a d o v a ld r á 3 .5
El operador del módulo (%) sirve para calcular el rest o de una división ent era.
Ej emplo:
resultado = i1 % i2; / / E l r e s u lt a d o s e r á 4
operador significado
< Menor
> Mayor
>= Mayor o igual
<= Menor o igual
== Igual
!= Dist int o
! No lógico (NOT)
&& “ Y” lógico (AND)
|| “ O” lógico (OR)
b o o le a n m ayorDeEdad, m enorDeEdad;
in t edad = 21;
m ayorDeEdad = edad >= 18; / / m a y o r D e E d a d s e r á t r u e
m en orDeEdad = !m ayorDeEdad; / / m e n o r De E d a d s e r á f a ls e
El operador && (AND) sirve para evaluar dos expresiones de modo que si
ambas son ciert as, el result ado será t rue sino el result ado será false. Ej emplo:
b o o le a n carnetConducir=true;
in t edad=20 ;
b o o le a n puedeConducir= (edad>=18) && carnetConducir;
/ / S i la e d a d e s d e a l m e n o s 18 a ñ o s y ca r n e t Co n d u cir es
/ / t r u e , p u e d e Co n d u cir e s t r u e
(37)
El operador | | (OR) sirve t ambién para evaluar dos expresiones. El result ado
será t rue si al menos uno de las expresiones es t rue. Ej emplo:
operador significado
& AND
| OR
~ NOT
^ XOR
>> Desplazamiento a la derecha
<< Desplazamiento a la izquierda
>>> Desplazamiento derecha con relleno de ceros
<<< Desplazamiento izquierda con relleno de ceros
x + = 3;
+= -= *= /=
&= |= ^= %=
>>= <<=
x1 = x2 = x3 = 5; / / t o d a s v a le n 5
x+ + ; / / e s t o e s x =x +1;
x--; / / e s t o es x =x -1;
(38)
Ej emplo:
in t x=5, y=5, z;
z=x+ + ; / / z v a le 5, x v a le 6
z=+ + y; / / z v a le 6 , y v a le 6
(3.10.6) operador ?
Est e operador (conocido como if de una línea) permit e ej ecut ar una
inst rucción u ot ra según el valor de la expresión. Sint axis:
expresion logica?valorSiVerdadero:valorSiFalso;
Ej emplo:
paga=(edad>18)?60 0 0 :30 0 0 ;
En est e caso si la variable edad es mayor de 18, la paga será de 6000, sino será
de 3000. Se evalúa una condición y según es ciert a o no se devuelve un valor u
ot ro. Nót ese que est a función ha de devolver un valor y no una expresión
correct a. Es decir, no funcionaría:
resultado = 8 + 4 / 2;
resultado = (8 + 4) / 2;
Ahora no hay duda, el result ado es seis. No obst ant e el orden de precedencia
de los operadores Java es:
nivel operador
1 () [] .
2 ++ -- ~ !
3 * / %
4 + -
5 >> >>> << <<<
6 > >= < <=
(39)
nivel operador
7 == !=
8 &
9 ^
10 |
11 &&
12 ||
13 ?:
14 = +=, -=, *=,...
En la t abla ant erior los operadores con mayor precedencia est á en la part e
superior, los de menor precedencia en la part e inferior. De izquierda a
derecha la precedencia es la misma. Es decir, t iene la misma precedencia el
operador de suma que el de rest a.
Est o últ imo provoca conflict os, por ej emplo en:
resu ltado = 9 / 3 * 3;
El result ado podría ser uno ó nueve. En est e caso el result ado es nueve,
porque la división y el product o t ienen la misma precedencia; por ello el
compilador de Java realiza primero la operación que est e más a la izquierda,
que en est e caso es la división.
Una vez más los parént esis podrían evit ar est os conflict os.
(3.11) constantes
Una const ant e es una variable de sólo lect ura. Dicho de ot ro modo más
correct o, es un valor que no puede variar (por lo t ant o no es una var iable).
La forma de declarar const ant es es la misma que la de crear variables, sólo
que hay que ant eponer la palabra final que es la que indica que est amos
declarando una const ant e y por t ant o no podremos variar su valor inicial:
fin a l d o u b le PI=3.141591;
PI= 4; / / E r r o r , n o p o d e m o s ca m b ia r el v a lo r d e PI
Como medida aconsej able (aunque no es obligat oria, sí alt ament e recomen-
dable), los nombres de las const ant es deberían ir en mayúsculas.
(40)
in t a=5, b=9;
d o u b le c=5.5;
Est a función t ras escribir añade un salt o de línea, de modo que lo siguient e
que se escriba saldrá en ot ra línea. Exist e una variant e de est a función que no
insert a el salt o de línea es Syst em.out .pr int :
in t a=5, b=9;
Sys t e m .out.println("La sum a es "+(a+b));
im p o r t javax.swing.J Op t io n P a n e ;
(41)
Est a es una clase pensada para manej ar cuadros de diálogo de t ipo Swing
(véase t ema ¡Er ror ! No se encuent ra el origen de la referencia. ¡Err or! No
se encuent ra el origen de la referencia.). Uno de est os cuadros permit e
int roducir dat os y que una variable les almacene. El problema es que t odos los
dat os les devuelve en forma de St ring (t ext o), lo que implica almacenarles en
una variable de ese t ipo y luego convert irlos al t ipo apropiado (int , double,
char,…). Ej emplo:
Evident ement e est e código no es fácil. Para explicar vamos línea a línea:
♦ En la primera línea, la variable t ext o almacena lo que el usuario
escriba en el cuadro de mensaj e. JOpt i onPane.showInput Dialog es la
función que permit e sacar el cuadro de mensaj e. "Escr iba un númer o
ent er o" es el t ext o que present a el mensaj e. Es decir el result ado de
est a inst rucción es:
Aunque el código es un t ant o crípt ico a est as alt uras, merece la pena
aprenderle ya que permit e más posibilidades de hacer programas para
pract icar. De ot ro modo no t endremos manera de leer dat os por t eclado y eso
supone una t ara import ant e para nuest ros programas.
Hay que señalar que hay más funciones de conversión, se pueden apreciar
en est a t abla:
Función Conviert e a
Int eger .parseInt int
Shor t .par seShor t shor t
Byt e.parseByt e byt e
Long.par seLong long
(42)
Hay que t ener cuidado con las mayúsculas, son obligat orias donde aparezcan.
im p o r t ja va .la n g.M a t h ;
Est a clase posee mét odos muy int eresant es para realizar cálculos mat emát icos
complej os. Por ej emplo:
d o u b le x= M a t h .pow(3,3); / / x es 3 3 , e s d ecir 2 7
constante significado
double E El número e (2, 7182818245...)
double PI El número ∏ (3,14159265...)
operador significado
double ceil(double x) Redondea x al ent ero mayor siguient e:
♦ Mat h.ceil(2.8) vale 3
♦ Mat h.ceil(2.4) vale 3
♦ Mat h.ceil(-2.8) vale -2
double floor (double x) Redondea x al ent ero menor siguient e:
♦ Mat h.floor(2.8) vale 2
♦ Mat h. floor (2.4) vale 2
♦ Mat h. floor (-2.8) vale -3
int r ound(double x) Redondea x de forma clásica:
♦ Mat h.round(2.8) vale 3
♦ Mat h. round (2.4) vale 2
♦ Mat h. round (-2.8) vale -3
(43)
operador significado
double rint (double x) Idént ico al ant erior, sólo que ést e mét odo da
como result ado un número double mient ras
que r ound da como result ado un ent ero t ipo
int
double random() Número aleat orio decimal sit uado ent re el 0 y
el 1
t iponúmer o abs( t iponúmer o x) Devuelve el valor absolut o de x.
t iponúmer o min( t iponúmer o x, Devuelve el menor valor de x o y
t iponúmer o y)
t iponúmer o max( t iponúmer o x, Devuelve el mayor valor de x o y
t iponúmer o y)
double sqr t (double x) Calcula la raíz cuadrada de x
double pow(double x, double y) Calcula x y
double exp(double x) Calcula ex
double log(double x) Calcula el logarit mo neperiano de x
double acos(double x) Calcula el arco coseno de x
double asin(double x) Calcula el arco seno de x
double at an(double x) Calcula el arco t angent e de x
double sin(double x) Calcula el seno de x
double cos(double x) Calcula el coseno de x
double t an(double x) Calcula la t angent e de x
double t oDegr ees( Conviert e de radianes a grados
double anguloEnRadianes)
double t oRadians( Conviert e de grados a radianes
double anguloEnGrados)
double signum(double n) Devuelve el valor del signo del número n. Si n
vale cero, la función devuelve cero; si es
posit ivo devulve 1.0 y si es negat ivo -1.0
(44)
M a t h .random ()*10
M a t h .random ()*9+1
Y si queremos que sea un número ent ero ent re 1 y 10, la expresión correct a
es:
Ent re 10 y 30 sería:
(45)
Apéndice (I)
Eclipse
(I.i) entornos de desarrollo integrado (IDE)
Los IDE son soft ware que permit en a los programadores crear aplicaciones
de forma cómoda. En est e anexo se explica brevement e como empezar a
t rabaj ar con Eclipse. Est e capít ulo no pret ende ser una guía complet a de
Eclipse sino explicar lo mínimo para ut ilizar cómodament e Eclipse a fin de
ut ilizarle como soft ware básico de creación de aplicaciones en Java.
Eclipse int egra edit ores para escribir código, compilación y ej ecución desde
el propio ent orno, depuración, diseño asist ido para crear el int erf az de la
aplicación y casi cualquier herramient a int eresant e para programar en Java (o
en ot ros lenguaj es, aunque desde luego el núcleo de desarrollo de Eclipse es
Java).
Eclipse es el nombre del ent orno de desarrollo int egrado más popular de la
act ualidad para programar en Java.
Eclipse se define a sí misma en la página oficial www.eclipse.org como una
comunidad basada en los modelos de código abier t o, que desar r olla
pr oyect o, plat af or mas y her r amient as par a cr ear , diseñar y administ r ar
sof t war e cubr iendo t odo el ciclo de vida de la aplicación. Eclipse es una
f undación del sin ánimo de lucr o apoyada por empr esas y ent idades que
per mit en su desar r ollo.
Efect ivament e en la act ualidad Eclipse int ent a cubrir t odo el ciclo de vida
de desarrollo de una aplicación. Ya que además de facilit ar la escrit ura de
código, añade herramient as de diseño, gest ión comunicación con bases de
dat os y cada vez más y más módulos que se añaden al núcleo del IDE Eclipse.
El proyect o Eclipse fue iniciado por IBM en noviembre de 2001 con la idea
de sust it uir a Visual Age que era su ant erior product o de desarrollo de
aplicaciones Java. En 2004 se independizó La fundación del eclipse f ue creada
en enero de 2004 pasó a ser desarrollado de manera independient e por la
Fundación Eclipse, que est á apoyada por empresas como IBM, Adobe,
Borland, Oracle, Int el, Mot orola, SAP…
(46)
(47)
(48)
Not a: Parece ser que exist en problemas de incompat ibilidad en Windows ent re
Eclipse y la versión de la máquina virt ual de Java de 64 bit . Por eso en
Windows si se desea ut ilizar Eclipse hay que seguir inst alando la versión del
SDK de 32 bit s. O bien lanzar Eclipse con una máquina de 32 bit s aunque
nuest ros programas Java les probemos en un SDK de 64 bit s, ya que en Eclipse
se pueden especificar SDK dif erent es, como se ha vist o ant es.
(49)
Ilust r aci ón 3-11, Aspect o del área de t rabaj o de Eclipse al iniciar por primera vez
Como se observa dispone de numerosas vent anas y paneles, los cuales se
pueden cerrar y modificar el t amaño. Eso hace que de un programador a ot ro
el aspect o de Eclipse pueda cambiar.
(I.iii.i) las perspectivas de Eclipse
Se llama perspect iva a un conj unt o de paneles y su disposición en la pant alla.
Como Eclipse sirve para realizar numerosas t areas, podemos elegir ent re varias
perspect ivas. Inicialment e la perspect iva de t rabaj o es la de Java (que es la
que se muest ra en est e manual).
Más exact ament e una perspect iva de Eclipse es un conj unt o de Vist as y
Edit ores.
vistas
Una vist a es un component e dent ro de Eclipse que sirve para most rar
información. Por ej emplo el Explorador de paquet es es una vist a que permit e
examinar los proyect os realizados.
Las vist as se pueden colocar como deseemos. Si arrast ramos desde su
pest aña a ot ro sit io, la vist a cambiará de posición. Eso permit e dej ar el
espacio de t rabaj o a nuest ro gust o.
Se pueden cerrar vist as simplement e haciendo clic en el signo del
nombre de la vist a.
Para most rar una vist a que ahora est á cerrada se elige Vent ana-Most rar-
Vist a (Window-Show view) y luego se hace clic sobre la vist a a most rar.
(50)
editores
También son component es, pero que permit en la escrit ura y la navegación. El
edit or de Java es el component e fundament al para escribir código en Java.
Normalment e un edit or aparece cuando hacemos doble clic en Eclipse sobre
un element o que permit e su edición (por ej emplo al hacer doble clic en un
archivo de código fuent e Java).
Los edit ores son dist int os dependiendo del element o que edit an. Por
ej emplo si se edit a código Java, aparecerá coloreado de manera especial las
palabras reservadas de Java; mient ras que si se abre un archivo de t ext o, t odo
el t ext o aparece igual.
cambiar la perspectiva
Como se indicó ant es las perspect ivas aglut inan una serie de edit ores y vist as
en una det erminada posición en la pant alla.
Mediant e el menú Vent ana (Window)-Abrir perspect iva (Open
per spect ive) se puede cambiar la perspect iva act ual. Incluso se pueden
almacenar perspect ivas creadas por nosot ros mismos (mediant e Vent ana
(Window)-Guardar perspect iva (Save per spect ive as)).
También podemos cambiar de perspect iva ut ilizando los bot ones para esa
t area que est án arriba y a la derecha de Eclipse ( ).
En el caso de j ugar mucho con los paneles y vent anas de Eclipse, podríamos
desear recuperar la perspect iva t ípica para t rabaj a con Java la cual se abre
con menú Vent ana (Window)-Abrir perspect iva (Open per spect ive)-Java.
(51)
(52)
(53)
at añen a aspect os de Java que aún no han sido coment ados en est os
apunt es.
(3) Una vez finalizado el asist ent e aparecerá una nueva clase en el
explorador de paquet es.
(I.iv.iv) cambiar el nombre a los elementos de Java
cambiar el nombre a una clase
En Java no es t an fácil cambiar el nombre a una clase o programa. La razón
t iene que ver con el hecho de que el nombre de la clase y el del archivo t ienen
que ser el mismo; lo que significa que no podemos cambiar el uno sin cambiar
el ot ro. Además ot ras clases pueden hacer referencia a aquella que queremos
cambiar de nombre.
Todo est o se arregla si cambiamos el nombre desde el explorador de
paquet es eligiendo Refact orizar (Ref act or )-Redenominar (Rename) que
aparece si pulsamos el bot ón secundario del rat ón sobre la clase que queremos
cambiar de nombre.
cambiar el nombre a variables y otros elementos de Java
La misma opción ut ilizada en el apart ado ant erior nos permit e simplificar una
de las operaciones más engorrosas al escribir programas, cambiar el nombre a
una variable.
Lo normal es que una variable aparezca varias veces en el código. Si, por lo
que sea, deseamos cambiar el nombre de una variable t endríamos que
modificar t odas las veces que aparezca la variable.
Más cómo es:
(1) Seleccionar el nombre de la variable en cualquier part e del código en
que aparezca
(2) Pulsar el bot ón secundario sobre la selección y elegir Refact orizar-
Redenominar (t ambién se puede pulsar direct ament e la combinación
de t eclas Mayús+Alt +R)
(3) Escribir el nuevo nombre y pulsar la t ecla Int ro
(54)
(55)
(56)
(57)
modificar las preferencias del edit or, subapart ado plant illas.
(58)
(59)
Ilust r aci ón 3-14, Cuadro de preferencias de Eclipse most rando el apart ado ref erent e al
Edit or de Java
(60)
(61)
(I.vii.vii) plantillas
Como se ha coment ado ant eriorment e, se t rat a de una de las opciones más
int eresant es de ayuda al escribir código. En el caso de Eclipse las posibilidades
de las plant illas son espect aculares.
La list a de las plant illas act uales se puede observar en el menú de
preferencias, apart ado Java-Edit or -Plant illas (Templat es).
Desde est e cuadro podemos crear nuevas plant illas (bot ón New) , edit arlas o
borrarlas (Remove). Incluso podemos import ar y export ar plant illas de una
inst alación de Eclipse a ot ra.
(62)
(63)
Por ej emplo si creamos est a plant illa (que por ciert o es mi favorit a):
Ilust r aci ón 3-16, Cuadro de plant illas en Eclipse según aparece t ras escribir
"Hola" e invocarle
Un buen uso de las plant illas ahorra muchísimo t iempo de escrit ura de código
y además evit a comet er numerosos errores t ont os. Las variables son muy
import ant es, de hecho hay muchas más que las señaladas en el cuadro
ant erior, su uso y pot encia se comprenderá más cuant o más avancemos en
nuest ros conocimient os en Java.
(64)
Ilust r aci ón 3-17, El cuadro de pref erencias en el apart ado Est i lo de códi go
Inicialment e en la raíz del apart ado podemos elegir opciones que serán mej or
ent endidas cuando t engamos más conocimient os sobre Java (y que desde luego
son muy int eresant es).
(65)
formateador
(66)
relacionados con Java. Pero si deseamos modificar est a forma por defect o,
desde el apart ado del format eador bast a con:
(1) Pulsar el bot ón Nuevo si queremos crear un nuevo perfil o Edit ar si
queremos modificar uno exist ent e
(2) Lógicament e si hemos pulsado Nuevo, hay que dar nombre al perfil e
indicar en quién se basará est e perfil inicialment e.
(3) Modificar los parámet ros según deseemos.
En Eclipse es espect acular la cant idad de parámet ros que podemos configurar,
con lo que nuest ra forma part icular de escribir código podrá ser
perfect ament e det erminada en el cuadro.
Podemos t ambién (como siempre) export ar e import ar conf iguraciones, lo
que f acilit a por ej emplo que una empresa que haya realizado un prot ocolo
concret o de escrit ura de código pueda fácilment e colocar est e prot ocolo en
t odas las máquinas de sus programadoras y programadores.
(I.vii.ix) limpiar
El apart ado dedicado a limpiar código, permit e que Eclipse arregle aspect os
diversos en el código, por ej emplo et iquet as Javadoc que nos hayamos
salt ado. Nuevament e podemos edit ar o crear un perfil para det erminar el
funcionamient o de est e apart ado.
La limpieza de código se produce si pulsamos el bot ón secundario del rat ón
sobre el código y elegimos Código fuent e-Limpiar.
organizar importaciones
Eclipse t iene la capacidad de colocar las inst rucciones import necesarias para
que nuest ro código funcione correct ament e. El orden de est os import y ot ros
aspect os se configuran en est e apart ado. Por ej emplo en mi caso suelo elegir
cinco como número máximo de import aciones para ut ilizar un ast erisco en el
import . Es decir que cuando haya colocado cinco clases procedent es por
ej emplo del paquet e j ava.ut il, Eclipse colocará un import j ava.ut il.* en lugar
de los cinco import correspondient es.
plantillas de código
Permit e configurar el código que Eclipse escribe por defect o cuando creamos
una nueva clase. Es un apart ado algo ext enso, pero como ocurría con las
plant illas del edit or, muy int eresant e. Bien ut ilizado ahorra mucho t iempo de
t rabaj o.
El cuadro se divide en dos apart ados: coment arios (referido a los
coment arios que escribe Eclipse aut omát icament e) y código (referido al código
que Eclipse escribe aut omát icament e).
(67)
Ilust ración 3-19, Cuadro de pref erencias en el apart ado Plant illas de código
comentarios
Apart ado Uso
Archivos Aparece al inicio de cada archivo creado con Eclipse.
Normalment e aparece la fecha y nombre del aut or. Se puede
hacer referencia al cont enido de est e apartado usando la
variable ${ filecomment }
Tipos Aparece al inicio de cada nuevo t ipo (clase, int erfaz,…) creado.
Se suele usar la variable ${ tags} que permit e colocar
aut omát icament e los coment arios j avadoc pert inent es. Se
puede hacer referencia a est e apart ado con la variable
${ t ypecomment }
Campos Coment arios que aparecen delant e de cada nuevo campo
Const ruct ores Coment arios para nuevos const ruct ores
Mét odos Coment arios para nuevos mét odos
Mét odos delegados
Mét odos de Coment arios para mét odos get
obt ención
Mét odos de Coment arios para mét odos set
est ablecimiento
(68)
código
Est ablece el código que Eclipse coloca por defect o en diversos apart ados. El
más int eresant e es el que se ref iere a los archivos Java nuevos, que suele
hacer ref erencia a ot ros apart ados (especialment e a los de los coment arios
indicados ant eriorment e).
La int eresant e casilla añadir coment arios aut omát icament e (muy
recomendable) permit e que Eclipse coloque los coment arios Javadoc
pert inent es cada vez que se crea un nuevo mét odo o campo; est o permit e
evit ar despist es con la document ación del código.
(I.vii.x) exportar preferencias
Cuando se t ienen múlt iples inst alaciones de Eclipse, es muy út il export ar las
preferencias, para que sean cargadas desde ot ra inst alación. Para hacer lo hay
que ir a Archivo-Export ar y en el cuadro que aparece, elegir el grupo General
y después Preferencias:
(69)
(70)
Mediant e las que se especifica aún más la document ación que realizaremos
(71)
(II.ii) instalación
Primero t enemos que descargar la versión deseada de Net beans de la
página www.net beans.org. La versión t ot al cont iene t odas las posibilidades de
Net beans. Además disponemos de versiones para Windows, Linux y MacOS;
t ambién podemos elegir idioma español.
(73)
Ilust r aci ón 3-22, Pant alla inicial de inst alación de Net beans
Seleccionamos los component es a inst alar (para Java, al menos hay que
inst alar el IDE Base y Java SE).
Ilust r aci ón 3-23, Selección de los component es Net beans a inst alar
(74)
La inst alación finaliza y disponemos de Net beans. Una vez lanzado podremos
iniciar un t ut orial, obt ener ayuda,…. o direct ament e empezar a t rabaj ar.
(75)
(76)
(77)
En la vent ana Pr oyect o Nuevo hay que selección aplicación Java. Después
podremos elegir el nombre y las opciones del proyect o:
(78)
(79)
(80)
Sin embargo la vist a Archivos nos enseña la realidad de los archivos del
proyect o. Nos enseña la organización de los archivos del proyect o desde el
punt o de vist a del sist ema:
(81)
La carpet a build cont iene los archivos compilados (los class). La carpet a src el
código fuent e. El rest o son archivos por Net beans para comprobar la
configuración del proyect o o los archivos necesarios para la correct a
int erpret ación del código en ot ros sist emas (en cualquier caso no hay que
borrarlos).
(II.iv.vi) propiedades del proyecto
Pulsando el bot ón derecho sobre un proyect o, podemos elegir Propiedades. El
panel de propiedades nos permit e modificar la configuración del proyect o. Por
ej emplo podremos indicar una nueva clase principal en el proyect o, si fuera
necesario o bien indicar los argument os o parámet ros que enviaremos al
programa
Ilust r aci ón 3-34, Cuadro de propiedades abiert o por las opciones de ej ecución
(82)
(83)
(84)
(II.vi) javadoc
Net beans t iene t ambién capacidad para generar t oda la document ación
j avadoc de un proyect o.
(II.vi.i) añadir la documentación Java a Netbeans
Para que Net beans pueda most rarnos ayuda de t ipo j avadoc en cada clase
est ándar que ut ilicemos en nuest ros proyect os, debemos añadir la
document ación del SDK con el que est emos compilando nuest ros proyect os.
Para hacerlo:
(1) Descargamos la document ación de Java desde la
página ht t p:/ / j ava. sun.com/ j avase/ downloads/ index. j sp
(2) Ir al menú Her ramient as-Plat aformas Java
(3) Ir a la pest aña Javadoc y pulsar en añadir ar chivo ZIP/ carpet a
(4) Elegir el archivo zip en el que se encuent ra la document ación
(5) La document ación est ará inst alada en cuant o acept emos el cuadro
(85)
Ilust r aci ón 3-37, La vent ana de código most rando dos archivos a la vez
Est a últ ima acción puede ser muy int eresant e si la hacemos con el propio
archivo; es decir consiguiendo ver el mismo archivo en dos pest añas
diferent es, a fin de examinar a la vez dos part es dist int as del mismo. Para ello
primero hay que duplicar el archivo bast a con pulsar el bot ón derecho sobre la
pest aña del archivo abiert o y elegir Clonar document o. Después podremos
arrast rar la nueva pest aña a la posición que queramos.
(86)
(87)
(88)
Los colores y t ipos de let ra con los que se most rará el código est án en el
apart ado Fuent es y colores del mismo cuadro de Opciones.
Cabe señalar que en est e sent ido Eclipse posee más opciones de ayuda y
format o de código. Pero normalment e t endremos más opciones que las
necesit adas con Net beans.
(II.vii.vi) reestructurar
Son opciones que permit en una modif icación del código de modo que sea más
legible, que sean más improbables las apariciones de errores y que se realiza
de una forma más aut omát ica t areas que result an pesadas. Las posibilidades
son:
♦ Cambiar de nombre. Cuando queremos cambiar de nombre a una
clase, variable, mét odo,… t enemos que encont rar en el código t odas
las ref erencias al nombre ant iguo. Para evit ar eso, podemos:
a> Seleccionar el element o al que queremos cambiar de nombre
b> Pulsar el bot ón secundario en la selección y elegir Reest ruct urar-
cambiar nombre
(89)
(90)
Cuando se crea una nueva clase, aparece código ya creado: código Javadoc,
inst rucción package,… Es posible modificar ese código haciendo lo siguient e:
(2) Yendo a Herramient as-Plant illas
(3) Abriendo la carpet a Java
(4) Eligiendo la plant illa a modificar y pulsando Abrir en el edit or
(5) Después bast a con realizar los cambios deseados y guardar el
document o
(91)
Para import ar, hay que disponer del archivo ZIP creado durant e la export ación
y después volviendo a Herramient as-Opciones, elegir Import ar y seleccionar
el archivo. Se nos avisará de que se sobrescribirán las opciones que t eníamos
hast a ahora. Una vez acept ado el mensaj e, Net beans se reinicia con las nuevas
opciones aplicadas.
(92)
índice de ilustraciones
Ilustración 3-1, Proceso de compilación de un programa C++ en Windows y Linux ................... 13
Ilustración 3-2, Proceso de compilación de un programa Java ...................................................... 14
Ilustración 3-3, El cuadro de las variables del Sistema en Windows Server 2008 .....................20
Ilustración 3-4, Ejemplo de configuración de la variable JAVA_HOME en Windows ..............20
Ilustración 3-5, El gestor de paquetes Synaptic en el sistema Linux Ubuntu,.............................. 21
Ilustración 3-6, Ejemplo de compilación y ejecución en la línea de comandos.......................... 26
Ilustración 3-7, Página de documentación de un programa Java ............................................... 29
Ilustración 3-8, Pantalla de la página de descargas de Eclipse .................................................... 47
Ilustración 3-9, Aspecto del primer arranque de Eclipse ................................................................. 48
Ilustración 3-10, Aspecto de la bienvenida de Eclipse ...................................................................... 49
Ilustración 3-11, Aspecto del área de trabajo de Eclipse al iniciar por primera vez ..................50
Ilustración 3-12, Cuadro de creación de proyectos nuevos en Eclipse ........................................... 52
Ilustración 3-13, Cuadro de nueva clase Java en Eclipse .................................................................. 53
Ilustración 3-14, Cuadro de preferencias de Eclipse referente al Editor de Java....................... 60
Ilustración 3-15, Cuadro de preferencias en el apartado de plantillas ......................................... 62
Ilustración 3-16, Cuadro de plantillas en Eclipse ................................................................................ 64
Ilustración 3-17, El cuadro de preferencias en el apartado Estilo de código ............................... 65
Ilustración 3-18, Creación de un nuevo perfil de formato de código ............................................ 66
Ilustración 3-19, Cuadro de preferencias en el apartado Plantillas de código ........................... 68
Ilustración 3-20, Cuadro de exportación de preferencias de Eclipse ............................................ 69
Ilustración 3-21, cuadro de generación de Javadoc en Eclipse ....................................................... 70
Ilustración 3-22, Pantalla inicial de instalación de Netbeans......................................................... 74
Ilustración 3-23, Selección de los componentes Netbeans a instalar ............................................ 74
Ilustración 3-24, Selección de directorios durante la instalación de Netbeans........................... 75
Ilustración 3-25, Pantalla inicial de Netbeans.................................................................................... 75
Ilustración 3-26, Aspecto habitual de Netbeans................................................................................ 76
Ilustración 3-27, Selección del tipo de proyecto en Netbeans ........................................................ 78
Ilustración 3-28, Selección de las opciones del proyecto................................................................... 78
Ilustración 3-29, Aspecto de Netbeans con un proyecto vacío ...................................................... 79
Ilustración 3-30, Cuadro de creación de nuevos paquetes .............................................................80
Ilustración 3-31, Cuadro de creación de nuevas clases ...................................................................... 81
Ilustración 3-32, Ventana de proyectos................................................................................................. 81
Ilustración 3-33, Ventana de archivos del proyecto .......................................................................... 82
Ilustración 3-34, Cuadro de propiedades abierto por las opciones de ejecución....................... 82
Ilustración 3-35, cuadro de confirmación de borrado de un proyecto......................................... 83
Ilustración 3-36, Seleccionando la documentación de Java ........................................................... 85
Ilustración 3-37, La ventana de código mostrando dos archivos a la vez ................................... 86
Ilustración 3-38, El cuadro de opciones del editor en el apartado de formato del código ..... 88
Ilustración 3-39, El cuadro de administración de plantillas ........................................................... 90
Ilustración 3-40, La herramienta diff comparando archivos .......................................................... 91
Ilustración 3-41, Cuadro de exportación de opciones de Netbeans .............................................. 92
(93)