Constantes

Aqui va una breve descripción de como funcionan las constantes en java.

Las constanes pueden ser de varios tipos. Por un lado las constantes normales y corrientes de toda la vida. Se especifican con la palabra clave final y pueden ser privadas, publicas o estáticas dependiendo de gustos y necesidades del momento.

Si intentas hacer un objeto constante,como en el caso de un array (si, un array es un objeto),lo que obtienes es que la constante es la referencia al objeto. pero el contenido del objeto no es constante pa'que veas:

//Constantes.java
// diferentes usos y tipos de constantes en java
class Valor{
int i = 1;
}

import java.util.Random;
public class Constantes{
static final Random rand = new Random();
// hay constantes en tiempo de compilación. Las constantes de toda la vida....
final int i1=9;
static final int VAL_DOS=99;
// y la tipica topica
public static final int VAL_TRES = 39;
// no pueden ser contantes en tiempo de compilacion
final int i4 = rand.nextInt(20);
static final int i5 = rand.nextInt(20);
Valor v1 = new Valor();
final Valor v2 = new Valor();
static final Valor V3 = new Valor();
// arrays
final int[] a = {1,2,3,4,5,6,7,8,9};
public void escribir(String id){
System.out.println( id +": " + " i4= " + i4 + " i5 = "+i5);
}
public static void main(String[] args){
Constantes c1 = new Constantes();
// c1.i1++; // error no se puede cambiar el valor
c1.v2.i++; // la referencia es constante el contenido del objeto no
c1.v1 = new Valor(); // se puede porque no es final
for(int i = 0; i<c1.a.length; i++){
c1.a[i]++; // un array no es una constante es un objeto
}
c1.escribir("c1");
System.out.println("creando otro objeto Constanes");
Constantes c2 = new Constantes();
c1.escribir("c1");
c2.escribir("c2");
}
}

Y… eso es todo? No. tambien se pueden hacer constantes blancas, pero entonces las tienes que inicializar en el constructor.

//ConstantesBlancas.java
// ejemplo de constantes blancas
class Elemento{ }
class ConstantesBlancas{
final int i = 0; // constante vulgar
final int j; // ¡ehh! no lo he inicializado.¡¡ Es una CONSTANTE BLANCA!!
final Elemento p; // ¡ahhh! otra constante blanca.
// las CONSTANTES BLANCAS debe inicializarse en el constructor
ConstantesBlancas(){
j=1;
p=new Elemento();
}
ConstantesBlancas(int x){ // ¿recuerdas lo de la sobrecarga de constructores....?
j=x;
p=new Elemento();
}
void escribir(){
System.out.println("i= " + i + " j= " +j );
}
public static void main(String[] args){
ConstantesBlancas cb = new ConstantesBlancas(); // constructor por defecto
cb.escribir();
System.out.println("ahi va otra");
ConstantesBlancas cb2 = new ConstantesBlancas(3); // constructor sobrecargado
cb2.escribir();
}
}

Y… eso es todo? No. tambien se pueden hacer clases constantes… -¿lo que? Pues que puedes hacer clases constantes, es decir, que no dejan que se herede de ellas. Que son clases finales… como su propio nombre indica.

//ClaseConstante.java
// de esta clase no se puede heredar
class Cerebro{String contenido = "Quiero comer";}
final class Dinosaurio{
int altura = 2;
int velocidad = 1;
Cerebro cabeza = new Cerebro();
void actuar(){
System.out.println("Soy un dinosaurio de " + altura + " que corre a una velocidad de " + velocidad + " y piensa "+ cabeza.contenido); // fijate que comvierte los enteros a caracteres al vuelo.
}
}
// la clase evolucion intentará lo propio con los dinosaurios
// pero no podrá
// class evolucion extends Dinosaurio()
public class ClaseConstante{
public static void main(String[] args){
Dinosaurio dino = new Dinosaurio();
dino.actuar();
}
}

y…. aun hay mas, puede hacer metods constantes y parametros contantes y hasta a tu abuela constante site lo propones. pero paso de ponerlo todo aqui. ¡Buscate la vida!