Hello most kezdtem a suliban java-t tanulni és érdeklődni szeretnék, hogy tudtok-e ajánlani vmi jó java könyvet vagy az angster erzsébetes tökéletes?vmi jó IDE felületet?(linux alá) eclipse?
és egy jó feladatgyűjti érekelne mint pl a juhász-kósa-pánovics féle java gyak könyv...

Minden input az ördögtől érkezik!

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]

Eclipse is van linux-ra. Szubjektív véleményem szerint azzal jobban jársz

sziasztok!

adott egy online progi

[link]

és a képek nézegetéséhez valami beépülő cucc kell, neve: proquest

azonban a telepítéskor hibával leáll, valami cfg file baja van

PLEASE segítsetek fontos lenne!!

H97 / i5 / 16GB DDR3 / 3TB HDD / 120GB SSD / R9 280 / 24" IPS / 550W

Hi!

A suliban Fedora alatt az eclipse -szel létrehoztunk egy új java projectet és abban mappákat, classokat, meg ilyesmiket hoztunk létre és ezeket a fileokat az eclips szépen menti is. Ez így szép, jó, meg minden, de hogyan tudom átvinni az egész projektet egy masik gépre?
Projektre vonatkozó file-t nem találtam sehol, csak ezeket a class fileokat látom egy mappában ( - a mappa neve a project neve). Lényeg az, hogy próbálkoztam, de nem sikerült ezt így megnyitnom az otthoni gépen ( igaz, otthon windows alatt próbálkoztam, de az elvileg nem számíthat ).

Előre is köszi a segítséget!

Forest

-=Legyél Laza!=- __ ''Have you tried turning it off and on again?'' __ ''Is it definitely plugged in?'' /o\ :D:D

Közben volt óra - megmutatták, úgyhogy érdektelen!

-=Legyél Laza!=- __ ''Have you tried turning it off and on again?'' __ ''Is it definitely plugged in?'' /o\ :D:D

az én problémám viszont nem érdektelen, valaki esetleg egy kis HELP?

H97 / i5 / 16GB DDR3 / 3TB HDD / 120GB SSD / R9 280 / 24" IPS / 550W

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

A {} blokkban deklarált változók csak a {} blokkon bellül érvényesek.
Vagyis az történik, hogy lefoglal az n számára tárterületet, majd felszabadítja, megint lefoglalja és megint felszabadítja.
De egy okos fordítóprogram ki is optimalizálhatja, és valójában nem csinál semmit.

''Twenty years from now you will be more disappointed by the things that you didn't do than by the ones you did do.'' - Mark Twain

Szerintem a legjobb magyar könyv:
Java 2 Útikalauz Programozóknak

''Twenty years from now you will be more disappointed by the things that you didn't do than by the ones you did do.'' - Mark Twain

Szép lenne ha felszabadítaná a ciklus minden iterációjában..
A fordító kb. azt csinálja, hogy
int n = 10;
for (int i=0;i<2;i++){
n = 10;
}

Thank you to god for making me an atheist

HE?!
Szóval a ciklusmagon kívűl is lehet hivatkozni rá?!
Hát jó te tudod...

''Twenty years from now you will be more disappointed by the things that you didn't do than by the ones you did do.'' - Mark Twain

Nem, nem mondtam ilyet. Még azt sem mondtam, hogy pont ezt csinálja a fordító. C# alatt megmondom neked assemblyre, java-nál nem tudom. Szemantikailag viszont így kell elképzelni. Ha mondjuk egy újabb blokkba rakod az egészet, akkor mindjárt nem látszik kívülről..., de tök mindegy, nem találgattam, csak választ adtam, hogy kell elképzelni.
De te aztán még úgy jól tudod, írsz egy totál hülyeséget aztán én vagyok a hülye..

Thank you to god for making me an atheist

pedig szerintem igaza van a koleganak. Ha a for cikluson belul hozol letre egy valtozot, akkor azt bizony fel fogja szabaditani sztem.

