1. Az előadáson látott program Szamla osztályát egészítse ki egy kamat osztályváltozóval, 
ennek beállító és lekérdező metódusaival valamint az éves kamatjóváírást elvégző metódussal. 
A Bank osztály menüjét is bővítse ki.

import extra.*;

class Szamla{
  private static int utolsoSzamlaSzam=0;
  private int szamlaSzam;          
  private String tulajdonos;
  private int egyenleg;
  
  private static double kamat=2.5;
  
  public Szamla(String tulajdonos, int egyenleg){
    szamlaSzam=++utolsoSzamlaSzam;
    this.tulajdonos=tulajdonos;
    this.egyenleg=egyenleg;
  }

  public Szamla(String tulajdonos){
    this(tulajdonos,0);
  }

  public String getTulajdonos(){
    return tulajdonos;
  }

  public void setTulajdonos(String tulajdonos){
    this.tulajdonos=tulajdonos;
  }

  public void befizet(int osszeg){
    if(osszeg>=0)
      egyenleg+=osszeg;
  }

  public int kivesz(int osszeg){
    if(osszeg>=0 && osszeg<=egyenleg)
      egyenleg-=osszeg;
    return egyenleg;
  }

  public String toString() {
    return "Szamlaszam: "+szamlaSzam+" Tulajd.: "+tulajdonos+" Egyenleg: "+egyenleg;
  }
  
  
  public static double getKamat(){
    return kamat;
  }
  
  
  public static void setKamat(double k){
    if(k>=0) kamat=k;
  }
  
  public void kamatjovairas(){
    egyenleg*=(1+kamat/100);
  }
  
}//Számla osztály vége


public class Bank2 {
  private Szamla szamla1, szamla2;

  public Bank2() {
    szamla1 = new Szamla("Kiss Istvan", 1000000);
    szamla2 = new Szamla("Nagy Peter");
  }

  public void ugyfelKiszolgalas(Szamla szamla) {
    char valasz; 
    do{
      valasz = Character.toUpperCase(Console.readChar("B(efizet)/K(ivesz)"));
    }while(valasz!='B' && valasz!='K');
    if (valasz == 'B') 
      szamla.befizet(Console.readInt("Mennyit fizet be? "));
    else{
      int egyenleg = szamla.kivesz(Console.readInt("Mennyit vesz ki? "));
      System.out.println("Maradek egyenleg "+egyenleg+" Ft");
    }
  }

  public void menu() {
    char valasz;
    do{
      System.out.println("\n\n"+szamla1);
      System.out.println(szamla2);
      System.out.println("\n1: 1. ugyfel kiszolgalasa");
      System.out.println("2: 2. ugyfel kiszolgalasa");
      System.out.println("3: 3. kamatjovairas");
      System.out.print  ("V: Vege ");
      valasz = Character.toUpperCase(Console.readChar());
      switch (valasz) {
        case '1': ugyfelKiszolgalas(szamla1); break;
        case '2': ugyfelKiszolgalas(szamla2); break;
        case '3': szamla1.kamatjovairas(); szamla2.kamatjovairas(); break;
      }
    }while (valasz!='V');
  }

  public static void main(String[] args) {
    Bank2 otp = new Bank2();
    otp.menu();
  }
}//Bank osztály vége

--------------------------------------------------------

2. Borfesztivált rendeznek, ahol egy nagy hordóból bort osztanak. 
Készítsen egy Hordo osztályt, melynek adatai: kapacitás, mennyiség. 
A konstruktora paraméteren keresztül inicializálja a kapacitást, és töltse tele. 
Készítse el az alábbi metódusokat: 
- van: a paramétereként megadott mennyiség van-e még a hordóban; 
- kitolt: paraméterként kapja a kitölteni kívánt mennyiséget. Ha van benne annyi, kitölti és igaz értékkel tér
 vissza, ha nincs benne annyi, akkor nem tölt ki semennyit és hamis értékkel tér vissza; 
- toString: kiírja a hordó adatait.
Írjon egy vezérlő osztályt, és osztogasson bor, amíg el nem fogy.

import extra.*;

class Hordo {
  private double kapacitas, mennyiseg;

  public Hordo(double kapacitas) {
    this.kapacitas = kapacitas;
    mennyiseg = kapacitas;
  }

  public boolean van(double menny) {
    return mennyiseg >= menny;
  }

