Clases, Variables Local/Global, Mod de Acceso e Instancia/Clase

Una clase se define a partir de atributos y métodos, a partir de una clase se crean objetos.

Las clases son de las que veniamos creando:

• public class NombreClase{
• }

Para poder entender a qué le deciamos clases hay que hacer uso de la imaginación. Inmaginemos en una pelota cualquiera...¿Qué es lo que hace que lo que inmaginamos sea una pelota y no otra cosa?

Probablemnte las respuestas más precisas sean que es esférica y se usa en encuentros deportivos. Justamenteel hecho de que sea de forma esférica es un "Atributo" y cada cual tiene más(peso, color, densidad, textura, etc).

Por otro lado cada tipo de pelota se usa en un deporte en especifico es por la manera que esta tiene de reaccionar (de que forma rebota, la resistencia que tiene al lanzarla, etc) estos son sus "Métodos"

Descriptos en un diagrama de clase un pelota de futbol, donde en el primer cuadro va el nombre, luego los atributos y debajo sus métodos, sería asi:

Pelota

---

+forma

+peso

+textura

+perímetro

---

+rebotar()

+patear()

Como código java esta clase sería más o menos así:

1. public class PelotaFutbol{
3.     String forma = "esférica";
4.     int peso = 450; // medido en gr
5.     String textura = "cuero";
6.     int perímetro = 70; //medido en cm
8.     public void Rebotar(){
9.         System.out.println(" La pelota ha rebotado.");
10.     }
12.     public void Patear(){
13.         System.out.println(" Haz pateado la pelota. ");
14.     }
15. }

NOTA: Aunque la clase está definida con atributos y métodos, por si sola compila pero no hace absolutamente nada ya sea porque le falta el método "main" o ser llamada desde otra clase.

Variable Local Vs Global - Scope

Una variable puede declararse en cualquier lugar dentro del cuerpo de una clase. Sin embargo no es igual declararlo dentro cuerpo de la clase que dentro de un método o estructura de control/repetición.

Una variable local se considera toda aquella que sea declarada dentro de un método o estructura de control/repetición y por su lado una variable global es aquella que se declara en el cuerpo de una clase, generalmente al principio ya que nuestro el compilador no llega a entender si usamos una variable que todavía no hemos declarado, aún declarando al final.

1. public class LocalvsGlobal {
2.     double e = 2.718;
3.     public void getE(){
4.         System.out.println(e);
5.     }
6.     public static void main(String[] args) {
7.         float pi = 3.14f;
8.         System.out.println(pi);
9.         LocalvsGlobal objeto = new LocalvsGlobal();
10.         objeto.getE();
11.     }  
12. }

En este ejemplo el número "e" es una variable local y el número "pi" es una variable local del método main. El resultado es obviamente:

• 3.14
• 2.718

Alcance (Scope)

La idea de indivdualiar a una variable por su lugar de declaración tiene que ver con su alcance (scope en inglés). Una variable que se declara "global" está disponible para toda la clase, en cambio, una variable local "nace,vive y muere" dentro del bloque donde fue declarada, modificando el ejemplo anterior veremos que se producirá un error si intentamos mostrar por pantalla a "pi" que la declaramos dentro de un bloque If, fuera de él no hay alcance de variable.

1. public class LocalvsGlobal {
2.     static double e = 2.718;
3.    
4.     public static void main(String[] args) {
5.         if (e == 2.718){
6.             float pi = 3.14f;
7.         }
8.         System.out.println(pi);
9.     }  
10. }

NOTA: Siendo un buen observador se nota que se antepuso una palabra reserva "static" en el numero "e" que es un modificador que convierte a nuestra variable global en un atributo de clase.

Modificadores de Acceso: Encasuplamiento

Los modificadores son las palabras claves que le añadimos a las definiciones de clases, paquetes, variables y métodos.

• Modificadores de Acceso: (Determina que variables y métodos son visibles para otras clases)
  • Public
  • Protected
  • Default
  • Private
• Modificadores de Instancia/Clase: (Convierte a métodos y variables "de instancia" a "de Clase")
  • Static
  • Default: no-estático
• Modificador de Fijación: (Hace inmodificable variable, métodos y clases)
  • Final
  • Default: no-final
• Modificador Abstracto: (Impide la instanziación)
  • Abtract
  • Default: no-abstracto
• Modificadores de Hilos: (Usados en Threads-hilos de ejecución)
  • Synchronized
  • Volatile

De momento nos centraremos en los 3 primeros modificadores: De acceso, de Instancia/Clase y de Fijación.

Modificadores de Acceso: Encapsulamiento

El encapsulamiento es el proceso que hace que tanto variables como métodos de una clase sean visibles a otras, es decir si bien odemos hacer uso de sus atributos sólo es posible modificar los mismos mediante los propios métodos definidos y no podremos saber como se ejecutan esos métodos ya que se lo guardan para si aunque entregan el resultado. Esto detalles de la implementación de los métodos permanecen "ocultos" a quienes usan las clases, evitando así modificaciones o accesos indebidos a los datos que almacenan las clases. Además, el usuario de la clase no se tiene que preocupar de cómo están implementados los métodos y propiedades, concentrándose sólo en cómo debe usarlos. La encapsulación es una de las principales ventajas que proporciona la programación orientada a objetos.

