• Szerző: Sallai András
• Copyright © 2011, Sallai András
• Szerkesztve: 2011, 2013, 2014, 2019, 2021, 2023, 2024
• Licenc: CC Attribution-Share Alike 4.0 International
• Web: https://szit.hu

Alapértelmezetten mindig használunk egy osztályt, az alábbi példában ennek a neve „Program01”:

Program01

public class Program01 {
 
    public void kiir() {
        System.out.println("Alma");
    }
 
    public static void main(String [] args) {
         Program01 iro = new Program01();
         iro.kiir();
    }
}

Még mindig egyetlen osztályt használunk, amelyben több metódust és egy mezőt hozunk létre. A mező neve Nev. A név mező tulajdonképpen egy String típusú változó. Ennek beállításra és lekérdezésére hozunk létre egy setNev() és egy getNev() metódust.

Szemely.java

public class Szemely {
    //Adatmezők
    private String nev;
 
    //Metódusok
    public void setNev(String n) {
        nev = n;
    }
 
    public String getNev() {
         return nev; 
    }
 
    public static void main(String [] args) {
         Szemely ember = new Szemely();  //Osztálynév Objektum = new Osztály_Konstruktor;
         ember.setNev("Józsi");
         System.out.println("Eredmeny: " + ember.getNev());    
    }
}

1. Mire való egy osztályban a metódus?
2. Milyen kulcsszóval kezdődik egy osztály?
3. Írjon egy metódust, amely mindig 100-al tér vissza.

A következő példákban már létrehozunk más osztályokat is a főosztály mellett. Ha lehet 1 állományban csak egy osztály legyen. Ha mégis több osztályunk van, csak a főosztály legyen publikus.

Alapesetben a tulajdonságok (mezők) szabadon elérhetők. Az objektumorientált programozásnak azonban ez ellentmond.

Program01.java

public class Program01 {		
    public static void main(String args[]) {
        Szemely tanulo1 = new Szemely();
        tanulo1.nev = "Pista";
        System.out.println(tanulo1.nev());
    }
}
 
class Szemely {
    String nev;
    int kor;
    String Hajszin;
}

A következő példában az osztály mezőit bezárjuk (privát tagokká tesszük, azok csak metódusokkal változtathatók meg.)

Program01.java

public class Program01 {
    public static void main(String args[]) {
        Szemely tanulo1 = new Szemely();			
	tanulo1.adNev("Pista");
        System.out.println(tanulo1.kerNev());
    }
}
 
 
class Szemely {
    //Adatmezők
    private String nev;
    private int kor;
 
    //Metódusok
    public void adNev(String nev) {
        this.nev = nev;
    }
    public String kerNev() {
        return this.nev;	
    }
}

A kor mezőnek is létrehozhatunk egy-egy metódust

Program01.java

public class Program01 {
    public static void main(String args[]) {
        Szemely tanulo1 = new Szemely();			
	tanulo1.adNev("Pista");
        System.out.println(tanulo1.kerNev());
    }
}
 
 
class  Szemely {
    //Adatmezők
    private String nev;
    private int kor;
 
    //Metódusok
    public void adNev(String nev) {
        this.nev = nev;
    }
    public String kerNev() {
        return this.nev;	
    }
    public void adKor(String nev) {
        this.nev = nev;
    }
    public String kerKor() {
        return this.nev;	
    }
}

A konstruktorral előkészíthetjük az osztályt. A konstruktor metódus valójában akkor is létrejön ha azt nem deklaráljuk. Az osztály példányosításánál valójában ezt hívjuk meg:

Szemely tanulo1 = new Szemely();

Az alábbi példában konstruktort is létrehozzuk.

Program01.java

public class Program01 {
    public static void main(String args[]) {
        Szemely tanulo1 = new Szemely();			
	tanulo1.adNev("Pista");
        System.out.println(tanulo1.kerNev());
    }
}
 
 
class  Szemely {
    private String nev;
    private int kor;
 
    Szemely() {
        this.nev = "Névtelen";
    }
    public void adNev(String nev) {
        this.nev = nev;
    }
    public String kerNev() {
        return this.nev;	
    }
}

Ha adNev metódust nem használjuk a nev mezőnek akkor is lesz értéke:

Szemely tanulo1 = new Szemely();
System.out.println(tanulo1.kerNev());

1. Mit jelent az, hogy egy metódus private?
2. Mit jelent az, hogy egy metódus public?
3. Mit jelent az, hogy egy metódus protected?
4. Mi a szerepe a konstruktornak?

A nagyobb programokat külön állományokba tesszük. Minden állomány egy-egy osztály:

Szemely.java

class Szemely {
	String name;
	Integer age;
	void setName(String inName) {
		name = inName;
	}
	String getName() {
		return name;
	}
	void setAge(Integer inAge) {
		age = inAge;
	}
	Integer getAge() {
		return age;
	}
}

Program01.java

class Program01 {
	public static void main(String args[]) 	{		
		Szemely Pista = new Szemely();		
		Pista.setName("Nagy István");		
		System.out.println(Pista.getName());
 
	}
}

Az osztályokat kétféle módon használhatjuk: példányosítjuk őket, vagy az osztály nevén meghívjuk a metódust. Egy osztály nevén olyan metódusokat hívhatunk meg, amelyeket statikusnak adtunk meg.

A követkeő példában az Osztaly1 osztályból létrehozok egy o1 nevű objektum példányt. Ezek után az objektumon meghívhatjuk a metódust.

Osztaly1.java

public class Osztaly1 {
   public void m1() {
       System.out.println("Helló Világ!");
   }
}

Program01.java

public class Program01 {
    public static void main(String[] args) {
        Osztaly1 o1 = new Osztaly1();
        o1.m1();
    }
}

Ha egy osztály egyik metódusát static kulcsszóval statikussá tesszük, az osztály nevén is meghívhatjuk a metódust.

Osztaly2.java

public class Osztaly2 {
   public static void m1() {
       System.out.println("Helló Világ!");
   }
}

Program01.java

public class Program01 {
    public static void main(String[] args) {
        Osztaly2.m1();
    }
}

Láthattuk, hogy a metódusaink, osztályaik elé néha public, private, stb. módosítókat teszünk. A public egy metódus előtt azt jelenti, hogy más osztályokból is elérhetők, sőt más csomagokból, de tulajdonképpen bárhonnan elérhetők. A private, azt jeleneti, csak az aktuális osztályból érhetők el. A protected elérhető, a saját osztályból, azok alosztályaiból és az aktuális csomagból, de más csomagokból már nem. Ha nem adunk meg módosítót, akkor csak a saját osztályból és a saját csomagból érhető el.

A Java programozási nyelv megengedi, hogy egy osztályban egy másik osztályt definiáljunk. Az ilyen osztályt úgy hívjuk, hogy nested class (osztály) és az alábbiakban látunk rá egy példát:

class OuterClass {
    ...
    class NestedClass {
        ...
    }
}

A nested osztályból kétféle van: statikus és nem-statikus (static és non-static). Ha egy nested osztályt statikusnak deklarálunk, akkor a neve szimplán nested osztály. Ha nem statikus, akkor inner osztály.

class OuterClass {
    ...
    static class StaticNestedClass {
        ...
    }
    class InnerClass {
        ...
    }
}

A nested osztály egy zárt osztály tagja. A nem-statikus nested osztályok (inner) hozzáférnek más zárt osztályok tagjaihoz, még ha azok privátnak vannak deklarálva is. A statikus nested osztályok nem férnek hozzá más zárt osztályok tagjaihoz. Mint egy OuterClass tagja, egy nested osztály deklarálható private, public, protected, vagy csomag (package) private módon. Az outer osztályok csak public vagy pacakage private módban deklarálhatók.

Több ok is létezik, amiért nested osztályt érdemes használni:

• Az osztályokat csoportosítjuk és egy helyen kezeljük
• Egymásba ágyazzuk az osztályokat
• A nested osztályok olvashatóbb és karbantarthatóbb kódot eredményeznek.

Program01.java