  public boolean kitolt(double menny) {
    boolean ok = van(menny);
    if (ok)
      mennyiseg -= menny;
    return ok;
  }

  public String toString() {
    return "Kapacitas:"+Format.right(kapacitas,5,2)+
      "  Mennyiseg:"+Format.right(mennyiseg,5,2);
  }
}

public class Borfesztival {
  private Hordo hordo;

  public Borfesztival() {
    hordo = new Hordo(100);
  }

  public void osztogat() {
    do {
      System.out.println(hordo);  
      double menny = Console.readDouble("Mennyit? ");
      if (!hordo.kitolt(menny))
          System.out.println("Sajnalom, nincs annyi!");
    } while (hordo.van(0.1));
    System.out.println("Elfogyott!");
  }

  public static void main(String[] args) {
    Borfesztival borfesztival = new Borfesztival();
    borfesztival.osztogat();
  }
}

------------------------------------------------

3. Készítsen egy Tört osztályt, mely két adatot tartalmaz: számláló, nevező. 
A konstruktor paramétereken keresztül inicializálja a két adatot. 
Készítse el az osztály következő metódusait: beállító és lekérdező metódusok a két adatra ill. 
a tört értékének lekérdezésére; a tört egyszerűsítésére; paraméterben megadható számmal való bővítésére; 
toString pl: A tort erteke: 4/5. Írjon egy TörtProgram osztályt a tesztelésére.

class Tort{
  private int szamlalo;
  private int nevezo;
  
  public Tort(int szamlalo,int nevezo){
    this.szamlalo=szamlalo;
    this.nevezo=nevezo;
  }
  
  public int getSzamlalo(){
    return szamlalo;
  }
  
  public int getNevezo(){
    return nevezo;
  }

  public void setSzamlalo(int szamlalo){
    this.szamlalo=szamlalo;
  }
  
  public void setNevezo(int nevezo){
    this.nevezo=nevezo;
  }
  
  public double getErtek(){
    return 1.0*szamlalo/nevezo;
  }
  
  public void egyszerusit(){
    int sz=szamlalo;
    int n=nevezo;
    while(n!=0){
      int m=sz%n;
      sz=n;
      n=m;
    }
    szamlalo/=sz;
    nevezo/=sz;
  }
  
  public void bovit(int szam){
    szamlalo*=szam;
    nevezo*=szam;
  }
  
  public String toString(){
    return "A tort: "+szamlalo+"/"+nevezo;
  }
}

public class TortProgram{
  public static void main(String[]args){
    Tort t=new Tort(6,8);
    System.out.println(t);
    t.bovit(5);
    System.out.println(t);
    t.egyszerusit();
    System.out.println(t);
  }
}   

-----------------------------------------------------------

4. Készítsen egy Másodfokú osztályt, melynek adatai a másodfokú polinom együtthatói: a, b, c. 
A konstruktor paramétereken keresztül inicializálja az adatokat. 
A getD() metódus adja vissza a diszkriminánst, a getValósMegoldásokSzáma() a valós gyökök számát, 
getX1(), getX2() pedig a két gyököt.

class Masodfoku{
  private double a;
  private double b;
  private double c;
  
  public Masodfoku(double a, double b, double c){
    this.a=a;
    this.b=b;
    this.c=c;
  }
  
  public double getD(){
    return b*b-4*a*c;
  }
  
  public int getValosMegoldasokSzama(){
    if(getD()>0)
      return 2;
    else if(getD()==0)
      return 1;
    else
      return 0;
  }
  
  public double getX1(){
    return (-b+Math.sqrt(getD()))/2;
  }
  
  public double getX2(){
    return (-b-Math.sqrt(getD()))/2;
  }
}

//Egy példa az osztály tesztelésére:
public class MasodfokuProg{
  public static void main(String[]args){
    Masodfoku m = new Masodfoku(1, -2, 1);
    System.out.println("A diszkriminans: "+m.getD());
    if(m.getValosMegoldasokSzama()>0)
      System.out.println("A gyok: "+m.getX1());
    if(m.getValosMegoldasokSzama()>1)
      System.out.println("A masik gyok: "+m.getX1());
  }
}

---------------------------------------------

