Arreglos y La sentencia for mejorada.

Los Arreglos son estructuras de datos que consisten en elementos relacionados por el tipo de dato. Los arreglos son estructuras de longitud fija, una vez inicializado su tamaño este se mantiene como  una constante, aunque se puede reasignar una variable tipo arreglo que haga refencia a un arreglo de longitud distinta.

Los arreglos son conjuntos de variables todas del mismo tipo, Es necesario recordar en que Java existen dos tipos de datos; los primitivos y los de tipo por referencia. Los arreglos son objetos, por ende, son del tipo por referencia, en realidad un arreglo es una referencia a un objeto arreglo en memoria (es por ello que se le considera como tipo referenciado).
Para la creación de un arreglo debemos especificar un tipo de dato, un nombre y un [ ](corchete abierto y cerrado)

Los objetos o valores dentro de un arreglo se ubican a partir de su "indice" o "subindice". el subindice de un arreglo siempre comienza en 0, por ende un arreglo de tamaño 5, sera asi.

c[ 5 ] = c[0]  ,  c[1]  , c[2]  ,  c[3]  ,  c[4]

Como el arreglo es de tamaño 5 y el subindice siempre comienza en 0, el ultimo subindice siempre sera 1 menos que el tamaño del arreglo. en este ejemplo el arreglo es de tamaño 5 el ultimo subindice es 4.

EJ:

int arreglo1[ ]; también puede ser int [ ] arreglo1;

estas sentencias lo único que hacen es crear un arreglo de valores int llamado arreglo1. pero no lo inicializa, esta declaración seria equivalente a declarar una variable como int num1;
Para inicializar el arreglo tenemos tres posibles caminos; simplemente declarar el arreglo como en el ejemplo, después dimencionarlo y por ultimo inicializarlo;

int arreglo1[ ];   //crea el arreglo
arreglo1 = new int[ 5 ];  //dimensiona el arreglo con un tamaño 5
arreglo1[ 0 ] = 33; //inicializa el subindice 0 con un valor de 33

Otra manera  es

int arreglo2[ ] = {22,102,1,5,99}; //crea en arreglo y lo dimensiona pasandole valores.
este arreglo es de tamaño 5,

¿que valor tendría en este arreglo  arreglo2[ 1 ]; ?

R; 102.  recuerda que el sub-indice de un arreglo siempre comienza en 0, en este caso [0]=22,[1]=102, etc...

También se pueden haber inicializado los valores de uno en uno a través de sus sub-indices el mismo ejemplo.


int arreglo2[] = new arreglo[5]; //crea el arreglo y le da un tamaño inmediatamente
arreglo2[ 0 ] = 22; //inicializa el indice con un valor del mismo tipo de dato del arreglo.

arreglo2[ 1 ] = 102;

etc,,,

Al crear un arreglo y dimensionarlo, pero no asignarle valores a sus subindices, java automáticamente inicializa el arreglo con los valores predeterminados dependiendo de su tipo... recordar, como ya puse en una entrada anterior: int, short, long, double, byte en 0, char en null, boolean en false y todos los de referencia en null.
*dimensionar un arreglo en la forma int c[4]; produce un error de sintaxis.

Ej:

//crea un arreglo de tamaño 10 y dale valores al azar entre 1 y 100


1     import java.util.Random;
2
3     public class arreglos
4     {
5        public static void main(String[]args)
6    {
7         int arreglo1[] = new int[10]; //crea y dimensiona un arreglo de tamaño 10  
8         Random azar = new Random();  //crea un nuevo objeto random
9         for(int i = 0; i<arreglo1.length; i++)
10      {
11         int num = azar.nextInt(99)+1;
12         arreglo1[i] = num;
13      }//fin del ciclo for
14  
15      for(int x=0; x<arreglo1.length; x++)
16       {
17         System.out.println("el valor del indice ["+x+"] es de :"+arreglo1[x]);
18        }
19    }//fin del metodo main
20    }//fin de la clase



En la linea 7  creamos y dimensionamos un arreglo de valores int cuyo tamaño es 10, en la linea 8 instanciamos (o creamos) un objeto de la clase Random que nos permite usar sus métodos y variables, en este ejemplo solo usamos el método nextInt(), que recibe un argumento de tipo entero el que establece el numero máximo de los posibles números, acá le pasamos como argumento 99 y esto es porque el numero cuenta desde el 0 hasta el que le pasemos, como acá es 99 podría ser un numero desde 0 (incluyéndolo) hasta 99, Como el ejercicio establecía que debían ser numero del 1 al 100 se le suma 1 (azar.nextInt(99)+1;). así aunque salga 0 seria 1 y si sale 99 serian 100 respectivamente   y le pasamos ese valor a la variable num.

