Java TXT

*******************************************************************
*******************************************************************
*** ***
*** ***
*** XX XXXXXX XX XX XXXXXX ***
*** XX XX XX X X XX XX ***
*** XX XXXXXX X X XXXXXX ***
*** X XX XX XX XXXX XX XX ***
*** XXXX XX XX XX XX XX ***
*** ***
*** ***
*******************************************************************
*******************************************************************
CURSO: PROGRAMADOR DE APLICACIONES DE REDES NUMERO: 2830

Curso impartido por: Manuel Velilla
Apuntes de Carlos Gozalo
http://www.infoaplicaciones.com
Email: info@plicaciones.com
==========================
1. ELEMENTOS DE JAVA.
CREAR VARIBLES, IF, FOR, EXTRUCTURAS...
i++, i--, while, =, /= -> esto seria un lenguaje de programacion
2. PROGRAMACION ORIENTADA A OBJETOS (VIENE DE PASCAL)
(REUTILIZAR TODO
OBJETOS
CONCEPTOS HERENCIA -> REUTILIZAR CODIGO
INTERFACES -> METODOS GLOBALES-PUNTEROS
3. CLASES DE JAVA (API) JAVA.LANG ->ES BASICA PARA QUE FUNCIONE JAVA
JAVA.UTIL ->HORA, ARBOLES, LISTAS ENLAZADAS Y ARRAIS
COLECIONES DE OBJETOS, PODEMOS GUARDAR
AQUI CUALQUIER TIPO DE DATOS.
4. JAVA.AWT CLASES COMPONENTES BASICOS ENTORNO GRAFICO,
5. JAVA.SWING BOTONES,CAJA DE TEXTO
hasta aqui certificacion 310-025
desde aqui certificacion 310-252A en ingles (hacer un programa con bbdd)
310-027
6. APPLETS programa guardado en el servidor que se ejecuta en el cliente
para ejecutarlo dentro del codigo html escribiriamos:
<applet code="---">
7. I/O Entrada/Salida Guardar datos en un fichero
DESDE AQUI ES NECESARIO UN SERVIDOR DE COMUNICACIONES (PARTE EMPRESARIAL)
8. SOCKETS hablar con la tarjeta de red
REDES MODELO OSI.
9. RMI distribuida con balance de carga.
10. JNDI acceso a Active directory
DATASOURCE-> buscara el motor de la base de datos haciedo transparente la
conexion
11. BBDD -> jdbc Acceso a base de datos, como realizar consultas
Rowset
preparedsta zewent -sentencias prepradas(ej:insertar datos)
12. SERWETS-> se genera en el servidor y despues devuelve el resultado
NECESITA un descriptor de despliegue XTML
SESSION-> Hilos (PETICIONES)
FILTROS->
13. JSP -> TAGS ->ETIQUETAS PERSONALIZADAS
MVC ->
---------------------------------------------
normas notacion Hungara
Crear un documento con cualquier editor hola.java
nombreclase -> cada palabra la inicial en mayuscula HolaQueTal
variables y metodos -> la primera inicial de cada palabra en minusculas
y el resto de las iniciales en mayusculas.
variables y metodos -> la primera inicial de cada palabra en minusculas
y el resto de las iniciales en mayusculas.
campos constantes -> ERROR_DE_COMPLILACION en mayusculas todo y
separada cada palabra por un guion "_" bajo
HolaMundo.java
El programa principal sera public, si no existe no se puede ejecutar
----------------------------------------
class HolaMundo
{
public static void main (String[] arg)
{
System.out.print("Hola Mundo!");
}
}
----------------------------------------
javac HolaMundo.java <- complila el programa y
genera=> HolaMundo.class
METODOLOGIA:
VARIABLES-> GUARDAR EN MEMORIA UN VALOR

TAMA¥O BYTES
|- byte 1 -127 0 +127
| 5= 00000101
| -5= 11111010
| los negativos son el complemento
|- shrt 2
|-ENTERAS |- int 4
|- NUMERICAS | |- long 8
TIPOS | |
| | |- float 4
| |-DECIMALES |
| |- double 8
|
|
| |- char 2 bytes
|- ALFANUMERICOS |
| |- String
|
| |- true
|- BOOLEANAS boolean |
|- false;
declaracion de variables tipo primitivo
Tipo de variable(define el tama¤o)

| nombre de variable
| | Valor para la variable
| | |
int a=5;
char a='¥';
String s="Hola Que Tal"; ese valor es una constante y no se puede modificar
(String Constan pool)
el tipo literal String es un puntero a un char;
OPERADORES
| + ->
suma
ARITMETIOS| - ->
resta
| * ->
producto
| / ->
division
| % ->
modulo
| i++; ->
aumenta en uno el valor de la variable, asigna primero
| y luego incrementa
| ++i; incrementa primero y luego asigna
| a=+b;-> incremento la variable a con el valor de la variable b
| (a=a+b)
| a--;
| --a;
|
| a=012; si se pone un 0 delante de un valor trabajariamos en octal
| a=0x10; si se pone 0X delante de un valor decimal trabajariamos en
| hexadecimal
byte | & -> operador AND a nivel de byte evalua las dos condiciones
| ^ -> XOR 5 ^ 3=6 suma binaria quita el acarreo
| 00000101
| + 00000011
| 00000110 =6
| >> => operadores a nivel de byte se desplaza una posicion a la
| derecha manteniendo el signo signo (division) añade unos
| 24 >>2=6 000111000
| 000000110
|
| >>> => operadores a nivel de byte se desplaza una posicion a la
| derecha sin mantener el signo el signo (division) añade unos
|
| << -> operadores a nivel de byte se desplaza una posicion a la
| izquieda añadiendo ceros (multiplicacion)
|
|
LOGICOS | || -> operador OR "o logico" suma en biario
| && -> operador AND "y logico" producto en binario
|logic->solo evaluarian la segunda ecuacion si es true la primera.
|
|
| ! -> complementario negacion
| == -> operador de igualdad; devueve un boean;
| != -> distinto devuelve un bolean;
libro sobre bit=> extructura y tecnologia de los computadores RAMA
para convertir de un tipo a otro se introduce entre parentesis el tipo a
convertir se llama CASTING O MOLDEADO.
int a=5;
int b=2;
int c=(int)(a/b);
|- if(condicion){ A } si es true se valua entre las llaves "A"
| si es sigue a no ser que tenga else
| else{ B } si es false ejecutaria "B"
|
|- if(condicion){ A } si es true se valua entre las llaves "A"
| sigue y pregunta siguiente condicion
| else if(condicion) { B } si cumple la condicion ejecutaria
| el contenido de "B"
SENTENCIAS |
CONDICIONALES |
| swith(var) valua sobre el valor de una variable y debe de ser
| de un tipo primitivo (enteros,char)
| {
| case 3: caso que la variable valga 3
| ;
| ;
| ; Ojo falta break evaluaria primero 3 y despues 5
| ; ejecutaria el 5
| case 5: caso que la variable valga 5
| ;
| ;
| break; de aqui iria al final si no tiene break
| continuaria con la siguiente
| default: cualquier otro caso, debe de estar al final
| ; aunque no daria error si esta en cualquier
| ; otra parte
| ;
| break;
BUCLES ¢ | while (condicion) {A} mientras que se cumpla la condicion se
SENTENCIAS | se ejecuta el contenido entre las llaves.
|
|
REPETITIVAS | do { A } while(condicion) se ejecuta por lo menos una vez
|
|
| for(inicio;condicion;incremento){A} mientras que se cumplan
| las condiciones se ejecuta
| for(int i=0; i<i=10;i++){A} se pueden definir las variables
| dentro de la sentencia.
|
| continue; se salta las sentencias que hay a continuacion y
| vuelve ha preguntar, debe de ir acompa¤ado de un
| if , si no es asi dara error de complilacion
| break; rompe el bucle y rompe el flujo saltando a la
| sentencia siguiente.
LOS PROGRAMAS SON FUNCIONES:
FUERA DE LAS FUNCIONES NO SE PUEDE DAR NINGUNA ORDEN;
LOS DELIMITADORES DE LAS FUUNCIONES SON LLAVES
LAS FUNCIONES SE LLAMAN METODOS
AMBITO DE LAS VARIABLES.
EL AMBITO DE UNA VARIABLE ESTA COMPRENDIDO ENTRE LA DEFINICION DE LA VARIABLE
Y LAS LLAVES MAS CERCANAS. FUERA DE ESE AMBITO YA NO EXISTE ESA VARIABLE.
VARIABLES DE INSTANCIA:
VARIABLES DE CLASE:
VECTORES/ARRAYS: Un ARRAY es un conjunto de variables u OBJETOS es un PUNTERO
a un tipo, los elementos del ARRAY han de ser del mismo
tipo o polimorfico. Un ARRAY se define con un nombre y
un tipo de elementos.
int[] a=new int [5];
| | | puede ser una variable
| | puntero a ese array
| tipo de elementos
Se crearian 5 casillas que se inicializan con el valor 0 igual que todas las
numericas.
En un char el valor de inicializacion es null
Para asignar valor a un ARRAY la primera casilla es la casilla 0.
a[0]=5; Inserta el valor 5 en la casilla 0 del ARRAY a.
int[] a={1,3,8}; Crearia un vector de tres casillas con unos valores
predeterminados
int[] a=new int[3] {1,3,8}; seria igual que el anterior
int x=a[2]; x toma el valor de la casilla 3 del array
ArrayAUTOFBAnds EXception error en ejecucion al sobrepasar el valor de un
array
UN ARRAY BIDIMENSIONAL ES UN ARRAY DE PUNTEROS A ARRAYS
NO ES UNA MATRIZ POR QUE LOS DATOS PUEDEN NO SER DEL MISMO TAMA¥O
TODOS LOS DATOS DE UN ARRAY DEBEN DE SER DEL MISMO TIPO.
m -> ARRAY de punteros
__ ---------------
| |---> | 2 | 4 | 3 | 4 |
-- ---------------
__ -------
| |---> | 1 | 3 |
-- -------
__ -----------
| |---> | 2 | 3 | 5 |
-- -----------
int [][] m={{2,4,3,4},{1,3},{2,3,5}}; Este es el ARRAY BIDIMENSIONAL m

int [][] m=new int[fila][columna]; Esto seria una matriz
int[] x =m[2][]; corjeria el ARRAY m {2,3,5} y se lo pasaria al ARRAY x
Para recorrer un ARRAY se utiliza for
for(int i=0; i<10; i++) a[i]=0; pondria a 0 los valores del array "a".
ARRAYS N DIMENSIONALES.
FUNCIONES/METODOS es donde vamos a realizar nuestro programa
<modificadores> <tipo de devolucion> funcion ( <parametros> )
static void suma (int x, int y)
la funcion mas importante es:

| | | | | |desde aqui se controlan los parametros
| | | | | |de entrada arg[0] seria el primero
| | | | |array de string aqui se recogerian
| | | | |los parametros al ejecutar el programa
| | | |nombre de la funcion
| | |no devuelve nada (tipo de devolucion)
| |modificador
|metodos de acceso (public -> es imprescincible para ejecutar el prog.)

{
int a=5;
int b=3;
int x=suma(a,b) /* llamada a la funcion suma */
} /*pasa el valor de "a" a "x" y
el valor de b a y*/
// la funcion suma devuelve un int, es obligatorio que
// tenga un return en el flujo por el que pasa simpre la ejecucion.
int suma(int x, int y)

{
return x+y;
}
Return devolvera el valor de la funcion.
Los datos se pasan por valor, nunca por referencia.
Si una funcion no queremos que devuelva nada la definiremos como void ej:
static void suma(int x, int y)
static es un modificador
PROGRAMACION ORIENTADA A OBJETOS = REUTILIZAR CODIGO
ENCAPSULACION -> es encapsular datos tipo primitivo.
EJ:
la CLASE es el formulario que es la extructura y cada alumno es la instancia
clase(nombre,edad,..)
dni(numero,nombre.......)
Expediente(dni,datos_bancarios,.....)
HERENCIA
INSTANCIA -> Creacion de un objeto de clase
Principio de Encapsulacion las variables de INSTANCIA deben de ser privadas
el estado lo suministrara el metodo asociado a las variables de instancia
el valor de la variable de instancia es el estado de Instancia
CARACTERISTICAS DE LOS OBJETOS:
COMPORTAMIENTO,ESTADO,IDENTIDAD
Cada formulario tendria un comportamiento
---------------------------------------------------
// Clase Fecha
class Fecha{private int dia;
private int mes;
private int ayo;
/* este es el metodo constructor */
Fecha(int d,int m,int a) /* poner valor a la instancia */
{ /* no devuelve nada */
dia=d;mes=m;ayo=a; /* inicializamos las variables */
}
void imprimir() /* este es el metodo imprimir */
{
System.out.print(dia+"/"+mes+"/"+ayo);
}
}
----------------------------------------------------
class Principal
{
{
int dia=1;
int mes=1;
int ayo=1976;
Fecha f=new Fecha(dia,mes,ayo);
/*Crear una instancia de clase y llamar
al metodo/funcion constructor
el nombre del metodo constructor tiene que
ser igual el nombre la clase todas las
clases tienen un metodo constructor
el compilador crea un metodo o constructor
sin parametros si ve que no hay ninguno.
*/
f.imprimir();
}
}
------------------------------------------------
El metodo constructor sirve para inicializar las variables de instancia o
globales el metodo constructor se tiene que llamar exactamente igual que
la clase si no se define un metodo constructor el genera uno automaticamente.
para invocar a un metodo constructor desde otro programa se hace con" new "
creando una instancia operador
el operador this hace referencia a los objetos de la propia instancia
class A{
private int x;
A(int x){
this.x=x;
}
con el operador this podemos invocar a otro metodo constructor, tiene que
ser la primera sentencia en el ejemplo buscaria la funcion que devolviera
double,double
class A{
private int x;
A(int x){
this(double,double);
}
la sobrecarga son funciones, metodos que tienen el mismo nombre pero
pueden recibir parametros diferentes (OVERLOAD)
class A{
double suma(int,int); /*esta no podria existir pues los valores
son iguales a la siguiente aunque la
variable de recogida sea de otro tipo*/
int suma(int,int);
int suma(double,int);
int suma(double,double);
double suma(double,int);
}
LOS PAQUETES: organizacion y seguridad el nombre de los paquetes siempre
en minusculas, para referirse a un paquete:
package timezone.fechas;
carpetas .class
principal.class
|
------------------
| | | timezone
|
------
|fechas
|
Fecha
import timezone.fechas.Fecha;
import timezone.fechas.*; importaria todas las .class de
la carpeta fechas
METODOS DE ACCESO
clausulas para restringir metodos de acceso:
private -> solo podran acceder a el desde la propia classe

como private podemos tener no se puede poner como private
-------------------------- ------------------------------
clases internas clases
metodos interfaces
variables instancia variables locales
constructores
variables y metodos staticos
public -> desde cualquier lado podremos acceder se puede poner

publico todo menos las variables locales
protected -> solo las clases del mismo paquete y las heredadas
pueden acceder a el pueden estar en otros paquetes
como protected podemos tener no se puede poner como protected
--------------------------- --------------------------------
metodos interfaces
default -> (o no poner ningun identificador) solo las clases del
mismo paquete podran acceder a el.
como default podemos tener no se puede poner como default
--------------------------- --------------------------------
metodos interfaces
constructores
final -> define una constante no se puede modificar su valor.
variable -> final int a=5; haria constante el valor
metodo -> final int pepe(); no podre sobreescribir ese metodo
clase -> final class A no podran heredar de ella
a todos menos a los contructores interfaces y metodos abtractos se les
puede aplicar final
static -> un metodo o una variable static pretenecen a la clase no a la
instancia serian metodos globales
class Empleado
{
static int ContarEmpleados();
cont++;
int pepe(){ a++}
}
se llamara desde: Empleado.ContarEmpeados();
Empleado e=new Empleado()
e.pepe();
un metodo estatico solo puede acceder a variables estaticas o locales
como static podemos tener no se puede poner como static
------------------------- -------------------------------
variables y metodos staticos interfaces
variables locales
-------------------------------------------------------------------------
www.java.sun.com <esta todo pero en ingles>
bajarselo de internet.
j2sdk-1_4_0-linux-i386-rpm.bin
j2sdk-1_4_0-win.exe
j2sdk1.4.2 35Mb -> JAVA Ver 2

j2sdk-1_4_0-doc.zip 30Mb -> APIS (documentacion
j2sdkee-1_3_1-win.exe 17Mb -> J2EE 1.4 Sdk Version empresarial, Gratis
s1s5se-win-en.exe 178Mb -> Sun Java System Application Server, 60 dias
c:\jsdk1_nb\j2sdk1.4.2\doc\ -> Documentacion (APIs)

c:\jsdk1_nb\j2sdk1.4.2\bin\ -> binarios
c:\jsdk1_nb\j2sdk1.4.2\src.zip\ -> las clases empaquetadas
c:\jsdk1_nb\j2sdk1.4.2\jre\ -> maquina virtual
http://www.java.sun.com
Al tener un ejecutor independiente le ofrece una portabilidad mayor
Inicio\Mi Pc\BD\Propiedades\Opciones Avanzadas\Variables de entorno

Modificar
A¥ADIR A
PATH C:\j2sdk1.4.2\bin;c:\javacarlos
CLASSPATH=.;C:\javacarlos;c:\j12e1.3.1\bin\j2ee.jar -> directorio de trabajo.
JAVA_HOME= C:\J2SDK1.4.2 -> directorio netbeans
J2EE_HOME= C:\J12EE1.3.1 -> directorio empresarial
A¥ADIR A PATH C:\j2EE.1.3.1\BIN
Instalar NetBeans IDE 3.51
a la primera pregunta no.
extension fuente -> .java
\javac.exe ->compilador crea el ejecutable .class
bytecodes .class ->lo ejecuta en maquina virtual de java(JVM)
\java.exe ->ejecutor
---------------------------------------------------------------------------
Ejercicio :
la Arraymundo va ha tener dos metodos construtores un Array int
y un array de char
int[]
char[]
int calcularElementoMenor() ;
bolean existeElemento(int) ;
bolean existeElemento(char) ;
int calcularSuma() ;
double media() ;
double palindromo() ; ver si la palabra es capicua
int[] valoresPares() ; devuelva un array con los valores pares
int producto(int[]) ; el producto de todos por todos
int suma([]) ; suma de los dos vectores (el que recibe de
parametro con este.
char[] ; devuelva un array con las letras que hay en
las posiciones impares
a.length -> es una variable que devuelve cuantos elementos tiene un array
--------------------------------------------
En la clase Fecha una funcion o metodo calcular dias desde esa fecha 1/1/1900
4/4/2003
calcularDias
--------------------------------------------
un metodo constructor es invocado con el operador new
un metodo constructor puede ser private
un metodo final no puede ser sobreescrito si sobrecargado si puede ser
estatico
HERENCIA
class Jefe extends Empleado
Todas las clases heredan de la clase Objec y despues del padre.
-------- ---------------
|empleado|-> |nombre|Manuel |
-------- |---------------|
superclase |dni |No Tiene|
base |---------------|
padre |salari| 2000 |
---------------
------ ---------------
|Jefe | -> |nombre|Julian |
------ |---------------|
subclase |dni |3437927w|
derivada |---------------|
hija |salari|2000*2 |
|---------------|
|bonifi| 300 |
---------------
NIVELES JERARQUICOS. FORMAN UN ARBOL Y NO PUEDEN TENER CICLOS,
SOLO PODEMOS HEREDAR DE UN PADRE
LA EXTRUCTURA SE PUEDE HEREDAR PERO NO SE PUEDE
UTILIZAR.
ser_vivo
| |
planta animal
carnivoro
perro
boxer
final class Empleado -> SI LA CLASE ES final NO SE PUEDE HEREDAR,
LA CLASE final OCUPA MENOS ESPACIO
class Empleado{
private String nombre;
private String dni;
Empleado(String nombre,string dni){
this.nombre=nombre;
this.dni=dni;
}
string getnombre(){return nombre}
int salario() { return 2000;}
class Jefe extends Empleado
{
Jefe(String nombre,String Dni)
{
Super(nombre,dni);
}
int salario() {return Super.Salario() * 2;}
int bonificacion() {return 300;}
}
Crear un empleado llamando al metodo constructor, se crea la extructura "e".

Empleado e=new Empleado("Manuel","No Tiene","2000")
Crear un Jefe
Jefe f=new Jefe("Julian","3437927w");
Al llamar a un Jefe la funcion super() invoca al metodo constructor del padre
y crea la extructura "f"
Si la funcion super() no existe se crea automaticamente sin parametros,
dara error si el metodo constructor solo tiene parametros.
primero se a¤aden las caracteristicas del padre y despues las del hijo
si hay que reescribir se reescribe.
OVERRIDE sobreescritura cuando un metodo esta repetido se sobreescribe
el salario del jefe es el doble del empleado;
POLIMORFISMOS: crearia los datos del empleado pero con la difencia del
salario, y no deberia de cargar con el resto de los datos;
Empleado f=new Jefe("pepe","23456675k");
jefe es un empleado pero un empleado no tiene por que ser jefe
CLASES ABSTRACTAS:
Estan compuestas de metodos
Si una clase tiene un metodo Abstracto => la clase es Abstracta
una clase abstracta no tiene por que tener metodos abstractos
los metodos abstractos definen la personalidad del resto de las clases,
y solo se van a definir no se implementara eso lo hara extends.
abstrac class A{ | class B extends A{
abstract void pepe(); | void pepe(){System.out("Hola")
| class B extends A{
} | }
Extructura=Instancia
No se puede crear una instancia de una clase abstracta.
no puede ser final pues tiene que heredar y se debe de poder sobreescribir
Figura
------------
| | |
| | |
| | |
Circulo | Rectangulo
| |
| |
| |
| |
Triangulo cuadrado
-------- |--------------------
|Figura |-> |nombre |rectangulo|
-------- |--------------------
|area | 25 |
|--------------------------------
|esmenor | |
|-------------------------------|
|toString|rectangulo con area 25|
--------------------------------
----------- ---------------
|Rectangulo|-> |ancho | 2 |
----------- ---------------
|largo | 3 |
---------------
-------- ---------------
|Tringulo|-> |base | 4 |
-------- ---------------
|altura | 6 |
---------------
-------- ---------------
|Cuadrado |-> |radio | 5 |
-------- ---------------
-------- ---------------
|Circulo |-> |radio | 5 |
-------- ---------------
-----Figura.java-----
public abstract class Figura{
public Figura(String n){
nombre=n;
}
public abstract double area();
/* public final String toString(){
return nombre+"con area"+area();
}*/
public final boolean esMenor(Figura f){

return area()<f.area();
}
}
----Circulo.java------
public class Circulo extends Figura{
private int radio;
private static final double PI=3.141592;
public Circulo(int r){
super("circulo");
radio=r;
public double area(){
return PI*radio*radio;
}
}
----Area.java-----
return PI*radio*radio;
}
----Rectangulo.java
public class Rectangulo extends Figura{
private double ancho;
private double largo;
public Rectangulo(double l,double a){
super("rectangylou");
ancho=a;
largo=l;
}
return ancho*largo;
}
}
----Cuadrado.java
public class Cuadrado extends Rectangulo{
public Cuadrado(double l){
super(l,l);
}
}
----Principal
/*
* X.java
*
* Created on 9 de diciembre de 2003, 11:08
*/
/**
*
* @author Administrador
*/
public class X {
/** Creates a new instance of X */

public X() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Circulo r=new Circulo(5);
Rectangulo r=new Rectangulo(2,3);
Cuadrado cu=new Cuadrado(5);
boolean b=c.esmenor(cu); /* POLIMORFISMO */
System.out.println("Calculando si es menor: ");
if(c.esMenor(cu)) System.out.print("hola");
else System.out.print("adios");
System.out.println(c.area());
System.out.print(c);
}
}
CARACTERISTICAS
CLASES O METODOS ABSTRACTOS NO PUEDEN SER INSTANCIADAS
METODOS ABSTRACTOS HAN DE SER SOBREESCRITOS EN LAS SUBCLASES
METODOS ABSTRACTOS NO PUEDEN SER private à final.
SOLO METODOS Y CLASES PUEDEN SER ABSTACTOS.
SE PUEDE PONER UNA RESTRICCION MENOR O IGUAL:
Restricciones de menor a mayor=> public>protectec>default>private
OVERRIDE sobreescritura cuando el NOMBRE, LISTA DE PARAMETROS Y TIPO DE
DEVOLUCION COINCIDEN.
SE PUEDE PONER UNA RESTRICCION MENOR O IGUAL:
public>protectec>default>private
INTERFACE. que deben hacer las clases, pero no lo implementamos, simplemente
lo definimos
las clases que implementen este interfaz han de implementar todos
los metodos que ese interface tenga definidos
public interfaz A{>{
public double area();
}
public class B implements A{ public double area() { }
HASTA AHORA TENIAMOS :METODO DE INSTANCIA Y METODO ESTATICO

CON EL INTERFACE TENEMOS METODOS DE UN CONJUNTO DE CLASES
LOS METODOS DEL INTERFACE SON PUBLICOS
LAS VARIABLES SE CONSIDERAN COMO CONSTANTES, PORQUE SON
estaticas,publicas y final
LOS INTERFACES NO SON CLASES, NO PODREMOS IMPLEMENTAR
NO PODREMOS HACER : a=new a();
PERO SI a=new B(); -> POLIMORFISMO
RETROLLAMADAS
EventListener -> ESCUCHADORES receptores de eventos
EventObject -> LLAMADORES fuentes de eventos (source)
Ejercicio: IMAGINANDO QUE NO HAY String
clase cadena
metodo contructor cadena de char
variable de instancia
bolean palidromo() ; ver si la cadena es capicua

m.impleletra en posicion(int)
longitud() ; longitud de la cadena
cadena subcadena(int,int) ; cadena entre cadenas
cadena izquierda(int) ; cadena desde esa posicion hasta el principio
cadena derecha(int) ; cadena desde esa posicion hasta el final
int contarletras() ; cuantas tiene. 0=ninguna
interfac InterfacComparable ; definira el siguiente metodo
int compararA(cadena) ; devuelve 0 si las palabras son iguales
; 1 si va antes en el dicionario
; -1 si va despues en el dicionario
bolean iguales(cadena) true si son iguales
false si son distintos
las varables locales es obligatorio iniciarlas las de instancia no
cadena cad1=new cadena(c1);-> esto es un objeto

int Comparar A(Cadena z){ -> esto es un metodo
if (longitud() <c.longitud())
| |longitud del segundo array
|longitud del array desde el que estamos llamando
if(txt[i]<c.txt[i]) return 1;
APIS -> clases implementadas de java y documentacion
es el .zip que esta en el cd
c:\jsdk1_nb\j2sdk1.4.2\src.zip\ -> las clases empaquetadas
c:\jsdk1_nb\j2sdk1.4.1-doc.zip\ -> la documentacion de las clases
desempaquetarlo aqui:
c:\jsdk1_nb\j2sdk1.4.2\docs
Ejecutar:
c:\jsdk1_nb\j2sdk1.4.2\docs\api\index.html
java.lang.Object
java.lang
String -> es final no puede heredar nadie de aqui
CompareTo <-interfaz
java.lang hereda de java.lang.Object

String a="Hola" -> con esto creamos una constante "a"
String a=new String(o) esto es un objeto que encapsula y aparte se puede
llamar a cualquier metodo ej: CompareTo
char c=a.charAt(o); esto convertiria una primitiva en un objeto = que 2
String a="hola";
String b="Que ";
System.out.print(a+b)
a=a+b = String a=new String(new StringBuffer().append(a).append(b));
StringBuffer Es un buffer que permite trabajar con texto
a=a+b = String a=new String(new StringBuffer
La clase String tiene los siguentes metodos o clases
String() vacio, char, Int
CompareTo(String) ; compara cadenas
endWitsh(String,sufijo) a.endWith("la"); los que acaban en la
a.equals(b); compara el objeto a con el objeto b diferenciando mayusculas con
minusculas
Clase Oject
java.lang.Object es el objeto raiz de esta clase heredan todos metodos
clone() todos los valores se igualaran simepre entre los objetos
int[] a={1,2,3,4}
int[] b=a;
b[o]=5;
int a[]={1,2,3}
int b[]=a.clone(); hace una copia identica
equals lo implementa tambien String con lo cual se sobrescribiria
clase Class para conocer datos de la clase en tiempo de ejecucion
no se usa a no ser para hacer herramientas.
devuelve los metodos, interfaces, valores de la instancia,
metadatos etc.
Class c=f.getClass(); este metodo retornaria la extructura del obeto fecha
Class c=f.getClasses(); este metodo devolvera las clases que dependan de esa
clase
Class c=f.forName("fecha"); este metodo retornaria la informacion del obeto
Class c=Fecha.class; este metodo retornaria la informacion del obeto
fecha
ClassLoader Carga dinamicamente las clases en la maquina virtual
las clases estan en src.jar o de nuestro Classpath
cuando no esten en las clases de arriba habra que especificarlo
con esta orden
Clase Runtime llamada al sistema operativo
metodo exec para obtener un objeto de runtime getRuntime
Runtime r=Runtime.getRuntime();
r.exec("c:\windows\notepad.exe pp.txt")
exit() termina los procesos.

load() carga librerias
Clase System -> para comunicarse con el S.O.

err -> salida de error
in -> entrada estandar
out -> salida estandar
setErr|
setIn |> definir la entrada salida estandar
setOut|
Clase Math ; no tiene metodo constructor

cuando es estatico se llama asi
Math.E
numero E
numero PI
abs(double a)
cos
exp
ceil redondeo hacia abajo
floor redondeo hacia arriba
max(int a, int b)
max(long a, long b) ; estas se sobrescriben
min
random() ; genera numeros aleatorios
round() ; redondeo hacia el que este mas cerca
toDegrees convierte grados
toRadians convierte a radianes
toDegrees convierte grados
toRadians convierte a radianes
------------------------
buscar en internet metodos de java.lang
VARABLE DE CLASE ES IGUAL PERO EN MAYUSCULAS
MANUALES www.programacion.com/java
ejercicios:
hacer subcadena.
hacer programa subcadena
subcadena (1,5) "hola a todos"
izq (5)
der (5)
1/1/1900
CALCULAR 50000 DIAS A PARTIR DE LA FECHA 1/1/1900

devolver_fecha(int dias)
imprimir con el siguiente formato "2/1/2003"
CALCULAR 50000 CALCULAR LA FECHA
timezone
Fecha
Java.lang
Runtime
metodo exec
getiruntime .->
Import java.lang.System;
import java.lang.Runtime;
import java.io.IOException;
public class RuntimeExecApp{
public static void main(String args[]) throws IOException{
Runtime r=Runtime.getRuntime();
r.exec("C:\\Windows\\Explorer.exe");
}
}
a.pp();
metodo estatico de la clase a
A.pp();
Ejercicio para el viernes
ejecutar un cls.
o
WrappedClassApp ->
metodos
ValorValor maximo o maximo de una variable
como pasar un Strin a un int
String a="52";
int x=Integer.parseInt(a)
sobre escritura con dos metodos con el mismo nombre
sobre cargado recibe dos variables de distinto tipo para un mismo metodo
RuntimeMemApp -> memoria disponible total/libre
StringBuffer -> posibilidad de modificar un string
metodo append -> a¤ade un texto a continuacion del que ya tenemos
primero lamaos al metodo constructor
StringBuffer carlos=new StringBuffer("hola");
append("carlos");
Devuelve el valor completo.
System.out.print(carlos.toString();
nos a¤ade automaticamente toString;
System.out.print(carlos);
append() A¤ade texto
Array test
Array de objetos seria comun a todos los tipos
getClass preguntamos a la extructura de la clase( los metadatos)
newInstance(ctype,longitud2);
java.util -> utilidades
libros: extructura de datos y algoritmos en java
: extructura de datos y algoritmos (esta en modula2)
Teoria de EDAL.
problemas de los arrays escabilidad tama¤o, insertar, borrar elementos
extructura de Datos y Algoritmos.
Array de ordenacion
busqueda dicotonica (desde la mitad)
clase Vector()
hace todos los los procesos borrar instert etc...
el tama¤o po defecto son 10 casillas
LISTAS ENLAZADAS =LintedList
es un objeto compuesto de informacion y una referencia(puntero) a cual es el
siguiente elemento
los objetos son modos un conjunto de nodos es una lista enlazada
Class Nodo | Oject informacion; <- INFORMACION
Nodo siguiente; <- punteroO
Nodo A=new Nodo(new Fecha(1,1,76),null);
| |puntero al ser el primero
|Informacion
Nodo B=new Nodo(new Fecha(1,1,76),null);
A -> B -> C
A.siguente=B; -> cambia el puntero de A de null a B.
todo esto lo hace automaticamente, esta encapsulado.
ELIMINAMOS B A -> C -> SE BORRARIA CO EL RECOLECTOR DE BASURA.
la emliminacion
A.siguiente=C;
LISTAS DOBLEMENTE ENLAZADAS Linkedlist
-> ->
NULL <- A B C ->NULL
<- <-
Limkedlist le=new linkedlist()
le.add(new "Empleado
Nodo A=new Nodo(new Fecha(1,1,76),null);
| |puntero al nodo anterior
| |puntero al nodo siguiente
|ojeto Informacion
LISTAS DOBLEMNENTE ENLAZADAS O CIRCULARES.

LISTAS SIMPLEMENTE ENLAZADAS CIRCULARES.
v----<----------<
|-> A -> B C->|
PILAS. PRIMERO EN ENTRAR ULTIMO EN SALIR FILO
ULTIMO EN ENTRAR PRIMERO EN SALIR LIFO
COLA. PRIMERO EN ENTRAR PRIMERO EN SALIR FIFO
ULTIMO EN ENTRAR ULTIMO EN SALIR LILO
Queue = Cola
Stack = Pila
SE SUELEN IMPLEMENTAR CON LISTAS SIMPLEMENTE ENLAZADAS CIRCULARES
METODOS DE LA PILA
pop() SACAR UN ELEMENTO Y LO BORRA
push() INSERTAR UN ELEMENTO A LA PILA O LA COLA
peek() SACAR ELEMENTOS
ARBOL -> no tenga ciclos

tiene que estar balanceado (algoritmos clase para rebalancear:
treeMap-> puede repetir elementos
Tree Set, no puede repetir elementos
4
/ \
/ \
3 8
/ / \
1 7 9
\
11
\
13 mal balanceado mas de un nivel caeriamos en una
lista enlazada
| |puntero al nodo izquierda

| |puntero al nodo derecha
| |objeto Informacion
la derecha estan los mayores a la izquierda los menores
el peor caso de un arbol es una lista enlazada
|Arays
colletion - enumeration|Listas Enlazadas
|Arboles
|Hast
Java.util ademas tiene date, gregorian.Calendar,
event Lister interfade e informacion (pulsar un boton)
event Object
conetctio,list, set => Interfaces
Resto =>clases
| Arrylist -> evolucion de la clase vector no sincronizado

| list | linkedlist -> listas enlazadas
| | vector -> vector -> Stack
colletion |
|
| | HastSet -> Devuelven la posicion de memoria
| set |
|no rep |
eticion| Sorted -> TreeSett
introducir
elementos
| HashMap
| Hashtable -> Reportes
map | weakhastmap
| SortedMap -> tree
Empleado[] Colon=new Empleado[8]; -> vectores no usar a no ser cosas peque¤as
con pocos elementos a partir de ahora
usaremos Arraylist.
Araylist array=new Arraylist();
array.add(new Empleado("Carlos"); -> a¤adir un objeto
array.add(new fecha(1,1,76); -> a¤adir un objeto
array.add(new Integer(5)); -> Arraylist no puede trabajar con datos
primitivos con lo que tendremos que
encapsularlo con: Integer();
array.remove(new Empleado("Carlos"); -> borra "carlossNa¤adir un objeto
¨ALGORITMOS? intentar hacerlos Ejercicio.
CLASIFICACION POR INSERCION DIRECTA (no usar)
1- tomar un elemento en la posicion i
2- buscar su lugar en las posiciones anteriores (comparando)
3- mover hacia la derecha los restantes
4- insertar
ordenar
---------
|9|7|2|5|3|
---------
---------
|7|9|2|5|3|
---------
---------
|2|7|9|5|3|
---------
---------
|2|5|7|9|3|
---------
---------
|2|3|5|7|9|
---------
for(i=1;length
SELECCION DIRECTA
1- selecionar el elemento menor de la parte no ordenada
2- colocarlo en la primera posicion de la parte no ordenada
seleccion
---------
|9|1|2|5|3|
---------
---------
|1|9|2|5|3|
---------
---------
|1|3|9|2|5|
---------
---------
|1|2|3|9|5|
---------
for(i=0; length-1
CLASIFICACION POR INTERCAMBIO DIRECTO (BULBUJA)
1- comparar pares de elmento contiguos

2- intercambiarlos si estan desordenados
---------
|9|1|2|5|3|
---------
---------
|1|9|2|5|3|
---------
---------
|1|2|9|5|3|
---------
---------
|1|2|5|9|3|
---------
---------
|1|2|5|3|9|
---------
---------
|1|2|3|5|9|
---------
Quicksort
1- coger elemento de la mitad (pivote)
2- intercambios de manera que a laizquierda esten los menores y a la dereha los
mayores
2- elijo el pivote de la mitad izquierda y comparo el de la izquierda y el de la
derecha
3- elijo el pivote de la mitad derecha y comparo el de la izquierda y el de la
algoritmo:
int a[]={ }
maint (quiqSort(0,a.length);
void quickSort(Int L int R){
int i=L; j=R;
int piv=a[[(L+R)/2];
do while(a[i]<piv) i++;
while(piv<a[j]) 1--;
if(i <=j) {aux=a[i]=a[j]; a[j]=aux; i++;j--}
}while (i<=j)
if(L<j) quikSort(L,j);
if(i<R) quikSort(i,R);
RECURSIVO->
---------
|9|1|2|5|3|
---------
---------
|1|9|2|5|3|
---------
---------
|1|9|2|3|5|
---------
---------
|1|3|2|9|3|
---------
---------
|1|9|2|5|3|
---------
---------
|1|9|2|5|3|
---------
---------
|1|9|2|5|3|
---------
AWT
java.awt
Es un conjunto de clases para poder crear ventanas, interfac grafico
clases
Component -> componentes, ventana,boton,frame
subclases
heredan de <-
button <- boton
Canvas <- Lienzo
component <- Checkbox <- validacion [v] Checkbox group..
Choice <- despliegue para selecionar solo una (combo)
List <- Multiseleccion
Label <- contenedor de texto
Scrollbar<- barras de desplazamiento (ascensor)
| <- TextArea
TextComponent <-|
| <- TextField
| <- panel <- Applet
Container <-|
| <- window<- Frame
| TextArea varias lineas(wordpad)

TextComponent<-|
| TextField (solo una linea, ej: busqueda google)
Container: componente que puede alvergar mas componentes
| panel divisiones de un container <- Applet se ejecutan en el

| cliente(es un contenedor
| dentro de una pagina web
container<-|
| window region de cliente de una ventana <- Frame<-Holaventana
Frame hereda de window
import java.awt.* ; importa las ventanas
import java.awt.event.*; manejadores de interfaces y eventos
extends hereda de Frame.

super("hola ventana") llamamos al metodo padre Frame y pone hola vetana en el
en la barra de titulo.
setBounds(x,i,ancho,largo); tama¤o
setVisible(true); visible
para que el aspa funcione se tiene que producir un evento.
necesita un interface
addWindowListener(new Cierre()); Se va ha producir un evento add a¤ade
la clase que va a manejar sera cierre()
esta clase tiene que implementar el interface
cobreescribimos la clase WindowAdapter
para qu implemente todos los metodos
sobreescribiendolos
WindowAdapter implements Windowslistener

class Cierr extends WindowAdapter{
public void windowsClosing(windowEvent e)
{
system.exit(0); /* cierra la ventana */
}
qsos para crear una ventana
1. importar librerias
2. clase extends Frame
3. en el main crear objeto de la propia clase
4. crear y definir los componentes
5. a¤adir los componentes a sus containers
6. indicar los eventos sobre los componentes
7. posicion tama¤o y visibilidad del Frame
rear un boton los componentes se suelen deficnir como globales.

clase button
Button b=new Button("Hola mundo!); /* crea un boton
add(b); a¤ade a mi ventana frame el boton b que ocuparia toda la ventana
TextField t=new TextField(" "); /* crea una linea de texto
setLayout(new FlowLayout()); /* disponer los controles uno al dado del otro
palntillas
setLayoutborder
flow
card
add____listener -> se va a producir un evento sobre u
b.addActionListener(new ButtonHandler());
class BH implements ActionListener{ /* que vamos ha hacer con el teboton
P
public void actionPerformed(ActionEvent e){
t.setText("hola");
}
}
Ejercicio.
hacer 3 ventanas
getActionCommand() devuelve el te texto del boton
getSource() devuelve el objeto(el boton)
getlabel() devuelve el texto del boton estas dos equivalen a la primera
en windowAdapter se implementan todos los eventos y asi solo tenemos
que sobreescribirlos sinimplementarlos.
gettext.
valor
formulario
guardarlo en Arraylist
mostrar
en vez de fecha de nacimiento que salga la edad
/out
hacer una lista (list)
hacer una lista desplegable (choice)
en java.awt
tres checkbox
tres checkboxgroup
Panel : es un container, solo tiene un metodo constructor panel();
Scrollbar() barras de desplazamiento
bubble -> burbuja ascensor
orientacion -> direccion horizontal, vertical
value -> numero de casilla donde quiero que aparezca el bubble.
visible -> visible o no visilble
minimun ->
los eventos son: add.......Listener
en este caso es: addAdjustmentListener
existe public Static void main

pues lo ejecutara el navegador
public void init(); SERA COMO NUESTRO main. es obligatorio
public void start(); invocado despues de ejecutar init o al recargar la pagina
public void stop();
public void destroy(); cuando cierre el navegador
Panel() hereda de:
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--java.awt.Panel
Hijo=Subclase-> Applet
para insertar dentro de un documento HTML se hara con la etiqueta
<applet> </applet>
Atributos
code="Miapplet.class" -> nombre dele programa.class
height=100 -> largo
width=200 -> ancho
javax.Swing heredan de java.awt

javax.swing
Class JTable
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--javax.swing.JComponent
|
+--javax.swing.JTable
todos los metodos empiezan por J
JButton -> boton normal
JToggleButton -> boton que se queda pulsado y al darle de se queda desactivado
JTable
JTablePanel -> pesta¤itas
JProgressBar
Slider
JList -> podremos meter iconos
Imagecon -> crea imagr nese
Flowlayout
Border -> norte...
Card
Grid
GridBag
Ejercicio:
Jtoolbar
al pulsar que aparezca mi nombre
Escribir
Salir
JSlider
Jtoogle
-------------------------------------------------------+
|swings |
-------------------------------------------------------+
|Escribir | Salir | |
|------------------------------------------------------+
| |
| -------------- -------- |
| | mi nombre |Toggle |
| -------------- -------- |
|
| |---------V------|
| 0 100
Layouts
Flow -> uno al lado del otro
Border -> norte,sur,este,oeste
Card ->libro
Grid -> cuadricula
GridBag -> Cuadricula que cada elemento coge el tama¤o que necesita
SetBounds()
null Setsize
setLocation
==============================================================================
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class Layouts extends Applet {
//array de paneles
Panel[] panels;
//Panel visualizado, guardamos
Panel currentPanel;
//damos nombre a los paneles
static int border=0;
static int card=1;
static int flow=2;
static int grid=3;
static int gridBag=4;
//arry de string (layouts) textos, para cargarlos con un for
String[] layouts = {"Border","Card","Flow","Grid","GridBag"};
//arry de string (cards) textos
String[] cards = {"First","Last","Next","Previous"};
// array de botones (layoutButtons y navigateButtons)
Button[] layoutButtons = new Button[layouts.length];
Button[] navigateButtons = new Button[cards.length];
Panel layoutButtonPanel = new Panel();
Panel navigateButtonPanel = new Panel();
public static void main(String [] arg){
Layouts l =new Layouts();
}
public void init(){
setLayout(new BorderLayout());
//cargar los botones(setButtons
setupButtons();
//a¤ade al norte
add("North",layoutButtonPanel);
//cargamos los paneles
setupDisplayPanels();
}
void setupButtons() {
for(int i=0;i<layouts.length;++i) {
// a¤adimos el texto a los botones y el texto
layoutButtons[i] = new Button(layouts[i]);
// a¤adimos el manejador de los eventos
layoutButtons[i].addActionListener(new ButtonHandler());
layoutButtonPanel.add(layoutButtons[i]);
}
for(int i=0;i<cards.length;++i) {
// a¤adimos el texto a los botones y el texto
navigateButtons[i] = new Button(cards[i]);
navigateButtons[i].addActionListener(new ButtonHandler());
navigateButtonPanel.add(navigateButtons[i]);
}
}
void setupDisplayPanels() {
panels = new Panel[5];
for(int i=0;i<5;++i) panels[i]=new Panel();
//ponemos los paneles con
panels[border].setLayout(new BorderLayout());
panels[card].setLayout(new CardLayout());
panels[flow].setLayout(new FlowLayout());
//dos filas tres columnas
panels[grid].setLayout(new GridLayout(2,3));
GridBagLayout gridBagLayout = new GridBagLayout();
panels[gridBag].setLayout(gridBagLayout);
panels[border].add("North",new Button("North"));
panels[border].add("South",new Button("South"));
panels[border].add("East",new Button("East"));
panels[border].add("West",new Button("West"));
panels[border].add("Center",new Button("Center"));
String cardButtons[] = {"First","Second","Third","Fourth","Last"};
String flowButtons[] = {"One","Two","Three","Four","Five"};
String gridButtons[] = {"(0,0)","(1,0)","(2,0)","(0,1)","(1,1)","(2,1)"};
// a¤ade el texto y los botones
for(int i=0;i<cardButtons.length;++i)
panels[card].add("next card",new Button(cardButtons[i]));
for(int i=0;i<flowButtons.length;++i)
panels[flow].add(new Button(flowButtons[i]));
for(int i=0;i<gridButtons.length;++i)
panels[grid].add(new Button(gridButtons[i]));
Button gridBagButtons[] = new Button[9];
for(int i=0;i<9;++i) gridBagButtons[i] = new Button("Button"+i);
// principio de la cuadricula (x,y)
int gridx[] = {0,1,2,0,2,0,1,1,0};
int gridy[] = {0,0,0,1,1,2,2,3,4};
//final de la cuadricula (x,y)
int gridwidth[] = {1,1,1,2,1,1,1,2,3};
int gridheight[] = {1,1,1,1,2,2,1,1,1};
GridBagConstraints gridBagConstraints[] = new GridBagConstraints[9];
for(int i=0;i<9;++i) {
//con la clase GridBagConstraints como podemos poner los controles
gridBagConstraints[i] = new GridBagConstraints();
gridBagConstraints[i].fill=GridBagConstraints.BOTH;
gridBagConstraints[i].gridx=gridx[i];
gridBagConstraints[i].gridy=gridy[i];
gridBagConstraints[i].gridwidth=gridwidth[i];
gridBagConstraints[i].gridheight=gridheight[i];
gridBagLayout.setConstraints(gridBagButtons[i],gridBagConstraints[i]);
panels[gridBag].add(gridBagButtons[i]);
}
//a¤ade el panel en el centro
add("Center",panels[border]);
//este
currentPanel=panels[border];
}
void switchPanels(Panel newPanel,boolean setNavigateButtons) {
//quitar el cuadro
remove(currentPanel);
currentPanel=newPanel;
// a¤ade el nuevo
add("Center",currentPanel);
//borra la parte de abajo
remove(navigateButtonPanel);
if(setNavigateButtons) add("South",navigateButtonPanel);
//refrescando paneles
validate();
}
// cuando hacen click en uno de los botones
class ButtonHandler implements ActionListener {
public void actionPerformed(ActionEvent ev){
String s=ev.getActionCommand();
// pasamos el panel y le decimos si queremos poner la parte de abajo ver (true)
if(s.equals("Border")) switchPanels(panels[border],false);
else if(s.equals("Card")) switchPanels(panels[card],true);
else if(s.equals("Flow")) switchPanels(panels[flow],false);
else if(s.equals("Grid")) switchPanels(panels[grid],false);
else if(s.equals("GridBag")) switchPanels(panels[gridBag],false);
else if(s.equals("First")){
CardLayout currentLayout=(CardLayout)currentPanel.getLayout();
currentLayout.first(currentPanel);
}else if(s.equals("Last")){
currentLayout.last(currentPanel);
}else if(s.equals("Next")){
currentLayout.next(currentPanel);
}else if(s.equals("Previous")){
currentLayout.previous(currentPanel);
}
}
}
}
los Menus
MenuItem -> lo que se despiega del menu
Menu -> esta compuesto de MenuItems
MenuBar-> la barra de menus
evento action listrener
MenuItem mbln= new MenuItem("Block de Notas");
MenuItem mcal= new MenuItem("Calculadora ");
MenuItem msal= new MenuItem("Salir");
menu mavbrir=new Menu ("Abrir");
menubar mb=new menuBar()
mAbrir.add(macalc);
mAbrir.add(nbln);
mArchivo.add(mAbrir);
mArchivo.add(msalir);
mb.add(mArchivo);
set MenuBar(mb);
hacer un programa menu bar que abra blok de notas y calculadora.
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
============== buscar Apis en espalon en Internet ===========================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
==============================================================================
Definimos una clase, como una coleccion o conjunto de objetos que comparten
caracteristicas comunes entre si.
Tanto una clase, asi como un objeto derivado de la misma, contienen tres
aspectos importantes que nos permiten hacer clasificaciones con ellos, dichos
aspectos son:
Ambos tienen propiedades, es decir tienen un conjunto de caracteristicas
propias que permiten individualizarlos entre si, caracteristicas tan
genericos como son la forma, el color, el tama¤o, etc. o caracteristicas,
propiedades o atributos mas particulares como , nombre, edad, etc.
Por ejemplo la clase gatos tienen como propiedades o atributos, nombre,
edad, color, peso, estatura, etc.
La clase FRAME tiene como propiedades , el tama¤o, el background, etc.
El segundo aspecto de las clases o sus objetos derivados, son las conductas,
comportamientos o mas apropiado los llamados metodos.
Los metodos son las conductas propias del objeto que se trate, es decir
mientras las propiedades reflejan el "SER" del objeto, los metodos nos
indican el "HACER" del objeto.
Por ejemplo los metodos del objeto o clase gatos, son dormir(), maullar(),
comer(), etc.
Por ejemplo los metodos de una buena ventana son, abrirse(), cerrarse(),
maximizarse(), minimizarse() etc.
El tercer aspecto de una clase u objeto, son los eventos, es decir la
capacidad que tienen de relacionarse con otros objetos derivados de la
misma clase o de otras clases.
Es decir los objetos no existen, ni mucho menos se programan en solitario,
es decir de que sirve un programa que nada mas tenga una ventana y nada
mas, o un alumno sin maestro.
Esta relacion produce un evento cuando los dos objetos entran en contacto
entre si, es decir una relacion de momento la podemos definir como una
frase que contenga los dos objetos y un verbo que los une, de esta manera
tendremos eventos o relaciones como los siguientes.
R1.- el alumno saluda al maestro.
R2.- un gato detecta un raton
R3.- la ventana detecta un click del raton
En todos los casos, en el momento del evento o relacion, ambos objetos,
disparan una serie de metodos propios y no necesariamente en el mismo
orden.
Por ejemplo en el evento "el gato detecta el perro", el gato activa sus
metodos, bufar(), esponjar(), correr(), saltar(), etc, mientras que el
perro activa sus metodos ladrar(), correr(), etc.
Es tarea comun de un programador,es proveer de mecanismos de activacion de
metodos, cuando el sistema operativo, informa que se ha realizado un evento,
entre dos objetos del programa.
Dentro de un programa, lo mas comun es derivar un objeto de una clase ya
predeterminada o porpocionada muy amablemente por los fabricantes de
compiladores, por ejemplo cuando se crearon applets o servlets, se estuvieron
realmente creando objetos derivados de las clases Applet o de la clase
HttpServlet, es decir prog1 o prog5 , etc son realmente objetos derivados de
esas clases.
Tambien cuando se realizaron programas visuales, las clases Frame, TextField,
Panel, etc, dieron origen a muchos objetos.
Es tambien tarea comun en programacion derivar un objeto de alguna clase y
agregarle nuevos metodos o propiedades, para darle mayor funcionalidad al nuevo
objeto, no nada mas usar los metodos o propiedades que el fabricante de
compiladores tuvo la gentileza de darle, como se ha estado haciendo en todos
los programas realizados hasta la fecha.
HERENCIA
========
La Herencia es el mecanismo por el que se crean nuevos objetos definidos en
terminos de objetos ya existentes. Por ejemplo, si se tiene la clase Ave, se
puede crear la subclase Pato, que es una especializacion de Ave.
class Pato extends Ave {
int numero_de_patas;
}
La palabra clave extends se usa para generar una subclase (especializacion) de
un objeto. Una Pato es una subclase de Ave. Cualquier cosa que contenga la
definicion de Ave sera copiada a la clase Pato, ademas, en Pato se pueden
definir sus propios metodos y variables de instancia. Se dice que Pato deriva
o hereda de Ave.
Ademas, se pueden sustituir los metodos proporcionados por la clase base.
Utilizando nuestro anterior ejemplo de MiClase, aqui hay un ejemplo de una
clase derivada sustituyendo a la funcion Suma_a_i():
import MiClase;
public class MiNuevaClase extends MiClase {
public void Suma_a_i( int j ) {
i = i + ( j/2 );
}
}
Ahora cuando se crea una instancia de MiNuevaClase, el valor de i tambien se
inicializa a 10, pero la llamada al metodo Suma_a_i() produce un resultado
diferente:
MiNuevaClase mnc;
mnc = new MiNuevaClase();
mnc.Suma_a_i( 10 );
En Java no se puede hacer herencia multiple. Por ejemplo, de la clase aparato
con motor y de la clase animal no se puede derivar nada, sera como obtener el
objeto toro mecanico a partir de una maquina motorizada (aparato con motor) y
un toro (aminal). En realidad, lo que se pretende es copiar los metodos, es
decir, pasar la funcionalidad del toro de verdad al toro mecanico, con lo cual
no seria necesaria la herencia multiple sino simplemente la comparticion de
funcionalidad que se encuentra implementada en Java a traves de interfaces.
ALCANCE DE OBJETOS Y RECICLADO DE MEMORIA

=========================================
Los objetos tienen un tiempo de vida y consumen recursos durante el mismo.
Cuando un objeto no se va a utilizar mas, deberia liberar el espacio que
ocupaba en la memoria de forma que las aplicaciones no la agoten (especialmente
las grandes).
En Java, la recoleccion y liberacion de memoria es responsabilidad de un
thread llamado automatic garbage collector (recolector automatico de basura).
Este thread monitoriza el alcance de los objetos y marca los objetos que se
han salido de alcance. Veamos un ejemplo:
String s; // no se ha asignado todavia
s = new String( "abc" ); // memoria asignada
s = "def"; // se ha asignado nueva memoria
// (nuevo objeto)
Mas adelante veremos en detalle la clase String, pero una breve descripcion de
lo que hace esto es; crear un objeto String y rellenarlo con los caracteres
"abc" y crear otro (nuevo) String y colocarle los caracteres "def".
En esencia se crean dos objetos:
Objeto String "abc"
Objeto String "def"
Al final de la tercera sentencia, el primer objeto creado de nombre s que
contiene "abc" se ha salido de alcance. No hay forma de acceder a el. Ahora se
tiene un nuevo objeto llamado s y contiene "def". Es marcado y eliminado en
la siguiente iteracion del thread reciclador de memoria.
CONTROL DE ACCESO
=================
Cuando se crea una nueva clase en Java, se puede especificar el nivel de acceso
que se quiere para las variables de instancia y los metodos definidos en la
clase:
public
======
public void CualquieraPuedeAcceder(){}
Cualquier clase desde cualquier lugar puede acceder a las variables y metodos
de instacia publicos.
protected
=========
protected void SoloSubClases(){}
Solo las subclases de la clase y nadie mas puede acceder a las variables y
metodos de instancia protegidos.
private
=======
private String NumeroDelCarnetDeIdentidad;
Las variables y metodos de instancia privados solo pueden ser accedidos desde
dentro de la clase. No son accesibles desde las subclases.
friendly (sin declaracion especifica)
void MetodoDeMiPaquete(){}
Por defecto, si no se especifica el control de acceso, las variables y metodos
de instancia se declaran friendly (amigas), lo que significa que son accesibles
por todos los objetos dentro del mismo paquete, pero no por los externos al
paquete. Es lo mismo que protected.
Los metodos protegidos (protected) pueden ser vistos por las clases derivadas,
como en C++, y tambien, en Java, por los paquetes (packages). Todas las clases
de un paquete pueden ver los metodos protegidos de ese paquete. Para evitarlo,
se deben declarar como private protected, lo que hace que ya funcione como en
C++ en donde solo se puede acceder a las variables y metodos protegidos de las
clases derivadas.
VARIABLES Y METODOS ESTATICOS

=============================
En un momento determinado se puede querer crear una clase en la que el valor de
una variable de instancia sea el mismo (y de hecho sea la misma variable) para
todos los objetos instanciados a partir de esa clase. Es decir, que exista una
unica copia de la variable de instancia. Se usara para ello la palabra clave
static.
class Documento extends Pagina {
static int version = 10;
}
El valor de la variable version sera el mismo para cualquier objeto instanciado
de la clase Documento. Siempre que un objeto instanciado de Documento cambie la
variable version, esta cambiara para todos los objetos.
De la misma forma se puede declarar un metodo como estatico, lo que evita que
el metodo pueda acceder a las variables de instancia no estaticas:
class Documento extends Pagina {
static int version = 10;
int numero_de_capitulos;
static void annade_un_capitulo() {
numero_de_capitulos++; // esto no funciona
}
static void modifica_version( int i ) {
version++; // esto si funciona
}
}
La modificacion de la variable numero_de_capitulos no funciona porque se esta
violando una de las reglas de acceso al intentar acceder desde un metodo
estatico a una variable no estatica.
Todas las clases que se derivan, cuando se declaran estaticas, comparten la
misma pagina de variables; es decir, todos los objetos que se generen comparten
la misma zona de memoria. Las funciones estaticas se usan para acceder
solamente a variables estaticas.
class UnaClase {
int var;
UnaClase()
{
var = 5;
}
UnaFuncion()
{
var += 5;
}
}
En el codigo anterior, si se llama a la funcion UnaFuncion a traves de un
puntero a funcion, no se podra acceder a var, porque al utilizar un puntero
a funcion no se pasa implicitamente el puntero al propio objeto (this).
Sin embargo, si se podria acceder a var si fuese estatica, porque siempre
estara en la misma posicion de memoria para todos los objetos que se creasen
de UnaClase.
this Y super
Al acceder a variables de instancia de una clase, la palabra clave this hace
referencia a los miembros de la propia clase. Volviendo al ejemplo de MiClase,
se puede a¤adir otro constructor de la forma siguiente:
public class MiClase {

int i;
public MiClase() {
i = 10;
}
// Este constructor establece el valor de i
public MiClase( int valor ) {
this.i = valor; // i = valor
}
i = i + j;
}
}
Aqui this.i se refiere al entero i en la clase MiClase.
Si se necesita llamar al metodo padre dentro de una clase que ha reemplazado

ese metodo, se puede hacer referencia al metodo padre con la palabra clave
super:
import MiClase;
public class MiNuevaClase extends MiClase {
i = i + ( j/2 );
super.Suma_a_i( j );
}
}
En el siguiente codigo, el constructor establecer el valor de i a 10, despues
lo cambiara a 15 y finalmente el metodo Suma_a_i() de la clase padre (MiClase)
lo dejara en 25:
MiNuevaClase mnc;
mnc = new MiNuevaClase();
mnc.Suma_a_i( 10 );
CLASES ABSTRACTAS
=================
Una de las caracteristicas mas utiles de cualquier lenguaje orientado a objetos
es la posibilidad de declarar clases que definen como se utiliza solamente, sin
tener que implementar metodos. Esto es muy util cuando la implementacion es
especifica para cada usuario, pero todos los usuarios tienen que utilizar los
mismos metodos. Un ejemplo de clase abstracta en Java es la clase Graphics:
public abstract class Graphics {
public abstract void drawLine( int x1,int y1,int x2,
int y2 );
public abstract void drawOval( int x,int y,int width,
int height );
public abstract void drawArc( int x,int y,int width,
int height,int startAngle,int arcAngle );
. . .
}
Los metodos se declaran en la clase Graphics, pero el codigo que ejecutara el
metodo esta en algun otro sitio:
public class MiClase extends Graphics {
public void drawLine( int x1,int y1,int x2,int y2 ) {
<codigo para pintar lineas -especifico de
la arquitectura->
}
}
Cuando una clase contiene un metodo abstracto tiene que declararse abstracta.
No obstante, no todos los metodos de una clase abstracta tienen que ser
abstractos. Las clases abstractas no pueden tener metodos privados (no se
podrian implementar) ni tampoco estaticos. Una clase abstracta tiene que
derivarse obligatoriamente, no se puede hacer un new de una clase abstracta.
Una clase abstracta en Java es lo mismo que en C++ virtual func() = 0; lo que
obliga a que al derivar de la clase haya que implementar forzosamente los
metodos de esa clase abstracta.
INTERFACES
==========
Los metodos abstractos son utiles cuando se quiere que cada implementacion de
la clase parezca y funcione igual, pero necesita que se cree una nueva clase
para utilizar los metodos abstractos.
Los interfaces proporcionan un mecanismo para abstraer los metodos a un nivel
superior.
Un interface contiene una coleccion de metodos que se implementan en otro
lugar. Los metodos de una clase son public, static y final.
La principal diferencia entre interface y abstract es que un interface
proporciona un mecanismo de encapsulacion de los protocolos de los metodos sin
forzar al usuario a utilizar la herencia.
Por ejemplo:
public interface VideoClip {
// comienza la reproduccion del video
void play();
// reproduce el clip en un bucle
void bucle();
// detiene la reproduccion
void stop();
}
Las clases que quieran utilizar el interface VideoClip utilizaran la palabra
implements y proporcionarán el codigo necesario para implementar los metodos
que se han definido para el interface:
class MiClase implements VideoClip {
void play() {
<codigo>
}
void bucle() {
<codigo>
}
void stop() {
<codigo>
}
Al utilizar implements para el interface es como si se hiciese una accion de
copiar-y-pegar del codigo del interface, con lo cual no se hereda nada,
solamente se pueden usar los metodos.
La ventaja principal del uso de interfaces es que una clase interface puede
ser implementada por cualquier numero de clases, permitiendo a cada clase
compartir el interfaz de programacion sin tener que ser consciente de la
implementacion que hagan las otras clases que implementen el interface.
class MiOtraClase implements VideoClip {
void play() {
<codigo nuevo>
}
void bucle() {
<codigo nuevo>
}
void stop() {
<codigo nuevo>
}
METODOS NATIVOS
===============
Java proporciona un mecanismo para la llamada a funciones C y C++ desde nuestro
codigo fuente Java. Para definir métodos como funciones C o C++ se utiliza la
palabra clave native.
public class Fecha {
int ahora;
public Fecha() {
ahora = time();
}
private native int time();
static {
System.loadLibrary( "time" );
}
}
Una vez escrito el codigo Java, se necesitan ejecutar los pasos siguientes
para poder integrar el codigo C o C++:
Utilizar javah para crear un fichero de cabecera (.h)
Utilizar javah para crear un fichero de stubs, es decir, que contiene la
declaracion de las funciones
Escribir el codigo del metodo nativo en C o C++, es decir, rellenar el codigo
de la funcion, completando el trabajo de javah al crear el fichero de stubs
Compilar el fichero de stubs y el fichero .c en una libreria de carga dinamica
(DLL en Windows '95 o libXX.so en Unix)
Ejecutar la aplicacion con el appletviewer
Mas adelante trataremos en profundidad los metodos nativos, porque a¤aden una
gran potencia a Java, al permitirle integrar a traves de libreria dinamica
cualquier algoritmo desarrollado en C o C++, lo cual, entre otras cosas, se
utiliza como metodo de proteccion contra la descompilacion completa del codigo
Java.
PAQUETES
========
La palabra clave package permite agrupar clases e interfaces. Los nombres de los
paquetes son palabras separadas por puntos y se almacenan en directorios que
coinciden con esos nombres.
Por ejemplo, los ficheros siguientes, que contienen codigo fuente Java:
Applet.java, AppletContext.java, AppletStub.java, AudioClip.java
contienen en su codigo la linea:
package java.applet;
Y las clases que se obtienen de la compilacion de los ficheros anteriores, se
encuentran con el nombre nombre_de_clase.class, en el directorio:
java/applet
Import
Los paquetes de clases se cargan con la palabra clave import, especificando el
nombre del paquete como ruta y nombre de clase (es lo mismo que #include de
C/C++). Se pueden cargar varias clases utilizando un asterisco.
import java.Date;
import java.awt.*;
Si un fichero fuente Java no contiene ningún package, se coloca en el paquete por

defecto sin nombre. Es decir, en el mismo directorio que el fichero fuente, y la
clase puede ser cargada con la sentencia import:
import MiClase;
Paquetes de Java
El lenguaje Java proporciona una serie de paquetes que incluyen ventanas,
utilidades, un sistema de entrada/salida general, herramientas y comunicaciones.
En la version actual del JDK, los paquetes Java que se incluyen son:
java.applet
Este paquete contiene clases dise¤adas para usar con applets. Hay una clase
Applet y tres interfaces: AppletContext, AppletStub y AudioClip.
java.awt
El paquete Abstract Windowing Toolkit (awt) contiene clases para generar widgets
y componentes GUI (Interfaz Gráfico de Usuario). Incluye las clases Button,
Checkbox, Choice, Component, Graphics, Menu, Panel, TextArea y TextField.
java.io
El paquete de entrada/salida contiene las clases de acceso a ficheros:

FileInputStream y FileOutputStream.
java.lang
Este paquete incluye las clases del lenguaje Java propiamente dicho:
Object, Thread, Exception, System, Integer, Float, Math, String, etc.
java.net
Este paquete da soporte a las conexiones del protocolo TCP/IP y, ademas,

incluye las clases Socket, URL y URLConnection.
java.util
Este paquete es una miscelanea de clases utiles para muchas cosas en

programacion. Se incluyen, entre otras, Date (fecha), Dictionary (diccionario)
Random (numeros aleatorios) y Stack (pila FIFO).
CLASES
======
Las clases son lo más simple de Java. Todo en Java forma parte de una clase, es un
a clase o describe como funciona una clase. El conocimiento de las clases es fun
damental para poder entender los programas Java.
Todas las acciones de los programas Java se colocan dentro del bloque de una
clase o un objeto. Todos los métodos se definen dentro del bloque de la clase,
Java no soporta funciones o variables globales. Esto puede despistar a los
programadores de C++, que pueden definir metodos fuera del bloque de la clase,
pero esta posibilidad es más un intento de no separarse mucho y ser compatible
con C, que un buen dise¤o orientado a objetos. Asi pues, el esqueleto de
cualquier aplicacion Java se basa en la definicion de una clase.
Todos los datos basicos, como los enteros, se deben declarar en las clases
antes de hacer uso de ellos. En C la unidad fundamental son los ficheros con
codigo fuente, en Java son las clases. De hecho son pocas las sentencias que se
pueden colocar fuera del bloque de una clase. La palabra clave import
(equivalente al #include) puede colocarse al principio de un fichero, fuera del
bloque de la clase. Sin embargo, el compilador reemplazará esa sentencia con el co
ntenido del fichero que se indique, que consistira, como es de suponer, en
mas clases.
Tipos de Clases
===============
Hasta ahora solo se ha utilizado la palabra clave public para calificar el
nombre de las clases que hemos visto, pero hay tres modificadores mas. Los
tipos de clases que podemos definir son:
abstract
Una clase abstract tiene al menos un metodo abstracto. Una clase abstracta
no se instancia, sino que se utiliza como clase base para la herencia.
final
Una clase final se declara como la clase que termina una cadena de herencia.
No se puede heredar de una clase final. Por ejemplo, la clase Math es una
clase final.
public
Las clases public son accesibles desde otras clases, bien sea directamente o
por herencia. Son accesibles dentro del mismo paquete en el que se han
declarado. Para acceder desde otros paquetes, primero tienen que ser importadas.
synchronizable
Este modificador especifica que todos los metodos definidos en la clase son
sincronizados, es decir, que no se puede acceder al mismo tiempo a ellos desde
distintos threads; el sistema se encarga de colocar los flags necesarios para
evitarlo. Este mecanismo hace que desde threads diferentes se puedan modificar
las mismas variables sin que haya problemas de que se sobreescriban.
CONTROL DE FLUJO
================
Muchas de las sentencias de control del flujo del programa se han tomado del C:
Sentencias de Salto
if/else
if( Boolean ) {
sentencias;
}
else {
sentencias;
}
switch
switch( expr1 ) {
case expr2:
sentencias;
break;
case expr3:
sentencias;
break;
default:
sentencias;
break;
}
Sentencias de Bucle
Bucles for
for( expr1 inicio; expr2 test; expr3 incremento ) {
sentencias;
}
El siguiente trocito de codigo Java que dibuja varias lineas en pantalla
alternando sus colores entre rojo, azul y verde. Este fragmento seria parte de
una funcion Java (metodo):
int contador;
for( contador=1; contador <= 12; contador++ ) {
switch( contador % 3 ) {
case 0:
setColor( Color.red );
break;
case 1:
setColor( Color.blue );
break;
case 2:
setColor( Color.green );
break;
}
g.drawLine( 10,contador*10,80,contador*10 );
}
Tambien se soporta el operador coma (,) en los bucles for
for( a=0,b=0; a < 7; a++,b+=2 )
Bucles while
while( Boolean ) {
sentencias;
}
Bucles do/while
do {
sentencias;
}while( Boolean );
Excepciones
try-catch-throw
try {
sentencias;
} catch( Exception ) {
sentencias;
}
Java implementa excepciones para facilitar la construccion de codigo robusto.
Cuando ocurre un error en un programa, el codigo que encuentra el error lanza
una excepcion, que se puede capturar y recuperarse de ella. Java proporciona
muchas excepciones predefinidas.
Control General del Flujo
break [etiqueta]
continue [etiqueta]
return expr;
etiqueta: sentencia;
En caso de que nos encontremos con bucles anidados, se permite el uso de
etiquetas para poder salirse de ellos, por ejemplo:
uno: for( )
{
dos: for( )
{
continue; // seguiria en el bucle interno
continue uno; // seguiria en el bucle principal
break uno; // se saldria del bucle principal
}
}
En el codigo de una funcion siempre hay que ser consecuentes con la declaracion
que se haya hecho de ella. Por ejemplo, si se declara una funcion para que
devuelva un entero, es imprescindible que se coloque un return final para salir
de esa funcion, independientemente de que haya otros en medio del codigo que
tambien provoquen la salida de la funcion. En caso de no hacerlo se generara un
Warning, y el codigo Java no se puede compilar con Warnings.
int func()
{
if( a == 0 )
return 1;
return 0; // es imprescindible porque se retorna un entero
}
Paquete.
java.io -> entrada/salida
ver esquemas en io.rar
Almacenar datos, capturar texto de teclado y devolver a monitor.

Flujos de Entrada/Salida Conexiones
Teclado-monitor-disco duro o cualquier dispositivo
System.out.print -> escribir en la salida estandar el flujo
es un flujo de escritura de salida PrintStream
flujo de entrada System.in -> teclado
Jerarquia de clases:
ImputStream | -> leen 8 bits,Ascii ebcdic
OutputStream |
para la conversion existe imputStreamReader/ImputStreamWriter
Reader |-> leen 16 byits, Byte, Unicode char
Writer |
Tratamiento del buffer
metodos de la imputStram:
int available(); numero de bytes disponibles en el buffer(no usar)
void close(); cierra un flujo
intread() devuelve un int si al leer no hay nada devuelve menos 1
ByteArrayImputStream -> array de bytes |Arraybytes|

PipedImputStream -> coge informacion de otro hilo |Threads|
FileImputStream -> creamos un flujo de entrada desde un fichero
FileImputStream fichero=new FileImputStream("hola.txt");
while (fichero.read()!=-1))
SecuenceImputStream -> Fusionar dos flujos, concatena uno a continuacion
del otro, solo flujos de entrada |fusionar|
StringBufferImputStream -> trata el buffer como si fuera un string, como
un conjunto de caracteres |String|
ObjectImputStream -> leer objetos, Empleado |Oject| Serializar la clase
es el proceso de grabacion de un fichero
FilterImputStream -> Trabajan con buffer intermedio, realmente no se
trabaja, define las caracteristicas, se trabaja
con las hijas que son las siguientes.
BufferedImputStream -> buffer intermedio, mas velocidad, nos lo da por
fasciculos
PushbackImputStream -> releer el fichero, sin establecer de nuevo la
conexion
LineNumberImputStream -> cuenta las lineas que tiene un fichero
DataImputStream -> podemos leer datos primitivos implementa la
interface DataImport
estas pertenecen a la java.util.zip
InflaterImputStream -> lee archivos comprimidos: tar ,gzip, jar.
ZipFile -> Archivo comprimido, informacion de (algortimo)
ZipEntry -> devuelve los ficheros
ZipFile zf=new ZipFile("X.zip"); // accedemos al fichero comprimido
Enumeracion e=zf.entries)(); // primer fichero
zf.GetImputStream((ZipEntry)e.next()); // de esa entrada devuelve un flujo
metodos de la outputStream
System.out.print
para controlar las excecpciones

// coger informacion del teclado la convierte de 8 a 16 bits y lo va guardando
// en un buffer
BufferedReader teclado=new BufferedReader(new ImputStreamReader(System.in))

//lee el teclado hasta que se pulso enter
String ext=teclado.readline();
-----------------------------------------
import java.io.*;
public class Empleado implements Serializable{
private String apellido;
//private Fecha fecha;
public Empleado(String n,String a){

nombre=n;
apellido=a;
// fecha=f;
}
public String getNombre(){
return nombre;
}
public String getApellido(){
return apellido;
}
/* public String getFecha(){
return fecha.toString();
}*/
public String toString(){
return nombre+" "+apellido;
}
}
----------------------------------
import java.io.*;
public class Fichero{
try{
// para coger la informacion del teclado convirtiendola a unicode
// BufferedReader : buffer intermedio para que coja varias lineas
// ImputStreamReader: convierte o moldea de 8 a 16 bits la entrada System.in
BufferedReader teclado=new BufferedReader(new InputStreamReader(System.in));
// lectura de teclado hasta primer enter
String nombre=teclado.readLine();
// lectura del teclado desde el primer enter hasta el segundo
String apellido=teclado.readLine();
// creamos dos instancias
Empleado e1=new Empleado(nombre,apellido);
Empleado e2=new Empleado("Luis","perez");
// creamos o abrimos un fichero
FileOutputStream flujo=new FileOutputStream("empleados.txt");
// creamos un objeto con el flujo
ObjectOutputStream salida=new ObjectOutputStream(flujo);
// damos los valores al flujo escribimos los datos.
salida.writeObject(e1);
// cerrar el flujo
flujo.close();
// cerrar el fichero
salida.close();
// excepcion par acontrolar los errores
}catch(Exception e){;}
}
}
------------------hacer una clase que se llama leer para leer un entero
pedirEntero();
Reader -> para 16 bit unicode

CharArrayReader -> para leer un char
BufferReader -> para leer un buferr
FilterReader ->
PipedReader -> un buferr
StringReader -> para leer un String
ImputStreamReader -> para leer un buferr
Writer
BufferedWriter ->
CharArrayWriter -> para escribir un char
BufferWriter -> para escribir un buferr
FilterWriter ->
PipedWriter -> un buferr
StringWriter -> para escribir un String
ImputStreamWriter -> para escribir un buferr
StringTokenizer -> distingue palabras entre blancos
import java.io.*;
import datosio.Leer;
public class Fichero1{
try{
String nombre=Leer.pedirTexto();
String apellido=Leer.pedirTexto();
//int edad=Leer.pedirEntero();
Empleado e1=new Empleado(nombre,apellido);

Empleado e2=new Empleado("Luis","perez");
FileOutputStream flujo=new FileOutputStream("empleados.txt");
ObjectOutputStream salida=new ObjectOutputStream(flujo);
flujo.close();
salida.close();
}catch(Exception e){;}
}
}
------------------------------------
;;;;;;;clase Leer
package datosio;
import java.io.*;
public class Leer{
// leer datos del teclado
static BufferedReader teclado=new BufferedReader(new InputStreamReader(Syste
m.in));
static String txt;
public static String pedirTexto(){
try{
txt=teclado.readLine().toLowerCase();
}catch(IOException E){;}
return txt;
}
public static int pedirEntero(){
int num=0;
try{
txt=teclado.readLine();
num=Integer.parseInt(txt);
}catch(IOException e){;}
return num;
}
public static double pedirDecimal(){
double num=0;
try{
num=Double.parseDouble(txt);
return num;
}
public static char pedirCaracter(){
char c=' ';
try{
c=txt.charAt(0);
| objeto del flujo

| |nombre donde guardamos el buffer
| | |buffer intermedio para pedir el flujo de 16 bit
| | | |transforma a 16 bits
| | | | lectura 8 bit
| | | | |
BufferedReader teclado=new BufferedReader(new InputStreamReader(System.in));
String nombre=" ";

FileImputStream flujof=new FileInputStream("empleados.txt");
// leyendo bytes
while((c=flujof.read())!-1) nombre=nombre+c;
//leyendo objetos
ObjectInputStream salida=new ObjectInputStream(flujof);
//leyendo objetos
while((c=flujof.readObject())null) nombre=nombre+c;
BufferedReader fichero=new BufferedReader(new InputStreamReader("fich.txt"));
provincias.txt
Nombre String
Apellido String
edad int
dni String
cod
provincia combo
borrar guardar grabar
provincias.txt personas.txt
guardar
FileOuputStrem("provincias.txt",true);
Persona.java -> ventana para peticion de datos.(principal)
Provincias.java -> para crear el fichero provincias.txt
Grabaprovincias.java -> para grabar provincias
LeeProvincias -> para leer provincias
Personas.java -> para crear personas
Grabapersonas.java -> para grabar personas en personas.txt
Leepersonas.java -> para leer personas de peresonas.txt
---------------------------------
java.net
para informacion y codigo fuente
ver: www.pearsoneducacion.com/informatica/areadscarga/sb.htm
conectarnos a otro oddenador via
TCP
UDP
NIC
Clase ServerSocket
Clase Soket tiene un metodo constructor conpuesto de( Sring,int)
| | puerto
|ip-del servidor
la comunicacion es hal-duplex, en ambos sentidos
// esto genera un buffer
Socket s=new Socket("ALBRETO",7777);
// con esto creamos un flujo a nuestro programa
InputStream in=s.getInputStream();
// flujo de salida escribir datos
OutputStream out=s.getOutStream();
ejercicio SockFileServ.java
SockFileClie.java
cliente Servidor
datos.txt clientes.txt
|nombre|contrase¤a|fecha| |nombre|Contrase¤a|Fecha|
1§ mirar a ver si existe datos.txt
si no existe lo crea
2§ el servidor mirara a ver si esta el cliente y comprobar la fecha
si ha pasado mas de 30 dias, la contrase¤a caduca
3¦ si no existe le crea y manda un mensaje
-------------------------------------------------------------------------
excepciones
la excepcion se produce cuando nos da un error en nuestro programa
para controlar las excepciones se usa:
Try{
}castch(Excepcion e) {e.printStackTrace();}
puede tener varios castch para distintos metodos
si ponemos{ ;} no nos mostraria el error haria nada

ver las apis
java.io
FileInputStream
read()
public int read
throws IOException
{
} e.printStackTrace(); nos lista las excepciones de esa
; clase herencia
Throwable
Error Exception
IOEXcption RuntimeException
RuntimeException -> excepciones de error en operaciones

IOException -> excepciones de lectura escritura
-------------------------------------------------------------------------------
************** bases de datos *******************
desventajas de los ficheros planos:
no tienen un sistema de bloqueo
especializados en pocos datos
Dificultad de ampliacion
Almacenamiento de los datos del pasado(historial)
Serializacion:
Proceso por el que se serializan los datos de una instancia los datos de
memoria son marcados para serializar y poder ser transmitidos a un fichero
Bases de datos relacionales (tablas relacionadas) boyce-Codd:
Conjunto de objetos(controlan almacenamiento gestion de los datos) y
entidades (tablas)
SQL
Enviamos un texto, lo compila, ejecuta la senmtencia y devueve el resulset
que sera una tabla.
Lenguage de comunicacion con la base de datos:
El cliente envia peticiones SQL, a traves de una conexion, al servidor que
almacena los datos
Es un lenguaje declarativo( indica lo que hay que hacer, no como se hace).
Consultas,crear,modificar eliminar registros
Caracteristicas
No son estandar, cada fabricante crea su propia API
El lenguaje de programacion debe cumplir:
No depender de la plataforma
No depender de la plataforma de la base de datos
Java con JDBNC
INTERFACES
------------
DriverManager -> se encarga de cargar el controlador de las base de datos
nos lo suministra la empresa de la bbdd y deben de valer
para cualquier plataforma.
Connection -> conexion con la base de datos. ODBC
Statement -> enviar una sentencia SQL , encapsula la consulta
Resultset -> almacena resultado de la consulta en datos tabulados
Datbase management System

Responsablidad:
Creacion de los archivos de almacenamiento de la base de datos
Proporcionar facilidad de consulta y actualizacion
Mantener el registro de acciones (log)
Gestionar la seguridad
Transacciones y acceso concurente:
Serie de eventos que deben completarse satisfactoiamente antes de que los
resultados sean permanetes
Consistencia:
Ejemplo de la transferencia bancaria
Acceso varios usuarios
Una peticion no afecte a los demas
Calcular valores y llegue un update
Synchronized
Presentacion
Acceso a datos
Manipulacion de los datos extraidos de local o remoto
Recuperacion de datos
Java-Sql
JDBC se relaciona con el driver de la base de datos
Caracteristica JDBC 2.0
* conjunto de resultados desplazables
* Conjunto de resultados actualizable.
accedemos al mimo elemento
r.first(); // el primer elemento
r.getInt("edad"); // acceder por nombre del campo
// o
r.getInt(2); // acceder por numero de elemento
| nombre | apell | edad |
| | | |
r.next(); // lee el siguiente registro
DataSource: arquitectura flexible para conexiones. Oculta URL puerto servidor..

JNDI: acceso al servicio de nombre y directorio
Pool: cada conexion tiene un coste (crear,mantener y liberar), el pool realiza
una reserva con lo que reutiliza.
Rowset: transmitir informacion a traves de la red
Transacciones distribuidas: gestiona transacciones que abarcan varios origenes
de datos
Java Noming & Directory
JDBC 3.0
SavePoint: se¤al deshacer transacciones
DriverManager -> Connection -> Statement Resultset
| | ^
| | |
| | sql | Datos
| v |
----------> D R I V E R S
Establece Enlace | ^
| |
| ------ |
--| bbdd |-
------
//
// java1901.java
//
/**
* Este ejemplo supone que existe una Base de Datos "TUTORIAL" ya registrada
* con Access, a la cual se le a¤ade una tabla más que contiene la
* información que está codificada en el ejemplo.
*/
import java.sql.*; //paquete de SQL
class java1901 {
static public void main( String[] args ) {
Connection conexion; // variables
Statement sentencia; // de conexion y resultado
ResultSet resultado; //
System.out.println( "Iniciando programa." );
// Se carga el driver JDBC-ODBC
try {
Class.forName( "sun.jdbc.odbc.JdbcOdbcDriver" );
} catch( Exception e ) {
System.out.println( "No se pudo cargar el puente JDBC-ODBC." );
return;
}
try {
// Se establece la conexion con la base de datos
conexion = DriverManager.getConnection( "jdbc:odbc:Tutorial","","" );
// enviar sentencias a esta base de datos
sentencia = conexion.createStatement();
try {
// Se elimina la tabla en caso de que ya existiese
sentencia.execute( "DROP TABLE LIBROS" );
} catch( SQLException e ) {
}
// Esto es código SQL
sentencia.execute( "CREATE TABLE LIBROS ("+
" TITULO VARCHAR(50) NOT NULL, "+
" AUTOR VARCHAR(30) NOT NULL, "+
" PRECIO FLOAT NOT NULL, "+
" PUBLICACION DATETIME) " );
sentencia.execute( "INSERT INTO LIBROS "+
"VALUES('Piratas Cibernéticos',"+
"'J. de Marcelo',18.00,'11/14/2001')" );
"VALUES('JavaServer Pages: Manual de Usuario y Tutorial',"+
"'A. Froufe',18.00,'12/28/2001')" );
"VALUES('JAVA 2: Manual de Usuario y Tutorial',"+
"'A. Froufe',35.75,'12/28/1999')" );
"VALUES('Domine Microsoft Word 2000',"+
"'C. Pérez',35.75, NULL)" );
System.out.println( e );
return;
}
System.out.println( "Creacion finalizada." );
}
}
//------------------------------------------ Final del fichero java1901.java
Pasos:
1) // Cargamos el driver odbc
tipos de driver:
| 1. puente ODBC-JDBC (driver tipo 1)
tipos | 2. parte java parte nativo (driver tipo 2)
driver | 3. Middleware, asincrono, (funciona como el correo) (t 3)
| 4. Todo java/todo nativo, (para bases de datos hechas en java) (t 4)
2) // Establece la conexion con la base de datos
nombre de la base , protocolo, puerto, login password
<protololo>:<subprotocolo>\\Servidor:puerto <bbdd>
conexion = DriverManager.getConnection( "jdbc:odbc:Tutorial","","" );
3) // crea la consulta a la base de datos
sentencia = conexion.createStatement();
4) // get obtener resultado de la tabla resulset es una tabla
execute
executeQuery
executeUpdate
resultado=sentencia.executeQuery ("select * from tcliens")
5) // manupular resultados
resultado.first(); //el primero trabajar con el
6) // cerrar flujos
sentencia.Close(); //
conexion.Close(); //
================= S Q L =================
Lenguaje procedural: describe la informacion a procesar y el motor decide la
la mejor forma
DML : Data Manipulation Language. Comnado consulta
DDL : comandos Referentes a tablas
DCL : gestion de derechos
Diagramas de Venn
Select [c1,..cn] From [t1,..,tm]
| | | |tabla o tablas que quiero selecionar
| | |de
| |campos o columnas
|seleciona
select * from tclientes
Where <condici¢nes>
| |se cumplan las condiciones
|mientras, donde ,cuando
Group By[c1,.., ck]

| |en campo departamento
|agruparlo
Order by [c1,..,cj]
| |por campo o columna
|muestra los datos ordenados
Calculos
select cantidad * precio from t2 where nomart="pp*"
| | | | | | | | |articulos qui
| | | | | | | |en columna
| | | | | | |cuando
| | | | | |la tabla 2
| | | | |de
| | | |campo precio
| | |producto
| |campo cantidad
|seleciona
coincidencia de tipos
conversion de tipos cast(expresion AS tipodato)
0 1 2
tabla2 : |cantidad|precio|articulo|
r.getString("cantidad");
r.getString(0);
0=posicion del campo en la tabla
select cast(cantidad*precio AS total) damos el nombre a la tabla resultado
====== Expresiones con funciones ======
funciones numericas
Abs() -> valor absoluto Selec cast(abs(cantidad*precio) as total)
ceil() -> redondeo hacia arriba
flor() -> redondeo hacia abajo
mod(x,y) -> el resto de la diovision entre x/y
power(x,y) -> eleva x a y
sqrt() -> raiz cuadrada
max(x) -> el maximo
min(x) -> el minimo
sum(x) -> suma los campos
count() -> cuantos elementos tiene la tabla
avg() -> media
funciones alfanumericas texto
left(c,x) -> devuelve la parte izquierda desde el numero x
right(c,x) -> devuelve la parte derecha desde el numero x
upper() -> pasar a mayusculas
lower() -> pasar a minusculas
length() -> longitud del campo
substr(c,x,y)> devuelve el contenido entre x e y
isnull() -> devuelve un bolean (si esta vacio)
funciones fecha
Date() -> dia,mes a¤o
month() -> mes
day() -> dia del sisteme
yaer() -> a¤o
weekday() -> dia dse la semana
Tipos de datos
Ordenar datos
Order by [c1,..cn]
los campos se ordenan segun aparicion
DES y ASC
operadores LIKE 't%'
busqueda por patrones
'T%'
'T_'
[ -f] complementario de a a z = g a z
[a-f] rango de a a f
uniones UNION
intersecciones INTERSECT
Group By
agrupacion de campos
mayor sueldo dse tiendas
lo que aparece en selec que no es una funcion, debe aparecer en Group by
HAVING es el wuere de los grupos
HAVING se aplica a grupos
WHERE se aplica a filas
ALGEBRA RELACIONAL
coperaciones conjuntos:
union u
interseccion n
diferencia -
producto cartesiano x unir tablas
operaciones relacionales
proyeccion PI SELECT
Seleccion o WHERE
para diferenciar el nombre del campo de dos tablas que coincide en el nombre:
where tclientes.nombre=tarticulo.nombre
Tablas dinamicas
efecto cascada SELECT ... FROM(SELECT ...) AS A
Entidad es un objeto, una tabla, ej: tcliente

con atributos o campos nombrei, apellido ...
registro -> instancia -> fila
modo de interactuar
Uso de verbos (cliente pedir discos)
cardinalidad:restricciones que haya sobre
1 a 1 <-------->
1 a n <---------
n a m ----------
Clave principal puede estar compuesta de varios campos
Distinguir cada fila de la tabla
una o varias columnas pueden ser clave
si ninguna cumple los requisitos, a¤adir una para ese fin (tipo secuencial)
Valores numericos
Procurar que los valores no cambien nunca
orden de las columas influye
colocar al principio las que contengan menos valores dupicados

tcli_art
tcliente tarticulo
libro: Bases de datos con Java ANAYA MULTIMEDIA/WROX
porque dividir las tablas:
tama¤o
repeticion evitar la redundancia
Cambio de datos
Codd:
Dividir datos en tabla mas peque¤as con reglas estrictas de los datos que
pueden contener, Crear relaciones entre tabla, eleiminar atributos
redundantes y /o filas, eliminar datos derivados, asegurar que cada tabla
respeta a una entidad
1NF columna identificada atomica y unica
2NF eliminar datos redundantes
Debe de ser 1NF
los atributos que no estan relacionados con PK, han de depender de ella
CINE/PELICULA/hora/tfno entonces CPH y CT
3NF cada atributo a de depender de la clave primaria exclusivamente
PedidoID/NumeroLinea/<
BCNF Trabajo sobre las claves
claves candidatas
claves compuestas
claves superpuestas
es 3NF y no existen dependencias entre claves candidatas
4NF
5NF
ejercicios:
/\
/ \ / \
------ / \ ------ / \
|marcas| -> /marco \, |coches| /distribucion\
------ \ / ------ \ /
\ / || |
\ / /\ |
\/ / \ --------------
/vent\______>|concesionarios|
\ / --------------
tablas: MARCAS(CIFM,NOMBRE,CIUDAD)
----
COCHES(CODCOCHE,NOMBRE,MODELO)
--------
CONCESIONARIOS(CIFE,NOMBRE,CIUDAD)
----
CLIENTES(DNI,NOMBRE,APELLIDOS,CIUDAD)
---
DISTRIBUCION(CIFE,CODCOHE,CANTIDAD)
---- -------
VENTAS(CIFE,DNI,CODCOCHE,COLOR)
---- --- --------
MARCO(CIFM,CODCOHE)
---- --------
examen B)
1) Que metodos me devuelven un Resulset
45) Obtener los CODCOCHE de los COCHES cuya ciudad sea la ultima de la lista
alfabetica de las ciudades donde hay concesionario.
SELECT DNI FORM CLIENTES
WHERE CIUDAD=(SELECT MAX(CIUDAD) FROM CONCESIONARIO)
19. Obtecer los CODCOCHE de los coches comprados en un concesionario

de la misma ciudad que el cliente que lo compra
SELECT CODCOCHE from ventas,clienetes,concesionarios
WHERE concesionario.ciudad=clientes.ciudad
and concesionario.cifc=ventas.cifc
and clientes
5) Indicar la sentencia SQL que inserta datos en una tabla
6) Tipos de sentencias SQL
Crear una tabla en tiempo de ejecucion

CREATE TABLE nombre de la tabla (defin_campo1,defin_campo2,defini_campo3...)
Borrar la tabla
DROP table <nombre
Insertar elementos en una tabla
INSER INTO tabla values (-----,-----,-----)
CREATE TABLE COCHES
( codcoche smallint notnull,
Nombre char(10) notnull,
Modelo char(10) notnull,
PRIMARY KEY (codcoche));
CREATE TABLE DISTRIBUCION
( codcoche smallint notnull,
Cifc smallint notnull,
Cantidad smallint notnull,
PRIMARY KEY (codcoche,Cifc),
FORFEIGN KEY Cifc REFERENCES Concesionario,
FORFEIGN KEY Codcoche REFERENCES coches);
select cantidad * precio from t2 where nomart="pp*"
8) obtener todos los campos de todos los clientes de Madrid
SELECT * From Clientes where ciudad='MADRID'
se debe de poner comillas simples para los string
9) obtener los nombres de todas las marcas de coches ordenadas alfanumericamente
SELECT nombres From marcas Order by nombre
10) obtener el cif de todos los concesionarios cuya cantidad en distribucion

es >18
---- -------
SELECT cife FROM distribucion

WHERE (cantidad>18)
12) obtener el cif de todos los concesionarios cuya cantidad en distribucion

este comprendia entre 10 y 18
---- -------
SELECT cife FROM distribucion
WHERE cantidad<18 and cantidad>10
14) obtener parejas del cif de marcas y dni clientes que sean de la misma ciudad
MARCAS(CIFM,NOMBRE,CIUDAD)
----
---
SELECT cifc,dni FROM marcas,clientes
WHERE marcas.ciudad = clientres.ciudad
16) obtener codcoche de coches suministrados por algun concesionario

de BARCELONA
----
---- -------
SELECT codcoche FROM concesionarios,distribucion

WHERE distribucion.cife=concesionario.cife
and concesionario.ciudad='BARCELONA'
17) obtener codcoche de aquellos coches vendidos a clientes de madrid
___
---- --- --------
SELECT codcoche.ventas FROM ventas,clientes
WHERE clientes.ciudad='MADRID' and clientes.dni=ventas.dni
18) obtener codcoche de los coches adquiridos en madrid por un cliente de madrid
___
---- --- --------
----
SELECT codcoche.ventas FROM ventas,clientes,concesionarios
WHERE concesionario.ciudad='MADRID'
and clientes.ciduad='MADRID'
and concesionario.cife=ventas.cife
and ventas.dni=clientes.dni
Se desea dise¤ar un esquema relacional de una base de datos para un centro de
ense¤anza y que contengas informacion sobre los alumnos, las asignaturas y las
calificaciones que se obtienes en cada una de las mismas.
Desarrollar un modelo de entidar relacion, y reducirloa tablas
alumnos ( dni,nombre,apellido)
----
asignaturas(codigo_asig,nombre_asig,num_horas)
-----------
calificaciones(codigo_asig,dni,calificacion)
----------- ---
23) obtener codcoche de los coches cuyo nombre empiece por 'c'
--------
select codcoche from coches where codcoche='c*'
25) obtener numero total de marcas de coches que son de madrid
--------
MARCAS(CIFM,NOMBRE,CIUDAD)
----
28) obtener el dni de numeracion mas baja de todos los clientes que han
comprado coche blanco
31) obtener el dni de los clientes que han comprado algun coche en un
concesionario de madrd
33) obtener codcoche de los coches vendidos por algun concesionario de madrid
36) obtener nombre y apellido de los clientes que han adquirido un coche
modelo=gti de color blanco
46) obtener la media de los automoviles que cada concesionario tiene actualmente
en stock.
31) obtener codcoche de los coches validos

