Scopul acestui laborator este prezentarea conceptului de clasă internă și modalitățile de creare și folosire a claselor interne în Java.

Aspectele urmărite sunt: * prezentarea tipurilor de clase interne * diferențele dintre clase interne statice și cele ne-statice * utilitatea claselor interne

Clasele declarate în interiorul unei alte clase se numesc clase interne (nested classes) și reprezintă o funcționalitate importantă deoarece permit gruparea claselor care sunt legate logic și controlul vizibilității uneia din cadrul celorlalte.

Clasele interne sunt de mai multe tipuri, în funcție de modul de a le instanția și de relația lor cu clasa exterioră: * clase interne normale (regular inner classes) * clase interne statice (static nested classes) * clase anonime (anonymous inner classes) * clase interne metodelor (method-local inner classes) sau blocurilor

O clasă internă este definită în interiorul unei clase și poate fi accesată doar la runtime printr-o instanță a clasei externe (la fel ca metodele și variabilele ne-statice). Compilatorul creează fișiere .class separate pentru fiecare clasă internă, în exemplul de mai jos generând fișierele Outer.class și Outer$Inner.class, însă execuția fișierului Outer$Inner.class nu este permisă.

Test.java

class Outer {
    class Inner {
        private int i;
        public Inner (int i) {
            this.i = i;
        }
        public int value () {
            return i;
        }
    }
 
    public Inner getInnerInstance () {
        Inner in = new Inner (11);
        return in;
    } 
}
 
public class Test { 
    public static void main(String[] args) {
        Outer out       = new Outer ();
 
	Outer.Inner in1 = out.getInnerInstance();		
	Outer.Inner in2 = out.new Inner(10);
 
	System.out.println(in1.value());
	System.out.println(in2.value());
    }
} 

În exemplul de mai sus, o dată ce avem o instanță a clasei Outer, sunt folosite două modalități de a obține o instanță a clasei Inner (definită în interiorul clasei Outer): * definim o metodă getInnerInstance, care creează și întoarce o astfel de instanță; * instanțiem efectiv Inner; observați cu atentie sintaxa folosita! Pentru a instanția Inner, avem nevoie de o instanta Outer: out.new Inner(10);

Dintr-o clasă internă putem accesa referința la clasa externă (în cazul nostru Outer) folosind numele acesteia și keyword-ul this:

Outer.this;

Așa cum s-a menționat și în secțiunea Introducere, claselor interne le pot fi asociați orice identificatori de acces, spre deosebire de clasele top-level Java, care pot fi doar public sau package-private. Ca urmare, clasele interne pot fi, în plus, private și protected, aceasta fiind o modalitate de a ascunde implementarea.

Test.java

interface Hidden {
    public int value();
}
 
class Outer {
    private class HiddenInner implements Hidden {
        private int i;
        public HiddenInner (int i) {
            this.i = i;
        }        
        public int value () {
            return i;
        }
    }
 
    public Hidden getInnerInstance () {
        HiddenInner in = new HiddenInner(11);
        return in;
    } 
}
 
public class Test {
    public static void main(String[] args) {
        Outer out             = new Outer();
 
	Outer.HiddenInner in1 = out.getInnerInstance();          // va genera eroare, tipul Outer.HiddenInner nu este vizibil
	Outer.HiddenInner in2 = new Outer().new HiddenInner(10); // din nou eroare
 
        Hidden in3            = out.getInnerInstance();          // acces corect la o instanta HiddenInner
	System.out.println(in3.value());
    }
}

Observați definirea interfeței Hidden. Ea este utilă pentru a putea asocia clasei HiddenInner un tip, care să ne permita folosirea instanțelor acesteia, altfel tipul ei nu ar fi fost vizibil pentru ca a fost declarată private. Observați, de asemenea, încercarile eronate de a instanția HiddenInner. Cum clasa internă a fost declarată private, acest tip nu mai este vizibil in exteriorul clasei Outer.

Primele exemple prezintă modalitățile cele mai uzuale de folosire a claselor interne. Totuși, design-ul claselor interne este destul de complet și exista modalitati mai “obscure” de a le folosi: clasele interne pot fi definite și în cadrul metodelor sau al unor blocuri arbitrare de cod.

