Hirdetés

Keresés

Új hozzászólás Aktív témák

  • Drizzt
    nagyúr

    Köszi!
    Akkor ha jól értem, van egy lista a memóriában ezekről a számokról(-128 és 127 között), és a változók mindig a tartalmuknak megfelelő memóriacímre mutatnak?
    Mert akkor így értelmet nyer, hogy a == nem a változó tartalmát, hanem a rámutató memória címet hasonlítja össze.

    Ez még így is szándékos bonyolításnak tűnik.

    Objektumok értékének összehasonlítására mindig equalst kell használni. Ha ezt betartod, jelentősen csökkented a potenciális szívások számát.

    (Aztán ha már nagyon pontosan tudod mit csinálsz, enumoknál érdemes lehet eltérni ettől a szabálytól, de sehol máshol. )

  • Drizzt
    nagyúr

    public class Wrap {
        public static void main(String[] args) {        
    Integer i1 = 1000; // 10        
    Integer i2 = 1000; // 10        
    if (i1 == i2) System.out.println("same");        
    if (i1 != i2) System.out.println("different objects");
    // System.out.println((i1 != i2) + " " + (i1 == i2) + " " + i1.equals(i2));    }
    }

    Nem értem , miért különböző 1000 vagy 10 értékre futtatva az összehasonlítás?

  • Drizzt
    nagyúr

    Köszi értem. És a sic egy rövidítés vagy valami
    angolizmus? :B

    Nem, ez latin.
    [link]
    Nyomtatott magyar sajtoban regebben nagyon sokat alkalmaztak.

  • Drizzt
    nagyúr

    Nagyon nem java, de megpróbálom...
    Idézet az OCP-ből
    Develop code that declares, implements and/or extends
    interfaces and use the @Override annotation (sic*).

    Mit akar jelenteni ez a sic a mondat végén?

    Azt tippelnem, hogy arra utal, hogy az annotacio neve bizonyos esetekben megteveszto. Hiszen egy interface metodus implementalasa nem override fogalmilag.

  • Drizzt
    nagyúr

    Üdv, szerintetek az alábbi feladatot meg lehet oldani jobban, elegánsabban is?

    A metódus kap egy egész számokból álló listát, meg kell számolni benn a növekvő sorozatokat. Pl (1, 2, 3, 1, 2, 3, 1) ebben van kettő.

    Az én megoldásom:
    public int numberOfIncSeries(List<Integer> numbers) {

    int count = 0;
    boolean inc = false;

    for (int i = 1; i < numbers.size(); i++) {
    if (numbers.get(i - 1) <= numbers.get(i)) {
    inc = true;
    } else {
    if (inc) {
    inc = false;
    count++;
    }
    }
    }
    count = inc ? count + 1 : count;
    return count;
    }

    Sokkal szebb szerintem nincsen sajnos. Én picit gyakoroltam TDD-t rajta, nagyjából ez jött ki belőle:
    [link]
    ListSequenceFinder.findSeq a metódus, ListSequenceFinderTest tartalmazza a 18 Test case-et. Sajnos a formázást valamiért elcseszte csúnyán.

  • Drizzt
    nagyúr

    Valaki kitalálja miért?
    [link] libgdx Color

    int x = 1 + 255;
    Color color = new Color(x);
    print(color); = 0x00000100;

    Hát én 0x000001FF -re számítottam.

    new Color(0f, 0f, 1f/255f, 1f); - ez jó

    Miért számítottál másra?
    Decimális 256 az hexadecimális 0x100. Mitől kellett volna 0x1FF-nek lennie?
    Ha 0x1FF-et akarsz, miért nem hexadecimálisan adod meg az x int értékét?

  • Drizzt
    nagyúr

    Ha rengeteg objektumot írok ki serializálva a tárolóra akkor jobb byte field-eket használni az osztályban használni mint int-et?
    Elvileg negyede lesz a fájl mérete?

    Ha kifejezetten méretre lősz és nem muszáj JDK only megoldást adni, akkor lehet jobban jársz, ha valamilyen cél library-t használsz. Némi összehasonlítás: [link] Főleg a 3.4 performance az érdekes.
    Btw: Nagyban függ attól, hogy mi egyéb van még az osztályokban, ha csak egész számok, akkor hány darab, etc. De ha nagyon optimalizálni akarsz méretre, akkor lehet nem is magát a classt kéne szerializálni, mert az nyilván hoz magával mindenféle metadatát, ami tuti sokat fogyaszt.

  • Drizzt
    nagyúr

    Az OCP jó megoldása szerint a következő forrásra két byte kód generálódik
    (Book.class and Book$BookReader.class):
    public class Book {
        private int pageNumber;

        private class BookReader {
            public int getPage() {
                return pageNumber;
            }
        }
    }
    Kipróbáltam, de nekem csak a Book.class keletkezik eclipse buildre ( vagy javac cli-ben). Valamit félreértek vagy máshogy kell fordítani ezt a kódot?

    Nem hinném, hogy máshogy kéne fordítani. De nem lehet, hogy valamelyik Java verzióban változott a viselkedés? Melyik verzióval fordítasz? Ki tudsz próbálni másikat is?

    Rövid utánanézés után mintha a Java 11-ben lett volna ezzel kapcsolatos módosítás? Hányas Java OCP-t nézel és milyen JDK-val fordítasz?

  • Drizzt
    nagyúr

    Sziasztok!
    Van egy házi feladatom amiben nem tudok dűlőre jutni. JPARepositoryt kéne használnom. Van egy Application osztályom, ezt indítja el a Spring. Van egy SQLDataStore osztályom, ez fogná össze a származtatott JPARepository interface-ket. Nyilván a kettő közt elhelyezkedik egy TravelService osztály is.Egy rakat hibát dob a Spring és mindegyik arra panaszkodik, hogy az egyik típusom nem menedzselt típus."Not a managed type: class travel.domain.Destination" és ezért nem tudja kielégíteni a spring a függőségeket az Autowire-höz. Csatoltam képeket, könyörgöm valaki segítsen!
    [kép] [kép] [kép] [kép] [kép]

    Valahova nem tudod felrakni maven, vagy gradle projektként, hogy próbálkozhassunk vele?

  • Drizzt
    nagyúr

    Akkor inkább Set-et használnék összetett kulccsal, és megoldanám, hogy megfelelő sorrendben összefűzze a két értéket a hash és az equals számításnál.

    En siman hasznalnam a map.entrySet().removeIf metodust.

  • Drizzt
    nagyúr

    Ráadásul ugyanezt meg tudom változókkal is csinálni, ugye?. Csinálok egy marker interface-t(AnimalAttribute), amihez hozzádobok esetleg egy getPossibleValues()-t és legrosszabb esetben kap az adott class egy wrapper-t. Így akár egy dinamikus listát is tudok csinálni, ahol a tigriseknek lesz Csíkvastagsága a kengurunak meg Erszénynyúlásiegyütthatója.
    "Szabad" ilyet?

    Szabadni szabad, de nem tul szep. Interface moge viselkedest illik rejteni, igy pl. azt, hogy miket tudnak csinalni az allatok, szivesen kiszerveznem interface-be, de azt, hogy milyen tulajdonsagai vannak az allatoknak, inkabb nem.
    A backend dolgot nem tudom itt hogyan erted.

  • Drizzt
    nagyúr

    Nem teljesen java, inkább OOP kérdés, amiben kicsit elveszve érzem magam.
    Vannak állataink, legyen mondjuk kenguru és tigris. Szeretnénk építeni egy cirkuszt, több ilyen állattal.
    A cirkusz igazgató le tud hívni egy állatlistát, amiben látja mindkét fajt és az adataikat, pl. születési év. Illetve ha kiválaszt egyet, akkor utasítást adhat pl. egy gombbal. Mindkét állat tud a farkán ugrálni, viszont a kenguru el is tud rejteni valamit az erszényében.
    A problémám, hogy sokak szerint egy instanceof mindig code smell. Akár leszármazást, akár kompozíciót használok, valahogy meg kell tudnom a lista egy adott elméről, hogy milyen többlet képessége.
    Hogyan lehet ezt szépen megoldani?
    Illetve lehet-e dinamikussá tenni az egészet, hogy kódváltoztatás nélkül új fajokat kreáljon az igazgató, amik saját "képességekkel" rendelkeznek?

    Tobbfele megoldas lehet, de talan a legegyszerubb az, ha csinalsz egy Activity osztalyt, ami leirja, hogy mit es hogyan tud csinalni az az Activity.
    Az allat osztalyban meg eltarolsz egy Activity Collection-t, amire csinalsz egy getter-t.
    Aztan az Activity-bol csinalhatsz mondjuk egy KangarooHidingActivity-t, ami a konstruktoraban megkap egy Kangaroo-t. A Kangaroo konstruktoraban meg megcsinalod a KangarooHidingActivity-t, meg a masikat es belerakod oket egy collection-be.
    Igy amikor vegigmesz egy Animal Collection-on, le tudod kerni az egyes Activity-k kollekciojat allatoktol fuggetlenul, azok az Activity-k meg megis kepesek lesznek allat specifikus dolgokat csinalni, az eppen megadott allaton.
    Azt nem tudom, hogy ez egy ismert pattern-e, meg van-e neve, de egyszeru esetben valami ilyesmit csinalnek. A Command pattern nagyjabol ez, de talan nem pontosan.

  • Drizzt
    nagyúr

    Egy kis stream alap...

    A végrehajtásban a .map upperCase -ként fűzi, adja tovább a stream elemet. Ez eddig érthető(számomra). Az .anyMatch -nél nem értem, hogy a kiértékelt boolean eredmény mit jelent. A következő stream ciklusban megint az eredeti következő stream elem lesz manipulálva.
    Hogy is van ez?

        Stream.of("d2", "a2", "b1", "b3", "c")
            .map(s -> {
                System.out.println("map: " + s);
                return s.toUpperCase();
            })
            .anyMatch(s -> {
                System.out.println("anyMatch: " + s);
                return s.startsWith("A");
            });
        // map:      d2
        // anyMatch: D2
        // map:      a2
        // anyMatch: A2    

    anyMatch egy Predicate-et vár. A Predicate egy olyan függvény, ami valamilyen bemenetre egy booleanüt ad vissza.
    Az anyMatch addig folytatja a kiértékelést, amíg a predicate igaz nem lesz. Tehát jelen esetben addig, amíg nem talál olyan elemet, ami nagy A-val kezdődik. Utána leáll a további feldolgozás, mert teljesen felesleges lenne.

  • Drizzt
    nagyúr

    Én csak azt ismerem TDD-nek amit a 3. pontban írsz.
    Programkódot nem szabad írni amíg a teszt nincs meg.
    És nem szabad újabb tesztet írni amig nincs kész az előző tesztre a jó program.
    unit teszt az más tészta, azt lehet írogatni szabadon a program mellett.
    Tehát ha valaki unit tesztet használ az még nem TDD.

    De lehet rosszul tudja, Robert C. Martin könyvében olvastam.

    Ezzel nem mondasz ellent annak, amit mondtam. Sehol nem állítottam, hogy az első 2 TDD lenne. :)

  • Drizzt
    nagyúr

    Ha már Hello World.
    Azt hogy kell TDD-ben csinálni?
    Hogy állapítja meg a teszt hogy kiírta-e a képernyőre hogy Helló világ?
    És a jó pozícióba. Nem csak Helló vi és a lág meg kilóg oldalt.

    [Például]
    De egyébként A hello world egy unit tesztelhetőség szempontjából pont eléggé faramuci dolog, mert ott a függvényedet le kellene választani a környezetéről. Ha nem a környezetéről leválasztva tesztelsz valamit, akkor az az én szememben már inkább integration teszt.
    Egy olyan függvényt, ami a standard outputra kiírja, hogy Hello world, nem lehet jól unit testelni, mert a standard outputot kell mockolni, ami meg csak ilyen nyakatekert módokon oldható meg.
    Ha viszont olyan függvényed lenne, ami visszaadja, hogy: "Hello world" -> remekül unit tesztelhető. Olyan, ami kap egy outputstream-et input-ként és kiírja rá, hogy "Hello world" -> szintén remekül unit testelhető.
    "Ritka volt az, amikor nem változott hétről hétre a követelmény, és nagyon kevés része volt a kódnak az, amiben unit tesztre érdemes dolgok történtek."
    Ez utóbbi mindig nagyon gyanús. Én is mindig azt hiszem, ogy jó, triviális kódokat írok, aztán amikor elkezdem tesztelni, szinte mindig kijön valami turpisság. Nyilván a tesztelés mehet három módon: kézzel pöcögtetve: valószínűleg jó kódot eredményez, de ha legközelebb aki hozzányúl, nem olyan alapos, mint aki írta és kézzel tesztelte, akkor rögtön veszélyes lesz módosítani a kódot. 2.: vagy azonnal automata tesztet írni, vagy az előző pont kézi eseteit automatizálni. Ez elég jó általában. 3.: előre írni meg a tesztet és csak utána a kódot. Pont az a nagy előnye, ami miatt elsőre nagyon nehéz vele dolgozni: végig kell előre gondolni az elvárt viselkedést és a trükkös eseteket is. Erre gyakran használt kifogás, hogy sokat változik az elvárás, azért nem kezdenek vele. De nem teljesen korrekt érv, hiszen anélkül, hogy tudná mit akar csinálni az ember, el sem tud mit kezdeni programozni.
    Én tényleg csak alkalomszerűen TDD-zek, de örülnék, ha valamikor elkezdenénk végignyomni vele teljes projekteket, mert minőségben ég és föld a különbség. Ha előre írsz tesztet, akkor sokkal jobban át tudod gondolni, hogy milyen osztályoknak, milyen interface-eken keresztül kell tudniuk egymással beszélni. Sokkal könnyebb elkerülni a spagetti kódokat.

  • Drizzt
    nagyúr

    A TDD zseniális ötlet.
    De azért ara kíváncsi vagyok hogy a gyakorlatban hány cég fejleszt ezzel.
    Kiderül hogy 1-2, de azok is megbánták.

    Nagyon teves feltetelezes. Konkretan van ceg, ahol a felveteli reszekent TDD-ben kell megoldanod a feladatot. Mivel - meglepeteeees - TDD alapon dolgoznak. En viszonylag keves dolgot fejlesztettem TDD-ben, de amit igen, az mindig meghalalta.

  • Drizzt
    nagyúr

    Mindössze két tag változó van a Book osztályban:
    private String name;
    private int publicationYear;
    -----------------------------------------------------------//------------
        @Override
        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            } else if (!(obj instanceof Book)) {
                return false;
            }
            return (((Book) obj).name.equals(this.name) && ((Book) obj).publicationYear == this.publicationYear);
        }

    Akkor nem értem a problémát, nálam teljesen jól működik:

    Name (empty will stop):
    mybook
    Publication year:
    1
    Thank you! Books added: 1
    Name (empty will stop):
    mybook
    Publication year:
    1
    The book is already on the list. Let's not add the same book again.
    Name (empty will stop):
    Thank you! Books added: 1
    Name (empty will stop):
    yourbook
    Publication year:
    2
    Thank you! Books added: 2
    Name (empty will stop):
    mybook 1
    yourbook 2

    (Thank you! Books added: egy picit félrevezető kiírás, mert akkor is jön, ha nem adtunk hozzá semmit)

  • Drizzt
    nagyúr

    Azt hittem olyan csoda metódus a contains. :B Akkor mi értelme a contains-nek?
    Az eddigi (oktatási) feladatokban is override-oltam az equals-t és az jól is üzemelt. (referenciát és minden változót végigvizsgálva az objektumban)

    A contains megmondja, hogy érték alapján van-e egyező elem az adott kollekcióban azzal az objektummal, amit paraméterként kapott. Azt, hogy érték szerint megegyezik-e valami, az equals metódus jelenti a Javaban. Ha van szerinted jó equals és nem így működik, akkor mutasd meg az equals-odat.

  • Drizzt
    nagyúr

    Egy kis szakértést szeretnék kérni, mert nem tudom megfejteni miért nem akar a contains metodus nekem működni. :( (book class a simple pojo)
    public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    ArrayList<Book> books = new ArrayList<>();

    while (true) {
    System.out.println("Name (empty will stop):");
    String name = scanner.nextLine();
    if (name.isEmpty()) {
    break;
    }

    System.out.println("Publication year:");
    int publicationYear = Integer.valueOf(scanner.nextLine());
    Book book = new Book(name, publicationYear);
    if (books.contains(book)) {
    System.out.println("The book is already on the list. Let's not add the same book again. \n Name (empty will stop):");
    } else {
    books.add(book);
    }

    System.out.println("Thank you! Books added: " + books.size());
    }
    for(Book b:books) {System.out.println(b.getName() + " " + b.getPublicationYear());}
    }

    Az Arraylist contains hasznalja az equalst. Ha nincs korrektul implementalt equals a Book classban, akkor csak abban az esetben fog igazat adni, ha ugyanazt a referenciat tartalmazza az egyik, meg a masik book. Erdemes viszont akkor mar hashCode-ot is implementalni, mert mas kollekciok hasznalhatjak azt is a contains eldontesehez.

  • Drizzt
    nagyúr

    Valós probléma pl., hogy az USA-ban a feketéket megbélyegzik a rendőrök. Vagy az, hogy a kormányunk a melegek ellen uszít.

    Az, hogy a gitben, hogy hívják a fő branchet, az nem valós probléma, hanem fingreszelés.

    De befejeztem az offolást.

    Igen, azok valosak, s joval nagyobbak, illetve latvanyosabbak, alairom. Attol meg szerintem a master branch problemakore is tekintheto valosnak, ha joval kisebb meretu is a dolog.
    Offnak reszemrol is vege.

  • Drizzt
    nagyúr

    "Ez egy gesztus, ami egy lepes egy empatikusabb, bekesebb vilag fele."
    Az ilyen hülyeségektől se empatikusabb, se békésebb nem lesz a világ, mert a valós problémákkal senki nem foglalkozik.

    Miert, mi a valos problema? Amugy ha off miatt van megfelelobb topic, szivesen koltozok. Ez pont egy valos problema, csak te nem erted, hogy az. Neked nem az, vannak akiknek igen.

  • Drizzt
    nagyúr

    Ha valakit traumatizál az, hogy a branch neve master... az kezelésre szorul, és nagyobb baja is van ennél... Illetve, azt tegyük hozzá, hogy sok más helyen is ott vannak különböző szavak...amik triggerelhetik ezt az érzés...

    Sajnos nem erted az emberek mukodeset, meg a traumak hatasat. Hiaba mondod esetleg azt, hogy ma mar nincsen rabszolgasag, ezert nem lehet traumatizalo hatasa az emlitesenek, de a traumak jelentos resze generaciokon tovabboroklodik. Persze az egy remek dolog, ha ezzel el kezd foglalkozni az ember, de ott ahol a lakossag 12%-a potencialisan kitett ennek a problemanak, ott elegge irrealis azt mondani, hogy akkor mindenki oldja meg es menjen pszichologushoz kozuluk.
    Valamint ott sem biztos, hogy mindenki arra a pontra fog eljutni, hogy ot valojaban ez nem is zavarja, mert nem neki szol, lehet inkabb az ezen kifejezesek megszunteteset kero enje fog eloterbe kerulni. Ha valaki azt erzi, hogy serti valami, akkor a pszihologusnal egyaltalan nem biztos, hogy az fog kijonni, hogy akkor elfogadom a sertest. Sokkal valoszinubb, hogy az fog kijonni, hogy akkor szembeszallok vele nyiltan, mert tartom magamat annyira, hogy ne engedjem megalazni masok altal.
    Ez egy gesztus, ami egy lepes egy empatikusabb, bekesebb vilag fele. Nem oldja meg a vilag gondjait, sokaknak megis szebb lesz toluk a vilag, kevesebb az alapfeszultseguk.
    Egyebkent en sem talaltam volna semmi bantot a master branch nevben, de nem nekem tisztem megitelni, hogy banto-e, mert nem vagyok erintett. Foleg ugy, hogy itt nincs melle mondva a slave kifejezes, ez nehezebben erthetove teszi a dolgot a szamomra is. De ez nem nekem szol. Annyira nem lesz nehez ket betuvel kevesebbet gepelnem, meg neha rajonni, hogy jeee, itt master van. Multbeli dolgokat, muveket en sem valtoztatnek meg, de azert raknek mellejuk disclaimereket.

  • Drizzt
    nagyúr

    Ezzel csak egy baj van. Semmi köze nincs a szakmához... Fogadni mernék rá, hogy az eddigiekben fejlesztőként dolgozó feketék, totál nem foglalkoztak ezzel. Max 1-2 hiperézékeny viráglelkű... Csak most az a divat, hogy az feleljünk meg minden jogi aktivista csoportnak... Alig várom, hogy véget érjen ez a korszak... és végre a lényegre fókuszáljon a világ. És ha valakit ez zavar, akkor 3mp alatt kapja a különböző bélyegeket...de úgy hogy utána már életében nem fog tudni dolgozni... Ez abszurd.

    Egyreszt magahoz a szakmahoz is van koze, ha masert nem, az emlitett fekete fejlesztok miatt. Masreszt meg a szakma termekeinek is van celkozonsege. Ott aztan vegleg hatalmas versenykepessegi eleses, ha nem gondolsz mindenfele marginalizalt csoportra.
    Valahol a lenyeg ott van, hogy szerinted csak hipererzekeny viraglelkueket zavar a dolog, de valojaban nem. Az emberre a dolgok nem csak tudatosan hatnak, a felszin alatt hatalmas lelki es ezen keresztul kesobb fizikai bantalmat tudnak okozni. De errol ne nekem higyj, inkabb pszichologusok/pszichiaterek tapasztalatait vedd figyelembe.
    Azzal, hogy aki ellenvelemenyt fogalmaz meg, en sem ertek egyet, hogy el kellene nyomni. Ellenvelemenynek mindig van helye.

  • Drizzt
    nagyúr

    Nem. A repo létrehozást.
    Most én a github-on csinálok egy üreset.
    git clone
    majd ebbe az új könyvtárba másolom a libgds által generált cuccokat
    és azt commit+push

    most újra csináltam, az előbb 2 branch lett, main meg master, én se tudom hogy
    és mindez azért mert valaki sérelmezte a master nevet
    legalább büdösnigger lett volna, akkor még érteném

    Valoszinuleg sosem fogd megerteni, hogy mit jelent egy feketenek a mester szo hallata. En sem fogom, bar szeretnem azt hinni, hogy igen. De nem vagyok naiv, sosem fogom valoban aterezni milyen rabszolgacsalad sarjanak lenni, barmekkora is az empatiam. Az ilyen szavak tudat alatt is hatalmas karokat tudnak okozni az erintetteknek. S az is persze igaz, hogy Magyarorszagon tok mas az elsodleges jelentese a leforditott szonak, emiatt megint mas elkepzelni a pszichologiai hatasat. Idehaza persze elsosorban a mindenhez erto ember jon elo a szo kapcsan, nem a korbacsos rabszolgatarto. Meg az is igaz, hogy biztosan korulvesz minket ezer olyan szo, ami mas emberekben szorongast valt ki. Es persze eszre se vesszuk. Azert amik eleg szeles korben okoznak problemat, az reszemrol nem baj, ha atnevezesre kerul. Meg fogom birni szokni, hogy 1 betuvel kevesebbet kell gepelni.

  • Drizzt
    nagyúr

    És ez a tapasztalataid szerint mennyire gyakori feladat való életbeli projektekben?

    Nem gyakori, de nem art, hogyha van az embernek az eszkotaraban valami, amivel tudja kezelni adott esetben. Nyilvan valos statisztikam nincs a dologrol, de egyebkent azert egyaltalan nem ritka, hogy sok duplikalt string van a heapen. Az mar ritkabb, hogy ezek hosszu eletuek is legyenek egyben. Es elsosorban akkor jon el az a szint, ahol erdemes kezelni.

  • Drizzt
    nagyúr

    Nekem ez már a bitb.szás kategóriába tartozik. A legtöbben tervezni sem tudnak elégséges szinten, nem hogy még erre optimalizáljanak.

    Van amikor bitbaszas, de van amikor a heaped 95%-a ismetlodo stringekbol all. Akkor nem az. Az megint egy mas kerdes, hogy az ilyen esetben nem biztos, hogy a problema megoldasara idealis architecturalis megoldas lett kivalasztva.

  • Drizzt
    nagyúr

    Erre ott van a -XX:+UseStringDeduplication VM kapcsoló. Bár az csak a hosszú életű Stringeket internálja, de sok esetben az is elég lehet attól függően mi a cél.

    Igen, az egy jó megoldás, de tudtommal csak G1GC mellett megy.
    Vagy persze marad az, hogy csinál az ember saját dictionary-t és az abból lookupolt értéket rakja bele az objektumokba.

  • Drizzt
    nagyúr

    Másrészt én speciel az intern használatáért kurva nagyot csapnék a fejlesztő kezére :D

    Mit javasolsz helyette? Nekem van saját preferenciám, de kíváncsi vagyok mit mondanál rá.

  • Drizzt
    nagyúr

    Hogyan hívják a meghívott osztály változó nevét megmutató kiegészítést? Sehogyan sem jut eszembe. (name: age:)

    public Person giveMePerson() {
          return(new Person(name: "Anti",age: 40));
        }

    IntelliJ-ben a funkció neve parameter hints. Máshol nem biztos, hogy ugyanígy hívják.

  • Drizzt
    nagyúr

    Van egy entitásom 39 attribútummal (lesz még több is).
    Ezek szerint kéne szűrnöm az adatbázisból (az ugye nem opció, hogy findAll, és majd a serviceben filterezek), DE!
    MINDEN attribútum opcionális, és egy vagy több érték lehet benne.

    Először nekiestem az ExampleMatcher-nek, ami nagyszerűen működik, de nem kezel multiple value-t.
    Szerintetek mi lenne erre a legmegfelelőbb:
    - CriteriaBuilder a Predicate-ekkel
    - QueryDSL
    - vmi egyéb okosság?

    Talan jpql queryvel, ilyenekkel a clauseban: where :users is null or user in :users. De 39 parameterrel lesz ez minden, csak szep nem.
    Ha mondjuk Spring data-t hasznalsz, akkor a filter lehet komplex objektum. [link]

  • Drizzt
    nagyúr

    Melyiket törölted? Csak mert a két metódushívás nem ugyanaz. requesterId, majd requestedId.

    No, valakinek nagyon jó a szeme és/vagy jó nagy dpi-jű monitora van. :)

  • Drizzt
    nagyúr

    Még a setterrel kapcsolatban lenne egy kérdésem.
    A beolvas metódusban szeretném átadni közvetlen a setternek az értéket de nem nagyon jött eddig össze.
    Valahogy így gondoltam, de lehetséges, hogy rosszul csinálom nagyon.

    public void beolvas(Scanner sc) {
    System.out.println("Kérem a diák nevét!");
    this.setNev(nev) = sc.nextLine();
    }
    public void setNev(String nev) {
    this.nev = nev;
    }

    Fuha, itt elegge komoly gondok vannak. :(

    public void beolvas(Scanner sc) {
    System.out.println("Kérem a diák nevét!");
    this.setNev(sc.nextLine());
    }
    public void setNev(String nev) {
    this.nev = nev;
    }

  • Drizzt
    nagyúr

    Köszi srácok!

    És még egy dolog, hogy tudom kiíratni az eredményt egy új tömbbe?

    Hobbiból tanulom, minden kezdet nehéz :))

    Foglalni kell egy új tömböt, aminek a mérete a két tömb méretének a szorzata, a cikluson belül pedig egy indexet kell növelgetni és arra a poziícióra kell elhelyezni az éppen megalkotott elemet, ahol tart az index.

    String[] lastNames = {"Nagy", "Kovács"};
    String[] firstNames = {"Júlia", "Béla"};
    String[] combinedNames = new String[lastNames.length * firstNames.length];
    int i = 0;
    for (String lastName: lastNames) {
    for (String firstName: firstNames) {
    combinedNames[i++] = lastName + " " + firstName;
    }
    }
    System.out.println(Arrays.toString(combinedNames));

  • Drizzt
    nagyúr

    Sziasztok!

    Amatőr kérdés :)

    Van két előre szöveggel feltöltött tömböm.

    Feladatban ki kéne íratnom az összes lehetséges névkombinációt konzolra. Ezt, hogy tudom megoldani a legegyszerűbben?

    String[] lastNames = {"Nagy", "Kovács"};
    String[] firstNames = {"Júlia", "Béla"};
    for (String lastName: lastNames) {
    for (String firstName: firstNames) {
    System.out.println(lastName + " " + firstName);
    }
    }

    Nagy Júlia
    Nagy Béla
    Kovács Júlia
    Kovács Béla

  • Drizzt
    nagyúr

    Magától értetődően legegyszerűbb maga a session (HttpSession), ha tényleg van... Ugye ez nem egyértelmű RESTful API-nál és JWT authentikációnál, aminek statelessnek kéne lennie.
    Komolyabb alkalmazásnál floodot még az alkalmazás előtt célszerű megfogni, api gatewayen, proxyn, load balanceren stb.

    Remek kérdés, hogy egyébként mit ért floodon? Csak annyit, hogy ne tudjon mondjuk 5 másodpernél gyakrabban post-olni valami endpoint-ra és elég ha eldobja a requestet, amennyiben az túl friss?
    Mert akkor valahol simán el kell tárolni, hogy mikor jött a legutolsó sikeres request userenként és ha túl gyorsan, akkor eldobni. Erre is lehet persze csomóféle megoldás, a singleton beanben levő maptól a redisen át az adatbázisba eltárolt lastUpdateDate-ig. Függően attól, hogy mi a cél, hány instance van, etc.
    Ha meg DDoS-tól kell védekezni, az nem a Spring boot alkalmazás feladata lenne ideális esetben valóban.

  • Drizzt
    nagyúr

    Arra gondoltam, hogy ez is egy probléma a kóddal, csak nem sikerült értelmes dolgot írnom.

    Ez a writeObject implementáció meg elég nagy gyökérség, gratulálok az Oraclenek. :D

    Nem sok gratulalni valo van az Oracle-nek, mert a JDK 1.1-es verzio, 1997. februar ota van az ObjectOutputStream, akkor meg nem volt koze az Oracle-nek a Javahoz. Ehhez a reszehez az implementacionak meg kb. senki nem is nyult hozza azota(Oke, csak 7-es OpenJDK-ban latom, hogy mar az initial load commitban ugyanez volt 2007-ben). Az Oracle meg 2010-ben vette meg a Sunt.

  • Drizzt
    nagyúr

    Nem az a gond itt, hogy exception esetén nyitvamarad a stream?

    Ha nincs try with resources, akkor finallyben kéne zárni (már feltéve, hogy nem null).

    Attol, hogy nyitva marad a stream, random adat nem fog belekerulni.
    De direkt debugban vegiglepkedtem az idezett kodon, az Exception kiirasat az ObjectOutputStream.writeFatalException metodus vegzi az OutputStream-be.
    A writeObject maga igy nez ki:

    public final void writeObject(Object obj) throws IOException {
    if (enableOverride) {
    writeObjectOverride(obj);
    return;
    }
    try {
    writeObject0(obj, false);
    } catch (IOException ex) {
    if (depth == 0) {
    writeFatalException(ex);
    }
    throw ex;
    }
    }

    11.0.11-es Oracle JDK-val neztem.

  • Drizzt
    nagyúr

    Ha nem sikerül a serializálás fájlba akkor beleírja az exception-t a végére?

    Koszi a peldat!
    Igy egyszerubb valaszolni a kerdesedre.
    [Javadoc] : "Exceptions are thrown for problems with the OutputStream and for classes that should not be serialized. All exceptions are fatal to the OutputStream, which is left in an indeterminate state, and it is up to the caller to ignore or recover the stream state."
    Szoval nincsen kulonosebben specifikalva, hogy mi fog tortenni Exception eseten. Elofordulhat, hogy kulonbozo JVM-eken es kulonbozo javaverziokon is kulonbozokeppen viselkedik, de a leirasaban benne van, hogy az esetleges szemetet a hivonak kell feltakaritani. Szamomra meglepo, hogy igy van. Szoval a catch agban zard a Streameket, majd torold a fajlt, ha van.
    Ha atirod a peldadat "try with resources" alapon, akkor a close-et nem kell sehol meghivnod, mert a ket outputstream autoClosable.

  • Drizzt
    nagyúr

    Nálam ezt csinálta a Java. Benne van a fájl végén a write exception.
    Amikor beolvasom akkor elszáll read exception-nal, de a stacktrace-ben a mentett write exceptiont is kiírja.
    Először nem is értettem hogy hívódik meg a save metódus vagy mi van.
    java.io.NotSerializableException volt.

    Lassan megoszthatnád, hogy konkrétan hogyan csinálod a szerializációt is fájlba írást. A Java azt csinálja, amit mondasz neki, hogy csináljon.

  • Drizzt
    nagyúr

    Sziasztok!

    Java Programming Masterclass covering Java 11 & Java 17

    Lassan elérek ebben a kurzusban a JavaFX-hez. Érdemes rászánnom azt a 10 órát? Az a terv, hogy miután végeztem belevágok valami saját hobbi projektbe (még nem tudom mibe :D ) Saját projekthez lehet, hogy jól jönne a JavaFX, viszont konkrét projekteknél, gondolom már nem használják. Inkább web-alkalmazásban kellene gondolkoznom pl. SpringBoot és ebben készíteni egy projektet?

    Köszi!

    Igen, JavaFX-et nem valószínű, hogy egy átlag Java fejlesztői munkakörben fogsz látni a közeljövőben. Egyébként azért van értelme hallani róla, de túl sok enrgiát beleölni talán nem.
    Spring boot meg hasznos és végtelen kereslet van rá, úgyhogy érdemes arra ráfeküdni.

  • Drizzt
    nagyúr

    nem ismerem, hogy a jáva ezt hogy csinálja, de a rendes eredeti hash tárolási struktúra egyáltalán nem keres hash értéket. ettől gyors.
    és úgy tartják fenn az elemek növekedése ellenére a gyorsaságot, hogy módosítják a hash függvényt.

    Pedig tok egyszeru a dolog.
    Van kiindulaskor valamennyi(n) darab bucket. A bucketek gyakorlatilag tombok. Tehat van egy n elemu tombod. Minden bucketben van egy linkelt lista, vagy valamilyen annak megfelelo struktura.
    A hash fuggvenyen nem modositanak semmit, mivel azt Javaban a user-nek szokas megadnia(oke, altalaban a Lombok irja meg helyette, meg lehet hasznalni a default implementaciot is, de az lehet lassu bizonyos esetekben).

    Kereses kulcs alapjan:
    - Meghivod a kulcsra a .hashCode metodust. Igy kapod az x erteket.
    - Kiszamolod , hogy x mod n = z alapjan mi a z.
    - A z. bucketet kikeresed(ez egy lepesben megvan).
    - A z. bucket osszes elemen vegigiteralsz, s megnezed, hogy a kulcs equals-e az eppen iteralas alatt levo elemmel. Ha igen, akkor az ott szinten eltarolt erteket visszaadod.

    Mikor lesz ez az egesz lassu?
    - Ha a hashCode ugy van megirva, hogy minden kulcs ugyanabba a bucketbe keruljon, vagy legalabbis a bucketek egy kis reszebe. Ilyenkor abban a bucketben egy hosszu lista lesz, ami miatt nem o(1) lesz a lookup, hanem kozeliti az o(n)-et.
    Ugyanez akkor is igaz lenne, ha a map-ben levo elemek szama joval nagyobb lenne, mint n. Mit csinal ez ellen a Java? Figyel egy toltottsegi szintet. Ha a toltottsegi szinte egy hataron tul van, akkor fogja, s csinal 2*n uj bucketet, s a meglevo elemeket belerakja, a regi n bucketet meg eldobja.

    Ebbe a pogramozo is bele tud szolni, van olyan konstruktor, amiben meg tudod adni a kezdeti n-t, s a toltottsegi tenyezot. Szoval ha tudod, hogy rohadt sok elemet fogsz belepakolni, akkor rogton csinalhatsz egy HashMap-et jo nagy n ertekkel, s akkor meguszol par rehash-t. Alapbol 16 bucket lesz, amit akkor ujrahashel, ha legalabb 13-ra no a size. Ekkor 32 bucket lesz, majd ha size legalabb 25 lesz, akkor ujrahashel 64 bucketbe, stb.

    A LinkedHashMap az egy specibb valtozat, ahol az egesz HashMap-en tul egy LinkedList is fenn van tartva, ami az osszes elemet tartalmazza a hozzaadas sorrendjeben. Akkor kell hasznalni, ha fontos a hozzaadas sorrendjet tudni.

  • Drizzt
    nagyúr

        public void setManowar(int manowar) {
            this.manowar = manowar;
            setFleetLabelText();
        }

    Mi a hiba?

    Gondolom unwanted side effectnek minositi egy linter, vagy egy senior programozo.

  • Drizzt
    nagyúr

    Nem lett bonyolult a helyzet ezzel a lambda meg stream-ekkel?
    Most mindig gondolkoznom kell hogy for legyen vagy stream.

    Tanmesét mondok. Bár lehet olyan régen volt hogy igaz sem volt.
    Annak idején egy fejlesztőnyelv/eszköz-ben csak az volt ami nagyon kellett. Minden le volt dokumentálva és minden úgy működött ahogy a doksiban volt.

    Most már nehéz a programozó élete. A sok nyílt forráskódú, ingyenes cuccban az egyik fele nincs dokumentálva a másik fele meg hibásan működik vagy éppen sehogy. Ugye azért nyílt, mert majd kijavítod magad ha nagyon kell. Csak nem képzeled hogy ingyen még hibátlan is legyen?

    "Nem lett bonyolult a helyzet ezzel a lambda meg stream-ekkel?"
    Nem, sokkal egyszerűbb lett. Egyébként lambdát nem kötelező használni, ahol tudok inkább method reference-et használok. A streamnek meg fontos képessége a lazy eval, meg a concurrency support. Bizonyos problémákat tök egyszerűen, szépen, elegánsan és hatékonyan meg lehet oldani funkcionális eszköztárral, amit amúgy bonyolultan/csúnyán lehet megoldani nélküle.
    "Annak idején egy fejlesztőnyelv/eszköz-ben csak az volt ami nagyon kellett. Minden le volt dokumentálva és minden úgy működött ahogy a doksiban volt."
    Ez ma is így van. Maximum 1-2 szinte már sosem használt nyelvi elem léte lenne megkérdőjelezhető, de azok meg maradnak némi backward compatibility miatt. Az meg ha esetleg azért kérded ezt, mert szerinted a Stream felesleges, akkor egyszerűen még nem éreztél rá. Nélküle nagyon szar lenne az élet, ezt pár évi gyakori Stream használóként mondom. Nézz végig valamilyen alap fukncionális progamozást traininget, után egyértelműnek kellene lennie miért ilyen fontos dolog.
    "Most már nehéz a programozó élete. A sok nyílt forráskódú, ingyenes cuccban az egyik fele nincs dokumentálva a másik fele meg hibásan működik vagy éppen sehogy. Ugye azért nyílt, mert majd kijavítod magad ha nagyon kell. Csak nem képzeled hogy ingyen még hibátlan is legyen?"
    Ez megint nincs így. A lefontosabb, legnépszerűbb framework/libek leggyakrabban használt funkciói eléggé stabilak, ritkán kell körbebástyázni őket. A probléma az esetek 95%-ban abból adódik, hogy valaki megspórolja az alapjaik megismerését és anélkül kezdi őket használni valami olyan célra, amire nem feltétlenül alkalmasak. Még ha elő is fordulnak bugok, sokkal előrébb jársz, ha valami libet használsz rájuk, mintha 0-ról kezdenéd megírni. Sokkal tovább tartana, s a minősége is szinte borítékolhatóan rosszabb lenne.
    Az utóbbi évekből pár dolog, aminek én nem voltam elégedett a dokumentációjával: annotation processor, Spring boot property source használat belsőségei. De az is lehet csak nem a megfelelő dokumentációt olvastam. Ráadásul Java-ban az se megy ritkaságszámba, hogy korábbi open source lib a nyelv részévé válik, pl.: Joda-time.

  • Drizzt
    nagyúr

    Sziasztok!
    Kezdő java-s mire számítson, ha technikai interjú előtt lesz két teszt papíron, ami kb. fél órát tart? :)

    Annyira valtozatos, hogy nem lehet megjosolni. Kezdve a miert kerek a csatornafedelen at a mi a kulonbseg a kompozicio es a leszarmazas kozotton at a melyik lista implementacion gyorsabb az iteracioig barmi elofordulhat.

  • Drizzt
    nagyúr

    Sziasztok!
    Tudtok ajánlani egy kezdőnek, konkrét projektet ( projekteket), amivel jól be lehet gyakorolni a java-t. Köszi!

    Programozas topicban kert valaki segitseget, hogy programozzanak le neki valamit. Erre mindenki elkuldte a francba, hogy mit kepzel, hogy ingyen dolgoztatna embereket. Viszont ha nincs otleted mit csinalni, szerintem pont kapora johet.

  • Drizzt
    nagyúr

    Sziasztok!
    package com.sec.config;

    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
    import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
    import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

    @EnableGlobalMethodSecurity(securedEnabled = true)
    @Configuration
    public class SecurityConf extends WebSecurityConfigurerAdapter{

    @Autowired
    public void configureAuth(AuthenticationManagerBuilder auth) throws Exception {
    auth
    .inMemoryAuthentication()
    .withUser("sfjuser")
    .password("{noop}pass")
    .roles("USER")
    .and()
    .withUser("sfjadmin")
    .password("{noop}pass")
    .roles("ADMIN");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
    http
    .authorizeRequests()
    .antMatchers("admin/**").hasRole("ADMIN")
    .anyRequest().authenticated()
    .and()
    .formLogin()
    .loginPage("/login.html")
    .permitAll()
    .and()
    .logout()
    .logoutSuccessUrl("/login?logout")
    .permitAll();
    }

    }

    Nem találja a login.html-t, pedig a templates mappában van. Van ötletetek miért?

    Az elkészülő - feltétlezem JAR-ban is benne van? Ha igen, ott, ahol lennie kellene?
    Ha nincs felülírva, akkor a /static, vagy /public mappában kellene lennie a classpathon futási időben.
    Ha nincs ott, akkor maven, vagy gradle setup lesz a probléma. Vagy ha esetleg csak IDE-ben nem megy java -cp-s futtatással, akkor az IDE-ben kell megkeresni azt, hogy miért nem olyan classpathot rak össze futtatáskor, mint amit kellene.

  • Drizzt
    nagyúr

    Értem, de az a-t újra létrehoztam. Az már más példány más címmel?
    Az a2 mégis módosult.

    Ja igen. A helyzet az, hogy az a2 nem módosulhatott. Valami más miatt tűnik úgy, mintha ez történt volna. Hogy néz ki az A class? Nem véletlen valami static field-et állít át a konstruktora? Mi alapján gondolod, hogy a1, meg a2 is "hi"?

    Itt egy példa, hogy ennek a fajta értékadásnak az a2(, a példában s2) által mutatott címet nem szabadna mósodítania.

    @Test
    void assignment() {
    String s1 = new String("Hello");
    String s2 = s1;
    s1 = new String("hi");
    System.out.println(s1);
    System.out.println(s2);
    System.out.println("s1 default hashcode: " + System.identityHashCode(s1));
    System.out.println("s2 default hashcode: " + System.identityHashCode(s2));
    }

    Output:
    hi
    Hello
    s1 default hashcode: 1366025231
    s2 default hashcode: 1427889191

  • Drizzt
    nagyúr

            A a = new A("hello");
            A a2 = a;
            a = new A("hi");

    a = hi, a2 = hi
    ugye milyen klassz?

    kiderült a háttérben pool-ozva vannak, és ugyanazt az objektumot kaptam újrafelhasználásra

    Nem poolozva vannak, hanem egyszeruen az osztaly/interface tipusu valtozok gyakorlatilag pointerek. Szoval ezekkel a sorokkal kb. az alabbit csinaltad:
    A heapen letrehoztal egy A tipusu peldanyt. A kis a valtozot letrehoztad a stacken, ami az elobb letrhozott heapen levo peldany cimere mutat. Letrehoztad az a2 valtozot a stacken, ami ugyanarra a cimre mutat az ertekadas miatt, mint a.

    Emiatt van az is, hogy nyelvi alapelem lett az equals, hogy latvanyosan megkulonboztetheto legyen az ertek szerinti osszehasonlitas a cim szerintitol.

  • Drizzt
    nagyúr

    Android Studio (Idea) azt javasolja cseréljem le a lambdát method reference-re.
    pausedActions.forEach((k, v) -> {
    k.addAction(v);

    vs
    pausedActions.forEach(Actor::addAction);

    class Actor { public void addAction (Action action) {
    nem is értem a lambdában miért van kávé? Biztos túl sokat iszom.

    Vagy csak siman egy entry altalaban key, value parost jelent.

  • Drizzt
    nagyúr

    indításkor kér be a terminálról.

    Vagy ha eleg annyi, hogy a rooton kivul mas ne tudja elerni, akkor lehet egy csak a programot futtato linux user altal olvashato fajlban tarolni.
    Ezernyi jobb es rosszabb megoldas letezhet, ismerni kellene hozza a kornyezetet, meg a lehetseges tamadasi vektorokat.

  • Drizzt
    nagyúr

    Sziasztok.

    Volna néhány olyan érzékeny adat (email fiók jelszó, stb), amit tisztán plain text-ben nem szeretnék property-ben tárolni. Milyen megoldást tudnátok javasolni, hogy védve is legyen, de módosítható legyen rebuild nélkül?

    Jasypt, Spring cloud config. Ami az erdekes a kerdeskorben, hogy az encryption keyt hol tudod eltarolni es beszerezni az alkalmazas altal, de mas user altal nem.

  • Drizzt
    nagyúr

    Sziasztok!
    Adott két properties file:

    application.properties és application-dev.properties

    Tudja valaki, hogy a Spring Boot miért nem tud kiolvasni a második file-bol?

    @Value("${msg}")
    private String message;

    Nem tudja kiolvasni az msg-t csak ha az első file-ba teszem, miért :F ?

    Hiba: Could not resolve placeholder 'msg' in value "${msg}"

    Köszi!

    Meg kell mondani az alkalmazasnak inditaskor, hogy melyik profilokat hasznalja. Application.properties by default mindig beolvasasra kerul, a - dev-hez aktivalni krll a dev profile-et. Asszem ha jar-kent inditod, akkor - Dspring.profiles.active=dev a megfleelo kulcsszo, de fejbol irom, lehet rossz.

  • Drizzt
    nagyúr

    Sziasztok!
    Friss Windows-om van. Még nincs Java és Spring Tool Suite sem. Spring Boot használatához elég a JDK SE vagy JDK EE kell?
    Gondolom ha Tomcat-et használok akkor nincs szükség az EE-re... :F
    Köszi!

    Jdk SE eleg. En mondjuk inkabb Intellij community-val allnek neki, meg ha joval baratsagtalanabb is, mint az Ultimate. De azert arra meg nem vettem ra magam, hogy otthonra is megvegyem az Ultimate-et. Nehany pluginnal a community is eleg jo a Springhez.

  • Drizzt
    nagyúr

    Ok, de a kotlin, mint jelenség még mindig kisebb százalékát érinti a projekteknek. Egyrészt. Másrészt meg szerintem ha nem szokványos taszkok vannak, azok legtöbb esetben design problémák. De tényleg ugorjunk :)

    Mostmar ha elorangattad, ne hatralj ki. ;]
    Erre en csak annyit akartam irni, hogy eddig olyan 5 eves maven hasznalatom alatt egyszer sem jott szembe olyan dolog, amire nem lett volna letezo plugin, ami megoldotta a problemat. Oke, vannak azert olyanok, amitol jobbat is el tudnek kepzelni, de egyutt lehet vele elni. Van amugy joval hosszabb programozoi tapasztalatom(ossz. ~15 ev), de OOP/Java az legyen inkabb 5 ev. Ezert 5 ev a maven is.
    Illetve ami pl.: Gradle-re atteressel problema lenne, hogy van egy jo szazas nagysagrendu microservice, ami azert jelenleg elegge hasonlit build projektileg. De ettol fuggetlenul mindegyikben johet fejlesztesi igeny. Ha meg hirtelen a projektek egyik fele maven, a masik fele meg gradle lenne, bevinne egy szep kis extra komplexitast.

  • Drizzt
    nagyúr

    Tényleg nem szabad használni a switch statement-et?

    De, szabad hasznalni. Viszont ha nem valamilyen factory metodusban hasznalod, akkor gyanus, hogy lenne helyette szebb, biztonsagosabb, bovithetobb OOP megoldast talalni a problemara. Nyilvan nem mindig. Akkortol jon a gond, ha tobb metodusban ugyanazon ertekkeszlet alapjan kell kulonbozo dolgokat csinalni, mert konnyen el lehet cseszni, ha bovul az ertekkeszlet.

  • Drizzt
    nagyúr

    Mi az előnye a teljesítmény mellett? Sokkal rugalmasabb: deklaratív és procedurális egyben. Ha valami nem szokványos dolgot kell megoldani, elég egy kisebb scriptet írni benne. Nem vagy kötve a CI/CD képességeihez, és lokálisan is meg tudod azt tenni, amit a CI/CD pluginekkel támogat
    Azt sem tartom valós problémának, hogy annyit kéne vele bíbelődni, hiszen a fejlesztőkörnyezetek már eléggé támogatják a nulláról kezdést is, ahogy a maven esetében. Sokkal körülményesebb a maven, de igazán nem akarok téríteni, nyilván nem kötelező, ha valaki nem akarja. Végülis lehet írni SOAP-os vagy RMI-s alkalmazást is manapság, az is működhet...

    Off az off-ban: szoktam találkozni olyan emberekkel, akiknél megfigyelhető az a felfogás, hogy csak abba az irányba hajlandóak elmozdulni, amerre a kényszer viszi őket. Ők általában egy idő után benne ragadnak egy adott technológiai stackben, ami egy ideig fel sem tűnik nekik. 10 évvel később viszont már riasztó, amikor még mindig servletről beszél, és oracle + jdbc a DB megoldás mindenre

    Remek, de ezekre nincs szuksegunk. Egyszer jo lenne atterni, de joval nagyobb annak az ara, mint amit itt sugallsz. Mindenkeppen eltart egy ideig, mig egy programozo csapat atszokik egy masik build tool-ra. Nyilvan van az a helyzet, amikor a relativ koltsege az atallasnak kisebb, mint a relativ haszna. Nalunk jelenleg nem az.

  • Drizzt
    nagyúr

    A megfelelő build alap összerakása elhanyagolható erőforrásigényű egy átlagos projekt többi feladatához képest. Nyilván nem a legkritikusabb helyzetekben kell fejest ugrani az ismeretlenbe, de ezzel a mentalitással bele lehet ragadni technológiákba. Amúgy pont devopsos szempontból nem értem a dolgot, hiszen épp a gradle az, ami sokkal kezesebb groovy/kotlin oldalról. Compose-os projektekben befonnánk egymás haját, ha mavent kellene használni.

    "A megfelelő build alap összerakása elhanyagolható erőforrásigényű egy átlagos projekt többi feladatához képest." Nem ertek egyet. Ez csak akkor igaz, ha az adott build rendszerhez es az azzal szembeni kovetelmeneykhez is valaki nagyon ert. Igazabol aztan utana tok mindegy, hogy pipeline-bol mavent, vagy gradle-t hivok meg.
    Projektek atlagos build ideje ket perc mavennel. Intellij meg ugyis feldolgozza az egeszet belso projekt formatumra, ami sokkal gyorsabb, foleg ha szelektiven akarsz valamit futtatni. Kiprobalnam en is elesben a Gradle-t, de nem igazan varok tole semmi valos hasznot a mi use case-unkben. Ha nagyon nem lesz semmi dolgunk, akkor majd rakerul arra is a sor. A mostani maven service template-jeink tokeletesen megfelelnek az elvarasainknak, a lecserelesukben sokkal tobb lenne a potencialis risk, mint a potencialis benefit.

  • Drizzt
    nagyúr

    És van igény ott új dolgok megtanulására (kérlek ne pejoratív érelemben értsd). Nálunk a mavent írtják - szerencsére. Persze ez csak marketing de: [link] .

    Alapvetoen van, de elsosorban business case-ekhez kototten. Meg igyekszunk mindig uj dolgokat behozni, ha hasznos, vagy hosszan tarto megoldast adhat. De nalunk mindenki erosen devops/automated tester/data magus is egyben, s legkevesbe izgalmas/lenyeges resz az egeszben a java build. Nyilvan a magussal tuloztam, de inkabb a szeles tudas az, ami nalunk a fokusz, nem pedig a reszletekbe meno tudas egyes alteruleteken.

  • Drizzt
    nagyúr

    Jó én ebből a vitából kiszállok. Nem fogom megérteni sosem a régi dolgokhoz ragaszkodást. Fiatal vagyok hozzá. :D

    Ha keresztbe-kasul ismersz valamit, s atlagban egy problemat 3mp megoldani neked benne, akkor nagyon nyomos erv kell ahhoz, hogy lecsereld valami masra, amiben ugyanez a folyamat a kompetenciad hianya miatt eltartana vagy 1 napig.

    Nalunk minden regi es minden uj projekt is maven, szimplan azert, mert van par emberunk, aki nagyon ert hozza. Ok tenyleg kb. 5 perc alatt a legkomplexebb projekteket is atlatjak, mig Gradle-hez nincsen ilyen emberunk. A build time meg nem kritikus.

    Persze lenne haszna gradle-zni, legalabb lenne eselye kialakulni benne mely kompetencianak. Ha ma kezdenek Javazni, biztos azzal kezdenek. Igy viszont, hogy teljesen otthonos terep a maven, foleg ezt hasznalom, itthon is. Volt projekt amit gradle-lel kezdtem, de semmi nem vitt ra utana, hogy a kovetkezot is azzal csinaljam. Van boven mas szakterulet, ahol tobb hasznot hoz a raforditott tanuloido.

  • Drizzt
    nagyúr

    Sziasztok!

    mvn exec:java -Dexec.mainClass=cinema.Program -Dexec.args="http://localhost:8080/WebService/Cinema A 5 Lock"

    Az fent látható paranccsal szeretnék futtatni egy "Maven simple project"-et. A problémám ott kezdődik, hogy a program argumentumaként adott URL-t a maven megpróbálja pluginként feloldani. Nem meglepő módon, nem talál hozzá metadatat és elhal a build.

    A program Eclipseből indítva ugyanezekkel az argumentumokkal, hibátlanul működik. A cinema.Program osztály is megfelelően van benne. Mondhatnátok persze, hogy futtassasm Eclipse-ből, de egyetemi feladathoz kell és gondolom így fogják tesztelni.

    Bármi ötlet, hogy ez mitől lehet? :F
    (Én alapvetően .Netes vagyok, szóval most először dolgozom mavennel. :B )

    [link]

    Proba igy?
    mvn exec:java -Dexec.mainClass=cinema.Program "-Dexec.args=http://localhost:8080/WebService/Cinema A 5 Lock"

  • Drizzt
    nagyúr

    What kind of sorcery is this? :D

    Spring boot 2.4.0, data-jpa és data-rest függőségekkel. Jó, van még egy h2 db, meg egy actuator, de az nem számít. Semmi konfiguráció, sem extra függőség, nem értem.
    Szóval csináltam egy hót egyszerű spring boot appot, tettem bele egy City nevű jpa entity-t, meg hozzá egy töküres JpaRepository-t. Zéró REST végpont mutat bárminemű City-vel kapcsolatos dologra, mégis, amikor megkérdezem a root végpontot, akkor ezt a fenti izét nyomja az arcomba.
    Az összes végpont, amit csináltam egy "/hello", és a hello world-ön kívül semmit sem csinál.

    Már átnéztem a spring doksi teljes hateoas szócikkét, de egy falat megjegyzés sincs arról, hogy a spring kitalált nevű végpontokat szór fel nekem az alkalmazásomra csak úgy, expozálva ezáltal az app belső dolgait, konkrétan az entitások neveit. Egyrészt ez felháborító, hogy kérdés nélkül ilyet csinál, másrészt ti találkoztatok ezzel? Miatököm csinálja, és hogyan lehet kikapcsolni?

    Ez a Spring Data Rest default viselkedese. Convention over configuration, mint megannyi mas helyen a spring bootban.
    Megfeleloen uj Spring verziokkal o lesz a baratod: [stackoverflow: set exposed repositories to annotated only. ]

  • Drizzt
    nagyúr

    Ja és itt van az application.properties tartalma:
    spring.application.name = HelloWorldExampleApplication
    server.port=8080
    spring.profiles.active=@spring.profiles.active@

    Erre biztosan nem lesz szükséged. Ez beállítja aktív profilnak a @spring.profiles.active@-at, ami nagyon valószínű, hogy nem létezik. Szóval nyerni nem nyersz vele.
    A logban hiba nincs. Viszont hiányzik belőle, hogy a Tomcat elindulna a 8080-as porton, mint ahogy a példa screenshotján is van.
    Annyit látok a logodban, hogy a "D:\eclipse_workspaces\java_coding_exercises\HelloWorld_Example\target\classes" könyvtár biztosan rajta van a classpathon. Mik vannak ebben a könyvtárban? Benne van a ApplicationConfiguration.java? Illetve egyáltalán a Spring MVC-s dependency-k ott vannak? Távolról ezt elég nehéz diagnosztizálni.

  • Drizzt
    nagyúr

    Köszi!
    Közben pontosan azt csináltam amit most látok, hogy javasoltad.
    De, az egész dolog több sebből is vérzik sajnos.
    Kezdjük ott, hogy ha elindítom az alkalmazást 3 sor üzenet után rögtön terminálódik. Próbáltam valami profile dolgot csinálni mert arra is panaszkodott, de hiába, nem segített. Vagy igen, de az kevés volt.
    Nem jövök rá, mi az ami hiányzik.
    Ha van valami tanács, hogyan maradjon életben az applikáció annak nagyon örülnék.

    Mutasd meg a logot. Profile nem feltelenul kell, alapbol ki szokta irni, hogy defaultot hasznal, ha mas nincs megadva.

  • Drizzt
    nagyúr

    Sziasztok!
    Az alábbi tutoriálon (Eclipse, Java, Spring Boot, Microservice) próbálok végigmenni:
    [link]
    Ott akadtam el, hogy valami configuration fájlt kellene csinálni, ezt írják róla:
    "Even though this application acts ready as a stand-alone application, we will still add a configuration file to it. This will help us handle the HTTP requests. Refer to the snapshot below."
    Szerintetek hogyan kellene elkészíteni és hogyan kellene hozzáadni az alkalmazáshoz?
    Előre is köszi.

    Ranezve a @RestController komponensre gondol konfiguracio alatt. Nem vilagos, hogy miert igy hivja.
    Mindenestre annyi az egesz, hogy a HellowWorldExampleApplication.java melle csinalj egy ApplicationConfiguration.java nevu fajlt, a kepen megadott tartalommal, s ennyi. Rakhatod olyan package-be is, ami melyebben van, mint az HelloWorldExampleApplication, mert a component scanninggel azt is meg fogja talalni.

  • Drizzt
    nagyúr

    Gondolom race condition valamelyik klasszikus esete. Vagy egyeb apro reszlet a debug/run kornyezet kozott, ami nem lett reszletezve.

  • Drizzt
    nagyúr

    "Unexpected bound" a Class<T extends AbstractInvoiceEntity> newClass-re.

    #11308 az már részletkérdés lenne :) mindegyik 0 paraméteres, szóval elég lenne, de a fenti probléma miatt így se, úgy se jó :(

    E helyett: Class<T extends AbstractInvoiceEntity> newClass siman Class<T> newClass kell.

  • Drizzt
    nagyúr

    protected static <T extends AbstractInvoiceEntity> T getInvoiceEntity(AbstractInvoiceEntity originalEntity, Class<T extends AbstractInvoiceEntity> newClass) {
    T newInvoice = newClass.newInstance();
    (...)
    return newInvoice;
    }
    valami ilyesmi vagy átadsz egy factory-t, ami létrehozza a kívánt objektumot

    En a newClass helyett inkabb Supplier<T>-t hasznalnek. Akkor nem vagy megkotve, hogy csak 0 parameteres konstruktoru osztalyokkal mukodjon.

    Az se teljesen vilagos, hogy ez miert egy static method, elso erzesre siman lehetne az AbstractInvoiceEntity-nek egy tagmetodusa.

  • Drizzt
    nagyúr

    Dinamikus weboldal készítéséhez, de mivel kezdő vagyok, az is egy kérdés persze, hogy egyáltalán érdemes-e tanulni a Java EE-t.
    Még nem láttam elég videót, nem olvastam elég cikket, hogy felmérjem, mi a legnaprakészebb tudás, amit érdemes megszerezni, ha az ember a Java nyelvet kezdte el tanulni, majd weboldalakat szeretne ksézíteni.

    Spring/Spring boot erzesre joval fenyesebb jelen/jovo elott all. Meg weboldalakat kesziteni azert nagyon sokfele modon lehet, de szerintem erdemes a weboldalt es a serveroldalt teljesen fuggetlenul fejleszteni. De attol is fugg, hogy mit akarsz az egeszbol kihozni. Nagyon elterjedt a single-page webapp valamelyik js frameworkben + Spring boot server alkalmazas.
    Java ee-ben szerintem a legnagyobb baj az uzemeltetesevel, meg a java EE app serverekkel van. Bar letezik oda is uber/fat jar megoldas.

  • Drizzt
    nagyúr

    Java EE tanulásához, (dinamikus weboldal készítéséhez) melyik tárhelyszolgáltatót válasszam?
    Nem otthoni környezeten szeretnék gyakorolni, hanem "egy kicsit élesebb" környezetben. Továbbá jól jöhet, ha valakinek/cégnek majd meg is akarom mutatni, amit készítek.

    Miert eppen Java EE?

  • Drizzt
    nagyúr

    Composite Design Pattern in Java

    Van itt valaki aki tényleg így fejleszt hogy "igen, itt a Composite Design Pattern-t kell használni" ? :)

    Igen. Leszamitva, hogy azert a Composite nem tul gyakori. Singletont, factoryt altalaban ugyis ad a framework, buildert a Lombok. Strategy szerintem elegge gyakori a jo kodokban ahol tipusfuggoen kell algoritmust valasztani. A java8, meg a Spring eleg sokat segit, hogy az oldschool modon kevesebbszer kelljen patternt implementalni.

  • Drizzt
    nagyúr

    Igen, castolni kellene, csak nem tudom mire és hogyan?
    Lehet castolni egy local inner class-ra? :)

    Ezerintem local classt nem lehet. De mibe tart kiprobalni? En most tableten vagyok, azert nem tudom. Inner class elerheto kivulrol, hacsak nem private, de a local class definicioja csak a definialo blokkon belul ervenyes. Annyira nem hasznalok ilyeneket soha, hogy nagyon nem vagyok bennuk biztos.

  • Drizzt
    nagyúr

    Pl. JavaFX-ben van egy metódus, ami TextFieldeket kérdez le, de ugyanezeket a mezőket egy másik metódus hozza létre, amikor egy menüpontra egy panel felugrik.
    Adjam át az összes textfieldet a lekérdező metódusnak? Nem egyszerűbb osztályváltozóként kezelni?

    Egyszerubbnek egyszerubb. Ha viszont valamiert tobben is hasznalnak ugyanazt a peldanyt, abbol meg baj is lehet. En csinalnek egy osztalyt, aminek a konstruktora letrehozza a textfieldeket, de nincsenek setterei. De van metodusa amivel a mezoket meg lehet szerezni. Ez mar igy kvazi egy immutable osztaly lesz, s akkor tobb szalon is jol mukodhet. Mezoben eltarolni azert veszelyes szerintem, mert nem garantalhato sorrendiseget varsz el. Lesz fv-d, ami beallitja a mezot, meg lesz ami lekerdezi. Mi van ha elobb hivjak meg a lekerdezot, mint a letrehozot? Az en javaslatomban ez nem fordulhat elo, mert letrehozni csak egyszer tudod a peldanyt, es amig az nincs meg, addig nem nem tudod meghivni. A te esetedben meg nem garantalja semmi a helyes meghivasi sorrendet.

  • Drizzt
    nagyúr

    Melyik az elfogadott/ajánlott eljárás, ha egy metódus módosít egy változót, és arra egy vagy több másiknak is szüksége van?
    1. Az adott változót osztályváltozóként kezelni, vagy
    2. A másik metódusnak paraméterként átadni?

    Talan az a legszebb, ha csinalsz egy masik osztalyy, ahol az emlitett valtozo osztalyvaltozo, s az ot cseszegteto metodusok is az uj osztalyban vannak.

    De fejtsd ki jobban a problemat. Remelem olyan dolgok nincsenek, hogy meghatarozott sorrendben kell meghivogatni a dolgokat.

    Vagy ha ez valami seged metodus, ami mindenfele muveleteket tud vegezni a parameterrel, akkor mehet egy utility osztaly static metodusanak.

    Konkretabb pelda tenyleg sokat segitene.

  • Drizzt
    nagyúr

    A probléma a teg készülékedben lehet. Egy kezemen meg tudom számolni hányszor crashelt össze az elmúlt fél évben (0). Gradle + spring micro servicek néha nyitva 3-4-5 (bár ez full irreleváns).

    Nekem se volt még vele sose ilyen probléma. És nálam is meg van nyitva vagy 5-6 Spring microservice, 2-3 JavaEE app, meg néhány devops repo állandó jelleggel. Maven mind. Mondjuk amúgy a maven részét annyira nem szeretem az IDEA-nak, bár összehasonlítási alapom nem nagyon van, mert mást 10+ éve nem használtam(Javara).

  • Drizzt
    nagyúr

    JPA-ban van arra automata lehetőség, hogy a fő entity, és a hozzá tartozó al-entity-ket egyszerre rakja a DB-be? Tehát van egy fő entity, amihez kapcsolódhat sok al-entity.
    Mert fő entity save-nél csak a fő entity elemeit menti le, a benne lévő al-entityket nem.
    Tényleg csak selectkor képes összeszedni mindent, máskor szájba kell rágni az egyértelműt?

    Cascade a funkcio amit keresel. Amugy altalaban nem annyira javasolt a hasznalata. Meg tudod adni egy tombben, hogy milyen muveleteket kaszkadoljon egy adott entitas objektumra, vagy entitas kollekciora.

  • Drizzt
    nagyúr

    Kérdés:
    - Addott egy osztály, aminek főleg beépített osztályok az adattagjai. Van benne 1-2 Set is, amiket nyilván addAll-lal szeretnék összeuniózni. Erre van-e valami jó library, ami generálhat ilyet? Szóval olyat, mint lent az incrementBy.

    public class Example {

    private Double value;
    private Integer count;
    private Set<String> stringSet;

    public void incrementBy(Example other) {
    value += other.value;
    count += other.count;
    stringSet.addAll(other.stringSet);
    }
    }

  • Drizzt
    nagyúr

    Most kellett :)
    Linkeltem fent a bugot, ami valahol van... exception alapján spring data-ban van, de a workaround az egy criteriaquery, aminél nem jelentkezik ugyan az a bug:

    @Query("select p.id from Photo p where p.user = ?1")
    List<Long> findIdsByUserId(long id, boolean restricted);
    Ez elhasal, a linkelthez hasonló: org.springframework.dao.InvalidDataAccessApiUsageException: Parameter value [34] did not match expected type... -al

    Míg ugyan az a lekérdezés (kicsit még kibővítve), criteriaqueryvel, ugyan olyan metódusparaméterekkel, fut ahogy kell:
     public List<Long> findIdsByUserId(long id, boolean restricted) {
      var cb= em.getCriteriaBuilder();
      var ids=cb.createQuery(Long.class);
      var root=ids.from(Photo.class);
      ids.select(cb.construct(Long.class, root.get("id")));
      var pred= new ArrayList<Predicate>();
      pred.add(cb.equal(root.get("user"), id));
      if (!restricted) pred.add(cb.equal(root.get("restricted"), false));
      ids.where(pred.toArray(new Predicate[pred.size()]));
      return em.createQuery(ids).getResultList();
     }

    fura. user= User entity kapcsolat, ami DB-ben egy BIGINT-et jelent user_id mezőben.

    Igy ranezesre: ket fuggveny parametered van, mig a querynek csak 1. A @Queryben jpql expression van. Ha a user id-jere akarsz szurni, akkor: where p.user.userId =?

  • Drizzt
    nagyúr

    Köszi a választ.
    A jsp-k azok futnak, nincs skype a gépemen
    A 80-as porton futna
    A két kód teljesen ugyanaz, a db is. Asztali gépen lett megírva a kód ahol teljesen jól működött, aztán meg a laptopon ezt a hibát adta.
    XAMPP adatbázissal lett fejlesztve.

    Hibaüzenet:

    HTTP Status 500 – Internal Server Error

    Type Exception Report

    Message Error instantiating servlet class [login.LoginServlet]

    Description The server encountered an unexpected condition that prevented it from fulfilling the request.

    Exception

    javax.servlet.ServletException: Error instantiating servlet class [login.LoginServlet] org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:541) org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:92) org.apache.catalina.valves.AbstractAccessLogValve.invoke(AbstractAccessLogValve.java:678) org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:343) org.apache.coyote.http11.Http11Processor.service(Http11Processor.java:367) org.apache.coyote.AbstractProcessorLight.process(AbstractProcessorLight.java:65) org.apache.coyote.AbstractProtocol$ConnectionHandler.process(AbstractProtocol.java:860) org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1598) org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:49) java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1135) java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:635) org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61) java.base/java.lang.Thread.run(Thread.java:844)

    Root Cause

    java.lang.RuntimeException: login.LoginServlet.<init>(LoginServlet.java:1) java.base/jdk.internal.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) java.base/jdk.internal.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62) java.base/jdk.internal.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45) java.base/java.lang.reflect.Constructor.newInstance(Constructor.java:488) org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:541) org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:92) org.apache.catalina.valves.AbstractAccessLogValve.invoke(AbstractAccessLogValve.java:678) org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:343) org.apache.coyote.http11.Http11Processor.service(Http11Processor.java:367) org.apache.coyote.AbstractProcessorLight.process(AbstractProcessorLight.java:65) org.apache.coyote.AbstractProtocol$ConnectionHandler.process(AbstractProtocol.java:860) org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1598) org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:49) java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1135) java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:635) org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61) java.base/java.lang.Thread.run(Thread.java:844)

    Note The full stack trace of the root cause is available in the server logs.
    Apache Tomcat/9.0.30

    Ugyanolyan verzioju a Java a gepeken? A Java module support elegge bekavart a reflectionnek, a hibauzeneted meg onnan jon. Elsore ugyanolyan jdk-t bugaznek.

  • Drizzt
    nagyúr

    Őszintén...?
    DevOps-os szemmel nézve nem is szerencsés az IDE ilyen szintű integrációja. Ha nem oldható meg egy jól definiálható pipeline/toolchain segítségével automatizáltan még lokálisan is, akkor megette a fene az egészet.
    Mondanám, hogy VS Code + gradle FTW, de a Red6 annyira elcseszett most valamit a Java bővítményen, hogy szinte használhatatlan. Addig meg Idea CE...

    Szerintem teljesen mindegy milyen szemmel nézed, a lényeg, hogy a developernek a lehető legkényelmesebb legyen a fejlesztés, annak az összes aspektusával, különös fókuszt téve a debuggingra, a build/deploy sebességre, stb. Milyen olyan pipeline-t tudsz mondani, ami lokálisan gyorsabb, egyszerűbb, szükség esetén gyorsabban testre szabható, mintha közvetlen a gépeden fut az app server, vagy a Spring boot app? Ha csinálsz egy dockerben levő Java EE szervert, akkor ahhoz, hogy oda deployolj, ott debugolj szintén kell ultimate edition. Ha egy app server image-ből kiindulsz dockerfile-ban, és mellé rakod az alkalmazásod a buildnél, az lassabb és körlülményesebb lesz jóval. Sajnos a "jó" devops pipeline-nak gyakran az a vége, hogy az emberek csak deploy + println-nel tudnak debuggolni.

    Egyébként a legjobb debugging tool meg szerintem a unit teszt, két okból is: gyors, olcsó, és ha sikerül megfejteni a hibát, automatikusan van rá regression teszt. Csak sajnos nem mindig elég a hibához a unit test.

    (#10940) mobal: Ok, de a kérdés kimondottan JEE volt. Egyébként a Springes véleményeddel is vitára kelnék. Munkahelyen ultimate-et használok, itthon CE-t.Az ultimate-ben sokkal több infót kapsz. Pl. autowiringnél már ki szokta jelezni, ha nincs autowire candidate, vagy több is van, s kéne qualifier. application.properties szerkesztése közben az éppen elérhető property-t felkínálja dokumentációstul. Van JPA support. És ezek most csak ilyen hasraütésszerű dolgok, lehetne még találni bőven különbséget. Meg így is vannak amik hiányoznak ultimate-ből is. Pl. custom autoconfigurable bean-ek felismerése autowiringnél, etc.

    [CE vs ultimate]

  • Drizzt
    nagyúr

    Spring-gel dolgozom és tökéletes a CE.

    A kerdes JEE volt. Azt azert eleg kellemetlen idea CE-vel nyomatni. 1-2 eve meg tuti nem tamogatta az app szerverre deploymentet sem. De Springet is joval egyszerubb Ultimate-tel. Viszont azert szukebb az ollo.

  • Drizzt
    nagyúr

    próbálom megérteni a streamek furcsaságait, de nem sikerül:
    Arrays.asList(asd).stream().forEach(System.out::println);
    Miért nem írja ki a lista tartalmát? Egy ref stringet ír ki, gondolom a stream-ét.
      for (int j : asd) {
       System.out.println(j);
      }
    A klasszikus foreach meg simán működik, ahogy kell.

    Miért?

    A streammel nincs baj, az Arrays.asListet használod rosszul. Az listát csinál a megadott tömb elemeiből. Jelen esetben egy egy elemű listád lesz, aminek az az egy eleme egy int[] lesz.

    int[] ints = new int[]{0, 1, 2, 3};
    Arrays.asList(ints).stream().forEach(System.out::println);
    Arrays.asList(1, 2, 3).stream().forEach(System.out::println);

    Arrays.stream(ints).forEach(System.out::println);

    Eredménye:

    [I@1218025c
    1
    2
    3
    0
    1
    2
    3

  • Drizzt
    nagyúr

    Használjátok a funkcionális programozást mindenhol ahol csak lehet?

    for (Label infoLabel : infoLabelList) {
       uiTable.row();
       uiTable.add(infoLabel);
    }

    helyett:

    infoLabelList.forEach(x -> {
       uiTable.row();
       uiTable.add(x);
      });

    Ahol jobban olvashato ott igen. En igyekszem ahol lehet, de ha tul egzotikusan kell megoldani(pl. Exception dobo metodusok), ott nem hasznalom.

  • Drizzt
    nagyúr

    Melyik egyetemen vagy?

    Semelyiken. Külső elbírálónak kértek fel egy diplomamunkához. Többé nem is kívánok ilyet csinálni.

    Egyeteme válogatja milyen elvárás van a külső elbírálóval szemben. Az adott helyzetben annyi volt, hogy x ideje legyen diplomája.

  • Drizzt
    nagyúr

    Többek között az ilyenek miatt örülök, hogy Kotlinra sikerült váltanom.

    Apropó, valaki doilgozik a Kotlin-nal rajtam kívül?

    Kotlinban is igaz ugyanez, csak a "===" vonatkozásában.

    Nekem annyi közöm volt a Kotlinhoz, hogy valakinek a diplomamunkáját elbíráltam, aki Kotlinban írta hozzá a programot.

  • Drizzt
    nagyúr

    Az == a referenciát ellenőrzi, az pedig sosem lesz ugyanaz. Javaban stringet az equals-szal tudsz ellenőrizni:

    if ("X".equals(xoTransferObj.getXoInput()) {
    ...
    }

    "Az == a referenciát ellenőrzi, az pedig sosem lesz ugyanaz." Ez így nem teljesen igaz. Pl. ha ugyanarra a String literalra hivatkozol, akkor a referncia is ugyanaz lesz, mert a fordító észreveszi, hogy több referencia van ugyanarra a stringre már fordítási időben, így nem fogja kétszer ugyanazt a konstants elrakni a memória megfelelő szegmensébe.

  • Drizzt
    nagyúr

    Helló!

    Elkezdtem az Agyhullám java könyvet. Egy kérdés: Van ennél részletesebben elmagyarázó könyv?

    [kép]

    Ennél a feladatnál elakadtam. Nem értem, miért kell hirtelen String változónév = "értékebetűkkel" helyett String[] változónév = {"értékebetűkkel"}?

    Mit jelent a []? Miért kell kapcsos zárójel amikor megadjuk az értékét? (bár tippem az, hogy a felsorolás miatt)
    Nem igaz, hogy nem találok normálisan elmagyarázó könyvet.....

    []: tömb. {ertek1, ertek2, ...}: tömb elemeket leíró literál. A lényeg, hogy több értéket felsorolhatnál, ami String és a tömbben akarod eltárolni.

    Az említett könyvet nem ismerem. Totál alap Java könyvet nem is tudnék ajánlani. Inkább Java alap videokat néznék. Pl. totál kezdő szinten van a Udemy-n a Java masterclass. Az talán már 100 óránál is hosszabb, nagyon sok dologra kitér, teljesen az alapoktól kezdve. Bár angol és fizetős.

  • Drizzt
    nagyúr

    "Good Comments
    Some comments are necessary or beneficial. We’ll look at a few that I consider worthy of the bits they consume. Keep in mind, however, that the only truly good comment is the comment you found a way not to write."

    Robert.C.Martin: Clean Code

    "Some comments are necessary or beneficial. We’ll look at a few that I consider worthy of the bits they consume." Tehát kommentet írni bizonyos esetekben és és jogos. Javadoc meg akkor igazán fontos, hogyha egy library API-ját írja le. Mivel akkor az konkrétan inkább dokumentáció, mint komment.

  • Drizzt
    nagyúr

    Titeket nem zavar ez a Clean Code tudathasadásos állapot?
    Clean Code szabály: ne írjunk kommentet, főleg ne Javadocot.
    Erre a 2017-ben megjelent Java9-ről szóló könyvben szerepel a hogyan írjunk metódust leírás:
    9 sor metódus, 15 sor magyarázattal előtte mit csinál :C

    És? Aki a Java9-es könyvet írta amit olvasol, azt mondta, hogy clean code enthusiast? Vagy honnan jön a tudathasadás feltételezés? Van aki követi, van aki nem. Nem szeretem a kommenteket, de néha van haszna. Főleg ha valamit úgy írsz meg, hogy elüt a best practice-ről, de van valamilyen jól megfogható oka, hogy miért van mégis úgy. Én nagyjából követem az elveket, bár a refactoring könyveket sokkal jobban és hasznosabbnak tartom.

  • Drizzt
    nagyúr

    Igen, az lesz az. Így már érthető, köszi szépen!

    Igen, bocs. A ph-s kódszerkesztő elég fura, lehet elvesztettem a kontent egy részét. Vagy lehet nem is volt meg soha.

  • Drizzt
    nagyúr

    Hali

    Hogyan nézne ki ez a kód, ha nem lambda expressionnal írnám? (JavaFX)
    Nem igazán értem, hogy mit csinál, talán a régebbi módon írva érthetőbb lenne.

    private List<Sprite> sprites() {
       return root.getChildren().stream().map(Node n -> (Sprite) n)
            .collect(Collectors.toList());
    }

    private List<Sprite> sprites() {
    List sprites = new ArrayList<>();
    for (Node node : root.getChildren()) {
    sprites.add((Sprite) node); }
    }

  • Drizzt
    nagyúr

    Hölgyek/Urak!

    Programozás vizsgára készülök, az egyik feladatnál megakadtam.

    Csv file-ból kellett adatokat beolvasni ArrayListbe, aztán mindenféle metódusokat gyártani rá. A csv file-ban gyümölcsök nevei (pl. alma, körte, stb) és hozzájuk tartozó adatok vannak, többek között a kalória.

    A feladat az, hogy a metódus kérje be a felhasználótól a gyümölcs nevét és a mennyiséget, és ez alapján mondja meg, hogy az adott mennyiségű gyümölcs hány kalóriát tartalmaz.

    Megcsináltam a metódust, azt szeretném elérni, hogy ha a felhasználó rossz nevet ír be (ami nem szerepel az ArrayListben), akkor addig kérje, amíg jót nem ad (jelen állás szerint ha rossz nevet ír be a felhasználó, leáll a program).

    Itt a kód:
    public static void kaloriaKiir(ArrayList<Gyumolcs> ertekek, File f) {
            Scanner scan = new Scanner(System.in, "ISO-8859-2");
            System.out.println("Kérem a gyümölcs nevét: ");
            String nev = scan.nextLine();
            if (gyum.toString().contains(nev)) {
                System.out.println("Kérem a mennyiséget grammban: ");
                int menny = scan.nextInt();
                for (Gyumolcs gyum : ertekek) {
                    if (nev.equals(gyum.Megnevezes)) {
                        System.out.println(menny + " gramm " + gyum.Megnevezes + " " + gyum.kcal / 100 * menny + " gramm kalóriát tartalmaz.");
                    }
                }
            } else {
                System.out.println("Nem megfelelő név!");
            }
        }

    Van valami ötletetek?

    Bulizhatz rekurzioval: az utolso else agban meghivhatod a kaloriaKiirt megegyszer.
    Bulizhatsz do-while ciklussal: do... while (beolvasott szo nem gyumolcs).

    Amugy van sok furcsasag a kododban. Lehet csak a tableten nem latom, de mi szukseged van a File f parameterre? Mi a gyum, honnan jon az extended for loop elott. Van egy static String gyumod az osztalyban valamilyen ertekkel?

  • Drizzt
    nagyúr

    Sziasztok!
    Írtam egy hosszabb kódot, amiben az Arraylist rendezése nem működik.
    Csak ezt a részt kivettem, hogy egy egyszerű példán oldjam előbb meg, de ugyanúgy nem jó.
    Tudtok segíteni, hogy mi a baj vele? Miért nem jó?
    A Collection.sort... kezdetű sornál jelez hibát.
    Ezt irja ki: non-static variable dis cannot be referenced from static context
    Köszönöm a segítséget.

    public class Komparator {
     class KutyaRend implements Comparator<Kutyak> {
     @Override
     public int compare(Kutyak o1, Kutyak o2) {
     return o1.getKor()-o2.getKor();
     }
     }
     public static void main(String[] args) {
     Kutyak kutya;
     ArrayList<Kutyak> KutyaLista=new ArrayList<>();
     kutya=new Kutyak("Stefi", 6);
     KutyaLista.add(kutya);
     KutyaLista.add(new Kutyak("Lacy", 2));
     KutyaLista.add(new Kutyak("Roger", 3));
     KutyaLista.add(new Kutyak("Tomi", 4));
    Collections.sort(KutyaLista, new KutyaRend());

    Ez szerintem egy elég nehezen érthető része a javanak. De a lényeg. Van a Komparator osztályod. Ezen az osztályon belül van egy inner classod, a KutyaRend. Ilyenkor a kutyarend osztály mivel nem static, ezért a példánya csak egy adott objektumpéldányon belül hozható létre. A static method nem példányhoz, hanem osztályhoz tartozik, így annak nincsen példánya, tehát nincsen benne KutyaRend létrehozási lehetőség sem. Legkönnyebben ezt itt úgy tudod megoldani, ha a Kutyarend osztályt statická teszed:
    static class Kutyarend ...

    De ettől sokkal szebb, ha nem ágyazod be az osztályba semmilyen módon, hanem külön osztályba teszed. Sőt, ha ez a kutyák természetes rendezése, akkor elég a Kutyákat implements Comaparble<Kutyák> módon megadni, s akkor benne a compareTo-t implementálni.

    Még egyszerűbb, ha használod a Java 8-as Comparators.comparing-et, így:
    Collections.sort(KutyaLista, Comparators.comparing(Kutyak::getKor));

  • Drizzt
    nagyúr

    jaja, így csinálják a windowsról átszökött, unixot messziről ugató fotelprogramozók :P :P :P

    nem, nem mindegy, hogy fájlba írod-e, tehát átkergeted kétszer a fájlrendszeren és a blokkos eszközökön a cuccot, vagy memória puffereken keresztül tolod be. nem pazaroljuk az erőforrásokat. különös tekintettel az iot nevű betegségre, ahol flash drájvokat nyírhatsz ki azzal, ha fájlba írsz, mivel a ramdiszk jellemzően kevés.

    select meg watch service meg toronyóra lánccal... az eredeti kérdés szerint linuxon futna, ami egy unix. nem bohóckodunk ilyenekkel.

    ha az a probléma, hogy debuggolni akarod a fájlt, akkor van rá segédporgram. tee. tehát azt írod, hogy:

    sensorread | tee /tmp/logfile1 | sed | tee /tmp/logfile2 | mysql

    ha nem akarod azt a hatalmas nagy sedet folyton forkolni, és mindenáron bele akarsz piszkolni a fájlrendszerbe, akkor egyik taszkban:

    sensorread >>/tmp/dumpfile &

    másik taszkban:

    tail -f /tmp/dumpfile | sed | mysql
    vagy
    tail -f /tmp/dumpfile | java -jar tefeldolgozod.jar

    második esetben esetleg van értelme jávás watch objektumozni...

    de ha már ennyire elb.szarintod az architektúrát, akkor a legegyszerűbb az, ha a szenzorok adatait logoltatod a syslogba, és abból azon a gépen ott és akkor azt csinálsz, amit akarsz.

    miért érzem azt, hogy azért jobb a jáva szerinted, mert a shell programozásról fogalmad sincs?

    Muhahaha. :D
    Remekül szórakoztatod az embert a nagyon furcsa feltételezéseiddel, de közben szerencsére jó dolgokat is mondasz.

    Arról sehol nem volt eddig szó, hogy mekkora méretű lenne az adat. Én eddig mindvégig azt feltételeztem, hogy kicsi.

    "select meg watch service meg toronyóra lánccal... az eredeti kérdés szerint linuxon futna, ami egy unix. nem bohóckodunk ilyenekkel." És a select melyik oprendszer egyik fontos syscallja? :)

    A tee-t tök jó, hogy felhoztad, mert magamtól nem jutott volna eszembe a neve, remélem most jobban elmélyül a tudatomban.
    A syslogos megoldás az amúgy tetszik, bennem is bennem volt.

    "tail -f /tmp/dumpfile | java -jar tefeldolgozod.jar
    második esetben esetleg van értelme jávás watch objektumozni..."
    De ilyenkor egy sima Scanner.nextLine is elég. Az vár az új inputig, vagy amíg a stdin-je el nem tűnik.

    "miért érzem azt, hogy azért jobb a jáva szerinted, mert a shell programozásról fogalmad sincs?"
    Én ilyet sehol nem írtam. Különböző célokra különböző eszközök a jók. Hirtelen meg az ember mindig úgyis azt a megoldást fogja ajánlgatni, amivel éppen a legjobban képben van. Ha nagyon akarnék, akkor én is elkezdhetnék kötekedni, hogy miért mysql-ben akarod a szenzor adatokat eltárolni, amikor vannak más kifejezetten ilyen célú adatbázisok is. De nem teszem, mert valószínűleg a probléma olyan kis méretű, hogy igazából nem számít.

    Ui. a mysql klienst úgy kezeled itt mindenhol, mintha minden linuxon kötelezően rajta lenne, de az ugyanúgy egy dependencia, ami vagy van, vagy nincs.

    "most eltekintve attól, hogy tök értelmetlen http-n csinálni ilyet, a curl-ben túl sok hiba van ahhoz, hogy komoly rendszeren használd."
    Ezt btw. még kifejthetnéd, hogy mire gondolsz. Milyen hiba? (És természetesen a curl sem feltétlen minden disztró része)

  • Drizzt
    nagyúr

    "akkor linuxon mindent írjunk szerinted bash-ben": nem.
    a fő különbség a két rendszer között (unix vs. windows), hogy a unixot eredetileg kis programok hatékony összekapcsolására találták ki, a windows meg nagy monolitikus rendszerek futtatására. pl. ha windowson elindítod az outlookot, a fél office-t maga alá rántja, mert ha a levélben van excel vagy html, akkor máris behúzza az excelt meg a html motort.

    unixon ezzel szemben az az alapvetés, hogy kis programokat csinálsz (amikor csak lehet), azok egy dolgot csinálnak, de azt hatékonyan és jól, és rábízod az oprendszerre, hogy összekösse a programjaidat.

    ezért amikor elhangzott itt (nem Peachmantől), hogy a szenzor program tegye le diszkre egy fájlban az adatot és azt olvassa be jávából LINUXON, akkor azt gondoltam, hogy ezzel totálisan szívenszúrja a unixos alapfilozófiát. kevésbé udvarias megfogalmazásban ekkora f.ságot évek óta nem hallottam.

    tehát itt a unixos filozófia szerinti megoldás az, hogy van egy szenzorleolvasója, van egy átalakítója meg egy adatbáziskliense, amiket a shell összeköt:

    sensorread | sed ... | mysql ...

    ha ezt el akarjuk rontani az itteni kérdés szintjére, akkor is az a megoldás, hogy jávában a szabvány bemenetet olvassa és azt elemzi, és csővezetékkel kerül a bemenetre az adat:
    sensorread | java -jar szenzorosztalyom.jar

    "Cserébe nem lesz olyan lassú.": értem, tehát a bash egy pártíz-párszáz soros szenzor kimenetnél lassú lesz? kizárt. ráadásul ugye itt nem is a bash fut sokáig, mert az csak összeköti a programokat, falusiasan fogalmazva bűvészkedik a fájldeszkriptorokkal, a sok olvasást, írást egy c-ben megírt, évtizedek alatt optimalizált kód fogja csinálni a sedben. nem lesz lassú, ne aggódj, nagyjából bármit el fog verni, mint az atom. az interpretált bájtkódodat szinte biztosan rommá fogja verni.

    Egyébként én csak húsz éve foglalkozom hasonló kérdésekkel, nyilván tapasztalatlan vagyok a témában, szemben pár fórumtárssal a fotelből...

    "ezért amikor elhangzott itt (nem Peachmantől), hogy a szenzor program tegye le diszkre egy fájlban az adatot és azt olvassa be jávából LINUXON, akkor azt gondoltam, hogy ezzel totálisan szívenszúrja a unixos alapfilozófiát. kevésbé udvarias megfogalmazásban ekkora f.ságot évek óta nem hallottam."

    Én írtam, s egyáltalán nem értek veled egyet. Majdnem mindegy, hogy először fájlba írsz valamit és onnan pollozod, vagy közvetlenül a pipe-pal küldöd át. Utóbbi esetben ráadásul újra, meg újra meg kell hívni a feldolgozó programot, ami nem feltétlen hatékony. Fájl változásra linux alatt selecttel fel tudsz iratkozni, Javaban is megvannak a megfelelő képződmények(Watch service). Egyébként named pipe-pal lehet a legjobban áthidalni, hogy a feldolgozó mindig futhasson attól függetlenül, hogy mikor kap inputot. De én fájlba írnám inkább, mert sokkal könnyebb lesz hibát izolálni annak előfordulásakor, ha a fájlra nézve meg tudod azonnal mondani, hogy mikor frissült, meg mi van benne, anélkül hogy a két alkalmazás belében kellene turkálni.

  • Drizzt
    nagyúr

    Milyen megoldással lehetne egy külső program konzolba írt tartalmát parse-olni?

    Van egy linux-os programom, ami bizonyos szenzorok adatait az alábbihoz hasonló módon adja vissza a konzolba kiírva:

    ... (néhány sor sima text elötte)
    group1.data1.value1: 123456
    group1.data1.value2: valamiszoveg
    group1.data1.value3: 123.01
    group1.data2.value1: valamiszoveg
    group1.data2.value2: 123456
    group2.data1.value1: 123456
    group2.data1.value2: 123456
    group2.data2.value1: 123456
    group3.data1.value1: 123456
    ...

    A lényeg, hogy minden tag új sorban van, a variable neve pontokkal van, a value lehet string, int, float.

    Szeretném bizonyos időközönként (30 másodpercenként) lefuttatni ezt a külsős exe programot és a visszakapott értékeket db-ben tárolni.
    Mivel volna érdemes nekikezdeni?
    Az exe futtatásban, a visszakapott értékek parsolásában kellene segítség.
    Db kezelés nem gond.

    A Linuxos program időzített futtatására használj cront, vagy egyszerűen írj egy bash scriptet, ami tight loopban vár. A kimenetet meg simán irányítsd bele egy fájlba. A Java programban ugyanezt a fájlt nyisd meg ugyanilyen időközönként. Aztán dolgozd fel, s írd ki adatbázisba. Amúgy ahogy az adatod jellegét nézem, kb. egy time series database-ben lenne a legjobb őket tárolni. Erre jó pl. Influxdb. Aztán csinálhatsz rá mindenféle fancy ábrát Grafanával.

    Parse-olni ezt egyébként elég egyszerű, soronként végigolvasod, majd line.split("."), a három elemű tömböt meg felhasználod ahogy akarod..

    Más: Mi a legjobb, legmélyebb Spring video course amivel találkoztatok? Kéne nekem egy masszívabb. Ha csak fizetős van, az se gond. De örülnék, ha legalább 20 óra körüli lenne és nagyon a részletekbe menő.

  • Drizzt
    nagyúr

    Egy interjúra megyek, és ott ezt használják, bár minél jobban belerágom magam a témába annál inkább nem értem miért...

    Ha jól értem a J2EE egy régebbi "framework"? ez tartalmazza a servletet, EJB-t, JMS-t, ma már viszont a Springet használják helyette pl

    Ja, a Java EE egy framework. Egy jó nagy adag specifikáció halmaz, amit különféle app szervereknek kell implementálnia, hogy Java EE compliant-ek legyenek. Régen elég kínszenvedés volt a Java EE, orrba-szájba kellett örökölgetni mindenféle framework classból. Viszont idővel megjelent az annotation based configuration, elkezdtek egyre szeparáltabbak és önmagukban is életképesek lenni a komponensek. Így ma szerintem egyébként egy nagyon jó framework a Java EE, de tény, hogy a Spring mellett nem valószínű, hogy hosszú távon túlélő lesz. Én nem örülnék neki, ha eltűnne. De ennek főleg az az oka, hogy jelenleg ebben vagyok a leginkább otthon. Springet még csak tanulom. Illetve most főleg Kubernetest, meg Helmet, mert most épp az kell a melóban, de igyekszem visszanyergelni a java-ra.

    Szóval az hátránya a Java EE-nek, hogy heavyweight runtime környezet kell hozzá, de ebben is fejlődik.

    De érdekes, pl. szerintem a CDI event handling sokkal szebb, mint a Springes.

  • Drizzt
    nagyúr

    Olyan kód nem létezik amit később ne tudnál refaktorálni szerintem :))

    Persze hogy nem. De az mas kerdes, hogy erdemes-e, illetve miert. Az esetek nagy tobbsegeben akkor is kell refaktoralni, ha amugy a kod jo. Pl. ha jon valami olyan uj feature, vagy meglevo modositasa, ami a refaktoralas eredmenyekeppen sokkal egyszerubb lesz, dinamikusabb, kivulrol konfiguralhato, vagy neha epp fixebb, merevebb. Nem veletlenul van tele a refaktoring katalogus olyan lepesekkel, aminek az inverze is benne van. Az egesz refaktoring az agilehoz hasonloan azert terjedt el es lett fontos modszer, mert az it ipar rajott, hogy feature stability szinte semmilyen realis szoftverfejlesztesi projektben nincs.

  • Drizzt
    nagyúr

    erre mondjuk, hogy bullshit....én ezt tuti nem tudnám így elmondani...valld be te is most kopiztad ki valahonnét :U
    Java fejlesztőt, vagy elméleti szakembert keresnek?

    Nem, én ezt rendkívül fontos dolognak tartom. Ha ez nincs végig az ember fejében, amikor kódol, akkor jó eséllyel gányolt minőséget fog kiadni. Az meg most, hogy konkrétan a SOLID betűit feloldja-e valaki, vagy a lényegét elmondja a mozaikszónak, igazából mindegy, de számomra mozaikszót megjegyezni és felidézni sokkal egyszerűbb, mint bármi más módszer.

    Juniortól nem ezt kérdezném, mert szinte biztos, hogy nem fogja tudni. Ott nyomatnám az egyszerűbb adatstruktúrák kérdéseit. Senior szinten viszont szerintem ez alapelvárás, akármikor.

  • Drizzt
    nagyúr

    Sziasztok,

    Java junior fejlesztő pozíció interjún azt kérdezték, hogy szerintem milyen egy jó, minőségi Java Osztály implementációja?
    Szerintetek mi a minél tömörebb, jó válasz erre? Milyen a jó felépítésű Java Osztály? Ha van köztetek nagyobb tapasztalatú, Senior fejlesztő, akkor milyen felépítésű, tartalmú választ szeretnétek hallani?

    köszönöm

    Tömör, egy felelőssége van, se többet, se kevesebbet nem csinál mint ami a célja. Magas a koherencia a az adattagok és a metódusok között, meg az összes SOLID principle felsorolása, kifejtése, 1-2 design patternen keresztüli elmagyarázása. Én ezt várnám el egy interjúzótól. Bár juniortól lehet nem ilyet kérdeznék, hanem inkább alapvetőbb algoritmus kérdéseket, adatstruktúrákat.

  • Drizzt
    nagyúr

    Ami statikus azért miért kell példányosítani?

    Hát ha nem példányosítod, akkor null lesz. Az egy jogosabb kérdés lenne, hogy mi a fene szükség van rá egyáltalán, hogy ott legyen az a static variable, mert a felhasználási módja nem indokolja a jelenlétét. De a többiek már úgyis leírták.

Új hozzászólás Aktív témák

Hirdetés