2009. október 16., péntek

SCJP

A mai nap sikeresen letettem a Sun Certified Programmer for the Java Platform, Standard Edition 6 (CX-310-065), rövid nevén SCJP vizsgát. Már rég meg kellett volna lépnem, a voucher is már majdnem egy éve megvan, de most tudtam rászánni magam. Leírnám a tapasztalataimat, hátha más is tudja kamatoztatni.

Felkészülés

Szinte kizárólag Katherine Sierra, Bert Bates: SCJP Sun Certified Programmer for Java 6 Exam 310-065 könyvet használtam felkészülésre. A könyv tíz fejezetből áll, és kifejezetten a vizsgára koncentrál, nagyon kevés plusz tudnivalót ír le, bár így is a tananyaggal foglakozó rész kb. 800 oldal. Azért érdemes ezt választani, mert írói részt vettek a vizsgakérdések kidolgozásában, egyértelműen definiálja a tananyagot, és példa teszt sorok is járnak hozzá. A könyvet mindig frissítették, ahogy új verziók jöttek ki a vizsgából.

A könyv egy bevezetéssel indul, mely a vizsga lebonyolításáról szól, hogyan kell jelentkezni, hogyan zajlik a vizsga, stb. Majd mindegyik fejezet hosszasan kifejti a tananyagot, tudnivalókat. A szöveg közben vannak un. Exam Watch keretes írások, melyek azt írják le, hogy mire kell a vizsgán odafigyelni, és viszonylag kevés On The Job keretes írás, hogy az ismeretett témakört hogyan érdemes a gyakorlatban alkalmazni. Mindegyik fejezet leírja Certification Objective fejezethez tartozó részét, azaz a Sun által kiadott témakörökre való hivatkozásokat. Mindegyik fejezet végén van egy összefoglaló, egy Two-Minute Drill mely felsorolásszerűen tartalmazza a fontosabb tudnivalókat (nevükkel ellentétbe nekem darabjának áttanulmányozása vagy 15 percig tartott). Itt vannak még a témakörhöz kapcsolódó példa kérdések és válaszok is (nagyon zavaró, mikor a kérdés felénél, a forráskódban van a sortörés). Különösen kiakasztott, hogy olyanokra kérdezett rá, melyeket az előző fejezetben nem írt le.

A CD mellékleten található két teljes vizsgasor is. Ezt meg lehet oldani úgy is, mintha a vizsgán lennénk (MasterExam), ugyanazokkal a feltételekkel, valamint quiz-szerűen is (Quiz). A CD mellékleten lévő vizsga 72 kérdéssel számol és 210 perccel. A quiz esetén 90 perc van a maximum 70 kérdésre, ez ne zavarjon meg minket, és ne keseredjünk el, reménytelen annyi idő alatt. A vizsga azonban nemrég változott, csak 60 kérdés van, melyeket 180 perc alatt kell megválaszolni. A program nagyon nem tetszett. Egyrészt nincsenek benne drag&drop kérdések, melyek a valós tesztben vannak. Ha egy teljes tesztet végigcsinálunk, akkor van lehetőség riport nyomtatására. A riport csak a jó válaszokat tartalmazza, és nem tartalmazza, hogy mi mit válaszoltunk, szóval csak a memóriánkra hagyatkozhatunk. Így a riport tanulásra teljesen alkalmatlan. Ehelyett alkalmazzuk a quiz-t, open book-kal, ilyenkor tippet is kapunk, valamint a választ megadva azonnal láthatjuk a helyes válaszokat, meg is magyarázva. A program honlapján regisztrálva állítólag még egy példa tesztet le lehet tölteni, de ezt nem próbáltam.

Én a teljes vizsgára kb. 30 órát készültem. Ebben benne van a könyv végigolvasása, a Two-Minute Drill-ek kétszeri végigolvasása, a fejezetek végén lévő tesztek megoldása, valamint a két példateszt végigpróbálása, és a válaszok kielemzése. Ennek bőven elég kell lennie. A vizsga a könyv kérdéseihez képest sokkal egyszerűbb, szóval ha az előbbin átmegyünk, nem lesz gondunk az éles vizsgán sem. Hasznos lehet még a JavaRanch.com-on lévő JSCP FAQ, valamint a Sun felkészítő anyaga. Bevallom, én a CD mellékleten kívül egy szabadon elérhető tesztsort sem vittem végig. Amit még elolvastam, ismétlő jelleggel Palacsint blogjában található SCJP csapdák bejegyzés, mely nagyon jól használható. Innen vettem az ötletet, hogy én is összeírom a szerintem fontos dolgokat, melyet listaszerűen a bejegyzés végén találsz.

Amire nagyon oda kell figyelni, az szerintem a collections, generics és concurrency.

Körítés

A vizsgára a voucher-t a Sun-nál lehet megrendelni, jelenleg 300$, ehhez semmiféle járulékos költség nem adódik. A vizsgát valamelyik Prometric vizsgaközpontban lehet letenni, természetesen én a SZÁMALK-ot válaszotottam, a vizsga előtt kb. két héttel jelentkeztem be. A vizsgán feleletválasztós kérdések (egy helyes válasz esetén rádiógomb, több esetén meg van adva a helyes válaszok száma - szemben a könyvvel) és pár drag&drop kérdés van (kódrészleteket kell kódrészletbe behuzigálni - egyet akár többször is, és nem kötelező mindet felhasználni). A rendelkezésre álló idő 180 perc, a 60 kérdésből 35-öt kell eltalálni a sikeres vizsgához (58.33 %). A vizsgára nem lehet íróeszközt, szatyrot, tárcát, telefont, kabátot bevinni, ezeket elzárják. Letörölhető jegyzettömböt adnak. Mindenképp érdemes vizet bevinni. Az idő nem kevés, én minden kérdésen még egyszer át tudtam menni. Ezt érdemes is megtenni, 4-5 kérdést biztos javítottam. A teszt közben ha valamelyik kérdésben nem vagy biztos, érdemes megjelölni, sőt a jegyzettömbre felírni, hogy melyik válaszra gyanakszol. A drag&drop-ról sokan mondták, hogyha újból megjeleníted, elveszted a már beírt dolgokat, így nem is kísérleteztem vele, de szerencsére nagyon egyszerűek voltak, nem akartam őket újra átnézni. A vizsga eredménye nem jelenik meg a képernyőn, hanem ki kell nyomtatni, és kinn adja oda az adminisztrátor.

Vélemény

Kérdés, hogy mennyi értelme van letenni az SCJP vizsgát? Sajnos itthon nem annyira elfogadott, álláskereséskor inkább a céget képviselő programozó kérdéseire, általa összeállított tesztsorra kell válaszolgatni. Kint jobb a helyzet, németeknél pl. sokat számít a papír. Magam részéről úgy gondolom (, régebben gyakrabban felvételiztettem), hogy az SCJP vizsgától még nem lesz jó programozó az emberből, de jobb programozó lesz, és mindenképp becsülendő, hogyha valaki időt és pénzt áldozott a felkészülésre és a vizsga megcsinálására. Ha egy cégnél dolgozunk, akkor szép juttatás lehet a vizsga, és arra való felkészülésnek a biztosítása.

