Mi lehet az oka annak, hogy a java.exe nem találja meg a lefordított .class állományt, holott a path rendben van?
[kép]

Sok állítgatás után, most működik. De hogy mi volt a baja ...

Ha elmondod, hogy konkrétan miket állítgattál, akkor talán meg tudnánk mondani, hogy mi lehetett a probléma

MI 10T Pro 8/256 , Arsenal FC - Go Gunnarz...

Sziasztok!
Teljesen kezdőként szeretnék megtanulni java-ban programozni. Melyik könyvből érdemes elkezdeni?
Az Angster Erzsébet féle Objektumorienttált tervezés és programozást és a Tanuljuk Meg a Java Programozási Nyelvet 24 Óra Alatt könyveket ajánlgatják több helyen.
Ezek a mai napig megállják a helyüket?

"Az igaz, hogy a kemény munka még senkit sem ölt meg, de minek kockáztasson az ember?" - Ronald Reagan

Szerintem a 24 órás könyvek sose állták meg a helyüket.
Akkor már inkább a Head First/Agyhullám könyvnek járj utána.

“All nothings are not equal.”

Megnéztem az Agyhullámot. Egyből az elején azt írja, hogy kell hozzá prgramozói alap.

"Az igaz, hogy a kemény munka még senkit sem ölt meg, de minek kockáztasson az ember?" - Ronald Reagan

Programozói alap nélkül nem fog menni a Java. És semmi más sem. Neked nem Java alapok, hanem programozói alapok kellenek első körben.

[ Szerkesztve ]

MI 10T Pro 8/256 , Arsenal FC - Go Gunnarz...

Szerintem próbálj meg belekezdeni, ne habozz! Aztán majd kiderül, hogy megy.

Hát nem túl valószínű.

MI 10T Pro 8/256 , Arsenal FC - Go Gunnarz...

Szerintem igen.

2:1 arányban győzött a meg lehet tanulni tábor
El is kezdtem olvasni. Egyelőre elég szájbarágósnak tűnik. Remélem ez így is marad.

"Az igaz, hogy a kemény munka még senkit sem ölt meg, de minek kockáztasson az ember?" - Ronald Reagan

Kb ezek:
szekvencia, szelekció, iteráció
alapvető adattípusok és struktúrák
összetett adatszerkezetek
programozási tételek, algoritmusok
objektum-orientált paradigma

Valamint személyes meggyőződésem hogy ezzel párhuzamosan a számítógép architektúrákat és operációs rendszereket is megfelelő ütemben, összhangban kell tanulni (és oprendszer tantárgy alatt nem a windows grafikus felületének kezelésére gondolok.)

[ Szerkesztve ]

"Nem gond ha nem vágod a párologtatók bináris nyelvét..."

Pffff. Ezt remélem, nem komolyan írtad. A programozás, sőt manapság alkalmazás fejlesztés nem csupán for/while/if dolgokból áll. Adatbázis kezelés, hálózatok, szálak...hogy pár apróságot említsek. Paradigmák, tervezési minták és társai. Hogy a matematikai és egyéb elméleti alapokról ne is beszéljek....adatbázis elmélet, számítógép és távközlési alapok, protokollok, digitális technika, boole algebra, mátrixok, numerikus módszerek, számítástudományi alapok...hogy csak kapásból említsek pár dolgot. Ezt nem fogja a kolléga java tutoriálból kimazsolázni.

[ Szerkesztve ]

MI 10T Pro 8/256 , Arsenal FC - Go Gunnarz...

Persze, neki lehet menni, de nagyon a favágó szintről elmozdulni nem lehet.

MI 10T Pro 8/256 , Arsenal FC - Go Gunnarz...

A mondanivaló hangsúlya nem az oop-n volt. Pár, fontosabb dolgot is odaírtam. Bool algebrával szopatni magam? Ember, ez mindennek az alfája és omegája. Hogy akarsz ennélkül pl. if/else szerkezetet írni?

[ Szerkesztve ]

MI 10T Pro 8/256 , Arsenal FC - Go Gunnarz...

Nyilván kell egy eszköz amin keresztül gyakorlatban is ki lehet próbálni az elméletet. Erre viszont semmiképp sem egy java féle környezetet javaslok.
Éppen ezért írtam azt hogy kell hozzá az architekturák és oprendszerek megfelelő összhangban történő tanulása.
pl miért és hogyan történik egy program indítása. hogyan történik a különféle adatok tárolása a memóriában. ahhoz hogyan fér hozzá a processzor. hogyan készül egy olyan program ami képes a memóriába betöltődni, majd ott elindulni és különféle utasítások végrehajtása kapcsán egy konkrét feladatot elvégezni....

