RSS

Archivo de la categoría: Tema 1

Declaración y control de acceso (V)

Declaración de un array

Los arrays se usan normalmente para agrupar objetos del mismo tipo. Permiten hacer referencia al grupo de objetos a través de un nombre común.

Es posible declarar arrays de cualquier tipo, ya sea de tipos primitivos o tipos de referencia.

En cualquier caso, un array en Java es un objeto incluso cuando esté compuesto de tipos primitivos.

Como en el caso de otros tipos de clase, la declaración del array no crea el objeto en sí. La declaración de un array crea una referencia al array. La memoria utilizada por los elementos del array se asigna de forma dinámica mediante una sentencia new o mediante el inicializador del array.

La sintaxis de declaración es:

tipoElementos [] nombreArray;
tipoElementos nombreArray [];

Las dos opciones son válidas. Aunque se suele recomendar los corchetes a la izquierda por ser más legible y porque éstos se aplican a todas las variables a la derecha de ellos.

int [] puntuacion, puntuacionMaxima; //Recomendada
int puntuacion[], puntuacionMaxima [];

En la declaración no se debe indicar el tamaño concreto del array, dará error de compilación. Veremos esto más adelante en la construcción e incialización de arrays.

Tipos Enumerados

Una práctica habitual en programación es tener un número finito de nombres simbólicos que representan los valores de un atributo.
Por ejemplo para representar los colores de un semáforo: ROJO, AMARILLO, VERDE.

A partir de la versión 5.0, Java SE incluye una modalidad de tipos enumerados que mantiene la seguridad de los tipos.

Veamos un ejemplo de declaración:

public class Semaforo {
enum ColorSemaforo{
 ROJO,
 AMARILLO,
 VERDE
 };// el punto y coma es opcional en la declaracion de enums.
 ...

Habría que pensar en el tipo Semaforo como en una clase con un conjunto finito de valores que reciben los nombres simbólicos incluidos en la definición del tipo. Los valores serían realmente instancias de esa clase. El compilador no permitirá que pueda asignarse otro valor diferente a los especificados.

El orden en el que definamos los valores importa, pero se verá más adelante

ColorSemaforo colorActual = ColorSemaforo.VERDE; // VERDE es de tipo ColorSemaforo
ColorSemaforo colorIncorrecto = ColorSemaforo.AZUL; //provocará error de compilación.

Los tipos enumerados pueden declararse como miembro de una clase, como una clase aparte, pero nunca dentro de un método.

Declarando constructores, variables y métodos en un Tipo Enumerado

La nueva modalidad de tipos enumerados permite usar atributos y métodos, igual que en otras clases.
Un constructor enum siempre debería usar acceso privado. Los argumentos del constructor se suministran después de cada valor declarado. Los tipos enumerados pueden tener cualquier cantidad de atributos y métodos.

Para nuestro ejemplo, definamos un atributo nombreColor con un literal más amigable que las mayúsculas y un atributo segundosColor que indicará el tiempo en segundos que está activado cada color.

//Argumentos para el constructor en la declaración
public enum ColorSemaforo{
ROJO ("Rojo", 60),
AMARILLO ("Amarillo", 25),
VERDE ("Verde", 45); //Se requiere el punto y coma cuando hay
 //mas código en la definición del enum

private String nombreColor; //atributos
private int segundosColor; // atributos

//Constructor
private ColorSemaforo (String nombreColor, int segundosColor){
 this.nombreColor = nombreColor;
 this.segundosColor = segundosColor;
}

//Métodos getters
public String getNombreColor(){
 return nombreColor;
}
public int getSegundosColor(){
 return segundosColor;
}
}

Recordaremos de los constructores de tipos enumerados:

  • No se puede invocar un constructor de un enum directamente. Se llama automáticamente cuando especificamos los argumentos en la declaración de los valores del tipo enumerado.
  • Se puede definir más de un argumento para el constructor y se puede sobrecargar los constructores.
 
3 comentarios

Publicado por en 25 abril, 2011 en Estudio, Tema 1

 

Etiquetas: , , ,

Declaraciones y control de acceso (IV)

Variables

Por el tipo se pueden dividir en:

  • variables de tipos primitivos.
  • variables de tipos de referencia.

Por el lugar en que se definen:

  • variables locales (dentro de un método, parámetros del método)
  • variables miembro (fuera de un método, en la definición de la clase)
  • variable de clase (fuera de un método, en la definición de una clase, lleva la palabra static)

Tipos Primitivos en Java

Los tipos primitivos son simples valores, no objetos. Los tipos de referencia se utilizan para tipos más complejos, incluidos los que declara el propio programador.

Java define ocho tipos de datos primitivos, que se dividen en cuatro categorías:

  • Lógicos: boolean
  • Texto: char
  • Enteros: byte, short, int, long
  • Reales: float, double

Boolean

Los valores lógicos se representan mediante el tipo boolean, que puede contener uno de estos dos valores: true (verdadero) o false (falso).
Decimos que el tipo boolean admite dos valores literales: true y false.

Char

Los caracteres se representan mediante el tipo char. Un valor char representa un carácter Unicode de 16 bits sin signo. Los literales char se escriben entre ‘ ‘.

Enteros

Hay cuatro tipos de datos enteros en Java. Cada uno de ellos se declara usando las palabras clave byte, short, int o long.
Se puede representar los literales de los tipos enteros utilizando una notación decimal, octal o hexadecimal.

Por ejemplo:
70 sería 70 en decimal, 046 en octal y 0x106 en hexadecimal.

Todos los tipos numéricos en Java representan números con signo.
Por defecto  los literales enteros son del tipo int, a menos que vayan seguidos de la letra L, que indicaría que es un long.

Por ejemplo:
24L indicaría que el valor decimal 24 se representaría como un entero largo.

La tabla siguiente indica el tamaño en bits de cada tipo y su rango de valores:


Reales

Las variables de tipo real se declaran con las palabras float o double. Un literal numérico es un número real si incluye un separador decimal y un exponente, o bien si va seguido de la letra F o f (float) o de la letra D o d (double).

Los literales reales se consideran double de forma predeterminada. Es posible declarar literales del tipo float agregando F o f al valor.

Ejemplos:

5.15               Valor corto de precisión simple, pero por defecto sería double.
3.35E25          Valor largo double
4.393F             Valor corto de precisión simple (float)
76.5E800D        Valor largo double

Tabla de los reales:

Declarando variables primitivas

Pueden ser declaradas como variables de clase (static), como variables miembro o como variables locales.
Se pueden declarar en una misma linea varias variables del mismo tipo.

Ejemplos:

boolean resultado, existe, estaEncendido;   //declaraciones de variables locales
char nuevaLinea;
byte b;

public class claseX {
public static int contador = 0;      //ejemplo de declaración de variable de clase

private int codigo;                  //ejemplo de declaración de variables miembro.
private boolean hayExistencias;
...
}

Declarando variables de referencia

Pueden ser declaradas como variables de clase (static), como variables miembro o como variables locales.
Se pueden declarar en una misma linea varias variables del mismo tipo.

Ejemplos:

String nombre, direccion, provincia;    // declaración de variables de referencia locales
MiObjeto x;
Informe i;

public class Cliente{
public static Cuenta[] cuentasVIP = new Cuenta [100]; //declaración como variable de clase
private String nombre;               //declaración de variables de referencia como miembros
private Domicilio domicilioActual;
private Cuenta cuenta;
...
}

Variables Locales

Las variables que se definen dentro de un método se denominan locales, aunque algunas veces también reciben el nombre de variables temporales o de pila.

Es preciso inicializarlas antes de usarlas por primera vez, de lo contrario el compilador dará error.
Los parámetros de los métodos y los constructores también son variables locales, pero las inicializa el código de llamada.

Las variables locales se crean cuando el programa empieza a ejecutar el método y se destruyen cuando finaliza dicha ejecución.

Las variables que se definen dentro de los métodos de una clase son locales para ese método, por lo que es posible usar el mismo nombre de variable en distintas funciones miembro para hacer referencia a  distintas variables.

El único modificador que pueden usar las variables locales es static.

Variables Miembro y de Clase

Las variables de clase, marcadas con static, se crean cuando se carga la clase y siguen existiendo mientras ésta se mantenga cargada.
Las variables miembro existen mientras exista el objeto asociado.

Las variables de clase y variables miembro se inicializan automáticamente en el momento de crearse. Si el programador no asigna un valor predeterminado lo hará el compilador.

Las variables no locales (miembro y de clase) pueden utilizar los siguientes modificadores: public, protected, private, static, final, transient, volatile.

 
4 comentarios

Publicado por en 21 abril, 2011 en Estudio, Tema 1

 

Etiquetas: , , ,

Declaraciones y control de acceso (III)

Interfaz

La interfaz pública de una clase es un “contrato” entre el código cliente y la clase que proporciona el servicio.

Decimos que una clase implementa una interfaz cuando implementa todos los métodos declarados en ella.

Varias clases pueden implementar la misma interfaz. Una sola clase puede implementar varias interfaces.

La sintaxis para declarar una interfaz es la siguiente:

[Modificadores] interface NombreInterface [extends InterfacePadre]{
<public static final atributos>
<public abstract metodos>
}

Todos los métodos declarados en una interfaz son public y abstract, aunque no se especifique.
Todos los atributos en una interfaz son public, static y final, aunque no se especifique. Es decir, constantes.

Los métodos no pueden ser static ni final, strictfp, o native.

Una interfaz puede extender solo otras interfaces.

Las interfaces se usan para:

  • declarar métodos que serán implementados por una o varias clases.
  • dar a conocer la interfaz de programación sin revelar la implementación
  • identificar similitudes entre clases no relacionadas
  • simular la herencia múltiple declarando una clase que implemente varias interfaces


Variables Locales y Modificadores

Los modificadores de acceso no son aplicables a variables locales, provocaría error de compilación.
El único modificador que podría aplicarse a variables locales sería final.

Modificadores de acceso para miembros de una clase

Se pueden aplicar: public, protected, paquete (por defecto), private.

Otros modificadores para miembros de una clase

Strictfp

Para miembros de clase sólo se puede aplicar a métodos. Cuando marcamos strictfp a un método el código del método sigue la especificación anterior IEEE754 para flotantes.

Final

Los métodos marcados como final no pueden sobrescribirse.
Los argumentos marcados como final no pueden cambiar su valor.
Si una variable se marca como final, se convierte en una constante.

Abstract

Un método abstracto se declara pero no se implementa. Acaba en ;.
Un solo método abstracto obliga a declarar la clase como abstracta.
La primera subclase concreta debe implementar todos los métodos abstractos.

Static

Pueden marcarse static: métodos, variables, clases anidadas y bloques de inicialización.

Crea miembros que están asociados a la Clase y no necesitan que exista un objeto instanciado de la Clase para existir.

Synchronized

Sólo métodos pueden marcarse synchronized. Significa que solo un hilo puede acceder al método a la vez.

Native

Sólo métodos pueden marcarse native. Indica que el método está implementado en un lenguaje que es dependiente de la plataforma, usualmente C. Su declaración acabará en ‘;’ como los métodos abstractos, ya que su implementación no se especifica.

Transient variable

Si marcamos una variable de instancia transient no se añadirá en la serialización del objeto que la contenga.

Volatile variable

Indica al hilo que accede a la variable que siempre debe reconciliar su copia privada con la copia en memoria. Solo aplica a variables de instancia.

Argumentos variables

Para especificar un método con un número variable de argumentos, se define el tipo seguido de ‘…’, un espacio y un nombre para el array asociado.

El argumento variable debe ser el último en la declaración del método y solo se permite uno.

[Modificador] ValorDeRetorno NombreMetodo (Tipo… a) {}

Constructores

Un constructor es un conjunto de sentencias para inicializar una instancia.No se consideran métodos. No tienen valores de retorno ni se heredan.

El nombre del constructor debe coincidir con el de la clase.

Cada clase tiene al menos un constructor. Si no se escribe ninguno Java suministra uno por defecto. En ese caso el constructor no tiene argumentos y su cuerpo está vacío.

En el momento que nosotros escribamos un constructor se pierde el constructor por defecto.

La sintaxis es:
[Modificadores] nombreClase (<argumentos>){}

 
7 comentarios

Publicado por en 17 abril, 2011 en Estudio, Tema 1

 

Etiquetas: , , ,

Declaraciones y control de acceso (II)

Declaración de una clase

Una clase es una plantilla que describe las propiedades y el comportamiento que van a tener los objetos de esa clase.

La sintaxis para declarar una clase es la siguiente:

[Modificadores] class NombreClase [extends SuperClase] [implementes Interface]{}

La mínima expresión de una declaración de clase sería:
class MinimaClase{}

Los modificadores y las cláusulas de herencia e interfaces son opcionales.

Reglas de Declaración en el fichero fuente

  • Solo puede existir una clase pública en un fichero .java
  • El nombre del fichero debe coincidir con el de la clase pública.
  • La sentencia package (si existe) debe ser la primera sentencia del fichero.
  • Las sentencias import (si existen) deben seguir a la sentencia package y preceder a las declaraciones de clases.
  • Pueden existir más clases en el fichero pero no pueden ser públicas.
  • Las sentencias package e import afectarán a todas las clases declaradas en el fichero.
  • El nombre de los ficheros que solo tengan declaraciones de clase no públicas no tiene que coincidir con ninguna de las clases.

Modificadores de acceso

Existen tres modificadores de acceso: public, protected y private. Sin embargo, existen cuatro niveles de acceso. Cuando no se especifica ninguno de los tres modificadores anteriores se tiene el nivel de acceso por defecto, que es el nivel de paquete.

Para las clases de primer nivel solo se permite:

  • public
  • nivel de paquete

Para atributos, métodos, clases anidadas, se permiten todos.

Los explicamos un poco más, desde el más restrictivo al menos restrictivo:

  • private: solo es accesible dentro de su clase.
  • no se especifica (nivel de paquete): es accesible dentro de su clase y por todas las clases de su paquete.
  • protected: es accesible dentro de su clase, por todas las clases de su paquete y por las clases hijas que estén en otro paquete diferente.
  • public: es accesible para cualquier clase Java.


Otros Modificadores

Otros modificadores que pueden añadirse despúes de los modificadores de acceso son:

  • strictfp
  • abstract
  • final

Strictfp puede modificar una clase o un método, nunca una variable.

Cuando marcamos una clase como strictp significa que todo el código de la clase sigue la especificación IEEE754 para flotantes. Cuando marcamos strictfp a un método el código del método sigue la especificación anterior.

Si cumplimos esta especificación prevenimos que los números flotantes puedan ser dependientes de la plataforma.

Final

Cuando marcamos una clase como final estamos indicando que esta clase no puede ser extendida en subclases.
Los métodos marcados como final no pueden sobrescribirse.
Si una variable se marca como final, se convierte en una constante.

Abstract

Cuando marcamos una clase como abstract estamos indicando que no se puede instanciar. Su objetivo es ser extendida en subclases.
Una clase abstracta puede tener tanto métodos abstractos como no abstractos. Un solo método abstracto obliga a declarar la clase como abstracta.
Este tipo de clases son útiles cuando la implementación queremos que se concrete en sus clases hijas.

No tiene sentido declarar una clase final y abstracta.

 
10 comentarios

Publicado por en 13 abril, 2011 en Estudio, Tema 1

 

Etiquetas: , , ,

Declaraciones y Control de acceso (I)

Identificadores en Java

Un identificador es un nombre asignado a un paquete, clase, interface, método o variable.

Un identificador en Java debe comenzar por una letra, el signo de subrayado “_” o símbolo de moneda.
Los siguientes caracteres pueden ser cualquier combinación de letras, números, caracteres de moneda o conectores.
No tienen longitud máxima.
Se diferencia entre mayúsculas y minúsculas.
Un identificador no puede ser una palabra clave de Java, pero puede contener una palabra clave como parte de su nombre.

Ejemplo de literales válidos:


Ejemplo de literales no válidos:


Palabras clave en Java

Son palabras reservadas aquellas que tienen un significado especial para el compilador de Java.
Se suelen mostrar en un cuadro alfabéticamente pero creo que es más fácil recordarlas agrupandolas por categorías.

Tipos de datos (10) : byte, short, int, long, float, double, boolean, char, enum, void
Flujo de datos (11)  : if, else, for, do, while, switch, case, break, default, continue, return
Excepciones(6) : try, catch, finally, throw, throws, assert
Operador(1) : instanceof
NoUso(2) : const, goto
Objetos(9) : package, import, class, interface,extends, implements, new, this, super
Modificadores(11)   : abstract, final, static, private, protected, public, strictfp, synchronized, transient, volatile, native

true, false y null son literales, se escriben en minúsculas, y tampoco pueden ser usados como identificadores.

Convenciones de codificación Java

Paquetes: en minúsculas (transporte.objetos, utiles.factura)
Clases e Interfaces: la primera letra en Mayúscula (FacturaElectronica, Facturable)
Métodos: combinaciones verbo-nombre en camelCase. (getCliente, setAltura, sumarAsientos)
Variables: nombres en camelCase. (nuevoCliente, saldoMedioInteranual)
Constantes: en Mayúsculas y si hay que separar usar el subrayado “_” (IPC, TOTAL_NOMINA)

Estructuras de control: cuando las sentencias forman parte de una estructura de control de flujo,
escribirlas entre llaves, aunque sean sentencias sencillas.

Espacios: solo debe colocarse una sentencia por línea y utilizar sangrías de dos o cuatro espacios para facilitar la lectura.

Comentarios: utilizar comentarios para explicar segmentos de código no obvios.

JavaBeans: son clases de Java que tienen sus atributos privados.
Los métodos para obtener estos atributos se denominan getters y los métodos para establecer estos atributos setters.
(getLongitud(), getFechaNacimiento(), isEncendido(), setLongitud(l), setFechaNacimiento(fecha), setEncendido(true))

 
32 comentarios

Publicado por en 10 abril, 2011 en Estudio, Tema 1

 

Etiquetas: , , ,

 
A %d blogueros les gusta esto: