© 1996 Descarado Software Limited Co..
Si quieres comentarme algo, hazloen Jose Arcos ó en mi dirección de FidoNet 2:346/207.68
Saludos amigos de la lista,
Pese a toda la carga de trabajo que tenemos encima, siempre tratamos de cumplir
con todos ustedes, hace una semana que no abrimos el correo espero que aun sigan
alli, bueno sin mas ni mas aqui va la leccion #3.
====================Leccion #3============================
OCULTAMIENTO Y ENCAPSULACION DE DATOS
---------------------------------------------------------------------
Anteriomente describimos una clase como "una coleccion de datos y metodos". Una
de las mas importantes tecnicas que no hemos tocado hasta este momento es el
ocultamiento de datos dentro de una clase, y hacer que esten disponibles (los
datos ocultados) solamente atravez de los metodos. Esta tecnica es usualmente
conocida a menudo como ENCAPCULACION por que este cierra hermeticamente los
datos de la clase dentro de la capsula de seguridad, los cuales solo pueden ser
accesados por usuarios que tengan derechos -de acceso- para los metodos de la
clase.
Aqui algunas de las razones para ocultar datos :
Una clase contiene un numero de variables que son interdependientes y deben
tener un estado consistente.
Si permites a un programador (que puedes ser tu mismo) manipular esas variables
directamente la clase puede entrar en un estado inconsistente y funcionar
inapropiadamente.
Cuando todas las variables de la clase estan ocultas y los metodos son la unica
posibilidad para cambiar los valores de las variables -ocultas- en objetos de la
clase todo funciona bien. Por que si mediante un metodo
tratamos de cambiar un valor para una variable y el valor no es correcto el
metodo tiene la facultad para rechazarlo.
* Si nosotros permitimos que las variables sean directamente manipuladas, sin
intervencion de los metodos de la clase, el numero de posibilidades que tienes
que comprobar se vuelve inmanejable.
Las variables que son visibles externamentea la clase
Si una variable es visible en tu clase, entonces debes documentar esta. Una
manera de ahorrar tiempo en la documentacion es ocultar esta al usuario de la
clase.
Control de Acceso a los Metodos.
----------------------------------------
Cuando se declara un metodo, dentro de una clase Java, Usted puede permitir o
bloquear que otras clases y objetos puedan llamar a los metodos para esto tendra
que hacer uso de los especificadores de acceso.
Java soporta 5 diferentes niveles de acceso para los metodos los cuales son:
private
private protected
protected
public, y ademas "friendly"
veamos la siguiente tabla:
sub- pack-
Specificador clases clases age world
----------------------------------------------------- private X
private protected X X
protected X X* X
public X X X X
friendly X X
La X de la primera columna indica que la clase misma puede llamar al metodo
definido con el especificador private.
La X de la segunda columna indica que la subclase de la clase puede llamar al
metodo especificado como private protected.
La tercera columna indica que la clase como las clases del mismo paquete pueden
llamar al metodo.
Y la cuarta columna indica que cualquier clase puede llamar al metodo.
Private
-------
En este nivel nivel de acceso, solo la clase que contiene al metodo puede
llamarlo para declarar un metodo privado utilizamos la palabra reservada private
ejemplo:
class prueba {
private void texto1() {
System.out.println("como se ve..");
}
}
Los objetos de tipo prueba, pueden llamar al metodo texto1, pero los objetos de
otro tipo no pueden hacerlo.
Private Protected
-----------------
Este nivel de acceso incluye el acceso private, ademas permite que cualquier
subclase de la clase pueda llamar al metodo.
La siguiente clase esta definida como private protected:
class prueba2 {
private protected void texto2() {
System.out.println("y ahora como se ve..");
}
}
Los objetos del tipo prueba2, pueden llamar al metodo texto2(), ademas las
subclases de prueba2, tambien tienen acceso a texto2().
Por instancia, la subclase de prueba2, subprueba puede llamar al metodo texto2()
de un objeto prueba2.
class subprueba extends prueba2 {
void maspruebas(prueba2 a) {
a.texto2();
}
}
Protected
---------
Este nivel permite que la clase, las subclases y todas las clases en el mismo
paquete puedan llamar al metodo.
veamos un ejemplo:
package curso;
class leccion3 {
protected void contenido() {
System.out.println("Imprimiendo..baaa");
}
}
ahora supongamos que otra clase, llamada leccion4, sera declarada miembro del
paquete curso la clase leccion4, puede llamar al metodo contenido() declarado
dentro de la clase leccion3, porque esta dentro del mismo paquete.
package curso;
class leccion4 {
void Metododeacceso() {
leccion3 a = new leccion3();
a.contenido();
}
}
Public
------
Cuando los metodos son publicos todas las clases tienen acceso a ellos.
package curso;
class leccion3 {
public void contenidopub() {
System.out.println("todos pueden ver los contenidos");
}
}
package html;
class leccion4 {
void metododeacceso() {
leccion3 a = new leccion3();
a.contenidopub();
}
}
Como se ve podemos llamar al metodo contenidopub() en la clase leccion3.
Friendly
--------
Veamos un ejemplo:
package curso;
class A {
void invitado() {
System.out.println("Como estan amigos");
}
}
La clase A, puede llamar al metodo invitado(), pero ademas todas las clases
declaradas dentro del mismo paquete curso, pueden llamar al metodo invitado().
El Metodo main()
-----------------
escriba este codigo en cualquier editor de textos, guardelo como fecha.java
import java.util.Date;
class fecha {
public static void main(String args[]) {
Date hoy = new Date();
System.out.println(hoy);
}
}
Explicando........
public static void main(String args[])
Como se podra ver el metodo main() contiene tres modificadores
public:
Indica que el metodo main(), puede ser llamado por cualquier objeto, ya lo
explicamos arriba.
static:
Indica que el metodo main() es una clase metodo.
void:
Indica que el metodo main(), no retorna valores.
En java cuando se ejecuta una aplicacion el interprete de java (java.exe) inicia
con el metodo main(), el metodo main(), llama entonces todos los otros metodos
requeridos por la aplicacion.
*****Utilize el compilador javac, con su archivo fecha.java, luego si todo esta
Ok, con el interprete de java escriba: java classname(sin extension) para
visualizar el resultado.
Argumentos del metodo main()
----------------------------
public static void main(String args[])
Este arreglo de cadenas es el mecanismo mediante el cual el sistema, en tiempo
de ejecucion pasa informacion a la aplicacion cada cadena en el arreglo es
llamada como un comando de linea. mas abajo explicaremos acerca de cadenas y
arreglos.
Variables y Tipos de Datos
--------------------------
Todas las variables del lenguaje Java, soportan un tipo de dato, en los que se
incluyen: Enteros, punto flotante, caracter, y boolean.
Tipo
byte 8-bit
short 16-bit
int 32-bit
long 64-bit
float 32-bit
double 64-bit
char 16-bit
Operadores Aritmeticos
-----------------------------
Java soporta varios operadores aritmeticos incluyendo Adicion(+),
Substraccion(-) Multiplicacion(*), Division(/) y Resto(%) por ejemplo:
x++ <==> Si : a=1 y se efectua : y=a++, luego y=1, a=2 y-- <==> Si : a=1 y se
efectua : y=a--, luego y=1, a=0
++x <==> Si : a=1 y se efectua : y=++a, luego y=2, a=2 --y <==> Si : a=1 y se
efectua : y=--a, luego y=0, a=0
otras operaciones tambien son :
y*=a + 1 que es lo mismo que : y = y * a + 1 y/=a*3/4 que es lo mismo que : y =
y / (a * 3 / 4)
El orden de evaluacion de operadores en expresiones es : se evalua
multiplicaciones y divisiones, luego sumas y restas.
Operadores de Relacion
----------------------------
Los operadores de relacion comparan 2 valores y determinan la relacion entre
ellos, por ejemplo:
a != b (a diferente de b?)
a > b, a >= b (a mayor que b, a mayor o igual que b) a < b, a <= b
a = b
operadores logicos
------------------------
los operadores logicos tienen 2 valores que representan las operaciones logicas
entre dichos operadores tenemos:
&& ==> Y Logico
|| ==> O Logico
Por ejemplo:
if (0 < edad && edad < edad_max)
verifica la edad de una persona entre el rango <0,edad_max>
ARRAYS
------------
Mucho de lo que se ha aprendido en lo que se refiere a tipos de datos y objetos
es aplicable a los arreglos en Java.
- Los arrays son manipulados por referencia - Son creados con new
- Son enviados automaticamente al colector de basura cuando dejan de ser usados
Creando y destruyendo Arrays
-------------------------------------
Hay dos maneras de crear arrays en Java. La primera usa new, y especifica que
tan grande debe ser el array :
byte buffer_octetos[] = new byte[1024];
Button botones[] = new Buttons[10];
Cuando se crea un aray de esta forma no se crean los objetos que son almacenados
en el array, no hay un constructor para llamar, y la lista de argumentos es
omitida con la palabra new. Los elementos de un array creados de esta menera con
el valor por defecto del tipo. Los elementos de un array de int son
inicializados a 0, por ejemplo, y los de un array de objetos a null (no apuntan
a nada).
La otra manera de crear un array es mediante un inicializador estatico que tiene
la misma apariencia que en C :
int tabla[] = {1,2,4,8,16,32,64,128};
Esta sintaxis crea un array dinamicamente e inicializa sus elementos a los
valores especificados. Los elementos especificados en la inicializacion de un
array deben ser expresiones arbitrarias. Esto es diferente que en C, donde deben
ser expresiones constantes.
Accesando a elementos de un Array
-------------------------------------------
El acceso a elementos de un array en Java es similar a C, se accesa a un
elemento del array poniendeo una expresion de valor entero entre corchetes
(nombre_array[valor_entero]) despues del nombre del array :
int a[] = new int[100];
a[0] = 0;
for (int i = 1; i < a.length; i++)
a[i] = i + a[i - 1];
en todas las referencias a los elementos del array el indice es chequeado
constantemente. este no debe ser menor que cero ni mayor que el numero de
elementos del array menos 1.
en el ejemplo anterior los elementos de a estarian en el rango (0..99).
si el indice especificado no esta en el rago se genera un error de excepcion
(arrayindexofboundsexception) pero no interrumpe la ejecucion del programa sino
que ejecuta una seccion de codigo previamente escrita para tratar este error y
luego continua con la ejecucion. esta es una de las maneras en que java trabaja
para prevenir bugs (bichos) y problemas de seguridad.
arrays multidimensionales
-------------------------------
java tambien soporta arrays multidimensionales. estos son implementados como
arrays de arrays, similar a c. se especifica una variable como un tipo de array
multidimensional simplemente agregando un segundo par de corchetes al final del
par anterior. la dimension de los arrays se especifica entre los corchetes con
un valor para cada dimension.
ejemplo :
byte arraydosdim[][] = ew byte[256][16];
cuando creas un array multidimensional es opcional especificar el numero de
elementos contenidos en cada dimension, por ejemplo :
int arraytresdim = new int[10][][];
este array contiene 10 elementos, cada uno de tipo int[][]. esto quiere decir
que es un array de una sola dimension, cuando los elementos del array sean
inicializados recien pasara a ser multidimensional. la regla para este tipo de
arrayses que las primeras n dimensiones (donde es almenos una) debe tener el
numero de elementos especificado, y esas dimensiones deben ser seguidas por m
dimensiones adicionales que no tengan un tama¤o de dimension especificado.
la siguiente declaracion se considera legal :
string conjunto_strings[][][][] = new string[5][3][][];
esta declaracion no se considera legal :
double temperature_data[][][] = new double[100][][10];
* ejemplo de creacion e inicializacion de un array multidimensional :
short triangle[][] = new short[10][];
for (int i = 0; i < triangle.length; i++) {
triangle[i] = new short[i+ 1];
for (int j = 0; j < i + 1; j++)
triangle[i][j] = i + j;
}
asi mismo se pueden declarar y inicializar arrays de esta manera :
static int[][] dosdim = {{1,2},{3,4,5},{5,6,7,8}}
¨ son los arrays objetos ?
-----------------------------
la evidencia sugiere que los arrays son, en realidad objetos. java define
bastante sintaxis especial para arrays, no obstante, para referenciar arrays y
objetos se utilizan maneras distintas.
strings
------------
los strings en java no son arrays de caracteres terminados en null como en c. en
vez de ello son instancias de la clase java.lang.string. un string es creado
cuando el compilador de java encuentra una cadena entre comillas("").
toda la teoria especificada para la creacion de tipos de objetos dicha
anteriormente es aplicada aqui mismo.
Si quieres comentarme algo, hazlo