Onlline futtató környezetek;
https://www.jdoodle.com/online-java-compiler
https://www.tutorialspoint.com/compile_java_online.php
https://www.compilejava.net/
http://www.browxy.com/
http://www.compileonline.com/compile_java_online.php
------------------
public class Szamok {
public static void main(String[] args) {
int i,n=10;
System.out.println("Az elso "+n+" egesz szam:");
for(i=1;i<=n;i++){
System.out.println(i);
}
}
}
-------------------
Forciklussal
public class Vissza {
public static void main(String[] args) {
int i,n=5;
System.out.println("Az elso "+n+" egesz szam visszafele:");
for(i=n;i>=1;i--){
System.out.println(i);
}
}
}
-------------------------
Elől tesztelős
public class Szamok1a {
public static void main(String[] args) {
int i,n=20;
System.out.println("Az elso "+n+" egesz szam:");
i=15; //kezdőértékadás
while(i<=20) {
System.out.println(i);
i++; //ciklusváltozó növelése
}
i=30;
System.out.println("Az elso "+n+" egesz szam visszafele:");
while(i>=25) {
System.out.println(i);
i--;
}
}
}
---------------------
Hátultesztelős
public class Szamok1b {
public static void main(String[] args) {
int i,n=5;
System.out.println("Az elso "+n+" egesz szam:");
i=1; //kezdőértékadás
do { //"do" blokk = a ciklusmag
System.out.println(i);
i++; //ciklusváltozó növelése
} while(i<=n); //ciklusfeltétel: amíg igaz, addig ismétli a ciklusmagot
i=n;
System.out.println("Az elso "+n+" egesz szam visszafele:");
do {
System.out.println(i);
i--;
} while(i>=1);
}
}
-----------------
páratlan
public class Szamok2 {
public static void main(String[] args) {
int i,j,n=10;
System.out.println("Az elso "+n+" paratlan szam:");
j=1; //első páratlan szám
for(i=1;i<=n;i++){
System.out.println(j);
j+=2; //következő páratlan szám
}
}
}
---------------
Páros számok
public class Szamok2a {
public static void main(String[] args) {
int i,j,n=10;
System.out.println("Az elso "+n+" paros szam:");
j=2; //első páros szám
for(i=1;i<=n;i++){
System.out.println(j);
j+=2; //következő paros szám
}
}
}
----------------------
Visszafelé
public class Szamok2b {
public static void main(String[] args) {
int i,j,n=10;
System.out.println("Az elso "+n+" paros szam visszafele:");
j=2*10; //a 10. páros szám
for(i=1;i<=n;i++){
System.out.println(j);
j-=2; //következő paros szám
}
}
}
----------------
Sorszámmal összefűzve
public class Szamok2c {
public static void main(String[] args) {
int i,j,n=10;
System.out.println("Az elso "+n+" paros szam:");
j=2; //első páros szám
for(i=1;i<=n;i++){
System.out.println("A(z) "+i+". paros szam: "+j);
j+=2; //következő paros szám
}
}
}
-------------------
public class Szamok3 {
public static void main(String[] args) {
int i,j,n=10;
System.out.println("Az 1,2,4,7,11,... sorozat elso "+n+" eleme:");
j=1; //sorozat első eleme
for(i=1;i<=n;i++){
System.out.println("A(z) "+i+". elem: "+j);
j+=i; //sorozat következő eleme
}
}
}
----------------
public class Szamok4 {
public static void main(String[] args) {
int i,n=10;
boolean pozitiv;
System.out.println("Az 1,-2,3,-4,... sorozat elso "+n+" eleme:");
pozitiv=true;
for(i=1;i<=n;i++){
System.out.println(pozitiv?i:-i); //+i vagy -i kiiratása váltakozva
pozitiv=!pozitiv; //true -> false, ill. false -> true váltás
}
}
}
----------------
Összeg
public class Osszeg {
public static void main(String[] args) {
int i,sum,n=31;
System.out.print("Az elso "+n+" egesz szam osszegenek erteke: ");
sum=0;
for(i=42;i<=73;i++){
sum+=i;
}
System.out.println(sum);
}
}
----------------
public class Osszeg1 {
public int osszeg(int n){
int i,sum=0;
for(i=1;i<=n;i++){
sum+=i;
}
return sum; //visszatér az első n szám összegével
}
public static void main(String[] args) {
int i,n=10;
Osszeg1 o=new Osszeg1();
System.out.println("Szamok osszegenek kiiratasa:");
for(i=1;i<=n;i++){
System.out.println("elso "+i+" szam osszege: "+o.osszeg(i));
}
}
}
----------------
Páratlan összeg
public class Osszeg2 {
public static void main(String[] args) {
int i,j,sum,n=10;
System.out.print("Az elso "+n+" paratlan szam osszegenek erteke: ");
sum=0;
j=36;
for(i=1;i<=n;i++){
sum+=j;
j+=3;
}
System.out.println(sum);
}
}
--------------
public class Fakt3 {
public static void main(String[] args) {
int i,j,n=10;
long f; //bővebb értéktartomány
f=1;
j=1;
for(i=1;i<=n;i++){
f*=j;
j+=2;
}
System.out.println("Az elso "+n+" paratlan szam szorzatanak erteke: "+f);
}
}
------------------
Páratlan összeg és szorzat
public class Fakt4 {
public static void main(String[] args) {
int i,j,sum,n=5;
long f; //bővebb értéktartomány
sum=0;
f=1;
j=1;
for(i=1;i<=n;i++){
sum+=j;
f*=j;
j+=2;
}
System.out.println("Az elso "+n+" paratlan szam osszegenek erteke: "+sum);
System.out.println("Az elso "+n+" paratlan szam szorzatanak erteke: "+f);
}
}
-----------------
Négyzetszámok
public class Negyzet {
public static void main(String[] args) {
int i,n=10;
System.out.println("Az elso 10 negyzetszam:");
for(i=1;i<=n;i++){
System.out.println(i+"*"+i+" = "+i*i);
}
}
}
------------
Hatvány
public class Hatvany {
public static void main(String[] args) {
int i,n=10;
double h=2.0,x;
x=1.0; //h^0 (h nulladik hatványa)
System.out.println(h+" elso 10 hatvanya:");
for(i=0;i<n;i++){
System.out.println(h+"^"+i+" = "+x);
x*=h;
}
}
}
---------------
Véletlen
public class Veletlen {
public static void main(String[] args) {
int i,n=10;
double szam;
System.out.println(n+" darab veletlen szam a [0,1) intervallumbol:");
for(i=0;i<n;i++){
szam=Math.random(); //véletlen szám generálása
System.out.println(szam);
}
}
}
------------
Tömb
public class Veletlen1 {
public static void main(String[] args) {
int i,n=10;
double[] szamok=new double[n]; //10 elemű valós tömb létrehozása
System.out.println(n+" darab veletlen szam a [0,1) intervallumbol:");
for(i=0;i<n;i++){
szamok[i]=Math.random(); //számok eltárolása a tömbben
}
for(i=0;i<n;i++){
System.out.println(szamok[i]); //számok kiíratása a tömbből
}
}
}
-------------
Lottó
public class Veletlen3 {
public static void main(String[] args) {
int i,veletlen,n=5,min=1,max=90;
System.out.println(n+" darab veletlen egesz szam a(z) ["+
min+","+max+"] intervallumbol:");
for(i=1;i<=n;i++){
veletlen=(int)(max*Math.random())+min; //típuskényszerítés (int)-re
System.out.println(veletlen);
}
}
}
------------
Adott egy szám. Vizsgáld meg, hogy negatív-e a szám és írd ki, ha igen.
int szam = 25;
if( szam < 0 )
{
System.out.println("A szam negativ.");
}
Adott egy szám. Vizsgáld meg, hogy páros-e a szám és írd ki, ha igen.
int szam = 25;
if( szam % 2 == 0 )
{
System.out.println("A szam paros.");
}
--------------
int szam = 25;
if( szam % 2 != 0 )
{
System.out.println("A szam páratlan.");
}
---------------
Ilyen 3 ágú elágazásra jó példa a pozitív-negatív vizsgálat.
int szam = (int)(Math.random()*21)-10;
if( szam < 0 )
{
System.out.println("A szam negativ.");
}
else if( szam > 0 )
{
System.out.println("A szam pozitiv.");
}
else
{
System.out.println("A szam nulla.");
}
---------------
Lássuk akkor az előző példa megoldását másképp:
int szam = (int)(Math.random()*21)-10;
if( szam = 0 )
{
System.out.println("A szam nulla.");
}
else if( szam < 0 )
{
System.out.println("A szam negativ.");
}
else
{
System.out.println("A szam pozitiv.");
}
------------
Nem ritka a 6-7 ágú feltételvizsgálat sem.
int honap = (int)(Math.random()*12)+1;
if( honap == 3 || honap == 4 || honap == 5 )
{
System.out.println("Tavasz");
}
else if( honap == 6 || honap == 7 || honap == 8 )
{
System.out.println("Nyar");
}
else if( honap == 9 || honap == 10 || honap == 11 )
{
System.out.println("Osz");
}
else
{
System.out.println("Tel");
}
----------------
Ha a testmagassága normális, akkor ne írjunk ki semmit sem:
// a testmagassag a [140;200] intervallumban legyen
int magassag = (int)(Math.random()*61)+140;
if( magassag < 160 )
{
System.out.println("Tul alacsony");
}
else if( magassag > 190 )
{
System.out.println("Tul magas");
}
--------------
Nézzük ugyanezt a hónapvizsgálatot másképp:
int honap = (int)(Math.random()*12)+1;
if( honap == 3 || honap == 4 || honap == 5 )
{
System.out.println("Tavasz");
}
if( honap == 6 || honap == 7 || honap == 8 )
{
System.out.println("Nyar");
}
if( honap == 9 || honap == 10 || honap == 11 )
{
System.out.println("Osz");
}
if( honap == 12 || honap == 1 || honap == 2 )
{
System.out.println("Tel");
}
--------------
Álljon itt akkor egy példa független és egy többágú feltételvizsgálatra:
// 1. példa
int szam = (int)(Math.random()*50)+1;
if( szam % 3 == 0 )
{
System.out.println("A szam oszthato harommal.");
}
if( szam % 5 == 0 )
{
System.out.println("A szam oszthato ottel.");
}
// 2. példa
int szam = (int)(Math.random()*50)+1;
if( szam % 3 == 0 )
{
System.out.println("A szam oszthato harommal.");
}
else if( szam % 5 == 0 )
{
System.out.println("A szam oszthato ottel.");
----------------
Vannak olyan esetek, amikor a sok if-else if-else ág helyett egyszerűbb lenne egy olyan vizsgálat, ahol egy változó értékeit közvetlenül lehetne vizsgálni, és azokhoz más-más utasításokat rendelhetnénk hozzá. Erre szolgál a switch.
Switch szerkezete
switch( valtozo )
{
// case után a konkrét előfordulás
case 1_tipus :
// az előforduláshoz kapcsolt egyetlen utasítás
elso_tipus_utasitasa;
// lezárjuk a kapcsolt utasítást
break;
// több előforduláshoz ugyanaz az utasítás is tartozhat
case 2_tipus : case 3_tipus :
masodik_vagy_harmadik_tipusok_utasitasa;
break;
// sokszor a rovid egy utasitasos agakat egy sorba irjuk
// a tomorebb forma miatt, a break mehet a vegere
case 5_tipus : otodik_tipus_utasitasa; break;
// irhattam volna a 2 case agat azonos sorba is, mint a 2-3-nal
case 4_tipus :
case 6_tipus :
// több előforduláshoz több utasítás is tartozhat
negyedik_vagy_hatodik_tipusok_elso_utasitasa;
negyedik_vagy_hatodik_tipusok_masodik_utasitasa;
....
break;
// a 7-es agnal nem veletlenul hianyzik a break!!
case 7_tipus : hetedik_tipus_utasitasa;
case 8_tipus : nyolcadik_tipus_utasitasa; break;
// egy előforduláshoz több utasítás is tartozhat
case 9 :
kilencedik_tipus_elso_utasitasa;
kilencedik_tipus_masodik_utasitasa;
break;
...
...
// a default ag nem kotelezo! egyfajta else agkent ertelmezheto
default :
minden_mas_eset_utasitasai;
....
break;
}
Akkor pár magyarázat ezzel kapcsolatban:
A switch után zárójelben meg kell adni azt a típust, amelynek a különféle értékeihez kapcsolódó ágakat a switch-en belül kezelni szeretnénk. Ezek a típusok jórészt primitív típusok lehetnek, valamint pár speciális típus. A lista nem teljes, de a lényeges elemek benne vannak:
byte
short
int
char
String(!) (java 7 óta)
enum
Az egyes ágakat case kulcsszóval vezetjük be, ami után odaírjuk a konkrét előfordulást, amihez a kettőspont utáni utasításokat kapcsolni szeretnénk. Ha egyetlen rövid utasítást használunk csak, akkor írhatjuk a példa ötödik előfordulásának megfelelő szerkezetben egy sorba.
------------------
Lottó
import java.awt.*;
import java.awt.event.*;
public class LottoFrame1 extends Frame implements WindowListener,
ActionListener {
public LottoFrame1(String s) { //konstruktor paraméterrel
super(s); //a Frame osztály konstruktora beállítja az ablak címsorát
}
public static void main(String[] args) {
LottoFrame1 frame=new LottoFrame1("Lottószámok");
MenuItem actionNew=new MenuItem("New");
MenuItem actionQuit=new MenuItem("Quit");
Menu menusor=new Menu("Action");
menusor.setFont(new Font("Arial",Font.BOLD,12));
menusor.add(actionNew);
actionNew.addActionListener(frame); //menüpont figyelése
menusor.add(actionQuit);
actionQuit.addActionListener(frame); //menüpont figyelése
MenuBar fomenu=new MenuBar();
fomenu.add(menusor);
frame.setSize(150,100); //beállítja az ablak méretét
frame.addWindowListener(frame); //ablakesemények figyelése
frame.setMenuBar(fomenu); //főmenü beállítása
frame.show(); //kirajzolja az ablakot
}
public void paint(Graphics g) {
int i;
Lotto lotto=new Lotto();
g.drawString("A javasolt lottószámok:",10,60);
for(i=0;i<Lotto.MAXNUM;i++){
lotto.general();
}
for(i=0;i<Lotto.MAXNUM;i++){
g.drawString(""+lotto.kihuz(),24*i+10,72);
}
}
public void actionPerformed(ActionEvent ev) {
if(ev.getActionCommand()=="New") {
repaint();
}
else if (ev.getActionCommand()=="Quit") {
System.exit(0);
}
}
public void windowOpened(WindowEvent ew) {}
public void windowClosing(WindowEvent ew) {
System.exit(0);
}
public void windowClosed(WindowEvent ew) {}
public void windowIconified(WindowEvent ew) {}
public void windowDeiconified(WindowEvent ew) {}
public void windowActivated(WindowEvent ew) {}
public void windowDeactivated(WindowEvent ew) {}
}
-----------
Objektum orientált programozás I.
/ Java lépésről-lépésre © Gál Tibor /
Bevezetés
A klasszikus, procedurális programozási nyelvekben a valós világ problémáit néhány előre definiált adattípussal: egészekkel, valósakkal és esetleg tömbökkel próbáljuk megoldani. Az objektum orientált programozási nyelvekben ezzel szemben egy valós világnak a modelljét hozzuk létre. Az osztályok a programmozó által definiált típusok, melyek a rendszer részeit modellezik.
Egy class (osztály) nem más mint egy programozó által definiált típus, amely az osztály példányainak mintájául szolgál. Továbbra is használhat egészeket, valós változókat, stirngeket és tömböket, de használhat olyan típusokat is mint autók, emberek, házak, bankok, számlák, és minden más típust, amely fontos lehet az adott feladat megoldása szempontjából.
Az osztályok maguk számára és a belőlük képzett objektumok számára is specifikálják az általuk tartalmazott adatokat és viselkedést. Egy osztálynak két része van: a mezőváltozók (vagy tulajdonságok) és a metódusok. A mezőváltozók azt írják le, hogy mi is az osztály, a metódusok pedig azt, mit csinál az osztály.
Az osztály által szolgáltatott minta alapján akárhány objektumot létrehozhat, melyeket az osztály példányainak nevezünk. Egy adott osztály különböző objektumai azonos mezőváltozókkal és metódusokkal rendelkeznek, de a mezőváltozók (példányváltozók) értékei rendszerint különbözőek. Például minden embernek van szem-színe, de az egyes emberek szem-színei eltérnek egymástól.
Másrészt viszont az objektumok metódusai azonosak az osztályban, attól eltekintve, hogy a metódusok függnek a mezőváltozók (röviden mezők) értékeitől és a metódusok argumentumaitól.
A fentiek az objektumok futási alakjában is tükröződnek. Minden objektumnak külön memóriaterülete van a mezők tárolására, de az aktuális metódusokat az osztály objektumai megosztva használják.
Egy hétköznapi analógia az osztály és az objektum viszonyára a tésztaforma és a tészta kapcsolata. Egy tésztaformával sok tésztát készíthetünk. Csak egy osztályról van szó, de sok objektum tartozhat ebbe az osztályba. Minden objektum az osztály egy példánya.
1. példa: Az autó osztály
Tegyük fel, hogy egy forgalom szimulációs programot akar írni, amely figyeli a kereszteződésen áthaladó autókat. Minden autónak van sebessége, maximális sebessége és rendszámtáblája, amely egyértelműen azonosítja. A tradicionális programozási nyelvekben két float és egy string típusú változót definiálna minden autó számára. Egy osztállyal ezeket egyetlen dologba integrálhatja:
class Car {
String rendszamTabla;
double sebesseg;
double maxSebesseg;
}
Ezeket a változókat (rendszamTabla, sebesseg és maxSebesseg) az osztály tagváltozóinak, példányváltozóinak vagy mezőinek nevezzük.
A mezők azt mutatják meg, hogy mi is az osztály, milyen tulajdonságai (property) vannak.
Egy objektum nem más mint az osztálynak egy specifikus példánya, amely egyedi értékekkel bír a mezők tekintetében.
Objektumok létrehozása a new kulcsszóval
class Car {
String rendszamTabla;
double sebesseg;
double maxSebesseg;
}
Egy objektum létrehozásához a Jávában a new kulcsszót kell használnunk, melyet az osztály konstruktora követ. Egy új Car objektum létrehozása, ha az új objektumnak a c nevet adjuk:
Car c;
c = new Car();
Az első szó, a Car a c változó típusát deklarálja. Az osztályok típusát és az osztálytípus változókat deklarálni kell, csak úgy mint az egészeket vagy a stringeket.
A new kulcsszó a konstuktor operátor.
Végül a Car() egy metódus. A zárójel jelzi, hogy ez egy metódus és nem egy adattípus mint például a Car. Ez a konstruktor metódus vagy röviden konstruktor, amely létrehozza az osztály egy új példányát. A konstruktor metódus definiálásáról később lesz szó, most csak annyit, ha nem definiál konstruktor metódust, akkor a fordító egy default konstruktort szúr be, aminek nincs argumentuma.
A fentieket gyakran egyetlen sorba írjuk:
Car c = new Car();
A mezőváltozó hozzáférési szeparátora
class Car {
String rendszamTabla;
double sebesseg;
double maxSebesseg;
}
Ha már konstruáltunk egy autót, valamit tenni is akarunk vele. Az autó példányváltozóihoz való hozzáféréskor a . szeparátort használjuk. A Car osztálynak három példányváltozója van:
rendszamTabla
sebesseg
maxSebesseg
Ezért, ha a c egy Car objektum, akkor a c szintén három példányváltozóval rendelkezik:
c.rendszamTabla
c.sebesseg
c.maxSebesseg
Ezeket más változókhoz hasonlóan használhatja. Például:
Car c = new Car();
c.rendszamTabla = "HQS 256";
c.sebesseg = 70.0;
c.maxSebesseg = 123.45;
System.out.println(c.rendszamTabla + " sebessége "
+ c.sebesseg + "km/óra.");
A . szeparátor válsztja ki a Car osztály egy objektumát a neve szerint.
Egy Car objektum használata egy másik osztályban
class Car {
String rendszamTabla;
double sebesseg;
double maxSebesseg;
}
A következő program létrehoz egy új autó objektumot, értéket ad a mezőváltozóinak és kinyomtatja azokat:
class CarTest {
public static void main(String args[]) {
Car c = new Car();
c.rendszamTabla = "HQS 256";
c.sebesseg = 120.0;
c.maxSebesseg = 145.00;
System.out.println(c.rendszamTabla + " sebessége " +
c.sebesseg + "km/óra.");
}
}
Ez a program nemcsak a CarTest osztályt, hanem a Car osztályt is igényli. Hogy a dolog működjön, tegye a Car osztályt egy Car.java nevű fájlba, a CarTest osztályt pedig egy CarTest.java nevű fájlba. Mindkét fájlt tegye ugyanabba a könyvtárba. Azután fordítsa le a szokásos módon mindkét fájlt. Végül futtassa a CarTest programot. Például,
> javac Car.java
> javac CarTest.java
> java CarTest
HQS 256 sebessége 120.0 km/óra.
Figyelje meg, hogy a Car-ban nincs main() metódus, ezért az nem futtatható. Ez csak akkor létezik, ha más main() metódussal rendelkező program hívja.
Tagváltozók és lokális változók
class Car {
String rendszamTabla; // tagváltozó
double sebesseg; // tagváltozó
double maxSebesseg; // tagváltozó
}
Az eddig látott programok struktúrája igen egyszerű volt. Mindegyik csak egyetlen osztályból állt. Ez az oszály egyetlen metódust, a main()-t tartalmazta, s ez utóbbi tartalmazta a program logikáját és változóit. Ezek a változók lokálisak voltak a main() metódusban, s nem voltak hozzáférhetők a main() metóduson kívülről. Ezeket a változókat lokális változónak nevezzük.
A Car osztály rendszamTabla, sebesseg és maxSebesseg változói azonban egy Car objektumhoz tartoznak, nem pedig egy individuális metódushoz. Ezek az összes metódusok kívül, de az osztályon belül vannak definiálva, s különböző metódusokban használva. Ezek az ún. tagváltozók vagy mezőváltozók.
Tagváltozó (member variable), példányváltozó (instance variable), mezőváltozó (field variable) és mező (field) ugyanannak a dolognak más elnevezése. A Java nyelvben a mezőváltozó a preferált. Ezzel szemben a C++ nyelvben a tagváltozó használata az elterjedtebb.
Egy tag nem azonos a tagváltozóval vagy a mezővel. A tagok magukba foglalják a mezőket és a metódusokat is.
Metódusok
Az adattípusoknak nincs sok haszna, ha nem tudunk velül valamit tenni. Erre a célra szolgálnak az osztályok metódusai. A mező azt mondja meg, hogy mi egy osztály, a metódusok pedig azt, hogy mit csinálegy osztály. A mezőket és a metódusokat együttesen az osztály tagjainak is hívjuk.
Az eddigi osztályainkban általában csak egyetlen metódus, a main() szerepelt. Azonban általában az osztályok több különböző metódust tartalmaznak különböző dolgok elvégzésére. Például a Car osztálynak lehet egy olyan metódusa, amely a kocsit a maximális sebességre állítja be:
class Car {
String rendszamTabla; // pl. "HQS 256"
double sebesseg; // km/óra
double maxSebesseg; // km/óra
// maximális sebességre gyorsítás
// a gázpedál teljes benyomása
void floorIt() {
this.sebesseg = this.maxSebesseg;
}
}
A mezők ugyanazok mint korábban, de most egy floorIt() nevű metódust is tartalmaz az osztály. Ez a metódus a void Java kulcsszóval kezdődik, ez a metódus vissztérési értéke. Minden metódusnak kell lenni visszatérési értékének, ami vagy void vagy valamilyen adattípus pl. int, byte, float, vagy String, sőt bármilyen objektum is lehet. A visszatérési érték azt mondja meg, hogy milyen értéket kell visszaadni a hívó metódusnak, ha az összes számítás el lett végezve a metódusban. Ha például a visszatérési érték int, akkor ezt a metódust bárhol használhatja, ahol egy int konstanst is használhat. Ha a visszatérési érték void, akkor a metódus nem ad vissza értéket.
A floorIt a metódus neve. Ezt a nevet két üres zárójel követi. A metódusnak átadandó argumentumokat ezen zárójelek között kell felsorolni, ennek a metódusnak azonban nincsennek argumentumai. Végül a nyitó kapcsos zárójellel ( { ) kezdődik a metódus törzse.
Most a metóduson belül csak egyetlen utasítás van:
this.sebesseg = this.maxSebesseg;
Figyeljük meg, hogy a Car osztályon belül a mezőneveket a this kulcsszó előzi meg, ez arra utal, hogy a jelenlegi objektum mezőjére hivatkozunk.
Végül a floorIt() metódust egy } zárja le, majd az osztályt egy másik }.
A metódusok hívása
class Car {
String rendszamTabla; // pl. "HQS 256"
double sebesseg; // km/óra
double maxSebesseg; // km/óra
// maximális sebességre gyorsítás
// a gázpedál teljes benyomása
void floorIt() {
this.sebesseg = this.maxSebesseg;
}
}
A Car osztályon kívül ugyanúgy hívhatja a floorIt() metódust, ahogy egy mezőre hivatkozott, azaz annak az objektumnak a nevéhez kapcsolja a metódus nevét a . szeparátorral, amelyiknek a sebességét be akarja állítani.
class CarTest2 {
public static void main(String args[]) {
Car c = new Car();
c.rendszamTabla = "HQS 256";
c.sebesseg = 0.0;
c.maxSebesseg = 123.45;
System.out.println(this.rendszamTabla +
" sebessége " + this.sebesseg +
" km/óra.");
c.floorIt();
System.out.println(this.rendszamTabla +
" sebessége " + this.sebesseg +
" km/óra.");
}
}
A kimenet:
HQS 256 sebessége 0.0 km/óra.
HQS 256 sebessége 123.45 km/óra.
A floorIt() metódus teljes egészében a Car osztályon belül van. A Java programban minden metódus egy osztályhoz tartozik. A C++ programoktól eltérően a Java programban nem lehetnek a globális térben "kódorgó" metódusok, melyek mindazt megcsinálják, amiről az osztályokon belül megfeledkezett.
Burkolt (implied) this
class Car {
String rendszamTabla; // pl. "HQS 256"
double sebesseg; // km/óra
double maxSebesseg; // km/óra
void print() {
System.out.println(rendszamTabla + " sebessége " + sebesseg +
" km/óra ");
}
}
A Car osztályon belül nem feltétlenül szükséges a mezőnevek elé tenni a this. prefixet mint pl. this.rendszamTabla vagy this.sebesseg. Egyszerűen írhatja rendszamTabla és sebesseg. Azaz a this. burkolt használata megengedett. Ez azért van, mert a print() metódust a Car osztálynak egy specifikus példányával kell hívi, s ez a példány tudja, hogy mi az ő adata. Másképpen nézve, minden objektumnak megvan a saját print() metódusa.
Argumentumok átadása a metódusoknak
Általában nem javasolt a mezőkhöz való közvetlen hozzáférés. Sokkal inkább illik az objektum orientált filozófiába, ha a mezőkhöz csak metódusokon keresztül férünk hozzá. Ez lehetővé teszi egy osztály implementációjának megváltoztatását, anélkül hogy az interfészt meg kellene változtatni. Továbbá lehetővé teszi a mezők értékeire korlátok alkalmazását és azok betartásának ellenőrzését.
Tegyük fel, hogy más objektumnak lehetővé akarjuk tenni egy Car objektum sebesseg mezőjének a megváltoztatását. Ekkor a Car osztálynak egy accelerate() metódust kell biztosítania. Ez a metódus nem fogja megengedni, hogy túllépjük a maximális sebességet vagy hogy 0 km/h alá csökkentsük azt.
void accelerate(double deltaV) {
this.sebesseg = this.sebesseg + deltaV;
if (this.sebesseg > this.maxSebesseg) {
this.sebesseg = this.maxSebesseg;
}
if (this.sebesseg < 0.0) {
this.sebesseg = 0.0;
}
}
A metódus első sorát aláírásnak (signature) nevezik. A
A void accelerate(double deltaV)
aláírás most azt mondja meg, hogy az accelerate() nem ad visszatérési értéket és csak egy argumentuma van, egy double típus, amelyre a metóduson belül a hivatkozás a deltaV névvel történik.
A deltaV egy formális argumentum.
A Java a metódusok argumentumait érték és nem referencia szerint adja át (ez objektumok esetén nem igaz, azok esetében már a referencia adódik át).
Természetesen több mint egy argumentum adható át egy metódusnak. Ezeket vesszővel elválasztva adjuk meg. Például
void setNameURLDescription(String s1, String s2, String s3) {
this.name = s1;
this.url = s2;
this.description = s3;
}
bár ez egy mesterként példa, melyet senki nem fog a gyakorlatban használni.
Példa a paraméterek átadására
class Car {
String rendszamTabla; // pl. "HQS 256"
double sebesseg; // km/óra
double maxSebesseg; // km/óra
// gyorsítás maximális sebességre
// gázpedál teljes benyomása
void floorIt() {
this.sebesseg = this.maxSebesseg;
}
void accelerate(double deltaV) {
this.sebesseg = this.sebesseg + deltaV;
if (this.sebesseg > this.maxSebesseg) {
this.sebesseg = this.maxSebesseg;
}
if (this.sebesseg < 0.0) {
this.sebesseg = 0.0;
}
}
}
class CarTest3 {
public static void main(String args[]) {
Car c = new Car();
c.rendszamTabla = "HQS 256";
c.sebesseg = 0.0;
c.maxSebesseg = 123.45;
System.out.println(c.rendszamTabla +
" sebessége " + c.sebesseg +
" km/óra.");
for (int i = 0; i < 15; i++) {
c.accelerate(10.0);
System.out.println(c.rendszamTabla +
" sebessége " + c.sebesseg +
" km/óra.");
}
}
}
Itt a fenti program kimenete:
> java CarTest3
HQS 256 sebessége 0.0 km/óra.
HQS 256 sebessége 10.0 km/óra.
HQS 256 sebessége 20.0 km/óra.
HQS 256 sebessége 30.0 km/óra.
HQS 256 sebessége 40.0 km/óra.
HQS 256 sebessége 50.0 km/óra.
HQS 256 sebessége 60.0 km/óra.
HQS 256 sebessége 70.0 km/óra.
HQS 256 sebessége 80.0 km/óra.
HQS 256 sebessége 90.0 km/óra.
HQS 256 sebessége 100.0 km/óra.
HQS 256 sebessége 110.0 km/óra.
HQS 256 sebessége 120.0 km/óra.
HQS 256 sebessége 123.45 km/óra.
HQS 256 sebessége 123.45 km/óra.
HQS 256 sebessége 123.45 km/óra.
Állító (setter) metódusok
Az állító metódusoknak (melyeket mutátor metódusoknak is neveznek) csak az a feladatuk, hogy egy mezőváltozó értékét a metódus argumentumával meghatározott értékre beállítsák. Ezeknek a metódusoknak a visszaadott értéke csaknem minden esetben void.
Elterjedt szokás, hogy a setter metódusokban a mezőre a this.name használatával hivatkozunk, s az argumentumnak ugyanazt a nevet adjuk, mint a mező neve. Például
class Car {
String rendszamTabla; // pl. "HQS 256"
double sebesseg; // km/óra
double maxSebesseg; // km/óra
// setter metódus a rendszámtábla értékének megváltoztatására
void setrendszamTabla(String rendszamTabla) {
this.rendszamTabla = rendszamTabla;
}
// gyorsítás a maxumális sebességre
// a gázpedál teljes benyomása
void floorIt() {
this.sebesseg = this.maxSebesseg;
}
void accelerate(double deltaV) {
this.sebesseg = this.sebesseg + deltaV;
if (this.sebesseg > this.maxSebesseg) {
this.sebesseg = this.maxSebesseg;
}
if (this.sebesseg < 0.0) {
this.sebesseg = 0.0;
}
}
}
Ha argumentumon belül a this prefix nélkül hivatkozunk egy olyan változóra, amely egyidejűleg mezőváltozóként és a metódus argumentumaként is szerepel, akkor a fordító a metódus argumentumaként fogja azt kezelni (azaz mindig a legbelsőbb hatáskörben megadott deklaráció az érvényes). Ebből következik, hogy azonos mezőváltozó és metódus argumentum esetén a metóduson belül a mezőváltozóra csak a this prefix használatával hivatkozhatunk.
Értékek visszaadása a metódusokból
Az érték visszaadását egy metódusból a metódus végén elhelyezett return kulcsszó után adjuk meg. A visszaadott érték típusát a metódus elején deklaráltuk.
Az alábbi példában a getrendszamTabla() visszaadja a Car osztály rendszamTabla mezőjének aktuális értékét.
String getrendszamTabla() {
return this.rendszamTabla;
}
Egy olyan metódust, amely egy osztály mezőváltozójának vagy tulajdonságának az értékét adja vissza, getter vagy accessor (hozzáférő) metódusnak nevezzük.
A String getrendszamTabla() aláírása azt mutatja, hogy a getrendszamTabla() egy String típusú értéket ad vissza, s nincs argumentuma. A metóduson belül a
return this.rendszamTabla;
utasítás meghatároz egy String-et, amely annak az objektumnak a rendszamTabla mezőjét tartlamazza, amelyikre a metódus meg lett hívva.
Több érték visszaadása egy metódusból
Egy metódus nem adhat vissza több mint egy értéket. Például egyetlen metódus nem adhatja vissza a rendszamTabla, sebesseg és a maxSebesseg mezőket. Tremészetesen összevonhatja őket egyetlen valamilyen típusú objektumba, s ezt az objektumot már visszaadhatja egy metódus. Ez azonban gyenge megoldás az objektum orientált programozást tekintve.
A helyes megoldás az, ha három metódust definiálunk, a getSpeed(), a getMaxSpeed(), és a getrendszamTabla() metódusokat, s mindegyik visszaad egy megfelelő értéket. Például:
class Car {
String rendszamTabla; // pl. "HQS 256"
double sebesseg; // km/óra
double maxSebesseg; // km/óra
// getter (accessor) metódusok
String getrendszamTabla() {
return this.rendszamTabla;
}
double getMaxSpeed() {
return this.sebesseg;
}
double getSpeed() {
return this.maxSebesseg;
}
// gyorsítás a maximális sebességre
// a gázpedál teljes benyomása
void floorIt() {
this.sebesseg = this.maxSebesseg;
}
void accelerate(double deltaV) {
this.sebesseg = this.sebesseg + deltaV;
if (this.sebesseg > this.maxSebesseg) {
this.sebesseg = this.maxSebesseg;
}
if (this.sebesseg < 0.0) {
this.sebesseg = 0.0;
}
}
}
Konstruktorok - I.
Az osztály egy új példányát egy konstruktor hozza létre. Inicializálja az összes változót és elvégzi a szükséges tevékenységet az osztály használatának előkészítésére. A
Car c = new Car();
sorban a Car() egy konstruktor. A konstruktor neve mindig megegyezik az osztály nevével.
Ha nem definiálunk konstruktort egy osztályban, akkor a Java biztosít egy argumentum nélküli általános konstruktort. A konstruktort az osztály nevével azonos nevű metódussal definiáljuk.
A konstruktoroknak nincs visszatérési típusuk, ennek ellenére nem szabad a void kulcsszót szerepeltetni az aláírásukban. A konstruktorok visszaadják az osztályuk egy pédányát, de ez nem explicit, hanem implicit.
A következő konstruktor metódus a rendszámot üres stringre, a sebességet nullára, a maximális sebességet pedig 120 km/h-ra inicializálja.
Car() {
this.rendszamTabla = "";
this.sebesseg = 0.0;
this.maxSebesseg = 120.0;
}
Jobb megoldás, ha a konstruktornak esetünkben három argumentuma is van, s a mezők inicializálásához ezeket az argumentumokat használja fel:
Car(String rendszamTabla, double sebesseg, double maxSebesseg) {
this.rendszamTabla = rendszamTabla;
this.sebesseg = sebesseg;
this.maxSebesseg = maxSebesseg;
}
De ha például a sebesség kezdeti értékére mindig nullát akar beállítani, akkor egy másik konstruktor:
Car(String rendszamTabla, double maxSebesseg) {
this.rendszamTabla = rendszamTabla;
this.sebesseg = 0.0;
this.maxSebesseg = maxSebesseg;
}
Konstruktorok - II.
Az alábbi program a konstruktort is tartalmazó teljes osztályt mutatja:
class Car {
String rendszamTabla; // pl. "HQS 256"
double sebesseg; // km/óra
double maxSebesseg; // km/óra
Car(String rendszamTabla, double maxSebesseg) {
this.rendszamTabla = rendszamTabla;
this.sebesseg = 0.0;
this.maxSebesseg = maxSebesseg;
}
// getter (accessor) metódusok
String getrendszamTabla() {
return this.rendszamTabla;
}
double getMaxSpeed() {
return this.sebesseg;
}
double getSpeed() {
return this.maxSebesseg;
}
// setter metódus a rendszám beállításához
void setrendszamTabla(String rendszamTabla) {
this.rendszamTabla = rendszamTabla;
}
// gyorsítás a maximális sebességre
// a gázpedál teljes benyomása
void floorIt() {
this.sebesseg = this.maxSebesseg;
}
void accelerate(double deltaV) {
this.sebesseg = this.sebesseg + deltaV;
if (this.sebesseg > this.maxSebesseg) {
this.sebesseg = this.maxSebesseg;
}
if (this.sebesseg < 0.0) {
this.sebesseg = 0.0;
}
}
}
A konstruktorok használata
A következő program a konstruktort használja az autó inicializálására, s nem a mezők közvetlen állítását:
class CarTest4 {
public static void main(String args[]) {
Car c = new Car("HQS 256", 123.45);
System.out.println(c.rendszamTabla + " sebessége "
+ c.sebesseg + " km/óra.");
for (int i = 0; i < 15; i++) {
c.accelerate(10.0);
System.out.println(c.rendszamTabla +
" sebssége " + c.sebesseg + " km/óra.");
}
}
}
A fenti konstruktor használatával nem szükséges tudnunk a rendszamTabla, sebesseg és maxSebesseg mezőkről. Minden amit tudnunk kell csak az, hogyan hozunk létre egy új autót és hogyan íratunk ki.
Megkérdezheti, hogy a setrendszamTabla() metódusra szükség van-e még, hiszen a konstruktorral beállítjuk ezt a mezőt. Esetünkben ez attól függ, hogy a rendszámtábla állítását megengedjük-e a Carobjektum létrehozása után.
Bizonyos osztályok a létrehozásuk után már nem változhatnak, vagy ha megváltoznak, akkor már egy más objektumot reprezentálnak. A leggyakoribb ilyen osztály a String osztály. A string adata nem változtatható meg. Csak egy új String objektumot hozhat létre. Az ilyen objektumokat immutable objektumoknak nevezzük.
Korlátok
A konstruktorok és setter metódusok használatának egyik oka a mezőkhöz való direkt hozzáféréssel szemben a korlátok kikényszerítése. Például a Car osztályban fontos, hogy a sebesség ne legyen nagyobb a maximális sebességnél, s a sebesség és a maximális sebesség ne legyen kisebb nullánál.
Már láttunk egy példát az accelerate() metódusnál, amely nem engedte meg a sebesség beállítását a maximális sebesség fölé.
void accelerate(double deltaV) {
this.sebesseg = this.sebesseg + deltaV;
if (this.sebesseg > this.maxSebesseg) {
this.sebesseg = this.maxSebesseg;
}
if (this.sebesseg < 0.0) {
this.sebesseg = 0.0;
}
}
Ilyen korlátokat a konstruktorba is beépíthetünk. Például az alábbi Car konstruktor biztosítja, hogy a maximális sebesség nem kisebb nullánál:
Car(String rendszamTabla, double maxSebesseg) {
this.rendszamTabla = rendszamTabla;
this.sebesseg = 0.0;
if (maxSebesseg >= 0.0) {
this.maxSebesseg = maxSebesseg;
}
else {
maxSebesseg = 0.0;
}
}
Hozzáférés védelem (access protection)
A globális változók jelentik a hibák forrásának jelentős részét a legtöbb programozási nyelvben.
A legtöbb programozási nyelv, így a Java is lehetővé teszi a változók védelmét külső módosítással szemben. Ez lehetővé teszi, hogy egy osztály konzisztens maradjon, ha az osztály metódusai maguk hibátlanok. A Car osztályban például biztosítani szeretnénk, hogy más osztályból a maximális sebesség ne legyen nullánál kisebbre állítható. Azt szeretnénk, hogy a következő illegális legyen:
Car c = new Car("HQS 256", 100.0);
c.sebesseg = 150.0;
Ebben lesz segítségünkre az, hogy minden osztályhoz, mezőhöz és metódushoz a Java programokban public, private, protected vagy nem specifikált hozzáférési védelem rendelhető hozzá.
A Car osztály esetében például a védelem érdekében az alábbiakban láthatókat tehetjük. A mezőket private-nak deklaráljuk, s ezekhez csak public típusú metódusokon keresztül férünk hozzá:
public class Car {
private String rendszamTabla; // pl. "HQS 256"
private double sebesseg; // km/óra
private double maxSebesseg; // km/óra
public Car(String rendszamTabla, double maxSebesseg) {
this.rendszamTabla = rendszamTabla;
this.sebesseg = 0.0;
if (maxSebesseg >= 0.0) {
this.maxSebesseg = maxSebesseg;
}
else {
maxSebesseg = 0.0;
}
}
// getter (accessor) metódusok
public String getrendszamTabla() {
return this.rendszamTabla;
}
public double getMaxSpeed() {
return this.sebesseg;
}
public double getSpeed() {
return this.maxSebesseg;
}
// setter metóus a rendszám beállítására
public void setrendszamTabla(String rendszamTabla) {
this.rendszamTabla = rendszamTabla;
}
// gyorsítás a maximális sebességre
// a gázpedál teljes benyomása
public void floorIt() {
this.sebesseg = this.maxSebesseg;
}
public void accelerate(double deltaV) {
this.sebesseg = this.sebesseg + deltaV;
if (this.sebesseg > this.maxSebesseg) {
this.sebesseg = this.maxSebesseg;
}
if (this.sebesseg < 0.0) {
this.sebesseg = 0.0;
}
}
}
A legtöbb esetben private, protected és default hozzáférési joggal rendelkező metódusokat is használunk. Ezeket gyűjtőnéven non-public metódusoknak nevezzük.
A mezők akár védetté, akár public hozzáférésűvé is tehetők. A public mezők azonban ritkák. Ez ugyanis lehetővé tenné a programozó számára, hogy megváltoztassa az osztály implementációját.
A hozzáférési jogok négy szintje
A Java nyelv a hozzáférési jogok négy szintjét biztosítja egy objektum példányváltozóihoz és metódusaihoz való hozzáférés tekintetében. Ezek a public, protected, private és a nem specifikált.
Osztályok esetén viszont csak a public és a nem specifikált áll rendelkezésre.
Ha minden objektum számára hozzáférhetővé akar tenni egy mezőváltozót vagy metódust, akkor azt public-nak kell deklarálni.
Ezzel szemben, ha csak a saját osztályon belül akarja engedélyezni a hozzáférést a mezőváltozókhoz és a metódusokhoz, akkor azokat private-nak kell deklarálni.
Ha az azonos csomagban lévő valamennyi objektum számára engedélyezni kívánja a hozzáférést a mezőváltozókhoz és metódusokhoz, akkor nem kell deklarálni a hozzáférési jogot. Ez a default védelmi szint.
Végül, ha az azonos csomag osztályain kívül az osztály szubosztályaiban is engedélyezni kívánja a hozzáférést, akkor a deklaráció protected.
Az osztályok tekintetében a public specifikációjúakhoz bárhonnan hozzá lehet férni, a specifikálatlanokhoz viszont csak az azonos csomagból.
Alapértelmezésben (default) az Ön által írt valamennyi osztály azonos csomagban van. De ezek más csomagban vannak mint az olyan Java osztályok mint System vagy Applet.
Egy objektum public mezői és metódusai bárhonnan elérhetők, ahol maga az objektum látható. Mivel bárki hozzáférhet a public tagokhoz, ezeket minimális értéken kell tartani. Nagyon egyszerű esetektől eltekintve a mezőknek nem szabad public tipusúnak lenni.
Táblázatos formában ide kattintva láthatja a védelmi szinteket.
A hozzáférési védelem előnyei
A hozzáférési védelemnek három fő előnye van:
Lehetővé teszi az objektum állapotára vonatkozó korlátok kikényszerítését.
Egyszerűbb kliens interfészt biztosít. A kliens programoknak nem kell tudni semmit az osztály belsejéről, csak a public részeket.
Elválasztja az interfészt az implementációtól, lehetővé téve ezek egymástól független változtatását.
Mi legyen public? Mi legyen private?
Ökölszabályok:
Osztályok - public.
Mezők - private.
Konstruktorok - public.
Getter és setter metódusok - public.
Többi metódus - esetről-esetre aldöntendő.
Class vagy static tagok
A Jávában egy metódus vagy egy mező static-nak is deklarálható. Ez azt jelenti, hogy nem az individuális objektumokhoz, hanem magához az osztályhoz tartozik.
Ha egy változó static, akkor az osztály bármelyik objektuma megváltoztatja annak értékét, az osztály többi objektumában is meg fog változni ennek a változónak az értéke.
Egy lehetséges alkalmazás a static metódusok és mezők számára az osztály verziójával kapcsolatos információ. Egy static String mező (legyen neve version) arra használható, hogy tárolja az információt az osztály verziójáról, s ennek értékét a static getVersion() adja vissza.
Az alábbi program egy olyan Car osztályt tartalmaz, amelyben megtalálható egy static version mező és egy getVersion() metódus.
public class Car {
private String rendszamTabla; // pl. "HQS 256"
private double sebesseg; // km/óra
private double maxSebesseg; // km/óra
static String version = "1.0";
public Car(String rendszamTabla, double maxSebesseg) {
this.rendszamTabla = rendszamTabla;
this.sebesseg = 0.0;
if (maxSebesseg >= 0.0) {
this.maxSebesseg = maxSebesseg;
}
else {
maxSebesseg = 0.0;
}
}
// getter (accessor) metódusok
public String getrendszamTabla() {
return this.rendszamTabla;
}
public double getMaxSpeed() {
return this.sebesseg;
}
public double getSpeed() {
return this.maxSebesseg;
}
public static String getVersion() {
return version;
}
// setter metódusok
public void setrendszamTabla(String rendszamTabla) {
this.rendszamTabla = rendszamTabla;
}
public void floorIt() {
this.sebesseg = this.maxSebesseg;
}
public void accelerate(double deltaV) {
this.sebesseg = this.sebesseg + deltaV;
if (this.sebesseg > this.maxSebesseg) {
this.sebesseg = this.maxSebesseg;
}
if (this.sebesseg < 0.0) {
this.sebesseg = 0.0;
}
}
}
Hivatkozás a static tagokra
Ha egy mező vagy metódus static deklarációjú, akkor a hivatkozás nem az objektum, hanem az osztály nevével történik. Ezért, ahelyett hogy a következőket írnánk:
Car c = new Car("HQS 222", 89.7);
String s = c.getVersion();
a helyes megoldás:
String s = Car.getVersion();
Sőt az osztálynak egyetlen példányát sem kell feltétlenül létrehozni, hogy egy static metódust meghívhassunk.
A static metódusok a nem-static metódusokat vagy az azonos osztály tagjait közvetlenül nem hívhatják. Hanem specifikálniuk kell, hogy az osztály melyik példányára hivatkoznak. Ez egy tipikus hiba, melyet a fordító az alábbiak szerint jelez:
Error: Can't make static reference to method void print() in
class test.
toString() metódusok
A Jávában a System.out.println() használatával nyomtathatunk ki bármilyen objektumot. Azonban a jó eredmény érdekében szükségünk van egy toString() metódusra, amely az objektum adatait értelmes módon formattálva ad vissza egy stringet. Egyébként csak az osztály neve nyomtatódik ki, s általában nem erre van szüksége. Például egy jó toString() metódus a Car osztály számára a következő lehetne:
public String toString() {
return (this.rendszamTabla + " sebessége " + this.sebesseg
+ "km/óra, a maximális sebessége pedig "
+ this.maxSebesseg +"km/óra.");
}
-------------
Elmélet
Objektum, adat, program
Objektum
A valós világban előforduló dolgokat objektumoknak nevezzük. Egy objektumnak rengeteg
olyan mérhető és nem mérhető jellemzője van, amelyek alapján az objektum felismerhető. Az
objektumnak vannak adatai (tulajdonságai), és van valamilyen, algoritmusokkal leírható viselkedésmódja. Az autónak például van márkája és rendszáma, és képes haladni. Az autó az
objektum, a márka és a rendszám az autó adatai, a „halad” pedig az autó viselkedésmódja.
Objektum: A valós világban előforduló dolog, melynek vannak adatai és van viselkedésmódja.
Program: A számítógép számára érthető instrukciók sorozata, mely az adatok megfelelő
számításaival és mozgatásaival egy feladat megoldását célozza.
Szoftver: Egy számítógépes rendszer meg nem fogható, nem fizikai összetevői.
Forráskód (forrásprogram): A fordítóprogram által lefordítandó szöveg, illetve szöveges
állomány.
Forrásprogram szerkesztése: A forráskód megírása, javítása szövegszerkesztő program
(editor) segítségével.
Program fordítása: A forráskód átalakítása a számítógép által érthető tárgykóddá, illetve
egy közbenső bájtkóddá. A fordítást a fordítóprogram (compiler) végzi.
Programszerkesztő (linker): Program, amely a lefordított tárgykódokat összeszerkeszti,
futtatható állapotba hozza.
Interpreter: Értelmező program, mely a forrásprogramot vagy a bájtkódot utasításonként
értelmezi, fordítja le, és hajtja végre.
Program futtatása: Egy adott számítógépen a tárgykód, illetve bájtkód végrehajtása. Bájtkód esetén a tényleges futtatás előtt még egy fordítás, illetve értelmezés szükséges.
Az algoritmus fogalma
Az algoritmus az adatokat mozgató, manipuláló lépések, instrukciók sorozata, mely egy feladat
megoldásához vezet. Algoritmusokkal a hétköznapokban is lépten-nyomon találkozunk: egy
algoritmus sokféleképpen adható meg, például: szóban, rajzban, írásban vagy egy programozási nyelven. Egy számítógép által érthető algoritmust programnak nevezünk
Nincsenek megjegyzések:
Megjegyzés küldése