Los elementos del lenguaje Java
¿Que son los objetos?
En informática, un objeto es un conjunto de variables y de los métodos relacionados con esas variables.
Un poco más sencillo: un objeto contiene en sí mismo la información y los métodos o funciones necesarios para manipular esa información
Lo más importante de los objetos es que permiten tener un control total sobre 'quien' o 'que' puede acceder a sus miembros, es decir, los objetos pueden tener miembros públicos a los que podrán acceder otros objetos o miembros privados a los que solo puede acceder él. Estos miembros pueden set tanto variables como funciones.
El gran beneficio de todo esto es la encapsulación, el código fuente de un objeto puede escribirse y mantenerse de forma independiente a los otros objetos contenidos en la aplicación.
¿Qué son las clases?
Una clase es un proyecto, o prototipo, que define las variables y los métodos comunes a un cierto tipo de objetos.
Un poco más sencillo: las clases son las matrices de las que luego se pueden crear múltiples objetos del mismo tipo.
La clase define las variables y los métodos comunes a los objetos de ese tipo, pero luego, cada objeto tendrá sus propios valores y compartirán las mismas funciones.
Primero deberemos crear una clase antes de poder crear objetos o ejemplares de esa clase.
¿Modificadores de acceso?
Los modificadores son elementos del lenguaje que se colocan delante de la definición de variables locales, datos miembro, métodos o clases y que alteran o condicionan el significado del elemento estos permiten al diseñador de clases delimitar la frontera entre lo que es accesible para los usuarios de la clase, lo que es estrictamente privado y 'no importa' a nadie más que al diseñador de la clase e incluso lo que podría llegar a importar a otros diseñadores de clases que quisieran alterar, completar o especializar el comportamiento de la clase.
¿Modificadores de acceso?
Los modificadores son elementos del lenguaje que se colocan delante de la definición de variables locales, datos miembro, métodos o clases y que alteran o condicionan el significado del elemento estos permiten al diseñador de clases delimitar la frontera entre lo que es accesible para los usuarios de la clase, lo que es estrictamente privado y 'no importa' a nadie más que al diseñador de la clase e incluso lo que podría llegar a importar a otros diseñadores de clases que quisieran alterar, completar o especializar el comportamiento de la clase.
Con el uso de estos modificadores se consigue uno de los principios básicos de la Programación Orientada a Objetos, que es la encapsulación: Las clases tienen un comportamiento definido para quienes las usan conformado por los elementos que tienen un acceso público, y una implementación oculta formada por los elementos privados, de la que no tienen que preocuparse los usuarios de la clase.
Los otros dos modificadores, protected y el acceso por defecto (package) complementan a los otros dos. El primero es muy importante cuando se utilizan relaciones de herencia entre las clases y el segundo establece relaciones de 'confianza' entre clases afines dentro del mismo package. Así, la pertenencia de las clases a un mismo package es algo más que una clasificación de clases por cuestiones de orden.
Cuando se diseñan clases, es importante pararse a pensar en términos de quien debe tener acceso a que. Qué cosas son parte de la implantación y deberían ocultarse (y en que grado) y que cosas forman parte de la interface y deberían ser públicas.
Existen los siguientes modificadores de acceso:
- public - Todo el mundo puede acceder al elemento. Si es un dato miembro, todo el mundo puede ver el elemento, es decir, usarlo y asignarlo. Si es un método todo el mundo puede invocarlo.
- private - Sólo se puede acceder al elemento desde métodos de la clase, o sólo puede invocarse el método desde otro método de la clase.
- protected - Sólo pueden obtener acceso al tipo o miembro código de la misma clase o estructura o de una clase derivada
- sin modificador - Se puede acceder al elemento desde cualquier clase del package donde se define la clase.
Los modificadores de acceso preceden a la declaración de un elemento de la clase (ya sea dato o método), de la siguiente forma:
[modificadores] tipo_variable nombre;
[modificadores] tipo_devuelto nombre_Metodo ( lista_Argumentos );
La sintáxis de un lenguaje define los elementos de dicho lenguaje y cómose combinan para formar un programa. Los elementos típicos de cualquier lenguaje son los siguientes:
- Identificadores: los nombres que se dan a las variables
- Tipos de datos
- Palabras reservadas: las palabras que utiliza el propio lenguaje
- Sentencias
- Bloques de código
- Comentarios
- Expresiones
- Operadores
Identificadores
Un identificador es un nombre que identifica a una variable, a un método o función miembro, a una clase. Todos los lenguajes tienen ciertas reglas para componer los identificadores:- Todos los identificadores han de comenzar con una letra, el carácter subrayado ( _ ) o el carácter dollar ( $ )
- Puede incluir, pero no comenzar por un número
- No puede incluir el carácter espacio en blanco
- Distingue entre letras mayúsculas y minúsculas
- No se pueden utilizar las plabras reservadas como identificadores
| Tipo de identificador | Convención | Ejemplo |
|---|---|---|
| nombre de una clase | Comienza por la letra mayúscula | String, Rectangulo, CinematicaApplet |
| nombre de variable | comienza por letra minúscula | area, color, appletSize |
| nombre de constante | En letras maýusculas | PI,MAX_ANCHO |
Comentarios
Un comentario es un texto adicional que se añade al código para explicar su funcionalidad, bien a otras personas que lean el programa, o al propio autor como recordatorio. Los comentarios son una parte importante de la documentación de un programa. Los comentarios son ignorados por el compilador, por lo que no incrementan el tamaño del archivo ejecutable; se pueden por tanto, añadir libremente al código para que pueda entenderse mejor.La programación orientada a objetos facilita mucho la lectura del código, por lo que lo que no se precisa hacer tanto uso de los comentarios como en los lenguajes estructurados. En Java existen tres tipos de comentarios:
- Comentarios en una sola línea //
- Comentarios de varias líneas /* */
- Comentarios de documentación /** */
| /*-------------------------------| | (C) Juan Lopez Quesada | | fecha: Diciembre | | programa: 2ASI.java | |---------------------------------*/ |
| /** Este es el primer programa de una serie dedicada a explicar los fundamentos del lenguaje Java */ |
| public class PrimeroApp{ ----public static void main(String[] args) { //imprime un mensaje --------System.out.println("El primer programa"); ----} } |
| //System.out.println("El primer programa"); |
Sentencias
Una sentencia es una orden que se le da al programa para realizar una tarea especÍfica, esta puede ser: mostrar un mensaje en la pantalla, declarar una variable (para reservar espacio en memoria), inicializarla, llamar a una función, etc. Las sentencias acaban con ;. este carácter separa una sentencia de la siguiente. Normalmente, las sentencias se ponen unas debajo de otras, aunque sentencias cortas pueden colocarse en una misma línea. He aquÍ algunos ejemplos de sentencias| int i=1; import java.awt.*; System.out.println("El primer programa"); rect.mover(10, 20); |
Bloques de código
Un bloque de código es un grupo de sentencias que se comportan como una unidad. Un bloque de código está limitado por las llaves de apertura { y cierre }. Como ejemplos de bloques de código tenemos la definición de una clase, la definición de una función miembro, una sentencia iterativa for, los bloques try ... catch, para el tratamiento de las excepciones, etc.Expresiones
Una expresión es todo aquello que se puede poner a la derecha del operador asignación =. Por ejemplo:| x=123; y=(x+100)/4; area=circulo.calcularArea(2.5); Rectangulo r=new Rectangulo(10, 10, 200, 300); |
La segunda, realiza una operación
La tercera, es una llamada a una función miembro calcularArea desde un objeto circulo de una clase determinada
La cuarta, reserva espacio en memoria para un objeto de la clase Rectangulo mediante la llamada a una función especial denominada constructor.
Variables
Una variable es un nombre que se asocia con una porción de la memoria del ordenador, en la que se guarda el valor asignado a dicha variable. Hay varios tipos de variables que requieren distintas cantidades de memoria para guardar datos.Todas las variables han de declararse antes de usarlas, la declaración consiste en una sentencia en la que figura el tipo de dato y el nombre que asignamos a la variable. Una vez declarada se le podrá asignar valores.
Java tiene tres tipos de variables:
- De instancia
- De clase
- Locales
Las variables de clase o miembros dato estáticos son similares a las variables de instancia, con la excepción de que los valores que guardan son los mismos para todos los objetos de una determinada clase. En el siguiente ejemplo, PI es una variable de clase y radio es una variable de instancia. PI guarda el mismo valor para todos los objetos de la clase Circulo, pero el radio de cada cÍrculo puede ser diferente
| class Circulo{ static final double PI=3.1416; double radio; //... } |
| class Circulo{ //... double calcularArea(){ double area=PI*radio*radio; return area; } } |
| int x=0; String nombre="Angel"; double a=3.5, b=0.0, c=-2.4; boolean bNuevo=true; int[] datos; |
- Un tipo de dato primitivo
- El nombre de una clase
- Un array
| int año=1999; |
| double radioCirculo=3.2; |
- Declarar
- Inicializar
- Usar
Tipos de datos primitivos
| Tipo | Descripción |
|---|---|
| boolean | Tiene 2 valores True o False. |
| char | Caracteres Unicode de 16 bits. Los caracteres alfa-numéricos son los mismos que los ASCII con el bit alto puesto a 0. El intervalo de valores va desde 0 hasta 65535 (valores de 16-bits sin signo) |
| byte | Tamaño 8 bits. El intervalo de valores va desde -27 hasta 27 -1 (-128 a 127) |
| short | Tamaño 16 bits. El intervalo de valores va desde -215 hasta 215-1 (-32768 a 32767) |
| int | Tamaño 32 bits. El intervalo de valores va desde -231 hasta 231-1 (-2147483648 a 2147483647) |
| long | Tamaño 64 bits. El intervalo de valores va desde -263 hasta 263-1 (-9223372036854775808 a 9223372036854775807) |
| float | Tamaño 32 bits. Números en coma flotante de simple precisión. Estándar IEEE 754-1985 (de 1.40239846e–45f a 3.40282347e+38f) |
| double | Tamaño 64 bits. Números en coma flotante de doble precisión. Estándar IEEE 754-1985. (de 4.94065645841246544e–324d a 1.7976931348623157e+308d.) |
Caracteres
En Java los caracteres no están restringidos a los ASCII sino son Unicode. Un carácter está siempre rodeado de comillas simples como 'A', '9', 'ñ', etc. El tipo de dato char sirve para guardar estos caracteres.Un tipo especial de carácter es la secuencia de escape, similares a las del lenguaje C/C++, que se utilizan para representar caracteres de control o caracteres que no se imprimen. Una secuencia de escape está formada por la barra invertida (\) y un carácter. En la siguiente tabla se dan las secuencias de escape más utilizadas.
| Acción | Secuancia |
|---|---|
| retorno de carro | \r |
| tabulador horizontal | \t |
| nueva linea | \n |
| barra invertida | \\ |
Variables booleanas
En el lenguaje C/C++ el valor 0 se toma como falso y el 1 como verdadero. En el lenguaje Java existe el tipo de dato boolean. Una variable booleana solamente puede guardar uno de los dos posibles valores: true (verdadero) y false (falso).| boolean encontrado=false; {...} encontrado=true; |
Variables enteras
Una variable entera consiste en cualquier combinación de cifras precedidos por el signo más (opcional), para los positivos, o el signo menos, para los negativos. Son ejemplos de números enteros:| 12, -36, 0, 4687, -3598 |
| int numero=1205; int x,y; long m=30L; |
En la tercera línea 30 es un número de tipo int por defecto, le ponemos el sufijo L en mayúsculas o minúsculas para indicar que es de tipo long.
Existen como vemos en la tabla varios tipos de números enteros (byte, short, int,long), y también existe una clase denominada BigInteger cuyos objetos pueden guardar un número entero arbitrariamente grande.
Variables en coma flotante
Las variables del tipo float o double (coma flotante) se usan para guardar números en memoria que tienen parte entera y parte decimal.| double PI=3.14159; double g=9.7805, c=2.9979e8; |
Otras ejemplos son los siguientes
| float a=12.5f; float b=7f; double c=7.0; double d=7d; |
Valores constantes
Cuando se declara una variable de tipo final, se ha de inicializar y cualquier intento de modificarla en el curso de la ejecución del programa da lugar a un error en tiempo de compilación.Normalmente, las constantes de un programa se suelen poner en letras mayúsculas, para distinguirlas de las que no son constantes. He aquÍ ejemplos de declaración de constantes.
| final double PI=3.141592653589793; final int MAX_DATOS=150; |
Las cadenas de caracteres o strings
Además de los ocho tipos de datos primitivos, las variables en Java pueden ser declaradas para guardar una instancia de una clase.Las cadenas de caracteres o strings son distintas en Java y en el lenguaje C/C++, en este último, las cadenas son arrays de caracteres terminados en el carácter '\0'. Sin embargo, en Java son objetos de la clase String.
| String mensaje="El primer programa"; |
| public class PrimeroApp{ public static void main(String[] args) { //imprime un mensaje String mensaje="El primer programa"; System.out.println(mensaje); } } |
| String texto="Un string con \t un carácter tabulador y \n un salto de línea"; |
Palabras reservadas
En el siguiente cuadro se listan las palabras reservadas, aquellas que emplea el lenguaje Java, y que el programador no puede utilizar comoidentificadores. Algunas de estas palabras le resultarán familiares al programador del lenguaje C/C++. Las palabras reservadas señaladas con un arterisco (*) no se utilizan.| abstract | boolean | break | byte | byvalue* |
| case | cast* | catch | char | class |
| const* | continue | default | do | double |
| else | extends | false | final | finally |
| float | for | future* | generic* | goto* |
| if | implements | import | inner* | instanceof |
| int | interface | long | native | new |
| null | operator* | outer* | package | private |
| protected | public | rest* | return | short |
| satatic | super | switch | synchronized | this |
| throw | transient | true | try | var* |
| void | volatile | while |
- Tipos de datos: boolean, float, double, int, char
- Sentencias condicionales: if, else, switch
- Sentencias iterativas: for, do, while, continue
- Tratamiento de las excepciones: try, catch, finally, throw
- Estructura de datos: class, interface, implements, extends
- Modificadores y control de acceso: public, private, protected, transient
- Otras: super, null, this.
Estructuras de Control
Durante un programa existen acciones que se han de repetir un número determinado de veces. Por ejemplo, leer 3 caracteres de un flujo de entrada in se codificaría:| in.read(); in.read(); in.read(); |
Así, nuestro ejemplo se podría indicar como:
| int i=0; for ( i=0 ; i <= 3 ; i++ ){ in.read(); } |
El lenguaje Java soporta las estructuras de control:
| Sentencia | Clave |
|---|---|
| Toma de decisión | if-else, switch-case |
| Bucle | for, while, do-while |
| Misceláneo | break, continue, label:, return, goto |
Las sentencias condicionales: if y switch
| if ( condición ){ Bloque de código a ejecutar si la condición es cierta; }else;{ Bloque de código a ejecutar si la condición es falsa; } |
La parte del else es opcional, y un bloque de código puede ser simplemente la sentencia vacía ; para representar que en ese caso no se ha de ejecutar nada.
Se pueden anidar expresiones if-else, para poder implementar aquellos casos con múltiples acciones. Esto es lo que se suele denominar como sentencias else if.
Por ejemplo, supongamos que se desea escribir un programa que clasifique según el contenido de una variable valor, asigne una letra a una variable clasificacion: A para un valor del 100-91, B de 90-81, C para 80-71 y F si no es ninguno de los anteriores:
| int valor; char clasificacion; if (valor > 90){ clasificacion='A'; } else if (valor > 80){ clasificacion='B'; } else if (valor > 70){ clasificacion='C'; } else { clasificacion='F'; } |
Este sistema de programación (else if) no es demasiado recomendable, y por ello el lenguaje Java incluye la sentencia switch, que veremos a continuación, para dirigir el flujo de control de variables con múltiples valores.
La sentencia switch
Mediante la sentencia switch se puede seleccionar entre varias sentencias según el valor de cierta expresión.La forma general de switch es la siguiente:
| switch ( expresionMultivalor ) { case valor1 : conjuntoDeSentencias; break; case valor2 : conjuntoDeSentencias; break; case valor3: conjuntoDeSentencias; break; default: conjuntoDeSentencias; break; } |
Cada sentencia case debe ser única y el valor que evalúa debe ser del mismo tipo que el devuelto por la expresiónMultivalor de la sentencia switch.
Las sentencias break que aparecen tras cada conjuntoDeSentencias provocan que el control salga del switch y continúe con la siguiente instrucción al switch. Las sentencias break son necesarias porque sin ellas se ejecutarían secuencialmente las sentencias case siguientes. Existen ciertas situaciones en las que se desea ejecutar secuencialmente algunas o todas las sentencias case, para lo que habrá que eliminar algunos break.
Finalmente, se puede usar la sentencia default para manejar los valores que no son explícitamente contemplados por alguna de las sentencias case. Su uso es altamente recomendado.
Por ejemplo, supongamos un programa con una variable entera meses cuyo valor indica el mes actual, y se desea imprimir el nombre del mes en que estemos. Se puede utilizar la sentencia switch para realizar esta operación:
| int meses; switch ( meses ){ case 1: System.out.println( "Enero" ); break; case 2: System.out.println( "Febrero" ); break; case 3: System.out.println( "Marzo" ); break; //Demas meses // . . . case 12: System.out.println( "Diciembre" ); break; default: System.out.println( "Mes no valido" ); break; } |
| int meses; if ( meses == 1 ) { System.out.println( "Enero" ); } else if ( meses == 2 ) { System.out.println( "Febrero" ); } // Y así para los demás meses |
Sentencias de iteración o bucles: for, do, while
Bucle while
El bucle while es el bucle básico de iteración. Sirve para realizar una acción sucesivamente mientras se cumpla una determinada condición.La forma general del bucle while es la siguiente:
| while ( expresiónBooleana ) { sentencias; } |
Se utiliza, por ejemplo para estar en un bucle del que no hay que salir hasta que no se cumpla una determinada condición. Por ejemplo, multiplicar un número por 2 hasta que sea mayor que 100:
| int i = 1; while ( i <= 100 ) { i = i * 2; } |
Bucle do-while
El bucle do-while es similar al bucle while, pero en el bucle while la expresión se evalúa al principio del bucle y en el bucle do-while la evaluación se realiza al final.La forma general del bucle do-while es la siguiente:
| do { sentencias; } while ( expresiónBooleana ); |
Por ejemplo, cuando se lee información de un archivo, se sabe que siempre se debe leer por lo menos un carácter:
| int c; do { c = System.in.read( ); // Sentencias para tratar el carácter c } while ( c != -1 ); // No se puede leer más (Fin fichero) |
Bucle for
Mediante la sentencia for se resume un bucle do-while con una iniciación previa. Es muy común que en los bucles while y do-while se inicien las variables de control de número de pasadas por el bucle, inmediatamente antes de comenzar los bucles. Por eso el bucle for está tan extendido.La forma general de la sentencia for es la siguiente:
| for ( iniciación ; terminación ; incremento ){ sentencias; } |
La terminación es una expresión que determina cuándo se debe terminar el bucle. Esta expresión se evalúa al final de cada iteración del bucle. Cuando la expresión se evalúa a falso, el bucle termina.
El incremento es una expresión que es invocada en cada iteración del bucle. En realidad puede ser una acción cualquiera, aunque se suele utilizar para incrementar una variable contador:
| for ( i = 0 ; i < 10 ; i++ ) |
Se debe utilizar el bucle for cuando se conozcan las restricciones del bucle (su instrucción de iniciación, criterio de terminación e instrucción de incremento).
Por ejemplo, los bucles for son utilizados comúnmente para iterar sobre los elementos de una matriz, o los caracteres de una cadena:
| // cad es una cadena (String) for ( int i = 0; i < cad.length() ; i++){ // hacer algo con el elemento i-ésimo de cad } |
Sentencias de salto: break, continue y return
Sentencia break
La sentencia break provoca que el flujo de control salte a la sentencia inmediatamente posterior al bloque en curso. Ya se ha visto anteriormente la sentencia break dentro de la sentencia switch.El uso de la sentencia break con sentencias etiquetadas es una alternativa al uso de la sentencia goto, que no es soportada por el lenguaje Java.
Se puede etiquetar una sentencia poniendo una identificador Java válido seguido por dos puntos antes de la sentencia:
| nombreSentencia: sentenciaEtiquetada |
break nombreSentencia2;
Un ejemplo de esto sería el programa:
| void gotoBreak() { System.out.println("Ejemplo de break como 'goto' "); a: for( int i=1; i<10; i++ ){ System.out.print(" i="+i); for( int j=1; j<10; j++ ){ if ( j==5 ) break a; //Sale de los dos bucles!!! System.out.print(" j="+j); } System.out.print("No llega aquí"); } } |
| i=1 j=1 j=2 j=3 |
Sentencia continue
Del mismo modo que en un bucle se puede desear romper la iteración, también se puede desear continuar con el bucle, pero dejando pasar una determinada iteración. Se puede usar la sentencia continue dentro de los bucles para saltar a otra sentencia, aunque no puede ser llamada fuera de un bucle.Tras la invocación a una sentencia continue se transfiere el control a la condición de terminación del bucle, que vuelve a ser evaluada en ese momento, y el bucle continúa o no dependiendo del resultado de la evaluación. En los bucles for además en ese momento se ejecuta la cláusula de incremento (antes de la evaluación). Por ejemplo el siguiente fragmento de código imprime los números del 0 al 9 no divisibles por 3:
| for ( int i = 0 ; i < 10 ; i++ ) { if ( ( i % 3 ) == 0 ) continue; System.out.print( " " + i ); } |
Por ejemplo, el siguiente fragmento de código:
| void gotoContinue( ) { f: for ( int i=1; i <5; i++ ) { for ( int j=1; j<5; j++ ) { if ( j>i ) { System.out.println(" "); continue f; } System.out.print( " " + (i*j) ); } } } |
| 1 2 4 3 6 9 4 8 12 16 |
Sentencia return
La última de las sentencias de salto es la sentencia return, que puede usar para salir del método en curso y retornar a la sentencia dentro de la cual se realizó la llamada.Para devolver un valor, simplemente se debe poner el valor (o una expresión que calcule el valor) a continuación de la palabra return. El valor devuelto por return debe coincidir con el tipo declarado como valor de retorno del método.
Cuando un método se declara como void se debe usar la forma de return sin indicarle ningún valor. Esto se hace para no ejecutar todo el código del programa:
| int contador; boolean condicion; int devuelveContadorIncrementado(){ return ++contador; } void metodoReturn(){ //Sentencias if ( condicion == true ) return; //Más sentencias a ejecutar si condición no vale true } |
No hay comentarios:
Publicar un comentario