en la linea 9 creamos un ciclo for, el que va a iterar mientras que i = 0 sea menor que arreglo1.length
El metodo .length es propio de los arreglos y su función es devolver el largo del arreglo, en este caso 10. es por eso que en el encabezado del for pongo que debe iterar hasta que sea menor que <arreglo1.length pues el i inicia en 0 (si dejaramos que iterara hasta que fuera menor o igual, en total daría 11 vueltas y nos daría un error Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: este es un arror por intentar llegar a un indice que noe sta en el arreglo, por ejemplo tenemos un arreglo de tamaño 10 e intentamos acceder al subindice 10, recordar que en un arreglod e tamaño 10 el ultimo subindice es 9 ). si el i iniciara en 1 entonces seria correcto poner <= .
en la linea 12 se realiza el "llenado del arreglo" ponemos arreglo1[ i ] para que vaya llenando el arreglo conforme itera el arreglo. así como en la primera vuelta i vale 0, se inicializa el subindice 0 del arreglo con algún valor al azar entregado por nexInt(99)+1
finalmente en la linea 15 crea otro ciclo for que iterara a traves del arreglo para mostrar sus valores.

La sentencia for mejorada

La instrucción for mejorada nos permite iterar a través de un arreglo o colección sin la necesidad de un contador, con lo que se evita la posibilidad de salir mas allá de los limites del arreglo.

su sintaxis es:

for(parametro : nombrearreglo)
{
instrucción
}

el parametro es una variable no inicializada del mismo tipo del arreglo, por ejemplo int. nombre arreglo es el nombre del arreglo sin los corchetes [ ]
//suma los elementos de un arreglo

int valores[ ] = {2,33,42,99,1};
int suma = 0;
for(int iterador : valores)
{
suma+=iterador;
}
System.out.println("El total de sumar los elementos del arreglo es : "+suma);

la variable iterador no se inicializa pues en este tipo de for realiza las veces de valor provisorio, por ejemplo en la primera vuelta, iterador toma el valor del elemento 0 del arreglo valores, así según este ejemplo en la primera vuelta iterador = 2, en la segunda iterador = 33 etc...

La sentencia for mejorada es util cuando debemos iterar sobre elementos de un arreglo pero no modificaros  tampoco se puede hacer referecia al iterador como se haria con uno en una sentencia for normal, ya que en este tipo de declaración el iterador no toma los valores 0, 1, 2... sino los valores de los elementos de arreglo, como recién dije..

Arreglos Multidimensionales


Los arreglos multidimensionales de dos dimensiones se utilizan con frecuencia para representar tablas de valores, las cuales consisten en información ordenada en fi las y columnas. Para identificar un elemento específico de una tabla, debemos especifi car dos subíndices. Por convención, el primero identifica la fi la del elemento y el segundo su columna. Los arreglos que requieren dos subíndices para identifi car un elemento específico se llaman arreglos bidimensionales (los arreglos multidimensionales pueden tener más de dos dimensiones). Java no soporta los arreglos multidimensionales directamente, pero permite al programador especificar arreglos unidimensionales, cuyos elementos sean también arreglos unidimensionales, con lo cual se obtiene el mismo efecto.
En general, a un arreglo con m fi las y n columnas se le llama arreglo de m por n.
Cada elemento en el arreglo a se identifica en la fi gura 7.16 mediante una expresión de acceso a un arreglo de la forma a [ fila ][ columna ]; a es el nombre del arreglo, fila y columna son los subíndices que identifi can
en forma única a cada elemento en el arreglo a por número de fila y columna.

imagen de "como programar en java". Deitel y Deitel