class Program01 {
	public static void main(String args[]) 	{		
		Szemely pista = new Szemely();		
		pista.setName("Nagy István");		
		System.out.println(pista.getName());
 
	}
	static class Szemely {
		String name;
		Integer age;
		public Szemely() {}
		void setName(String inName) {
			name = inName;
		}
		String getName() {
			return name;
		}
		void setAge(Integer inAge) {
			age = inAge;
		}
		Integer getAge() {
			return age;
		}
	}
 
}

Ha már van egy osztályunk és szeretnénk azt kibővíteni az eredeti megtartása mellett, akkor az új osztályunkba az eredeti osztály összes tagját átörökítjük. A Java ezt a extends kulcsszóval képes végrehajtani.

Szabály, hogy egy osztály csak egy darab másik osztályból örökölhet.

A következő meglévő Szemely osztályból szeretnénk egy Dolgozó osztály készíteni, amelyben már több tulajdonság van tárolva, a Szemely osztályhoz képest.

Program01.java

class Szemely {
	String nev;
	int kor;
}
 
class Dolgozo extends Szemely {
	String munkakor;
	double fizetes;
}
 
class Program01 {
	public static void main(String args[]) {
		Dolgozo joska = new Dolgozo();
		joska.nev = "Nagy Jozsef";
		joska.kor = 35;
		joska.munkakor = "programozó";
		joska.fizetes = 870000;
		System.out.println(joska.kor);
	}
}

A Dolgozo osztályból további öröklés lehetséges:

Program01.java

class Szemely {
	String nev;
	int kor;
}
 
class Dolgozo extends Szemely {
	String munkakor;
	double fizetes;
}
 
class Mernok extends Dolgozo {
	String diplomaSzam;	
}
 
class Doktor extends Mernok {
	String phdSzam;
}
 
class Program01 {
	public static void main(String args[]) {
		Mernok joska = new Mernok();
		joska.nev = "Nagy Jozsef";
		joska.kor = 35;
		joska.munkakor = "programozó";
		joska.fizetes = 870000;
		joska.diplomaSzam = "ABC3483";
		System.out.println(joska.kor);
	}
}

Az abstract osztályokat eleve öröklésre szánjuk, tehát nem hozható belőle létre példány.

• Az abstract osztály metódusainak törzsét nem lehet megvalósítani, ha maga a metódus is abstract.
• Az örökölt osztályban viszont kötelező megvalósítani, ha csak nem az is abstarct.
• Egy metódus csak akkor lehet abstract, ha maga az osztály is abstract.
• Egy abstract osztály metódusainak nem kötelező abstractnak lenni.
• Az abstract osztályt nem lehet final és privat módosítóval ellátni.

Program.java

abstract class Dolgozo {
	String nev;
	int kor;
}
 
class Mernok extends Dolgozo {
	String diplomaAz;
}
 
class Lapatos extends Dolgozo {
	String szerszam;
}
 
class Program {
	public static void main(String args[]) {
		Lapatos joska = new Lapatos();
		joska.kor = 35;
		joska.szerszam = "szívlapát";
		System.out.println("Jóska szerszáma: " + joska.szerszam);
	}
}

Ha megpróbáljuk a példában szereplő Dolgozo osztályt példányosítani, akkor hibaüzenetet kapunk.

Egy metódus alakja, annak paramétereit és visszatérési értékét jelenti.

Program.java

class Dolgozo {
	String nev;
	int kor;
	void beallitKor(int atvettKor) {
		kor = atvettKor;
	}
	void beallitKor(double atvettKor) {
		kor = Double.valueOf(atvettKor).intValue();
	}
	void beallitKor(String atvettKor) {
		kor = Integer.parseInt(atvettKor);
	}
}
 
class Program {
	public static void main(String args[]) {
		Dolgozo joska = new Dolgozo();
		joska.beallitKor("5");
	}
}

Program.java

class Dolgozo {
	String nev;
	int kor;
	void beallit(int atvettKor) {
		kor = atvettKor;
	}
	void beallit(double atvettKor) {
		kor = Double.valueOf(atvettKor).intValue();
	}
	void beallit(String atvettKor) {
		kor = Integer.parseInt(atvettKor);
	}
	void beallit(int atvettKor, String atvettNev) {
		kor = atvettKor;
		nev = atvettNev;
	}
}
 
