Objetos, Composición y miembros static

En java Casi todo es un objeto, la única excepción como ya se ha explicado son los tipos primitivos.
Los modificadores de acceso (public private, protected, friendly) nos permiten definir el alcance y desde
donde se puede acceder a los objetos. Es una buena practica de programación que establezcamos los métodos y variables importantes de una clase como private, por lo general se declaran así cuando son objetos a los que no se deben acceder directamente, para ello establecemos -a su vez- métodos public para modificar dichos valores. por ejemplo:

private int saldo; //variable declarada como private

public void agregarSaldo(int valor)
{
   if(valor >0)
  {
   saldo = saldo+valor;
  }else{
  System.out.println("debe ingresar un monto mayor  a 0");
  }
}//fin método modificarSaldo

Como podemos ver acá tenemos una variable <<saldo>> que esta como private para que no pueda
ser modificada desde ningún otro lugar que no sea la misma clase en que se declara, y a su vez tenemos un método <<agregarSaldo>> que es la encargada de modificar el saldo, siempre y cuando se cumpla una condición, en este caso que el valor ingresado sea mayor que 0. también podríamos tener un método
restarSaldo que solo permita restar un monto no mayor a 200000 como es el caso de los cajeros automáticos chilenos. Con estos métodos ponemos un limite en el acceso a lo que seria un valor importante como saldo.

ejercicio sugerido: Crea una clase Cuenta, con metodos deposito, giro y consulta, cada metodo debe validar sus datos y enviar mensajes apropiados en caso por ejemplo que de se intente hacer un giro mayor al saldo disponible. la variable saldo debe ser private y los memtodos public. crea el metodo main en otra clase.

this

Todos los objetos pueden acceder a una referencia de si mismos a través de la palabra clave this 

ej:

private int saldo;

   

   public void agregarSaldo(int saldo)

   {

   this.saldo = this.saldo + saldo;

   }

En este pequeño fragmento de código utilizamos la palabra "this" para hacer referencia a la variable saldo de

la clase, pues en caso contrario estaríamos haciendo referencia a la variable local "saldo" del método.

con this también podemos diferenciar entre dos variables en las relaciones de herencia, en caso de que nos vemos a declarar variables con el mismo nombre tanto en la superclase como el la subclase.

otro uso de this, es para referenciar a un constructor de la misma clase, por ejemplo:

public class referenciaThis{

  
    referenciaThis(int n1)
   {
    this(2,5); //esta llamada debe ser siempre la primera linea del constructor
   }
   
   referenciaThis(int n1, int n2)
   {
   

   }

}//fin de la clase refenciaThis.

Para llamar a un constructor dentro de otro, en la misma clase utilizamos simplemente this sin el nombre
del constructor y debemos asegurarnos que esta llamada sea la primera declaración en el constructor. poner un punto después de this para llamar a un constructor es un error de sintaxis.
¿pero como sabemos cual es el constructor al cual llamamos? La llamada se distingue a través de sus paramentos, en este caso como ponemos 2 y 5 estamos indicándole a this que llamamos al constructor de dos parámetros.
es un error auto-invocar a un constructor, es decir hacer que un constructor se llame a si mismo, esto produce recursividad infinita.
también cable aclarar que esta llamada a un constructor a través de this, es solo valida dentro de otro constructor y no de un método normal.

Un constructor puede llamar a los metodos de una clase simplemente utilizando su nombre y la lista de parámetros adecuada, pero debes tener en cuenta que el constructor esta inicializando el objeto (la clase) por lo que las variables de instancia pueden no estar en un estado consistente. Para evitar errores lógicos no realices llamadas a métodos que muestren o modifiquen variables de instancia que no han sido inicializadas

Composición

La capacidad de una clase de contener referencias de otra clase como miembros se conoce como Composición. por ejemplo una clase Calculadora debería tener referencia a la clase Numeros para realizar sus operaciones. La composición es una de las herramientas de re-utilización de software mas poderosas, ya que podemos crear objetos que sean útiles para múltiples objetos futuros.. por ejemplo podemos tener una clase Fecha que nos devuelva la fecha actual, y dicha clase la podriamos utilizar al interior de una clase agendaDespertador que utilice a la clase Fecha para comprobar si tenemos citas o recordatorios para la fecha actual.

Ejemplo:
Creamos una clase Triangulo que puede ser instanciada en cualquier parte donde necesitemos un triangulo. este ejemplo básico puede ser ampliado para obtener mas especificaciones del triangulo como el perimetro o la superficie.

public class Triangulo {

private int  altura, b, posX, posY;  
   
    Triangulo(int altura, int b) //constructor encargado de crear el triangulo e inicializar las variables
    {
    this.altura = altura;
    this.b = b;
    }
   