nezzunk egy mitirki peldat

for (i=0;i<10;i++) {
int n=10;
System.out.println(n);
n++;
}

''Gee, Brain, what do you want to do tonight?'' ''The same thing we do every night, Pinky: Try to take over the world!''

bocsi, igazad van, felreertettelek. Tenyleg logikusabb hogy az ertekadas mindig megtortenik, de a lefoglalas/felszabaditas csak egyszer.

''Gee, Brain, what do you want to do tonight?'' ''The same thing we do every night, Pinky: Try to take over the world!''

Én azt nem mondtam, hogy az értékadás csak egyszer fut le, hisz ott van az én kódomban is. Így azt kapod ami a példádban is van. Csupán azt állítottam, hogy nem történik allokáció és felszabadítás minden iterációnál. Ez komoly bünti lenne egy ilyen magas szintű nyelvnél, még egy egyszerű int-nél is.

szerk: 815: np.

[Szerkesztve]

Thank you to god for making me an atheist

Az első fele a mondatomnak arra vonatkozott, hogy hogy kell elképzelni. Azzal pedig semmi gond nem volt. A ciklusmagon kívűl nem létezik az n változó.

A második fele pedig az hogy a fordító kioptimalizálhatja. Nem tudom hogy, mert nem ismerem a jdk forrását, lehet hogy úgy ahogy te mondtad (+ a külső blokk köré egy {}), de ennél egy jobb megoldás, amit én mondtam, hogy észreveszi, hogy a ciklusmagon bellül nincs hivatkozás az n-re (ezt azt hiszem amúgy is észreveszi, mert warningot ad), és akkor a ciklusmag üres, ezt is kioptimalizálhatja és nem csinál semmit.

''Twenty years from now you will be more disappointed by the things that you didn't do than by the ones you did do.'' - Mark Twain

Jó, abban igazad van, hogy általános esetben, ha tényleg egy értelmes ciklusmag van, akkor a benne deklarált változók nem jönnek létre és szünnek meg minden iterációban. Ezt inkább csak szemantikailag lehet így képzelni.
A te hozzászólásodban meg az zavart, hogy csak simán kiraktad a ciklusmagból a változót.
Már így is túl sok volt erre a kérdésre.

''Twenty years from now you will be more disappointed by the things that you didn't do than by the ones you did do.'' - Mark Twain

Köszönöm a válaszokat.

KL

A 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]

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]

Referencia típusoknál mindig allokáció van.

Ha így érdekel a téma, ajánlom áttanulmányozásra az alábbi írást és a kommenteket : [link]

Thank you to god for making me an atheist

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]

false, false

Tipikus autoboxing kérdés, amit így is meg lehet fogalmazni:

while (i<=j && i>=j && i!=j) {
;
}

Hogyan deklaráljuk i-t és j-t hogy a fenti ciklus végtelen legyen?

Ja nem, megszívtam.... true, false

Most néztem utána, hogy miért is van ez így.... ez nagyon gáz!!!

Ugye? Megfeküdtem, amikor arról olvastam, hogy az == és != másképp viselkedik
Character, Short és Integer típusoknál -128..127 ig, míg a fölött és alatt.

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.

A gyakorlatban ugyan ennek vajmi kevés jelentősége van, mert az Integer
érték egyenlőségét úgyis equals-al vizsgáljuk, de ez akkor is... meghökkentő

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.

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>.''

''Gee, Brain, what do you want to do tonight?'' ''The same thing we do every night, Pinky: Try to take over the world!''

Eclipse-ben hasznalok Visual Editort. Kerdesem az lenne, hogy tudom elrejteni az elemeket a formban? Tehat szerkesztes kozben el szeretnem rejteni, hogy lassam az ''alatta'' levo elemeket.

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]

Itt van meg par erdekes eszrevetel a Javaval kapcsolatban: [link]

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.

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.

