Despre autoboxing

 Începând cu Java 1.5 s-a introdus autoboxing-ul, adică o conversie automată de tip, dintr-o variabilă primitivă, către tipul wrapper corespunzător, sau invers. Folosirea lui este simplă, dacă au fost înțelese bine limitările și riscurile.

package work;

public class Autoboxing {
    public static void main (String [] args){
        //int si Integer raman totusi doua clase diferite:
        System.out.println(int.class);
        System.out.println(Integer.class);
       
        //atentie la overloading!
        metoda(2);
        metoda(Integer.valueOf(2));
        metoda((Integer)3);
       
        Integer i1 = 3, i2 = null;
//compilatorul poate permite "i1 + i2" chiar daca i2 este null
        System.out.println(i1 + i2);
    }  

    public static void metoda(Integer i){
        System.out.println("metoda(Integer i) !");
    }

    public static void metoda(int i){
        System.out.println("metoda(int i) !");
    }
}

Atenție la numele variabilelor

Ce poate provoca mai multă confuzie decât refolosirea unor nume de variabile ? Studiați exemplul următor și vă veți convinge.

/**
 * Ce se afiseaza la consola prin rularea functiei main() ?
 * Explicati ce se intampla la fiecare pas.
 * Ce concluzii trageti?
 */
package work;
class ClasaExterna {
    private int i;
   
    class ClasaInterna1 {       
        ClasaInterna1(int i){   
            i = i;
        }
    }   
    class ClasaInterna2 {
        ClasaInterna2(int j){
            i = j;
        }   
    }   
    class ClasaInterna3 {
        private int i;       
        ClasaInterna3(int k){
            i = k;
            this.i = k;
        }
    }
       
    public int getI(){
        return i;
    }   
}

public class TestClaseInterne1{
    public static void main (String [] args){
        ClasaExterna ce = new ClasaExterna();
        ce.new ClasaInterna1(3);
        System.out.println(ce.getI());

        ce.new ClasaInterna2(4);
        System.out.println(ce.getI());

        ce.new ClasaInterna3(5);
        System.out.println(ce.getI());
    }
}

Clase locale

Se poate declara o clasă în interiorul unei metode? Dacă da, cum se folosește o astfel de clasă  ?

/**
 * Ce erori apar la compilarea codului urmator ?
 * Ce trebuie modificat pentru a se putea compila?
 */
package work;
public class TestClasaInMetoda {
    private static String str1 = "xyz";
    private String str2 = "123";
    
    public void oMetoda (String str){
        String str3 = "blabla";
        
        class ClasaInMetoda{
            private String str4 = str1;
            private static String str5 = str2;
            private String str6 = str3;
            private String str7 = str;

            ClasaInMetoda(){
                System.out.print(str4+" "+str5+" "+str6+"  "+str7);
            }           
        }
        
        new ClasaInMetoda();
    }
    
    public static void main (String [] args){
        new TestClasaInMetoda().oMetoda("a");
    }
}

Semnificația lui "protected"

Vă lansez o provocare.  Răspundeți la întrebarea: pentru ce se folosește modificatorul de acces "protected" ? Gândiți-vă la situații unde el este mai oportun decât ceilalți modificatori (public, private sau default). Dacă nu vă descurcați cu răspunsul, sunteți încurajați să consultați documentația oficială sau diverse tutoriale.
După ce ați răspuns și ați găsit exemple, priviți codul următor:

/**
  * Codul de mai jos se compileaza?
 * De ce s-ar putea dori o metoda "protected final" ?
 */
package work;
public class ClasaCuMetoda_ProtectedFinal {
    protected final void metoda(){
        //niste cod
    }
}

Regulă încălcată ?

/**
 * Cum de este posibila suprascrierea unei metode finale ?
 * La ce bun o metoda "private final" ? (justificati cu exemplu)
 */
package work;
class ClasaUnu {
    private final void metodaFinala(){
        System.out.println("metodaFinala() din ClasaUnu");
    }  
}

class ClasaDoi extends ClasaUnu {
    public final void metodaFinala(){
        System.out.println("metodaFinala() din ClasaDoi");
    }
}

Ce poate conține o interfață (2)

/**
 * Ce se poate pune intr-o interfata?
 * (este important sa aveti imaginatie bogata)
 * Cum s-ar putea folosi aceasta "facilitate" de limbaj ?
 */

package work;
public interface InterfataCuprinzatoare{
//mai intai, chestii standard
    int i=5; // implicit, este si "public static final"
    public void metodaBuna(Object... parametri);

//  public static void metStatica(){};//nu metode statice
//  public InterfataCuprinzatoare(){};//nu constructori

//si acum incepem sa improvizam   
    public InterfataCuprinzatoare obiect = null;
    static enum Enum1 {VAL1("valoare 1"), VAL2("valoare 2");
        Enum1 (String nume){
            this.nume = nume;
        }
        private String nume;
        public String toString(){
            return this.nume;
        }
    }   
    enum Enum2 implements InterfataCuprinzatoare{V1, V2, V3;
        public void metodaBuna(Object... parametri) {
            System.out.println(parametri);           
        }
    }   
    static class Cls1{
        private String nume;       
        public Cls1(){
            System.out.println("Un nou obiect Cls1");
        }       
        Cls1(String nume){
            this();
            this.nume = nume;
        }       
    }
    abstract class Cls2{
        abstract double calcul(double d1, double d2);
    }
    final class Cls3{
        static{
            System.out.println("bloc static din clasa finala Cls3 din interfata InterfataCuprinzatoare");
        }
    }   
    class Cls4 extends Cls2 {
        double calcul(double d1, double d2) {
            return d1+d2;
        }
    }   
    class Cls5 implements InterfataCuprinzatoare{
        public void metodaBuna(Object... parametri) {
            //niste cod
        }
    }   
    interface Int1{
        char met1();
    }
    interface Int2 extends InterfataCuprinzatoare{}
   
    //etc...
}

Ce poate conține o interfață (1)

Pentru că astăzi este Ziua Națională a Franței, tema pe care v-o propun nu este foarte complexă, pentru a vă lăsa timp să urmăriți in liniște petrecerea cu focuri de artificii ce va avea loc diseară.

/**
 * De ce credeti ca o interfata nu poate declara metode statice?

 * (aveti mai jos un exemplu)
 */
package work;

interface Interfata{
    public static void metoda1(int i);
}