În exemplul următor, clasa internă a fost declarată în interiorul funcției getInnerInstance. În acest mod, vizibilitatea ei a fost redusă pentru ca nu poate fi instanțiată decât în această funcție.

Singurii modificatori care pot fi aplicați acestor clase sunt abstract și final (binențeles, nu amândoi deodată).

Test.java

interface Hidden {
    public int value ();
}
 
class Outer {
    public Hidden getInnerInstance() {
        class FuncInner implements Hidden {
    	    private int i = 11;    	
   	    public int value () {
    	        return i;
    	    }
    	}
 
    	return new FuncInner();
    }
}
 
public class Test {
    public static void main(String[] args) {
        Outer out           = new Outer ();
 
        Outer.FuncInner in2 = out.getInnerInstance(); // EROARE: clasa FuncInner nu este vizibila
	Hidden in3          = out.getInnerInstance();
 
	System.out.println(in3.value());
    }
}

public void f() {
    final Student s = new Student();   // s trebuie declarat final ca sa poata fi accesat din AlterStudent
 
    class AlterStudent {
        public void alterStudent() {
            s.name = ...               // OK
            s = new Student();         // GRESIT!
        }
    }
}

Exemplu de clasa internă declarata într-un bloc:

interface Hidden {
    public int value ();
}
 
class Outer {
    public Hidden getInnerInstance(int i) {
        if (i == 11) {
    	    class BlockInner implements Hidden {
                private int i = 11;
 
     		public int value() {
        	    return i;
        	}
            }
 
            return new BlockInner();
    	}
 
        return null;
    } 
}

În acest exemplu, clasa internă BlockInner este defintă în cadrul unui bloc if, dar acest lucru nu înseamnă că declarația va fi luată în considerare doar la rulare, în cazul în care condiția este adevarată.

Exista multe situații în care o clasă internă este instanțiată într-un singur loc (si este folosita prin upcasting la o clasă de bază sau interfață), ceea ce face ca numele clasei să nu mai fie important, iar tipul ei poate fi un subtip al unei clase sau o implementare a unei interfețe. Singurele metode care pot fi apelate pe o clasa anonimă sunt cele are tipului pe care îl extinde sau implementează.

In Java putem crea clase interne anonime (făra nume) ca în exemplul următor:

interface Hidden {
    public int value();
}
 
class Outer {
    public Hidden getInnerInstance(int i) {
        return new Hidden() {
            private int i = 11;    	
            public int value() {
    	        return i;
            }
    	};
    } 
}
 
public class Test {
    public static void main(String[] args) {
        Outer out  = new Outer();
 
	Hidden in3 = out.getInnerInstance(11);
	System.out.println(in3.value());
    }
}

Observați modalitatea de declarare a clasei anonime. Sintaxa return new Hidden() { … } reprezintă urmatoarele: * dorim sa întoarcem un obiect de tip Hidden * acest obiect este instanțiat imediat dupa return, folosind new (referința întoarsă de new va fi upcast la clasa de baza: Hidden) * numele clasei instanțiate este absent (ea este anonimă), însă ea este de tipul Hidden, prin urmare, va implementa metoda/metodele din interfață(cum e metoda value). Corpul clasei urmeaza imediat instanțierii.

Construcția return new Hidden() { … } este echivalentă cu a spune: creează un obiect al unei clase anonime ce implementeaza Hidden.

Clasele anonime nu pot avea constructori din cauză că nu au nume (nu am ști cum să numim constructorii). Această restricție asupra claselor anonime ridică o problemăƒ: în mod implicit, clasă de bază este creată cu constructorul default.

Ce se întâmplă dacムdorim să invocăƒm un alt constructor al clasei de bază? În clasele normale acest lucru era posibil prin apelarea explicită, în prima linie din constructor a constructorului clasei de bazムcu parametrii doriți, folosind super. În clasele interne acest lucru se obține prin transmiterea parametrilor căƒtre constructorul clasei de bază direct la crearea obiectului de tip clasă anonimă:

new Student("Andrei") {
    ...
}

În acest exemplu, am instanțiat o clasa anonimă, ce extinde clasa Student, apelând constructorul clasei de bază cu parametrul “Andrei”.

