- Fórumok
- Szoftverfejlesztés
- Java programozás
- (kiemelt téma)
- Melyik tápegységet vegyem?
- A Linux megnégyszerezte magát a Steamen — a Microsoft ismét ígérget
- Milyen széket vegyek?
- Nem indul és mi a baja a gépemnek topik
- Bluetooth hangszórók
- Házimozi belépő szinten
- Fokozatosan erősít majd a szerverpiacon az Intel
- E-book olvasók
- Gaming notebook topik
- AMD vs. INTEL vs. NVIDIA
-
Fórumok
PROHARDVER! - hardver fórumok
Notebookok TV & Audió Digitális fényképezés Alaplapok, chipsetek, memóriák Processzorok, tuning Hűtés, házak, tápok, modding Videokártyák Monitorok Adattárolás Multimédia, életmód, 3D nyomtatás Tabletek, E-bookok Nyomtatók, szkennerek PC, mini PC, barebone, szerver Beviteli eszközök Egyéb hardverek PROHARDVER! BlogokMobilarena - mobil fórumok
Okostelefonok Mobiltelefonok Okosórák Autó+mobil Üzlet és Szolgáltatások Mobilalkalmazások Tartozékok, egyebek Mobilarena blogokIT café - infotech fórumok
Infotech Hálózat, szolgáltatók OS, alkalmazások SzoftverfejlesztésGAMEPOD - játék fórumok
PC játékok Konzol játékok MobiljátékokLOGOUT - lépj ki, lépj be!
LOGOUT reakciók Monologoszféra FototrendFÁRADT GŐZ - közösségi tér szinte bármiről
Tudomány, oktatás Sport, életmód, utazás, egészség Kultúra, művészet, média Gazdaság, jog Technika, hobbi, otthon Társadalom, közélet Egyéb Lokál PROHARDVER! interaktív
Új hozzászólás Aktív témák
-
loszerafin
senior tag
Sziasztok,
JDeveloper-t használok és olvastam egy helyen, hogy ha beírom :
/**
akkor egy template alapján beszúrja a javadoc commenteket, de úgy, hogy beleírja a
paraméterek neveit, meg a @throes-t meg a @return-t is.Pl. itt : [link]
Nekem csak ennyit ír be:
/**
*
*/Nem tudja valaki, hogy lehet jobb javadoc template-eket beletenni a jDeveloper Studio Edition Version 10.1.3.3-ba ?
Előre is köszönöm
KLHelp->Check for Updates->Install JIndent
-
loszerafin
senior tag
Sziasztok,
JDeveloper-t használok és olvastam egy helyen, hogy ha beírom :
/**
akkor egy template alapján beszúrja a javadoc commenteket, de úgy, hogy beleírja a
paraméterek neveit, meg a @throes-t meg a @return-t is.Pl. itt : [link]
Nekem csak ennyit ír be:
/**
*
*/Nem tudja valaki, hogy lehet jobb javadoc template-eket beletenni a jDeveloper Studio Edition Version 10.1.3.3-ba ?
Előre is köszönöm
KL -
loszerafin
senior tag
Próbálok java EE-s dolgot csinálni, az alapoknál tartok:
1. Linuxra telepítettem Tomcat 5.5-öt, működnek a példák.
2. Windows-on NetBeans 6-tal csináltam egy Hello World Enterprise Application-t. A NetBeans mindent megcsinált, én csak az index.jsp-t módosítottam egy kissé.
3. NetBeans tudja futtatni a saját GlassFish szerverével.Próbálnám ezt a HelloWorld application-t a Tomcat-ra feltenni és onnan futtani. Ez sehogy se megy:
A Tomcat Manager-rel deploy-oltam a szerverre a war fájlt. Ez látszólag megy, bár a visszajelzés csak egy "OK", nem az hogy "OK, deployed to .... path" vagy ilyesmi.
A szerveren bekerül a könyvtárstruktúrába a /var/lib/tomcat5.5/webapps/EE_HelloWorld-war.war fájl és ugyanide egy EE_HelloWorld-war könyvtár, amibe a war tartalma van kibontva. (Eddig ez a hely teljesen üres volt)A böngészőből viszont sehogy se tudom elérni. Ráadásul a Tomcat Manager-ben se látszik a listában az EE_HelloWorld-war.
Ha újra akarom deploy-olni, akkor "FAIL - War file "EE_HelloWorld-war.war" already exists on server"-t kapok.Előre is köszönöm a segítséget
KLKözben találtam pár okot, amiért egyébként se működne a dolog:
Tomcat 5.5 nem kompatibilis java ee 5-tel, szóval 1.4-gyel kellene próbálnom vagy tomcat 6-tal.Feltettem Windowsra a Tomcat5.5-öt, hátha könnyebb lesz.
A NetBEans 6-ban meg felvettem szervernek a Tomcat-et, ez látszólag meg is történt,
de mikor elkezdek egy Enterprise projectet, nem tudom szervernek kiválasztani a Tomcat5.5-öt, csak a glassfish-t. Pedig ha "Add"-dal próbálok hozzáadni, látszik, hogy a windowsos Tomcat fel van véve a szerverek közé.A Tomcat bin-jébe belemásoltam a *.bat állományokat, úgyhogy ez nem lehet a probléma, meg működik is a tomcat, kipróbáltam. Igaz, áttettem 8180-as portra, hogy ne zavarja a GlassFish-t.
-
loszerafin
senior tag
-
loszerafin
senior tag
Vagy nincs jar parancsod, vagy nincs benne a path-ban. Telepítettél j2sdk-t?
-
loszerafin
senior tag
Próbálok java EE-s dolgot csinálni, az alapoknál tartok:
1. Linuxra telepítettem Tomcat 5.5-öt, működnek a példák.
2. Windows-on NetBeans 6-tal csináltam egy Hello World Enterprise Application-t. A NetBeans mindent megcsinált, én csak az index.jsp-t módosítottam egy kissé.
3. NetBeans tudja futtatni a saját GlassFish szerverével.Próbálnám ezt a HelloWorld application-t a Tomcat-ra feltenni és onnan futtani. Ez sehogy se megy:
A Tomcat Manager-rel deploy-oltam a szerverre a war fájlt. Ez látszólag megy, bár a visszajelzés csak egy "OK", nem az hogy "OK, deployed to .... path" vagy ilyesmi.
A szerveren bekerül a könyvtárstruktúrába a /var/lib/tomcat5.5/webapps/EE_HelloWorld-war.war fájl és ugyanide egy EE_HelloWorld-war könyvtár, amibe a war tartalma van kibontva. (Eddig ez a hely teljesen üres volt)A böngészőből viszont sehogy se tudom elérni. Ráadásul a Tomcat Manager-ben se látszik a listában az EE_HelloWorld-war.
Ha újra akarom deploy-olni, akkor "FAIL - War file "EE_HelloWorld-war.war" already exists on server"-t kapok.Előre is köszönöm a segítséget
KL -
loszerafin
senior tag
Régebben írtam erről:
http://logout.hu/iras/java_hozzaferes-vezerles.html -
loszerafin
senior tag
Közben megértettem, hogy olyan kártyajátékot akarsz írni, amit még nem csináltak meg.
Próbáld meg: magyar kártyával a makaót.
5-5-öt osztanak, egyet felcsapnak (nem lehet különleges lap), azután színre színt vagy formára formát, sorozni lehet.
Különleges lapok: VII-es:következő játékos kettőt húz
Ász: következő kimarad
Felső: színt kérhetsz
IX: számot kérhetsz
Ha a következőnek van ugyanolyan különleges kártyája, azzal semlegesít. A VII-esek összeadódnak, azaz ha A,B játékos is letett VII-est, akkor C-nek 2+2 lapot kell húznia. -
loszerafin
senior tag
egyetértek veled, de gondoltam igy jobb, mint tapasztalat nélkül belevágni a keresésbe. Biztos nem 1 oolyan ember van, aki valahogy megtanulta, és ennek egy része talán ismer valami könyvet, amit tud ajánlani. Pl Javaból én is tudnék ajánlani bevezető könyvet, amiből jól meg lehet tanulni. Jah valami kártyajáték lesz amugy a dologból, mert többre nem fogja futni az időmből. Csak valami olyat kéne kitalálni, amit még nem csináltak meg.
No innen aztán lehet válogatni:
http://www.daniweb.com/forums/thread80727.html -
loszerafin
senior tag
egyetértek veled, de gondoltam igy jobb, mint tapasztalat nélkül belevágni a keresésbe. Biztos nem 1 oolyan ember van, aki valahogy megtanulta, és ennek egy része talán ismer valami könyvet, amit tud ajánlani. Pl Javaból én is tudnék ajánlani bevezető könyvet, amiből jól meg lehet tanulni. Jah valami kártyajáték lesz amugy a dologból, mert többre nem fogja futni az időmből. Csak valami olyat kéne kitalálni, amit még nem csináltak meg.
http://www.microjava.com/
Még itt van nagyon sok jó dolog.
-
loszerafin
senior tag
egyetértek veled, de gondoltam igy jobb, mint tapasztalat nélkül belevágni a keresésbe. Biztos nem 1 oolyan ember van, aki valahogy megtanulta, és ennek egy része talán ismer valami könyvet, amit tud ajánlani. Pl Javaból én is tudnék ajánlani bevezető könyvet, amiből jól meg lehet tanulni. Jah valami kártyajáték lesz amugy a dologból, mert többre nem fogja futni az időmből. Csak valami olyat kéne kitalálni, amit még nem csináltak meg.
Csak valami olyat kéne kitalálni, amit még nem csináltak meg.
Na ja, olyat én is szeretnék...
-
loszerafin
senior tag
semmi baj nincs ezzel, ha gugliba akarok keresni akkor neki jajjgatok. Nekem olyasvalakinek a tanácsa kéna, aki vágja az ME-t és tisztában va vele milyen tankönyvek vannak( ha vannak egyetalán ), és hogy melyiket érdemes kézbe venni. De azért köszi, már ez is több annál amire az órán jutottam.

