Hirdetés
- Új Intel CPU-kkal jön a Surface Pro 12 és a Surface Laptop 8 for Business
- Nem kell még temetni: 2 éves órajelcsúcsot döntöttek meg Raptor Lake-kel
- HiFi műszaki szemmel - sztereó hangrendszerek
- Házimozi belépő szinten
- Apple MacBook
- Milyen egeret válasszak?
- AMD K6-III, és minden ami RETRO - Oldschool tuning
- Gaming notebook topik
- Nem kéri tovább a nekik fejlesztett csúcs-GeForce-ot Kína?
- Fejhallgató erősítő és DAC topik
Új hozzászólás Aktív témák
-
norbert1998
nagyúr
Csak egy apró tanács: ne nevezd el a tömb hosszút jelentő változót "i"-nek. Az "i"-t szinte mindig ciklusváltozónak szoktuk felhasználni.
Igen, tudom, ezt copy paste-eltem egy nagyobb programból, amiatt a fura nevek. Az i-t én is ciklusváltozónak szoktam használni
-
norbert1998
nagyúr
A j egy nemnegatív szám. A k megy j+1-től j-ig, és növekszik. Csodálkozol, hogy nem csinál semmit?
Bakker, hogy erre nem jöttem rá
Mondjuk azóta nem nagyon foglalkoztam vele, haladtam tovább, ott már teljes sikerrel. Már csak a beolvasás rossz, azt meg a tanár mondta, hogy megcsekkolja.Köszi
-
norbert1998
nagyúr
Üdv újra!
Egy ABC rendezéssel szenvedek. Leegyszerűsítettem az egészet egy külön programba, elsősorban, hogy egy ilyen egyszerű esetben is csinálja-e, amit csinál. Sajnos igen. Az utolsó elemet berakja előre, és viszon'látás!
Minimumkiválasztásos rendezéssel ezt csinálja, közvetlen kiválasztásossal pedig az égvilágon lófült sem tesz. A minimumkiválasztásost írom le, most az van kicsinyítve nekem.
String csereseged;
String []rendnev={"A","B","C","D","E"};
int cser;
int i=rendnev.length;
for(int j=0;j<i-1;j++){
cser=0;
for (int k=j+1;k<j;k++){
if (rendnev[j].compareTo(rendnev[cser])>0) cser=k;
}
csereseged=rendnev[j];
rendnev[j]=rendnev[cser];
rendnev[cser]=csereseged;
}
for(int j=0;j<i;j++) System.out.println(rendnev[j]); -
norbert1998
nagyúr
Tudom, hogy csak a konzolra írtok, nem is baj az. Csak a formázást sztem nem kell túlzásba venni.
A keresést már nem néztem, mert az extra hiánya miatt ugye az egész kód piros volt. A beolvasás jó.
Értem. Köszi, hogy megnézted
-
norbert1998
nagyúr
ha format left vagy right-tal kiiratod, akkor sincs elcsúszva a felső sor?
Nem. Mivel nem mellékelted azt a csomagot, ezért kénytelen voltam törölni az extra csomagban lévő hívásokat. De ezek szerint a kiírás rossz csak. Én nem sokat foglalkoznék egy konzolra való kiírás formázásával...
És az extra hiánya miatt törölted az egész extra dolgot? Mondom pont abban látszik, hogy mi van.
És azt is mondtam, hogy csak konzolra iratunk. Az egész tanterven nincs is más!Neked működik az 1/2/1-es menüpontban a keresés és az első találat kiírása?
-
norbert1998
nagyúr
Szia!
Az ember maximum 7 dolgot tud egyszerre fejben tartani. A program komplexitása messze meghaladja ezt a számot. Vagyis az időd nagy részét arra pazarlod, hogy a fejedből kieső információt folyamatosan töltöd vissza, miközben ettől függetlenül hibát is keresel. Ne csodálkozz, ha nem megy. Senkinek sem menne.
Az oktatás célja új tudásanyag átadása, és nem a szívatás. Ha tömbök használatát kell gyakorolni, akkor gyakoroljátok, de ezt nem egy átláthatatlan programon kell csinálni, mert az már nem a tömbök használata lesz. Ezzel csak arra akarok célozni, hogy bizonyos komplexitás elérésekor meg KELL tanulni a kód kisebb egységekre bontásának módjait. Különben az energia egyre nagyobb részét fogja felemészteni az, hogy próbálod megérteni, mi történik, és egyre kevesebb figyelem jut a tényleges gyakorlásra.
A nehezebb mód az, hogy tovább görcsölsz rajta, és majd egyszer sikerül rátalálni az egyik hibára. Sajnos hátra van még a többi hiba is. Mindig van egy újabb hiba.
Ezen valamelyest javíthatsz, ha elkezded debugolni: teszel egy breakpoint-ot a problémás rész elé, és debug módban indítod a programot. Majd szépen lassan, soronként egyesével lépkedve, a változók értékeit folyamatosan ellenőrizve megnézed, mit is a csinál a gép.A könnyebb (és melósabb) mód, ha legalább megtanulsz metódust készíteni.
Első lépés:
public class Beadando {
public static void main(String[] args) {
new Beadando.doit();
}
// ez egy példány szintű metódus, nincs visszatérési értéke, nincs paramétere
public void doit() {
// a main helyett ide kerül minden
}
}A static main metódus a program belépési pontja, ugyan a Beadando osztályban van (mert valahova tenni kell), de nem sok köze van hozzá. Ami a main-ben történik, hogy az osztályból készül egy példány, és azonnal ráhívsz annak egy példány szintű (nem static) metódusára. Én doit-nek neveztem, te úgy nevezed, ahogy akarod. Minden más marad a régiben.
A következő lépés lehetne mondjuk a Beadando által gyakran használt változókat kiemelni, field-et csinálni belőle. Ha nem lenne egy Beadando példányod, ezt nem tehetnéd meg ilyen szépen. Pl. én kiemelném az adatot tartalmazó tömböket, sőt a színeket tartalmazó konstansokat is:
public class Beadando {
private static final String RESET = "\u001B[0m";
private static final String RED = "\u001B[31m";
private static final String BLUE = "\u001B[34m";
private static final String CYAN = "\u001B[36m";
private int n=500;
private String [] nev =new String [n];
private String [] gazdnev =new String [n];
private String [] tomeg =new String [n];
private String [] kor =new String [n];
public static void main(String[] args) {
new Beadando().doit();
}
public void doit() {
// ide kerül minden
}
}
Értelemszerűen ezeket már nem kell belül létrehoznod, elég hivatkozni rájuk. Javaban a konstans static és final módosítóval is rendelkezik, a példány szintű field-eknek nem kell static-nak lenniük. Nem is ajánlott.new Beadando()
Ez készít egy példányt az osztályból. Mivel az osztálynak még nincs látható(!) konstruktora, az alapértelmezett konstruktor (aminek nincs paramétere) használható a példányosításkor.A tömb mérete nem túl szép ott a field-ek között, lehetne akár konstruktor argumentum. A konstruktor tekinthető egy spéci metódusak is, máshogy is néz ki. Ő csak egyszer hajtódik végre, a példány létrehozásakor. A tömböket is elég ilyenkor lefoglalni:
public class Beadando {
private static final String RESET = "\u001B[0m";
private static final String RED = "\u001B[31m";
private static final String BLUE = "\u001B[34m";
private static final String CYAN = "\u001B[36m";
private String [] nev;
private String [] gazdnev;
private String [] tomeg;
private String [] kor;
private int n;
public static void main(String[] args) {
// new Beadando(500).doit();
// vagy akár így is lehet példányosítani és ráhívni az egyik metódusára:
Beadando beadando = new Beadando(500);
beadando.doit();
}
// ez a konstruktor, van egy int argumentuma, ebben lesz majd az 500
public Beadando(int n) {
this.nev =new String [n];
this.gazdnev =new String [n];
this.tomeg =new String [n];
this.kor =new String [n];
this.n = n; // ha esetleg még valahol hivatkoznál az n-re, a this.n-nel ezt megteheted
}
public void doit() {
// ide kerül minden
}
}A field-ekre a this. prefix-szel hivatkozhatsz, de elhagyható, ha a neve nem ütközik más változó nevével.
Első blikkre egész szépen kiszervezhetők metódusokba a case blokkokban lévő cuccok. Kezdd a belül lévő legkisebbekkel. Kommentekkel még el is nevezted őket, szinte adja magát.
Pl. ebből:
// ...
public void doit() {
// ... a doit elején lévő cuccok
case 3 : { //főmenü 1-es menüpont->2-es menüpont
String kereses=extra.Console.readLine("Milyen korút keressünk?");
db=0;
i=0;
while(kor[i++]!=null){
}
for (int g=0;g<i;g++){
if (kereses.equals(kor [g])){
torvalogatas[db]=g;
db++;
}
}
break;
}
// ... a doit végén lévő cuccok
}
}Ez lesz:
// ...
public void doit() {
// ... a doit elején lévő cuccok
case 3 : { //főmenü 1-es menüpont->2-es menüpont
db = keresKorra(torvalogatas);
break;
}
// ... a doit végén lévő cuccok
}
// ez egy új metódus, az osztályon belül, de a doit metóduson kívül
private int keresKorra(int[] torvalogatas)
String kereses=extra.Console.readLine("Milyen korút keressünk?");
int db=0; // Figyelem! Ez a db, nem a metóduson kívül található db.
int i=0; // Ahogy ennek az i-nek sincs semmi köze a külső i-hez. Ezek csak itt belül léteznek.
while(kor[i++]!=null){
}
for (int g=0;g<i;g++){
if (kereses.equals(kor [g])){
torvalogatas[db]=g;
db++;
}
}
return db; // Itt a metódus futása megszakad és visszatér a return mögött található változó értékével.
}
}A metódusokat tetszőleges sorba rendezheted, azokat, amelyek hasonló dolgot csinálnak, egységesítheted. Amelyek pedig ugyanazt csinálják, több helyen újra felhasználhatod, eltérő paramétereket adva neki.
private int keresKorra(int[] torvalogatas)
Az első elem egy láthatóságot szabályozó módosító, a private csak az osztályon belül látható, a public bárhol, a többi most nem érdekes, jelen esetben teljesen mindegy, melyiket használod.
A következő a metódus visszatérési értékének típusa. Sajnos max. csak 1 db visszatérési értéke lehet egy metódusnak, ez most egy int (a metódus törzsében található return utasítással adod majd vissza a tényleges értéket). Ha a metódus nem kell, hogy visszaadjon értéket, akkor a típus a void lesz (a return pedig elhagyható).
Aztán jön a metódus neve, tetszőleges, bár a szokásos névkonvenciók rá is vonatkoznak, kezdődjön kisbetűvel, és az ékezetes betűket inkább hanyagold.
A zárójelek között pedig vesszővel elválasztva felsorolod a metódus paramétereit (típusa és a metóduson belül használt neve).
Ha a metódusban kivételt is dobunk és azt nem kapjuk el, akkor a ) után szerepel a throws kulcsszó és a kivételek vesszővel elválasztva, pl.: void metodusNeve(String param1, int param2) throws IOException { }. A fordító majd úgyis reklamál, ha ilyet kell csinálnod.A return a metódusban bárhova tehető, de ha a vezérlés elér hozzá, - akár egy ciklus kellős közepén is vagy - a metódus futása megszakad és visszatér az adott változó aktuális értékével. Ez alól csak a finally blokk kivétel, mert az abban lévő cucc a metódus elhagyása előtt még gyorsan megfut.
A metódus felhívása így történik:
db = keresKorra(torvalogatas);
Metódus neve, és zárójelben vesszővel elválasztva felsorolod az átadni kívánt paramétereket. Ha a metódus valamilyen értékkel is visszatér (nem void), akkor azt az értéket el is tárolhatod egy változóban, most a db változóba tettük egy sima értékadás keretében. Persze ha kint nincs szükséged a visszaadott értékre, nem kell azt mindenáron változóba tenni, az értékadás elhagyható.A metódus törzse egy külön világ, itt csak a field-eket és a beadott paramétereket látod, ezekkel dolgozhatsz.
A paraméterek érték szerint adódnak át. Ez primitív típusoknál (int, char, boolean, stb.) egyértelmű, az érték átadásra kerül, de a metódusban bármit is csinálsz vele, az a metóduson kívül nem fog érvényre jutni. Immutable típusoknál (pl. String) sincs veszély, mert azok úgy lettek megalkotva, hogy bármit is csinálsz vele, magán az objektum állapotán nem változtat, inkább új objektumot hoz létre.
Viszont van minden más (pl. a fentebb említett Dog osztály, vagy éppen a tömbök), amelyek akár több értéket is képviselhetnek. Ezért aztán csak azok memóriacíme kerül értékként átadásra, így ha ezek tartalmát módosítod a metóduson belül, a módosításod a metóduson kívül is érvényre jut. Hiszen a metóduson kívül létező tömb és a metódusnak átadott tömb címe ugyanaz, ugyanazt a memóriaterületet piszkálod.
És itt jutottunk el ahhoz a csúnya megoldáshoz, amit alkalmaztam: átadtam a torvalogatas tömböt a metódusnak, pedig az csak ír bele. Nem szép dolog metóduson belül a paramétereket változtatni, normális esetben csak olvasni szabadna, de ez például egy módszer arra, hogy a metódus több dolgot is változtasson (mivel csak egy visszatérési értéke lehet, és azt a db-re elpazaroltuk).
Persze a több visszatérési értékre van más megoldás is, pl. minden visszaadandó cuccot becsomagolni egy objektumba, de egyelőre szerintem ennyi is elég.Kellemes refaktorálást. Miközben bontod szét a kódot, valószínűleg a mostani hiba okát is meg fogod találni. Ha lehet, említsd meg a tanárnak, hogy az ezersoros programod kezd átláthatatlanná válni, meséljen már az osztályokról, példányokról és metódusokról.
Ami pedig az érettségit illeti: Egy problémát meg lehet oldani jól és hatékonyan, de meg lehet oldani gányolással is. Nem kell ismerni az osztályokat, a metódusokat, de még a for ciklust sem hozzá. Csak éppen évekkel tovább tart a megoldás, és lehet hogy kapsz rá egy kettest. És egy bizonyos méret felett az ember már nem a megoldással foglalkozik, hanem a kapálózással, hogy a víz felszínén tudjon maradni. Kizárt, hogy érettségin ne kelljen ezeket az alap dolgokat használni. De tedd fel magadnak a kérdést: Könnyű érettségit akarsz? Jó munkahelyet magas fizuval? Ha igen, és a tömböket már unalomig gyakoroltad, akkor érdemes továbblépni a List-re. Annyi hasznos dolog van még a nyelvben, sose jutsz a végére.
Bár lehet, hogy feleslegesen pötyögtem... csapd fel a tankönyvet a metódusnál és hajrá.
Persze a legjobb az lenne, ha az osztályok és metódusok után egy elegáns mozdulattal telepítené mindenki a junit-ot, és TDD-ben gyakorolnátok tovább. Mennyivel könnyebb lenne az immáron jól struktúrált kódon megtalálni a hibákat. És a refaktorálás is veszélytelenebb lenne. Szép álom.
Szia!
Valójában 3-400 soros programot kellene írni. Az első része az volt, hogy alkossunk egy feladat specifikációt, ami alapján elkészül a program. Extra dolgokat tudhat, viszont kevesebbet nem. Nos, kicsit nagyon elvetettem a sulykot a feladatspecifikacional. Így most tulajdonképpen iszom a levét.Jézus, mennyit írtál!
köszönöm szépen
Sajnos ez nekem még mindig nagyon magasÉs tankonyvunk sincs. Semmit nem írt ki az oktatási minisztérium. Egy füzetbe jegyzetelunk és kész.
WonderCSabo: ha format left vagy right-tal kiiratod, akkor sincs elcsúszva a felső sor?
-
norbert1998
nagyúr
Töltsd fel a forrásfájlt valahova, változatlanul.
[link]
A mappában az adatok txt lesz az. Küldöm az egészet, hátha mész valamira. Úgyis csak 32 KB. -
norbert1998
nagyúr
Metódus-t meg nem lehet máshogy hívni Javában:
pulic class Main {
public static void main(String[] args) { // a main egy metódus
}
public String masikMetodus() { // masikMetodus egy másik metódus
return null;
}
} -
norbert1998
nagyúr
Új metódusok írását se tanultátok?
Szerk: Ezek szerint nem... Mondd meg a tanárnak, hogy ilyen komplex feladat (már ha az tényleg) megoldásához biztosítsa a megfelelő eszköztárat.
-
norbert1998
nagyúr
Értettem. Ha minden igaz, itt van:
[link]És mégis hogyan bontsak szét egy majd 1000 sort is hamarosan elérő switch case-t? Mondtam már. Osztályok nincsenek, nem tanultuk őket.
Közelebb kerültem ismét a megoldáshoz. Mégis a beolvasással lehet valami. A legelső beolvasott tömbelem (azaz a példában az első sor Bukfenc-e) egy nem látható karakterrel rövidebb, mint a többi tömb elem(e).
A szöveg BOM nélküli UTF-8-ba van formázva, txt fájl, és ahogy fent látható, szóközök nélkül pontosvesszők választják el őket.
gygabor88: És az mi és hogy?
-
norbert1998
nagyúr
-
norbert1998
nagyúr
Megkerestem a kerettanterveket. Ahogy írtad szakos osztály vagytok, szóval a szakközépiskolai kerettanterveket töltöttem le. Ahogy leszűrtem te most 10-es lehetsz (2 év múlva érettségin miatt). Szóval a 10-es tantervet néztem ami két ágazatra szakosodott. Az egyik a programozó másik hálózatos, ahogy én értelmeztem. A programozói szakágon van az algoritmusok és adatszerkezetek valamilyen algoritmusleíró nyelven míg a másikon ugyan ezen a helyen a hálózati kommunikációk. Szóval nem nagyon van meghatározva. Amúgy annak idején 10-ben nekünk C++-t tanítottak, szóval elég régóta van már ez a rendszer. A lényeg az, hogy érettségin a kód működését illetve a felépítését ellenőrzik okos emberek, ugyanis emelt érettségit jobb esetben kijelölt iskolában végzed ahol hozzáértő emberek ellenőrzik. Ha korszerűbben oldod meg mint ahogy amúgy tanultad nem fognak megbuktatni.
Értem, köszi
Most megint lehet én vagyok hülye, de egyszerűen nem jut eszembe, hogy lehetne megoldani.
Adott egy pár elemes tömb, ami egész számokat tartalmaz. Kéne egy ciklus, ami megnézi, hogy a bevitt int-et (pl. 5-öt) tartalmazza-e a tömb. Ha nem tartalmazza, akkor írja ki, hogy ... és kérje be újra a változót, amíg nem lesz egyenlő a tömb valamelyik elemével. -
norbert1998
nagyúr
És a kerettantervben mi van? Az, hogy gyakoroltatni kell a ciklusokat és a tömbök használatát is, és most épp ott tartotok? Csak mert mint előbb írtam - szerkesztettem a hsz.-t közben -, ezekre ennél SOKKAL értelmesebb és használhatóbb példákat is ki lehetne találni, hogy megértsétek a használatát, meg hogy mire jó. Nagyon nem erre, amit mutattál.
És attól még, mert gyakorlatiasabb példákat vesztek, nem lenne muszáj eltérni a kerettantervtől. Most itt az infós kerettantervet fikázzuk, de még nem említette senki, hogy pontosan mi is van benne, ami szar (nekem most nincs kedvem rákeresni) - biztos egyébként bőven van miért szidni sok tekintetben, de nem ártana némi konkrét információval felvértezve fikázni. 
Amúgy most akkor hogyan is alakítgattad a kódodat, ami nem működik? És akkor most mi a gond, hogy nem írja ki az első elemet? Kicsit nekem már zagyva a leírásod.
Én nem ismerem, a tanárOK mondják, hogy rémes a kerettanterv
Szóval, annyit javult a helyzet, hogy most ha a gazda neve, kor vagy tömeg alapján keresek, akkor tökéletes, viszont ha név alapján, akkor a név tömb első elemét valamiért ignorálja. Az egész beolvasás procedúra tulajdonképpen ugyanaz az összes tömbnél, továbbá ha csak szimplán kiiratom azt a tömbelemet, akkor ott van rendesen, hogy Füsti (vagy akármi, amit beviszek arra az elemre), de a kereséskor nem találja.
Itt a kód(try catch-ben van, de azt most nem keresem meg, hol a vége-eleje, de nincs azzal gond)
Így azt hiszem, egy az egyben be is másolhatváltozók megadásával) futtatható is//változók
int fomenu, kilepes=0;
int bevitel,torles,rendezes,szures,mentes,elvet,kilep;
int bevkeres,torkeres, szurkor,szurtt;
int mod;
//beolvasas
BufferedReader br=new BufferedReader(new FileReader("adatok.txt"));
String sor;
int n=500;
String [] nev =new String [n];
String [] gazdnev =new String [n];
String [] tomeg =new String [n];
String [] kor =new String [n];
int olvastomb=0;
while((sor=br.readLine())!=null){
nev[olvastomb]=(sor.substring(0, sor.indexOf(";")));
sor=sor.substring(sor.indexOf(";")+1);
gazdnev[olvastomb]=(sor.substring(0,sor.indexOf(";")));
sor=sor.substring(sor.indexOf(";")+1);
tomeg[olvastomb]=(sor.substring(0, sor.indexOf(";")));
sor=sor.substring(sor.indexOf(";")+1);
kor[olvastomb]=sor;
olvastomb++;
}
//problémás részlet
try{
int []modvalogatas=new int[n];
int db=-1;
int i=0;
do{
i=0;
System.out.println(BLUE+"MEGLÉVŐ ÁLLAT ADATAINAK MÓDOSÍTÁSA MENÜ"+RESET);
System.out.println("Mi alapján szeretnénk kiválasztani a módosítandó tulajdonságú állatot?");
System.out.println("1-Név alapján");
System.out.println("2-Gazdája neve alapján");
System.out.println("3-Kor alapján");
System.out.println("4-Testtömege alapján");
System.out.println("5-Mégsem");
System.out.println();
bevkeres=extra.Console.readInt("Melyik menüpontot választja? ");
switch(bevkeres){
case 1 : {
String kereses=extra.Console.readLine("Milyen nevet keressünk?");
db=0;
i=0;
while(nev[i++]!=null){
}
for (int g=0;g<i;g++){
if (kereses.equals(nev [g])){
modvalogatas[db]=g;
db++;
}
}
break;
}
case 2 : {//főmenü 1-es menüpont->2-es menüpont
String kereses=extra.Console.readLine("Mi a gazda neve?");
db=0;
i=0;
while(gazdnev[i++]!=null){
}
for (int g=0;g<i;g++){
if (kereses.equals(gazdnev[g])){
modvalogatas[db]=g;
db++;
}
}
break;
}
case 3 : { //főmenü 1-es menüpont->2-es menüpont
String kereses=extra.Console.readLine("Milyen korút keressünk?");
db=0;
i=0;
while(kor[i++]!=null){
}
for (int g=0;g<i;g++){
if (kereses.equals(kor [g])){
modvalogatas[db]=g;
db++;
}
}
break;
}
case 4 : {//főmenü 1-es menüpont->2-es menüpont
String kereses=extra.Console.readLine("Milyen tömegűt keressünk?");
db=0;
i=0;
while(tomeg[i++]!=null){
}
for (int g=0;g<i;g++){
if (kereses.equals(tomeg [g])){
modvalogatas[db]=g;
db++;
}
}
break;
}
case 5: { //főmenü 1-es menüpont->2-es menüpont
break;
}
default: { //főmenü 1-es menüpont->2-es menüpont
System.out.println(RED+"Hibás értéket adott meg."+RESET);
}
}
try{ //főmenü 1-es menüpont->2-es menüpont
if(db!=0){
System.out.println(nev[0]+gazdnev[0]+tomeg[0]+kor[0]);
System.out.println("Az alábbi találat(ok) keletkeztek. ");
for (int j=0;j<db;j++){
System.out.println((modvalogatas[j])+"-"+nev[modvalogatas[j]]+";"+gazdnev[modvalogatas[j]]+";"+kor[modvalogatas[j]]+"év;"+tomeg[modvalogatas[j]]);
}
int modos=extra.Console.readInt("Melyik állatot kívánja módosítani a fentiek közül?");
do{
System.out.println(BLUE+"ÁLLAT ADATÁNAK MÓDOSÍTÁSA MENÜ"+RESET);
System.out.println("1-Név módosítása");
System.out.println("2-Gazda nevének módosítása");
System.out.println("3-Testtömeg módosítása");
System.out.println("4-Kor módosítása");
System.out.println("5-Mégsem");
System.out.println();
mod=extra.Console.readInt("Melyik menüpontot választja?");
switch (mod){
case 1:{ //főmenü 1-es menüpont->2-es menüpont
nev[modos]=extra.Console.readLine("Mi az állat új neve?");
break;
}
case 2:{ //főmenü 1-es menüpont->2-es menüpont
gazdnev[modos]=extra.Console.readLine("Mi az új gazda neve?");
break;
}
case 3:{//főmenü 1-es menüpont->2-es menüpont
tomeg[modos]=String.valueOf(extra.Console.readInt("Mennyi az állat új tömege?"));
break;
}
case 4:{//főmenü 1-es menüpont->2-es menüpont
kor[modos]=String.valueOf(extra.Console.readInt("Mennyi idős az állat?"));
}
case 5:{//főmenü 1-es menüpont->2-es menüpont
break;
}
default: {//főmenü 1-es menüpont->2-es menüpont
System.out.println(RED+"Hibás értéket adott meg."+RESET);
}
}
} while(mod!=5);
}
else {
System.out.println("Nincs ilyen állat.");
}
System.out.println();
}catch(Exception e){
System.out.println(RED+"Hiba történt!: "+e.getMessage()+RESET);
}
}while(bevkeres!=5);
}catch(Exception e){
System.out.println(RED+"Hiba történt!: "+e.getMessage()+RESET);
}
break; -
norbert1998
nagyúr
"De miért a tanár a hülye, ha ez szerepel a kerettantervben? Csak nem mondhatja azt, hogy screw you és tanítaná azt, ami tényleg értelmes, aztán a hülye tanterv alapján felállított érettségin meg sorban megbukunk"
Az érettségin az ilyen C-szerű kódolást kérik számon Java-nyelven? Nagyon remélem, hogy nem. Ha meg nem, akkor a tanár hülye, hogy olyan szokásokat próbál belétek verni, amik ennél a programozási nyelvnél kifejezetten károsak, és ocsmánnyá teszik a kódot. Ha tényleg ilyet kérnek számon az érettségin is, akkor qrva nagy gáz van az ottani számonkéréssel is.Nem az van, hogy a tanár is most tanulgatja a Javát, és korábban más nyelvben programozott?
A ciklusok, tömbök gyakoroltatására létezne ezerszer értelmesebb és gyakorlatiasabb feladat is.(#7417): tehát akkor most mi is a kódod, ami nem működik?
-
norbert1998
nagyúr
Odáig tudtam elvinni, hogy a név tömb alapján fennáll, hogy a legelső elemet nem hajlnadó kiírni, de a kor, tömeg és gazda neve tömbbel tökéletesen működik, pedig egy az egyben copy paste, csak a műveleteknél a tömb nevét mondjuk nev-ről kor-ra írtam át.
És igen, a tömb tartalmazza azt az első elemet -
norbert1998
nagyúr
"Elhiszem, de manapság mit nem bonyolítanak agyon a NAT-ban?"
Ez nem bonyolítás, hanem egy nagy kupac gőzőlgő szar. A jelek szerint a tanárnak fogalma sincs a Javaról, én a helyedben - ha érdekel a programozás - akkor elkezdenék önállóan foglalkozni az témával, mert ebből legfeljebb egy rakat kiírtandó rossz reflex lesz, rendes tudás semmiképpen sem.
-
norbert1998
nagyúr
A problema az, hogy gyakorlatilag C64 BASIC-ben programoztok. Bar persze Javaban is lehet fix meretu tomboket hasznalni meg ezersoros methodokat irni, de ezek olyan dolgok, amiket egy rendes Java programozo csak nagyon kulonleges helyzetekben alkalmaz, ezeknek mar felsobb szinteken kellene elokerulniuk, semmikeppen sem kezdoknel.
-
norbert1998
nagyúr
Ezt a megoldást a tanár ajánlotta nektek? Mert ez borzalmas. Csináljatok egy Dog nevű osztályt, annak legyen név, gazda, tömeg, kor mezői, és rögtön elég egy tömbben tárolni. (Azt mondanám, hogy List-ben, de gondolom Collections még nem volt). Meg lehetne for ciklus while helyett, azt se vettétek még?
public class Dog {
public String name, owner, age, weight; // getter setter kéne, típus lehet szám, stb.
@Override
public String toString() {
return name + " " + owner + " " + age + " " + weight;
}
}
...
Dog[] dogs = new Dogs[500];
// read
int i = 0;
Dog dog = dogs[i];
while(dog != null) {
if (dog.name.equals(input)) {
System.out.println(dog);
}
dog = dogs[++i];
}Egyébként már a beolvasásnál el lehetne menteni, hány sor volt, és akkor lehetne addig menni a null ellenőrzés helyett.
Megelőztek.
Osztályok nem voltak még. Ez van a tantervben, mást nem nagyon lehet tenni. A tanár meg konkrétan elfoglaltabb, mint az igazgató és amellett cirka 15 osztálynak szakmai tanára, csak a mi osztályunknak 10 órát tart egy héten, szóval kiegészíteni a kerettantervet kicsit húzós lenne.
Azt hiszem, javult egy kicsit a helyzet, mostmár keres rendesen, de az első találatot még mindig nem írja ki
-
norbert1998
nagyúr
Ez így nagyon gáz.
Egyrészt ez a nullig keresés olyan, mintha C-ben programoznál, márpedig a Java nem C, itt vannak rendes containerek, tessék azokat rendesen használni iterátorral. Másrészt meg ahelyett, hogy csinálnál ezer tömböt (listát, akármit) csinálhatnál egyet, amibe classokat raksz, minek van név, gazdnév, tömeg meg hasonló fieldje.Hogy micsoda?
Nézd el, tök kezdő vagyok. És a többiek is.
Konkrétan úgy mi ezzel a gond? Miért nem működik? -
norbert1998
nagyúr
-
norbert1998
nagyúr
Jééézus....
-
norbert1998
nagyúr
Ezt nehezen hiszem el. Miért?
-
norbert1998
nagyúr
-
norbert1998
nagyúr
-
norbert1998
nagyúr
-
norbert1998
nagyúr
-
norbert1998
nagyúr
-
norbert1998
nagyúr
Asszem az ellen nem sokat tudsz tenni.
Marad az ANSI színezés, és azt a tanár is elfogadtta, mert megkérdeztem tőle, mit mond erre.
Köszi újra
-
norbert1998
nagyúr
Picit utánanéztem, és a javasolt flush-nek nem sok értelme van, mivel automatikusan megtörténik a flush. Legalábbis ha println-t használsz.
Vagy Neked az volt a bajod, hogy System.out és a System.err összekeveredett?
-
norbert1998
nagyúr
Most sikerült megnéznem, sajnos minden hogycsinalja, majd 6.-ban meg tudom kérdezni a tanártól.
Azt hiszem, az s számíthat valamit, hogy ciklusban van. -
norbert1998
nagyúr
A out-re is legyen flush.
-
norbert1998
nagyúr
-
norbert1998
nagyúr
Rendben, köszi
Kedden megkérdem a tanárt, hogy esetleg tud-e valamit, vagy hanyagoljam inkább az err-t. -
norbert1998
nagyúr
Bocs, benéztem, új sornál űríti a buffert.
Két különböző streamre írsz, csak egy ablakban látod, de a streamek feldolgozásának sorrendje nem garantált szvsz, pl IDEA vagy eclipse termináljában. Bevallom nem tudom, hogy garantált-e a sorrend, ha cmd-ből futtatod, de nem is nagyon használom a sysout/syserr párost, mindig valammi loggerrel mentünk fájlba kimenetet. -
norbert1998
nagyúr
-
norbert1998
nagyúr
-
norbert1998
nagyúr
Ez mondjuk az IDE consoljára nem biztos, hogy hatássas lesz. Rondábbnak tűnő, de platformfüggetlen megoldás jó sok új sort kiírni.
norbert1998: Ha System.err -re írsz System.out helyett azt remélhetőleg pirossal írja.
Áh, ez is jó lett, köszönöm
-
norbert1998
nagyúr
if os == windows {
Runtime.getRuntime.exec("cls");
} else if os == *nix {
Runtime.getRuntime.exec("clear");
} else {
Runtime.getRuntime.exec("akármi, ami konzolt töröl....");
}Amolyan pszeudóféleképpen
Köszi, holnap megnézem
-
norbert1998
nagyúr
Jobb gomb az Output ablakban, majd Clear, vagy nyomatsz egy Ctrl+L-t...
Olyanra gondoltam, amit a programkódba lehet írni, de akkor gondolom ilyen nincs. Mindegy, köszönöm
Olyan van esetleg, hogy amit oda kiír a NetBeans, azt vastgított vagy dőlt vagy valamilyen kiemelt betűvel tegye egy-egy sornál?
-
norbert1998
nagyúr
A konzol/terminál tartalmát szeretnéd törölni? Mert Windows-on az a cls bepötyögésével, majd Enterrel megoldható, Linuxnál a clear kulcsszóval.
(Már ha jól értettem a kérdésedet...)Hogy kell elképzelni ezt, hogy mindent konzolon csináltok? nano, mcedit (most ezek Linux-eszközök, de mindegy), vim (bár ezt kétlem), ilyesmik használatával szerkesztitek a kódot?
(#7288) floatr:
A Java-fejlesztőknek nem a hosszú távú támogatás jár a fejében? Ez így furán hangzik.
Bocsánat. NetBeans IDE
-
norbert1998
nagyúr
-
norbert1998
nagyúr
Teljesen érthető for-ciklusnál, de én még mindig foreach-ről beszélek, gondolom majd azt is fogjátok tanulni.
-
norbert1998
nagyúr
Akkor ha bármilyen negatív dolog lenne ezzel kapcsolatban.
Ugyanazt javasolta, mint ti. Extra. Console. Readint. [és ezt rendesen formázva, csak buta a t9]
Sk8erPeter: azért kéri így, hogy megtanuljuk a for, while és do-while ciklusokat használni.
Tényleg lehet break-kel kocolni, alairom, csak az adott esetben teljesen működőképes volt.
Köszönöm a segítséget
-
norbert1998
nagyúr
Ne viccelj, ha emiatt levonnak a megoldásodból, akkor hagyd ott azt az intézményt...
-
norbert1998
nagyúr
-
norbert1998
nagyúr
-
norbert1998
nagyúr
Új hozzászólás Aktív témák
A topicot kiemeltem. Valaki nem akar egy nyitó hsz-t írni?:))
- Okos otthon - Home Assistant, openHAB és más nyílt rendszerek
- Új Intel CPU-kkal jön a Surface Pro 12 és a Surface Laptop 8 for Business
- Digitális Állampolgárság Program DÁP
- Mibe tegyem a megtakarításaimat?
- Nem kell még temetni: 2 éves órajelcsúcsot döntöttek meg Raptor Lake-kel
- Asustor NAS
- Yettel topik
- Mesterséges intelligencia topik
- Audi, Cupra, Seat, Skoda, Volkswagen topik
- Villanyszerelés
- További aktív témák...
- Legújabb Thinkpad T14 gen6 - Bontatlan + magyar! - Core Ultra 7 255U - 16/32GB - 512GB - Gyártói gar
- Fujitsu 27" B27-9 TE Full HD 1920x1080 hófehér monitor - több db - gari számla - állítható magasság
- Kingston HyperX és FURY 16Gb (20-22k) és 32GB DDR4 (47k) laptop ramok párban is 2666Mhz/3200Mhz
- Lenovo Thinkpad T14s gen 6 - Teljesen új - Ryzen AI 7 PRO 350 - 32GB - 512GB - 2028 októberig gari!
- új, de karcos Lenovo ThinkCentre Neo 50t // Core i7 12700 // 16GB DDR4// 512GB
- Samsung Galaxy S23 FE 128GB,Újszerű,Dobozaval,12 hónap garanciával
- Xiaomi Pad 7 Pro 256GB, Wi-fi, 1 Év Garanciával
- NAGYKER ÁR!Sosemhasznált! HP OmniBook 5 Flip i5-1334U 8GB 512GB 14" FHD+ áthajtós-érintős Gar.: 1 év
- Apple iPhone 15 128GB Blue Karcmentes 100% akkumulátorral
- Apple iPhone SE 2020 128 GB Fehér 1 év Garancia Beszámítás Házhozszállítás
Állásajánlatok
Cég: Laptopműhely Bt.
Város: Budapest