Java Bases SQL

IAVA ICk nACk k CkACk
ue es Iava?
Lengua[e de programac|n nac|do en 1991 su padre !"# %&'()!*!+,%!- Lmpresa |a cua| ha
s|do |a promotora de este desde e| pr|nc|p|o de |os t|empos.
Deb|do a| avance en |as tecno|og|as de computadoras, versat|||dad en |os s|stemas y d|ferenc|as
entre |os m|smos D|cha empresa desarro||a un cd|go "neutra|" e| cua| puede correr en
d|ferentes t|pos de p|ataformas s|n |mportar |a maqu|na y e| t|po de s|stema que mane[e,
corr|endo |as ap||cac|ones en una "maqu|na v|rtua|" ./0/ 0&(+"/1 %/'2&#,, La func|n en
part|cu|ar de esta IVM es convert|r e| cd|go [ava a| formato |]o |engua[e correcto de |a maqu|na
anf|tr|ona hac|endo de este un |engua[e aprec|ado hoy d|a por muchos programadores grac|as a
su mu|t|p|ataforma.

Un breve repaso
A cont|nuac|n a|gunas caracter|st|cas |as cua|es hacen de [ava marcar |a d|ferenc|a entre
muchos |engua[es de programac|n:

SIMLICIDAD:
ue sea s|mp|e no qu|ere dec|r que sea
menos potente que otros |engua[es de
programac|n no!
So|o que [ava posee |as func|ones de un
|engua[e potente y robusto, e||m|nando
func|ones muy poco usadas y confusas a|
usuar|o.

DIS1kI8UIDC:
Ln cuanto a su d|str|buc|n ap||ca a| mane[o
de ||brer|as que este |ncorpora ([ava)
||brer|as para e| mane[o de conex|ones
1C]I y protoco|os como http y ftp para
acceder a bases de datos, f|cheros y
func|ones que se encuentren en
ordenadores remotos.
kC8US1ICIDAD
Lo que ||eva a [ava a ser un |engua[e robusto
d|rectamente es su protecc|n a|
programador en cuanto a eventua|es
errores de programac|n, ver|f|cando |os
m|smos en t|empo de comp||ac|n como en
t|empo de e[ecuc|n.

NLU1kALIDAD
Su neutra||dad se basa en |a generac|n de
un cd|go ob[eto e| cua| es |ndepend|ente
de |a arqu|tectura de cua|qu|er maqu|na, e|
f|chero generado por un comp||ador de [ava
actua|mente t|ene soporte para s|stemas
So|ar|s, L|nux, W|ndows, Mac, App|e Ltc.

2 www.hackxcrack.es

SLGUkIDAD
L| cd|go Iava pasa muchos 34535 antes de
e[ecutarse en una mqu|na. L| cd|go se
pasa a travs de un ver|f|cador de byte-
codes que comprueba e| formato de |os
fragmentos de cd|go y ap||ca un probador
de teoremas para detectar fragmentos de
cd|go ||ega| -cd|go que fa|sea punteros,
v|o|a derechos de acceso sobre ob[etos o
|ntenta camb|ar e| t|po o c|ase de un ob[eto-
.
S| |os byte-codes pasan |a ver|f|cac|n s|n
generar n|ngn mensa[e de error, entonces
sabemos que:
L| cd|go no produce
desbordam|ento de operandos en
p||as
L| t|po de |os parmetros de todos
|os cd|gos de operac|n son
conoc|dos y correctos
No ha ocurr|do n|nguna convers|n
||ega| de datos, ta| como convert|r
enteros en punteros
L| acceso a |os campos de un ob[eto
se sabe que es |ega|: pub||c, pr|vate,
protected
No hay n|ngn |ntento de v|o|ar |as
reg|as de acceso y segur|dad
estab|ec|das
Ck1A8ILIDAD
La portab|||dad va desde su poder de
e[ecuc|n en m|t|p|es p|ataformas, hasta
fac|||tar un entorno desarro||ado |dnt|co
para todos |os usuar|os en d|versas
maqu|nas.

IN1LkkL1ACICN
S|stema kun-1|me es e| |nterprete de [ava
encargado de |a e[ecuc|n de| cd|go ob[eto
comnmente e| |nterprete consume menos
recursos que a| comp||ar e| code por |o que
nosotros como desarro||adores [ava
tendremos ms t|empo para crear, a| ser
[ava un |engua[e |nterpretado |o hace ms
|ento que otros |engua[es de programac|n
comp||ados ya que este ([ava) debe ser
|nterpretado y no comp||ado ya que no
cuenta hasta ahora con un comp||ador
prop|o para cada p|ataforma.

CkILN1ADC A C8IL1CS
Soporta |os tres parad|gmas fundamenta|es
para |a or|entac|n a ob[etos:
Lncapsu|ac|n, herenc|a y po||morf|smo.
LN1CkNCS DL DLSAkkCLLC
Lx|sten d|versos programas para e| desarro||o de cd|go [ava estos son |os muy popu|ares IDL
"IN1LGkA1LD DLVLLCMLN1 LNVIkCNMLN1" |a compa|a SUN nos ofrece gratu|tamente e| k|t
para poder desarro||ar [ava "IDk" IAVA DLVLLCMLN1 kI1 dotado de una ser|e de ||brer|as y
programas para desarro||ar, comp||ar y e[ecutar en [ava y |os IDL anter|ormente menc|onados
como s|empre |o he d|cho nos fac|||tan |a v|da =) en un m|smo programa podrs e[ecutar y
comp||ar en [ava.

Actua|mente hay muchos IDL d|spon|b|es para [ava entre muchos tenemos, entre otros:
NL18LANS
LCLISL
IDLVLLCLk
I8UILDLk
VISUAL I++
3 www.hackxcrack.es
LMLCLMCS: CCMILAk LILCU1Ak 1U kIMLk kCGkAMA LN IAVA
r|mero que todo nos Insta|amos IDk(Iava Deve|opment k|t) "Descarga"
http:]]www.4shared.com]f||e]MkCwI|Mb][dk-6u20-w|ndows-|S86.htm|
Despus de Insta|ado IDk rocedemos a su conf|gurac|n
Nos Ub|camos en e| d|rector|o donde este se |nsta|a or defecto es (C:\Arch|vos de rograma\Iava) ta| vez
tengas otras vers|ones |nsta|adas se|ecc|onas |a ms rec|ente que tengas |nsta|ada |o ms probab|e es que
sea |a que acabamos de |nsta|ar xDD bue.. Abr|mos |a carpeta "b|n" y cop|amos |a ruta
Ejemplo: C:\Program Files\Java\jdk1.6.0_20\bin
Conf|guramos e| A1n
Nos Ub|camos en "MI C" damos C||c derecho se|ecc|onamos prop|edades, p|camos en |a pestaa
Cpc|ones avanzadas, |uego en var|ab|es de entorno, Se|ecc|onar ath y p|ncha en mod|f|car, en |os va|ores
s| |a cadena no term|na con unto y coma " , " se |o pones y a cont|nuac|n pegas |a ruta que cop|aste que
hace referenc|a a |os b|nar|os de IAVA, Cerramos |a cadena con punto y coma , C||c en Ck y Aceptar Creo
que no est de ms dec|r que no t|enes que borrar nada =D
Una Imagen..

Abr|mos |a SnLLL!! C CMD o |a anta|||ta negra..
In|c|o ! L[ecutar.. ! 1|peamos CMD ! Lnter
1ec|a W|ndows + k ! 1|peamos CMD ! Lnter
nacemos una esca|a de d|rector|os hasta ||egar a| D|rector|o ka|z C:\ con el comando CD. .
4 www.hackxcrack.es
Cuando est emos en c: \ t i peamos j avac Si Nos muest ra al gn error de no
reconocer el comando es porque no est bi en conf i gurado nuest ro pat h pero si
reci bi mos una respuest a como l a de l a si gui ent e i magen es porque somos
t ri unf ant es xD

Con esto podemos con p|ena certeza comp||ar y L[ecutar programas Lscr|tos en IAVA, Como pr|mera
med|da comp||emos nuestro pr|mer programa, A| Igua| que en muchas ocas|ones nos |anzaremos a|
estre||ato programando e| popu|ar "nCLA MUNDC"

64 4537 8794:7 349;:48<5 9=453:<
>73? @<9ABC=:7;< @<::4@3784934
D4:< 54 4537:E9 >:4C=9379;<
* 4F >73? >7:7 G=HIJ
D=45 4F >73? 9<5 >4:8B3B:E
27@4: :4A4:49@B7 7
@<8><949345
* A=9@B<945 ;4 ./0/
D7:7 9=453:< "5< K6
5 www.hackxcrack.es
kCGkAMANDC CCMILANDC NULS1kC kIMLk kCGkAMA
LN IAVA "nCLA MUNDC"
Conceptos a tener en cuenta antes de |n|c|ar:
UL LS UNA CLASL?
Una C|ase IAVA es |a "p|ant|||a"sobre |a cua| traba[aremos y estas pueden contener var|ab|es y mtodos
D|cha c|ase debe tener e| m|smo nombre de| arch|vo .[ava
UL LS UN ML1CDC?
Un mtodo IAVA es un 8|oque de cd|go que se |e as|gna un nombre para ser ||amado |uego en cua|qu|er
evento de| programa.
L|sto despus segu|mos con ms conceptos
Lmpezamos a programar en IAVA nada mas basta con abr|r un ed|tor de texto y que me[or opc|n que e|
trad|c|ona|, v|e[o, muy conoc|do, estupendo y poderoso notepad "b|ock de notas", ue pensabas que e|
notepad so|o serv|a para hacer bat's y autorun's 8ue.. a con nuestro b|og de notas ab|erto t|ramos code
IAVA!
ara este e[emp|o Crearemos una Carpeta en C:\ yo |a ||ame "ho|a mundo" sea que este e[erc|c|o |o
guardare en " C:\ho|a mundo\ "y |e pondr como nombre ma|n.[ava haber s| |e pones otro nombre he?

pub||c c|ass ma|n
{
pub||c stat|c vo|d ma|n(Str|ng[] args)
{
System.out.pr|nt|n("no|a Mundo"),
}
}

Le damos Arch|vo ! Guardar como ! 8uscamos nuestra ruta " C:\ho|a mundo\ " ya saben nombre de|
arch|vo ma|n.[ava y aba[o en t|po de arch|vo se|ecc|onamos todos |os arch|vos

L|sto hemos creado e| arch|vo IAVA
Abr|mos La She|| nos ub|camos en |a carpeta donde guardamos e| arch|vo
ara comp||ar [avac [nombre arch|vo].[ava
ara e[ecutar [ava [nombre arch|vo]
Cabe keca|car que estos comandos de e[ecuc|n y comp||ac|n se puden e[ecutar desde cua|qu|er
d|rectoro en e| que estemos ub|cados en |a conso|a, so|o en e| d|rector|o ra|z
#<37L ,F #<8M:4 ;4 F7 'F754 ;4M4 54: 4F %B58< N=4 4F 9<8M:4 ;4F 7:@?BO<
,P48>F<L
#<8M:4 7:@?BO<L 5=87QP7O7
'F754L >=MFB@ @F755 5=87

(4@<:;7:R ./0/ 6BA4:49@B7 493:4 87ST5@=F75 S 8B9T5@=F75
U547 G=4 45 ;BA4:4934 V07:B7MF4WX 7 VO7:B7MF4WX
6 www.hackxcrack.es

1a| Vez s| nunca has programado en [ava te preguntaras or D|os ue es este cd|go :S ?
L|sto exp||care..

Con esto hemos term|nado e| pr|mer programa en [ava de nuestras v|das s|.. S|.. Vendrn muchos ms..
Como por e[emp|o hagamos otro programa t|p|co a| |n|c|ar en cua|qu|er |engua[e de programac|n
Sumemos 2 nmeros! =D
ero pr|mero |o pr|mero .
VAkIA8LLS:
Con e| f|n de retener y poder ut|||zar tanto |os datos |n|c|a|es como |os resu|tados de operac|ones
efectuadas durante |a e[ecuc|n de un programa se requ|ere |a ut|||zac|n de var|ab|es, que
representan un |ugar de a|macenam|ento, cuyo conten|do podr var|ar durante e| proceso de
e[ecuc|n de| programa.
Var|ab|es de t|po Lnteras:
int variable1 = 500;
Dec|aramos que var|ab|e1 es un entero que equ|va|e a S00
Los datos de t|po |nt representan e| con[unto de |os nmeros enteros pos|t|vos y e| con[unto de |os
nmeros enteros negat|vos

A| dec|arar
pub||c c|ass ma|n
{
S| sabemos un poco de |ng|es Lstamos dec|arando una c|ase pb||ca sea que esta c|ase puede ser acces|b|e
desde otras c|ases
Aqu| estamos programando e| cuerpo de nuestra c|ase y |as func|ones de| programa
pub||c stat|c vo|d ma|n(Str|ng[] args)
{
Con esta Instrucc|n Mostramos Un mensa[e en panta||a, en este caso **** no|a Mundo****
System.out.pr|nt|n("no|a Mundo"),
por u|t|mo cerramos
}
}

7 www.hackxcrack.es

Var|ab|es de 1|po Cadena:
String nombre = "hackxcrack";
Dec|aramos que nombre es una cadena de carcter equ|va|ente a hackxcrack
L| str|ng se def|ne como una cadena de caracteres determ|nada por una secuenc|a de caracteres
encerrados entre |os apostrofes ""

Var|ab|es de t|po dec|ma|
double res = 3.5;
double numero1;
Dec|aramos una var|ab|e res con va|or de 3.S y una var|ab|e numero1 s|n n|ngn va|or ta| vez |a
dec|aramos para as|gnar|e a|gn va|or durante |a e[ecuc|n de| programa
f|oat var|ab|e1,var|ab|e2,var|ab|e3,
f|oat nn = 0S0,
Dec|aramos |n|c|a|mente 3 var|ab|es s|n va|or y mas aba[o una var|ab|e nn con va|or 0S0.

Var|ab|es de t|po Sw|tch Ia|so o Verdadero
boolean respuesta1 = true;
variable respuesta1 equivalente a true verdadero
Los va|ores que puede tomar una var|ab|e de t|po 8CCLLAN, son va|ores |g|cos, es dec|r, 1kUL
(verdadero) o IALSL (fa|so)
1amb|n Lncontramos otros t|pos de datos pr|m|t|vos como char, |ong, byte que sern tratados con
poster|dad por ahora traba[aremos con estos t|pos de datos, D
IDLN1IIICADCkLS:
Un |dent|f|cador es un nombre que otorgamos a una var|ab|e para d|ferenc|ar|a dentro de| programa,
d|chos |dent|f|cadores estn reg|dos por a|gunas reg|as expuestas por e| |engua[e estas son:
Debe Comenzar con |etra
No puede contener espac|o en b|anco
No se podr ut|||zar pa|abras reservadas de| |engua[e como |dent|f|cadores
Como d|[e arr|ba se d|st|ngu|r entre MAUSCULAS y m|nscu|as
No Inc|u|r caracteres espec|a|es

CCMLN1AkICS:
Los Comentar|os son |os textos que genera|mente se hacen en |a cabecera o a| f|na| de| programa,
tamb|n se sue|en co|ocar comentar|os para exp||car ||neas de cd|go y gu|arse en programas extensos por
|o menos yo uso |os comentar|o para bo|udear nomas =)
Los Comentar|os Ln Iava t|enen |a s|gu|ente estructura.
Correcto:
" Var|ab|e1
" Sa|do2
" NC1AIINAL

Incorrecto:
1nombre !Com|enza por Numero
Cuenta tres !Cont|ene espac|o en b|anco
new ! es una pa|abra reservada
nueva# !Cont|ene Meta Carcter

8 www.hackxcrack.es
]] no|a Soy Un Comentar|o en Iava y M| resenc|a aqu| no afecta en |o mas m|n|mo a| programa
]*
* no|a Soy Un Comentar|o en Iava
* De Var|as L|neas =D
*]
8|en ahora ten|endo unos cuantos conceptos bs|cos t|ramos e| code:
pub||c c|ass suma{
pub||c stat|c vo|d ma|n (Str|ng [] args)
{
|nt num1 = 20,
|nt num2 = 20,
|nt suma,
suma = num1 + num2,
System.out.pr|nt|n("L| resu|tado es"+suma),
}
}

Lxp||cac|on
8|en Comp||amos como ya sabemos =) y tendremos como resu|tado 40 en este e[erc|c|o vemos |a manera
de dec|arar var|ab|es as|gnadas como num1 que es un entero con va|or de 20 y |a var|ab|e suma que es un
entero que no |e as|gnamos va|ores ya que e| va|or de este vendr de |a suma de num1 + num2, nos
topamos tamb|n con |nstrucc|n:
System.out.pr|nt|n("L| resu|tado es"+suma),
S|..s|.. ya se es para mostrar un mensa[e en panta||a y tamb|n resu|tados obten|dos en operac|ones
rea||zadas dentro de| programa.
Muy 8|en! As| es.. ,D

ero No qu|ero As|gnar |os Nmeros qu|ero D|g|tar|os o M|smo!! :S

Muy 8|en Ln e| S|gu|ente L[erc|c|o veremos como capturar datos d|g|tados desde e| tec|ado, as|gnar|os a
var|ab|es para |uego rea||zar operac|ones pert|nentes.

|mport [ava.ut||.Scanner,
pub||c c|ass suma[{
pub||c stat|c vo|d ma|n(Str|ng Args[]){
|nt num1,
|nt num2,
|nt suma,
Scanner reader = new Scanner(System.|n),
9 www.hackxcrack.es
System.out.pr|nt ("D|g|te pr|mer numero:"),
num1 = reader.nextInt(),
System.out.pr|nt ("D|g|te segundo numero:"),
num2 = reader.nextInt(),
suma = num1+num2,
System.out.pr|nt|n("L| resu|tado es:"+suma),
}
}

Nos topamos que hemos usado |a |nstrucc|n |mport con |a que.. s| s|.. |mportamos |a ||brer|a
[ava.ut||.Scanner para poder recuperar en nuestras var|ab|es |os datos d|g|tados en |a conso|a .D
Med|ante num1 = reader.nextInt(), de resto |gua| una vez tenemos |os datos rea||zamos operac|ones y
mostramos resu|tados en e| transcurso de |a programac|n en [ava podrs darte cuenta que debers
|mportar a|gunas ||brer|as para poder ut|||zar c|ertas func|ones y contro|ar eventos.

INS1kUCCICNLS DL CCNDICICN
Lstas Instrucc|ones eva|an |a verac|dad en cuanto a eventos dados en e| programa, exacto te estoy
hab|ando de| muy conoc|do "SI" e| cua| abunda en |a mayor|a de |os |engua[es de programac|n ya que es
una |nstrucc|n muy poderosa.
s|ntax|s

|f [Cond|c|n] {
[sentenc|as 1]
}
e|se
{
[sentenc|as 2]
}

Un e[emp|o: Deseamos ||evar a [uan, car|os y a m|gue| a una D|sco pero so|o adm|ten so|o mayores de 18
1endr|amos que saber |a edad de |os 3 no? L|sto ed|mos |a edad de cada uno y eva|uamos s| estas son
mayores a 18 con un s|.
Comenzamos.

10 www.hackxcrack.es
SCLUCICN:
pub||c c|ass van{
|nt edadde[uan, edaddecar|os, edaddem|gue|,
Scanner reader = new Scanner(System.|n),
System.out.pr|nt ("D|g|te |a edad de [uan"),
edadde[uan = reader.nextInt(),
System.out.pr|nt ("D|g|te |a edad de car|os"),
edaddecar|os = reader.nextInt(),
System.out.pr|nt ("D|g|te |a edad de m|gue|"),
edaddem|gue| = reader.nextInt(),
|f (edadde[uan >= 18) {
System.out.pr|nt|n("IUAN ULDL LN1kAk A LA DISCC A UL 1ILNL"+edadde[uan),
}
e|se
{
System.out.pr|nt|n("IUAN NC ULDL LN1kAk A LA DISCC A UL 1ILNL"+edadde[uan),
}
|f (edaddecar|os >= 18) {
System.out.pr|nt|n("CAkLCS ULDL LN1kAk A LA DISCC A UL 1ILNL"+edaddecar|os),
}
e|se
{
System.out.pr|nt|n("CAkLCS NC ULDL LN1kAk A LA DISCC A UL 1ILNL"+edaddecar|os),
}
|f (edaddem|gue| >= 18) {
System.out.pr|nt|n("MIGULL ULDL LN1kAk A LA DISCC A UL 1ILNL"+edaddem|gue|),
}
e|se
{
System.out.pr|nt|n("MIGULL NC ULDL LN1kAk A LA DISCC A UL 1ILNL"+edaddem|gue|),
}
}
}

Lxp||cac|n de| cd|go:
Como en e| e[erc|c|o anter|or ped|mos |os datos, pero con |a part|cu|ar|dad que eva|uamos |os datos
recuperados con e| cond|c|ona| BAL

"# $%&'&&%(')*+, -. /01 2
34,5%67+8579)":5*:$;<=>?@3 ABCDC CEF>=> = ?= DG3<@ H= IBC FGCEC;J%&'&&%(')*+,1K
L
%*,% 2
34,5%67+8579)":5*:$;<=>?@3 E@ ABCDC CEF>=> = ?= DG3<@ H= IBC FGCEC;J%&'&&%(')*+,1K
L

S| edaddecar|os es mayor o |gua| ( >= ) a 18 escr|ba CAkLCS ULDL LN1kAk A LA DISCC
S| no es as|: CAkLCS NC ULDL LN1kAk A LA DISCC
Ic|| verdad?
IMAGLN DLL LILkCICIC AN1LkICk

INS1kUCCICNLS DL kLL1ICICN "CICLC ICk"

Un oco mas de 1eor|a.. es bueno por que muchos "rogramadores" so|o conocen e| nombre de |as
func|ones, no se muchas veces usan |nstrucc|ones en un |engua[e por "|nerc|a" bue.. S|gamos..

L| 8uc|e ICk es una estructura de contro| d|spon|b|e en cas| todos |os |engua[es de programac|n..
Cfrec|ndo|e a| programador |a pos|b|||dad de def|n|r cuantas veces desea generar determ|nada acc|n

S|ntax|s
for var|ab|e1 # var|ab|e2 hasta var|ab|e3 |ncrementos de var|ab|e4 {
Instrucc|ones.
}

!3<>RRR Antes de t|rar e| code Veamos |os operadores de re|ac|n:

CLkADCkLS DL kLLACICN
Cperador Nombre
= Igua|
< Menor
> Mayor
<= Menor C Igua|
>= Mayor C |gua|
!= D|ferente

M|ra|os 8|en ue sern vuestros Nuevos a||ados de ahora en ade|ante =D

Un L[emp|o: nacer un programa que genere |as tab|as de mu|t|p||car, |d|endo de entrada |a tab|a que
deseamos rev|sar.


pub||c c|ass tab|a{
|nt tab|a,
Scanner reader=new Scanner(System.|n),
System.out.pr|nt|n("ue 1ab|a de Mu|t|p||car Deseas kev|sar?"),
tab|a=reader.nextInt(),
System.out.pr|nt|n("****** 1A8LA DL MUL1ILICAk GLNLkADA ****** "),
for (|nt var1=1,var1<11,var1++)
System.out.pr|nt|n("Mu|t|p||cac|on de: "+tab|a+ "x" +var1+ "=" +(var1*tab|a)),
}
}

Como vemos ped|mos e| numero de |a tab|a que deseamos ver y med|ante e| c|c|o "for" |n|c|amos |a
var|ab|e "var|ab|e1" en un va|or de "1" e |ncrementndo|a hasta que sea menor a 11 |uego mostramos |a
sa||da por panta||a con un mensa[e en e| cua| tamb|n ||eva |a operac|n de mu|t|p||cac|n.

INS1kUCCIN DL kLL1ICICN CICLC "WnILL" M|entas UL

Lsta es otra |nstrucc|n poderosa a| momento de repet|r b|oques de cd|go, su func|n esta centrada en
e[ecutar b|oques de cd|go m|entras una |nstrucc|n sea verdadera.

S|ntax|s

Wh||e (Cond|c|n)
{
Instrucc|ones..
}

Sa|e L[emp|o...
nacer Un programa que p|da e| nmero de notas a traba[ar y |as promed|e.

]*kCMLDIC DL NC1AS
*U1ILIANDC CICLC WnILL LN IAVA "kecuerda Soy Un Comentar|o =D"
*]
pub||c c|ass promed|odenotas {
pub||c stat|c vo|d ma|n (Str|ng Args[]){
]]Dec|arac|on de Var|ab|es
|nt nn,
|nt tope = 1,
f|oat n,
f|oat notas = 0,
Scanner reader=new Scanner(System.|n),
]]Mensa[e a| Usuar|o
System.out.pr|nt|n("*****************************************"),
System.out.pr|nt|n("******Cuantas Notas Deseas Lva|uar?******"),
System.out.pr|nt|n("*****************************************"),
]]keco[emos La Cant|dad de Notas a romed|ar
nn=reader.nextInt(),
wh||e(tope<=nn) ]]M|entras que 1ope Sea Menor Igua| a nn |damos Notas
{
System.out.pr|nt|n("D|g|ta Una Nota"),
n=reader.nextI|oat(),
tope=tope+1, ]]Incrementamos e| va|or de |a var|ab|e tope para contro|ar e| c|c|o
notas=notas+n, ]]Vamos keco|ectando e| Va|or de |as Notas ue D|g|tamos y |as sumamos
}]]cerramos e| c|c|o
System.out.pr|nt|n("L| romed|o de Notas es:"+(notas]nn)), ]] Mostramos kesu|tados
}
}


Aqu| 1erm|namos Con Iava Ln modo conso|a ahora pasamos a un entorno de traba[o mucho ms am|gab|e
y cmodo e| cua| nos fac|||tara mucho nuestro traba[o "NL18LANS" nay muchos IDL Lo s pero para m|
uno de |os ms comp|etos y robustos es NL18LANS de |a m|sma compa|a de [ava, SUN que actua|mente
cursa en su vers|n =)
odemos Acceder a |a descargar Aca: http:]]netbeans.org]commun|ty]re|eases]0]
Ln |a parte de arr|ba exp||que |o que era un IDL pero ta| vez te ests preguntando ser que e| IDL
programara por m|? A[a como acabas de dec|r que me fac|||tara e| traba[o.. :
Lst b|en ac|aremos |os IDL "IN1LGkA1LD DLVLLCMLN1 LNVIkCNMLN1" Ls un programa e| cua| nos
pone en bande[a de p|ata un |engua[e para que programemos so|o |as func|ones de |os programas que
hagamos y no todo e| proyecto en s|. L[emp|o:
or conso|a os tocar|a desde d|sear |as ventanas de tus formu|ar|os hasta crear cada botn a mano code
por code.
M|entras que un IDL te perm|te crear formu|ar|os arrastrar componentes "botones, et|quetas, tab|as" etc
Vez |a venta[a de tener un IDL =) pero cabe reca|carte que un buen programador debe saber hacer desde
arrastrar un componente a un formu|ar|o, hasta saber e| code que se ha generado a| momento de rea||zar
esa acc|n.
Lxacto! ue |as cosas es me[or hacer|as uno m|smo que a que otro te |as de echas pero sabemos que este
campo de |a programac|n se mueve muy rp|damente y debemos estar a |a par y sacar proyectos para
vender y obtener ms c||entes as| que e| espab||a p|erde!! .

LCnANDC NULS1kC kIMLk VIS1AC AL IDL =)

Como Vemos es un entorno graf|co pero tamb|n podemos rea||zar programas por conso|a como |os que
ven|amos rea||zando, ya no tenemos que abr|r |a conso|a y tec|ear [ava [nombreprograma] so|o damos
e[ecutar y ||sto [e[e ya te d|ste cuenta de |o que pasa cuando |e das a| botn e[ecutar no? xD

1amb|n t|enes a tu d|spos|c|n una pa|eta de componentes con botones, |abe|s, campos de texto entre
muchos otros componentes ms que so|o ser dar c||c y ||evar|o a tu formu|ar|o ,) L| Inspector de Cb[etos
muestra un rbo| de todos |os componentes que ests ut|||zando en a|gn formu|ar|o, se que estas
ans|oso por hacer tu pr|mera ap||cac|n haber qu ta| te va ||sto hagmos|a!!

Como pr|mera med|da vamos a crear un proyecto
I||e! New royect.

L|eg|mos Iava App||cat|on como en |a s|gu|ente |magen .)


Next >>
onemos e| nombre de| proyecto es e| nombre que qu|eras man yo |e puse "m| proyecto de e[emp|o"
Veamos que tanto vue|a tu |mag|nac|n :D f|n|sh

=C se crearon e| paquete y |a c|ase (n), Lxacto se crean so||tos y como |o que vamos a traba[ar es entorno
graf|co crearemos un formu|ar|o para empezar a rea||zar tareas senc|||as, cabe dec|r que nuestra f|na||dad
es ||egar a rea||zar un proyecto con conex|ones a bases de datos =) pero para ||egar haya tendremos que
pract|car a|gunas cos|||as bs|cas, "ac|enc|a V|rtud de Sab|os"

8|en Creamos e| Iormu|ar|o C||c Derecho Sobre nuestro aquete ! new ! [frameform
Se.. Creat|vo camb|a e| nombre xDD

S que eres |mpac|ente y qu|eres e[ecutar e| formu|ar|o as| en b|anco

L[ecutas con Sh|ft + I6 o te vas a| Lxp|orador de proyectos c||c derecho sobre e| arch|vo que qu|eres
e[ecutar y escoges run f||e
Lo L[ecutaste.. =D
8ueno un gran programador
Ls una persona |nqu|eta
ue |e gusta exper|mentar
nasta |as cosas ms senc|||as
De |as cua|es aprende mucho ms de |o que |mag|na

Creando L| r|mer Lntorno Graf|co Con Contro|es

a que tenemos e| formu|ar|o ||sto so|o tenemos que arrastrar contro|es de |a pa|eta de contro|es que se
encuentra a |a derecha.
nagamos un pr|mer e[erc|c|o bs|co arrastramos 3 [textI|ed's 3 ILabe|'s y un I8utton
Lxacto Sumaremos :

ara Camb|ar e| texto de |as et|quetas de |as ca[as de texto o de| botn so|o se|ecc|onamos e| contro| y nos
vamos a |as prop|edades de| ob[eto y buscamos |a prop|edad text y mod|f|camos.

s|mp|emente c||c derecho a| componente "Ld|t 1ext"
8|en Ahora a programar!! Antes de empezar recordar que |os [textI|e|d's recuperan todo en formato texto
:S ue haremos!!
8|en asos a segu|r
1. dec|araremos var|ab|es Str|ng para caputar |os datos de |os [textf|e|d's
2. dec|araremos var|ab|es de t|po numero.
3. rea||zaremos una convers|n de |as var|ab|es t|po Str|ng a numero
4. rea||zamos una suma comn y corr|ente
S. mostramos e| resu|tado en e| tercer ItextI|e|d
Iac||!!
Con e| formu|ar|o ab|erto da c||c en e| botn code [e[e s| |o t|enes en |ng|es en source y nos ub|camos ba[o
package m|.proyecto.de.e[emp|o,
L |mportamos |a ||brer|a [avax.sw|ng.ICpt|onane, para poder |anzar mensa[es.
|mport [avax.sw|ng.ICpt|onane,
8|en damos dob|e c||c a| botn "ca|cu|ar" y t|ramos e| code.

Str|ng a,b, ]]Dec|aramos Var|ab|es Str|ng
doub|e c,d,e, ]] Dec|aramos var|ab|es 1|po Doub|e
a = [1extI|e|d1.get1ext(), ]] Capturamos Los Va|ores de| ItextI|e|1 en "a"
b = [1extI|e|d2.get1ext(), ]] Capturamos Los Va|ores de| ItextI|e|2 en "b"
c = Doub|e.parseDoub|e(a), ]]Convers|on de 1exto a Doub|e
d = Doub|e.parseDoub|e(b), ]]Convers|on de 1exto a Doub|e
e = c + d, ]]a podemos sumar norma|mente
[1extI|e|d3.set1ext(Str|ng.va|ueCf(e)), ]]Mostramos Va|ores en e| I1extI|e|3
ICpt|onane.showMessageD|a|og(th|s, ".::L|sto!!::.", "Suma kea||zada Corectamente",
ICpt|onane.INICkMA1ICNMLSSAGL), ]]L|sto!

1ICS DL MLNSAILS CCN IC1ICNANL

L| code s|empre ser e| m|smo |o n|co que muchas veces debemos mostrar d|ferentes t|pos de mensa[es
e[emp|os:

Mensa[e de Lrror

ICpt|onane.showMessageD|a|og(th|s, ".:1Lk1C MLNSAIL::.", "1I1ULI
MCNSAIL", ICpt|onane.LkkCkMLSSAGL),

Mensa[e de regunta

ICpt|onane.showMessageD|a|og(th|s, ".:1Lk1C MLNSAIL::.", "1I1ULI MCNSAIL",
ICpt|onane.ULS1ICNMLSSAGL),

Mensa[e de Advertenc|a

ICpt|onane.showMessageD|a|og(th|s, ".:1Lk1C MLNSAIL::.", "1I1ULI
MCNSAIL", ICpt|onane.CANCLLC1ICN),

Lstos son a|gunos e[emp|os, so|o es co|ocar
ICpt|onane.showMessageD|a|og(th|s, ".:1Lk1C MLNSAIL::.", "1I1ULI MCNSAIL", ICpt|onane. sa|drn todas |as
opc|ones para e| mane[o de mensa[es ya sea de |nformac|n o de so||c|tud de datos muy conf|gurab|es.

LILkCICICS kCULS1CS AkA kAC1ICAk IUNCICNLS DL ALGUNCS CCMCNLN1LS

CCMCNLN1L A LS1UDIAk IkADIC8U11CN
Los kad|o8uttons son componentes para se|ecc|n de opc|ones un e[emp|o:

D|g|tamos |os 2 nmeros y escogemos sumar sumamos d|g|tamos |os
2 nmeros y escogemos restar restamos y as| suces|vamente =)

8|en |o que debemos hacer es dec|r|e a| botn ca|cu|ar que cuando
Se |e d c||c eva|u e| IkADIC8U11CN se|ecc|onado y haga a|guna
Acc|n ert|nente en este caso sumar, restar, mu|t|p||car o d|v|d|r

Nota: Cada Ikad|o8utton ||eva cons|go puesto e| nombre equ|va|ente a su func|n. In|c|amos:
Dob|e c||c a| 8otn ca|cu|ar:

Str|ng n1,n2,
|f (sumar.|sSe|ected()) { ]]aqu| es donde ver|f|camos
Doub|e numero1,numero2,resu|tado,
n1 = [1extI|e|d1.get1ext(),
numero1 = Doub|e.parseDoub|e(n1),
resu|tado = numero1 + numero2,
[1extI|e|d3.set1ext(Str|ng.va|ueCf(resu|tado)),
]]de| resto |gua|, convers|on y muestra deresu|tado
}

|f (restar.|sSe|ected()) {
resu|tado = numero1 - numero2,
}
|f (mu|t|p||car.|sSe|ected()) {
resu|tado = numero1 * numero2,
}
|f (d|v|d|r.|sSe|ected()) {
resu|tado = numero1 ] numero2,
}
}
CCMCNLN1L A LS1UDIAk ICCM8C8Ck
L| uso hab|tua| de un Icombobox o ||stas desp|egab|es es de se|ecc|onar un |tem y se genere una acc|n o
muchas veces tamb|n has pod|do darte cuenta en |os t|p|cos formu|ar|os de reg|stro en cua|qu|er web
cuando vas a se|ecc|onar e| pa|s |e das c||c a |a ||sta desp|egab|e "combobox" y se|ecc|onas e| tuyo bueno
|o que se hace en esos formu|ar|os es guardar e| reg|stro de ese combobox segn |o que vos se|ecc|ones =)
ract|quemos un poco con |os ICCM8C8Ck:

LILkCICIC kCULS1C:
As|gnar S opc|ones a un ICombo8ox y a| se|ecc|onar a|gn |tem un ILabe| d|ga que |tem se|ecc|onamos:
Dob|e c||c a| ICombo8ox y codeamos:

Str|ng var, ]]Dec|aramos una var|ab|e str|ng para guardar e| dato de| ICombobox
var=((Str|ng) [Combo8ox1.getSe|ectedItem()), ]]As|gnamos e| va|or se|ecc|onado a |a var|ab|e
|f (var.equa|s("I1LM NUMLkC 1")){ ]]eva|uamos qu va|or t|ene |a var|ab|e var
[Labe|3.set1ext("nAS SLLLCCICNADC LL I1LM NUMLkC UNC"),
]] mostramos que |tem se|ecc|onamos
}
|f (var.equa|s("I1LM NUMLkC 2")){
[Labe|3.set1ext("nAS SLLLCCICNADC LL I1LM NUMLkC DCS"),
}
[Labe|3.set1ext("nAS SLLLCCICNADC LL I1LM NUMLkC 1kLS"),
}
[Labe|3.set1ext("nAS SLLLCCICNADC LL I1LM NUMLkC CUA1kC"),
}
|f (var.equa|s("I1LM NUMLkC S")){
[Labe|3.set1ext("nAS SLLLCCICNADC LL I1LM NUMLkC CINCC"),
}

CCMCNLN1L A LS1UDIAk I1Lk1IILLD
Las ItextI|e|d osea |as trad|c|ona|es ca[as de texto, su func|on d|rectamente es rec|b|r datos ya sea para
guardar en una 8D, hacer operac|ones matemat|cas en f|n |o que e| programador est|me pert|nente con
un dato escr|to en estas.
LILkCICIC kCULS1C
D|g|tar un va|or Cua|qu|era en un I1extI|e|d y mostrar este en un Mensa[e en otro ItextI|e|d y en un ILabe|

Importamos |a ||brer|a [Cpt|onpane
package m|proyectodee[emp|o, ]]kecuerda este es e| paquete de tu proyecto
|mport [avax.sw|ng.ICpt|onane, ]]|mportamos

naber damos Dob|e c||c en e| boton Ck
Str|ng texto,
texto = [1extI|e|d1.get1ext(), ]]kecuperamos e| va|or escr|to en e| [1extI|e|d1
[1extI|e|d2.set1ext(Str|ng.va|ueCf(texto)),]]As|gnamos e| va|or recuperado a [1extI|e|d2
[Labe|S.set1ext(Str|ng.va|ueCf(texto)),]]As| m|smo a Labe|S
ICpt|onane.showMessageD|a|og(th|s, "+[1extI|e|d1.get1ext()+"", "1exto Ln I1extI|e|d1",
ICpt|onane.INICkMA1ICNMLSSAGL),]] As| m|smo en un mensa[e

CCMCNLN1L A LS1UDIAk: IASSWCkDIILLD
Los IpasswordI|e|d son |os componentes que rec|ben datos conf|denc|a|es en |a mayor|a de |os casos
contraseas esas ca[|tas de texto que cuando escr|bes so|o sa|en |os t|p|cos aster|scos ******

LILkCICIC kCULS1C
8|en para e| e[emp|o haremos un formu|ar|o
|og|n muy senc|||o se ped|ra para e| acceso a |a
ap||cac|n nombre de usuar|o y password haber
de usuar|o co|ocare "Adm|n|strator" y pass
co|ocare "1234S68910" nUM.. que co|ocas vos
he? 8|en empezamos!

D|seamos un Iormu|ar|o donde p|damos user y pass. Camb|emos |os nombres de |os campos c||c derecho
sobre e| [1extI|e|d ! change var|ab|e name yo |e puse "user" y a| [asswordI|e|d |e puse "pwd" .

Como sabemos que va||daremos |os datos en e| boton Acceder damos dob|e c||c sobre e| y programamos:
Me Imag|no que no tengo que recordar |mportar |a ||brer|a [opt|onpane xDD

Str|ng Usuar|o = user.get1ext(),
char passArray[] = pwd.getassword(),
Str|ng pass = new Str|ng(passArray),
]]capturamos |os datos d|g|tados por e| usuar|o
|f (Usuar|o.equa|s("Adm|n|strator") pass.equa|s("1234S68910")) {
ICpt|onane.showMessageD|a|og(th|s, ".::8|enven|do a |a Ap||cac|on!::.", "Acceso Correcto",
ICpt|onane.INICkMA1ICNMLSSAGL),
]]ver|f|camos s| estos equ|va|en a nuestro |og|n user Adm|n|strator y pass 1234S68910
m|proyectodee[emp|o.pr|nc|pa| pr|nc|pa|= new m|proyectodee[emp|o.pr|nc|pa|(),
pr|nc|pa|.show(),
]]De ser c|erto Mostramos e| formu|ar|o pr|nc|pa|
setV|s|b|e(fa|se),
]]y ocu|tamos e| |og|n
} e|se {
]] de ser erroneo nuestros datos d|g|tados mostramos un error de acceso
ICpt|onane.showMessageD|a|og(th|s, "Usuar|o o Contrasea Incorrectos Ver|f|ca", "Lrror de
Acceso", ICpt|onane.LkkCkMLSSAGL),

user.set1ext(nu||),
pwd.set1ext(nu||),
]]y ||mp|amos |os campos para un nuevo |ntento

}


CCMCNLN1L A LS1UDIAk: IMLNU8Ak
8|en un menu para ofrecer opc|ones a d|ferentes parte de un software as| como cuando e| profe de
|nformat|ca dec|a en e| co|e, bueno nos vamos a arch|vo ! nuevo xDD exacto esta hac|endo referenc|a a|
|tem nuevo que esta en e| menu arch|vo b|en hagamos uno en netebeans creamos un formu|ar|o y
se|ecc|onamos de |a secc|on Sw|ng Menus de |a pa|eta de componentes e| componente MLNU8Ak

|o co|ocamos en nustro formu|ar|o como vez ensegu|da se s|tua en |a parte super|or como cua|qu|er
menu.

Armando e| menu as|..
AkCnIVC ACLkCA DL..
Cpc|on 1 hacerca de hack x crack
Cpc|on 2
Cpc|on 3
Sa||r

A| p|car en opc|on1 abr|remos un formu|ar|o puede ser en b|anco y as| con opc|on 2,3 y tamb|en en e|
menu acerca de..
C||c derecho sobre e| pr|mer |tem ! ed|t text para mod|f|car e| texto pones Arch|vo y en e| otro pones
Acerca de..

Ahora agregamos |os |tems de cada menu c||c derecho add from pa|ette ! menu |tem

Agregamos |as 4 opc|ones y |a opc|on de acerca de.. deber|amos |r as|..

S| eres 8uen observador puedes dar cuenta que os da |a opc|on de co|ocar|e a |os |tems shortcut osea
as|gnar|e una tec|a de acceso rap|do y un |cono so|o es dar|e dob|e c||c y conf|gurar|a =)

ASIGNANDC IUNCICNLS A CADA I1LM
Ub|quemos Cpc|on 1 de| menu arch|vo y demos c||c derecho ! events!act|on!act|onerformed

Ln este caso abr|re un formu|ar|o que se |e ||ame opc|on1
m|proyectodee[emp|o.opc|on1 var|ab|e= new m|proyectodee[emp|o.opc|on1(),
var|ab|e.show(),
as| m|smo con |os demas |tems
y e| |tem sa||r? As| me gusta que estes atento =D
hacemos |gua| que en |os demas pero e| code ser|a:
System.ex|t(0),]]Un boton cerrar :

CCMCNLN1L A LS1UDIAk IANLL
Los pane| son ut|||zados para agrupar componentes o en muchas ocac|ones yo |os tomo so|o para
co|ocar|e una |magen de fondo a un formu|ar|o.
Sa|e e[emp|o co|oquemos una |magen de fondo a un formu|ar|o med|ante un [pane|

Lxpandemos e| [pane| de ta| manera que cubra todo e| formu|ar|o y nos bamos a prop|edades.. no se
o|v|de que se encuentra en |a parte derecha de| programa esco[es border.

Aqu| se|ecc|onas Matte 8order y |uego c||c en |con se|ecc|onas externa| |mage para buscar|a en tu c

C||c en Ck y ||sto habremos puesto una |magen de fondo a| programa
Ln m| caso me quedo as|.

8|en s| has ||egado hasta aqu| qu|ere dec|r que t|enes muchos conseptos bas|cos en programac|on [ava y
de| mane[o de| IDL NL18LANS, ahora haremos |a tan anhe|ada conex|n a 8ASL DL DA1CS para e| pr|mer
paso en |as conex|ones, ut|||zaremos como "Motor de 8ase de Datos" M|crosoft Access, u|zas s| has |e|do
sobre access muchos no |o cata|ogan como un verdadero motor y gestor de bases de datos op|n|on que
comparto con e| que |o d|ce ,) pero sera e| pr|mer esca|on a sub|r.
ero me d|ces que no es cata|ogado como un verdadero motor de bases de datos : por que no hacemos
una conex|n con un verdadero motor de bases de datos?
ac|enc|a.. dec|erto os d|go que a| term|nar |a conex|n con access rea||zaremos una con MSL =)
No pongas esa cara n|ngun conoc|m|ento esta de mas ta| vez a|gun d|a neces|tes una bases|ta de datos en
access para a|gun programa pequeo.. o b|en ut|||zar tab|as tempora|es en access vez.. de a|go puede
serv|r :D
ero ten en cuenta |as pa|abras de un profesor que tuve " DLSULS UL LA LMkLSA 1LNGA UN AVISC
DL MAS DL 4 ML1kCS DL ANCnC A ACCLSS NC LL SIkVL CCMC MC1Ck DL 8ASL DL DA1CS kD"

S|n mas n| mas empezamos

CCNLC1ANDC A NULS1kA kIMLkA 8ASL DL DA1CS LN ACCLSS

Montamos un escenar|o con 4IttextI|e|d's 4 I|abe|'s y un I8utton As|:

Camb|amos |as var|ab|es de |as ca[as de texto como ya sabemos c||c derecho change var|ab|e name
pongamos nombres a|us|vos |dent|f|cac|on,nombres,ape|||dos,ocupac|on como ya sabes que |a f|na||dad
es guardar esos campos d|g|tados en una base de datos en access abr|mos access para crear |a 8D.

Como puedes ver |e co|oque de nombre 8D.mdb, CIC no |a guardes aun e| paso a segu|r es guardar|a en |a
m|sma carpeta de tu proyecto.
y donde estan guardados |os proyectos de NL18LANS?
Ln M|s Documentos en |a carpeta ||amada Net8eansro[ects hay se encuentran todos yo en m| caso qu|ce
ser un poco organ|zado y dentro de |a carpeta de| proyecto cree otra con nombre basededatos y |a guarde
hay dentro =)

Ahora traba[amos en access damos dob|e c||c sobre cada co|umna y co|ocamos |os nombres de estas as|:

C|erras |a tab|a y ped|ra un nombre yo |e puse datospersona|es
Seg|mos c||c derecho a |a tab|a ps d|go |a por que so|o tenemos una xD
esco[es v|sta d|seo

Vemos como estan const|tu|dos |os datos de |a tab|a y tamb|en vemos que |a ||ave pr|mar|a es e| campo
|dent|f|cac|on
LLAVL kIMAkIA: es |a co|umna que representara |os datos a|macenados en |a tab|a y no debe repet|rse
L[emp|o: Insertaste en |dent|f|cac|on: 123, en nombre: [ose, en ape|||dos: mendez, y en ocupac|on:
desemp|eado a| buscar |a |dent|f|cac|on con numero 123 sabras que haces referenc|a a [ose medes que es
un desocupado xDD
8|en vemos como esta conformada |a tab|a y nos damos cuenta que e| campo |dent|f|cac|on t|ene t|po de
dato autonumer|co |o pasamos a texto tamb|en ,)

Guardamos, hemos term|nado con access vo|vamos a Net8eans.

Creamos Una c|ase para |a conex|n
kecuerda c||c derecho sobre e| paquete de tu proyecto !new! Iava c|ass de nombre puse conex|n
Creamos otra c|ase ||amada guardar.
La c|ase conex|n hara |a referenc|a o |a conex|n con |a base de datos de access y |a c|ase guardar tendra
|as func|ones "obv|as" de guardar ut|||zando como referenc|a |a c|ase conex|n
As| va e| paquete

por que todo |o hacemos en c|ases y no e| code en e| boton como he v|sto en otros |engua[es?
ues s| podemos hacer|o con e| code en e| boton pero p|ensa s| t|enes un software con m|| botones
guardar, mod|f|car, e||m|nar etc cuantas conex|ones tocar|a hacer? Lste e[emp|o es pensado para personas
que qu|eran segu|r programando en [ava a |o grande, hay que prepararse para |a destrucc|on de mundo y
as| se emp|eza =)
Lmpezaremos con e| code, ya sabemos que donde veas un Iopt|ompane debes |mportar |a ||brer|a
Abr|mos |a c|ase conex|n e |mportamos a|gunas ||brer|as necesar|as para e| contro| de errores "de
haber|os" y dr|vers de conex|n

package m|proyectodee[emp|o,]] a sabes que este es e| paquete
|mport [ava.sq|.Connect|on,
|mport [ava.sq|.Dr|verManager,
|mport [ava.sq|.SLLxcept|on,
|mport [ava.sq|.Statement,

pub||c c|ass conex|on {
pr|vate Connect|on conex|on,
pub||c Statement sentenc|a,

pub||c vo|d conectar8aseDeDatos() {
try {

f|na| Str|ng CCN1kCLADCk = "sun.[dbc.odbc.IdbcCdbcDr|ver", ]]Aqu| se dec|ara e| contro|ador a ut|||zar
C|ass.forName( CCN1kCLADCk ),
f|na| Str|ng kU1A8D = "[dbc:odbc:Dr|ver={M|crosoft Access Dr|ver (*.mdb)},D8="+
System.getroperty( "user.d|r" )+"]dasedatos]8D.mdb", ]] hacemos referenc|a a| arch|vo access 8D.mdb
conex|on = Dr|verManager.getConnect|on(kU1A8D),
sentenc|a = conex|on.createStatement(),
]] se dec|ara una var|ab|e sentenc|a para |a man|pu|ac|on de |a base de datos
}
catch (C|assNotIoundLxcept|on ex1) {
ex1.pr|ntStack1race(),
[avax.sw|ng.ICpt|onane.showMessageD|a|og(nu||,"Lrror Carga Dr|ver"),
System.ex|t(1),
]]Ln caso de errores de dr|ver
}
catch (SLLxcept|on ex) {
ex.pr|ntStack1race(),
[avax.sw|ng.ICpt|onane.showMessageD|a|og(nu||,"Lrror Creac|on Statement"),
System.ex|t(1),
]]en caso de no acceder a |a base de datos o no encontrar ruta correcta
}
}
}

SLGUIMCS AnCkA CCN LA CLASL GUAkDAk

package m|proyectodee[emp|o,

pub||c c|ass guardar {
m|proyectodee[emp|o.conex|on bd = new m|proyectodee[emp|o.conex|on(),
]] As|ganmos un a||as a |a c|ase conex|n en este caso bd
pub||c vo|d reg|strardatos(Str|ng |d,Str|ng n,Str|ng a, Str|ng o){
]]ha|amos |as var|ab|es dec|aradas en e| formu|ar|o pr|nc|pa|.. tranqu||o ya |as dec|aramos. xD
try{
bd.conectar8aseDeDatos(),
]]conectamos..
bd.sentenc|a.execute("INSLk1 IN1C datospersona|es(|dent|f|cac|on,nombres,ape|||dos,ocupac|on)
VALULS("+|d+","+n+","+a+","+o+""+")"),
]]|nsertamos |os datos un SL norma|..
]]D no exp||co SL por que hay una rev|sta expresamente para eso =D
}catch (Lxcept|on e){}
}
}
Ahora segu|mos con e| ICkMULAkIC en m| caso se ||ama formu|ar|oconex|on y aad|mos un a||as para
hacer referenc|a a |a c|ase guardar
pub||c c|ass formu|ar|oconex|on extends [avax.sw|ng.IIrame { ]]esto es para que os gu|e ,D
m|proyectodee[emp|o.guardar guardar = new m|proyectodee[emp|o.guardar(),

L|sto segu|mos con e| boton, dob|e c||c y programamos..

Str|ng |d = |dent|f|cac|on.get1ext(),
Str|ng n = nombres.get1ext(),
Str|ng a = ape|||dos.get1ext(),
Str|ng o = ocupac|on.get1ext(),
]]kecuperamos en var|ab|es |os va|ores d|g|tados en |as ItextI|e|d
guardar.reg|strardatos(|d, n, a, o),
]]Mandamos |as var|ab|es a |a c|ase guardar.. ya e||a sabra que hacer con e||as xDD
ICpt|onane.showMessageD|a|og(nu||,"Datos Guardados Correctamente ","Mensa[e de
Conf|rmac|on",ICpt|onane.LAINMLSSAGL),
]]Dec|mos que ya todo esta heco (n)
|dent|f|cac|on.set1ext(""),
nombres.set1ext(""),
ape|||dos.set1ext(""),
ocupac|on.set1ext(""),
]] y ||mp|amos |os campos para segu|r d|g|tando $

L|sto Corremos |a ap||cac|n

Ver|f|camos |a 8ase de datos..

Lfect|vamente Los datos son env|ados correctamente a |os campos de |a 8D
Aqu| hemos term|nado nuestra pr|mera conex|n a bases de datos muy s|mp|e $
Me |mag|no que debes estar pensando que s| puedes guardar.. podras.
L||m|nar, Mod|f|car, buscar Lxacto ya has dado un gran paso hacer |a conex|n y guardar datos

Acont|nuac|on una verdadera conex|n a bases de datos ut|||zando como SG8D "S|stema Gestor de 8ases
de Datos" MSL S.1

S| no |o t|enes |nsta|ado puedes descargar|o aca: http:]]dev.mysq|.com]get]Down|oads]MySL-
S.1]mysq|-S.1.S1-w|n32.ms|

royecto a kea||zar:
Software Con Conex|n MSL "Modo Loca|"
Iunc|ones:
keg|strar datos (guardar)
Actua||zar keg|stros
L||m|nar keg|stros
8uscar keg|stros
Mostrar reg|stros A|macenados en |a 8ase de Datos

Ut|||zaremos |os m|smos mecan|snos ub|cando cada func|on en c|ases d|ferentes para un me[or
entend|m|ento y mane[o de c|ases empezamos!!

AkA LL LILMLC nL DLCIDIDC UL CkLLMCS UN kCLC1C AkA kLGIS1kC DL
LS1UDIAN1LS DL UN CCLLGIC "k"
Creamos nuestra 8ase de Datos en MSL La ||amaremos "co|eg|o"
Abr|mos La Conso|a de MSL or s| no tenemos un IDL ara Mysq| como SL ICG Nav|cat
CkLA1L DA1A8ASL co|eg|o,
ara Act|var|a y que 1odo |o que nagamos en esa 8ase de datos
USL co|eg|o


Creamos |a tab|a donde guardaremos todos |os reg|stros
'(,/+, +/Y1, 7F=89<5 Z
B; 0/('2/(Z[\] #)+ #"11-
9<8M:45 0/('2/(Z^\] #)+ #"11-
7>4FFB;<5 0/('2/(Z^\] #)+ #"11-
4;7; 0/('2/(ZW\] #)+ #"11-
;B:4@@B_9 0/('2/(Z`\] #)+ #"11-
>:B87:S a4SZB;]
]K

kLCI8IMCS..
uery Ck, 0 rows affected (0.2S sec)
LkC aun as|.. ver|f|camos que |a tab|a se haya creado.. nec|o yo? xDD
SnCW 1A8LLS,
+-------------------+
| Tables_in_colegio |
+-------------------+
| alumnos |
+-------------------+
Ckey hay tenemos nuestra tab|a creada en |a base de datos co|eg|o
Ctro t|p SL de paso m|remos como est compuesta |a tab|a..
6,!'(&Y, 7F=8<5K
+-----------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-----------+-------------+------+-----+---------+-------+
| id | varchar(20) | NO | PRI | | |
| nombres | varchar(30) | NO | | | |
| apellidos | varchar(30) | NO | | | |
| edad | varchar(10) | NO | | | |
| direccion | varchar(50) | NO | | | |
+-----------+-------------+------+-----+---------+-------+

Ckey hay tenemos |a descr|pc|n de |a tab|a que h|c|mos anter|ormente,, bue,, de[amos e| SL
por ahora..
Abr|mos Nuestro IDL de Net8eans y Creamos e| royecto para kea||zar |as Conex|ones..

a esta parte de creac|on de proyectos |a exp||que pero por |o genera| hay a|umnos que ||egan tarde a |as
c|ases xDD s|gamos..

Ln este caso yo |o ||ame proyectoconex|on ps a|us|vo a |o que estamos hac|endo

ara organ|zar |os e|ementos en nuestro proyecto separamos |as c|ases de |os formu|ar|os
Agregamos otro paquete a| proyecto como en |a s|gu|ente |magen..

C||c derecho sobre e| proyecto ! nuevo ! paquete [ava

L|sto entonces en e| paquete c|ase s|. guardaremos todo |os que son c|ases y en e| paquete
proyectoconex|on guardaremos todo |o que sern formu|ar|os =)

Agregamos Una c|aseen e| paquete c|ases |a cua| se encargara de rea||zar |a conex|n a |a base
de datos.

o |a he ||amado conex|onMySL
C||c en term|nar.
CCDIGC DL LA CLASL conex|onMySL:

package c|ases,
|mport [ava.secur|ty.r|nc|pa|,
|mport [ava.sq|.Connect|on,
|mport [ava.sq|.Dr|verManager,
|mport [ava.sq|.kesu|tSet,
|mport [ava.sq|.SLLxcept|on,
|mport [ava.sq|.Statement,
pub||c c|ass conex|onMySL {
pub||c stat|c Connect|on conex|on,
pub||c Statement sentenc|a,
pr|vate r|nc|pa| pr|n,
pub||c kesu|tSet resu|tado,
pub||c vo|d conectar8aseDeDatos() {

try {

f|na| Str|ng CCN1kCLADCk = "org.g[t.mm.mysq|.Dr|ver",
]]A| |gua| que en e| e[emp|o anter|or Dec|aramos que dr|ver vamoa a ut|||zar

C|ass.forName( CCN1kCLADCk ),

conex|on = Dr|verManager.getConnect|on("[dbc:mysq|:]]|oca|host]co|eg|o","root","root"),
]]hacemos |a conex|on en este caso en |oca|host por que |a bd esta en nuestro pc
]]espec|f|cando usuar|o y contrasea
sentenc|a = conex|on.createStatement(),
]]var|ab|e sentenc|a encargada de |as func|ones hac|a |a db
}

catch (C|assNotIoundLxcept|on ex1) {

ex1.pr|ntStack1race(),
[avax.sw|ng.ICpt|onane.showMessageD|a|og(nu||,"Lrror Carga Dr|ver"),
]]encaso de errores referentes a dr|ver error de carga, no encontrar|o etc
System.ex|t(1),
}
catch (SLLxcept|on ex)
{
[avax.sw|ng.ICpt|onane.showMessageD|a|og(nu||,"Lrror Creac|on Statement"),
]]encaso de no encontrar |a bd
System.ex|t(1),
}
}
pub||c vo|d desconectar8aseDeDatos() {
]] metodo de desconex|on
try {
|f (conex|on != nu|| ) {
|f(sentenc|a != nu||) {
]]s| |a conex|on devue|ve va|ores nu|os
sentenc|a.c|ose(),
}
conex|on.c|ose(),
}
}
catch (SLLxcept|on ex) {
}
}
}

kecordarte Guarda muy b|en este code ya que para rea||zar conex|ones en un futuro te sera muy ut|| so|o
bastar|a camb|ar e| nombre de |a base de datos a |a que ba||as a ut|||zar

Luego nos vamos a 8|b||otecas y aad|mos nuestro dr|ver
C||c derecho en e| paquete b|b||otecas ! aad|r 8|b||oteca

Lncaso de No tener e| Dr|ver Insta|ado no ser|a nada raro #D pues |o descargamos
http:]]dev.mysq|.com]get]Down|oads]Connector-I]mysq|-connector-[ava-S.1.13.tar.gz
Lo descargamos obv|o que ya no ser|a c||c derecho sobre 8|b||otecas aad|r b|b||otecas
Ahora ser|a c||c derecho sobre b|b||otecas Aad|r arch|vo IAk]Carpeta

8uscamos La carpeta mysq|-connector-[ava-S.1.13 y aad|mos e| arch|vo IAk
Ahora agregamos L| formu|ar|o e| cua| tendr |as func|ones d|rectas Guardar,
L||m|nar,8uscar,Mod|f|car y cua|qu|er otra que se nos ocurra xDD


o |o ||ame |n|c|o.
|o d|seamos de |a s|gu|ente manera acorde a nuestros datos de |a bd As|:
Nombre 1|poComponente
| I1extI|e|d
n I1extI|e|d
a I1extI|e|d
e I1extI|e|d
buscar|dent I1extI|e|d
M|tab|a I1ab|e
S I8utton's

Se Lxp||ca So|o no?
A| crear toda nuestra ||nda |nterfaz segu|mos hac|endo pub||cas todos |os componentes.."1odos
he?"
Damos C||c Derecho a| Componente en este e[emp|o a "|" ue es un Itextf|e|d nos vamos a
prop|edades |uego a |a pestaa cd|go |uego nos ub|camos en mod|f|cadores de var|ab|es y
escogemos pub||c stat|c
Como en |a s|gu|ente |magen >

Igua| Con Los Dems Componentes..
Nota:
Un Acceso pb||co es para ue
desde Cua|qu|er parte de
nuestro proyecto podamos
acceder a estos componentes
ya sea as|gnndo|e va|ores o
extrayendo va|ores de estos.

Creando Las C|ases Guardar, L||m|nar, Actua||zar, buscar y Mostrar

CCDIGC DL LA CLASL GUAkDAk

package c|ases,


pub||c c|ass guardar {
c|ases.conex|onMySL bd = new c|ases.conex|onMySL(),]]se dec|ara un a||as bd que es |gua| que dec|r
conex|onMySL
pub||c vo|d reg|strara|umno(Str|ng |d, Str|ng nombres, Str|ng ape|||dos, Str|ng edad, Str|ng d|recc|on){
]]aqu| se ha|an |as var|ab|es dec|aradas en e| formu|ar|o de |n|c|o que traen |os va|ores de |as ca[as de texto
]]hehe ahora |as dec|aramos trank|s
try{
]]conectamos
bd.sentenc|a.execute("|nsert |nto a|umnos(|d,nombres,ape|||dos,edad,d|recc|on) va|ues
("+|d+","+nombres+","+ape|||dos+","+edad+","+d|recc|on+")"),
]]|nsertamos |os datos
ICpt|onane.showMessageD|a|og(nu||, "L| A|umno Iue keg|strado Correctamente", " .::MLNSAIL::.",

}
}
CCDIGC DL LA CLASL e||m|nar

package c|ases,

pub||c c|ass e||m|nar {
c|ases.conex|onMySL bd = new c|ases.conex|onMySL(),
]]Denuevo e| a||as a |a conex|on obv|o hay que ||amar|a para conectar #D
pub||c vo|d e||m|nara|umno(Str|ng |de){
try{
bd.sentenc|a.execute("De|ete Irom a|umnos WnLkL |d= ("+|de+")"),
]]e[ecutamos un s|mp|e SL borrando de |a tab|a a|umno donde |a |de sea |gua| a |a |de
ICpt|onane.showMessageD|a|og(nu||, "L| A|umno Iue L||m|nado Correctamente", " .::MLNSAIL::.",
}
}

CCDIGC DL LA CLASL AC1UALIAk
package c|ases,
pub||c c|ass actua||zar {
pub||c vo|d actua||zara|umno(Str|ng e|eg|r|d, Str|ng no, Str|ng ape, Str|ng ed, Str|ng d|r){
]]Lstas var|ab|es v|enen de|formu|ar|o de |n|c|o pronto |as dec|araremos ]D
try{
bd.sentenc|a.execute("UDA1L a|umnos SL1
nombres="+no+",ape|||dos="+ape+",edad="+ed+",d|recc|on="+d|r+" WnLkL |d= "+e|eg|r|d+""),
]]hey!! Actua||za |os datos donde |d sea |gua| a e|eg|r|d (n)
ICpt|onane.showMessageD|a|og(nu||, "Los Datos De| A|umno Iueron Actua||zados Correctamente", "
.::MLNSAIL::.", ICpt|onane.INICkMA1ICNMLSSAGL),
}
}
Como vemos |a estructura de |as c|ases van s|endo |dent|cas so|o vamos camb|ando |as |nstrucc|ones SL
y a|gunas nuevas func|ones .)

CCDIGC DL LA CLASL 8USCAk
package c|ases,

pub||c c|ass buscar {

c|ases.conex|onMySL bd = new c|ases.conex|onMySL(),]]Lsta ||nea es |a protagon|sta de |a pe||cu|a xD
pub||c vo|d buscara|umno(Str|ng buscar|d) {
try{
bd.resu|tado = bd.sentenc|a.executeuery( "SLLLC1 * IkCM a|umnos WnLkL |d = "+buscar|d+""),
|f( bd.resu|tado != nu|| ) {
wh||e(bd.resu|tado.next() ) {
proyectoconex|on.|n|c|o.|.set1ext(""+bd.resu|tado.getStr|ng("|d")),
proyectoconex|on.|n|c|o.n.set1ext(""+bd.resu|tado.getStr|ng("nombres")),
proyectoconex|on.|n|c|o.a.set1ext(""+bd.resu|tado.getStr|ng("ape|||dos")),
proyectoconex|on.|n|c|o.e.set1ext(""+bd.resu|tado.getStr|ng("edad")),
proyectoconex|on.|n|c|o.d.set1ext(""+bd.resu|tado.getStr|ng("d|recc|on")),
}
}
e|se
ICpt|onane.showMessageD|a|og(nu||,"N|ngun dato Lncontrado","Mensa[e de
Informac|on",ICpt|onane.LAINMLSSAGL),
}
}
I|[ar que
Aqu| buscamos en |a tab|a a|umnos |a |dent|f|cac|on que este a|macenada en buscar|d
y dec|mos med|ante esta cadena
en pa|abras rust|cas s| encuentra a|go, osea s| |a consu|ta no b|ene vac|a "nu||"
mostramos |os datos re|ac|onados con |a consu|ta en |os campos de texto
proyectoconex|on.|n|c|o.|.set1ext(""+bd.resu|tado.getStr|ng("|d")),
vemos que espec|f|camos |a ruta proyecto.formu|ar|o.componente

CCDIGC DL LA CLASL MCS1kAk
Lncargada de cargar |os datos de |a tab|a de Mysq| en |a 1ab|a de| rograma

package c|ases,

pub||c c|ass mostrar {
]]e| famoso a||as a|us|vo a |a conex|on
|nt |=0, ]]var|ab|e | para e| contro| de c|c|o wh||e
pub||c vo|d mostrardatos(){
try{
|=0,
bd.resu|tado = bd.sentenc|a.executeuery( "SLLLC1 * IkCM a|umnos" ),
]]se|ecc|onamos todos de |a tab|a a|umnos
]]s| |a consu|ta no b|ene vac|a
wh||e(bd.resu|tado.next() ) {

proyectoconex|on.|n|c|o.m|tab|a.setVa|ueAt(""+bd.resu|tado.getStr|ng("|d"),|, 0),
proyectoconex|on.|n|c|o.m|tab|a.setVa|ueAt(""+bd.resu|tado.getStr|ng("nombres"),|, 1),
proyectoconex|on.|n|c|o.m|tab|a.setVa|ueAt(""+bd.resu|tado.getStr|ng("ape|||dos"),|, 2),
proyectoconex|on.|n|c|o.m|tab|a.setVa|ueAt(""+bd.resu|tado.getStr|ng("edad"),|, 3),
proyectoconex|on.|n|c|o.m|tab|a.setVa|ueAt(""+bd.resu|tado.getStr|ng("d|recc|on"),|, 4),
]]As|gnamos |os va|ores de |a consu|ta a |a tab|a
|=|+1,
}
}
}
}

SLGUIkLMCS AnCkA CCN LA ASIGNACIN DL IUNCICNLS A LCS 8C1CNLS DLL
ICkMULAkIC DL INICIC
pero pr|meramente ser as|gnar un a||as a |as c|ases para que estas puedan ser ||amadas
desde e| formu|ar|o [unto a sus func|ones as|:
damos c||c en e| boton souce en e| formu|ar|o |n|c|o

pub||c c|ass |n|c|o extends [avax.sw|ng.IIrame { ]]Lsto es para que sepas donde debes ub|carte =)
c|ases.guardar guardar= new c|ases.guardar(),
c|ases.buscar buscar= new c|ases.buscar(),
c|ases.e||m|nar e||m|nar= new c|ases.e||m|nar(),
c|ases.mostrar mostrar= new c|ases.mostrar(),
c|ases.actua||zar actua||zar= new c|ases.actua||zar(),
]*L|sto |as tenemos referenc|adas. Ahora Ahora para ue Cuando e| Iormu|ar|o Corra ( Se L[ecute ) |a
tab|a carge |os datos de |a tab|a de MSL *]
pub||c |n|c|o() { ]]Lsto es para que te gu|es kecuerda que estamos en e| formu|ar|o |n|c|o
|n|tComponents(),
mostrar.mostrardatos(),
}
]]Dec|aramos var|ab|es para rea||zar todas |as func|ones:
]]Deba[o de SuppressWarn|ngs("unchecked")
Str|ng |d,
Str|ng nombres,
Str|ng ape|||dos,
Str|ng edad,
Str|ng d|recc|on,
Str|ng e|eg|r|d,

SLGUIMCS CCN LAS IUNCICNLS DL LCS 8C1CNLS

8C1CN GUAkDAk
|d = |.get1ext(),
nombres = n.get1ext(),
ape|||dos = a.get1ext(),
edad = e.get1ext(),
d|recc|on = d.get1ext(),
]]capturamos |os datos d|g|tados en |os campos de texto
guardar.reg|strara|umno(|d, nombres, ape|||dos, edad, d|recc|on),
]]Aqu| |o que hacemos es env|ar |os datos de |os campos de texto en var|ab|es a |a c|ase guardar
|.set1ext(""),
n.set1ext(""),
a.set1ext(""),
e.set1ext(""),
d.set1ext(""),
]]Despues de Guardar L|mp|amos |os campos

8C1CN AC1UALIAk
e|eg|r|d = buscar|dent.get1ext(),
nombres = n.get1ext(),
ape|||dos = a.get1ext(),
edad = e.get1ext(),
d|recc|on = d.get1ext(),
actua||zar.actua||zara|umno(e|eg|r|d, nombres, ape|||dos, edad, d|recc|on),

8C1CN LLIMINAk
e||m|nar.e||m|nara|umno(buscar|dent.get1ext()),
|.set1ext(""),
n.set1ext(""),
a.set1ext(""),
e.set1ext(""),
d.set1ext(""),
buscar|dent.set1ext(""), ]]So|o se ||mp|an |os campos

8C1CN 8USCAk
buscar.buscara|umno(buscar|dent.get1ext()),

8C1CN LIMIAk
|.set1ext(""),
n.set1ext(""),
a.set1ext(""),
e.set1ext(""),
d.set1ext(""),
buscar|dent.set1ext(""),

Una u|t|ma screen de| programa en e[ecuc|n:

Aqu| term|na |a conex|on con MSL, con esto hemos |ogrado hacer |as func|ones pr|mord|a|es de un gran
proyecto como |o son guardar,e||m|nar,actua||zar,buscar de seguro ha s|do una gran ayuda para todo
aque| que qu|ere |n|c|arse en [ava y sacar|e e| mayor provecho a un |engua[e tan versat|| y poderoso como
este.
kecuerda..

"L| que AMA |o que hace, aun arrod|||ado a|canza |as estre||as"
VaNcnokcnk

Grac|as.

Java Bases SQL

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Java Bases SQL

Uploaded by

Copyright:

Available Formats

IAVA ICk nACk k CkACk

You might also like