Prog. mat.
5. Készítsen egy Lista osztályt, mely egy egész számokból álló sorozat tárolására alkalmas! Adatok:
- elem: tömb a számok tárolására;
- utolso: az utolsó elem indexe;
- max: a tároló tömb kapacitása.
Metódusok:
- Lista(int max): paramétere a kapacitás;
- boolean ures(), boolean tele(): a tároló tömb üres-e ill. tele van-e;
- int hossz(): a lista elemeinek száma;
- void hozzaad(int adat): az adatot elhelyezi a lista végén; *
- int leker(int index): visszaadja a megadott indexű elemet;
- int beallit(int index, int adat): megadott indexű elem értéke az adat lesz;
- int indexe(int adat): visszaadja az adat indexét, ha nem találja, akkor -1-et;
- boolean benne(int adat): megadja, hogy az adat benne van-e a listában;
- void torol(): törli a lista elemei (kiüríti);
- void rendez(): rendezi a lista elemeit;
- int osszeg(), double atlag(): visszaadja az elemek összegét ill. átlagát.
Tesztelje az osztályt!
* „Szorgalmi feladat”: a tároló tömb mérete automatikusan nőjön a kétszeresére, ha betelt.


class Lista{
  int[] elem;
  int utolso;
  int max;
  
  public Lista(int max){
    elem=new int[max];
    this.max=max;
    utolso=-1;
  }
  
  public boolean ures(){
    return utolso==-1;
  }
  
  public boolean tele(){
    return utolso==max-1;
  }
  
  public int hossz(){
    return utolso+1;
  }
  
  public void hozzaad(int adat){
    if(tele()){
      int[] regiElem=elem;
      max*=2;
      elem=new int[max];
      for(int i=0; i&lt;max/2;i++)
        elem[i]=regiElem[i];
    }
    elem[++utolso]=adat;
  }
  
  public int leker(int index){
    return elem[index];
  }
  
  public int beallit(int index, int adat){
    int regi=elem[index];
    elem[index]=adat;
    return regi;
  }
  
  public int indexe(int adat){
    int i=0;
    while(i<hossz()&&elem[i]!=adat)
      i++;
    if(i>=hossz())
      i=-1;
    return i;
  }
 
  public boolean benne(int adat){
    if(indexe(adat)!=-1)
      return true;
    else
      return false;
  }

  public void torol(){
    utolso=-1;
  }
  
  public void rendez(){
    for(int i=0;i<hossz()-1;i++){
      int min=i;
      for(int j=i+1;j<hossz();j++)
        if(elem[j]<elem[min]) min=j;
      if(min!=i){
        int csere=elem[min];
        elem[min]=elem[i];
        elem[i]=csere;
      }
    }
  }
  
  public int osszeg(){
    int sum=0;
    for(int i=0;i<hossz();i++)
      sum+=elem[i];
    return sum;
  }
  
  public double atlag(){
    return 1.0*osszeg()/hossz();
  }
  
  public String toString(){
    String s="A lista: ";
    for(int i=0;i<=utolso;i++)
      s+=elem[i]+" ";
    return s;
  }
}

public class ListaProgram{
  public static void main(String[]args){
    Lista lista=new Lista(4);
    for(int i=1;i<=10;i++)
      lista.hozzaad(i);
    System.out.println(lista);
    lista.beallit(3,88);
    System.out.println(lista);
    System.out.println("88: "+lista.benne(88)+" "+lista.indexe(88));
    System.out.println("44: "+lista.benne(44)+" "+lista.indexe(44));
    lista.torol();
    System.out.println(lista);
    lista.hozzaad(4);lista.hozzaad(3);lista.hozzaad(5);lista.hozzaad(2);
    System.out.println(lista);
    lista.rendez();
    System.out.println(lista);
    System.out.println(lista.osszeg());
    System.out.println(lista.atlag());
  }
}

----------------------------------------------------------

Prog. mat.
6. Készítsen egy Naplo osztályt, mely tartalmazza és kezeli a tanulók adatait tároló vektort. 
A vektor elmei Tanulo osztályúak. A Tanulo osztály adatai: név, matek, magyar, töri jegy, 
valamint az összes tanulóra jellemző határ átlag (pl. 3.5), amely alatt tandíjat kell fizetni. 
A konstruktor paraméteren keresztül inicializálja a nevet. Metódusok:
- beállító és lekérdező metódusok az átlaghatárra és a jegyekre;
- a név lekérdezése;
- átlag lekérdezése;
- tandíjköteles-e;
- a megfelelő equals metódus
- toString a név és az átlag kiírására.
A vezérlő Naplo osztályban legyen:
- egy bevitel() metódus, mely enter végjelig feltölti a vektort, és figyelmeztet, 
ha már fel van véve a tanuló; 
- beépített listázás; 
- index szerinti listázás;
- a matek jegyek listázása;
- a tandíjkötelesek listázása;
- egy függvény, melynek visszatérési értéke a legnagyobb átlagú tanuló;
- valamint egy kereső metódus, mely a beolvasott név alapján megkeresi a tanulót, 
és kiírja az átlagát.

