Table of Contents

Clase interne

Obiective

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:

Introducere

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ă:

Unul din avantajele claselor interne este comportamentul acestora ca un membru al clasei. Asta face ca o clasa internă sa poata avea acces la toți membrii clasei de care aparține (outer class), inclusiv cei private. În plus, aceasta poate avea modificatorii permiși metodelor și variabilelelor claselor. Astfel, o clasa internă poate fi nu numai public, final, abstract dar și private, protected și static.

Clase interne "normale"

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):

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

Outer.this;

Modificatorii de acces pentru clase interne

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.

Clase interne în metode și blocuri

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.

Clase interne în metode

Î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());
    }
}
Clasele interne declarate în metode nu pot folosi variabilele declarate în metoda respectivă și nici parametrii metodei. Pentru a le putea accesa, variabilele trebuie declarate final, ca în exemplul următor. Această restricție se datorează faptului că variabilele si parametrii metodelor se află pe segmentul de stivă (zonă de memorie) creat pentru metoda respectivă, ceea ce face ca ele să nu fie existe la fel de mult cât clasa internă. Dacă variabila este declarată final, atunci la runtime se va stoca o copie a acesteia ca un câmp al clasei interne, în acest mod putând fi accesată și după execuția metodei. 
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!
        }
    }
}

Clase interne în blocuri

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ă.

Semnificația declarării clasei într-un bloc este legată strict de vizibilitatea acesteia. La compilare clasa va fi creată indiferent care este valoarea de adevăr a condiției if.

Clase anonime

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:

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

O clasă internă anonimă poate extinde o clasă sau să implementeze o singură interfață, nu poate face pe ambele împreună ca la clasele ne-anonime (interne sau nu), și nici nu poate să implementeze mai multe interfețe.

Constructori

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”.

Clase interne statice

Î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:

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):

  • Clasele interne statice nu au nevoie de o instanță a clasei externe → atunci de ce le facem interne acesteia?
    • pentru a grupa clasele, dacă o clasă internă statică A.B este folosită doar de A, atunci nu are rost să o facem top-level.
  • Avem o clasă internă A.B, când facem o statică?
    • în interiorul clasei B nu avem nevoie de nimic specific instanței clasei externe A, deci nu avem nevoie de o instanță a acesteia → o facem statică
Terminologia nested classes vs inner classes: Clasele interne normale, cele anonime si cele interne blocurilor si metodelor sunt inner classes datorită relației pe care o au cu clasa exterioară (depind de o instanță a acesteia). Termenul de nested classes se referă la definirea unei clase în interiorul altei clase, și cuprinde atât inner classes cât și clasele statice interne. De aceea, claselor statice interne li se spune static nested classes și nu static inner classes.

Moștenirea claselor interne

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:

Utilizarea claselor interne

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

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

Exerciții

  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):
    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.
Acest mecanism de decuplare a obiectelor observabile, ce pot genera evenimente, de obiectele observator, ce recepționează evenimentele respective, poarte numele de Observer Pattern.

Fig. 1: Flow-ul dintre clase la executarea unei acțiuni pe listă Fig. 2: Clasele și interfețele pentru exercțiul 2

Resurse

Referințe

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