class Program {
	public static void main(String args[]) {
		Dolgozo joska = new Dolgozo();
		joska.beallit(35, "Nagy Péter");
	}
}

A következő példában a konstruktornak adunk több alakot:

Program01.java

class Szemely {
	String nev;
	int kor;
	public Szemely() {
		nev = "Névtelen";
		kor = 0;
	}
	public Szemely(String atvettNev) {
		nev = atvettNev;
		kor = 0;
	}
	public Szemely(int atvettKor){
		nev = "Névtelen";
		kor = atvettKor;
	}
	public Szemely(String atvettNev, int atvettKor){
		nev = atvettNev;
		kor = atvettKor;
	}
}
 
class Program01 {
	public static void main(String args[]) {
		Szemely joska = new Szemely();
		Szemely pista = new Szemely("Kis Pista");		
		Szemely kati = new Szemely(25);
		Szemely mari = new Szemely("Nagy Mária", 25);
	}
}

A többalakúság igazi példáját a többalakú osztályok adják. Mivel minden örökölt példányban átírhatom a metódusokat, ezért minden egyes örökölt osztályban mást és mást tehetnek a metódusok.

Program01.java

class Allat {
	String gyomor = "";
	public void eszik(String etel) {
		gyomor += etel;
	}
	public void beszel() {
		System.out.println("aaa");
	}
}
class Szamar extends Allat {
	public void beszel() {
		System.out.println("ia\'ia\'");
	}
}
class Boci extends Allat {
	public void beszel() {
		System.out.println("buuuuuuuuuu");
	}
}
class Program01 {
	public static void main(String[] args) {
		Szamar pici = new Szamar();
		pici.beszel();
		Boci mici = new Boci();
		mici.beszel();
	}
}

A többalakúság igazi kiszolgálói az elvont osztályok és metódusok.

Program01.java

abstract class Allat {
	String gyomor = "";
	public void eszik(String etel) {
		gyomor += etel;
	}
	public abstract void beszel();
}
class Szamar extends Allat {
	public void beszel() {
		System.out.println("ia\'ia\'");
	}
}
class Boci extends Allat {
	public void beszel() {
		System.out.println("buuuuuuuuuu");
	}
}
class Program01 {
	public static void main(String[] args) {
		Szamar pici = new Szamar();
		pici.beszel();
		Boci mici = new Boci();
		mici.beszel();
	}
}

Mivel az Allat osztályt elvonttá nyilvánítottam az abstract módosítóval, ezért ebből az osztályból nem lehet példányt létrehozni.

Az Allat osztály beszel() metódusa szintén elvont, azaz abstract, ezért kötelező felülírni a metódust. Az eredeti osztályban (Esetünkben az „Allat”) nem is lehet törzse, csak a fejrészt kell megadnunk.

Az interface-ek egy szabványos parancshalmazt definiálnak, amit az osztályok használhatnak. Az osztály implementálja az interfészt. A parancsok metódusokból állnak. Egy interfész a következőket tartalmazhat:

• metódus deklaráció
• nevesített állandó
• visszatérés típusa
• argumentum aláírása
• módosítók

Az osztálynak az interfész összes metódusát deklarálnia kell. Egy interface tehát olyan, mintegy abstract osztály, amelynek minden metódusa abstract.

Az interface nem rendelkezik szülő osztállyal, sem ősosztállyal, még rejtett módon sem, ellentétben az osztályokkal. Ez jól megfigyelhető a Java dokumentációban is. Minden osztálynak le van vezetve az öröklési hierarchiája, de az interfészeknek (interface) nincs ilyen.

Fentebb az abstract osztályokat és metódusokat tárgyaltuk. Ha egy osztály minden metódusát abstract módosítóval látok el, akkor az örökölt osztályban az összes metódust meg kell valósítani. Az ilyen szerkezetek helyett használhatjuk az interface-t.

Program01.java

interface Allat {
	public void eszik(String etel);
	public abstract void beszel();
}
class Szamar implements Allat {
	String gyomor = "";
	public void eszik(String etel) {, ott minden metódus virtuális.
		gyomor += etel;
	}
	public void beszel() {
		System.out.println("ia\'ia\'");
	}
}
class Boci implements Allat {
	String gyomor = "";
	public void eszik(String etel) {
		gyomor += etel;
	}	
	public void beszel() {
		System.out.println("buuuuuuuuuu");
	}
}
class Program01 {
	public static void main(String[] args) {
		Szamar pici = new Szamar();
		pici.beszel();
		Boci mici = new Boci();
		mici.beszel();
	}
}