import extra.*;
import java.util.*;

class Tanulo{
  private String nev;
  private int matek, magyar, tori;
  private static double hatar=3.5;
    
  public Tanulo(String nev){
    this.nev=nev;
  }
  
  public static void setHatar(double aHatar){
    hatar=aHatar;
  }
  
  public static double getHatar(){
    return hatar;
  }

  public String getNev(){
    return nev;
  }

  public void setMatek(int matek){
    this.matek=matek;
  }

  public int getMatek(){
    return matek;
  }
  
  public void setMagyar(int magyar){
    this.magyar=magyar;
  }
  
  public int getMagyar(){
    return magyar;
  }
  
  public void setTori(int tori){
    this.tori=tori;
  }

  public int getTori(){
    return tori;
  }
  
  public double getAtlag(){
    return (matek+magyar+tori)/3.0;
  }
  
  public boolean fizet(){
    return getAtlag()<hatar;
  }
  
  public boolean equals(Object obj){
    return nev.equals(((Tanulo)obj).getNev());
  }
  
  public String toString(){
    return nev+Format.right(getAtlag(),5,2);
  }
  
}

public class Naplo{
  private Vector tanulok=new Vector();
  
  public void bevitel(){
    Tanulo tanulo;
    String nev=Console.readLine("\nA tanulo neve: ");
    while(!nev.equals("")){
      if(tanulok.contains(tanulo=new Tanulo(nev)))
        System.out.println("Van mar ilyen tanulo!");
      else{
        tanulo.setMatek(Console.readInt("Matek: "));
        tanulo.setMagyar(Console.readInt("Magyar: "));
        tanulo.setTori(Console.readInt("Tori: "));
        tanulok.add(tanulo);
      }
      nev=Console.readLine("\nA tanulo neve: ");
    }
  }
  
  public void lista1(){
    System.out.println("\nBeepitett lista:");
    System.out.println(tanulok);
  }
  
  public void lista2(){
    System.out.println("\nLista index szerint:");
    for(int i=0;i<tanulok.size();i++)
      System.out.println(tanulok.get(i));
  }

  public void listaMatek(){
    Tanulo tanulo;
    System.out.println("\nMatek jegyek:");
    for(int i=0;i<tanulok.size();i++){
      tanulo=(Tanulo)tanulok.get(i);
      System.out.println(tanulo.getNev()+" "+tanulo.getMatek());
    }
  }
  
  public void listaFizet(){
    Tanulo tanulo;
    System.out.println("\nTandijat fizetnek:");
    for(int i=0;i<tanulok.size();i++){
      tanulo=(Tanulo)tanulok.get(i);
      if(tanulo.fizet()) System.out.println(tanulo.getNev());
    }
  }
  
  public Tanulo maxAtlagu(){
    Tanulo max;
    if (!tanulok.isEmpty()){
      max=(Tanulo)tanulok.get(0);
      for(int i=1;i<tanulok.size();i++)
        if(((Tanulo)tanulok.get(i)).getAtlag()>max.getAtlag())
          max=(Tanulo)tanulok.get(i);
      return max;
    }else
      return null;
  }
  
  public void kereses(){
    Tanulo keresett=new Tanulo(Console.readLine("A keresett tanulo neve: "));
    int poz=tanulok.indexOf(keresett);
    if (poz>=0)
      System.out.println("Van, atlaga: "+ ((Tanulo)tanulok.get(poz)).getAtlag());
    else
      System.out.println("Nincs ilyen");
  }

    
  
  public static void main(String[]args){
    Naplo naplo=new Naplo();
    naplo.bevitel();
    naplo.lista1();
    naplo.lista2();
    naplo.listaMatek();
    naplo.listaFizet();
    System.out.println("A legjobb tanulo: "+naplo.maxAtlagu());
    naplo.kereses();
  }
}

