Nem biztos, hogy jó lesz, nem teljesen értem, hogy mit akarsz. Egyébként Object-et típusparaméternek nem sok értelme van megadni, legalábbis ebben az esetben semmi.

Ha Object-et adsz meg típusparaméternek, akkor bármilyen objektumot berakhatsz a konténerbe. Pl.

Vector<Object> vector = new Vector();
vector.add(new String());
Integer integer = (Integer) vector.get(0);

Az utolsó sor fordítási időben teljesen legális kód, de ClassCastException-nel jár, hiszen a String nem Integer. A vicc az, hogy a generic-et pont arra találták ki, hogy ezt a problémát kiküszöbölje, Te pedig arra akarod használni, hogy mégis probléma lehessen belőle...

[ Szerkesztve ]

Nos, röviden azt szeretném, hogy letároljam egy termék (pl valamilyen gyümölcs) nevét, és az adott termék két tulajdonságát (ár és, hogy mennyi van belőle).

Erre írtam egy termek nevű osztályt, ahol az adott árura vonatkozó metódusok vannak. (nevének a lekérdezése, árának a lekérdezése stb.)
És írtam egy másik, Raktar osztályt, ahol deklaráltam a vektoromat és hozzá szeretném adni a vektorhoz a három adatot. (áru neve, ára, és a mennyisége)

10 féle ember van: aki ismeri a bináris számrendszert, és aki nem

Igen, és előbb jött erre az a válasz, hogy a termék nevét is vedd bele a termek osztályba (Java osztály nagybetűvel kezdődjön BTW). Így a Vector-od típusparamétere pedig lehet termek.

Ha pedig mindenképpen úgy érzed, hogy a termék neve nem tartozik bele a termek osztályba, akkor használhatsz egy Map<String, Termek> konténert, ami névből - termek asszociációkat tartalmaz.

És ez így is van.

class Termek{
private String nev;
private double ar;
private double menny;

public Zoldseg(String nev, double ar) {
this.nev = nev;
this.ar = ar;
menny = 0.0;
}

public String getNev() {
return nev;
}

public double getAr() {
return ar;
}

public double getMenny() {
return menny;
}

public void setMenny(double menny) {
menny += menny;
}

}