Public: hace que estén totalmente disponibles para cualquier otra clase.

• Ejemplo: public static void main(String[] args){}

Protected: Limita el acceso a cualquier clase no sea sub-clase o esté fuera del paquete

Default: Cuando no ponemos nada solo podrán acceder una clase dentro del paquete o de la misma clase

Private: Evita que sus métodos o variables sean usandos por ninguna otra clase

Acceso	Clase	Package	Subclase	Todos
public	si	si	si	si
protected	si	si	si	NO
Default	si	si	NO	NO
private	si	NO	NO	NO

De esta manera por ejemplo, un método private no podrá ser llamado por un objeto que viva en un paquete diferente.

Instancia Vs Clase

Nuestro modificador de Movilidad: "static" convierte a nuestras variables y métodos de instancias a variables y métodos de clase.

Una variable o método de instancia es aquel que obviamente no lleva el modificador static, y pertenece a la "instancia" (objeto particular) por lo tanto al ser modificado/eliminado, etc solo afecta a dicho objeto y no a cualquier otro objeto creado a partir de la clase. También será necesario que el objeto invoque al método o atributo para ser usado.

En este primer ejemplo creamos variables globales de instancia que son tomadas por un método de instacia que un objeto "dario" llama para ser mostrada

1. public class Persona {
2.     String nombre = "Darío";
3.     int anios = 25;
4.     String colorOjos = "verdes";
5.    
6.     public void datosPersonales(){
7.         System.out.println("Mi nombre es " + nombre);
8.         System.out.println("Tengo " + anios + "años");
9.         System.out.println("Y tengo los ojos color " + colorOjos);
10.     }
11.     public static void main(String[] args) {
12.         Persona dario = new Persona();
13.         dario.datosPersonales();
14.     }
15. }

• Mi nombre es Darío
• Tengo 25años
• Y tengo los ojos color verdes

En este segundo ejemplo vemos como pese que se modifican las variables de instancias con un objeto "pedro", al crear otro objeto darío sigue teniendo los valores iniciales

1. public class Persona2 {
2.     String nombre = "Darío";
3.     int anios = 25;
4.     String colorOjos = "verdes";
5.    
6.     public void datosPersonales(){
7.         System.out.println("Mi nombre es " + nombre);
8.         System.out.println("Tengo " + anios + "años");
9.         System.out.println("Y tengo los ojos color " + colorOjos);
10.     }
11.     public void setDatosPersonales(String unNombre, int unosAnios, String unColorOjos){
12.         nombre = unNombre;
13.         anios = unosAnios;
14.         colorOjos = unColorOjos;
15.     }
16.     public static void main(String[] args) {
17.         Persona2 dario = new Persona2();
18.         Persona2 pedro = new Persona2();
19.         pedro.setDatosPersonales("Pedro", 20, "Azules");
20.         pedro.datosPersonales();
21.         dario.datosPersonales();
22.     }
23. }

• Mi nombre es Pedro
• Tengo 20años
• Y tengo los ojos color Azules
• Mi nombre es Darío
• Tengo 25años
• Y tengo los ojos color verdes

---

Por su parte un métodos y/o atributos de clase es llevan la palabra reservada "static" y esto hace pertenecer a la "clase" por ende tiene que ser la clase que llame a la variable o método, y esto afecta a todos los objetos que seancreados a partir de esta clase.

1. public class Persona {
2.     static String nombre = "Darío";
3.     static int anios = 25;
4.     static String colorOjos = "verdes";
5.    
6.     public void datosPersonales(){
7.         System.out.println("Mi nombre es " + nombre);
8.         System.out.println("Tengo " + anios + "años");
9.         System.out.println("Y tengo los ojos color " + colorOjos);
10.     }
11.     public static void setDatosPersonales(String unNombre, int unosAnios, String unColorOjos){
12.         nombre = unNombre;
13.         anios = unosAnios;
14.         colorOjos = unColorOjos;
15.     }
16.     public static void main(String[] args) {
17.         Persona dario = new Persona();
18.         Persona pedro = new Persona();
19.         dario.datosPersonales();
20.         Persona.setDatosPersonales("Pedro", 20, "Azules");
21.         pedro.datosPersonales();
22.         dario.datosPersonales();
23.     }
24. }

El resultado será que se crea una "persona dario" con sus atributos, luego se crea otra "persona pedro" y la clase a través de Persona.setDatosPersonales("Pedro", 20, "Azules"); modifica a toda la clase entonces las 2 personas modifican sus valores de la siguiente manera:

• Mi nombre es Darío
• Tengo 25años
• Y tengo los ojos color verdes
• Mi nombre es Pedro
• Tengo 20años
• Y tengo los ojos color Azules
• Mi nombre es Pedro
• Tengo 20años
• Y tengo los ojos color Azules

NOTA: Al menos yo creia que al modificar los atributos en un tiempo "t2" a partir de ese momento todos los objetos cambiaban, quizás engañado por el System.out que en un tiempo t1 me muestra otros valores y en realidad es como una foto que se toma del objeto y no se actualiza magicamente en un tiempo t2, claramente se ve como la "persona dario" cambia de nombre por estar mirando a la misma clase que cambio.