o
/
// java1904.java
//
/**
* Este ejemplo presenta un interfaz para atacar a bases de datos
* a través del driver JDBC-ODBC.
* En los campos de texto que aparecen al ejecutarlo se debe
* indicar la base de datos con la que se desea establecer conexión
* y pulsar el botón. Una vez establecida la conexión, ya se puede
* realizar cualquier consulta a las tablas contenidas en la
* base de datos a través de sentencias SQL, escribiendo la
* consulta que se desea en el campo al efecto y pulsando el botón
* de ejecución de la consulta.
* En el campo de texto inferior se van mostrando los resultados
* correspondientes a cada una de las acciones que se van realizando
* o a los mensajes de la aplicación.
*/
import java.net.URL;
import java.awt.*;
import java.sql.*;
public class java1904 extends Frame implements MouseListener {
// Se utiliza el itnerfaz MouseListener para poder capturar
// los piques de ratón
// Estos son los objetos que se van a utilizar en la aplicación
Button botConexion = new Button( " Conexión a la Base de Datos " );
Button botConsulta = new Button( " Ejecutar Consulta " );
TextField txfConsulta = new TextField( 40 );
TextArea txaSalida = new TextArea( 10,75 );
TextField txfUsuario = new TextField( 40 );
TextField txfClave = new TextField( 40 );
TextField txfUrl = new TextField( 40 );
String strUrl = "";
String strUsuario = "";
String strClave = "";
// El objeto Connection es parte del API de JDBC, y debe ser lo
// primero que se obtenga, ya que representa la conexión efectiva
// con la Base de Datos
Connection con;
// Constructor de la clase, que es el que construye el interfaz

// que se va a mostrar en la ventana
public java1904() {
// Se hacen todos los campos de texto editables para que se
// puedan introducir datos, y no se permite que se escriba en
// el área de texto que se va a utilizar como salida de los
// resultados de las acciones del usuario y las respuestas que
// se obtengan de la base de datos a las consultas que se
// realicen
txfConsulta.setEditable( true );
txfUsuario.setEditable( true );
txfUrl.setEditable( true );
txaSalida.setEditable( false );
// Se va a utilizar el GridBagLayout, que aunque complicado
// en su uso, tiene la flexibilidad que se necesita en este
// caso concreto
GridBagLayout gridbag = new GridBagLayout();
GridBagConstraints gbCon = new GridBagConstraints();
// Lo fijamos como el layout a utilizar
setLayout( gridbag );
// Se fija el color y la fuente de caracteres a usar
setFont( new Font( "Helvetica",Font.PLAIN,12 ) );
setBackground( Color.orange );
// No se han fijado los setConstraints para el Label, para que
// se asuman los de defecto. El campo de texto txfUsuario es
// el último componente en su fila, a través de gbCon, y
// luego se añade al interfaz de usuario
gbCon.weightx = 1.0;
gbCon.weighty = 0.0;
gbCon.anchor = GridBagConstraints.CENTER;
gbCon.fill = GridBagConstraints.NONE;
gbCon.gridwidth = GridBagConstraints.REMAINDER;
add( new Label( "Usuario" ) );
gridbag.setConstraints( txfUsuario,gbCon );
add( txfUsuario );
add( new Label( "Clave de Acceso" ) );
gridbag.setConstraints( txfClave,gbCon );
add( txfClave );
add( new Label( "URL de la Base de Datos" ) );
gridbag.setConstraints( txfUrl,gbCon );
add( txfUrl );
// Ahora viene la fila en que está el botón de Conexión a la
// base de datos, fijamos los constraints para que eso sea así
// y lo añadimos
gridbag.setConstraints( botConexion,gbCon );
add( botConexion );
// Ahora registramos el botón para que reciba los eventos del
// raton a través del interfaz MouseListener
botConexion.addMouseListener( this );
// Ahora viene la zona que permite introducir el texto de la
// consulta que se quiere realizar y el botón que va a permitir
// su envío al driver JDBC
add( new Label( "Consulta SQL" ) );
gridbag.setConstraints( txfConsulta,gbCon );
add( txfConsulta );
gridbag.setConstraints( botConsulta,gbCon );
add( botConsulta );
botConsulta.addMouseListener( this );
// Ahora se coloca una etiqueta en su propia línea para rotular
// el área de texto en la que se van a presentar los resultados
// de las consultas que se realicen
Label labResultado = new Label( "Resultado" );
labResultado.setFont( new Font( "Helvetica",Font.PLAIN,16 ) );
labResultado.setForeground( Color.blue );
gridbag.setConstraints( labResultado,gbCon );
gbCon.weighty = 1.0;
add( labResultado );
// Ahora se cambia la forma de extensión de la ventana, para que
// si se agranda la ventana tenga la mayor parte de espacio
// posible en la zona de texto en donde se presentan los
// resultados
gridbag.setConstraints( txaSalida,gbCon );
txaSalida.setForeground( Color.white );
txaSalida.setBackground( Color.black );
add( txaSalida );
}
public void mouseClicked( MouseEvent evt ) {

// Cuando se pulsa el botón Consulta, se recoge el contenido del
// campo de texto txfConsulta y se le pasa al método Select, que
// es el que va a realizar la consulta y devolver el resultado
// que se va a presentar en la zona de salida
if( evt.getComponent() == botConsulta ) {
System.out.println( txfConsulta.getText() );
txaSalida.setText( Select( txfConsulta.getText() ) );
}
// Si se pulsa el botón de Conexión, se intenta establecer la
// conexión con la base de datos indicada en el campo de texto
// correspondiente a URL, con el usuario y clave que se hayan
// indicado en los campos correspondientes
if( evt.getComponent() == botConexion ) {
// Se fijan las variables globales de usaurio, clave y url a
// los valores que se hayan introducido en los campos
strUsuario = txfUsuario.getText();
strClave = txfClave.getText();
strUrl = txfUrl.getText();
// La creación de la conexión con la base de datos lanza una
// excepción en caso de que haya problemas al establecer esa
// conexión con los aprámetros que se le indiquen, por ello
// es imprescindible colocar el método getConnection en un
// bloque try-catch. Si se produce algún problema y se lanza
// la excepción, aparecerá reflejada en la consola y en el
// área que se ha destinado en la ventana a ver los resultados
try {
// Ahora se intenta crear una nueva instancia del driver que se
// va a utilizar. Hay varias formas de especificar el driver que
// se quiere, e incluso se puede dejar que sea el propio
// DriverManager de JDBC que seleccione el que considere más
// adecuado para conectarse a una fuente de datos determinada
// La conexión aquí se realiza indicando la URL de la base de
// datos y el usuario y clave que dan acceso a ella
con = DriverManager.getConnection( strUrl,strUsuario,strClave );
// Si la conexión ha sido satisfactoria, cambiamos el rótulo
// del botón de conexión, para que indique que si se pulsa lo
// que se realiza será la "Reconexión"
botConexion.setLabel( "Reconexión a la Base de Datos" );
txaSalida.setText( "Conexion establecida con "+strUrl );
// Se presenta la información correspondiente al error, tanto
// en la consola como en la zona de salida de la ventana
e.printStackTrace();
txaSalida.setText( e.getMessage() );
}
}
}
// Se implementan vacíos el resto de los métodos del interfaz de
// eventos del ratón, MouseListener. Si se quiere evitar, también es
// posible utilizar MouseAdapter, que tiene implementados, pero sin
// acciones asignadas, todos estos métodos
public void mouseEntered( MouseEvent evt ) {}
public void mouseExited( MouseEvent evt ) {}
public void mousePressed( MouseEvent evt ) {}
public void mouseReleased( MouseEvent evt ) {}
// Este es el método que realiza la consulta

public String Select( String consulta ) {
String resultado="";
int cols;
int pos;
// Hay varios métos que se van a emplear y que lanzan excepciones
// en caso de que haya algún problema con la consulta, o si se
// rompe la conexión, etc
try {
// En primer lugar, se instancia la clase Statement, que es
// necesaria para ejecutar la consulta. La clase Connection
// devuelve un objeto Statement que se enlaza a la conexión
// abierta para pasar de nuevo el objeto Statement. Así es
// como la instancia "sentencia" se enlaza a la conexión actual
// con la base de datos
Statement sentencia = con.createStatement();
// El objeto resultSet también es enlazado con la conexión a la
// base de datos a través de la clase Statement, que contiene el
// método executeQuery, que devuelve un objeto ResultSet.
ResultSet rs = sentencia.executeQuery( consulta );
// Ahora se utiliza el método getMetaData en el resultado para
// devolver un objeto MetaData, que contiene el método getColumnCount
// usado para determinar cuántas columnas de datos están presentes
// en el resultado.
cols = ( rs.getMetaData() ).getColumnCount();
// Aquí se utiliza el método next de la instancia "rs" de
// ResultSet para recorrer todas las filas, una a una. Hay formas
// más optimizadas de hacer esto, utilizando la característica
// inputStream del driver JDBC
while( rs.next() ) {
// Se recorre ahora cada una de las columnas de la fila, es
// decir, cada celda, una a una
for( pos=1; pos <= cols; pos++ ) {
// Este es el método general para obetener un resultado. el
// método getString intentará moldear el resultado a un String.
// En este caso solamente se recoge el resultado y se le añade
// un espacio y todo se añade a la variable "resultado"
resultado += rs.getString( pos )+" ";
}
// Para cada fila que se revise, se le añade un retorno de
// carro, para que la siguiente fila empiece en otra línea
resultado += "\n";
}
// Se cierra la "sentencia". En realidad se cierran todos los
// canales abiertos para la consulta pero la conexión con la
// base de datos permanece
sentencia.close();
e.printStackTrace();
resultado = e.getMessage();
}
// Antes de salir, se devuelve el resultado obtenido
return( resultado );
}
public static void main( String args[] ) {

java1904 ventana = new java1904();
// Se recoge el evento de cierre de la ventana
ventana.addWindowListener( new WindowAdapter() {
public void windowClosing( WindowEvent evt ) {
System.exit( 0 );
}
} );
ventana.setSize( 450,300 );
ventana.setTitle( "Tutorial de Java, JDBC" );
ventana.pack();
ventana.setVisible( true );
}
}
//------------------------------------------ Principio de DatosPersonales.java
import java.awt.*;
import java.sql.*;
class DatosPersonales extends Frame implements ActionListener
{ Button crear, ver, insertar, cerrar;
TextField informacion;
Panel principal;
Connection conexion;
DatosPersonales()
{ super("Datos personales");
setSize(200,120);
principal=new Panel();
crear=new Button ("Crear");
crear.addActionListener(this);
ver=new Button ("Ver");
ver.addActionListener(this);
insertar=new Button("Insertar");
insertar.addActionListener(this);
cerrar=new Button("Cerrar");
cerrar.addActionListener(this);
informacion=new TextField(20);
principal.add(informacion);
principal.add(crear);
principal.add(insertar);
principal.add(ver);
principal.add(cerrar);
addWindowListener(new Cerrar());
principal.setBackground(SystemColor.control);
add(principal);
setVisible(true);
// paso 1 carga el driver
try
{ Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
} catch(ClassNotFoundException e)
{ informacion.setText("No se pudo cargar el controlador JDBC-ODBC");}
}
//herramientas administrativas/origene de datos( odbc)/dsn Sistema+Agregar+
//odbc de la pltaforma, relacionar alias con BBDD en nuestro caso personal
//
private void Crear_tabla()
{ Statement sentencia;
try
{
// paso 2 establece la conexion personal es el alias que tendremos que poner
// en el odbc
// relacioonamos el alias con el nombre de, or ---------
conexion=DriverManager.getConnection("jdbc:odbc:Personal");
// paso 3 crea consulta a la base de datos , y le mandamos sentencias
// borramos la tabla
sentencia=conexion.createStatement();
try
{
sentencia.executeUpdate("DROP TABLE DATOSPERSONALES");
}
catch(SQLException e){informacion.setText("Error al crear la tabla")
;
System.out.println(e);}
//executeUpdate = ejecura ordenes SQL
sentencia.executeUpdate("CREATE TABLE DATOSPERSONALES("+
"NOMBRE CHAR(20) NOT NULL,"+
"APELLIDOS CHAR(20),"+
"EDAD CHAR(3),"+
"TELEFONO CHAR(10))");
informacion.setText("Tabla creada");
conexion.close();
}
catch(SQLException e){}
}
public void actionPerformed(ActionEvent e)

{ String com=e.getActionCommand();
if ("Crear".equals(com))
{ informacion.setText("");
Crear_tabla();}
else
if ("Insertar".equals(com))
{ new Insertar(this);
}
else
if ("Ver".equals(com))
{
new Ver(this);
}
else
{dispose();System.exit(0);}
}
class Cerrar extends WindowAdapter
{ public void windowClosing(WindowEvent e)
{ dispose();
System.exit(0);
}
}
public static void main(String args[])
{ new DatosPersonales();}
}
class Insertar extends Dialog implements ActionListener

