Gyakorlati alapok I.
Írjunk ki a konzolra mindenfélét a System.out.println() függvénnyel!
Ez a függvény pontosan arra való, amire neve is utal: segítségével mindenféle bemeneti, kimeneti vagy átmeneti adatot tudunk a konzolra kiírni. Ennél azonban jóval többet tud, amint az alábbiakban ki fog derülni.
A legelső probléma, amellyel a függvény használatakor szembesülünk, a függvény nevének leírása. Természetesen kedvező számunkra, ha megtanulunk kódot gépelni, ám a programozók többsége ebből a szempontból rendkívül lusta és mindig keresik az egyszerűsítési lehetőségeket. Tehát alapvetően mindig ezt kell begépelnünk: System.out.println().
Egyszerűbben és gyorsabban:
-
írjuk be a syso szót,
-
nyomjunk egy CTRL + Space billentyűkombinációt,
-
a felbukkanó listában kattintsunk a sysout - print to standard out szövegre,
-
ennek hatására System.out.println() inzertálásra kerül.
Bevezetésként ismételjük meg a lehető legegyszerűbb programunkat, amely egy Hello World! üdvözletet ír ki a konzol-képernyőre:
public class Main {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
Végeredmény:
Hello World!
Láthatjuk, hogy a szöveget a System.out.println() függvény bemeneti paramétereként adtuk meg: tehát a zárójelek közé kettős aposztróffal illesztve:
System.out.println("Ilyen módon itt bármilyen szöveget kiírhatunk");
Sőt, a + jel különböző szövegek összeillesztését is lehetővé teszi:
System.out.println("Ilyen módon itt bármilyen szöveget kiirathatunk"
+ " és ehhez hozzá is fűzhetünk"
+ " akár több sorban, "
+ "sőt még ide is.");
Természetesen a System.out.println() függvény ennél jóval sokoldalúbb. Az alábbi kódban int típusú végeredményt (c) írunk ki vele:
public class Main {
public static void main(String[] args) {
int a = 1;
int b = 2;
int c = a + b;
System.out.println(c);
}
}
Végeredmény:
3
A c változó deklarációját akár el is hagyhatjuk; ekkor az egész műveletet bemeneti paraméterként adjuk meg:
public class Main {
public static void main(String[] args) {
int a = 1;
int b = 2;
System.out.println(a + b);
}
}
Végeredmény:
3
Kiemelten vigyázzunk arra, hogy a függvény számára egyértelművé tegyük a bemeneti adatok típusát. Vajon mi lesz az alábbi kód végeredménye?
public class Main {
public static void main(String[] args) {
System.out.println("5 + 4" + 5 + 4);
}
}
Végeredmény:
5 + 454
Azaz bemeneti String után a számokat is akként értékeli. Ha jobban belegondolunk, valójában semmi sem utal arra, hogy mik a szándékaink. A megoldás, hogy ezeket egyértelművé kell tennünk a függvény számára. A matematikai művelet esetén a zárójelezés már konkréttá teszi elképzeléseinket...
public class Main {
public static void main(String[] args) {
System.out.println("5 + 4" + (5 + 4));
}
}
Végeredmény:
5 + 49
...ahol 49 nem a végeredmény, hanem az 5 + 4 utolsó tagjának és az (5 + 4) = 9 összeolvadása. (Szándékosan nem formáztam, hogy ne bonyolítsam tovább.)
A System.out.println() függvény léptető operátorok feldolgozására is képes:
public class Main {
public static void main(String[] args) {
int a = 1;
++a;
System.out.println(++a);
}
}
Végeredmény:
3
Később észre fogjuk venni, hogy bemeneti paraméterként bármilyen egyszerű vagy összetett változót, objektumot, sőt velük kapcsolatos műveleteket is beadhatunk: ha az adat valamilyen módon egyáltalán megjeleníthető, akkor az a konzolon meg fog jelenni.
Az alábbi futtatható Java-kódban a System.out.println() függvény paramétermezőjébe egy kamatszámító objektumot (BankszamlaKamat(int forint)) tettünk be:
public class
Main {
public static float BankszamlaKamat(int forint){
float kamat = (forint / 100) * 5;
return kamat;
}
public static void main(String[] args) {
int belaBacsiBankszamlaja = 154444;
int szilviNeniBankszamlaja = 6543210;
System.out.println(BankszamlaKamat(belaBacsiBankszamlaja));
System.out.println(BankszamlaKamat(szilviNeniBankszamlaja));
}
}
Végeredmény:
7720.0
327160.0
A fentiek továbbgondolása céljából most írjunk ki egy másik osztályban lévő, azaz közvetlenül nem hozzáférhető String objektumot egy kicsit bonyolultabb módon, ráadásként pedig kérdezzük meg a keletkezett objektum ősosztályát (getClass())!
class Ovoda {
String gyerekNev;
}
public class Main {
public static void main(String args[]) {
Ovoda o = new Ovoda();
o.gyerekNev = "Jani";
System.out.println(o.gyerekNev);
System.out.println(o.getClass());
}
}
Végeredmény:
Jani
class Ovoda
A System.out.println() függvény paramétermezője egyéb, relációs és logikai műveletek lekezelésére is képes.
public class
Main {
public static void main(String args[]) {
int integer10 = 10;
int integer20 = 20;
System.out.println(integer10 >= integer20);
}
}
Végeredmény:
false
A végeredmény természetesen hamis (false) érték lesz, hiszen integer10 nem nagyobb vagy egyenlő integer20-nál.
public class
Main {
public static void main(String args[]) {
int integer10 = 10;
int integer20 = 20;
System.out.println(integer10 <= integer20);
}
}
Végeredmény:
true
Az összehasonlítás -bizonyos belső szabályok gondos figyelembevételével-, a String típusú objektumok esetében is működik:
public class Main {
public static void main(String args[]) {
String str1 = "Java";
String str2 = "Java";
System.out.println(str1 == str2);
String str3 = new String("Java");
String str4 = new String("Java");
System.out.println(str3 == str4);
}
}
Végeredmény:
true
false
A kiírás tömbelemek esetében is működik:
public class Main {
public static void main(String[] args) {
int[] tomb = new int[10];
for(int i = 0; i < tomb.length; i++){
tomb[i] = i;
System.out.print(tomb[i] + " ");
}
}
}
Végeredmény:
0 1 2 3 4 5 6 7 8 9
Amint megfigyelhetjük, most nem println, hanem csak print utasítást adtam meg, amelynek hatására a kiírás nem függőlegesen, hanem vízszintesen történt meg. Itt érdemes egyúttal megjegyezni a sorkihagyás utasítását, amely:
System.out.println();
A kiírás tömbelemek esetében is működik:
public class Main {
public static void main(String[] args) {
int[] tomb = new int[10];
for(int i = 0; i < tomb.length; i++){
tomb[i] = i;
System.out.println(tomb[i]);
}
}
}
Végeredmény:
0
1
2
3
4
5
6
7
8
9
Nézzünk tovább relációs és logikai műveleti lehetőségeket!
public class Main {
public static void main(String args[]) {
boolean HAMIS = false;
boolean IGAZ = true;
System.out.println(HAMIS == IGAZ);
System.out.println(HAMIS != IGAZ);
}
}
Végeredmény:
false
true
A fenti műveletek jelei, főként a logikai egyenlőség jele (==) nem tévesztendő össze az értékadás jelével (=)! (Az értékadás-értékhozzárendelés operátorai és a Logikai operátorok című fejezetek)
public class
Main {
public static void main(String args[]) {
int integer10 = 10;
int integer20 = 20;
System.out.println(integer10 = integer20);
}
}
Végeredmény:
20
public class
Main {
public static void main(String args[]) {
boolean b = false;
System.out.println(b = true);
}
}
Végeredmény:
true
Most nézzük meg a 3 alapvető logikai művelet, az ÉS (&&), a VAGY (||) és a NEM (!) System.out.println() belüli működését!
public class Main {
public static void main(String[] args) {
boolean IGAZ = true;
boolean HAMIS = false;
System.out.println(IGAZ && HAMIS);
System.out.println(IGAZ || HAMIS);
System.out.println(!IGAZ);
}
}
Végeredmény:
false
true
false
Sőt, segítségükkel még ennél komplexebb műveleteket is beprogramozhatunk:
public class Main {
public static void main(String[] args) {
int a = 5;
int b = 10;
System.out.println(a > 10 && b > 5);
System.out.println(a > 10 || b > 5);
System.out.println( !(b > 5));
System.out.println( !(a > 10));
}
}
Végeredmény:
false
true
false
true
Még továbblépve: a függvény olyan fejlett, hogy a beviteli paramétermezőben úgymond "példányosítani", azaz egy objektumot létrehozni is lehet a new paranccsal:
class Muvelet {
int osszeadas() {
int a = 1;
int b = 2;
return a + b;
}
}
public class Main {
public static void main(String args[]) {
System.out.println(new Muvelet().osszeadas());
}
}
Végeredmény:
3
A fenti példákban a System.out.println() függvényre mindig teljes egészében hivatkoztunk. Ez alapjában véve kiválóan működött és működni is fog, bár arra is van lehetőségünk, hogy a felelős metódust előzetesen, statikusan becsatlakoztassuk az import paranccsal (import static java.lang.System.out;). Ezzel valójában sokat nem nyerünk, de mint lehetőség, mindenképpen érdemes megemlítenünk:
import static java.lang.System.out;
public class Main {
public static void main(String[] args) {
out.println("Hello World!");
out.print("Hello World!");
}
}
Végeredmény:
Hello World!
Hello World!
A rendkívül széleskörű tudása ellenére a System.out.println() függvényt nagyobbrészt eredeti, tehát konzolos adatkiíró-megjelenítő funkciója miatt használják.
Pénzes László