-------------------------------------------------------
Prog. mat. 
7. Készítse el az előadáson látott bank programot úgy, hogy az tetszőleges számú számlát kezeljen. 
A menü a következő pontokból álljon: ügyfélkiszolgálás; új ügyfél felvitele; egyenleglekérdezés; 
listázás és vége. Az ügyfelek keresése számlaszám alapján történjen.
Egészítse ki a Szamla osztályt a szükséges új metódusokkal.

import extra.*;
import java.util.*;

class Szamla{
  private static int utolsoSzamlaSzam=0;
  private int szamlaSzam;          
  private String tulajdonos;
  private int egyenleg;
  
  public Szamla(String tulajdonos, int egyenleg){
    szamlaSzam=++utolsoSzamlaSzam;
    this.tulajdonos=tulajdonos;
    this.egyenleg=egyenleg;
  }

  public Szamla(String tulajdonos){
    this(tulajdonos,0);
  }
  
  public Szamla(int szamlaSzam){
    this.szamlaSzam=szamlaSzam;
  }
  
  public String getTulajdonos(){
    return tulajdonos;
  }

  public void setTulajdonos(String tulajdonos){
    this.tulajdonos=tulajdonos;
  }

  public int getEgyenleg(){
    return egyenleg;
  }

  public int getSzamlaSzam(){
    return szamlaSzam;
  }
  
  public void befizet(int osszeg){
    if(osszeg>=0)
      egyenleg+=osszeg;
  }

  public int kivesz(int osszeg){
    if(osszeg>=0 && osszeg<=egyenleg)
      egyenleg-=osszeg;
    return egyenleg;
  }

  public boolean equals(Object obj){
    return szamlaSzam==((Szamla)obj).getSzamlaSzam();
  }
  
  public String toString(){
    return "Szamlaszam: "+szamlaSzam+" Tulajd.: "+tulajdonos+" Egyenleg: "+egyenleg;
  }
}//Számla osztály vége


public class BankUj{
  private Vector szamlak=new Vector();

  public void ugyfelKiszolgalas(){
    Szamla szamla=new Szamla(Console.readInt("Szamlaszam:"));
    int poz=szamlak.indexOf(szamla);
    if(poz>=0){
      szamla=(Szamla)szamlak.get(poz);
      char valasz; 
      do{
        valasz = Character.toUpperCase(Console.readChar("B(efizet)/K(ivesz)"));
      }while(valasz!='B' && valasz!='K');
      if (valasz == 'B') 
        szamla.befizet(Console.readInt("Mennyit fizet be? "));
      else{
        int egyenleg = szamla.kivesz(Console.readInt("Mennyit vesz ki? "));
        System.out.println("Maradek egyenleg "+egyenleg+" Ft");
      }
    }else
        System.out.println("Nincs ilyen");
  }


  public void felvitel(){
    Szamla szamla=new Szamla(Console.readLine("Nev:"),Console.readInt("Nyito osszeg:"));
    szamlak.add(szamla);
  }
    
  public void lekerdezes(){
    Szamla szamla=new Szamla(Console.readInt("Szamlaszam:"));
    int poz=szamlak.indexOf(szamla);
    if(poz>=0)
      System.out.println("Egyenlege: "+((Szamla)szamlak.get(poz)).getEgyenleg());
    else
      System.out.println("Hibas szamlaszam");
  }
  
  public void lista(){
    System.out.println("\nListazas:\n"+szamlak);
  }

  public void menu(){
    char valasz;
    do{
      System.out.println("\n\n1: Ugyfelkiszolgalas");
      System.out.println("2: Uj ugyfel felvitele");
      System.out.println("3: Egyenleglekerdezes");
      System.out.println("4: Listazas");
      System.out.print  ("V: Vege ");
      valasz = Character.toUpperCase(Console.readChar());
      switch (valasz) {
        case '1': ugyfelKiszolgalas(); break;
        case '2': felvitel(); break;
        case '3': lekerdezes(); break;
        case '4': lista(); break;
      }
    }while (valasz!='V');
  }

  public static void main(String[] args) {
    BankUj bank = new BankUj();
    bank.menu();
  }
}//Bank osztály vége