Szóval a java-ig meg az első osztály leírásáig el kell telni egy kis időnek ha valaki teljesen nulláról kezdi.

nyilván lehet úgy is tanulni hogy elindítja az ember a mindenféle okosságokkal felruházott IDE-t és ír benne java-ban vagy bármi más nyelvben programot, közben megtanulva a szekvencia-szelekció-iteráció egységeket alkalmazni. De az hogy közben mi és hogyan máködteti a magas szinten megírt programot ha valaki nem érti, nem látja át akkor ahogy alább írták, csak favágás lesz belőle.

Egy autószerelőnek ismernie kell az autók általános felépítését és működését a lehető legaprólékosabban. Ha nem ismeri akkor nem lesz jó autószerelő. Ki fogja tudni cserélni a gyertyákat, meg be fogja tudni állítani a gyújtást, de ez nem azt jelenti hogy érti is amit csinál. Kb ez a helyzet a programozással is.

Szóval érdemes az alapokat minél jobban megismerni, kár kihagyni ezeket a lépéseket.

"Nem gond ha nem vágod a párologtatók bináris nyelvét..."

Persze, programozni manapság nem olyan nehéz feladat

MI 10T Pro 8/256 , Arsenal FC - Go Gunnarz...

Álláshirdetéseket hol érdemes nézegetni?
Profession?

Gonosz

Erre poénból rákerestem, és lám: [link]

Thank you to god for making me an atheist

Ilyen is van

MI 10T Pro 8/256 , Arsenal FC - Go Gunnarz...

Szerintem meg Kellően erős érdeklődéssel, lelkesedéssel és sok szorgalommal mindent lehet.

Ez nagyon jó

[ Szerkesztve ]

Ez a Java jegyzet jó lehet kezdésnek. (Bár régi)

Sziasztok!

Segítségeteket szeretném kérni, mert én már belegabalyodtam! Több szem többet lát.

A hibát is látjátok! Miért csinálja ezt, hogy nem csak a második legkissebb elemet írja ki? Többet is kiír , és mindig más más mennyiségben.

Segítségeteket előre is köszönöm!

A Nő nem ember, a Sör nem alkohol, a Medve nem játék!

A for ciklus kapcsai hol vannak?

A for ciklusnak nincsenek kapcsi tehát a teljes if tartozik hozzá. A system.out.println is.
A system.out sor elé kellene az ifet záró } jel es nem utána.
Egy javaslatom had legyen. az ékezetes betűket próbald hanyagolni az azonosítókban.

[ Szerkesztve ]

"Nem gond ha nem vágod a párologtatók bináris nyelvét..."

En elsosorban az identalast tennem helyre, mert az egy dolog hogy a zarojeleket elrontja valaki, de igy baromira nem is latszik a kodbol, hogy mit hova szant. A for-on beluli elso teljes if egy tab-bal bentebb kene legyen.
A tobbivel egyetertek, ekezet es a magyar ugy altalaban elhagyasaval kapcsolatban is, csak szerintem mind a kettot meg kene elozze, hogy a programozo szandeka vilagos legyen a kodbol. (Meg szerintem ha ez rendben van, akkor mar mechanikusan a zarojelpar highlight segitsegevel ellenorizheto, hogy ki hol van bezarva, es az ott jo helyen van-e.)

[ Szerkesztve ]

egyetértek veled!
Egyébként én magam kiteszem mindig a { } jeleket, még akkor is ha csak egyetlen utasítás van az adott blokkban (mint pl itt az if szerkezet).
Valahogy így:

for(int i=0;i<MAX; i++) {
if (i>MIN) {
System.out.println("Alma");
} else {
System.out.println("Körte");
}
}

"Nem gond ha nem vágod a párologtatók bináris nyelvét..."

Tudom ajánlani a Google Java Style Guide-ot, szerintem korrekt. Jelenlegi projekten is ezt használjuk, annyi változtatással, hogy a sorszélesség 100 helyett 120.