A interfaceben nem lehet példányváltozót létrehozni, csak állandót.

Program01.java

interface Kerekpar {
	void beallitUtem(int ujUtem);
	void novelSebesseg(int novekmeny);
	void huzFek(int csokkentes);
} 
 
class HauserKerekpar implements Kerekpar {
	private int utem = 0;
	public void beallitUtem(int ujUtem) {
		utem = ujUtem;
	}
	public void novelSebesseg(int novekmeny) {}
	public void huzFek(int csokkentes) {}
	public int lekerUtem() {
		return utem;
	} 
}
 
class Program01 {
	public static void main(String args[]) {
		HauserKerekpar kerekpar = new HauserKerekpar();
		kerekpar.beallitUtem(1);
		System.out.println(kerekpar.lekerUtem());
	}
}

Program01.java

interface UdvariasSzemely {
	void koszon();
}
 
class Szemely implements UdvariasSzemely {
	String nev;
	int kor;
	public void koszon(){
		System.out.println("Szia!");
	}
}
 
class Program04 {
	public static void main(String args[]) {
 
		Szemely pista = new Szemely();
		pista.koszon();
	}
}

Program01.java

interface Alakzat {
	void beallitMeret(int szelesseg, int magassag);
	void rajzol();
}
class Tegla implements Alakzat {
	int szelesseg;
	int magassag;
	public void beallitMeret(int szelesseg, int magassag){
		this.szelesseg = szelesseg;
		this.magassag = magassag;
	}
	public void rajzol(){
		for(int i=0;i<szelesseg;i++)
			System.out.print("*");
		System.out.println();
 
		for(int j=0;j<magassag-2;j++){
			System.out.print("*");
			for(int i=0;i<szelesseg-2;i++)
				System.out.print(" ");
			System.out.print("*");
			System.out.println();
		}
		for(int i=0;i<szelesseg;i++)
			System.out.print("*");
		System.out.println();
	}	
}
 
class Program01 {
	public static void main(String args[]) {
		Tegla tegla = new Tegla();
		tegla.beallitMeret(5, 6);
		tegla.rajzol();
	}
}

Alakzat.java

public class Projekt01 {
    static void rajzolAlakzat(Alakzat alakzat) {
        alakzat.rajzol();
    }
 
    public static void main(String[] args) {
        rajzolAlakzat(new Haromszog());
        rajzolAlakzat(new Kor());
        rajzolAlakzat(new Teglalap());
    }    
}

Haromszog.java

public class Haromszog implements Alakzat {
    public void rajzol() {
        System.out.println("A");
    }
}

Kor.java

public class Kor implements Alakzat {
    public void rajzol() {
        System.out.println("o");
    }
}

Teglalap.java

public class Teglalap implements Alakzat {
    public void rajzol() {
        System.out.println("E");
    }
}

Projetk01.java

public class Projekt01 {
    static void rajzolAlakzat(Alakzat alakzat) {
        alakzat.rajzol();
    }
 
    public static void main(String[] args) {
        rajzolAlakzat(new Haromszog());
        rajzolAlakzat(new Kor());
        rajzolAlakzat(new Teglalap());
    }    
}

A this kulcsszó azt az osztályt reprezentálja, amelyben vagyunk.

Program01.java

class Dolgozo {
	public String name;
	public Dolgozo() {
		String name = "untitled";
		this.name = name;
	}
}
 
class Program02 {
	public static void main(String[] args) {
		Dolgozo joska = new Dolgozo();
		System.out.println(joska.name);
	}
}

A példánkban a Dolgozo osztály name mezője nem venné fel a Dolgozo() konstruktorban létrehozott name változó értékét, ha nem tettük volna az értékadás elejére a „this” szót. A program nélküle is lefordul, de az eredmény null lenne.