------------------------------------------------------------------------
Progr. mat.
8.a, Készítsen egy Dolgozó osztályt. Adatai: személyi szám, név, életkor, munkakör, nyugdíjkorhatár. 
Ez utóbbi legyen osztályváltozó, értéke 62. Írjon konstruktort.
b, - Írjon metódust, mely megadja, hogy hány év van még hátra a nyugdíjig; 
- írjon metódust, mely visszaadja, hogy elmúlt-e 35 éves a dolgozó;
- írjon toString metódust az összes példányváltozó (csak a példányváltozók) kiírására.
c. Írjon a feladat d, és f, részének megfelelő equals metódust.
Ha a feladat további része szükségessé teszi, bővítse metódusok (konstruktorok) körét!
Írjon egy Cég osztályt, mely egy vektorban (Vector) tárolja a dolgozók adatait. Metódusai: 
d, adatfeltöltés: végjelig beolvassa a dolgozók adatait és eltárolja a vektorban, 
(ha már van ilyen dolgozó, akkor ne vegye fel; a dolgozót a személyi szám alapján azonosítjuk);
e, lista: listázza a dolgozók nevét és munkakörét (csak ezt a két adatot);
f, keres: beolvas egy személyi számot, majd megadja a nevet és a munkakört (a vektor metódusával keressünk).
g, Számolja meg, hány 60 évnél idősebb dolgozó van, számolja ki az átlagéletkort.

import extra.*;
import java.util.*;

class Dolgozo{
  private int szemsz; //lehet String is
  private String nev;
  private int kor;
  private String munka;
  private static int nyugdijkh=62;

  public Dolgozo(int szemsz){
    this.szemsz=szemsz;
  }

  public int nyugdijig(){
    return nyugdijkh-kor;
  }
  
  public boolean elmult35(){
    return kor>35;
  }
 
  public String toString(){
    return szemsz+" "+nev+"Eletkor: "+kor+" Munkakor: "+munka;
  }

  public boolean equals(Object obj){
    return szemsz==((Dolgozo)obj).getSzemsz();
  }

  public int getSzemsz(){
    return szemsz;
  }

  public void setNev(String nev){ 
    this.nev=nev;
  }

  public void setKor(int kor){ 
    this.kor=kor;
  }

  public void setMunka(String munka){ 
    this.munka=munka;
  }

  public String getNev(){
    return nev;
  }

  public String getMunka(){
    return munka;
  }

  public int getKor(){
    return kor;
  }

}

public class Ceg{
  private Vector dolgozok = new Vector();

  public void bevitel(){
    Dolgozo d;
    int szemsz=Console.readInt("\nSzemelyi szam: ");
    while (szemsz!=0){
      d=new Dolgozo(szemsz);
      if (dolgozok.contains(d))
        System.out.println("Van mar ilyen dolgozo!");
      else{
        d.setNev(Console.readLine("neve : "));
        d.setKor(Console.readInt("eletkora : "));
        d.setMunka(Console.readLine("munkakore : "));
        dolgozok.add(d);
      }
      szemsz=Console.readInt("\nSzemelyi szam: ");
    }
  }

  public void lista(){
    Dolgozo d;
    System.out.println("\nLista:");
    for (int i=0; i<dolgozok.size(); i++){
      d = (Dolgozo)(dolgozok.get(i));
      System.out.println("Nev: "+d.getNev()+"  Munkakor: "+d.getMunka());
    }
  }

  public void kereses() {
    System.out.println("\nKereses:");
    Dolgozo d=new Dolgozo(Console.readInt("Szemszam: "));
    int poz = dolgozok.indexOf(d);
    if (poz >= 0)
      System.out.println("Van, nev: "+((Dolgozo)(dolgozok.get(poz))).getNev()+
          " Munkakor: "+((Dolgozo)(dolgozok.get(poz))).getMunka());
    else
      System.out.println("Nincs ilyen");
  }

  public void stat(){
    Dolgozo d;
    int idos=0,sum=0;
    for (int i=0; i<dolgozok.size(); i++){
      d = (Dolgozo)(dolgozok.get(i));
      if(d.getKor()>60) idos++;
      sum+=d.getKor();
    }
      
    System.out.println(idos+ " dolgozo idosebb 60 evnel; az atlageletkor: "+(double)sum/dolgozok.size()+" ev");
  }

  public static void main(String[] args) {
    Ceg ceg = new Ceg();
    ceg.bevitel();
    ceg.lista();
    ceg.kereses();
    ceg.stat();
  }
}