mod: Ja és azt még meg kell emlitenem hogy MIDP 1.0 és CLDC 1.0-ás apival toljuk, szal ha lehet akkor valami ősirégi forrás leggyen, ahogy látom itt MIDP 2.0 van, az meg nem jó mert abba már van ey csomó újítás( pl MIDP 1.0 -ba nics lebegőpontos tipus mások a memóriakorlátok stb.. )
lehet még meg éne kérdeznem Mikkamakkát vagy Dömdödömöt
Ja és azt még meg kell emlitenem hogy MIDP 1.0 és CLDC 1.0-ás apival toljuk, szal ha lehet akkor valami ősirégi forrás legg
Hát, ez nem szerepelt az eredeti kérdésedben.
1. Ha vmi rajta van a neten, azt a google megtalálja
2/a. Ha vmi angolul könyv alakban elérhető, akkor azt az amazon-on megtalálod
2/b. Ha magyar könyvet keresel, akkor bookline, alexandra, stb.
3. Ha vmi csak egyetemi jegyzet formájában terjed, akkor az adott egyetem könyvtárában keress (ott vannak diplomamunkák is)
4. Ha programozást akarsz gyorsan tanulni, akkor
a, keress egy crash course tutorialt (max 4 oldalasat)
b, keress példaprogramokat, futtasd, alakíts rajtuk
c, tűzz ki egy egszerű célt (snake, mastermind, vmi kértyajáték, tank-attack) és kezdd el csinálniSzvsz az egyetemi oktatások nagy részét el lehet felejteni. Ritka az olyan ember, aki vmi up-to-date dolgot tanít és profin csinálja, profin ad elő és nem félti a tudását.
-
loszerafin
senior tag
Üdv!
Java ME-hez kéne nekem valamiféle tutorial, könyv vagy bármilyen forrás, amiből meg lehet tanulni. Ha angol az se baj, de jobb lenne ha egy magyar nyelvű ( esetleg tan )könyvet tudna valaki ajánlani. Van egy órám, amire vésni kéne egy mobiltelos progit, de tiszta káosz az egész, már a sokadik, és szeretnék most már valamit alkotni, mert ennek igy nem lesz jó vége.
sun:Learning About the Mobile World
Ezzel mi a baj?
Google 1. találat -
loszerafin
senior tag
Sziasztok!
Problémába ütköztem, és gondoltam megpróbálom a PH-t, ha már a google nem hozott szerencsét. A lényeg, hogy idén felvettem a bevezetés a számítógépes grafikába című tantárgyat, aminek nagyjából a lényege, hogy bizonyos alapeszközökkel (van egy panelünk, arra tudunk kirajzolni egy pontot, 1 szakaszt, 1 kört, valamint ezeket tudjuk szinezni és kitölteni) fogunk majd leprogramozni szakaszrajzoló algoritmusokat, meg vágásokat, meg 3d hatású alakzatokat, etc.
C-ben tudom hogy kellene megcsinálni (erre konkrétan van leírás, plusz egy pár soros pédakód, ami nem csinál mást, mint létrehoz egy panelt, kirajzol egy pontot, és kirajzol egy kört), viszont én Javaban szeretném. Keresgéltem google-ban, megnéztem az idevágó Java dokumentációt is, de az istenért sem akar sikerülni. Azt szeretném kérni / kérdezni tőletek, hogy tudnátok mondani olyan oldalt, ahol 1 ilyen egyszerűen pont ennyit tudó (létrehoz egy panelt, kirajzol egy pontot, és kirajzol egy kört) kis példaprogram van leírva, vagy tudnátok nekem leírni egy pont ennyit tudó fordítható programot? Amiket találtam Google-n, abban mind voltak egérkezelés, meg egyéb plusz dolgok, amikhez szintén nem értek, és biztos egyszerűek azok a programok is, de a plusz dolgok csak jobban bezavarnak.
Úgy érzem, ha egy ilyen egyszerűen futó program forrásának birtokában lennék, már könnyedén át tudnám alakítani a dolgokat, illetve tudnék rajta gyakorolni bonyolultabb dolgokat is.
Remélem érthetően írtam le, de ha nem, akkor megpróbálom összefoglalni a kérést: Tudnátok adni egy URL-t, vagy be tudnátok másolni egy leforduló/futó programnak a kódját (vagy feltenni valahova a forrást), ami annyit csinál, hogy egy panelre (lehet hogy nem ez a jó szó) kirajzol 1 db pontot és 1 darab szakasz és 1 darab kört? Csak ennyit tudjon, semmi többet, viszont ezt main metódussal együtt, stb.
Előre is köszönöm!

btotyi válasza telitalálat.
Annyit hozzáfűznék, hogy induláskor _nem_ az API doksi a megfelelő, hanem a tutorial-ok.
Aztán, ha kedved van, pl. ilyesmi:
[spaceInvaders] -
loszerafin
senior tag
A Java core-hoz ezt:
Sun Study Guide -
loszerafin
senior tag
Ez olyan vicces kérdés, "Javanak pont az az óriási előnye, hogy nem exe hanem jar."
A JAR az átfordított file, amit egy java + filenev parancsal "BÁRMILYEN*" szgépen elindithatsz. Ellenben egy exevel ami max egy géptipus pl x86 és ott is csak egy fajta op rendszer alol hajlandó elindulni.
A kérdés jó volt. Nem azt kérdezte, "hogy lehet exet csinálni", hanem hogy lehet futtatni.
Az exe-s rész, az csak a magyarázat volt,. hogy pontosan megértsük a problémáját. -
loszerafin
senior tag
htmldoc tud ilyet, de szvsz nem éri meg. Azon a tutorialon 1 hét alatt végigmész, kár 1 napot elvesztegetni nyomtatással, formázással.
(Meg nem is annyira jó, didaktikailag. Persze nem rossz indulásnak, de nem elég mély, se nem elég jól felépített. Ha angolul tudsz, ezernyi másból válogathatsz, pdf-ben) -
loszerafin
senior tag
Sziasztok!
Urak, hozzátok fordulok végső menedékként, mivel egyszerűen nem találok megoldásd. Nem vagyok egy XML profi, de most XML-es problámám lenne. ArrayList-et vagy más String tárolására képes Java típust kell utaztatnom XML-ben. Ez megoldható valamilyen xsd:complextype-al?
Tehát az a lényeg, hogy String tömböt akarok visszakapni, ha jól tudom akkor Axis MessageElement[]-ben tudom kinyerni. Viszont itt hibát kapok, mivel az ArrayList-tel nem tud mit kezdeni, viszont nekem valamilyen dinamikus tömb megoldásra van szükségem.
Van valakinek ötlete?
Sianis
Esetleg egy rövid kódrészlet segítene.
Amíg nincs, addig ilyesmi jut eszembe:
ArrayList ar = ...;
ar.toArray(new String[0]); -
loszerafin
senior tag
Sziasztok,
következő "óriási" problémám lenne:
Be akarok hozni egy Java appletet böngészőben (Firefox), de a munkahelyi hálózat HTTP proxy-t használ a webes elérésre, ami magában nem lenne gond, viszont a Java alkalmazás (itt konkrétan a chat.hu kliense) nem kapcsolódik, a Java console pedig a következő hibaüzenetet dobja ki úgy 10 másodpercenként:
java.io.IOException: Action timed out[soc:443]
at jworx.client.n.a(Unknown Source)
at jworx.client.J.a(Unknown Source)
at jworx.client.next.p.<init>(Unknown Source)
at jworx.client.next.EmbeddedApplet.run(Unknown Source)
at java.lang.Thread.run(Unknown Source)ahol a "soc" szám mindig más. Próbáltam belőni a proxy-t az XP Control Panel / Java / Network-nél, de eredmény ugyanez. Ugyanakkor a böngészőben a proxy elsőként mindig kér user nevet és jelszót, amit be szoktam neki adni, viszont a Java már nem kéri csatlakozáskor. Lehet, hogy ez a gond....vagy mi lehet még ?
Előre is kösz a segítséget !
[OFF]
Kipróbáltam a chat.hu-t és a java applet a 251-shosts.hostoffice.hu gép 23-as portjára kapcsolódik. Mivel a helyi hálótokon szigorú szabályok kötik a netezést (jelszavas proxy),
gondolom, a 23-as portra nem mehettek ki.Esetleg kérdezd meg a helyi rgazdát. Vagy olvasd el a helyi számítógép használati szabályzatot, abban benne kell lennie minden tiltásnak.
[/OFF] -
loszerafin
senior tag
végülis a jpx inportálását megoldottam a sokumentáció segítségével. További kérdés a source/designe nézet. Ahogy néztem, netbeansben is akkor jelentek meg a gombok, ha olyan forrást húztam be, ami grafikus. Viszont újabb kérdés, hogy ha csak simen open file-al nyitok meg *.java fájlt, és nem project-be húzom, akkor hogyan lehet fordítani és futtatni? Erre nem sikerült sehogyse rájönnöm. Sorry az amatőr kérdésekért, de perpill ilyenen akadok ki

Netbeansben a Run menü Run file (Shift + F6)-tal nekem megy (NetBEans 6.0 beta 2)
-
loszerafin
senior tag
ciklus n-szer {
szoveg = szoveg_utolso_karaktere + szoveg_karakterei_elsotol_az_utolso_elottiig
kiir (szoveg)
} -
loszerafin
senior tag
Nem vagyok jártas ezen a téren, de elképzelhetőnek tartom, hogy a nem pc alapú szerverek piacán más JVM-ek is döntő szerephez jutnak.
Abban biztos vagyok, hogy pc-ken a Win XP és (M$ JVM vagy SUN JVM) felállás a tipikus.Ha pedig tesztelni akarsz, akkor a legtipikusabb felállásokat kell megnézned, esetleg érdekességképpen egy-egy különlegességet megmutatni.
(Pl. ilyenre gondolok: a userek 99%-a Win XP-t használ M$ JVM-mel, a tesztprogramod 10 egység alatt fut le. De ha Brutál OS-t használnának akkor Grgth cég JVM-jével 2 egység alá is mehetnek...)Gondolom, ide már eljutottál:
[link] -
loszerafin
senior tag
Értem amit írsz.
Nem tudok róla, hogy lenne külön Inteles és AMD-s Java, legalábbis a Sun oldalán nem találtam, csak egy fajtát.
Namost én nem JVM-eket akarok tesztelni, hanem procikat.
De ezekszerint ennek csak akkor van értelme, ha többféle JVM-et használok? Maradjunk csak egynél. Így is millió tesztet kell még megnézni procinként.
Melyik a legelterjedtebb? Gondolom a Sun-é?...Gondolom, az M$ és a SUN a legelterjedtebb.
Ha csak procit akarsz tesztelni és csak "asztali" gépekbe valót, szerintem mindegy, melyik JVM-et használod, csak az összes tesztedben legyen ugyanaz az oprendszer, ugyanaz a jvm és vagy csak appleteket nézz, vagy csak futtatható alkalmazásokat.
Ha appletekkel tesztelsz, maradj egyetlen böngésző egyetlen változatánál. -
loszerafin
senior tag
Üdv.
Mit gondoltok, ez a teszt [link] nyújt számotokra vmilyen infót arra vonatkozólag, hogy egy adott proci jó-e Javaban? Illetve itt egy másik [link], melyik jobb? Van értelme ilyenekkel procit tesztelni? A végeredmény mond nektek vmit?
Azt látom, hogy ezek sajna nem használják ki a többprocis működést, ha ilyenről tudtok, akkor légyszi szóljatok.
Előre is köszi."Adott proci jó-e java-ban", szerintem ez a kérdés maga megér egy kis boncolgatást.
Minden nagyon szvsz, amit írni fogok:
Egy java programmal nem a processzort próbálod ki, hanem elsősorban a JVM-et, hiszen a JVM-en/ben/on fut a program.
Ha ez igaz, akkor a kérdés így hangzana: "Mennyire jól fut egy adott JVM egy adott processzoron?"
Na most ha ezt továbbgondolom, akkor egy JVM akkor passzolna egy processzorhoz a legjobban, ha arra az adott processzorra lenne lefordítva, így a JVM ki tudná használni az adott processzor specialitásait.
Ha ez egyáltalán lehetséges, akkor a következménye az lenne, hogy JVM-et nem "x86"-os processzorhoz töltenénk le, hanem pl. AMD Athlon XY-hoz vagy Intel Core 2 duo XY-hoz vagy VIA akarmi ZW-hez.
Viszont erre utaló jeleket nem találok. Persze lehet, hogy a java parancs megvizsgálja a gépet, és a processzorhoz legjobban passzoló JVM-et indítja el...
Ellenben léteznek különböző JVM-ek (MIcrosoft, SUN, de még van pár másik is) amiken lefogadom, hogy egy adott java program különböző sebességgel fut le. Tehát azt mérhetnénk, hogy egy adott java program melyik JVM-en fut le a leggyorsabban.
Felhívnám a figyelmed, hogy mindaz amit írtam, merő spekuláció...
-
loszerafin
senior tag
Csak a teljesség kedvéért:
az intValue() nem megy primitív típussal, azaz :int i;
Double d = 6.0; //double d=6.0; nem jó
i=d.intValue(); -
loszerafin
senior tag
Innen:
Ez segíthet
(egy div-et pozicionálhatsz)function getRefToDiv(divID,oDoc) {
if( !oDoc ) { oDoc = document; }
if( document.layers ) {
if( oDoc.layers[divID] ) { return oDoc.layers[divID]; } else {
//repeatedly run through all child layers
for( var x = 0, y; !y && x < oDoc.layers.length; x++ ) {
//on success, return that layer, else return nothing
y = getRefToDiv(divID,oDoc.layers[x].document); }
return y; } }
if( document.getElementById ) {
return document.getElementById(divID); }
if( document.all ) {
return document.all[divID]; }
return false;
}
function moveDivTo(x,y) {
myReference = getRefToDiv( 'mydiv' );
if( !myReference ) { return; }
if( myReference.style ) { myReference = myReference.style; }
var noPx = document.childNodes ? 'px' : 0;
myReference.left = x + noPx;
myReference.top = y + noPx;
}Ha a célod animáció, akkor :
-
loszerafin
senior tag
örömmel jelentem, hogy négy napnyi kemény munak után elkészültem a megközelítőleg végleges kóddal