În secțiunile precedente, s-a discutat doar despre clase interne a caror instanțe există doar în contextul unei instanțe a clasei exterioare, astfel că poate accesa membrii obiectului exterior direct. De asemenea, am menționat că fiind membri ai claselor exterioare, clasele interne pot avea modificatorii disponibili pentru metode și variabile, dintre care și static (clasele exterioare nu pot fi statice!). Așa cum pentru a accesa metodele și variabilele statice ale unei clase nu este nevoie de o instanță a aceteia, putem obține o referință către o clasă internă fără a avea nevoie de o instanță a clasei exterioare.

Pentru a înțelege diferența dintre clasele interne statice și cele nestatice trebuie să reținem următorul aspect: clasele nestatice țin legătura cu obiectul exterior în vreme ce clasele statice nu păstrează această legătură.

Pentru clasele interne statice: * nu avem nevoie de un obiect al clasei externe pentru a crea un obiect al clasei interne * nu putem accesa câmpuri nestatice ale clasei externe din clasă internă (nu avem o instanță a clasei externe)

Test.java

class Outer {
 
    public int outerMember = 9;
 
    class NonStaticInner {		 
        private int i = 1;
        public int value() {
	    return i + Outer.this.outerMember; // OK, putem accesa un membru al clasei exterioare
        }
    }
 
    static class StaticInner {	
        public int k = 99;
	public int value() {
	    k += outerMember; // EROARE, nu putem accesa un membru nestatic al clasei exterioare
	    return k;
	}
    }
}
 
public class Test {
 
    public static void main(String[] args) {
        Outer out                  = new Outer ();
 
	Outer.NonStaticInner nonSt = out.new NonStaticInner(); // instantiere CORECTA pt o clasa nestatica
	Outer.StaticInner st       = out.new StaticInner();    // instantiere INCORECTA a clasei statice
	Outer.StaticInner st2      = new Outer.StaticInner();  // instantiere CORECTA a clasei statice
    }
}

În exemplul de mai sus se observă că folosirea membrului nestatic outerMember în clasa statică StaticInner este incorectă. De asemenea, se observă modalitățile diferite de instanțiere a celor două tipuri de clase interne (statice și nestatice): * folosim o instanță a clasei exterioare - out (ca și în exemplele anterioare) pentru a instanția o clasă nestatică. * folosim numele claselor pentru a instanția o clasă statică. Folosirea lui out este incorectă.

Deoarece constructorul clasei interne trebuie sa se atașeze de un obiect al clasei exterioare, moștenirea unei clase interne este puțin mai complicată decât cea obișnuită. Problema rezidă în nevoia de a inițializa legătura (ascunsă) cu clasa exterioară, în contextul în care în clasa derivată nu mai există un obiect default pentru acest lucru (care era NumeClasaExterna.this).

class WithInner {
    class Inner {
        public void method() {
            System.out.println("I am Inner's method");
        }
    }
}
 
class InheritInner extends WithInner.Inner {
 
    InheritInner() {}            // EROARE, avem nevoie de o legatura la obiectul clasei exterioare
    InheritInner(WithInner wi) { // OK
        wi.super();
    }
}
 
public class Test {
    public static void main(String[] args) {
        WithInner wi    = new WithInner();
        InheritInner ii = new InheritInner(wi);
        ii.method();
    }
}

Observăm ca InheritInner moșteneste doar WithInner.Inner însa sunt necesare: * parametrul constructorului InheritInner trebuie sa fie de tipul clasei externă (WithInner) * linia din constructorul InheritInner: wi.super().

Clasele interne pot părea un mecanism greoi și uneori artificial. Ele sunt însă foarte utile în următoarele situații:

• Rezolvăm o problemă complicată și dorim să creăm o clasă care ne ajută la dezvoltarea soluției dar:
  • nu dorim să fie accesibilă din exterior sau
  • nu mai are utilitate în alte zone ale programului