1. Mire használható a this kulcsszó?
2. Ha egy osztály egyik tagjára hivatkozok a this kulcsszóval, mi a szeparátor?

Program.java

class Dolgozo {
	String Nev;
	int Fizetes;
	void beallitKezdoFizetes() {
		Fizetes = 300100;
	}
}
 
class Mernok extends Dolgozo {
	void beallitKezdoFizetes() {
		Fizetes = 500000;
	}
}
 
class Program {
	public static void main(String args[]) {
		Mernok joska = new Mernok();
		joska.beallitKezdoFizetes();
		System.out.println(joska.Fizetes);
	}
}

A beallitKezdoFizetes() metódust felülírjuk a Mernok osztályban. Ekkor az eredeti beallitKezdoFizetes() rejtett marad a Mernok osztályban.

Van azonban lehetőség az eredeti metódus meghívására is:

Program.java

class Dolgozo {
	String Nev;
	int Fizetes;
	void beallitKezdoFizetes() {
		Fizetes = 300100;
	}
}
 
class Mernok extends Dolgozo {
	void beallitKezdoFizetes() 	{
		super.beallitKezdoFizetes();
		Fizetes = Fizetes + 200000;
	}
}
 
class Program {
	public static void main(String args[]) {
		Mernok joska = new Mernok();
		joska.beallitKezdoFizetes();
		System.out.println(joska.Fizetes);
	}
}

Az eredeti metódust a super.beallitKezdoFizetes(); utasítással hívom meg. Így megkapom a dolgozó alapfizetését és a mérnők számára ahhoz tudom hozzáadni a fizetést.

Ha létrehozok egy osztályt az örökölés során a metódusokat felülírhatjuk. A felülírható metódusokat virtuális metódusnak nevezzük. A Java nyelvben minden példánymetódus eleve virtuális, nem kell azt jelezni külön módosítóval.

Ha felülírunk egy metódust, akkor illik oda írni a „@Override” kulcsszót, de nem kötelező. Ha azonban oda írjuk fordításkor kiderülhet, ha elírtuk az átírandó metódus nevét, ezért érdemes mindig kiírni. Ezen felül vizuálisan is azonnal kiderül számunkra, hogy felülírtunk egy már meglévő metódust.

Program01.java

class Dolgozo {
	String nev;
	int kor;
	double fiz;
	public void alapfizetes() {
		this.fiz = 80000;
	}
}
class Mernok extends Dolgozo {
	@Override
	public void alapfizetes() {
		this.fiz = 350000;
	}
}
 
class Program01 {
	public static void main(String args[]) {
		Mernok lali = new Mernok();
		lali.alapfizetes();
		System.out.println(lali.fiz);
	}
}

A következő példában a toString() metódust írjuk felül, amelyet minden osztály az Object osztálytól örököl:

Program01.java

class Dolgozo {
	String nev;
	int kor;
	double fiz;
	Dolgozo(String nev, int kor, double fiz) {
		this.nev = nev;
		this.kor = kor;
		this.fiz = fiz;
	}
	@Override
	public String toString() {
		return nev + " " + kor + " " + fiz;
	}
}
 
class Program01 {
	public static void main(String args[]) {
		Dolgozo joska = new Dolgozo("Nagy József", 35, 350000);
		System.out.println(joska.toString());
 
	}
}

Az összetartozó osztályokat csomagokba rendezzük.

Készítsünk például egy „Jatek” nevű könyvtárat, majd helyezzük el benne a következő két fájlt:

Human.java

package Jatek;
 
public class Human {
    void mutat() {
	System.out.println("Ember");
    }
}

Gep.java

package Jatek;
 
public class Gep {
    public void mutat() {
	System.out.println("Gép");
    }
}

Mindkét fájl elejére a „package Jatek;” utasítást írtam. A package utasítás csak a forrásfájl elején lehet. Ezzel jelzem, hogy összetartozó névterekről van szó. Tulajdonképpen nevet adtam a névtérnek. Fordítsuk le mindkét osztályt:

javac Gep.java

javac Human.java

Most készítsünk egy névtelen névtérben egy osztály, mint azt eddig is tettük:

Program.java

import Jatek.Gep;
 