Lehet hogy elsőre furcsának tünik, de azért van benne némi logika
Ha csíkokat rajzolsz a string karakterei közé így:
| H | e | l | l | o |
akkor a substring-nek azt kell megadni, hogy melyik két ''csík'' közötti részt
kéred (0-tól kezdve az indexeket).

További előny, hogy az endIndex és a startIndex különbsége így pont az
eredmény hossza lesz. Tehát így is hasznáhatod:

substring(startindex, startindex + 10)

Ami visszaadja a startindex-től kezdődő 10 hosszúságú stringet.


[Szerkesztve]

''substring(startindex, startindex + 10)
Ami visszaadja a startindex-től kezdődő 10 hosszúságú stringet.''

En is pont ezt akartam irni, sztem teljesen logikus...

Egyreszt a fenti modszerrel pontosan ugy mukodik mint a c fele (start,darab) megoldas masreszt ha pl egy bizonyos minta elotti reszt akarod kivagni, akkor miutan megvan a minta kezdete nem kell meg egyet kivonni...

Szoval szerintem van ertelme, hogy igy irtak meg...

''Gee, Brain, what do you want to do tonight?'' ''The same thing we do every night, Pinky: Try to take over the world!''

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...

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.

Sziasztok!

Nekem egy Sony Ericsson P800asom van, és az a problémám, hogy amikor feltelepitek egy JAR fájlt a telefonra, és amikor elinditom, megjelenik, hogy ''MIDlet inditása'' és utána nem történik semmi. Esetleg nem tudna nekem valaki segiteni, hogy mi lehet a probléma? Újabb java-t kéne rá tennem? (amit nem találok a neten sehol :S )

Kérlek segitsetek!

Nem ismeres a telót de szerintem JAD fájl is kell neki vagy az is elképzelhető,
hogy a JAR fájl nem kompatibilis a telefonoddal.

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)

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...

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

''Gee, Brain, what do you want to do tonight?'' ''The same thing we do every night, Pinky: Try to take over the world!''

Kérdés az, hogy mit tekintesz értéknek.
Én azt mondtam volna, amit megadtak megoldásnak. De szó szerint véve elfogadható az A is, mivel egy objektum értéke a referenciája. (szintaktikailag)
Ugyanakkor ha azt mondod, hogy referencia szerinti átadás van objektumoknál, szerintem akkor sem mondasz hülyeséget (sőt), mivel az az érték ami átadódik az egy referencia, így ugyanazt mondod, csak a referencia pontosabb megnevezés, bővebb jelentéssel bír, épp ezért ez utóbbit preferálom.

Thank you to god for making me an atheist

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...

''Gee, Brain, what do you want to do tonight?'' ''The same thing we do every night, Pinky: Try to take over the world!''

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)

[...]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.

Valóban, referencia típusnál is átmásolódik a hívó paraméter referenciája a hívott paraméterbe. De mivel ez egy referencia, azaz mindkettő rámutat majd ugyanarra az objektumra, ezért mellékhatásokkal jár, ha a lokál paraméterrel mutatott objektumot mdosítjuk. Maga a paraméterként átadott objektum értéke, referenciája valóban nem fog megváltozni. Viszont az előbb említett mellékhatás miatt célszerű megkülönböztetni a hagyományos érték szerinti paraméterátadástól. Mint ahogy a ''valódi'' referencia szerintit is meg kell különböztetni tőle, ahol nem a referencia adódik át, hanem magának a referencia típusú változónak a címe, így a hívott eljárásban egy és ugyanaz a változó, mint a hívás helyén.

Hogy hogy hívjuk, az már nekem mindegy, ha a sun simán érték szerintinek írja, ám legyen, nem ez a lényeg, hanem hogy értsük a működését. C#-ban egyébként létezik mind a három általam említett paraméterátadás, dehát ez nem az a topik.

Thank you to god for making me an atheist