{
private Connection conexion;
private Button incluir,terminar;
private TextField nombre,apellidos,edad,telefono;
Insertar(Frame f)
{ super(f,"Insertar datos",true);
setSize(310,160);
nombre=new TextField(20);
apellidos=new TextField(20);
edad=new TextField(3);
telefono=new TextField(10);
incluir=new Button("Incluir");
incluir.addActionListener(this);
terminar=new Button("Terminar");
terminar.addActionListener(this);
Panel P_Datos=new Panel();

P_Datos.add(new Label("Nombre : "));
P_Datos.add(nombre);
P_Datos.add(new Label("Apellidos: "));
P_Datos.add(apellidos);
P_Datos.add(new Label("Edad : "));
P_Datos.add(edad);
P_Datos.add(new Label("Telefono : "));
P_Datos.add(telefono);
P_Datos.add(incluir);
P_Datos.add(terminar);
nombre.setEditable(true);
apellidos.setEditable(true);
edad.setEditable(true);
telefono.setEditable(true);
add(P_Datos);
setVisible(true);
}
private void insertar_fila()
{ Statement sentencia;
try{
// recogemos los valores de las cajas de texto
sentencia.executeUpdate("INSERT INTO DATOSPERSONALES"+
" VALUES ('"+nombre.getText()+"',"+
"'"+apellidos.getText()+"',"+
"'"+edad.getText()+"',"+
"'"+telefono.getText()+"')");
}
}
if ("Incluir".equals(com))
{insertar_fila();
// borrar las casillas
nombre.setText("");
apellidos.setText("");
edad.setText("");
telefono.setText("");
}
else
{
if(conexion!=null)
{
try
{
conexion.close();
}
catch(SQLException ex){}
}
dispose();
}
}
}
class Ver extends Dialog