class Program {
    public static void main(String[] args) {
	Gep gep = new Gep();
	gep.mutat();
    }
}

Az első sorban importáltuk a Jatek csomagból a Gep osztályt. A szokásos módon használjuk tovább.

Ha egy osztály több csomagban is szerepel és csoportosan importáltunk (Pl.: Jatek.*), akkor előfordul, hogy a minősített nevet kell használnunk. A minősített név tulajdonképpen a csomag teljes útvonala.

Újabb példa:

Megkötés, hogy ha csomagon belül nem lehet ugyanolyan nevű osztály is, és nem használhatunk a java vagy javax kezdetű csomagneveket.

Ha szeretném elkerülni más gyártókkal való ütközést, akkor esetleg egy

hu.szit.java.jatek

nevű névtérbe rendezem az osztályaim.

• Nincs módosító. Az alapértelmezett elérés public.
• public - Az egész világ számára publikus
• private - Csak az osztályon belül érhető el.
• proteced - Csomagon belül és a származtatott osztályokban.

• static - osztálymetódus és osztályváltozó létrehozására
• final - osztály, metódus vagy változó véglegesítése
• abstract - absztrakt osztály vagy metódus létrehozása
• synchronized, volatile - szálaknál használatos

Ha egy objektum állapotát szeretnék eltárolni akkor sorosítjuk, majd egy objektumkimeneti folyammal kiírom, fájlkimeneti adatfolyamon keresztül. A visszaolvasás hasonlóan történik, amihez szintén szükséges a sorosított objektum.

Program01.java

import java.io.*;
class Dolgozo implements Serializable {
	String nev;
	Integer kor;
}
 
class Program01 {
	private static void make() throws IOException {
		Dolgozo joska = new Dolgozo();
		joska.nev = "Nagy József";
		joska.kor = 35;
		Dolgozo mari = new Dolgozo();
		mari.nev = "Kis Mária";
		mari.kor = 28;
 
		FileOutputStream fs = new FileOutputStream("adat.dat");
		ObjectOutputStream os = new ObjectOutputStream(fs);
		os.writeObject(joska);
		os.writeObject(mari);
		os.close();		
	}
	private static void load() throws IOException, ClassNotFoundException {
		Dolgozo joska = null;
		Dolgozo mari = null;
		FileInputStream fs = new FileInputStream("adat.dat");
		ObjectInputStream os = new ObjectInputStream(fs);
		joska = (Dolgozo) os.readObject();
		mari = (Dolgozo) os.readObject();
		os.close();
		System.out.println("Név: " + joska.nev);
		System.out.println("Név: " + mari.nev);
	}
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		//~ make();
		load();
	}
}

Létrehozok egy dolgozó osztályt, majd a főmetódusban egy munkas nevű tömböt, amelyben Dolgozókat lehet tárolni. Egyetlen dolgozó nevét és életkorát beállítom.

Program.java

class Dolgozo {
	private String Nev;
	private int Kor;
	public void beallitNev(String atvettNev) {
		Nev = atvettNev;
	}
	public String lekerNev() {
		return Nev;
	}
	public void beallitKor(int atvettKor) {
		Kor = atvettKor;
	}
	public int lekerKor() {
		return Kor;
	}
}
 
class Program {
	public static void main(String[] argv) {
		Dolgozo[] munkas = new Dolgozo[100];
		for(int i=0; i<100; i++)
			munkas[i] = new Dolgozo();
 
		munkas[0].beallitNev("Joska");
		munkas[0].beallitKor(30);
		System.out.println(munkas[0].lekerNev());
		System.out.println(munkas[0].lekerKor());
 
	}
}

Program01.java

import java.util.Scanner;
abstract class Eloleny {
	protected StringBuilder emesztoRendszer = new StringBuilder("sav");
	protected int uritesigHatra = 4;
	public abstract void eszik(String kaja);
	public abstract void urit();
}
class Kisallat extends Eloleny {	
	public void eszik(String kaja) {
		this.emesztoRendszer.append(kaja);
	}
	public void urit() {
		System.out.print("Űrítek: ");
		System.out.println(this.emesztoRendszer.substring(0, 4));
		this.emesztoRendszer.delete(0, 4);
	}
}
class Program01 {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		Kisallat pamacs = new Kisallat();
		System.out.println("Van egy Pamacs nevű kis állatod. Időnként etetned kell az etet paranccsal.");
		System.out.println("Pamacs mindenféle karakter eszik. A \"etet\" parancs után ad meg mit adsz neki.");
 