public class Raktar {
Vector<String> aru = new Vector<String>();

public void felvitel() {
String nev = Console.readLine("Kérem adja meg az áru nevét: ");
Termek aru = new Temek(nev, 0.0);
if (zoldsegek.contains(aru)) {
System.out.println("Az áru már létezik!");
return;
}
double ar = Console.readDouble("Adja meg az áruárát: ");
double menny = Console.readDouble("Adja meg az áru mennyiségét (kg): ");
aru.add(new Termek(nev, ar));
}

A Termek osztály még nincs kész és valszeg nem is jó.

10 féle ember van: aki ismeri a bináris számrendszert, és aki nem

Itt eléggé nagy kavar van.

A Vector<String> aru példányváltozót elfedi a lokális Termek aru - ez bár legális, nem éppen okos döntés. Valamelyiket mindenképpen nevezd át, az elsőnek van rossz neve mellesleg.

A zoldsegek Vector hol van definiálva?

Termek aru = new Temek(nev, 0.0);
if (zoldsegek.contains(aru)) {

Ez itt mindig false-ot fog visszaadni, mivel a contains az equals metódust hívja meg, ami pedig alapesetben a referenciákat hasonlítja össze, azok pedig sosem fognak egyezni, hiszen mindig új objektumot hozol létre. Definiáld felül az equals és hashCode metódust a Termek osztályban, hogy ez értelmesen működjön.

A Vector<String> aru típusparamétere miért nem Termek?

Console.readLine

Csak kíváncsiságból kérdezem: ezt az osztályt milyen framework szolgáltatja?

[ Szerkesztve ]

Én ezt így csinálnám.

http://pastebin.com/0pWx7sH7

Nyílván csinálhatnál ekkor a gyümölcsöknek is egy külön osztályt. De akár az is játszik, hogy nem csinálsz egy külön interface-t, hanem pl a Zöldséget a Termék osztályból származtatod, mint ahogy a Gyümölcsöt is.
Ez sem egy világbajnok kód, de szerintem annál amit csináltál jobb

[ Szerkesztve ]

Ráadásul a termék osztálynak nem igazán lehet Zoldseg konstruktora.

Hops, a zöldségek egy régebbi állapotból maradt meg és úgy látszik azt elmulasztottam átírni.

Valahonnan szedett a haverom egy extra nevű csomagot és abban van konzol osztály, így az működik.

@modder: dehogy!

[ Szerkesztve ]

10 féle ember van: aki ismeri a bináris számrendszert, és aki nem

Az equals és a hashCode felüldefiniálása nélkül ez se fog menni.

A menny += menny csak nekem tűnt fel?

Mindenesetre eddig ez elég FUBAR, szerintem lassítanod kéne egy kicsit és két dolgot mindenképp megejteni: kicsit végiggondolni hogy ki kivel van, és némi konvenciót is kéne találnod a tagváltozókban (vagy kiírni a this-t, mert így a settereid nem sokat csinálnak.

WonderCsabo: a += -re gondoltam explicite

[ Szerkesztve ]

“All nothings are not equal.”

Igen, bár az aru kapcsán már én is felhívtam erre a problémára a figyelmet.

Arra írtam, hogy igen, az csak Neked tűnt fel.

Azzal meg mi baj van?
Mármint a +=-vel.

10 féle ember van: aki ismeri a bináris számrendszert, és aki nem

Az, hogy amikor ezt írod, hogy

public void setMenny(double menny) {
menny += menny;
}

Akkor a paraméterben kapott menny változó értékét növeled meg, és nem a példányváltozóét. A lokális változó mindig elfedi a tagváltozót. Úgy tudsz ilyen esetben a tagváltozóra hivatkozni, hogy:

public void setMenny(double menny) {
this.menny += menny;
}

A másik opció, hogy átnevezed a paramétert. Tényleg el kéne olvasnod valami alap Java könyvet, vagy vmi tutorialt végigcsinálni. De egyébként ez a jelenség más nyelveken is így vna.

[ Szerkesztve ]

Ja, az direkt van úgy.

10 féle ember van: aki ismeri a bináris számrendszert, és aki nem

De ennek semmi értelme! A függvény lefutása után a lokális változó felszabadul, és a növelt érték megy a kukába... Gondolom itt azt akartad elérni, hogy az osztály által reprezentált áru mennyisége változzon meg, nem?... Mert arra a jelenlegi függvényed nincs hatással.

[ Szerkesztve ]

A másik baj amellett, hogy a mennyiség mindig nulla marad az előzőek miatt az az, hogy úgy nevezted el a metódust, hogy "set". Ez azt jelenti mindenki más számára, hogy a paraméterben megadott szám lesz az új érték, nem pedig megnöveled azzal

“All nothings are not equal.”

Vanni van, bár olyan sok tapasztalatom nincs velük. A FindBugs például egy ingyenes eszköz ilyesmire, be lehet iktatni a build folyamatba is.

“All nothings are not equal.”

Szerintem az encryption-ra gondolt.

Igen, jól látod, hogy az áru mennyiségét akarom azzal változtatni.
De mint mondtam, az direkt van úgy, mivel mást kellett csinálnom, így a bemásolás pillanatáig nem írtam áát.

10 féle ember van: aki ismeri a bináris számrendszert, és aki nem

Azért a "direkt van így", az elég erős kifejezés akkor...

Na igen!

10 féle ember van: aki ismeri a bináris számrendszert, és aki nem

Sziasztok!

Elnézéseteket kérem, hogy itt teszem fel a kérdésem, de ennél jobb helyet nem találtam hirtelen és nagyon sürgős lenne a dolog.
A következő hibára tudtok valamilyen megoldást? Semmilyen nyomtatványt nem lehet a NAV kitöltőprogramjához telepíteni (több gépen is próbáltam). Vannak keresési találatok a hibára, de ebben az esetben szerintem a külföldi leírásokkal nem sokra megyek.

Előre is köszönöm!

[ Szerkesztve ]

Én nem látok hibát, csak egy figyelmeztetést a szoftver aláírásáról. Ha Runt nyomsz az első ablakban, akkor mennie kéne tovább.

“All nothings are not equal.”

Hát sajnos semmilyen nyomtatvány nem megy fel, ezt dobja fel:

Én úgy értelmeztem, hogy a tanusítvány hibája miatt nem fog menni.

[ Szerkesztve ]

configure java -t indítsd el
security fülnél add az exceptionlistához a címet
(amit utoljára küldtél képet ott amit a locationnál ír)

Köszönöm a tippet, a javaslat nem hozott eredményt, de rávezettél, mert mellette lejjebb vettem a biztonsági szintet és így engedte a telepítést!

Akkor hadd szóljak ki egy kicsit az enterspájzból én is. Ha egy metódusnak a neve "set...", de nem értéket állít be, hanem összead, akkor -- még ha azt is csinálná, amit kellene -- egy kód review-nál fognak hátba vágni. Másrészt meg sokak számára fájó pont, de célszerű legalább az elnevezések esetében angolt használni. Ha egy végzős egyemistát bedobnak a mély vízbe, nagy eséllyel kerülhet olyan projektbe, ami külföldi kooperációban készül.

De ha a konkrét példánál maradunk, akkor sokkal hatékonyabb lenne egy Map-be tárolni, és kulcs (név) alapján keresni, vagy Set-be pakolni, és hashCode/equals metódusokat használni. Ha ez valami oktatáshoz kötődik, akkor nem értem, hogy miért nem lehet életszerűbb példákon keresztül oktatni.

Egy raktár programban, ami új termékek felvételéből, számlázásából, pótlásából áll mi nem életszerű?

10 féle ember van: aki ismeri a bináris számrendszert, és aki nem

Ha a cél a Vector használata, akkor nem életszerű.
Az ilyen nyilvántartásokat Map vagy Set használatával sokkal egyszerűbb, és gyorsabb is kezelni. Ha rendezési elv is van mögötte, akkor vannak rendezhető Map-ek is. Nem véletlen, hogy általában adatbázist is raknak mögé.

Sziasztok, miért van az, hogy ez helyes:

public class RaktarV extends ArrayList<Termek> { }

ugye ez ha minden igaz azt, jelenti, hogy a RaktarV egy objektuma egy olyan ArrayList-et valósít meg ami Termek tipusú elemeket tárolhat.

de ez már helytelen:

public class RaktarV extends ArrayList<T extends Termek> { }
helyette ez a helyes
public class Raktar<T extends Termek> extends ArrayList<T> { }

a kérdés csak annyi lenne, hogy akkor utóbbi esetben máshogyan kell szintaktikailag jelenzni és kész, vagy van valami más különbség is?

Ugye a második esetben a Raktar egy objektuma egy olyan ArrayListet valósít meg ami Termek, vagy Termek subclass tipusu elemeket tárolhat.

Nekem az nem világos, hogy miért nem így kell ezt is megadni:
public class RaktarV extends ArrayList<T extends Termek> { }

?

üdv

public class RaktarV extends ArrayList<T extends Termek> { }

Ez semmiképpen nem lehet helyes, hiszen a T típust sehol sem deklaráltad.

Ebben az esetben nincs típusparamétere az osztálynak:

public class RaktarV extends ArrayList<Termek> { }

Ebben az esetben meg van:

public class Raktar<T extends Termek> extends ArrayList<T> { }

Mig az első esetben a RaktarV-be bármilyen Termek leszármazottat lehet rakni, a típusparaméteres verzióban csak az aktuális típusparamétert, vagy annak leszármazottjait, pl.

RaktarV<Gyumolcs> raktar;
raktar.add(new Termek()); // nem fordul

[ Szerkesztve ]

Miért a helyes esetben a T-t hol deklaráltam?

public class Raktar<T extends Termek> extends ArrayList<T> { }

aha, akkor azt a különbséget már értem, hogy ha
ArrayList<Termek> -ként hozom létre az osztályt, akkor ebbe mehet Termek, és Termek leszármazott, a másik tipusparaméteres esetben pedig a typus argumentumtól függ, hogy mi mehet bele, tehát
RaktarV<T extends Termek> extends ArrayList<T> esetén ha olyat írok hogy
RaktarV<Gyumolcs> = new ...
akkor Csak Gyumolcs és annak leszármazottai mehetnek bele, de Termek mar nem, csak ugy ha a tipus-argumentum az Termek ->
RaktarV<Termek> = new ...

De azt továbbra sem értem, hogy ezt miért így kell szintaktikailag létrehozni Bár lehet ezen feleslegesen pörgök, jegyezzem meg 'oszt kész ^^

[ Szerkesztve ]

A RaktarV-nek deklaráltál egy típusparamétert, ott. Egyébként bővítettem a hszemet. Javaslom olvasd el a Java genericset.

public class Raktar<T extends Termek>

[ Szerkesztve ]

Az új osztály definíciójánál az ősosztály paraméteres. Vagy konkretizálod, hogy mi a paraméter, vagy hagyod eredeti formájában. A paraméterre vonatkozó megszorítást (Termek) csak az éppen definiált osztálynál tehetsz. Ez a megszorítás annyit tesz, hogy a fordító csak olyan Raktar objektumot enged létrehozni, aminek a paramétere Termek típusú, vagy annak leszármazottja. Ha Gyumolcs paraméterrel hozod létre, akkor onnantól kezdve már nem adhatsz hozzá bármilyen Termek leszármazottat, csak ami a Gyumolcs-ből ered.

Ha pl a Kifli is termék (de ugyebár nem Gyumolcs), akkor ez nem fog fordulni:

new Raktar<Gyumolcs>().add(new Kifli());

mert ez egy "gyümölcsraktár" példány, ahová kiflit nem lehet raktározni

szerk.:
a paraméteres leszármaztatásnál vagy az osztály definíciójakor szabod meg, hogy mi a paraméter, vagy az osztály is paraméteres lesz. Ha paraméteresen hagyod, akkor megmondhatod, hogy milyen ősosztályból lehet paraméter használni, amikor az osztályt létrehozod. A megszorítást meg azért az új osztálynál kell bevésni, mert arra vonatkozik a megszorításod, nem az ősosztályra.

[ Szerkesztve ]

Köszönöm a válaszokat, közben sikerült megtalálnom a választ, az egyik könyvemben, ahol kb az van leírva amit te is leírtál

Tudtok mondani valami legegyszerűbb ingyenes tool-t amivel UI mockupokat tudok rajzolgatni?
Valamit, ami bevált.

Kösz

Esetleg: [link]

Igen, ez kell nekem, köszi

[ Szerkesztve ]

Sziasztok!

A cégnél ahol dolgozom van egy elég kokány Java-ban írt mentéskészítő alkalmazásunk. Arra gondoltam, hogy teljesen újraírnám, mert néha furcsán viselkedik. Tanultam főiskolán Java programozást, így az alapok meg vannak és tényleg nem bonyolult. Viszont pár dologban a segítségeteket szeretném kérni.

Amit tudni kell:

NetBeans 7.4-et használok
7-es Java-val.

A program az alábbiakat tudja:

Van egy grafikus felület. Rajta egy információs sor, ahol megjelenik az utolsó mentés dátuma, illetve a mentés hosszának ideje. Ezen kívül egy gomb van még Mentés felirattal. A gomb megnyomásakor ellenőrzi, hogy meg vannak-e a szerveren a mentendő fájlok (/home/server/mentendok), be van-e dugva a mentéshez használatos külső merevlemez (dev/eszkozneve). Ha minden oké, akkor felcsatolja a lemezt, a /mnt/mentes-disk alá. Majd elkezdi másolni az adatbázis fájlokat, ebből 4 van. Ha ezzel végzett akkor van egy pdf nevű mappa, amiben körülbelül 10 ezer kisebb fájl van. Ezeket is elkezdi másolni, viszont ha már meg van akkor kihagyja. Ha végzett, akkor lecsatolja a merevlemezt, frissíti az ablakon lévő információkat (utolsó mentés, mentés hossza).

Szóval ezt kellene megírni. Ti merre indulnátok el? Mit használnátok lemez csatoláshoz és lecsatoláshoz Linux alatt?