Capítulo 5: Descripción del ámbito de variables y construcción de clases.

• El ámbito de variables define a qué parte del código tienen acceso esas variables.
  
• Una instancia de variable se declara dentro de la clase, no dentro de un método. Esta variable se incluye pues en todo el método y permanecerá en memoria tanto tiempo como la instancia de la clase en la que fue declarada siga en memoria. Las instancias se pueden usar para almacenar el estado de un objeto, por ejemplo. Son los atributos de la clase.
  
• Cuando se hace uso de this, se está accediendo a las variables de instancia.
  
• Las variables locales pueden declararse en cualquier parte del código. Estas permanecerán en el ámbito tanto tiempo como la ejecución del código no deje el bloque donde fueron declaradas. Las variables locales se pueden usar como contador en un bucle, por ejemplo.
  
  
• Los parámetros de un método se declaran en la declaración del método, los cuales están en el ámbito para todo el método. Los parámetros se usan para pasar información al método.
  
• Las variables que se ha declarado dentro del ámbito (scope) no se puede acceder a ella fuera del ámbito.
  
• Las primitivas se pasan por valor, es decir, que su valor solo cambia en el método que las use. Por ejemplo, teniendo este método:
  void addTwo(int value) {
  System.out.println("Parameter: value = " + value);
  value = value + 2;
  System.out.println("Leaving method: value = " + value);
  }
  y con este código que llama al método:
  int value = 1;
  System.out.println("Argument: value = " + value);
  addTwo(value);
  System.out.println("After method call: value = " + value);
  
  El resultado sería:
  Argument: value = 1
  Parameter: value = 1
  Leaving method: value = 3
  After method call: value = 1
  
  
• Si no son static, pase lo que pase en el método, va a valer lo mismo fuera de él (como hemos visto), pero si se cambiase el valor de una posición del array (v[2]=3), sí cambia.
  
• Los objetos se pasan por referencia, es decir, que al cambiarlo en un método, cambia también en todo el ámbito. Por ejemplo, teniendo la clase Number:
  public class Number {
  int number;
  public Number(int number) {
  this.number = number;
  }
  int getNumber() {
  return this.number;
  }
  void setNumber(int number) {
  this.number = number;
  }
  }
  , el siguiente método:
  void addThree(Number value) {
  System.out.println("Parameter: value = " + value.getNumber());
  value.setNumber(value.getNumber() + 3);
  System.out.println("Leaving method: value = " + value.getNumber());
  }
  Y este código con la llamada al método:
  Number value = new Number(1);
  System.out.println("Argument: value = " + value.getNumber());
  addThree(value);
  System.out.println("After method call: value = " + value.getNumber());
  El resultado sería:
  Argument: value = 1
  Parameter: value = 1
  Leaving method: value = 4
  After method call: value = 4
  
• En la práctica tanto las primitivas como los objetos se pasan por valor.
  
• Un método puede devolver un valor o ninguno. El valor devuelto puede ser primitivo o un objeto.
  
• Un método debe declarar el tipo de dato de la variable que devuelve. Si no devuelve nada, se usa void.
  
• El código que haya después del return no se ejecutará y no podrá cambiar el valor de la variable que devuelve el return.
  
• Las variables static se le conocen también como variables de clase (no son variables de instancia). Cuando se crea una variable estática en una clase, todas las instancias a esta clase podrán usar esta variable, y cualquier modificación que haga un objeto de esta variable, lo verán los demás objetos instanciados. Ejemplo:
  
  class MiClase{
        static int contador = 0;
      public MiClase(){
        //Se modifica el valor en el constructor
        contador += 1;
      } 
      public static void main (String[] args){
        new MiClase();
        new MiClase();
        new MiClase();
        System.out.println("El número de clases son: "+contador); 
      } 
    }
  El resultado será : El número de clases son:3
  En este ejemplo el main es estático y por eso se puede llamar a la variable contador, pero para que un objeto pueda usar esta variable, se pondría: MiClase.contador para acceder a ella. Ejemplo:
  class MiClase{
    static int contador = 0;
    public MiClase(){
      contador += 1;
    }
  }
  
  class ProbarMiClase{
    public static void main(String[] args){
      new MiClase();
      new MiClase();
      new MiClase();
      System.out.printl("Contador: "+MiClase.contador);
    }
  }
  También se puede acceder a un componente estático de una clase mediante un objeto de dicha clase:
  MiClase mc = new MiClase();
  int clases = mc.contador;
                 
  Otro ejemplo de uso de static:
  public class Pruebajava {
      public static int num=3;
      public int valor=3;
  }
  ---
  import pruebajava.Pruebajava;
  public class PruebaClase {
      public static void main(String[] args) {
          Pruebajava p=new Pruebajava();
          Pruebajava p2=new Pruebajava();
          p.num+=1;
          p.valor+=1;
          System.out.println("Num="+p.num+" y valor="+p.valor+" de la primera instancia.");
          System.out.println("Num="+p2.num+" y valor="+p2.valor+" de la segunda instancia.");      
      }
  }
  El resultado es:
  Num=4 y valor=4 de la primera instancia.
  Num=4 y valor=3 de la segunda instancia.
  
• Otro ejemplo de uso de static: suponiendo que tenemos esta clase:
  class Test{
    static void alpha(){}
    void beta(){}
  }
•  Desde otra clase no se podrá llamar a Test.beta() sin instanciar la clase antes
• Se podrá llamar directamente a Test.alpha()
• Desde el método beta() se podrá llamar a alpha()
• Desde el método alpha() no se podrá llamar a beta() sin instanciar antes.
  
• Las constantes o variables finales se declaran mediante final . Al declarar esta constante haces que no pueda ser modificada una vez declarada e inicializada. Aunque no es obligatorio, deben ir acompañadas de static, ya que, puesto que no van a poder ser modificada, sólo suele ser necesaria una copia en memoria por clase (y no una por instancia) y así será una aplicación más óptima.