implements ActionListener
{
private Connection conexion;
private ResultSet resultado;
private Button siguiente,terminar;
private TextField nombre,apellidos, edad,telefono;
Ver(Frame f)
{
// para visualizar los datos
super(f,"Ver datos",true);
setSize(310,160);
nombre=new TextField(20);
apellidos=new TextField(20);
edad=new TextField(3);
telefono=new TextField(10);
siguiente=new Button("Siguiente");
siguiente.addActionListener(this);
terminar=new Button("Terminar");
terminar.addActionListener(this);
Panel P_Datos=new Panel();

P_Datos.add(new Label("Nombre : "));
P_Datos.add(nombre);
P_Datos.add(new Label("Apellidos: "));
P_Datos.add(apellidos);
P_Datos.add(new Label("Edad : "));
P_Datos.add(edad);
P_Datos.add(new Label("Telefono : "));
P_Datos.add(telefono);
P_Datos.add(siguiente);
P_Datos.add(terminar);
add(P_Datos);
nombre.setEditable(false);
apellidos.setEditable(false);
edad.setEditable(false);
telefono.setEditable(false);
mostrar();
setVisible(true);
}
if ("Siguiente".equals(com))
siguiente();
else
{
if (conexion!=null)
{
try
{
conexion.close();
}
catch(SQLException ex){}
}
dispose();
}
}
private void mostrar()
{
Statement sentencia;
try{
// nos devuelve resulset
resultado=sentencia.executeQuery("SELECT * FROM DATOSPERSONALES");
siguiente();
}
}
private void ver_Datos()
{ try
{
nombre.setText(resultado.getString("NOMBRE"));
apellidos.setText(resultado.getString("APELLIDOS"));
edad.setText(resultado.getString("EDAD"));
telefono.setText(resultado.getString("TELEFONO"));
}
catch (SQLException e){}
}
private void siguiente()
{ try
{
if (resultado.next()) ver_Datos();
}
catch(Exception ex){}
}
}
//------------------------------------------ final de DatosPersonales.java
hacer un boton ver2 y sacarlo en un jtable(matriz, y array)