		String cmd = null;
 
		do {
			System.out.print("> ");
			cmd = in.nextLine();
			if(cmd.matches("etet .+")) {
				String[] t = cmd.split(" ");
				pamacs.eszik(t[1]);
			}
			if(pamacs.uritesigHatra<=0) {
				pamacs.urit();
				pamacs.uritesigHatra = 5;
			}
			pamacs.uritesigHatra--;
		}while(!cmd.equals("vege"));
	}
}

Az önálló nyomógomb megvalósítása.

Program01.java

import javax.swing.JButton;
import javax.swing.JTextField;
import javax.swing.JFrame;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.FlowLayout;
 
class SzamitGomb extends JButton implements ActionListener {
	JTextField mezo;
	SzamitGomb(JTextField mezo) {
		this.setText("Klikkelj ide");
		this.addActionListener(this);
		this.mezo = mezo;
	}
	public void actionPerformed(ActionEvent event) {
		this.mezo.setText("Teszt ok");
	}
}
class FoAblak extends JFrame {
	SzamitGomb szamitGomb;
	JTextField mezo;
	FoAblak() {
		this.mezo = new JTextField(10);
		this.szamitGomb = new SzamitGomb(mezo);
		this.add(szamitGomb);
		this.add(mezo);
		this.setLayout(new FlowLayout());
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setSize(400, 300);
		this.setVisible(true);
	}	
}
class Program01 {
	public static void main(String args[]) {
		new FoAblak();
	}
}

A világon számtalan kerékpár létezik, de mindegyiknek vannak közös állapotaik, közös jellemzőik. Az objektum-orientál világban azt mondjuk, a kerékpár egy osztály. Egy konkrét kerékpár a kerékpár osztálynak egy példánya. Tehát az osztály tulajdonképpen egy terve, amelyből létrehozzuk a konkrét kerékpárokat.

class Kerékpár {
 
       int ütem = 0;
       int sebesség = 0;
       int fokozat = 1;
 
       void cserélLépésÜtem (int újÉrték) {
            ütem = újÉrték;
       }
 
       void cserélSebességFokozat (int újÉrték) {
            hajtómű = újÉrték;
       }
 
       void sebességNövelés (int növekmény) {
            sebesség = sebesség + növekmény;   
       }
 
       void alkalmazFékezés (int csökkentő) {
            sebesség = sebesség - csökkentő;
       }
 
       void állapotNyomtatása () {
            System.out.println ("ütem: " + ütem + "sebesség: " + sebesség + "fokozat: " + fokozat);
       }
}

Objektum példák.

Az objektum a kulcsa az objektum-orientált programozás megértésének. Néz körül az életedben, nagyon sok példát találsz az objektumokra. Az asztal, a kutya, a bicikli, stb.

Minden objektumnak van valamilyen állapota. Ezek az állapotok időnként változnak.

• állapotai
  • van neve: Bodri
  • éhes: igen
  • színe: fekete
  • stb.
• állapot megváltozása
  • eszik
  • alszik
  • ugat
  • hízeleg
  • csóválja a farkát
  • stb.

• állapotai
  • kék
  • az aktuális sebessége
• viselkedése
  • gyorsul
  • fékezés történik

• állapotai
  • fel van kapcsolva
  • le van kapcsolva
• viselkedése
  • felkapcsoljuk
  • lekapcsoljuk

• állapotai
  • az aktuális állomáson van
  • valamilyen hangerő be van éppen állítva
  • üzem (be van kapcsolva, ki van kapcsolva)
• viselkedés
  • bekapcsoljuk
  • kikapcsoljuk
  • állomást keresünk
  • hangerőt állítunk

A valós világ egyes objektumai további objektumokat tartalmazhatnak. Így van ez a szoftveres objektumok esetén is. Vannak objektumok, bizonyos mezőkkel (állapotokkal) és vannak metódusok (viselkedés).