Arreglos de arreglos unidimensionales
Al igual que los arreglos unidimensionales, los arreglos multidimensionales pueden inicializarse mediante inicializadores
de arreglos en las declaraciones. Un arreglo bidimensional b con dos fi las y dos columnas podría declararse
e inicializarse con inicializadores de arreglos anidados, como se muestra a continuación:
int b[ ] [ ] = { { 1, 2 }, {3, 4} };
Los valores del inicializador se agrupan por fi la entre llaves. Así, 1 y 2 inicializan a b[ 0 ][ 0 ] y b[ 0 ][ 1 ],
respectivamente; 3 y 4 inicializan a b[ 1 ][ 0 ] y b[ 1 ][ 1 ], respectivamente. El compilador cuenta el número
de inicializadores de arreglos anidados (representados por conjuntos de llaves dentro de las llaves externas) en
la declaración del arreglo, para determinar el número de fi las en el arreglo b. El compilador cuenta los valores
inicializadores en el inicializador de arreglos anidado de una fi la, para determinar el número de columnas en esa
fi la. Como veremos en unos momentos, esto signifi ca que las fi las pueden tener distintas longitudes.
Los arreglos multidimensionales se mantienen como arreglos de arreglos unidimensionales. Por lo tanto, el
arreglo b en la declaración anterior está realmente compuesto de dos arreglos unidimensionales separados: uno que contiene los valores en la primera lista inicializadora anidada { 1, 2 } y uno que contiene los valores en la segunda lista inicializadora anidada { 3, 4 }. Así, el arreglo b en sí es un arreglo de dos elementos, cada uno de los cuales es un arreglo unidimensional de valores int.

Arreglos bidimensionales con filas de distintas longitudes
La forma en que se representan los arreglos multidimensionales los hace bastante flexibles. De hecho, las longitudes de las filas en el arreglo b no tienen que ser iguales. Por ejemplo,
int b[ ][ ] = { { 1, 2 }, { 3, 4, 5 } };
crea el arreglo entero b con dos elementos (los cuales se determinan según el número de inicializadores de arreglos anidados) que representan las fi las del arreglo bidimensional. Cada elemento de b es una referencia a un arreglo unidimensional de variables int. El arreglo int de la fi la 0 es un arreglo unidimensional con dos elementos (1 y 2), y el arreglo int de la fi la 1 es un arreglo unidimensional con tres elementos (3, 4 y 5).
Creación de arreglos bidimensionales mediante expresiones de creación de arreglos
Un arreglo multidimensional con el mismo número de columnas en cada fila puede crearse mediante una expresión de creación de arreglos. Por ejemplo, en las siguientes líneas se declara el arreglo b y se le asigna una referencia a un arreglo de tres por cuatro:
int b[ ][ ] = new int[ 3 ][ 4 ];

En este caso, utilizamos los valores literales 3 y 4 para especificar el número de filas y columnas, respectivamente, pero esto no es obligatorio. Los programas también pueden utilizar variables para especificar las dimensiones de los arreglos, ya que new crea arreglos en tiempo de ejecución, no en tiempo de compilación. Al igual que con los arreglos unidimensionales, los elementos de un arreglo multidimensional se inicializan cuando se crea el objeto arreglo.
Un arreglo multidimensional, en el que cada fila tiene un número distinto de columnas, puede crearse de la
siguiente manera:
int b[][] = new int[ 2 ][ ]; // crea 2 filas
b[ 0 ] = new int[ 5 ]; // crea 5 columnas para la fila 0
b[ 1 ] = new int[ 3 ]; // crea 3 columnas para la fila 1


ejemplo:


import java.util.Random;

public class arreglos
{
    public static void main(String[]args)
    {
    int arreglo1[][]={{3,44,55},{4,32,54}};
    for(int fila=0; fila<arreglo1.length;fila++)
    {
    for(int columna=0; columna<arreglo1[fila].length;columna++){
    System.out.printf("%d ",arreglo1[fila][columna]);
    }
        System.out.println("");
    }
    }//fin del metodo main
}//fin de la clase

Objetos, Métodos y Constructores.