ejemplo de matriz
int a[][]={{5,2,3},{2,8},{6,9,8,1}};
-----------
| 5 2 3 |
-----------
| 2 8 |
-----------
| 6 9 8 1 |
-----------
Ejercicio:
nombre Apellidos edad y telefono
archivo
a¤adir
mostrar todo
salir
jtoolbar
|a¤adir | mostrar| borrar |vaciar| mostrar todo|
a¤adir(borrara la caja de texto y a¤ade el [ok]

mostrar (mostrara el primer registro y saldran los botones << < > >>
borrar (borra el registro)
vaciar (borra los campos)
AgendaC
Interfasz Statement:
hacer consultas a la base de datos
PreparedStatement
sentencias precompiladas, se almacenan en la cache la sentencia prcomplilada
y solo se tendra que enviar los datos.
PreparedStatement pstmt = con.prepareStatement("UPDATE EMPLOYEES
SET SALARY = ? WHERE ID = ?");
pstmt.setBigDecimal(1, 153833.00)
pstmt.setInt(2, 110592)
Conection con DriverManager.,getDonection()

String sqt="INSER INTO DATOSPERSONALES(?,?,?,?)";
PreparedStatement sentencia = con.prepareStatement(sql)
sentencia.setString(1,"Manuel");
sentencia.setString(2,"Chacho");
sentencia.setrInt(3,64);
sentencia.setrInt(4,916660403);
CallableStatement :
Procedimientos almacenados
pertenecen a la cl¤ase conetction
Metodo Statement createStatement(int,int)
parametros:
el primer paramaetro es eltipo de resulset, resulset.1004
el segundo parametro es el nivel de concurrencia.
Vacio: solo hacia delante
-Tipo_Resultet
TYPE_FOREARD_ONLY = sin nada 1003
TYPE_SCROLL_INSENSITIVE = sin concurrencia 1004
TYPE_SCROLL_SENSITIVE = con concurrencia (multiusuario) 1005
-Nivel_de_concurrecia
CONCUR_READ_ONLY
CONCUR_UPDATE
pertenece al examen Statement
Resulset executeQuery()
Int executUpdate()
object execute()
Devolver varios Resulset
Devolver varios contadores
SQL introducido en tiempo de ejecucuion
Valores devueltos
getResulset(),getUpdateCount(),getMoreResults()
Metodos
Resulset encapsula los datos devueltos
Bolean next()
getXXX("<campo>"
UpdateXXX()
Bolean wasNull()
Next(),last(),previus(),firsti()
insertRow()->insertXXX()->moveTolnsertRow()
updateXXX()-> updateRow()
Metodos de Statement
nos devuelven un int o un resulset
getMaxRows();
setMaxRows(); cuantas filas como maximo
getMaxFieldSize(),setMaxFieldSize(); tama¤o
Metadatos (informacion de la informacion de labase de datos)
Herramienta que muestra informacion sobre las tablas
diccionario de datos
Aplicacion de bases de datos
Metodos de Connection
DatabaseMetaData getMetaDaTa()
identificadore de la base
Caracteristicas que admite
Limites de tama¤o
Esquemas, catalogo,tablas,columnas
getTable(), getColumns()
Mandatos del Resulset
ResulsetMetaData getMetaData()
Metodos del Resulset
------------------------------
Transacciones:
TRANSACCIONES
Qué son
Conjunto de eventos que deben completarse antes de que el resultado sea permanen
te
Evita la corrupción
Base de datos consistente
Sentencias
- Commint: datos persistentes excepto los de l transaccióna ctual
- Rollback: devuelve la base al estado después de la operación con éxito
- SavePoint: marca y deshacemos las tranascción desde esa posición
Requisitos
Atomicidad
Consistencia: devuelve al estaado válido
Aislamiento: interactuación entre transacciones
Durabilidad
Concurrencia
Bloqueos (locking) aisla transacciones
Bloqueos a transacción ,memoria o sistema de archivos
Se pueden realizar a nivel fila, página y tabla
Exclusivos: sólo podrá haber una transacción bloqueando la fila al mismo tiempo
Compartidos: aplicamos a un recurso un grupo de usuarios
Bloqueos
Los bloqueos los dirige el motor de la base de datos
Bloqueos de lectura y escritura
Cuándo se bloquea
Actualización perdida
Pesimista: se bloquea en la consulta
Optimista: se bloquea en la actualización
Mortal: colisión de bloqueos. Bucle.
Niveles de aislamiento
Grado en el que una transacción puede ser vista por otras
Lectura sucia: los cambios no confirmados, pueden ser vistos
Lectura confirmada:
- No permiten las lecturas sucias
- Se podrá leer cuando los cambios se hagan efectivos
- Si escribo, se bloquea
Niveles de aislamiento II
Lectura repetible
- Admite la lectura fantasma
- La relectura en cualquier tiempo superior al comienzo de la transacción,
devolverá los mismos datos
Niveles que admite el driver
DatabaseMetaData
supportsTransactionIsolation()
getTransactIsolation()
Autocommit
Activado por defecto
Cada sentencia equivale a una transacción
Conexión.setAutoCommit(false)
Declaramos varias sentencias
Commit() hace efectiva la transacción actual
A ATOMICIDAD
C CONSTANCIA
I INSOLATION (AISLAMIENTO)
D DURABILIDAD
Un conjunto de eventos que han de completarse para labergar la persistencia
( todo o nada)
Evita la corrupcion de la base de datos
commit() se encarga de la persistencia
rollback() desace esos cambios
savepoint() marca, a partir de aqui hay persistencia (SOLO VERSIONES 3.0)
Concurrencias:
- Acceso a una instancia por dos o mas clientes
| fila
niveles de concordancia | pagina (lo que alberga la memoria)
| tabla
bloqueos:
- compartidos | lectura
- exclusivos | escritura
Optimista - se ejecuutaria, si ha tenido concurrencia , comenzaria de nuevo

Pesimista - se bloquearia al ejecutar la select (mas lento)
| No confirmadas (no se suelen utilizar)
tipos de lecturas | Confirmadas (no relaliza la lectura hasta que no finalice
| la escritura)
conexion.setAutoCommint(false); viene por defecto
conexion.setAutoCommint(true); activar transacciones
.
.
sentencias
.
.
conexion.conmmit();
H I L O S
=========
proceso: extructuras de un programa o varios.(estado, pos relativa en memoria)
traza: codigo del programa, lectura secuencial que se va cargando en memoria
un conjunto de intrucciones
contador de programa: puntero que me dice la siguiente instruccion que se
debe de cargar.
estados de los procesos generales

|en ejecucion
procesos|
|no ejecucion
cola para guardar los procesos( listas enlazadas)

| ejecucion -> se esta ejecutando el proceso
|
| listo -> se pone en la cola de proceso
Estados |
reales | bloqueado -> se puede bloquear a la espera de un (suceso)
|
| nuevo -> crear un proceso nuevo
|
| terminado -> fin de un proceso
| listos
colas|
| bloqueados
| memoria ->
|
|
tablas de control | e/s ->
| archivos->
| | ubicacion -> segmentos/paginas
| procesos-> |
| atributos -> informacion-metadatos del proceso
| usuario: privilegios con restrigciones

| ^
modos | | (salvar el contexto)
| v
| kernel: privilegios totales
-------------------------------------
hilos -> threads -> procesos lijeros
ES IMPORTANTE SINCRONIZAR LOS DATOS PARA QUE NO SE MEZCLEN UNOS CON OTROS.
java.lang
| Thread
Con esto se crea un hilo.

forma 1.
es obligatorio el metodo run dentro de run se introducira todo mi porceso hilo
aqui se sobreescribe run
class PrimeThread extends Thread {
long minPrime;
PrimeThread(long minPrime) {
this.minPrime = minPrime;
}
public void run() {
// compute primes larger than minPrime
. . .
}
}
--------------------------------------------------------------------------------
The following code would then create a thread and start it running:
con start() llamamos al metodo run de ese proceso.
PrimeThread p = new PrimeThread(143);

p.start();
Con esto se crea un hilo.
forma 1. interface Runable
con esta poderiamos heredar de otras clases
--------------------------------------------------------------------------------
class PrimeRun implements Runnable {
long minPrime;
PrimeRun(long minPrime) {
this.minPrime = minPrime;
}
public void run() {
// compute primes larger than minPrime
. . .
}
}
--------------------------------------------------------------------------------
The following code would then create a thread and start it running:
PrimeRun p = new PrimeRun(143);

new Thread(p).start();
Thead.sleep detiene el proceso un tiempo en nanosegundos
se utiliza para hacer el efecto del movimiento.
g.drawString("*",x,1);
yield() espera a que se acaben todos
clase Object
wait() para un hilo
notify() levanta un hilo
notifiAll() levanta todos los hilos
ver:
ThreadeEchoServer.java
SERVLET Y JSP
CONTENEDOR WEB, MANEJA RECURSOS DINAMICOS.
Servlet ->Programa java
Plantillas
Clientes de aplicacion, Clientes robustos Cliente dirige la logica de interactua
cion y de aplicacion
Clientes web. Navegadores
Gestionan relacion con usuario, pero dejan el resto al servidor
| conseguir recursos (HTML) URL
Navegador|
| analizador sintactico
HTML
El protocolo HTTP
Protocolo sin estado (no recuerda los datos)
Basado en solicitudes y respuestas
Protocolo de capa de aplicacion
capa 7 modelo OSI
modelo TCP/IP capa Aplicacion
es un protocolo orientado a conexion
HTTP
cabeceras HTTP
|GET -Realiza peticion del cocumento especificado
| -Acceso a recursos estaticos
| -Dinamico: parametros de consulta en lka URL
| www.mixmail.com/loginApp?login=paqui¬pwd=jairo
metodos | va en la cabecera
de |POST -Trata al documento como un ejecutable
solicitud | -informacion incluida en la peticion
| -Encapsula mensajes multiparte en el cuertpo de las solicitudes
| va en el cuerpo de la peticion
|HEAD -Realiza la peticion del encabezado de un docuo
ento
version 1.1
put - Reemplazar el contenido del documento especificado con los datos
enviaddos por el cliente
delete - la pagina especificada se borre del servidor
options - el servidor devuelve sus requisitos al cliente
trace - Devuelve la informacion de manera en que llefg el mensaje
Conexion con el puerto 80
Peticion del cliente
- metodo de peticion
- Encabezado de la peticion(MIME)
- datos de la peticion cuquis
Esperar respuesta
Cierre de la conexion
CONTENEDORES Y APLICACIONES
Un modelo de programacion y API (da una serie de interfaces)
Soporte de periodo de ejecucion del lado del servidor
Soporte de la implementacion (web.xml)
Servlets,JSP y Aplicaciones WEB
Un contenedor web
Extructura de empaquetado y descriptores de implementacion
Servlets
Logica de aplicacion durante la generacion de respuestas
El contenedor actua de interfaz con el servidor web aceptando solicitudes para l
os servlets
Proceso
Java Server Pages
Documentos de case textual
Pares:
HTML o XML para contenido estatico
Etiquetas y scriptles que escapsulan la logica de negocio
Plantilla para producir contenido
JSP basada en compilacion de la pagina
ASP evaluadas en tiempo de ejecucion
DESCRIPTOR DE DESPLIEGUE
informa del servlet al contenedor web
/WEB-INF/web.xml
Iniccializacion parametros para servlets
Definiciones de servlets
Tipos MIME
Seguridad (quien puede acceder a ese servlet
Estructura aplicaciones web
Directorio publico ne nuestro classpath, Recursos estaticos publicos
Directorio privado /WEB-NF solo el contenedore web podra aceder a esta carpeta
/classes -> donde guardaremos los servlets
/LIB
se empaqueta en documentos con extension .ear o .war ej empaquetador es jar.exe
J2EE Empresarial que se auxilia de la version J2SE
API
El paquete javax.servlet.* es independiente del protocolo
El paquete javax.servlet.http.*; depende del protocolo
Analisis
Implementacion
Configuracion
Execpciones
Solicitudes y respuestas
localizar sesion
Contexto
Colaboracion de los servlets
filtrado
implementacion
Interface servlet
- contrato entre el contenedor y el servlet
- Init()
public void init(ServletConfig)
Aceder a los datos de configuracion
Leer datos de los recursos persistentes
-Invocado una vez que se ha instanciado el servlet
- Service()
invocado en respuesta a solicitudes entrantes
public void service(ServletRequest,ServletResponse)
--------- ---------
entrada-> peticion respuesta <- salida
- Destroy()
public void destroy()
destruir la instancia
invocado antes de eliminar una instancia
Da tiempo a los hilos de service()
Realiza tareas de limpieza y mantener estado
getservletConfig() informacion del contexto

La clase GenericServlet es una classe abstracta qu implementa los interfaces:
los siguientes metodos
Destroy() Service() init() log() getServletContext()
Service() es el metodo abstacto
Es Abstarcta
.
.
.
.
.
..
Interfac Single ThreadModel

Metodo service() no esta a salvo de hilos
Solo un hilo se ejecuta, se crea una cola
Reserva de instancias
Serializacion de solicitudes
Realiza un Synchronized para el metodo
service()
La clase HttpServlet
heredaremos de esta clase
abstact class HttpServlet extends GenericServlet implements Serializable
Implementacion especifica de http
Service()
-publico la implementacion de GenericServlet
- Protected e invoca la metodo anterior
Tipo de solicitud
- getMethod()
- doTrace()
- doPut()
el cuerpo del programa lo escribiremos en un
- doPost()
o
- doGet
Configuracion de los Servlets
Interfaz ServletConfig
* getlnitParameter(String)
* getlnitParameterNames()
* getServerContext()
* getServerName()
Clases
*ServletException
- Lanzada por init(),service(),doXxx() destroy()
- Throwable ge
Ciclo de vida
init() inicio
service() ejecucion
destroy() DESTRUCCION
SOLICITUDES Y RESPUESTAS
Interfaz ServletRequest
Abstraccion de las solicitudes de un cliente
Solicitar parametros
- getParameter(),getParameterValues()
- getParameterNames(),getParameterMap()
Atributos de la solicitud
- Elemento del lenguaje nominado
- getAttribute(),getAttributeNames()
- setAttribute(),removeAttribute()
Metodos de entrada
- getlnputStream(),getReader()
- getCharacterEncoding(),setCharacterEncoding()
Interfaz HttpServletRequest
con esta interfaz hablamos con HTTP
Metodossolici
..
.
.
..
.
..
Interfax ServletResponse (la respuesta)
Metodos tipo.
-setContentType() :tipo de datos que devuelve. (MIME)
.-setContentLength(): longitud
Metodos de salida
-getOutputStream(),getWriter()
Salida en Buffer
- setBufferSize(),getBuffersize(),resetBuffer()
- flushBuffer(),isCommited(),reset()
Interfaz HttpservletResponse()
.
..
Servlets
API
El paquete javax.servlet.*; es independiente del protocolo
El paquete javax.servlet.http.*; depende del protocolo
Análisis
Implementación
Configuración
Excepciones
Solicitudes y respuestas
Localizar sesión
Contexto
Colaboración de los servlets
filtrado
1.Implementación del servlet
Interface servlet
Contrato entre el contenedor y el servlet
Init()
- Invocado una vez que se ha instaciado el servlet
- Acceder a los datos de configuración
- Leer datos de losrecursos persistentes
Service()
- Invocado en respuesta a solicitudes entrantes
Destroy()
- Invocado antes de eloiminar una instancia
- Da tiempo a los hilos de service()
- Realiza tareas de limpieza y mantener estado
ServletConfig getServletConfig()
- Método que debe ser implementado para devolver un ServletConfig pasado a
l init()
String getServletInfo()
- Información sobre el servlet.
La clase GenericServlet
Es abstracta
Implementa Servlet, ServletConfig y Serializable
Proporciona implementación básica de Servlet
Implementaciones del interfaz Servlet
- init(): Si lo ignoramos, super.init(config)
- log(String), log(String,Throwable)
Implementaciones de ServletConfig
- getInitParameter(), getInitParamenterNames()
- getServletContext(), getServletName()
Interfaz SingleThreadModel
Método service() no está a salvo de hilos
Sólo un hilo se ejecuta
Reserva de instancias
Serialización de solicitudes
Realiza un synchronized para el método service()
La clase HttpServlet
Abstract class HttpServlet extends GenericServlet implements Serializable
Implementación específica de http
Service()
- público la implementación de GenericServlet
- protected e invoca al método anterior
Tipo de solicitud
- getMethod()
- doXxx()
getLastModified()
- Implementa operación condicional GET
2. Configuración de los Servlet
Elementos
Parámetros de configuración
Nombre del servlet
Información del contenedor (ServletContext)
Elementos del descriptor
Interfaz ServletConfig
getInitParameter(String)
getInitParameterNames()
getServletContext()
getServletName()
Obtener referencias a ServletConfig
3. Excepciones Servlet
Clases
ServletException
- Lanzada por init(),service(),doXxx() y destroy()
-Throwable getRootCause() para el registro
UnavailableException
- Indicar que el contenedor no está disponible
Ciclo de vida
4. Solicitudes y respuestas
Interfaz ServletRequest
Abstracción de las solicitudes de un cliente
Solicitar parámetros
- getParameter(), getParameterValues()
- getParameterNames(), getParameterMap()
Atributos de la solicitud
- Elemento del lenguaje nominado
- getAttribute(), getAttributeNames()
- setAttribute(), removeAttribute()
Métodos de entrada
- getInputStream(),getReader()
- getCharacterEncoding(), setCharacterEncoding()
Clase ServletRequestWrapper
Implementación del interfaz
Interfaz HttpServletRequest
Métodos solicitar URL
- getPathInfo(), getPathTranslate(), getServletPath()
- getQueryString(), getRequestURL()
Métodos para las cabeceras
- getHeader(), getHeaders(), getHeaderNames()
-getMethod()
Interfaz ServletResponse
Métodos tipo de contenido y longitud
- setContentType(), setContentLength()
Métodos de salida
- getOutputStream(), getWriter()
Salida en buffer
- setBufferSize(), getBuffersize(), resetBuffer()
- flushBuffer(), isCommited(), reset()
Interfaz HttpServletRespons
Manejo de errores
- sendError(), setStatus()
sendRedirect() notificación 302 al cliente de desvío temporal
5. Sesiones
Protocolo
Aplicación atómica y tienda online
Distinguir usuarios
Contexto es una visión de la aplicación y el contenedor
HTTP sin estado
Instalaciones: sesión y estado
Recordar usuarios e información de la sesión
Enfoques del registro de sesión
Reescritura URL
- action de tipo GET
- parámetro pasado al contenedor
- jsessionuid testigo según la especificación
Campos de formularios ocultos
- type es hidden
- La especificación no contempla este tipo
Cookies
- Es un pequeño fragmento de información textual enviado por el servidor al
cliente y devuelto por el cliente para todas las solicitudes del servidor RFC210
9
- Contiene pares valor-nombre en las cabeceras
- Set-cookie (uid,max-age,domain )
- Respuesta es una cabecera Cookie:
- El contenedor genera automaticamente un jsessionid
- Deshabilitación del navegador
- javax.servlet.http.Cookie
La API Java Servlet
Creación y registro de sesiones
Métodos de la HttpServletRequest
HttpSession getSession(boolean)
HttpSession getSession()
El objeto HttpSession representa la posibilidad del contenedor de asociar una co
licitud a un cliente
Transparenvia en los procesos
Interfaz HttpSession
Métodos para la vida de la sesión
- getCreationTime(), getId(), getLastAccessTime()
- getMaxInactiveInterval(), setMaxInactiveInterval()
- isNew(), invalidate
- <session-config> en el descriptor
- <session-timeout>
Métodos de gestión del estado
- getAttribute(), setAttribute(), removeAttribute()
- getAtributeNames()
Manejo de eventos de ciclo de vida de sesión
Introducción
Creación e invalidación de la sesión
Pasivación y activación
Inactividad en el tiempo
Transferir de una JVM a otra
Interfaces
Interfaz HttpSesionListener
sessionCreated(), sessionDestroyed()
Explicitar la clase en el descriptor
<listener> <listener-class>
Interfaz HttpSesionActivationListener
sessionDidActivateCreated(), sessionWillPassivate()
La clase HttpSessionEvent
Evento para los escuchantes
getSesion()
Manejo de eventos para atributos de sesión

Introducción
Escuchantes basados en las siguientes actividades
Añadir atributo a sesión
Reeemplazar atributo
Eliminar atributo
Interfaces
HttpSessionBindingListener
valueBound(),valueUnBound()
HttpSessionAttributeListener
attributeAdded(), attributeRemoved(), attributeReplaced()
La clase HttpSessionBindingEvent
getName(), getValue(), getSession()
6. Contexto
El contexto
Define la vista de un servlet
Proporciona acceso comunes a todos los servlet de la aplicación
Particular de cada JVM
Estado común a todos los servlets y clientes de la aplicación
ServletContext
Se obtiene de ServletConfig con getServletContext()
Interfaz ServletContext
getMimeType()
getResource()
getResourceAsStream()
getRequestDispatcher()
getNamedDispatcher()
getRealPath()
getContext()
log
getServerInfo()
getServletContextName()
getResourcePaths()
getInitParameter()
getInitParameterNames()
getAttribute()
getAttributeNames()
setAttribute()
removeAttribute()
Manejo de eventos de ciclo de vida de ServletConfig
Interfaz ServletContextListener
contextInizialized(), contextDestroyed()
<listener>
Interfaz ServletContextAttributeListener
attributeAdded(), attributeReplaced(),a ttributeRemoved()
Las clases de eventos
ServletContextEvent
ServletcontextAttributeEvent
7. Colaboración de servlet
Intro
EL servlet delega el procesamiento en otro servlet
Tipos de soluciones
Encadenado de servlet
No se ajusta a la especificación
Invoca los servlets en el orden especificado
Lanzamiento de solicitud
Lanzar la solicitud a otro encargado de generar respuesta
Obtener referencia del segundo servlet
Interfaz RequestDispatcher
metodo getRequestDispatcher()
Encapsula la referencia a otro servlet
forward() -> inica a que servlet,pagina,jsp se quiere llamar,peticion
y respuesta
como obtener un metodo Dispatcher:
getServletContext().getRequestDispatcher()("/fecha\fechaet").forward( req,res);
include()
Obtener un objeto
ServletContext con ruta absoluta
ServletRequest con ruta relativa
getNameDispatcher accede a <servlet-name>
8. Filtrado
Introducción
Interactuar con las solicitudes y respuestas antes de que que el contenedor invo
que los recursos
Contenedor intercepta solicitudes
Participan en el proceso de interceptación
Confía en el orden
Posibilidades que ofrecen los filtros
Validar solicitudes
Solicitudes de registro
Autorizar solicitudes
Gestión del contenido
Modificar objetos de solicitud
interfaces
Filter
Init(), doFilter(), destroy()
Instanciar, inicializar, invocar y dertruir
FilterConfig
getFilterName(), getServletContext()
getInitParameter(), getInitParmeterNames()
FilterChain
doFilter()
Invoca al siguiente filtro de la cadena
Descriptor de despliegue
<filter>
<filter-name>
<filter-class>
<init-param>
<filter-mapping>
<filter-name>
<url-pattern>
Redireccionar RequestDispatcher()
ejemplo
import javax.servelet.http.* ; libreria
// heredamos de la clase httpServlet
public class GreetingServlet extends httpServlet
{
public void doGet(HttpServletRequest req, HttpServletResponse res)
{
String nombre=req.getPArameter("txtnombre");
String apellido=req.getPArameter("txtapellido");
String resultadoi=" Holo Sr. " +nombre+" "+apellido;
res.setContextType("txt/html");
PrintWriter at=res.getWriter();
out.print("<html><body>");
out.print(resultado);
out.print("</body></html>");
out.close();
}
}
-------------------------------------------------------------------------------
empaquetar el programa con extension ear
creamos web.xml
Desde consola:
c:\> deploytool
file\new\aplication
c:\javacarlos\Holamundo.ear
HolaMundo
File\ new\ New WEb Component
edit
Contents of WebApp1
* Servlet
Servlet Class:
HolaMundoServlet
Add Server
localhost
aqui desplegamos en el servidor web
Tools Deploy
Consex Root -> redirecionar a un directorio virtual
WebApp1 /greeting
Deployment Progres
|directorio virtual
http://localhost:8000/greating/servlet/HolaMundoServlet
----------------i
IP.dns:puerto
----------------------
abrimos iotra consola
c:\> j2ee -verbose
con esta instruccion arrancamos el servidor
pagina html de inicio.
=req.getPArameter("txtapellido");
.
login.html
login
pwd
logasrse borrar nuevo
nuevocliente.html
Nombre
Apellido
Dni
Provincia(combo)
CP
login [pwd] [repite pwd]
ok borrar
loginApp.java mirar en la base de datos

mirar en la base de datos nombre y password y mostrar por pantalla el dni
NuevoCliente
insertar en la base de datos
tres tablas
Dni Login PWD
DNI NOMBRE APELLIDO CP
COD PROVGINCIA
ver:
heloweb en:
http://developers.sun.com/
SESIONES
http -> protocolo sin estado , comunicacion entre diferentes paginas
distinguir a los diferentes usuarios. JSesionId
recordar el estado (guardar los datos cogidos de otras paginas)
para mentener la informacion se hace con los enfoques
Rescritura Url
- action de tipo GET
- campos de formularios ocultos
-type es "hidden"
-La especificacion no contempla este tipo
cookies
Metodos de gestion del estado

session=req.getSession()
objet Session.getAttribute("articulos")
Arraylist a= .... .....
Session.setAttribute("articulos",Object)
Arraylist a=(Arraylist) Session.getAttribute("articulos")
J S P
=====
Logica de usuario presentacion (salida cliente)
Logica de negocio (peticion)
Logica de acceso a datos i
Scriptles->
JSP: programas Java en páginas web
Una aplicación web normalmente requerirá que haya un programa funcionando en el
lado del servidor.
Este programa podría estar escrito en diferentes lenguajes, aunque nosotros
emplearemos Java.
Por tanto, necesitamos un servidor web que soporte la ejecución de aplicaciones
Java.
Aunque a nivel comercial hay un número considerable de servidores de este tipo,
utilizaremos uno de tipo open source denominado Tomcat.
Arranque y prueba de Tomcat
Para arrancar Tomcat hay que ir al menú de Inicio > Programas > Apache Tomcat
4.1 > Start Tomcat
Abrirá una ventana de MS-DOS en la que, tras dar una serie de mensajes de
arranque, queda a la espera.
Para probar el servidor, hay que abrir una ventana del navegador y teclear la si
guiente dirección
http://localhost:8080 Ya que tenemos al servidor funcionando en nuestra pr
opia máquina (localhost)
y este por defecto espera las conexiones por el puerto 8080 (de este modo, se p
uede arrancar el Tomcat
sin privilegios de root en sistemas que tengan seguridad, ya que el uso de puert
os por debajo de 1024 suele estar restringido).
Con esto, debería aparecer la página inicial con la documentación de Tomcat indicando
la versión del servidor que se está ejecutando (en nuestro caso la 4.1.27).
Aplicaciones web con Tomcat
Para que el servidor Tomcat pueda encontrar y ejecutar una aplicación web adecuada
mente, se deben cumplir dos condiciones:
La aplicación será una carpeta colocada en un directorio especial del servidor. En n
uestro caso el Tomcat utiliza el subdirectorio webapps. Dentro de este hay tanta
s carpetas como aplicaciones distintas tiene instaladas el servidor
Para que la carpeta que coloquemos en webapps sea reconocida como tal aplicación,
es necesario que contenga un directorio llamado WEB-INF (IMPORTANTE: el nombre d
ebe estar en mayúsculas). Dicho directorio contendrá a su vez dos subdirectorios: WE
B-INF/classes, donde se colocarán las clases Java compiladas y WEB-INF/lib donde s
e colocarán las librerías JAR que use la aplicación. Los fuentes (.java) no son necesa
rios para que la aplicación funcione.
Crear una página JSP
Una página JSP no es más que una página HTML que tiene incrustado código Java. Las páginas
JSP forman parte de una aplicación web. Por tanto, tienen que colocarse en una ca
rpeta dentro del directorio webapps, y esta carpeta debe tener una subcarpeta WE
B-INF.
La diferencia entre este código y el que ejecutábamos hasta el momento es básicamente
de dónde se obtiene la entrada y adónde se envía la salida.
Los programas vistos hasta el momento toman la entrada de la línea de comandos y e
nvían su salida a la salida estándar. Los programas que se ejecutan en el servidor w
eb toman su entrada de la petición HTTP que manda el cliente y envían su salida medi
ante una respuesta HTTP. A nivel de programación la diferencia está en las funciones
a emplear para obtener la entrada y enviar la salida:
Obtener la entrada
En línea de comandos: array args
En web: método request.getParameter(nombre-parámetro)
Enviar la salida
En línea de comandos: System.out.println(mensaje)
En web: out.print(mensaje)
Para que Tomcat reconozca el código incrustado en el HTML como Java, hay que poner
lo entre símbolos <% y %>. Así por ejemplo, el programa HolaUsuario en versión JSP sería
<%@page import="java.util.*" %>
<html>
<head> <title>HolaUsuario</title> </head>
<body>
<%
Date actual;
actual = new Date();
out.print("Hola " + request.getParameter("usuario"));
out.print("hoy es " + actual.toString());
%>
</body>
</html>Para probar este programa, hay que crear una nueva aplicación web en Tomc
at. Esto se hace creando una nueva carpeta dentro del directorio webapps de Tomc
at (llamadla como vuestro login de correo de la UA). Dentro de esta carpeta hay
que crear la carpeta WEB-INF, que por el momento puede estar vacía. Finalmente, gu
ardar el código anterior en un fichero llamado holausuario.jsp dentro de la carpet
a llamada como vuestro login.
Este programa habría que ejecutarlo llamándolo desde un navegador tecleando como URL
algo como:
http://localhost:8080/tu-login-de-correo/holausuario.jsp?usuario=Pepe
Nótense las principales diferencias entre el código de la versión en línea de comandos y
la versión JSP
La instrucción import se ha sustituido por la de <%@page import %>
Se ha extraído lo que es el código del método main, sin poner la definición de este ni e
l nombre de la clase. Este "contexto" ya lo pone Tomcat automáticamente, lo único qu
e nos interesa son las instrucciones a ejecutar. El código Java va entre los símbolo
s <% y %>.
La entrada, en lugar de obtenerse mediante el array args se obtiene mediante el
método request.getParameter(). Además, en línea de comandos, los argumentos se obtiene
n por posición mientras que en HTTP tienen un nombre
La salida se escribe mediante out.print() en lugar de System.out.println()
Ejercicio: creación de la página pelicula.jsp
La página pelicula.jsp es la que en el sitio web de los cines debe mostrar los dat
os de una película. Por el momento en vuestro sitio web esta página es pelicula.htm,
pero esta página es estática y necesitamos que los datos de la película se obtengan d
e la base de datos.
La página pelicula.jsp en realidad es el equivalente del programa en línea de comand
os BuscaPelicula.java. Para crear la página habrá que seguir estos pasos:
Tomar el fichero original pelicula.htm y renombrarlo a pelicula.jsp. Como la págin
a tiene que estar en una aplicación web, copiarla en la carpeta que habéis creado de
ntro de webapps en el apartado anterior.
Dentro de WEB-INF crear otra carpeta llamada lib y allí copiar el JAR con el drive
r de la base de datos, mysql.jar. De esta forma Tomcat podrá encontrarlo cuando ej
ecute la página.
Añadir como primera línea un <%@page import="java.sql.*"%> que es el equivalente al
import java.sql.* de BuscaPelicula.java
A continuación, copiar el código del método main del fichero BuscaPelicula.java en la
página pelicula.jsp, colocando el código java entre los símbolos <% y %>
Sustituir la referencia a args[0] por una instrucción request.getParameter("id").
Sustituir los System.out.println() por out.print(). Para que este último paso prod
uzca una página similar a la original, hay que mezclar estas sentencias con el códig
o HTML que ya teníamos. Por ejemplo, supongamos que en la página original el título de
la película salía en una celda de una tabla
...
<td> Matrix Revolutions </td>
...
El nuevo código será algo como
...
<td> <% out.print(res.getString("titulo");%> </td>
...
Para abreviar el código puede utilizarse el "truco" de que hacer out.print es lo m
ismo que poner el código entre <%= y %> en lugar de <% y %>. Así, lo anterior sería eq
uivalente a
...
<td> <%= res.getString("titulo") %> </td>Para probar la página habrá que irse al nav
egador y solicitar la URL pelicula.jsp, que estará dentro de la carpeta llamada co
mo vuestro login, y a la que le pasamos un parametro id con el código de la película
a visualizar (por ejemplo 1):
http://localhost:8080/tu-login-de-correo/pelicula.jsp?id=1
Las imágenes con los carteles de las películas se colocarán dentro del directorio de l
a aplicación web en un subdirectorio imag (aquí tenéis las imágenes comprimidas). Se uti
liza la convención de que el nombre de la imagen siempre es el identificador de la
película con extensión jpg. Así, para generar la etiqueta img que visualice el cartel
habrá que hacer algo como
<img src="<%=res.getString("id")%>.jpg">

Java TXT

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Java TXT

Încărcat de

Drepturi de autor:

Formate disponibile

*******************************************************************

CURSO: PROGRAMADOR DE APLICACIONES DE REDES NUMERO: 2830

VARIABLES-> GUARDAR EN MEMORIA UN VALOR

Tipo de variable(define el tama¤o)

int [][] m={{2,4,3,4},{1,3},{2,3,5}}; Este es el ARRAY BIDIMENSIONAL m

la funcion mas importante es:

public static void main (String[] arg)

int suma(int x, int y)

private -> solo podran acceder a el desde la propia classe

public -> desde cualquier lado podremos acceder se puede poner

j2sdk1.4.2 35Mb -> JAVA Ver 2

c:\jsdk1_nb\j2sdk1.4.2\doc\ -> Documentacion (APIs)

Inicio\Mi Pc\BD\Propiedades\Opciones Avanzadas\Variables de entorno

Crear un empleado llamando al metodo constructor, se crea la extructura "e".

public final boolean esMenor(Figura f){

/** Creates a new instance of X */

HASTA AHORA TENIAMOS :METODO DE INSTANCIA Y METODO ESTATICO

bolean palidromo() ; ver si la cadena es capicua

cadena cad1=new cadena(c1);-> esto es un objeto

java.lang hereda de java.lang.Object

exit() termina los procesos.

Clase System -> para comunicarse con el S.O.

Clase Math ; no tiene metodo constructor

CALCULAR 50000 DIAS A PARTIR DE LA FECHA 1/1/1900

LISTAS DOBLEMENTE ENLAZADAS Linkedlist

LISTAS DOBLEMNENTE ENLAZADAS O CIRCULARES.

ARBOL -> no tenga ciclos

| |puntero al nodo izquierda

| Arrylist -> evolucion de la clase vector no sincronizado

CLASIFICACION POR INTERCAMBIO DIRECTO (BULBUJA)

1- comparar pares de elmento contiguos

| TextArea varias lineas(wordpad)

| panel divisiones de un container <- Applet se ejecutan en el

extends hereda de Frame.

WindowAdapter implements Windowslistener

rear un boton los componentes se suelen deficnir como globales.

existe public Static void main

javax.Swing heredan de java.awt

ALCANCE DE OBJETOS Y RECICLADO DE MEMORIA

VARIABLES Y METODOS ESTATICOS

public class MiClase {

Si se necesita llamar al metodo padre dentro de una clase que ha reemplazado

Si un fichero fuente Java no contiene ningún package, se coloca en el paquete por

El paquete de entrada/salida contiene las clases de acceso a ficheros:

Este paquete da soporte a las conexiones del protocolo TCP/IP y, ademas,

Este paquete es una miscelanea de clases utiles para muchas cosas en

Almacenar datos, capturar texto de teclado y devolver a monitor.

ByteArrayImputStream -> array de bytes |Arraybytes|

para controlar las excecpciones

BufferedReader teclado=new BufferedReader(new ImputStreamReader(System.in))

public Empleado(String n,String a){

Reader -> para 16 bit unicode

Empleado e1=new Empleado(nombre,apellido);

| objeto del flujo

String nombre=" ";

BufferedReader fichero=new BufferedReader(new InputStreamReader("fich.txt"));

si ponemos{ ;} no nos mostraria el error haria nada

RuntimeException -> excepciones de error en operaciones

Datbase management System

DataSource: arquitectura flexible para conexiones. Oculta URL puerto servidor..

Group By[c1,.., ck]

Entidad es un objeto, una tabla, ej: tcliente

colocar al principio las que contengan menos valores dupicados