(#9088) donathl
Ha kódot raksz be, akkor ne képként légyszi. Amúgy neked pláne ajánlom a linket. Könnyezik a szemem ezektől az ékezetes magyar nevektől

“Yeah, well, you know, that’s just, like, your opinion, man.” — The Dude

Sziasztok!

Köszönöm szépen a segítségeteket, hozzászólásokat! Megoldódott a zárójelezéssel.
Köszönöm a Google Java linket, és a változókra és tab-ra figyelni fogok ezek után. Nekem ezek hasznos tanácsok, mivel még csak ismerkedek a Java nyelv rejtelmeivel.

A Nő nem ember, a Sör nem alkohol, a Medve nem játék!

Sziasztok!

Ismét segítségeteket kérném.

Van egy pont osztályom:

public class Point{
private int x;
private int y;

public Point(int x, int y){
this.x = x;
this.y= y;
}

public int getX(){
return this.x;
}

public int getY(){
return this.y;
}

public boolean equals(Object other){
Point otherPoint = (Point) other;
return getX() == otherPoint.getX() && getY() == otherPoint.getY();
}

public double getDistance(Point other){
return Math.sqrt( Math.pow(getX() - other.getX(), 2) + Math.pow(getY() - other.getY(), 2));
}

public String toString(){
return "(" + getX() +", " + getY() + ")";
}


}

Van egy pontokból álló vonallánc osztályom:

import java.util.ArrayList;
public class PolyLine{

private ArrayList<Point> points = new ArrayList<Point>();


public PolyLine(ArrayList<Point> points){
this.points = points;

for (int i = 0; i < points.size()-1; i++){
if (!add(points.get(i))){
points.remove(i);
i--;
}
}

}

public ArrayList<Point> getPoints(){
return points;
}

public boolean equals(Object other){
return points.equals(other);
}

public boolean add(Point p){

int pos = points.indexOf(p);

return pos != -1 && !points.get(pos+1).equals(p);

}

public String toString(){

String a = "[";

String b = "" ;

for (int i = 0; i < points.size()-1; i++){
b = b + points.get(i).toString()+ ", ";
}

String c = points.get(points.size()-1).toString() + "]";

return a + b + c;

}



}

A baj az, hogy a két vonallánc összehasonlításánál az equals false-t dob, amikor azok megegyeznek. Az ismétlődések nem számítanak, azt a vonallánc constructorja kiszedi. A fejlécek fixek, azokat nem lehet változtatni. A sejtesem az, hogy point osztály equals metódusával számol és nem a beépített arraylistessel.

Itt hozza a teszt:

import java.util.ArrayList;
public class Bsp10{

public static void main(String[] args){


ArrayList<Point> points = new ArrayList<>();
points.add(new Point(292, -457));
points.add(new Point(292, -457));
points.add(new Point(292, -457));
points.add(new Point(17, -277));
points.add(new Point(-942, -103));
points.add(new Point(-557, -18));

PolyLine polyLine = new PolyLine(points);

ArrayList<Point> points2 = new ArrayList<>();
points2.add(new Point(292, -457));
points2.add(new Point(17, -277));
points2.add(new Point(-942, -103));
points2.add(new Point(-557, -18));

PolyLine polyLine2 = new PolyLine(points2);

System.out.println(polyLine);
System.out.println(polyLine2);
System.out.println(polyLine.equals(polyLine2));

}
}

Köszi előre is!

[ Szerkesztve ]

Továbbá próbáltam volna for ciklussal elemenként összehasonlítani, de azt meg nem tudtam megoldani, mert az arraylistes metódusokat nem találta Objecktes változóra. Próbáltam átalakítani is mint a point-nal, de azt sem ette meg.

Ezért ne kövesd el te azt a hibát, amit a java megalkotói, hogy túl általános típust használsz.
Jó, tudom, csak kompatibilitás, de akkoris.

Szóval a probléma a PolyLine.equals-ban van. Mivel a szignatúrája szerint Objectet vár, az ember bármit beadhat. És hidd el, be is fog. Amin aztán az egész cucc megfekszik (pl. ClassCastException-nel), ha nem figyelsz. Rosszabb esetben - mint most is - működik tovább hibásan.
Javaslom, minden equals metódusodban ellenőrizni a bejövő paraméter típusát. Ha nem jó típus, akkor false, ha jó típus, akkor pedig tessék castolni, és aztán hasonlítgatni. Könnyebben kibukik, hogy a beadott PolyLine nem is ArrayList, amivel hasonlítani akarod.
Egyébként az equals, hashcode metódusokat egy IDE szépen ki is generálja neked, van rá menüpont.

Szóval listát a listával:

public boolean equals(Object obj){
if (obj == this) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
PolyLine other = (PolyLine) obj;
return points.equals(other.points);
}

Ha nem kellenek az ismétlődések, miért nem egy rendezett Setet használsz erre a célra? LinkedHashSet, vagy valami ilyesmi. Ő magától megcsinálja.

Pár megjegyzés:
- Osztályon belül felesleges gettereket használnod, simán lehet hivatkozni a field-ekre, pl.:
return Math.sqrt(Math.pow(this.x - other.x, 2) + Math.pow(this.y - other.y, 2));

- Ha az objektum állapota nem változhat, akkor érdemes a field-eket final-ra állítani, így még véletlenül sem fogod tudni tönkretenni az objektumaidat. Továbbá egy ilyen tipikus value object esetén én még a getterek elhagyását is megkockáztatnám, valahogy így:
public class Point{
public final int x;
public final int y;

public Point(int x, int y){
this.x = x;
this.y= y;
}

public boolean equals(Object other){
// ...
}

public double getDistance(Point other){
// ...
}

public String toString(){
// ...
}
}

- Ne félj interfészt használni, ahol lehet, könnyebben cserélgetheted majd mögötte az implementációt. Ha nem akarod cserélgetni, akkor sem árt, mert idővel rááll a kezed, és nem kell folyton törnöd az APIt egy kis módosítás miatt.
Erre gondolok:
private ArrayList<Point> points = new ArrayList<Point>();
// helyett
private List<Point> points = new ArrayList<Point>();
// esetleg (attól függ, milyen funkcionalitást vársz el tőle, legyen-e rendezett, stb)
private Collection<Point> points = new ArrayList<Point>();

- Ciklusban Stringeket konkatenálni + jellel nem szép dolog, brutálisan pazarló. Minden egyes konkatenáció egy újabb és egy újabb Stringet hoz létre, amit aztán a következő körben el is dob, mert csak átmenetileg volt rá szükség. StringBuilder javallott és annak append metódusa. Vaaagy használod a listák toString metódusát, mert van.

Az equals függvényt hashCode nélkül nem írjuk felül (és amikor felülírjuk használjuk az @Override annotációt)! Mindkét függvény az Object osztályból jön, ami minden osztály őse. Olvasnivaló a témához.

[ Szerkesztve ]

“Yeah, well, you know, that’s just, like, your opinion, man.” — The Dude

Remek... letelt az időkorlát. -.-

Szóval azt még elfelejtettem, hogy ha Set-re váltasz, akkor a Point.equals mellett a Point.hashcode-ot is implementálnod kell. Az IDE elvégzi helyetted, de a lényeg:

A HashSet úgy működik, hogy a beletolt objektumra először hashcode-ot számol, ez csak egy szám. Ehhez a hashcode-hoz létrehoz egy izét, nevezzük vödörnek, és ebbe a vödörbe dobja bele az objektumodat.
Ha egy újabbat adnál hozzá, akkor arra is hashcode-ot számol, és csak az adott hashcode-hoz tartozó vödörrel foglalkozik, végigmászik a vödör tartalmán, az equals-szal csekkolja, hogy benne van-e már, és ha talált, akkor nem teszi bele újra.
Ha a hashcode számítást elcseszed, akkor előfordulhat olyan, hogy van 2 objektumod, ami az equals szerint azonos, de a hashcode szerint nem. Mindkettő bele fog kerülni a Set-be (!!), mert a másik az eltérő hashcode miatt másik vödörbe kerül. Ilyet sose csinálj.
Vagy például megváltozik az objektumod állapota (mondjuk most nem, mert minden final, de máskor, mással, másnál igen ), és a megváltozott állapot miatt megváltozhat a hashcode is. Na az az objektumod, ha benne volt egy set-ben, akkor ott is marad, sose találod meg. Vicces dolgok ezek.
Gondolhatnád, hogy akkor legyen a hashcode mindig 1, abból baj nem lehet. Jó gondolat, de lassú lesz, épp azért szegmentálunk sok kis vödörre relatíve kis számításigényű megoldásokkal, hogy csak egy kis vödör tartalmán kelljen végigsuhanni, gyorsan el lehet dönteni, hogy valami benne van-e abban a Set-ben avagy sem.