És a végén az általam összegyűjtött dolgok, melyre érdemes odafigyelni:

  • Publikus osztályt nem tartalmazó állományt bárhogy elnevezhetünk.
  • Default hozzáféréssel rendelkező osztályok elérhetőek az ugyanabban a csomagban lévő osztályokból.
  • A példánymetódusok felüldefiniálásakor (override) az új metódus nem dobhat bővebb (broader, azaz nem azonos vagy leszármazott) ellenőrzött (checked) kivételeket.
  • A strictfp módosító osztályra és metódusra is alkalmazható.
  • Az enum deklaráció végén opcionális a pontosvessző.Ha egy statikus metódust hívunk egy változón keresztül, a fordító a változó deklarációjában szereplő osztályra cseréli ki.
  • Java 5-től kezdve a metódus felüldefiniálásakor a visszatérési érték lehet az eredeti visszatérési érték, vagy annak leszármazottai (covariant return)
  • Laza kötésre (loose coupling) és magas kohézióra (high cohesion) kell törekedni.
  • Az értékadó operátorok (pl. +=) automatikus típuskényszerítést végezhetnek
  • Az == használata autoboxing esetén trükkös, ugyanis byte, és -128 és 127 közötti Short, Integer értékek között egy pool van, így igazat fog visszaadni, e felett viszont hamist.
  • Egyenlőségvizsgálatnál ha két különböző osztályhierarchiában lévő osztály típusú változót hasonlítunk össze, már fordításkor elszáll
  • A switch esetén a case paraméterének fordítási időben kiszámolhatónak kell lennie
  • Ha byte típust adok át egy switch-nek, és a case után nem fér bele a szám byte-ba, fordítási hiba keletezik
  • A default block középen is lehet
  • System.exit-nél nem fut le a finally
  • Assert Java 1.4-től van
  • Nem szerializálható ősosztályok konstruktora, inicializációja lefut deszerializáláskor. Statikus változó sosem kerül szerializálásra.
  • A StringBuffer equals() metódusa nincs felüldefiniálva, nem az értéket hasonlítja
  • A megtanulandó printf flag-ek: -, +, 0, "," , és (, formátumok: %b, %c, %d, %f, %s. A %b boolean-ra, true-t ad minden non-null vagy non-boolean értékre.
  • Autoboxing esetén az equals() csak akkor igaz, ha a primitív típusok és az értékek is megegyeznek.
  • Queue interfész, PriorityQueue osztály
  • NavigableSet, NavigableMap interfészek: Java 6
  • A HashMap beenged null-t, a Hashtable nem
  • LinkedHashMap sorrendje: beszúrás vagy utolsó hozzáférés
  • equals metódusnál kötelező az Object típusú paraméter, compareTo-nál nem
  • headSet, subSet, tailSet - boolean paraméter - inclusive, ha nincs boolean, a kezdő mindig inclusive
  • Natural order: space, nagybetűk, kisbetűk
  • Generikus esetében a deklarációban és az értékadásban a generikus típusának pontosan meg kell egyeznie, amennyiben nem használunk wildcard karaktereket, azaz a List<Animal> aList = new ArrayList<Dog>(); nem fordul le, hiába a Dog az Animal leszármazottja
  • Példányosításnál generics wildcard nem használható
  • new MyOuter().new MyInner(); vagy MyOuter.MyInner inner = mo.new MyInner();
  • MyOuter.this
  • A vizsga szempontjából metóduson belül definiált osztály módosítója vagy abstract vagy final.
  • JAR készítésekor az a könyvtár is belekerül, melyet paraméternek megadunk, nem csak az az alatti könyvtárak, állományok
  • A Runnable példánynak nincs referenciája a szálra, ami futtatja, ezt lehet elkérni a Thread.currentThread() metódussal
  • Ha egy szál el lett indítva, nem lehet többet újra elindítani
  • sleep, yield: statikus metódusok
  • sleep-nél nem vesznek el a lock-ok
  • Console a java.io csomagban van
  • Polimorfizmus csak a példánymetódusokra vonatkozik, se a statikus metódusokra, se bármilyen típusú változókra
  • A Throwable az osztály
  • Szerializációkor a pontos metódus: private void readObject(ObjectInputStream is) throws IOException, ClassNotFoundException

10 megjegyzés:

  1. "Generikus esetében a deklarációban és az értékadásban a generikus típusának pontosan meg kell egyeznie"

    Vagy félreértettelek, vagy tévedsz :-)
    Ez pl. legális:
    List<? extends Number> numbers = new ArrayList<Integer>();

    Ez persze nem fordul le:
    List<Integer> ints = new ArrayList<Integer>();
    List<Number> numbers = ints;
    Oka, hogy ha legális lenne, akkor lehetséges lenne az "ints" listába pl. Double számokat írni a numbers referencián keresztül:
    numbers.add(2.3);

    Ha viszont numbers List<? extends Number>, akkor a fenti sor (add hívása) nem fordul le.

    Mondjuk a generics a Javaban nem épp triviális, lásd mondjuk a következő, kissé ijesztő deklarációt: http://java.sun.com/javase/6/docs/api/java/util/Collections.html#max(java.util.Collection)

    VálaszTörlés
  2. Köszi, javítottam, ott látszik, mire gondoltam.
    Tény, hogy a szálakon kívül ezt utáltam a legjobban.

    VálaszTörlés
  3. gratulálok! én is készülök régóta, de még gyűjtenem kell rá.

    VálaszTörlés
  4. Köszi!
    Szerencsére nekem hivatalból kellett. :)
    http://www.szamalk.hu/Szolgaltatasok/oktatoink.aspx

    VálaszTörlés
  5. Generics ill. szálak témakörében ajánlott:
    Java Concurrency in Practice (http://www.javaconcurrencyinpractice.com/)

    Java Generics and Collections (http://www.oreilly.com/catalog/javagenerics/)

    Mindkét könyv nagyon jó. A Concurrency in Practice az alacsony szintű alapoktól (volatile, synchronized, Java Memory Model) a Java 5-ben bevezetett java.util.concurrent-ig mindent tárgyal, és azon túl is bemutat hasznos technikákat (pl. hogyan állítsunk le szálakat).

    A Generics and Collections első fele a generics bemutatásával foglalkozik, szintén az egyszerű esetektől a buktatókon át mindennel (pár apró hiba van benne, de ezeket könnyű kiszúrni). A második fele a collection osztályokat tárgyalja, bemutatva a belső működést is (pl. ConcurrentSkipListMap). A legjobb szakmai könyvek közé tartoznak, amelyeket olvastam (tény, hogy közel sem olvastam annyit, mint Te :-) ).

    VálaszTörlés
  6. A Java Concurrency in Practice alapmű, már nagyon régóta a listámon van, rengetegen ajánlják.
    De szerencsére mostanában a szálas dolgaimat megoldják az alkalmazásszerverek, nem is tudom, mikor írtam le utoljára, hogy Thread.

    VálaszTörlés
  7. Hát igen, az alkalmazásszervereknek megvannak az előnyeik. Viszont ha servlet API-val foglalkozol valamiért, és van állapot a servletben/filterben, máris bejön a többszálúság.

    VálaszTörlés
  8. Hát, azt hiszem nyugodt szívvel kijelenthetem, hogy ez az SCJP igazi szarrágás.

    Végignéztem az általad és a palacsint által gyűjtött (igazán kimerítőnek nevezhető) listákat, és úgy gondolom, hogy a megjegyzések nagyrészt arra utalnak, hogy a vizsga kb. a "szívatós egyetemi írásbeli vizsga" színvonalán megy.

    Találtam egy-két teljesen triviális dolgot (pl. "array toString() eredménye: [Ljava.lang.String;@a90653, nem az elemek toString-je", "Polimorfizmus csak a példánymetódusokra vonatkozik, se a statikus metódusokra, se bármilyen típusú változókra"), amik minimális gyakorlás után szinte kiszúrják az ember szemét.

    Viszont például az ilyenek, hogy "A NumberFormatException az IllegalArgumentException leszármazottja", meg hogy "StringBuffer.delete() második paramétere endIndex", valamint hogy "A Throwable az osztály" nálam igencsak kiverik a biztosítékot, mégpedig azért mert ez a "magolj be sok-sok API-t totál feleslegesen" kategóriába tartozik számomra.

    Lehet, hogy én számítok "lúzernek", de - bár gondolkodtam ilyen vizsgán néhány évnyi Java tapasztalattal - azt hiszem, hogy inkább skippelem a témát, mert ilyen formán totál baromságnak tartom az egészet. Ebből nekem az jön le, hogy gyakorlatilag, ha megtanulod az API-t lexikonszerűen, valamint a Java nyelvtanát (szintén lexikonszerűen), akkor überfaszán méltó vagy arra, hogy Java Professionalnak nevezd magad. Csak éppen hiába tudod, hogy például szintaktikailag hányféleképpen lehet egy nyomorék többdimenziós tömböt példányosítani static környezetben, ha emellett alig sajátítottál el valamit az egész szemléletből.

    Szigorúan csak szerintem.

    Félreértés ne essék, respect a szerzőknek, és köszi a gyűjtéseket az összes leeendő SCJP vizsgázó nevében is, csupán azzal a vizsgaszemlélettel van bajom, ami átjön az összegyüjtött érdekességekből.

    Üdv,
    M

    VálaszTörlés
  9. Egyetértek veled abban, hogy az SCJP vizsgától nem lesz valaki jó programozó. Viszont szerintem jobb programozó lesz.
    Valamint Java-t oktatok, és szerintem ilyen szintű tudás kell ahhoz, hogy biztosan tudj a hallgatóknak bármit állítani. Igen, sokszor kérdeznek rá ilyenre, nem mondhatod nekik azt, hogy bocs, nem tudom fejből az API-t.

    Szóval szerencsére a dolog választható, mindenki döntse el magának, hogy megéri-e a befektetett időt, energiát és pénzt. Feltehetőleg a Java programozók egy részének nem éri meg.

    VálaszTörlés
  10. Közben eszembe jutott még egy érv az SCJP mellett. Mostanság egyre több pályázatot látok, ahol szükséges/előny az SCJP vizsga. Azaz a munkáltatók is szeretni fognak, ha az SCJP-del pályázni tudnak különböző projektekre.

    VálaszTörlés