"Comenzaremos con una analogía simple, para ayudarle a comprender el concepto de las clases y su contenido. Suponga que desea conducir un automóvil y, para hacer que aumente su velocidad, debe presionar el pedal del acelerador. ¿Qué debe ocurrir antes de que pueda hacer esto? Bueno, antes de poder conducir un automóvil, alguien tiene que diseñarlo. Por lo general, un automóvil empieza en forma de dibujos de ingeniería, similares a los planos de construcción que se utilizan para diseñar una casa. Estos dibujos de ingeniería incluyen el diseño del pedal del acelerador, para que el automóvil aumente su velocidad. El pedal “oculta” los complejos mecanismos que se encargan de que el automóvil aumente su velocidad, de igual forma que el pedal del freno “oculta” los mecanismos que disminuyen la velocidad del automóvil y por otro lado, el volante “oculta” los mecanismos que hacen que el automóvil de vuelta. Esto permite que las personas con poco o nada de conocimiento acerca de cómo funcionan los motores puedan conducir un automóvil con facilidad.
Desafortunadamente, no puede conducir los dibujos de ingeniería de un auto. Antes de poder conducir un
automóvil, éste debe construirse a partir de los dibujos de ingeniería que lo describen. Un automóvil completo tendrá un pedal acelerador verdadero para hacer que aumente su velocidad, pero aún así no es sufi ciente; el automóvil no acelerará por su propia cuenta, así que el conductor debe oprimir el pedal del acelerador.
Ahora utilizaremos nuestro ejemplo del automóvil para introducir los conceptos clave de programación de esta sección. Para realizar una tarea en una aplicación se requiere un método. El método describe los mecanismos que se encargan de realizar sus tareas; y oculta al usuario las tareas complejas que realiza, de la misma forma que el pedal del acelerador de un automóvil oculta al conductor los complejos mecanismos para hacer que el automóvil vaya más rápido. En Java, empezamos por crear una unidad de aplicación llamada clase para alojar a un método,
así como los dibujos de ingeniería de un automóvil alojan el diseño del pedal del acelerador. En una clase se proporcionan uno o más métodos, los cuales están diseñados para realizar las tareas de esa clase. Por ejemplo, una clase que representa a una cuenta bancaria podría contener un método para depositar dinero en una cuenta, otro para retirar dinero de una cuenta y un tercero para solicitar el saldo actual de la cuenta.
Así como no podemos conducir un dibujo de ingeniería de un automóvil, tampoco podemos “conducir” una clase. De la misma forma que alguien tiene que construir un automóvil a partir de sus dibujos de ingeniería para poder conducirlo, también debemos construir un objeto de una clase para poder hacer que un programa realice las tareas que la clase le describe cómo realizar. Ésta es una de las razones por las cuales Java se conoce como un lenguaje de programación orientado a objetos. Cuando usted conduce un automóvil, si oprime el pedal del acelerador se envía un mensaje al automóvil para que realice una tarea-hacer que el automóvil vaya más rápido. De manera similar, se envían mensajes a un objeto; cada mensaje se conoce como la llamada a un método, e indica a un método del objeto que realice su tarea.
Hasta ahora, hemos utilizado la analogía del automóvil para introducir las clases, los objetos y los métodos. Además de las capacidades con las que cuenta un automóvil, también tiene muchos atributos como su color, el número de puertas, la cantidad de gasolina en su tanque, su velocidad actual y el total de kilómetros recorridos (es decir, la lectura de su odómetro). Al igual que las capacidades del automóvil, estos atributos se representan como parte del diseño en sus diagramas de ingeniería. Cuando usted conduce un automóvil, estos atributos siempre están asociados con él. Cada uno mantiene sus propios atributos. Por ejemplo, cada conductor sabe cuánta gasolina tiene
en su propio tanque, pero no cuánta hay en los tanques de otros automóviles. De manera similar, un objeto tiene atributos que lleva consigo cuando se utiliza en un programa. Éstos se especifican como parte de la clase del objeto. Por ejemplo, un objeto tipo cuenta bancaria tiene un atributo llamado saldo, el cual representa la cantidad de dinero en la cuenta. Cada objeto tipo cuenta bancaria conoce el saldo en la cuenta que representa, pero no los saldos de las otras cuentas en el banco. Los atributos se especifican mediante las variables de instancia de la clase.
"Extracto de Como programar en Java, deitel y deitel, octava edición"


Metodos

Existen dos tipos de métodos; los que tienen valor de retorno y los de tipo void.

Los métodos con tipo de retorno devuelven un valor al ser llamados dentro de una clase, sintaxis

int suma(int num1, int num2)
{
int resultado = num1+num2;
return resultado;
}

Debemos poner un tipo de valor (en este caso int) antes del nombre del método. seguido del nombre del método van ( paréntesis ) en los cuales se pueden poner ( o no ) argumentos los cuales vana ser manipulados al interior del mismo. Los tipos de valores de los argumentos deben ser exactamente iguales a los de la declaración del método. *en realidad y siendo extricto los tipos de datos d elos argumentos si se pueden mezclar pero recuerden que el retorno es uno solo
la sentencia final del método con tipo de valor de retorno es " return " que es la encargada de retornar un valor del mismo tipo de la declaración del tipo de método.

métodos sin tipo de retorno. Tambien podemos crear métodos sin tipo de retorno, estos son los void, al igual que el otro tipo, estos pueden o no llevar argumentos y al no devolver un valor simplemente se ejecutan las acciones del cuerpo.