• Implementăm o anumită interfață și dorim să întoarcem o referință la acea interfață, ascunzând în același timp implementarea.
• Dorim să folosim/extindem funcționalități ale mai multor clase, însă în JAVA nu putem extinde decât o singură clasă. Putem defini însă clase interioare. Acestea pot moșteni orice clasă și au, în plus, acces la obiectul clasei exterioare.
• Implementarea unei arhitecturi de control, marcată de nevoia de a trata evenimente într-un sistem bazat pe evenimente. Unul din cele mai importante sisteme de acest tip este GUI (graphical user interface). Bibliotecile Java Swing, AWT, SWT sunt arhitecturi de control care folosesc intens clase interne. De exemplu, în Swing, pentru evenimente cum ar fi apăsarea unui buton se poate atașa obiectului buton o tratare particulară al evenimentului de apăsare în felul următor:

 button.addActionListener(new ActionListener() { //interfata implementata e ActionListener
	public void actionPerformed(ActionEvent e) {            
	     numClicks++;
	}
    });

1. (5p) Creați un program care sortează o listă de obiecte în funcție de mai diferite criterii. Obiectele sunt de tipul Student, o subclasă a clasei Person, clase realizate în laboratorul 3, și a căror implementare o găsiți în scheletul de laborator.
   1. (1p) Implementați în clasa Person un comparator care să permită sortarea crescătoare în funcție de nume.
   2. (1p) Implementați în clasa Student un comparator care să permită sortarea descrescătoare în funcție de notă.
   3. (1p) Testați cei doi comparatori prin crearea unei liste de obiecte Student și sortarea ei în funcție de nume și apoi de notă.
   4. (1p) Implementați comparatorii folosind clase interne statice. Modificați și codul de testare.
   5. (1p) Implementați comparatorii folosind clase anonime. Modificați și codul de testare.
   • Pentru listă folosiți o implementare a java.util.List, de exemplu ArrayList
   • Pentru a sorta folosiți metoda statică sort(List<T> list, Comparator<? super T> c) din clasa java.util.Collections
     • aceasta primește un obiect de tip Comparator
     • parametrizarea de tipuri <T> și <? super T> va fi studiată în laboratorul de Genericitate, în implementarea voastră puneți tipul Persoană sau Student în loc de <T>.
   • Comparatorii creați trebuie să fie clase interne care implementează interfața Comparator.
   • Care alegere este mai bună, clase interne statice sau clase interne ne-statice?
2. (7p) Folosiți clase interne anonime pentru a implementa un mecanism de monitorizare al schimbărilor dintr-o listă. Pentru a observa modficările din listă vom folosi obiecte eveniment care sunt transmise către obiecte cu rol de observator.
   1. (1p) Creați o subclasă a ArrayList care suprascrie metodele (nu este suficient timp in laborator pt a suprascrie toate variantele de add, remove):
      • add(E e)
      • remove(int index)
      • set(int index, E element)
      • folosiți E pentru tipul elementelor (mai multe detalii în laboratorul de Genericitate)
      • în metodele suprascrise veți notifica observatorii de apariția evenimentului
   2. (2p) Evenimente sunt definite prin clase anonime derivate din clasa abstractă ListEvent, dată în scheletul de cod. Acestea se generează în metodele suprascrise pentru lucrul cu elementele, și se transmit către toți observatorii înregistrați. Atenție, clasa ListEvent are un constructor care primește ca parametru tipul evenimentului.
   3. (1p) Lista trimite evenimentele către obiecte de tip Observer, iar pentru a înregistra și deînregistra pe aceștia trebuie să implementeze metodele din interfața Observable:
      • addObserver(Observer o)
      • removeObserver(Observer o)
   4. (2p) Creați obiecte de tip Observer, fie ca și clase interne în clasa Test, fie ca și clase interne anonime atunci când sunt înregistrați în listă.
      • (1p) un observator afișează evenimentul într-un format la alegerea voastră
      • (1p) un observator salvează evenimentele cu durată mare (threshold ales de voi)
   5. (1p) Testați comportamentul listei si observatorilor
      • Creați o listă cu tipul elementelor la alegerea voastră
      • Creați și înregistrați cel puțin doi observatori
      • Adăugați, scoateți și modificați elemente din listă
      • Afișați lista de evenimente cu durată mare. Găsiți o modalitate de a accesa lista din exteriorul clasei observator.

* Schelet * Soluții * PDF laborator

1. Kathy Sierra, Bert Bates. SCJP Sun Certified Programmer for Java™ 6 - Study Guide. Chapter 8 - Inner Classes (available online)