Már korábban akartam írni, hogy érdemes ilyen "kis" programoknál megtanulni a kód-dokumentálást, unit tesztelést és a többnyelvűséget
http://java.sun.com/docs/books/tutorial/i18n/index.html
http://java.sun.com/j2se/javadoc/writingdoccomments/
http://www.devx.com/Java/Article/31983/0/page/1 -
loszerafin
senior tag
nem titkos, kedden délután már elárulhatom, akkor már túl leszek a bemutatásán és a leadásán
Konzultáltam ma a szakirány tanárommal és azt javasolta, hogy bonstam ketté a render() metódust, mégpedig rajzolós és billentyűzetelemzős részre. Módosítsam ezek alapján a Midletben a szál run() metódusát úgy, hogy először billvizsgálatot csinál, aztán vár valamennyit, aztán egy for ciklusba tegyem bele a rajzolós metódust és ehhez mérten igazítsam mennyi ideig sleepeljen a thread. Tehát pl. 1 mp-es képváltásnál thread.sleep(50) és ciklusváltozó 0-19. Most ezt fogom megpróbálni megcsinálni, remélem sikerrel járok és utána már "csak" az RMS (RecodStore) rész van hátra az eredmények mentéséhez és kiírásához (HighScore).Remek.
Kissé átpofoztam a kódodat, de nem tudom kipróbálni:
int[] dx={25,85,145,25,85,145,25,85,145};
int[] dy={50,50,50,110,110,110,170,170,170};
int[] keyCodes={512,2,1024,4,256,32,2048,64,4096};
int keyIndex=(int)(Math.random()*9);
sprite.next(dx[keyIndex],dy[keyIndex],keyIndex);
lm.paint(g,0,0);
flushGraphics();
int keyState=getKeyStates();
if ( (keyState & keyCodes[keyIndex]) !=0 ){
score++;
}
else{
if(keyState!=0){
score--;
}
}A keyCodes tömb számai helyett jobb lenne enum-okat használni, úgy érthetőbb lenne a program.
Az else ágban a keyState!=0-nak utána kellene nézni, tényleg azt jelenti-e, hogy nyomtak gombot.És azt hiszem, itt mindent megtalálsz a témádhoz:
és ez se rossz:
[link]Ráadásul ez az utolsó "megvan" magyarul is:
[link] -
loszerafin
senior tag
megcsináltam az alábbi módon
(remélem jól értelmeztem a mondani valódat
)int[] tomb1={25,85,145,25,85,145,25,85,145};
int[] tomb2={50,50,50,110,110,110,170,170,170};
int[] gombtomb={512,2,1024,4,256,32,2048,64,4096};
Random rnd=new Random();
int veletlen=rnd.nextInt(8);
dx=tomb1[veletlen];
dy=tomb2[veletlen];
sprite.next(dx,dy,veletlen);
lm.paint(g,0,0);
flushGraphics();
int keyStates=getKeyStates();
if (keyStates==gombtomb[veletlen]){
pontszam++;
}
else{
if(keyStates!=0){
pontszam=(pontszam)-1;
}
}Apró szépséghiba, hogy az időzítések össze-visszasága miatt a jó billentyűleütéseket is néha rossznak veszi és fordítva, illetve valamiért a 2,4,5,6,8 gombok értéke nulla
Pedig tudomásom szerint azok felveszik a LEFT_PRESSED, RIGHT_PRESSED, UP_PRESSED, DOWN_PRESSED és FIRE_PRESSED értékeit is. A gombtomb[]-ben a gombok sorrendjében tároltam le a koordinátákat, tehát az index maga a gomb száma. Lehet az a gond, hogy a paint és/vagy flushgraphics után tettem a feltételeket?Jól értetted, így gondoltam, látom, gyorsan "fogod" az adást
Lenne pár megjegyzésem a programozási stílussal kapcsolatban:
1. Próbálj meg angol azonosítókat használni, jobban illenek a programozáshoz
2. Próbálj meg olyan azonosítókat választani, amik a funkcióra utalnak és nem a
tartalomra, vagy típusra (pl: veletlen, tomb nem szerencsés)
3. Próbáld meg betartani a Sun névkonvencióit (változónevek első betűje kicsi, ha több szóból áll, akkor a többi kezdőbetű nagy
4. Szeparáld a kódodat. rajzolás és user input mehetne külön metódusba, akár külön osztályban is lehetnének (cohesion)Találtam egy fórumot, talán segít, rákeresve a getkeystates szóra van pár programpélda
[L]http://developer.sonyericsson.com/search.jspa?objID=c2&q=getkeystates[/L]Ha az a gyanúd, hogy az időzítések miatt megy össze vissza a programod, olvasd el ezt:
[L]http://java.sun.com/docs/books/tutorial/essential/concurrency/sync.html[/L]
(Legyenek a metódusaid syncronized-ek)De lehet megoldás az is, hogy nevezzük egy "körnek" a lámpa kigyúlásától a gomb lenyomásáig vagy az idő lejártáig tartó játékrészt.
Ekkor a kör végén hagyd a szálakat összefutni (mindegyik fejeződjön be), majd indítsd újra a szálakat, így nem lesz olyan, hogy pl. az előző lámpához tartozó gombnyomást fogja a programod jónak érzékelni. Meg egyébként is "tisztább, szárazabb érzés" lesz, hogy a szálaid ugyanazt a "kört" kezelik.Hajrá, kíváncsi vagyok a programodra, ha nem titkos, küldhetnél egy forrást az emailemre.
-
loszerafin
senior tag
konkrétan azt szeretném elérni, hogy van egy veletlen nevű változóm, ami egy 0-8-ig terjedű szám (ezzel kreálom azt, hogy a 9 szám közül melyik váltson zöldről pirosra (értelemszerűen ezt kell majd lenyomni a billentyűzeten ahhoz, hogy kapjon a játékos egy pontot)), ez alapján csinálnék egy elágazást (jelenleg 9 darab if, de majd bevágom case-be őket
), hogy ha veletlen=0 & GAME_A_PRESSED!=0, akkor pontszam++, else pontszam=(pontszam-1). Na ilyenből csináltam 9 fajta IF-et, csak az a bajom, hogy állandóan növeli a pontszám értékét teljesen függetlenül attól, hogy hozzányúltam-e a billentyűzethez vagy sem.
Ráadásul én a 2,4,5,6,8 gombokkal úgy számoltam, hogy azok működnek UP,LEFT,FIRE,RIGHT,DOWN gombokként, de a keyStates-ük mindnek 0
Így hiába teszem bele az elágazásokba őket, nem fogja érzékelni a program, ha megnyomtam
Remélem úgy nagyjából világos mit szeretnék elérni
Nagyjából érthető, nekem csak a 9 db IF szúrt szemet.
Rakd be tömbbe a lenyomható gombokat, vizsgáld meg, a tömbben van-e a lenyomott gomb
és egyezik-e azzal ami kell neked, ha igen adj pontot, ha nem, vonj le egyet.kb így :
if nyomtak_le_gombot then
pontszam+=(lenyomhato_gombok[veletlen] == lenyomott_gomb) ? 1 : -1;
else lejart_az_ido then /* nem nyomott meg semmit és már vált a lámpa */
pontszam-=1; -
loszerafin
senior tag
Szívesen, bár ez pont nem a gyakorlat miatt van. Sokat olvasgattam régebben az algoritmusokról. Jó alap. Na, meg 10 évet tanítottam... -
loszerafin
senior tag
Halee. Én vagyok Vercetti a gdf.pganet fórumról. Megyek én is izzadni 10. -én bár én már túl vagyok Pascalo -n, ASM -en, Delphi -n, C -n. A megoldás adja magát, csak ezt rá kell ültetni specifikusan a Java nyelvre.
Ha ezt a feladatot kapom, bizony a Vector -ral fogom megoldani. Nekem érthetőbbnek tűnnek a tömbműveletek. Pl.: .add, .remove, .contains, .equals, stb. Adja magát a dolog.Integer[] nums;
nums = new Integer[95];
for (int i=0; i<95; i++) nums[i]=i+1;
List<Integer> numsList = Arrays.asList(nums);
Collections.shuffle(numsList);
System.out.println(numsList.subList(0,5));Érdekes, hogy az ilyen megoldásokat részesítitek előnyben, pedig amit
[link] itt írtam, elegánsabb,
gyorsabb, rövidebb, kisebb helyigényű. -
loszerafin
senior tag
Itt a Java kód:
Csak azért írom egy sorba, hogy ha vki gondolkodni akar, ne lássa rögtön a megoldást
/* */ int i=95; int x=5; while (i>0 && x>0) { if (Math.random()*i<=x) { System.out.println(i); x--; } i--; }Egyébként az a "mellékhatása" az algoritmusnak, hogy a kihúzott számokat nagyság szerint
rendezve írja ki. -
loszerafin
senior tag
Annyit hozzáteszek, hogy ez egy klasszikus probléma, és van is "klasszikus" megoldása:
Képzeld el, hogy vki mondja neked a számokat sorba.
Te néha megállítod az illetőt és felírod egy papírra a számot.Hogy mikor állítod meg, az itt a kérdés.
Az egyszerűség kedvéért tételezzük fel, hogy nagyság szerint csökkenő sorrendben
mondja a számokat.Képzeld el, hogy most éppen az "i" számot mondja (azaz még i db szám közül választhatsz), neked meg még x db számot kell
kiválasztanod.
Mikor állítod meg az illetőt? Másképp fogalmazva: Mekkora valószínűséggel állítod meg?(az eredmény program tárhelyigénye: 2 egység, egyetlen ciklus van benne, ami max. 95-ször fut le)
Üdv
KLItt a Java kód:
Csak azért írom egy sorba, hogy ha vki gondolkodni akar, ne lássa rögtön a megoldást
/* */ int i=95; int x=5; while (i>0 && x>0) { if (Math.random()*i<=x) { System.out.println(i); x--; } i--; } -
loszerafin
senior tag
Annyit hozzáteszek, hogy ez egy klasszikus probléma, és van is "klasszikus" megoldása:
Képzeld el, hogy vki mondja neked a számokat sorba.
Te néha megállítod az illetőt és felírod egy papírra a számot.Hogy mikor állítod meg, az itt a kérdés.
Az egyszerűség kedvéért tételezzük fel, hogy nagyság szerint csökkenő sorrendben
mondja a számokat.Képzeld el, hogy most éppen az "i" számot mondja (azaz még i db szám közül választhatsz), neked meg még x db számot kell
kiválasztanod.
Mikor állítod meg az illetőt? Másképp fogalmazva: Mekkora valószínűséggel állítod meg?(az eredmény program tárhelyigénye: 2 egység, egyetlen ciklus van benne, ami max. 95-ször fut le)
Üdv
KL -
loszerafin
senior tag
class Odd {
static boolean end = false;
static class Szamol1 implements Runnable {
static long num=0;
public synchronized void run() {
while(!end){
num+=2;
}
}
}
static class Szamol2 implements Runnable {
static long num=1;
public synchronized void run() {
while(!end){
num+=2;
}
}
}
public static void main(String[] args)
throws InterruptedException{
Thread t1 = new Thread(new Szamol1());
Thread t2 = new Thread(new Szamol2());
t1.start();
t2.start();
Thread.sleep(50000);
end = true;
t1.join();
t2.join();
System.out.println(''Vége'');
}
}
Nekem ez linuxon mindkét processzoron fut, összesen 194%-al.
Egyik szál a páros számokon lépked végig, másik szál a páratlanokon.
A harmadik szál meg várakozik.
A ''változó regiszterben tartásáról'': szerintem ez annyira Java-idegen gondolat, hogy meglepődnék, ha lenne ilyen.
Ha ilyen kis nüanszokon múlik a sebesség, akkor inkább a változó típusok meggondolt használatával de főleg az adatszerkezetek és algoritmusok átgondolásával lehetne gyorsítani. Vagy gyorsabb processzorral. -
loszerafin
senior tag
Ha szerencséd van:
java -jar jar-file
Ha nincs, akkor
kell egy html oldal, amiben ez van:
<applet code=main-class-neve.class
archive=''jar-file-konyvtára/jar-file-neve.jar''
width=120 height=120>
</applet>
Futáskor esetleg kiír vmi hibaüzenetet, akkor kiderül, nálad van-e az adatbázis. -
loszerafin
senior tag
A Serialization-nal baj van akkor is, ha változtatod a class-t, aminek objektumát kiírod, ugyanis van saját verziókezelése.
Azaz kiírod az objektumot, változtatod a class-t és már nem fogja beolvasni.
(Valójában be lehet, de trükközni kell)
Ha tömböt akarsz kiírni, akkor olyan osztály-t hozz létre, aminek a tömb az egyik field-je.
Ha több állapotot akarsz kiírni akkor használj különböző fájlneveket, pl. kiírás időpontja legyen a fájl neve. -
loszerafin
senior tag
Sziasztok!
Valakinek nincs véletlen megírva Java-ban egy egyszerű stratégiai játék?Ilyesmi a feladat : Tetszőleges méretű tábla, és vannak rajta nyilasok (leghátul) dárdások és lovasok tetszőleges számban.Ezek szépen mehetnek minden irányba amerre irányítjuk, és támadhatják egymást.
Ha valakinek netán van hasonló, akkor legyen szives segítsen
Köszi
Üdv.Keress rá a sourceforge.net en meg a freshmeat.net-en.
Ha pont ilyen nincs, akkor is találhatsz egy csomó játék-író környezetet, van, amelyik kifejezetten táblás játékok írásához készült.
[Szerkesztve] -
loszerafin
senior tag
ezeket nagy if (vagy case) elagazasokat kicsit gondosabb tervezessel ki lehet kuszobolni.
Bizony így van. Szerintem 6-8 case -nél többet inkább adatszerkezettel (tömb, hash) érdemes megcsinálni. Karbantartani is könnyebb, meg a kód is rövidebb.
Egyébként visszatérve a Java-hoz, szerintem ez a fajta case ügyetlen.
A falra tudnék mászni a fall-through tulajdonságától meg mert nem lehet ilyeneket írni:
case 1..10
vagy
case 1,2,3
vagy case (i>10)
stb.
Persze, valószínűleg épp ezért (1,2,3 és 1..10 hiánya miatt) kell a fall-through tulajdonság, mert így ilyeneket lehet írni:
case 1:
case 2:
case 3: System.out.println(''1..3''); break;
De ez azért eléggé ronda egy kódban. Szerintem.
KL -
loszerafin
senior tag
Csak nyavajgás következik...
Ahogy egyre jobban elmerülök a Java-ban, egyre nehezebbnek tartom.
Ez az auto boxing/widening témakör kemény dió.
A témakörök:
1. értékadások
2. overload-olt metódusok hívása (mikor, melyik hívódik)
3. == vizsgálat
4. switch - case
5. és még ki tudja, hány témakör van
Pl. a switch-nél most olvastam:
class Proba {
final static int i = 2;
final static Integer I = 3;
public static void main(String[] args){
int x = 2;
switch (x){
case i : System.out.println(x);
case I : System.out.println(x);
}
}
}
Hogy semmilyen wrapper osztály nem lehet a case-ben, akkor se, ha final. Pedig ugye a wrapperek immutable-ek, úgyhogy nem tudnám megváltoztatni az értékét a referencia változtatása nélkül. -
loszerafin
senior tag
hat mondjuk erre kezenfekvo valasz az, hogy egyreszt nem egyertelmu mikor egyezik meg ket StringBuilder objektum (marmint tobbfele megkozelites is elkepzelheto), illetve, hogy nagyon ritkan hasonlitasz ossze ket stringbuilder objektumot, ami sokkal inkabb elkepzelheto az az, hogy egy Stringhez hasonlitod.
De barmikor kiterjesztheted a StringBuildert, es akkor ugy mukodik az equals, ahogyan csak szeretned
Köszönöm a választ.
...ami sokkal inkabb elkepzelheto az az, hogy egy Stringhez hasonlitod
Igen, ez megy:
StringBuilder s1 = new StringBuilder(''Hello'');
String s = new String(''Hello'');
System.out.println(s.equals(s1.toString()));
Bár itt is Stringgé kell alakítani, kissé ügyetlennek tartom ezt.
Vagy akkor ez lehet a gyakori:
System.out.println(''Hello''.equals(s1.toString())); -
loszerafin
senior tag
Most, hogy másodszor/harmadszor olvasom el a Java könyvemet, ''újabb'' érdekességekre bukkanok...
StringBuilder equals metódus
Úgy látom, nincs felülírva a StringBuilder osztályban az equals.
Akkor így szoktak két StringBuilder-t összehasonlítan?:
StringBuilder s1 = new StringBuilder(''Hello'');
StringBuilder s2 = new StringBuilder(''Hello'');
System.out.println(s1.toString().equals(s2.toString()));
És tudja valaki, miért nincs az equals felülírva a StringBuilder osztályban?
Előre is köszönöm
KL -
loszerafin
senior tag
A for ciklus általános szintaxisa:
for (kifejezés1; kifejezés2; kifejezés3) {
...
}
Tehát három tetszőleges kifejezést kell megadni (lehet üres kifejezés is).
Viszont a Java-ban nem tudsz egy kifejezéssel különböző típusú referenciákat
létrehozni, tehát az alábbi deklaráció nem csak a for ciklusban, hanem mindenhol hibás:
int i = 0, byte j = 0;
Pontosvesszővel elválasztva már jó de így már két kifejezésnek számít:
int i = 0; byte j=0;
Azonos típusú változóból viszont többet is létrehozhatsz egy deklarációval:
int i = 0, j=0;
Ezt tehát nyugodtan beírhatod a kifejezés1 helyére.Viszont a Java-ban nem tudsz egy kifejezéssel különböző típusú referenciákat
létrehozni,
Köszönöm, érthető volt a magyarázatod.
[Szerkesztve] -
loszerafin
senior tag
for ciklus
Nem fér a fejembe a for ciklus indító részének első tagja, a deklarációs rész:
for(int i=0; i<10; i++){
}
Félkövérrel szedtem a kérdéses részt. Itt ugye lehet több lokális változót deklarálni és inicializálni, ami csak a cikluson belül lesz elérhető, így:
for(int i=0, j=0, k=0; i<10; i++){ ...
Nem csak int lehet ott, hanem bármi, amin végig lehet lépkedni:
for(byte i=0, j=0, k=0; i<10; i++){ ...
Ami nekem furcsa, hogy keverni nem lehet a típusokat, azaz ez már nem megy:
for(int i=0, byte j=0, short k=0; i<10; i++){...
De még csak ez se fordul le:
for(int i=0, int j=0, int k=0; i<10; i++){...
Nem értem, miért ez a megszorítás? Miért jó,hogy csak ugyanolyan típusú változókat deklarálhatok és inicializálhatok? (Ráadásul a doksikban se igen találtam erre utalást:
http://java.sun.com/docs/books/jls/third_edition/html/statements.html#14.14.1)
Előre is köszönöm
KL -
loszerafin
senior tag
loni meg nekem se sikerult...
a lenyeget szerintem lattad egyebkent, marmint ami a grafikat illeti..., igazabol nem akartam nagyon belemenni, csak nekem azt tunt fol, hogy ha VisualBasic-ben irnek egy hasonlot (ahogy irtam is) es sokkal kevesebb eroforrast hasznal, a programozoja azt mondta, hogy a ''grafika'' itt az eroforrashasznalat, processzorido 90%-a..., a szimulacio, azert nem annyira komplex... a kerdesem igazabol arra iranyult, hogy a java ennyire lassu-e a megjelenitesben...? most kezdte el fejleszteni a fejleszto a 3D-s verziot, (az en modellem alapjan) es azt igeri, hogy a GPU rendereles miatt jobban fog futni..., ez egyebkent hiheto is... koszi, hogy foglalkoztal vele..., ahogy nezem mondjuk nem lettel fuggo...
Találtam ilyeneket:
java -Xrunhprof:cpu=times <program>
és
java -Xprof <program>
Részletes táblázatokat ad a futási időről.
Még nem világosak az adatok számomra, de ígéretes. Esetleg próbáld ki. -
loszerafin
senior tag
Khm. Bocs, hülyeséget írtam. De legalább most, hogy rákérdeztél, magam is rájöttem.
Tehát javítom magam:
Nem tűnik el se a forrásfájlból (hiszen ez az értelme),
se a lefordított kódból (sajnos), hiszen a java futtatót kell paraméterezni az assertion-ök ki/bekapcsolásához.
Viszont nagyon kényelmesen kezelhető (parancssorból ki/bekapcsolható), osztályokra és csomagkönyvtárakra külön-külön, és nem lassítja a kódot, ha nincs bekapcsolva. -
loszerafin
senior tag
Köszi a logger osztály infót.
Megnéztem egy kissé, de nekem elsősorban debug-oláshoz kell, azaz jó lenne, ha eltűnne a kódbol mikor készen vagyok. Ezért jó az assert-es megoldás. -
loszerafin
senior tag
1órát késtél a válasszal!

Hogy mi nem megy?
Az idáig működő részeket se látom át (igazán)...
Innentől kezdve meg az egész gáz...
pl az adatmódosítást hogyan érzékeli a program(, vagy gombenyomásra update-eljen)?
az update megírása se igazán megy...
Nincsenek nagy problémáim, csak nem értem az egészet!
mod: de mostmár mindegy!
[Szerkesztve]
Sajnálom, hogy késtem 1 órát, de úgy érzem, ha 1 héttel ezelőtt írok, az is késésben lenne.
Amit javaslok:
Egy gyors Java alapok:
http://java.sun.com/docs/books/tutorial/
(Erre 1 hét elég lehet, ha nagyon nekifekszel, 3 nap /napi 4 óra alvással/)
Learning the Java language, Essential java classes, Collections, Deployment
Ezután JDBC:
http://java.sun.com/docs/books/tutorial/jdbc/index.html
Majd ez (bár ez egy monstrum, úgyhogy szelektálnod kell, viszont én nem ismerem a Javat eléggé, hogy ebben segítsek)
http://java.sun.com/j2ee/1.4/docs/tutorial/doc/
És nem árt némi AJAX ismeret (szerintem):
http://www.w3schools.com/ajax/default.asp
Ehhez persze JavaScript, css és html tudás is kell, amit szintén megszerezhetsz a w3schools oldalain. -
loszerafin
senior tag
HI!
Ma írok java server oldali programozásból - még csak a nagyon alapokból, de mivel én soha nem tanultam java-t, ez így egy kicsit nehéz lesz(, ha nem inkább lehetetlen), nem tudom minek vettem fel ez az órát
- egy kis segítséget kérnék.
Van egy ablak, benne egy táblázat, és a cellákba egy adatbázisból tölti be az adatokat.
Ez idáig elvileg működik.
A feladat az lenne, hogy ha módosítok egy cella tartalmát, akkor az adatbázisban is módosuljon az adott cellához tartozó érték.
Ebben tudnátok segíteni?
( ha kell tudok küldeni programot, annak akit érdekel )
Előre is köszönöm!
Forest
És mi nem megy?
1. Server oldalon nem tudod módosítani az adatbázist? (SQL gondok/Java sql használat gondok/
2. Serverprogramod nem tudja elkapni az adatokat?
3. html Weboldaladból nem tudod elküldeni az adatokat? (form/ajax probléma)
4. Java appletből nem tudod elküldeni az adatokat a szerver felé?
Talán ezek segítenek:
1. [link]
3. [link]
3. [link]
[Szerkesztve] -
loszerafin
senior tag
Próbálkozz a ''Mozilla Firefox'' vagy a ''Windows XP kérdések és válaszok'' topikban.
-
loszerafin
senior tag
nem en szeretnek javitani, hanem, erdekel a velemenyetek, hogy normalis-e, hogy egy ilyen program ennyit terhel..., a keszito szerint 90%-ot a ''grafika'' teszi ki...
[link] az oldal kozepe fele van egy tablazat: Tacticat Sailing Fields ott vannak a gombok, hogy S1, L1, t4... , arra kell kattintani, hogy elinduljon...Hát, én nem tudok vitorlázni és ezt a programot valószínűleg elindítani sem. De ha el is indítanám se tudnám, mit hogy állítsak be rajta.
Bejött egy kép, bal felső sarokban feltehetően egy szélzsák meg kriksz-krakszok a képernyőn, de sehol egy ellenfél, akit le lehetne lőni
...
Ha most ehhez hozzáveszem, hogy mondjuk az emberek tudása a vitorlázásról (nagy átlagban) kb az enyémnek megfelelő szinten van és hogy az intelligenciám nem átlag alatti, akkor ez a fórum ennek a kérdésnek a megválaszolására nem alkalmas.
Miért nem írsz a játék fórumába?
A ''90%-ot a grafika teszi ki'' : ez sok minden lehet. A programkód 90%-a? a belefeccölt munka 90%-a? A futásidő 90%-a?
Ez egy szimulátor, és ha a hajókat tényleg a szél lökdösi, meg a vitorlákat lehet állítani (és még ki tudja mit) és többen is vagytok egyszerre (hálózatos a játék), korántsem gondolnám triviális feladatnak és még csak megbecsülni se tudom, milyen nehéz kiszámolni az egyes hajók adatait (pl. hely, irány, sebesség) és az algoritmus meddig fut.
Azt gondolom, próbáld ki egy gyengébb gépen, ha lassú, kérdezz a fejlesztőtől. -
loszerafin
senior tag
Én eléggé új vagyok a Javában, de a show az deprecated. setVisible(true) a menő 1.5 óta.
A setMinimumSize() beleszólhat a dologba.
Nálam awt-tal megy:
import java.awt.*;
import java.awt.event.*;
import javax.imageio.*;
import java.io.*;
import java.awt.image.*;
import java.util.*;
[...]
class MyFrame extends Frame implements Runnable{
[...]
MyFrame(){
[...]
setSize(100,100);
[...]
setVisible(true);
[...]
}
[...]
}
[Szerkesztve] -
loszerafin
senior tag
debug üzenetek
Gondoltam jó lenne pár debug üzenet, és erre kézenfekvő az assert-et használni, úgyhogy csináltam egy Log osztályt:
class Log {
static int Level = 6;
public static boolean log(int level, String s){
if (level>=Level) System.out.println(s);
return(true);
}
public static boolean dlog(int level, String s){
if (level>=Level) {
new Throwable().printStackTrace();
log(level,s);
};
return(true);
}
}
Ezt a programban így lehet használni:
assert Log.log(5,''itt vagyok'');
assert Log.dlog(7,''itt vagyok'');
A log csak az üzenetet írja ki, a dlog a stack-et is.
Van erre valami bejáratott út, vagy megfelelő ez?
Előre is köszönöm
KL -
loszerafin
senior tag
-
loszerafin
senior tag
Köszönöm, kedves tőled.
Rákeresek a rövidítésekre, azután nézek vmi doksit.
Kb fél éven belül akarok elhelyezkedni. Nagyon ráuntam a php-re.
Még megtámogatom magam egy scjp-vel. Addig is jó lenne
pár kisebb munka, nem baj, ha nem nagyon fizet. -
loszerafin
senior tag
Köszönöm
KL -
loszerafin
senior tag
Sziasztok,
Kb. már tisztában vagyok a Java alapokkal, szerintetek hogyan tovább, mit tanuljak?
UML-t látom hasznosnak meg a Design Pattern-eket. Vagy esetleg mást?
Gondolkodtam a konkurrens programozás elméletén, ami jól jöhet a szálak írásakor, de ez talán csak később kellhet.
Azután itt van a unit tesztelés, javadoc, i18n.
Persze, gyakorlatot kellene szereznem, de nem akarok rossz (=gyenge minőségű) programokat írni, gyakorlás képpen sem.
Előre is köszönöm
KL -
loszerafin
senior tag
Ha jól értem a JVM-ek működését az olvasmányaim alapján, akkor nincs garantálva, hogy időosztásosan működjenek a JVM-ek. Azaz, ha azt akarom, hogy a többi szál is labdába rúghasson, kell sleep()-et tennem a hosszan futó ciklusaimba.
Igazából a yield() metódust találták ki megoldásként erre problémára, de sajnos
kínszenvedés a használata mert nagyon nem egyértelmű mikor kell meghívni.
(Valami olyasmit lehet elképzelni, hogy pörgetsz egy számlálót a ciklusodban és
minden 10-edik futáskor meghívod a yield()-et vagy valami hasonló)
Szerencsére azonban ez a probléma a ''való életben'' elég ritkán fordul elő,
hisz az ember általában olyan szálakat ír amelyek egyébként is blokkolnak.
Pl. mert egy socket-ről akarsz olvasni vagy vársz egy beérkező üzenetre... stb.
Igazából a yield() metódust találták ki megoldásként erre problémára, de sajnos
kínszenvedés a használata
Köszönöm, igaz, megnéztem még 1x. Azt írja a könyv, hogy a yield() átteszi a jelenleg futó szál állapotát runnable-be, ezáltal a scheduler választhat egy új szálat, amit futtatni fog.
Azonban nincs előírva, hogy a scheduler másik szálat válasszon, ezért lehet, hogy ugyanazt fogja futtatni, azaz előfordulhat, hogy a yield() tulajdonképpen nem csinált semmit.
Kicsit meg lehet spékelni az egészet a szálak prioritásával, de mivel a prioritást meg nem kötelező megvalósítania a JVM-eknek, kár a gőzért... -
loszerafin
senior tag
Ha jól értem a JVM-ek működését az olvasmányaim alapján, akkor nincs garantálva, hogy időosztásosan működjenek a JVM-ek. Azaz, ha azt akarom, hogy a többi szál is labdába rúghasson, kell sleep()-et tennem a hosszan futó ciklusaimba. Vagy tévedek?
Tehát nem a lock az érdekes itt, hanem hogy egy szál nem engedi futni a többit, mert nincs benne sleep és sose áll le. -
loszerafin
senior tag
Köszönöm, valóban jó megoldás egy lock objektum létrehozása:
class Counter3 {
static int cnt = 0;
static boolean end = false;
static Object lock = new Object();
static class ModCounter implements Runnable {
public void run() {
while(!end){
synchronized (lock) {
cnt += 1;
cnt -= 1;
}
}
}
}
public static void main(String[] args)
throws InterruptedException{
ModCounter modc = new ModCounter();
Thread t1 = new Thread(modc);
t1.start();
for(int i=0; i<10; i++){
Thread.sleep(500);
synchronized (lock) {
System.out.println(cnt);
};
};
end = true;
t1.join();
System.out.println(cnt);
}
}Még annyit hozzáteszek azok kedvéért, akik később olvassák ezt a topicot:
Azt hiszem nem szerencsés egy több szálon futó programban olyan ciklust futtatni, amiben nincs Thread.sleep(), mert így nem hagyunk időt másik szálaknak a bekapcsolódásra, ráadásul zabálja a processzort, szóval
valami ilyesmi jobb, mint ami a fenti kódjaimban látható:
while(!end){
synchronized (lock) {
cnt += 1;
cnt -= 1;
};
try {
Thread.sleep(10);
} catch (InterruptedException e) {}
} -
loszerafin
senior tag
nezd meg ezt:
class Main {
static int cnt = 0;
static boolean end = false;
static Object lock = new Object();
static class ModCounter extends Thread {
public void run() {
while(!end) {
synchronized (lock) {
cnt += 1;
System.out.println(cnt);
cnt -= 1;
}
}
}
}
public static void main(String[] args)
throws InterruptedException{
ModCounter modc = new ModCounter();
ModCounter modc2 = new ModCounter();
modc.start();
modc2.start();
Thread.sleep(500);
end = true;
}
}
[Szerkesztve]Köszönöm, valóban jó megoldás egy lock objektum létrehozása:
class Counter3 {
static int cnt = 0;
static boolean end = false;
static Object lock = new Object();
static class ModCounter implements Runnable {
public void run() {
while(!end){
synchronized (lock) {
cnt += 1;
cnt -= 1;
}
}
}
}
public static void main(String[] args)
throws InterruptedException{
ModCounter modc = new ModCounter();
Thread t1 = new Thread(modc);
t1.start();
for(int i=0; i<10; i++){
Thread.sleep(500);
synchronized (lock) {
System.out.println(cnt);
};
};
end = true;
t1.join();
System.out.println(cnt);
}
} -
loszerafin
senior tag
nezd meg ezt:
class Main {
static int cnt = 0;
static boolean end = false;
static Object lock = new Object();
static class ModCounter extends Thread {
public void run() {
while(!end) {
synchronized (lock) {
cnt += 1;
System.out.println(cnt);
cnt -= 1;
}
}
}
}
public static void main(String[] args)
throws InterruptedException{
ModCounter modc = new ModCounter();
ModCounter modc2 = new ModCounter();
modc.start();
modc2.start();
Thread.sleep(500);
end = true;
}
}
[Szerkesztve]Köszönöm, hogy foglalkozol a témával.
Közben kitaláltam egy megoldást (egy oldallal tovább kellett olvasnom a könyvben a wait()-ig)
class Counter2 {
static int cnt = 0;
static boolean end = false;
static class ModCounter implements Runnable {
public void run() {
while(!end){
synchronized (this) {
cnt += 1;
cnt -= 1;
notify();
}
}
}
}
public static void main(String[] args)
throws InterruptedException{
ModCounter modc = new ModCounter();
Thread t1 = new Thread(modc);
t1.start();
for(int i=0; i<10; i++){
Thread.sleep(500);
synchronized (modc) {
modc.wait();
System.out.println(cnt);
};
};
end = true;
t1.join();
System.out.println(cnt);
}
} -
loszerafin
senior tag
Próbálkozom a thread-ekkel és elakadtam.
a run() metódusom szinkronizált, egy ciklusban a cnt mezőhöz hozzáad egyet, majd ki is von.
A main()-ben 500 msec-enként kiírom a cnt értékét. A kimenet hol 0, hol egy. Nyilván, a main() metódust futtató szál println-ja ''beüt'' a cnt-hez hozzáadó és abból kivonó utasítás közé. Hogy lehet ezt elkerülni?
class Counter1 {
static int cnt = 0;
static boolean end = false;
static class ModCounter implements Runnable {
public synchronized void run() {
while(!end){
cnt += 1;
cnt -= 1;
}
}
}
public static void main(String[] args)
throws InterruptedException{
ModCounter modc = new ModCounter();
Thread t1 = new Thread(modc);
t1.start();
for(int i=0; i<10; i++){
System.out.println(cnt);
Thread.sleep(500);
};
end = true;
t1.join();
System.out.println(cnt);
}
}
Kimenet:
0
1
1
0
0
1
1
1
0
1
0
Szeretném, ha csupa 0 jelenne meg.
Próbáltam a kiírást szinkronizálni:
synchronized (Counter1.class) {
System.out.println(cnt);
};
De semmi változás.
Előre is köszönöm
KL -
loszerafin
senior tag
kifutottam az idobol:
''Ha ''objektumot adunk át paraméterként'' akkor nem is az objektum a paraméter, hanem az objektum referencia, ami már ''by value'' kerül a metódusba.''
itt a lenyeg, mivel nem az objektum, hanem a referencia kerul atadasra, pont ezert hivjuk referencia szerinti atadasnak...[...]hanem a referencia kerul atadasra, pont ezert hivjuk referencia szerinti atadasnak...
Nem, nem. A ''referencia szerinti paraméterátadás'' fogalma független a Java-tól, független az objektumoktól, sőt független az objektum orientált programozástól.
Egyrészt:
Az érték szerinti paraméterátadás a következő:
A hívó fél által átadott dologról (paraméter) egy másolat készül. Ezt a másolatot használja a hívott fél. Azaz a hívott fél hiába módosítja az argumentumát, az nincs kihatással a paraméterre, a hívó fél a módosításról nem vesz tudomást, hiszen a hívott eljárás csak egy másolatot módosít.
A referencia szerinti paraméterátadásnál ha a hívott fél módosítja a megkapott dolgot,
akkor a hívó félnél is megváltozik a dolog.
Az, hogy ezt hogy oldják meg az egyes nyelvek, vagy megvalósítják-e egyáltalán, az most nem érdekes.
Javában paraméterként objektum referenciát megadva a hívott eljárás egy másolatot kap a referenciáról, azaz azt hiába változtatja meg (nem az objektumot, hanem a referenciát), ebből a hívó fél semmit sem érzékel. Tehát az objektum referencia is érték szerint adódik át a hívott metódusnak.
Pl. Nyugodtan lehet null-ra állítani a metódusban a megkapott objektum referenciát, attól még nem vész el az objektumunk, csak eggyel kevesebb referenciája lesz, és minimum egy marad, amit a hívó fél használ. -
loszerafin
senior tag
szerintem meg teljesen jol, es erthetoen van leirva, nem ertem mi a gond? Az ertek es a referencia szerinti atadas kozott az a leglenyegesebb kulonbseg, hogy az eredeti ertek megvaltozik-e. Ha objektumot adsz at, es megvaltoztatod egy parameteret, akkor az eredetinek is valtozni fog. Marpedig ekkor a parameteratadas nem lehet ertek szerinti

Teljesen érthetően van leírva a Sybex könyvben és teljesen rosszul.
A sun weboldalán van az igazság, ahol szó szerint ez van:
------------------
Primitive arguments, such as an int or a double, are passed into methods by value.
[....]
Reference data type parameters, such as objects, are also passed into methods by value.
------------------
Mivel tudtommal nincs más típusú paraméter a Java-ban, csak primitív és objektum referencia, ezért nem is létezhet más fajta paraméterátadás, mint érték szerinti.
Itt ugyan van egy kis pontatlanság, mikor azt írja ''such as objects'', hiszen objektumot _nem_ lehet átadni paraméterként, de a hétköznapi szóhasználatban elfogadható ez a pongyolaság. (más kérdés, hogy szerintem a Sun weboldalán elfogadhatatlan, de ez most nem fontos) -
loszerafin
senior tag
Ezt olvastam egy Sybex könyvben:
--------------------
Which of the following statements accurately describes how variables are passed to methods?
A. Arguments are always passed by value.
B. Arguments are always passed by reference.
C. Arguments that are primitive type are passed by value.
D. Arguments that are passed with the & operator are passed by reference.
--------------------
Boldogan bejelöltem az A-t, majd megnéztem a megoldást:
C. Arguments are not always passed only by reference or only by value. It depends on the
argument itself, and primitives are always passed by value. Java does not use the & operator
to denote “pass by reference” as is done in the C programming language. See Chapter 1 for
more information.
Én azt gondolom, hogy mindig értékmásolás történik paraméterátadásnál, függetlenül attól, hogy objektum referencia vagy primitív típusú az átadni kívánt paraméter.
Ha ''objektumot adunk át paraméterként'' akkor nem is az objektum a paraméter, hanem az objektum referencia, ami már ''by value'' kerül a metódusba.
Mit gondoltok?
Közben megnéztem a Sun site-ján (nyilván ott olvastam ezt) és bizony így van
http://java.sun.com/docs/books/tutorial/java/javaOO/arguments.html
Úgyhogy ezt a Sybex könyvet el kell felejteni... -
loszerafin
senior tag
Ha valaki szereti a fejtörőket:
class Proba {
public static void main(String[] args){
int i1 = 10;
int i2 = 10;
Integer I1 = 10;
Integer I2 = 10;
Integer I3 = 1000;
Integer I4 = 1000;
Integer I5 = new Integer(10);
Integer I6 = new Integer(10);
Integer I7 = new Integer(1000);
Integer I8 = new Integer(1000);
String s1 = ''a'';
String s2 = ''a'';
String s3 = s1;
String s4 = new String(''a'');
String s5 = new String(''a'');
String s6 = s4;
String s7 = new String(s1);
System.out.println(1 + '':'' + (i1 == i2));
System.out.println(2 + '':'' + (I1 == I2));
System.out.println(3 + '':'' + (i1 == I1));
System.out.println(4 + '':'' + (I3 == I4));
System.out.println(5 + '':'' + (I5 == I6));
System.out.println(6 + '':'' + (I7 == I8));
System.out.println(7 + '':'' + (I3 == I7));
System.out.println(8 + '':'' + (I2 == I5));
System.out.println(9 + '':'' + (s1 == s2));
System.out.println(10+ '':'' + (s3 == s1));
System.out.println(11+ '':'' + (s3 == s2));
System.out.println(12+ '':'' + (s4 == s5));
System.out.println(13+ '':'' + (s6 == s4));
System.out.println(14+ '':'' + (s6 == s1));
System.out.println(15+ '':'' + (s6 == s5));
System.out.println(16+ '':'' + (s7 == s1));
System.out.println(17+ '':'' + (s7 == s4));
}
}
Mit ír ki a program? (persze, fejben érdemes próbálkozni előszőr, és magyarázatot fűzni a megoldásokhoz...)
(Azután tegye fel a kezét, aki 100% volt. Bár én csináltam a fenti ''feladatot'', nekem 94%-ot sikerült összehoznom) -
loszerafin
senior tag
A Calendar osztály set metódusában a hónapok 0-tól kezdve számozódnak, míg az év és a nap természetesen 1-től indul
Igen ez tényleg furának nevezhető, de a Calendar osztály estében az előre definiált
static konstansokat (JANUARY, FEBRUARY stb...) illik használni, innentől kezdve
pedig édesmindegy hogy a január a háttérben 0 vagy 5000
Igazad van, köszi. -
loszerafin
senior tag
Köszönöm mindkettőtöknek,
substring(startindex, startindex + 10)
Így könnyen megjegyezhető.
Közben találtam egy újabb ''fejfájást'':
A Calendar osztály set metódusában a hónapok 0-tól kezdve számozódnak, míg az év és a nap természetesen 1-től indul
De ezt csak mint érdekességet írom, nem fontos reagálni rá, és azt hiszem, abbahagyom a ''különös'' dolgok beírását a fórumba, talán fárasztó már, meg úgyis parttalan... -
loszerafin
senior tag
Köszi a linket, bár nem tűnik komoly oldalnak.
Ez kétszer is megtalálható az oldalon :
''a programozók ... fogalmatlan (sic!) emberek''
Van ott egy 35 soros program, ami a Java ''bénaságát'' szemlélteti, hát azt nekem (2 hete tanulom a Java-t) sikerült megírnom kissé rövidebben is.
A program a test változó szövegében levő szavak előfordulási gyakoriságát számolja meg:
import java.util.*;
class MyTest {
public static void main(String[] argv) {
String test = ''Let's count the words in this text. ''
+ ''The text contains some words more than once, ''
+ ''so their count will be more than one.'';
Collection<String> list = Arrays.asList(test.split('' ''));
Collection<String> set = new HashSet<String>(list);
for (String word : set ){
System.out.println(word + '':'' + Collections.frequency(list,word));
}
}
}
Egyébként igaz, hogy a Java az elején igen nehézkes volt, pl. említik a linkelt oldalon, hogy castolni kellett a primitív típus - objektum típus miatt, de ez mára eltűnt (autoboxing/unboxing), és a Collection Framework-öt is eléggé ütősnek érzem, pedig csak a felszínét értem. Azután itt van az assert, ami kitűnő eszköz, meg a kivételkezelés, stb.
Meg ''csúnya'' dolog erősen típusos, fordítós nyelvet összehasonlítani script-nyelvekkel.
A Java és a C# próbál közelíteni a scriptnyelvek hajlékonyságához, szabadságához, de nyilván sose lehetnek olyanok.
Ráadásul azt is írja, a Java könnyen tanulható, hát, nem tudom. Nekem gyötörnöm kell magam, meg magolnom eléggé sokat, és még van 400 oldalam hátra, és akkor csak az alapokon rágtam át magam és még gyakorlatom se lesz.
Személyes véleményem, hogy a programok olvashatósága rettentő fontos. Egy ismerősöm azt mondta a C-ről (eléggé régen volt ez) hogy azt csak írni tudja, olvasni nem...
Én eléggé otthon vagyok a perlben, (ami egy zseniális nyelv), de könnyedén összehozok benne olyan 1 soros programot, amit 3 perc múlva már magam se értek. -
loszerafin
senior tag
hat pedig eleg egyertelmu a mukodese:
''Returns a new string that is a substring of this string. The
substring begins at the specified <code>beginIndex</code> and
extends to the character at index <code>endIndex - 1</code>.
Thus the length of the substring is <code>endIndex-beginIndex</code>.''
Persze hogy egyértelmű. Az lenne a csuda, ha nem az lenne.
Azonban cseppet sem logikus.
Láthatod, a bemásolt leírásod is körmönfont:
beginIndex-ről és endIndex-ről ír, holott a substring vége _nem_ az endIndex-nél van, hanem endIndex-1 -nél.
Ugyanilyen ''logikával'' akár lehetne a string vége endIndex-17 -nél. Ekkor pl.
substring(0,17)-re kapnánk meg az első karakterét a stringnek.
[Szerkesztve] -
loszerafin
senior tag
Nézegetem a String osztály metódusait, és találtam valami furcsát.
substring(start,end)
Már az is eléggé furcsa, hogy a substring nem ilyen:
substring(start,darab)
Na de hogy az ''end'' 1-től számozódik!!!! Ez hihetetlen. Főleg annak tükrében, hogy a ''start'' meg 0-tól. Azért megkérdezném attól, aki ezt így találta ki, hogy mi volt az oka.
Gondolom, az oka a Java nyelv elődeiben keresendő.
Direkt megnéztem, C++-ban a substring(start, darab). Utánanéztem az Ada-nak, úgy láttam, az se ilyen ''elvetemült'', a slice-oknál tól-ig lehet megadni a pozíciót. -
loszerafin
senior tag
Köszi a példád, nagyon jó:
class AutoBoxing {
public static void main(String[] args){
Integer i=1000, j=1000;
while (i<=j && i>=j && i!=j) { };
}
}
Így végtelen ciklus,
Integer i=0, j=0; -val meg kilép. -
loszerafin
senior tag
-
loszerafin
senior tag
Köszi, megnézem később. Most van egy könyvem, azon rágom át magam éppen.
Ezt ismeri valaki?
Kérdés: Mit ír ki a program? (Figyelem! Tilos begépelni és kipróbálni, előbb tippelni kell!)
class Equal {
public static void main(String[] args){
Integer i,j;
i=10; j=10;
System.out.println(i==j);
i=1000; j=1000;
System.out.println(i==j);
}
}
(Persze az igazi kérdés inkább az, hogy miért van ez így?)
[Szerkesztve] -
loszerafin
senior tag
További ''érdekesség'' ebben a témában:
Az eredeti kérdés ez volt:
Az ugye világos, hogy ez
----------------
int a = 10;
int a = 10;
------------------
Nem működik (already defined, mondja a compiler).
És persze ez sem:
-------------------------
MyClass a = new MyClass();
MyClass a = new MyClass();
-------------------------
Az érdekes viszont az, hogy így működik:
for (int i=0; i<2; i++){
int a = 10;
};
pedig itt is 2x van az ''int a = 10'' sor.
A kérdés az volt, hogy lehet ez?
Amit ''felfedeztem'', hogy van olyan eset, amikor minden végrehajtáskor készül egy új objektum!
Legalábbis, ha osztályokról van szó:
class MyClass { }
class MoreMyClass {
public static void main (String[] args){
MyClass a = new MyClass();
for(int i=0; i<2; i++){
MyClass s = new MyClass();
if (i == 0) a = s;
System.out.println(i + '':'' + (a==s));
}
}
}
És az eredmény:
0:true
1:false
Ami azt szemlélteti, hogy a ciklus második futásakor az s másik objektumra mutat, mint az első körben. (már, ha nem tévedek, persze)
[Szerkesztve]
[Szerkesztve] -
loszerafin
senior tag
Találkoztam egy érdekes kérdéssel:
Ez nem megy, mert a NetBeans hibát jelez:
(n is already defined)
--------------------
int n = 10;
int n = 10;
--------------------
Ez viszont fut, hiba nélkül:
for (int i=0;i<2;i++){
int n = 10;
}
Az a kérdésem, mi történik ilyenkor ? Az int n = 10 lefut kétszer?
Előre is köszönöm
KLA beszélgetéseteket olvasva rájöttem, hogy elég megnéznem a bytekódot:
class MoreInt {
public static void main(String[] args){
for (int i=0; i<2; i++){
int j = 10;
}
}
}
És a bytekód:
Code:
0: iconst_0
1: istore_1
2: iload_1
3: iconst_2
4: if_icmpge 16
7: bipush 10
9: istore_2
10: iinc 1, 1
13: goto 2
16: return
}
A lokális változók számozva vannak, a j a kettes számú. A fordításkor ennek biztosít helyet a fordító, futáskor végig ezt a helyet használja.
[Szerkesztve] -
loszerafin
senior tag
Köszönöm a válaszokat.
KL -
loszerafin
senior tag
Találkoztam egy érdekes kérdéssel:
Ez nem megy, mert a NetBeans hibát jelez:
(n is already defined)
--------------------
int n = 10;
int n = 10;
--------------------
Ez viszont fut, hiba nélkül:
for (int i=0;i<2;i++){
int n = 10;
}
Az a kérdésem, mi történik ilyenkor ? Az int n = 10 lefut kétszer?
Előre is köszönöm
KL -
loszerafin
senior tag
Szia
Linux alá NetBeans5.5
http://www.netbeans.org/
Nálam néha lefagy, akkor bezárom a konzolt, amiből indítottam, és akkor újra konzol ablak, netbeans.
Javas ''könyv'':
http://java.sun.com/docs/books/tutorial/
Feladatgyűjtemény: nem ismerem a Juhász-... félét.
De:
http://www.javapassion.com/javaintro/#Software
Igaz, ezt se próbáltam...
[Szerkesztve]
[Szerkesztve] -
loszerafin
senior tag
A SUNDAY, MONDAY stb.. olyanok mintha a Day osztály statikus field-jei lennének,
(a compiler azzá is alakítja őket a háttérben) ÉS egyúttal Day típusú objektumok.
A kettő korántsem zárja ki egymást!
Így már gondolom érthető a
Day day = Day.MONDAY;
írásmód, hiszen a Day osztály statikus field-jére hivatkozol, ami egy Day típusú
objektum. Pontosan ahogy te is leírtad.
Ha akarod írhatod így is:
Day day = MONDAY;
de akkor a statikus importot kell használnod:
import static Day.*;
és ezzel gyönyörűen visszakanyarodtunk a legelső kérdésedhez
[Szerkesztve]Köszönöm. Igazán kedves vagy, hogy ilyen türelmesen válaszolsz a kérdéseimre.
-
loszerafin
senior tag
Mégsem világos.
Ha SUNDAY, MONDAY, stb. objektumok jönnének létre (amik Day típusúak), akkor nem
Day day = Day.MONDAY;
sorral használnám, hanem
Day day = MONDAY;
sorral.
A
Day day = Day.MONDAY; ből inkább az következik,
hogy már létezik egy Day osztály, aminek van egy MONDAY field-je, ami szintén Day típusú (!?)
Esetleg a Day osztálynak SUNDAY,MONDAY, stb. alosztályai, de ezt nem gondoltam még végig....
Persze, mondhatnánk, hogy ez teoretikus fejtegetés, de azt hiszem, hogy amíg az ember nem érti teljesen a dolgok működését (vagy legalább nincs egy jó modell a fejében), addig nem is tudja használni. A Java pedig a szerszámom lesz, jó, ha megismerem... -
loszerafin
senior tag
Egyedül az nem világos, hogy ki, mikor hívja meg a Day konstruktort
Ez is benne volt a válaszomban csak talán nem volt elég világos:
A MONDAY(''Monday'') sor az enum kódjában egyenértékű az általad leírt
konstruktorhívással. Olyan mintha statikus változót hoznál létre valahogy így:
Day MONDAY = new Day(''Monday'');
Tehát azzal hogy felsoroltad a 7 napot az enum-ban, egyúttal a konstruktor
is meghívódott mind a 7 alkalommal.
Kivülről nem tudsz új példányokat létrehozni az enum-ból, de nem is nagyon lenne értelme.Köszönöm, most már értem.
Azaz az enum-ban levő konstansok-nak megfelelő objektumok jönnek létre, számszerint 7,
ezek immutable-ek, és tölem függetlenül, a kódom elindulása előtt elkészülnek.
Én a
Day day = Day.MONDAY; sorral a már kész statikus objektumokat használom.
Így az is érthető, hogy hogy tud működni a Day.values(); hiszen a már létrejött 7 objektumon végig tud menni rendszer.
[Szerkesztve] -
loszerafin
senior tag
Szia!
Az enum típusra úgy érdemes gondolni mint egy sima osztályra.
Annyi a különbség, hogy ebből az osztályból közvetlenül sosem hozunk
létre példányokat, csak az előre definiált ''konstansokat'' használhatjuk.
A példában tehát létrejön egy Day ''osztály'' és annak a 7 példánya (SUNDAY,
MONDAY, stb...)
Legegyszerűbb formában tehát az enum így nézne ki:
enum Day {
SUNDAY,
MONDAY,
TUESDAY,
WEDNESDAY,
THURSDAY,
FRIDAY,
SATURDAY;
}
Mint minden sima osztályban az enum-ban is írhatunk metódusokat, tárolhatunk
egyéb adatokat.
Alapból a toString() metódus a konstans nevével megegyező string-et ad vissza,
tehát a System.out.println(Day.MONDAY) eredménye ''MONDAY''.
A te példádban az enum-ban tárolunk egy dayname string-et is. Itt jön be
a képbe a konstruktor szerepe. Igaz te kivülről sosem hivod közvetlenül a
konstruktor-t, de a SUNDAY(''Sunday'') sor az enumban valójában egy konstruktor
hívást jelent, azaz a ''Sunday'' string eltárolodik a dayname változóba.
A toString metódust is felüldefiniálódik a te példádban, mégpedig úgy, hogy ezt a
dayname String-et adja vissza. Igy a System.out.println(Day.MONDAY) eredménye
''Monday'' lesz ''MONDAY'' helyett.
Azt hogy milyen adatokat tárolsz az enum-ben és milyen konstruktorokat írsz
te döntöd el, csak a konstansok felsorolásánal (SUNDAY, MONDAY stb) a megfelelő
számú és típusú paramétert kell átadni.
[Szerkesztve]Köszi a választ, de a példámat értem, hiszen én hoztam létre.
(Sőt, csináltam egy rövidke tutorialt, hátha elfelejteném vmikor:
[link]
)
Egyedül az nem világos, hogy ki, mikor hívja meg a Day konstruktort, mert használat közben én nem hívom meg:
Day day = Day.MONDAY;
Olyat nem is enged a fordító, hogy
Day day = new Day(''Monday''); -
loszerafin
senior tag
Sziasztok
Van egy kérdésem az enum típussal kapcsolatban:
enum Day {
SUNDAY (''Sunday''),
MONDAY (''Monday''),
TUESDAY (''Tuesday''),
WEDNESDAY (''Wednesday''),
THURSDAY (''Thursday''),
FRIDAY (''Friday''),
SATURDAY (''Saturday'');
public final String dayname;
Day(String dayname) {
this.dayname = dayname;
}
public String toString(){
return (this.dayname);
}
}
Ez működik, meg használni is tudom. A kérdésem inkább elméleti jellegű:
A constructor-nál nem világos a paraméter szerepe.
( Day(String dayname) )
Hiszen így használom:
Day day = day.SUNDAY;
Akkor meg hogy kerül oda az a String dayname paraméter? Ez valami trükk, hogy a Java fordító az ilyen day.SUNDAY kifejezéseket átalakítja constructorhívássá, úgy hogy a SUNDAY-nak megfelelő szöveget (''Sunday''), odateszi paraméternek?
Azt megfigyeltem, hogy a constructor-t csak a kellő számú, típusú és sorrendű paraméterrel lehet megírni.
Persze használni kényelmes, de nem látom át, mi is történik itt valójában...
Előre is köszönöm
KL -
loszerafin
senior tag
Szia!
A static import viszonylag új dolog a Java-ban az 1.5-től kezdve jött képbe.
A hagyományos import arra jó, hogy a package név kiirása nélkül hivatkozhass
osztályokra. Ha például azt írod, hogy
import java.util.HashMap;
akkor a kódban simán HashMap-ként hivatkozhatsz a java.util.HashMap osztályra.
Az import java.lang.Math.*; értelmetlen, mivel az osztályon belüli dolgokat
nem lehet beimportálni a sima importtal.
A Math osztályra egyébként már eleve hivatkozhatsz rövid névvel, mivel az a java.lang package-ben van. Ez az egyetlen package amit soha nem kell beimportálni, mert mindig alapból be van importálva.
Az ''régi'' import esetén tehát a package név elhagyható, de nem
az osztálynév! Java 1.5 előtt tehát a PI konstansra úgy tudtál hivatkozni, hogy
Math.PI
Itt jön be a statikus import a képbe, mivel pont arra találták ki, hogy statikus
változók használatakor ne kelljen beirni az osztály nevét sem.
Ha tehát azt mondod, hogy
import static java.lang.Math.PI;
akkor attól kezdve sima PI-t irhatsz a kódban.
Az interfészek, osztályok importja között nincs különbség.
[Szerkesztve]Szia
Köszönöm a kimerítő választ, azt hiszem, megértettem.
Ráadásul a válaszod olvasása közben a csomag/osztály viszony is világosabb lett.
Választottam egy másik osztályt, amit nem importál be a java fordító automatikusan, hogy jobban átlássam a dolgot.
Pl. java.math.BigDecimal osztály.
Az import java.math.BigDecimal;
beírásával a nem-statikus metódusokat a metódus nevének a leírásával használhatom,
a statikus metódusokat/mezőket pedig a ''BigDecimal.''
beírásával a metódus/mező neve előtt használhatom.
Ha ezt is ( a BigDecimal. beírását) el akarom kerülni, akkor :
import static java.math.BigDecimal.*;
ami után az összes statikus mezőt/metódust a BigDecimal eléírása nélkül használhatok,
vagy
import static java.math.BigDecimal.ONE;
ha a ONE statikus mezőt akarom használni,
vagy
import static java.math.BigDecimal,valueOf;
ha a valueOf() metódust akarom használni.
Világos minden az import használata körül, még 1x köszönöm.
KL -
loszerafin
senior tag
Sziasztok
Elkezdtem tanulni a Java-t, és van egy kérdésem:
Szeretném a PI konstansot használni a programomban.
Ehhez a következő importot kell beírnom:
import static java.lang.Math.*;
Miért kell import static ? Miért nem jó :
import java.lang.Math;
import java.lang.Math.*;
Egészen konkrétan a kérdésem:
A
import java.lang.Math;
import java.lang.Math.*;
sorok miért nem importálnak minden public dolgot? Miért kellett különbséget tenni
a Java fejlesztésekor a konstansok és az osztályok/interfészek/metódusok importálása
között?
Előre is köszönöm
KL
Új hozzászólás Aktív témák
-
Fórumok
PROHARDVER! - hardver fórumok
Notebookok TV & Audió Digitális fényképezés Alaplapok, chipsetek, memóriák Processzorok, tuning Hűtés, házak, tápok, modding Videokártyák Monitorok Adattárolás Multimédia, életmód, 3D nyomtatás Tabletek, E-bookok Nyomtatók, szkennerek PC, mini PC, barebone, szerver Beviteli eszközök Egyéb hardverek PROHARDVER! BlogokMobilarena - mobil fórumok
Okostelefonok Mobiltelefonok Okosórák Autó+mobil Üzlet és Szolgáltatások Mobilalkalmazások Tartozékok, egyebek Mobilarena blogokIT café - infotech fórumok
Infotech Hálózat, szolgáltatók OS, alkalmazások SzoftverfejlesztésGAMEPOD - játék fórumok
PC játékok Konzol játékok MobiljátékokLOGOUT - lépj ki, lépj be!
LOGOUT reakciók Monologoszféra FototrendFÁRADT GŐZ - közösségi tér szinte bármiről
Tudomány, oktatás Sport, életmód, utazás, egészség Kultúra, művészet, média Gazdaság, jog Technika, hobbi, otthon Társadalom, közélet Egyéb Lokál PROHARDVER! interaktív
- Fórumok
- Szoftverfejlesztés
- Java programozás
- (kiemelt téma)
A topicot kiemeltem. Valaki nem akar egy nyitó hsz-t írni?:))
- Samsung Galaxy Felhasználók OFF topicja
- Battlefield 6
- Melyik tápegységet vegyem?
- Luck Dragon: Asszociációs játék. :)
- Samsung Galaxy Z Fold7 - ezt vártuk, de…
- Ubuntu Linux
- PROHARDVER! feedback: bugok, problémák, ötletek
- Gurulunk, WAZE?!
- Huawei Watch Fit 5 Pro - jó forma
- Motoros topic
- További aktív témák...
- Asus Chromebook C423NA, 8GB RAM, N4200 Pentium, 180 Kihajtható
- Lenovo 13w Yoga 2in1 Gen 2 AMD Ryzen 3 7330U 8 GB RAM 256 GB SSD Premium garancia FHD IPS TOUCH
- BESZÁMÍTÁS! AsRock H510M i5 10500 32GB DDR4 512GB SSD ARC B570 Zalman S2 TG Adata 600W
- GYÖNYÖRŰ iPhone 14 Pro Max 128GB Gold -2 ÉV GARANCIA -Kártyafüggetlen, MS5597
- Xiaomi Redmi Note 14 Pro+ 5G 512GB, Kártyafüggetlen, 1 Év Garanciával
Állásajánlatok
Cég: Laptopműhely Bt.
Város: Budapest



Mind1 kösz a segítséget, ha majd a négyszögletű kerek erdő felé járok meghálálom! 

Pedig tudomásom szerint azok felveszik a LEFT_PRESSED, RIGHT_PRESSED, UP_PRESSED, DOWN_PRESSED és FIRE_PRESSED értékeit is. A gombtomb[]-ben a gombok sorrendjében tároltam le a koordinátákat, tehát az index maga a gomb száma. Lehet az a gond, hogy a paint és/vagy flushgraphics után tettem a feltételeket?
hát igen, gyakorlat teszi a mestert...
up?