void miMetodo()
{
System.out.println("llamaste a este método");
} 

Al llamar al método  " miMetodo() " el resultado seria simplemente el mensaje especificado en su cuerpo
un metodo void con argumentos.

void miMetodo(String  nombre, String apellido)
{
System.out.println("Bienvenido a la programación Don :"+nombre +" "+apellido);
}

Lo cual devolvería:   Bienvenido a la programación Don -------  --------
*siendo estricto todos los métodos tienen valor de retorno, ya que void también es un tipo de retorno.

Cuando cambiamos los valores de variables de instancia (son las declaradas afuera de cualquier método  incluyendo el o main). en un método, estos nuevos valores solo se mantienen validos al interior del método a menos que sea una variable de tipo static.
*las variables declaradas como static (static int numero;) cambian sus valores reales desde cualquier lugar de una clase


EJ:


class EjemploMetodos
{
    //metodo con tipo de valor de retorno y argumentos
    int suma(int num, int num2)
    {
    int suma = num+num2;
    return suma;
    }
    //metodo con tipo de retorno void
    void mensaje(int num, int num2)
    {
    System.out.println("El valor de la suma es :"+(num+num2));
    }
 
    public static void main(String[]argumentos)
    {
    EjemploMetodos ini = new EjemploMetodos();
 
    System.out.println("La suma es :"+ini.suma(44, 12));
    ini.mensaje(10,15);//lamamos directamente al metodo void
 
    }//fin del main
}//fin de la clase



En el main, instanciamos la nuestra propia clase para poder llamar a los metodos desde su interior, ya que el método main al ser static solo permite llamar a otros metodos estáticos (static)  con la instanciacion eliminamos este problema.
llamamos al método suma a traves de la variable ini que creamos.  "ini.suma( )" y le pasamos dos argumentos de tipo int. el método realiza su tarea y devuelve un valor int que es la suma de los dos especificados.

*Es un error en tiempo de compilación especificar valores de otros tipos de datos a los solicitados por el método llamado.

*El método  println no permite poner en su interior métodos con valor de retorno void.

*Los metidos con tipo de valor de retorno, si no son usados en un mensaje deben pasarse como valor a otra variable ya que de lo contrario el retorno (un valor) queda sin contenedor.

*Es necesario que te familiarices con la vasta coleccion de clases de la api de Java, asi que evita inventarlo todo de nuevo, hay cerca de 6000 clases disponibles. http://docs.oracle.com/javase/6/docs/api/
*todas las clases  extienden de manera predeterminada del paquete java.lang que es el paquete padre de todo programa en java, es por eso que se pueden utilizar clases como String, Math, System... sin necesidad de importarlas.
*no se puede declarar un metodo dentro de otro.



Constructores 

Un constructor es una clase especial de método del cual podríamos diferenciarlos por:

1. Un constructor debe tener el mismo nombre de la clase en que se declara.

2. El constructor no tiene tipo de valor de retorno.

3. Los constructor no usa la sentencia return.


La labor del constructor es poner a los objetos de la clase en un estado consistente, es decir, el constructor inicializa las variables de clase y las pone en un estado correcto para ser utilizadas,
Cuando tenemos variables de clase y estas no han sido inicializadas con valores se produce un error en tiempo de ejecución, es por ello que el constructor se encarga de dicha tarea.
De manera predeterminada las variable de tipo primitivo se inicializan en 0, a excepcion de las booleanas que se establecen en false y las de tipo de referencia (cono un String) en null.

Los constructor se ejecutan de manera predeterminada cuando instanciamos una clase atraves de la palabra clave new. en caso de no especificar un constructor, el compilador establece un constructor sin argumentos para inicializar las variables y poder poner al programa de manera consistente en la memoria.

Java nos permite tener mas de un constructor por clase a través de la denominada "sobrecarga de constructores. Esto es diferenciar a los diferentes constructores solo por el numero y tipo de sus argumentos.
ej:

class Sobrecarga
{
 Sobrecarga(){
}//fin del constructor 1

Sobrecarga(int valor1){
}//fin del constructor 2

Sobrecarga(String nombre, int valor1){
}//fin del constructor 3

}//fin de la clase

Al instanciar nuestra clase Sobrecarga, podemos hacer la diferencia entre que constructor necesitamos utilizar dependiendo del numero de argumentos que le pasemos.

por ejemplo para ocupar el constructor 3:

Sobrecarga instancia = new Sobrecarga ("Pedro Gonzales",14); //el numero y orden de los argumentos
                                                                                                   debe ser el mismo que en la declaración
                                                                                                   del constructor.


Tambien es posible hacer que los diferentes constructores de una clase se comuniquen entre si, atraves de la palabra clave this.
la palabra clave this nos permite llamar a un constructor dentro de otro. ejemplo.



class Generalidades
{
    int numeroi;
    int numeroe;    //estas dos variables no las inicialize para que lo hagan los constructor
 
    Generalidades(int i, int e)          /*constructor de dos variables.
    {
    numeroi = i;                             * le damos los valores de los argumentos  i y e a las variables de instancia,                    
    numeroe = e;                           */inicializandolas.
    }
 
    Generalidades(int x)            /*segundo constructor con un solo argumento, este constructor
   {                                           *utiliza this para llamar al contructor de dos argumentos
    this(x, 0);                             *y le pasa el valor de X como primer argumento y establece el segundo
   }                                         */en un valor cualquiera
 
    void imprimir()
    {
        System.out.printf("valor de numeroi : %d\nvalor de numeroe : %d\n",numeroi, numeroe);
    }
 
    public static void main(String[]agrs)
    {
        Generalidades ini = new Generalidades(55);  /*llamamos al constructor de un solo argumento
        ini.imprimir();                                                *y le damos un solo valor, este lo establecen en su
                                                                            *En su variable X y se lo pasa atraves de this al
    }//fin del metodo main                                       * constructor de dos argumentos.
}// Fin de la clase




la salida de este programa es la sgte:


valor de numeroi : 55
valor de numeroe : 0
GENERACIÓN CORRECTA (total time: 0 seconds)

Como pueden comprobar a pesar de que llamamos en la instanciacion al contructor  de un argumento, en realidad llamamos al de dos.

Especificadores de Acceso

Un especificador (modificador) de acceso o alcance es una palabra clave (reservada) que nos permite controlar nivel de alcance que tiene cada variable, método o clase. Existen tres public, protected,  private, static, final. 

public establece un nivel de acceso total, es decir  una clase public puede ser usada por otras clases del mismo paquete y de otros paquetes no relacionados, lo mismo para los métodos y variables.
public es el especificador de acceso mas utilizado en estudiantes ya que no nos enfrentamos a la dificultad (¿..?) de tener que determinar que se puede y que no se puede utilizar en un clase.

private establece un nivel restringido de acceso, En el cual los miembros declarados como tal solo son accesibles dentro de la clase, aunque la clase herede de esta ultima. las variable y métodos private son usados cuando los clientes de una clase no deben preocuparse (ni les debe importar) como se efectúan las acciones claves de un programa. establecer miembros private establece el mayor nivel de seguridad.

protected establece un nivel de acceso intermedio entre public y private en el que los miembros solo son accesibles por clases y métodos dentro del mismo paquete.

static el modificador static crea variables y metodos de clase (a esto es lo que nos referimos cuando hablamos de variables de clase) estos objetos pueden ser llamados desde cualquier parte de la clase modificando sus valores reales de forma definitiva. la diferencia con una variable normal es que cuando llamamos a una variable de instancia (normal) cambiamos su valor solo en ese instancia (metodos, etc..) en cambia una variable estatica cambia de valor definitivamente cada vez que se llama, en palabras simples actualizamos su valor real desde cualquier parte del programa.


final el modificador final, crea una constante, en realidad en java no existen las constantes, pero final hace que las variables imiten su comportamiento. Cualquier intento por modificar una variable final creara un error en tiempo de ejecucion.
Un ejemplo de final, es la variable PI, de la clase Math


class Generalidades
{
  public static void main(String[]agrs)
    {
        System.out.println("El valor de  Pi es"+ Math.PI);
        System.out.println("nuevo valor de Pi"+(Math.PI = 5));//intentamos cambiar el valor de PI

    }//fin del metodo main
}// Fin de la clase

Esta seria la salida del compilador.:


El valor de  Pi es3.141592653589793
Exception in thread "main" java.lang.RuntimeException: Uncompilable source code - cannot assign a value to final variable PI
at Ejemplo.Generalidades.main(Generalidades.java:12)


lo que esta en rojo es la descripción del error cannot assign a value to final variable PI (no se puede asignar un valor a la variable final PI)


conforme avance el curso iremos agregando mas datos sobre los modificadores y especificadores.