    int areaTri()
    {
    return (altura*b)/2;       //retorna el area
    }
   
    void setPosicion(int pX, int pY) //establece la posicion en el plano
    {
    posX = pX;
    posY = pY;
    }
   
    String getPosicion()  //retorna la posicion como un String con formato
    {
    String pos = ("X="+posX+",Y="+posY);  
    return pos;
    }
}//FIN DE LA CLASE


public class PruebaFiguras {

  public static void main(String []args)
  {
    Triangulo t1 = new Triangulo(15, 10); //crea el primer triangulo
    t1.setPosicion(100, 100);
    System.out.printf("%s\n%s%d\n%s%s\n\n","Triangulo 1","Area :",t1.areaTri()
            ,"Posicion :",t1.getPosicion());
   
    Triangulo t2 = new Triangulo(22,18); //crea el segundo triangulo
    t2.setPosicion(300, 100);
    System.out.printf("%s\n%s%d\n%s%s\n\n","Triangulo 2","Area :",t2.areaTri()
            ,"Posicion :",t2.getPosicion());
  }  //fin del metodo main
}//fin de la clase PruebaFiguras

*******************
la salida es la siguiente:

Triangulo 1
Area :75
Posicion :X=100,Y=100

Triangulo 2
Area :198
Posicion :X=300,Y=100

GENERACIÓN CORRECTA (total time: 0 seconds)

Este simple ejemplo nos demuestra que una clase "es una fabrica de objetos" en este caso objetos triángulos que podríamos utilizar en cualquier momento para saber un área, un perímetro o incluso posicionarlo en un plano o interfaz gráfica. Al crear objetos que sean re-utilizables ahorraremos tiempo en escribir codigo que ya puede estar probado y depurado de antemano.

Miembros static

Cada objeto mantiene una copia de todas las variables de instancia de clase, en algunos casos solo es necesario compartir una copia de alguna variable entre todos los objetos de la misma clase, con el objetivo de que los cambios escritos en dicha variable sean vistos por cualquier objeto de las clases.

Para estos fines utilizamos los denominados campos static o mejor llamadas variables de clase 

Veamos un ejemplo con datos static. Suponga que tenemos un videojuego con Marcianos y otras criaturas espaciales. Cada Marciano tiende a ser valiente y deseoso de atacar a otras criaturas espaciales cuando sabe que hay al menos otros cuatro Marcianos presentes. Si están presentes menos de cinco Marcianos, cada Marciano se vuelve cobarde. Por lo tanto, cada uno de ellos necesita saber el valor de cuentaMarcianos. Podríamos dotar a la clase Marciano con la variable cuentaMarcianos como variable de instancia. Si hacemos esto, entonces cada Marciano tendrá una copia separada de la variable de instancia, y cada vez que creemos un nuevo Marciano, tendremos que actualizar la variable de instancia cuentaMarcianos en todos los objetos Marciano. Las copias redundantes desperdician espacio y tiempo en actualizar cada una de las copias de la variable, además de ser un proceso propenso a errores. En vez de ello, declaramos a cuentaMarcianos como static, lo cual convierte a cuentaMarcianos en datos disponibles en toda la clase. Cada objeto Marciano puede ver la cuentaMarcianos como si fuera una variable de instancia de la clase Marciano, pero sólo se mantiene una copia de la variable static cuentaMarcianos. Esto nos ahorra espacio. Ahorramos tiempo al hacer que el constructor de Marciano incremente a la variable static cuentaMarcianos; como sólo hay una copia, no tenemos que incrementar cada una de las copias de cuentaMarcianos para cada uno de los objetos Marciano.



Las variables static tienen alcance a nivel de clase. Los miembros public static de una clase pueden
utilizarse a través de una referencia a cualquier objeto de esa clase, o califi cando el nombre del miembro con el nombre de la clase y un punto (.), como en Math.random(). Los miembros private static de una clase
pueden utilizarse solamente a través de los métodos de esa clase. En realidad, los miembros static de una
clase existen a pesar de que no existan objetos de esa clase; están disponibles tan pronto como la clase se carga en memoria, en tiempo de ejecución. Para acceder a un miembro public static cuando no existen objetos de la clase (y aún cuando sí existen), se debe anteponer el nombre de la clase y un punto (.) al miembro static de la clase, como en Math.PI. Para acceder a un miembro private static cuando no existen objetos de la clase debe proporcionarse un método public static, y para llamar a este método se debe califi car su nombre con el nombre de la clase y un punto. (Las clases, por ejemplo Math son importadas indirectamente atrevez del árbol de herencia implícito de java, Recuerda que toda clase en java hereda de la clase Object.)