Feladatom, hogy a paraméterben átadott számnak kiszámítsam a sinusát, cosinusát, valamint gyök2-őt. Taylor-polinom segítségével meg is oldottam, viszont lenne egy kérdésem.
Melyik megoldás szebb? Az, amikor van egy sinus, cosinus, és gyok2 osztályom, és szépen példányosítom mindegyiket, vagy ha van egy Taylor osztályom, az csinál minden számolást, és a futó osztályban csak ezt példányosítom, és írom ki a toString felüldefiniált metódussal az eredményeket. 
Tudom, hogy működés szempontjából mindegy, megvan mindkétféleképpen, de melyik a jobb, szebb?
Java programozás - Szoftverfejlesztés fórum
üzenetek
hozzászólások
ZUP!
Ma el kellene küldenem valamelyiket 
andriscs
(aktív tag)
Hi!
Ez csak az én szubjektív véleményem, de úgy vélem, hogy egy viszonylag egyszerű problémát nem kell túl sok osztályra felbontani, így jelen esetben is érdemes inkább egy Taylor osztállyal számoltatni. Sok osztály akkor kell, ha valóban összetett a program.
[Szerkesztve]
Köszi, beadtam a 2 osztályos verziót. Remélem ilyenen nem fog szőrözni
Tudja v.ki hogy mi ez:
<!DOCTYPE HTML PUBLIC ''-//W3C//DTD HTML 4.0 Transitional//EN''>
Rengeteg hlyen van de miez?
andriscs
(aktív tag)
Hi!
A hivatalos HTML specifikációnak megfelelő HTML tag, amit a W3C alkotott (szabvány HTML), elvileg egy leírást ad a HTML doksiról, és megfelel a DTD specifikációknak. Bocsi, ha kicsit érthetelen, mi így tanultuk...
[Szerkesztve]
Ok. De nem gond ha nincs benne?
[Szerkesztve]
Zsu_
(senior tag)
Sziasztok!
A ''static'' kulcsszóról mit tudtok?
Mikor kell, mikor használjuk, stb...?
Tehát pl
- static class Name
Előre is köszi az infókat!
BaLinux
(tag)
Ez egy picit összetett dolog, biztosan ki is fogok felejteni valamit.
Használat módjai:
- static osztály változók: nem keletkeznek objektumonként, hanem az osztály összes példánya közösen használja a változót
pl.
class A { static int count; A() {count++;} }
esetén minden egyes konstruktorhívásnál inkrementálódik a count.
- static tagfüggvények: az előbbihez kapcsolódik, ugyanis ilyen függvényhez nem tartozik objektum. Ezt úgy értem, hogy a class A { static void fgv() {} } oszály fgv függvénye így hívható: A.fgv(); Természetesen ennél fogva nincs az fgv-ben definiálva ''this'' változó és ezért nem-static osztály változók/függvények sem használhatók, viszont static-kel jelöltek igen. (Persze ha átadsz paraméterben bármilyen objektumot, azzal azt csinálsz amit akarsz.)
- static belső osztályok: olyan osztályon belül definiált osztályok, melyek nem kapcsolódnak a külső osztályhoz példányszinten. Huh, ez bonyi
Na szóval:
class A { static int count; int local; static class B { }}
ilyenkor az A.B osztály példányosítható A-n kívülről. Egyébként nem! Továbbá az A.B osztály nem fér hozzá az A.local változóhoz, de az A.counthoz igen.
Ööö van még valami?!
[Szerkesztve]
BaLinux
(tag)
Kiegészíteném a nem-static belső class-ról mondottakat azzal, hogy példányosíthatóak kívülről, amennyiben a new operátor egy kevéssé szokásos szintaxisát használjuk.
pl. legyen:
class A {
int a;
class B {
void ezmuxik() {
// itt hivatkozunk a kulso osztalyra! Ehelyett irhatunk a++;-t, ha az egyertelmu.
A.this.a++;
}
}
}
Van egy másik osztály, mely ezt csinálja:
class C {
void f() {
// hibas! ''no enclosing instance of A''
new A.B();
// gyartunk egy A-t
A a_peldany=new A();
// explicit megadhato az enclosing instance!
A.B ab_peldany=a_peldany.new B();
}
}
Na kezd teljes lenni a dolog. Remélem érthető.
Zsu_
(senior tag)
köszönöm a kielégítő választ
Kérdezhetnék még egy konkrétat is? 
1.
Mi a hiba az alábbi forráskódban?
public class Application {
class Vector { double m_x, m_y; Vector(double x, double y) { m_x = x; m_y = y; } }
public static void main (String[] args) { Vector v = new Vector(0.0, 0.0); }
}
Fordítóval kipróbáltam, hogy az a hiba, hogy a class Vector elé kell a static szó.
De miért? nem igazán értem. 
2.
Mi a hiba az alábbi forráskódban?
class A { int a;
static class B {
B(int aa) { a = aa; }
}
}
Itt pedig az a hiba, hogy nem kell a static a class B elé. De ennek sem igazán értem a miértjét...
Hálás lennék, ha elmagyaráznád!
Előre is köszi
BaLinux
(tag)
Nyugodtan 
Bár úgy látom, hogy a kérdéseidre kifejtettem már a választ, csak nem pont ezekkel a példákkal... na lássuk:
1. A hiba valóban az, hogy oda kell a static, ugyanis (ahogy már leírtam): tetszőleges osztályban definiált static függvény osztálypéldány nélkül hívható. Ez azt jelenti, hogy nem tud hozzáférni (nem ''látható'' a függvény törzséből) semmilyen nem-static osztályváltozó. A nem-static belső osztályokra ez a szabály azért vonatkozik (tehát nem tud létrehozni olyan belső osztály típusú objektumot), mert a nem-static belső osztályok példányainak alapból rendelkezniük kell referenciával a külső osztályuk (amiben definiáltad a belső osztályt) egy példányára. Méghozzá pontosan arra, amely teremtette őket.
A belső osztály példány referenciája a külsőre úgy néz ki, hogy A.this (ha A a külső osztály neve). Remélem összeállt...
2. két lehetőség: nem kell static a B osztály elé, vagy éppen static kell az int a elé.
A szabály ugyanaz, mint az előbb: mivel a belső osztály statikus, nem kötődik külső oszályhoz, így a belső példány nem is rendelkezik információval (referenciával) az ő bennfoglaló objektumáról, ami ha a staticot eltöröljük, az A osztály egy példánya lenne.
Így a
a = aa;
sorban nem tud hozzáférni az 'a' változóhoz, ugyanis a szimbólumtáblázat látható részében (hogymondják szépen magyarul azt, hogy scope? ) nincs ilyen változó!
Ugye amikor azt írod hogy 'a', ebben az esetben prioritási sorrendben így tud feloldódni a jelentése:
1) lokális blokkban ({ } közötti utasítások) lévő változók
2) szülő blokkban lévők
3) rekurzívan a függvény fejlécig, itt a fgv paraméterek jönnek be
4) osztályváltozók (ez az ami ilyen bonyi szabályokkal írható le, ahogy eddig tettem)
Az utóbbinál az 'a' szimbólum ekvivalens a 'this.a'-val, amennyiben a belső rendelkezik nem-static 'a' nevű változóval; továbbá ekvivalens 'Belsoosztaly.a'-val, ha rendelkezik static 'a' nevű változóval.
Van egy ''5.'' szint, amennyiben egy belső osztályban használt változóról van szó. Ilyenkor az 1-es ponttól oldjuk fel ismét rekurzívan attól a helytől kezdve, ahol az osztályt definiáltad... így lesz az 'a'-ból 'Kulsoosztaly.this.a', ha a belső osztály nem static és a a Kulsoosztaly rendelkezik nem static 'a' változóval, a static szintaxis meg egyenlő a fentivel, tehát a 'Kulsoosztaly.a' static(!) változó mindenhonnan hozzáférhető, akár static, akár nem a belső osztály.
Hmmm... remélem érthető
[Szerkesztve]
Zsu_
(senior tag)
Tyűha! Köszi 
Azt hiszem értem, de ez majd a zh-n kiderül...
beeboy
(addikt)
randommal kapcsolatban:
néhány java óra után, no meg egy kis tanulást követően látom micsoda sületlenségeket hordtam össze! ![;]](/dl/s/v1.gif)
beeboy
(addikt)
ha ebben segítenél, megpróbálom röviden:
van egy vektor osztályom, ebben adatok.
ebben akarok keresni, úgy csináltam, hogy létrehoztam még egy vektor osztályt, és ebbe vittem be az adatot (hogy egyforma objektumúak legyenek)
de nem adja vissza a találatot, pölö:
tárolóvektor - ebben vannak az adatok, közte ''qqq'' srting
keresővektor értéke: 1 hosszú vektor, értéke ''qqq''
int melyiksor=tárolóvektor.indexOf(keresővektor.get(0));
tehát ''qqq'' értékű vektorelemet hasonlítok ''qqq'' értékhez, de nem jó, mindig -1 -el jön vissza.
próbáltam már sima stringel hasonlítani, de nem megy.
ötleted? köszi
BBC
(tag)
hátha még nem késő...
vagy mást is érdekel
szóval: .java->.class futtatása jdk esetén parancssoros bénázás nélkül:
akármi.bat-ba bemásolni, és erről egy parancsikont a SENDTO-ba!
@echo off
set folderfile=%~n1
set folderut=%~p1
set folderdriver=%~d1
%folderdriver%
cd %folderdriver%%folderut%
javac %folderfile%.java
java %folderfile%
pause
majd intézőben jobb klatty a .java fájlon és küldés-> java fordító (vagy ami a neve)
