Keyword static - JAVA

La paraula clau static, en Java, defineix un membre d'una classe que s'utilitzarà de manera independent als objectes d'aquesta classe. Podem utilitzar static en atributs (variables) i/o métodes. Si definim un atribut com a static no es crean còpies d'aquesta atribut, sinó que  tots els objectes creats a partir d'aquesta classe compartiran el mateix valor.

Normalment, s'accedeix a un membre d'una classe a través d'un objecte d'aquesta (instanciació). No obstant, quan declarem un membre com a static podrem accedir a aquest abans de crear objectes d'aquesta classe i sense referències a cap objecte.

L'escriptor suïs Robert Walser

Si ens fixem en el codi de l'entrada anterior veiem que no ens ha calgut crear o instanciar cap objecte de la classe exempleOl per a cridar els diferents métodes sobrecarregats. En aquest exemple, estem cridant métodes que es troben dins de la mateixa classe. Si vulguessim executar métodes d'una altra classe
només hauríem d'especificar el nom d'aquesta seguit de l'operador punt i el métode en qüestió:

nomClasse.nomMetodeEstatic

Els métodes static tenen una sèrie de restriccions:

• Només poden invocar directament altres métodes static
• Només poden accedir directament a dades static
• No tenen una referència this

Blocs estàtics

En ocasions, una classe requereix certa inicialització abans de que es puguin crear objectes d'aquesta. Per exemple, podem necessitar establir una connexió a una base de dades o inicialitzar determinades variables static. En aquests casos, Java permet declarar un bloc static que s'executarà al carregar la classe per primera vegada. Veiem-ne un exemple:

public class StaticBlock {

    static double valor1;
    static double valor2;

    static { // Aquest bloc s'executarà al carregar la classe

        System.out.println("Dins el bloc estàtic");
        valor1 = Math.sqrt(2.0);
        valor2 = Math.sqrt(3.0);
        
    }

    public StaticBlock(String msg) {
        System.out.println(msg);
    }

}

class SDemo {
    public static void main(String[] args) {
        StaticBlock ob = new StaticBlock("Dins el constructor");

        System.out.println("Valor1: "+StaticBlock.valor1);
        System.out.println("Valor2: "+StaticBlock.valor2);
    }
}

El resultat generat és el següent:

Dins el bloc estàtic
Dins el constructor

Valor1: 1.4142135623730951
Valor2: 1.7320508075688772

Sobrecàrrega de métodes en JAVA

En Java, dos o més métodes de la mateixa classe poden compartir el mateix nom sempre i quan la seva signatura ,el número i/o tipus de paràmetre, sigui diferent. Aquesta técnica s'anomena sobrecàrrega de métodes o overloading. Veiem-ne un exemple:

class exempleOl {

    static void metodeCalcular(int x) {

        System.out.println("int");

    }

    static void metodeCalcular(long x) {

        System.out.println("long");

    }

    static void metodeCalcular(float x) {

        System.out.println("float");

    }

    static void metodeCalcular(double x) {

        System.out.println("double");

    }

    public static void main(String[] args) {

        int i = 5;
        long l = 12;
        float d = 5.0f;
        byte b = 2;
        short s = 5;

        metodeCalcular(i);
        metodeCalcular(l);
        metodeCalcular(d);
        metodeCalcular(b);
        metodeCalcular(s);

    }
}
La sortida serà la següent:

int long double int int

L'ordre d'execució és de menor a major tipus de dada. Com no existeix un métode per al tipus primitiu byte o short, el compilador executa el métode del tipus int, ja que int permet encabir valors de tipus byte o short (conversió de tipus).
És per això que quan cridem a metodeCalcular() amb un byte o short com argument, s'executarà metodeCalcular(int x).

Regles per a la sobrecàrrega de métodes:

• Han de canviar la llista d'arguments (el tipus o número de paràmetres del métode).
• Poden canviar el tipus de retorn del métode.
• Poden canviar el modificador d'accés.
• Poden declarar nous tipus d'excepcions o ampliar-les.
• Un métode pot ser sobrecarregat en la mateixa classe o en una subclasse.

De la mateixa manera que els métodes, els constructors també poden ser sobrecarregats. Així, podem crear objectes de diferents maneres en funció del constructor cridat alhora d'instanciar una classe.

JAVA - Accés als membres d'una classe - Part II - package i private

Continuant amb els modificadors d'accessibilitat als membres d'una classe, ens restava per veure els nivells d'accés package i private.

Nivell package. Quan no s'especifíca un modificador d'accessibilitat a un membre, aquest només és accessible per altres subclasses dins el seu propi paquet de classes.Aquest nivell d'accés és més restrictiu que el protected.
Veiem-ne un exemple:


public class SuperClassA {

int superclassVarA;
void superclassMetodeA(){

...

}

}


En aquest exemple, la variable superclassVarA i el métode superclassMetodeA han estat declarats sense el modificador, per tant, només seràn accessibles dins del mateix paquet. Té restricció de paquet.

Nivell private. És el més restrictiu de tots els nivells d'accessibilitat. Els membres privats només són accessibles per altres membres de la mateixa classe.  Els membres amb modificador private no són heretats per la subclasse. En el següent exemple veiem que tant superclassVarA com superclassMetodeA tenen el nivell d'accés private, per tant, no són accessibles des de qualsevol lloc que no sigui la mateixa classe.


public class SuperClassA {

private int superclassVarA;
private void superclassMetodeA(){

...

}

}


JAVA - Accés als membres d'una classe - Part I - public i protected

Una classe pot controlar l'accés als seus membres (métodes o atributs) per part d'altres classes.

És a dir, pot determinar quina informació és accessible i quina no ho és. Hi ha quatre nivells diferents d'accessibilitat:

• public
• protected
• default (també anomenat package)
• private         

Si no s'especifica cap nivell, el membre, per defecte,  té accessibilitat de paquet o default.

Nivell public. És el menys restrictiu de tots els nivells. Un membre públic és accessible des de qualsevol lloc, ja sigui des del mateix paquet que conté la classe o des d'altres on aquesta classe és visible.

Nivell protected. Un membre protected és accessible en totes les classes dins del mateix paquet i per totes les subclasses de la classe en qualsevol paquet des d'on sigui visible aquesta. És a dir, classes no heretades en altres paquets no poden accedir a membres protected.

Una subclasse en un altre paquet només pot accedir a membres protected de la superclasse a través de referències del seu propi tipus o subtipus. Veiem un exemple:

// fitxer SuperClasseA.java
public class SuperClasseA {      // En el paquet packageA

protected int variableClasseA;  // membre protegit
protected void metodeClasseA () { ...}  // membre protegit

}

// fitxer subClasseB.java
package packageB;
import packageA.*;

public class subClasseB extends SuperClasseA {   // En el paquet packageB

SuperClasseA objRefA = new SuperClasseA();
void subMetodeClasseB (subClasseB objRefB){

objRefB.metodeClasseA();   // OK
objRefB.variableClasseA = 15;  // OK
objRefA.metodeClasseA();             // NO OK
objRefA.variableClasseA = 20;      // NO OK

}
}

Un membre protected d'una superclasse només és accessible per una subclasse que estigui en un altre paquet, a través de l'herència.