Design patterns sunt soluții cu nume pentru probleme care apar mereu. Aici construiești două dintre ele: un contor de vizite care există într-un singur exemplar și o rezervare de hotel cu opțiuni alese pe rând.
Main.java și Rezervari.java, în terminal
Contor creat
2
true
Ana, 3 nopți, mic dejun, parcare
Primele trei rânduri vin de la Singleton: contorul e creat o singură dată, deși e cerut de două ori. Ultimul rând e o rezervare făcută cu Builder.
Fiecare exemplu e un singur fișier cu mai multe clase. Îl rulezi cu java Main.java; Java pornește prima clasă din fișier.
să faci o clasă cu un singur obiect, cu constructor privat
să scrii un Singleton sigur, cu enum
să construiești obiecte cu multe opțiuni, cu un Builder
să extinzi un Builder prin moștenire, fără să pierzi înlănțuirea
Pasul 2 din 5
Urmărește Singleton-ul
main cere contorul de două ori. Apasă pe „Linia următoare” și urmărește câte obiecte Contor apar în memorie.
Main.java
publicclass Main {publicstaticvoidmain(String[] a) { Contor x = Contor.get(); Contor y = Contor.get(); x.vizita(); y.vizita(); System.out.println(x.total()); System.out.println(x == y); }}class Contor {privatestatic Contor unic;privateint vizite;privateContor() { System.out.println("Contor creat"); }static Contor get() {if (unic == null) { unic = new Contor(); }return unic; }voidvizita() { vizite++; }inttotal() {return vizite; }}
Variabile
Ce apare pe ecran
Linia 21. Linia 3 apelează Contor.get(). Câmpul static unic aparține clasei, nu unui obiect, și pornește cu null. Condiția unic == null e adevărată.
Linia 22. Se creează primul și singurul contor. Constructorul e privat, deci doar codul din clasa Contor are voie să scrie new Contor(). Pe ecran apare „Contor creat”.
Linia 24.get întoarce obiectul păstrat în unic.
Linia 3.x primește contorul, notat aici Contor#1.
Linia 21. Al doilea apel, de la linia 4. Acum unic nu mai e null, condiția e falsă și linia 22 e sărită: nu se mai creează nimic.
Linia 24. Se întoarce același obiect ca prima dată.
Linia 4.y primește tot Contor#1. Două variabile, un singur obiect.
Linia 5. Vizită prin x: câmpul vizite al obiectului devine 1.
Linia 6. Vizită prin y. E același obiect, deci vizite devine 2.
Linia 7. Se afișează totalul: 2.
Linia 8. Pentru obiecte, == întreabă dacă e același obiect în memorie. Este, deci apare true.
Gata. „Contor creat” a apărut o singură dată: asta garantează Singleton-ul.
Prezice ieșirea
Adaugi în main încă o linie, Contor.get().vizita();, înainte de linia 7. Ce afișează linia 7?
Răspuns: 3.
Contor.get() întoarce tot obiectul deja creat, deci a treia vizită se adună la celelalte două. Constructorul nu mai rulează.
Pasul 3 din 5
Când și cum le folosești
Trei idei: Singleton-ul sigur, Builder-ul și Builder-ul care se moștenește. Apoi două capcane, cu mesajele compilatorului.
1
Singleton cu enum
Setari.java
enum Setari { INSTANTA;private String moneda = "lei"; String moneda() {return moneda; }voidmoneda(String m) { moneda = m; }}voidmain() { Setari.INSTANTA.moneda("RON"); Setari s = Setari.INSTANTA; IO.println(s.moneda());}
Ce apare pe ecran
RON
Varianta din pasul 2 are o problemă: dacă două fire de execuție apelează get() în același timp, amândouă pot vedea null și pot crea câte un contor. Un enum cu o singură valoare rezolvă asta: Java creează INSTANTA o singură dată, la încărcarea clasei, sigur și pentru mai multe fire.
Folosește Singleton pentru lucruri care chiar trebuie să existe o dată, ca setările aplicației. Pentru restul, un obiect obișnuit, primit prin constructor, e mai ușor de testat.
Un constructor cu patru parametri, ca new Rezervare("Ana", 3, true, false), nu spune ce înseamnă true și false. Cu Builder, câmpurile obligatorii merg în constructorul builder-ului, iar opțiunile au nume: micDejun(), parcare().
Fiecare metodă întoarce this, adică tot builder-ul, de aceea apelurile se pot înlănțui. build() verifică datele o singură dată și creează rezervarea, cu toate câmpurile final: după creare nu se mai poate schimba.
3
Builder cu moștenire
Zboruri.java
publicclass Zboruri {publicstaticvoidmain(String[] a) { Zbor z = new Zbor.Builder() .pasager("Ana") .loc("12A") .build(); System.out.println(z); }}abstractclass Bilet {final String pasager; Bilet(Builder<?> b) { pasager = b.pasager; }abstractstaticclass Builder< T extends Builder<T>> {private String pasager; T pasager(String p) { pasager = p;return self(); }abstract T self(); }}class Zbor extends Bilet {final String loc;privateZbor(Builder b) {super(b); loc = b.loc; }public String toString() {return pasager + ", locul " + loc; }staticclass Builderextends Bilet.Builder<Builder> {private String loc; Builder loc(String l) { loc = l;returnthis; } Builder self() {returnthis; } Zbor build() {returnnew Zbor(this); } }}
Ce apare pe ecran
Ana, locul 12A
Când ai o clasă de bază, Bilet, și mai multe clase derivate, vrei ca builder-ul de bază să știe câmpurile comune. Problema: pasager(…) ar întoarce un Bilet.Builder, care nu are metoda loc, și înlănțuirea s-ar rupe.
Soluția e parametrul generic T: builder-ul de bază întoarce self(), iar fiecare builder derivat îl implementează cu return this. Așa, pasager("Ana") întoarce un Zbor.Builder și poți continua cu loc("12A").
Capcană: new pe un Singleton
Din obișnuință, scrii new Contor() în altă clasă. Constructorul privat oprește compilarea, exact cum trebuie:
Vizite.java
publicclass Vizite {publicstaticvoidmain(String[] a) { Contor c = new Contor(); c.vizita(); }}
Vizite.java:3: error: Contor() has private access in Contor
Contor c = new Contor();
^
1 error
Repară cerând obiectul de la clasă: Contor c = Contor.get();
Capcană: ai uitat build()
Lanțul se termină după ultima opțiune, iar rezultatul e încă builder-ul, nu rezervarea:
Comanda.java
publicclass Comanda {publicstaticvoidmain(String[] a) { Rezervare r =new Rezervare.Builder("Ana", 2) .micDejun(); }}
Comanda.java:5: error: incompatible types: Builder cannot be converted to Rezervare
.micDejun();
^
1 error
Repară terminând lanțul cu .build(): abia acolo apare obiectul Rezervare.
Pasul 4 din 5
Verifică-te
Cinci întrebări noi. După fiecare răspuns vezi imediat de ce e așa.
La primul apel, unic e null și se creează jurnalul. La următoarele două, get() întoarce același obiect. Un constructor privat se poate apela din interiorul clasei, deci rulează normal.
2 din 5 · Alege varianta
De ce are un Singleton constructorul private?
Răspuns: ca nimeni din afară să nu creeze alt obiect.
Dacă orice clasă ar putea scrie new, ar exista oricâte exemplare. Constructorul privat lasă o singură cale: metoda statică a clasei. Metodele publice rămân accesibile.
3 din 5 · Prezice ieșirea
Folosești clasa Rezervare din cardul 2. Ce se întâmplă?
Q3.java
publicclass Q3 {publicstaticvoidmain(String[] a) { Rezervare r =new Rezervare.Builder("Dan", 0) .parcare() .build(); System.out.println(r); }}
Răspuns: programul se oprește cu IllegalStateException.
Codul se compilează, dar build() verifică nopțile și aruncă excepția: Exception in thread "main" java.lang.IllegalStateException: minim o noapte. Rezervarea invalidă nu ajunge să existe.
4 din 5 · Alege varianta
Când merită un Builder?
Răspuns: multe câmpuri, unele opționale.
Pentru două câmpuri, un constructor e mai simplu. Builder-ul câștigă când apelul cu mulți parametri devine greu de citit. Un singur obiect e treaba Singleton-ului.
5 din 5 · Alege varianta
În Builder-ul cu moștenire, ce întoarce pasager("Ana") când e apelat pe un Zbor.Builder?
Răspuns: un Zbor.Builder.
Metoda întoarce tipul T, care pentru Zbor.Builder este chiar Zbor.Builder. De aceea loc("12A") merge imediat după. Obiectul Zbor apare doar la build().
Pasul 5 din 5
Ce ai învățat
Singleton: constructor privat, câmp static și o metodă care întoarce mereu același obiect.
Un enum cu o singură valoare e cel mai simplu Singleton sigur pentru mai multe fire.
Builder: opțiuni cu nume, metode înlănțuite care întorc this și validare în build().
Builder-ul cu moștenire folosește un tip generic și self() ca înlănțuirea să nu se rupă.
Încearcă singur
Pornește de la Rezervari.java și adaugă opțiunea animalDeCompanie(). Apoi fă ca build() să refuze și rezervările de peste 30 de nopți. Rulează cu java Rezervari.java și verifică ambele cazuri.
În lecția următoare treci de la tipare concrete la principii: cele cinci reguli SOLID, care spun cum împarți codul în clase ușor de schimbat.