Gyakorjunk jáva nyelven

1. Írja ki a monitorra Holnap ”jo” leszek! üzenetet! ( \” )

public class Gyak2_1 {
  public static void main(String[] args) {
    System.out.println("Holnap \"jo\" leszek");
  }
}

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

2. Kérdezze meg a nevét, majd írja ki a következő
jókívánságot: Kedves X! Sikeres Java programozást!

import extra.*;
public class Gyak2_2{
  public static void main(String [] args){
    String nev;
    nev = Console.readLine("Nev: ");
    System.out.println("Kedves "+nev+"! Sikeres Java programozast!");
  }
}

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

3. Kérje be egy hasáb három élének hosszúságát, majd írja ki a hasáb
felszínét és térfogatát!

import extra.*;
public class Gyak2_3{
  public static void main(String [] args){
    int a = Console.readInt("a: ");
    int b = Console.readInt("b: ");  
    int c = Console.readInt("c: ");
    int f = 2 * (a*b + a*c + b*c);
    int v = a * b * c;
    System.out.println("A hasab felszine: " + f);
    System.out.println("A hasab terfogata: " + v);
  }
}

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

4. Kérje be egy gömb sugarát, majd írja ki a gömb felszínét és térfogatát!

import extra.*;
public class Gyak2_4{
  public static void main(String [] args){
    double r, f, v;
    r = Console.readDouble("A gomb sugara: ");
    f = 4 * r * r * Math.PI;
    v = 4 * Math.pow(r,3) * Math.PI / 3;
    //vagy: v = 4 * r *r * r * Math.PI / 3;
    System.out.println("A gomb felszine: " + Format.left(f,0,2));
    System.out.println("A gomb terfogata: " + Format.left(v,0,2));
  }
}

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

5. Kérjen be egy pénzösszeget, majd írja ki, hogy milyen címletekben lehet
minimális számú pénzzel kifizetni úgy, hogy 5000, 1000, 500, 100-as címletek
állnak rendelkezésre!

import extra.*;
public class Gyak2_5{
  public static void main(String[] args){
    int cimlet1=5000, cimlet2=1000, cimlet3=500, cimlet4=100;
    int db1, db2, db3, db4;
    int osszeg=Console.readInt("A penzosszeg: ");
    db1=osszeg/cimlet1;
    osszeg%=cimlet1;
    db2=osszeg/cimlet2;
    osszeg%=cimlet2;
    db3=osszeg/cimlet3;
    osszeg%=cimlet3;
    db4=osszeg/cimlet4;
    System.out.println(cimlet1+": "+db1+" db");
    System.out.println(cimlet2+": "+db2+" db");
    System.out.println(cimlet3+": "+db3+" db");
    System.out.println(cimlet4+": "+db4+" db");
  }
}
1. Kérje be a főnöke fizetését, aztán a sajátját. Hasonlítsa össze a két fizetés:
írjon ki egy-egy megjegyzést, ha a főnöke fizetése nagyobb, ha a sajátja nagyobb,
illetve ha egyenlő!

import extra.*;

public class Gyak3_1 {
  public static void main(String[] args) {
    int fizFonok = Console.readInt("Fonokenek fizetese: ");
    int fizSajat = Console.readInt("On fizetese: ");
    if (fizFonok > fizSajat)
      System.out.println("A fonok fizetese nagyobb, ez nem meglepo!");
    else if (fizFonok < fizSajat)
      System.out.println("Tobbet keresek, mint a fonok! Mi van itten?");
    else
      System.out.println("Ugyanannyit keresek, mint a fonok!");
  }
}

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

2. Kérje be egy telek oldalait méterben! Írja ki a telek területét négyszögölben
(1 négyszögöl=3,6m2)! Ha a telek 100 négyszögölnél kisebb, akkor írja ki,
hogy túl kicsi!

import extra.*;

public class Gyak3_2 {
  public static void main(String[] args) {
    int szel  = Console.readInt("Telek szelessege(m): ");
    int hossz = Console.readInt("Telek hosszusaga(m): ");

    double ter = szel * hossz / 3.6;
    System.out.println("Terulet: "+ter+" negyszogol");
    if (ter<100)
      System.out.println("A telek tul kicsi!");
  }
}

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

3. Kérjen be egy évszámot! Ha a beütött szám negatív, adjon hibajelzést, ha nem,
állapítsa meg, hogy az évszám osztható-e 17-tel, vagy nem!

import extra.*;

public class Gyak3_3 {
  public static void main(String[] args) {
    int evszam = Console.readInt("Evszam: ");
    if (evszam < 0)
      System.out.println("Negativ, nem jo evszam!");
    else {
      if (evszam%17==0)
        System.out.println(evszam + " oszthato 17-tel.");
      else
        System.out.println(evszam + " nem oszthato 17-tel.");
    }
  }
}

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

4. Kérjen be egy egész óra értéket. Ha a szám nem 0 és 24 óra között van, akkor adjon
hibaüzenetet, egyébként köszönjön el a program a napszaknak megfelelően! 4-9: Jó
reggelt!, 10-17: Jó napot!, 18-21: Jó estét!, 22-3: Jó éjszakát!

import extra.*;

public class Gyak3_4 {
  public static void main(String[] args) {
    int ora = Console.readInt("Ora: ");
    if (ora<0 || ora>24)
      System.out.println("Ez nem ora!");
    else if (ora>=4 && ora<=9)
      System.out.println("Jo reggelt!");
    else if (ora>=10 && ora<=17)
      System.out.println("Jo napot!");
    else if (ora>=18 && ora<=21)
      System.out.println("Jo estet!");
    else
      System.out.println("Jo ejszakat!");
  }
}

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

5. Kérjen be egy egyjegyű, nem negatív számot! Írja ki a szám szöveges formáját
(egy, kettő, stb.)!

import extra.*;

public class Gyak3_4 {
  public static void main(String[] args) {
    int szam = Console.readInt("Egyjegyu nem negativ szam: ");
    String szoveg = "";
    switch (szam) {
      case 0: szoveg = "nulla"; break;
      case 1: szoveg = "egy"; break;
      case 2: szoveg = "ketto"; break;
      case 3: szoveg = "harom"; break;
      case 4: szoveg = "negy"; break;
      case 5: szoveg = "ot"; break;
      case 6: szoveg = "hat"; break;
      case 7: szoveg = "het"; break;
      case 8: szoveg = "nyolc"; break;
      case 9: szoveg = "kilenc"; break;
    }
    System.out.println(szam+" = "+szoveg);
 
  }
}

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

Prog. mat. 6. Olvassa be Pisti, Feri és Zoli magasságát, majd írja ki, hogy melyikük a
legmagasabb! (Feltehetjük, hogy különböző magasságúak.)

import extra.*;
public class Gyak3_6{
  public static void main(String[]args){
    int pisti=Console.readInt("Pisti magassaga: ");
    int feri=Console.readInt("Feri magassaga: ");
    int zoli=Console.readInt("Zoli magassaga: ");
    if(pisti>feri&&pisti>zoli)
      System.out.println("Pisti a legmagasabb.");
    else if(feri>zoli)
      System.out.println("Feri a legmagasabb.");
    else
      System.out.println("Zoli a legmagasabb.");
  }
}

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

Prog. mat. 7. Kérjen be egy karaktert! Ha a karakter nagybetű, akkor írja ki a kisbetűs
alakját, ha kisbetű, akkor a nagybetűs alakját! (A kisbetű kódja a nagyobb, a különbség:
'a'-'A')

import extra.*;
public class Gyak3_7 {
  public static void main(String[] args) {
    char kar = Console.readChar("Karakter: ");
    int eltolas = 'a'-'A';
    if(kar>='A' && kar<='Z'){
      System.out.println("Nagybetu");
      char kis=(char)(kar+eltolas);
      System.out.println("Kisbetus forma: "+kis);
    }
    else if(kar>='a' && kar<='z'){
      System.out.println("Kisbetu");
      char nagy=(char)(kar-eltolas);
      System.out.println("Nagybetus forma: "+nagy);
    }
    else
      System.out.println("Egyeb");
  }
}

//Egy másik megoldás a Character osztály használatával

import extra.*;
public class Gyak3_7 {
  public static void main(String[] args) {
    char kar = Console.readChar("Karakter: ");
    if(Character.isUpperCase(kar)){
      System.out.println("Nagybetu");
      System.out.println("Kisbetus forma: "+Character.toLowerCase(kar));
    }
    else if(Character.isLowerCase(kar)){
      System.out.println("Kisbetu");
      System.out.println("Nagybetus forma: "+Character.toUpperCase(kar));
    }
    else
      System.out.println("Egyeb");
  }
}

1. Kérjük be, hogy a héten mennyi kalóriát fogyasztottunk az egyes napokon. Írjuk ki az
összes kalóriafogyasztásunkat, valamint a napi átlagot!

import extra.*;
public class Gyak4_1{
  public static void main(String[]args){
    int sum=0;
    double atlag;
    for(int i=1;i<=7;i++)
      sum+=Console.readInt("A(z) "+i+". napi kaloria fogyasztas: ");
    atlag=sum/7.0;
    System.out.println("az atlag: "+atlag);
  }
}

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

2. Kérjünk be karaktereket * végjelig. Írjuk ki, hány nagybetűt, kisbetűt, számjegyet
ill. egyéb karaktert ütöttünk be!

import extra.*;
public class Gyak4_2{
  public static void main(String[]args){
    char kar;
    int nb=0,kb=0,szj=0,egyeb=0;
    kar=Console.readChar("A karakter: ");
    while(kar!='*'){
      if('A'<=kar & kar<='Z')
        nb++;
      else if('a'<=kar & kar<='z')
        kb++;
      else if('0'<=kar & kar<='9')
        szj++;
      else
        egyeb++;
    
      kar=Console.readChar("A karakter: ");
    }
    System.out.println("Nagybetu: "+nb);
    System.out.println("Kisbetu: "+kb);
    System.out.println("Szamjegy: "+szj);
    System.out.println("Egyeb: "+egyeb);
  }
}

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

3. Kérjen be egy egész számot, és állapítsa meg, hány 0 jegy szerepel benne!

import extra.*;
public class Gyak4_3{
  public static void main(String[]args){
    int a,n=0;
    a=Console.readInt("A szam: ");
    do{
      if(a%10==0) n++;
      a/=10;
    }while(a!=0);
    System.out.println(n);
  }
}

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

4. Kérjen be egy határszámot, majd írja ki eddig a számig az összes prímszámot!

import extra.*;
public class Gyak4_4{
  public static void main(String[]args){
    int a, hatar;
    boolean prim;
    hatar=Console.readInt("Meddig: ");
    for(a=2;a<=hatar;a++){
      prim=true;
      for(int i=2; i<=Math.sqrt(a)&prim; i++)
        if(a%i==0) prim=false;
      if(prim) System.out.print(a+"  ");
    }
  }
}

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

5. Készítsen pénzbedobó automatát. Először kérje be a bedobandó összeget. Az automata
csak 10, 20, 50, 100 Ft-os érmét fogadjon el. Az automata tájékoztasson, hogy mennyi
pénzt kell még bedobnunk, ill. túlfizetés esetén közölje a visszajáró összeget.

import extra.*;
public class Gyak4_5{
  public static void main(String[]args){
    int be, marad;
    marad=Console.readInt("A bedobando osszeg: ");
    do{
      be=Console.readInt("Dobjon be egy ermet (meg "+marad+" Ft kell):");
      if (be==10 | be==20 | be==50 | be==100)
        marad-=be;
    }while(marad>0);
    System.out.println("Visszajar "+ -marad +"Ft");
  }
}

1. Írja meg a következő eljárásokat:
a, Kiír egy adott hosszúságú, adott karakterekből álló sort!
b, Konzolra írja a megadott értékhatárok közötti páros számokat!
c, Egy adott szélességű és magasságú tömör téglalapot rajzol a konzolra a megadott
karakterekkel! Például a teglalap(5,2,’@’); hívásának eredménye:
@@@@@
@@@@@
(Használhatja az 1/a pont metódusát)


class Gyak5_1{
 
  public static void sor(int hossz, char kar){
    for(int i=1; i<=hossz; i++)
      System.out.print(kar);
    System.out.println();
  }

  public static void parosok(int also,int felso){
    if (also%2==1) also++;
    for(int i=also; i<=felso; i+=2)
      System.out.print(i+"  ");
    System.out.println();
  }
 
  public static void teglalap(int hossz, int magassag, char kar){
    for(int i=1; i<=magassag; i++)
      sor(hossz, kar);
  }
 
  public static void main(String[]args){
    sor(33,'*');
    parosok(3,32);
    teglalap(40,5,'A');
  }
}

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

2. Írja meg a következő függvényeket:
a, Visszaadja egy szám kétszeresét!
b, A kör sugarából kiszámolja a kör kerületét!
c, Megadja, hogy a megadott szám pozitív-e!
d, Megadja, hogy a paraméterként megadott karakter benne van-e a szintén paraméterként
megadott tartományban (alsó határ, felső határ)!
Hívása pl: if (benne('a','z',kar))...
e, Megadja két egész szám közötti összes egész szám összegét (a határokat is beleértve)!
f, Eldönti egy számról, hogy az prím-e!
Prog. mat.: g, Kiszámítja egy szám egész hatványát a.iteratív módon  b.rekurzív módon!

import extra.*;
public class Gyak5_2{
 
  public static int duplaz(int szam){
    return szam*2;
  }
 
  public static double kerulet(double r){
    return 2*r*Math.PI;
  }
 
  public static boolean pozitiv(int szam){
    return szam>0;
  }
 
  public static boolean benne(char also, char felso, char kar){
    return also<=kar & kar <=felso;
  }
 
  public static long osszeg(int alsoHatar, int felsoHatar) {
    long osszeg = 0;
    for(int i=alsoHatar; i<=felsoHatar; i++)
      osszeg += i;
    return osszeg;
  }

  public static boolean prim(int szam){
    boolean p=true;
    for(int i=2; i<=Math.sqrt(szam)&p; i++)
      if(szam%i==0) p=false;
    return p;
  }

//Prog. mat.
  public static double hatvany(double alap, int kitevo){
    double h=1;
    for(int i=1; i<=kitevo; i++)
      h*=alap;
    return h;
  }

//Prog. mat.
  public static double hatvanyRek(double alap, int kitevo){
    if(kitevo==0)
      return 1;
    else
      return alap*hatvanyRek(alap,kitevo-1);
  }
 
 
  public static void main(String[]args){
    int a=Console.readInt("Kerek egy szamot: ");
    System.out.println("A ketszerese: "+duplaz(a));
  
    double r=Console.readDouble("Sugar: ");
    System.out.println("A kor terulete: "+kerulet);
 
    int b=Console.readInt("Szam: ");
    if(pozitiv(b))
      System.out.println("pozitiv");
    else
      System.out.println("nem pozitiv");
    
    char k=Console.readChar("A karakter: ");
    char ah=Console.readChar("Also hatar: ");
    char fh=Console.readChar("Felso hatar: ");
    if (benne(ah,fh,k))
      System.out.println("Benne van");
    else
      System.out.println("Nincs benne");
    
    System.out.println();
    System.out.println("100-ig a primszamok:");
    for(int i=3;i<=100;i++)
      if(prim(i)) System.out.print(i+"  ");

    System.out.println(hatvany(2.5,3));
    System.out.println(hatvanyRek(2.5,3));
  
  }
}

1. Olvassunk be három számot, majd írjuk ki a legkisebbet!
//két lehetséges megoldás:

import extra.*;
public class Gy5plussz_1{
  public static void main(String[]args){
    int a=Console.readInt("Az elso szam: ");
    int b=Console.readInt("Az masodik szam: ");
    int c=Console.readInt("Az harmadik szam: ");
    if (a<b && a<c)
      System.out.println("A legkisebb: "+a);
    else if (b<c)
      System.out.println("A legkisebb: "+b);
    else
      System.out.println("A legkisebb: "+c);
  }
}
----  
import extra.*;
public class Gy5plussz_1{
  public static void main(String[]args){
    int a=Console.readInt("Az elso szam: ");
    int b=Console.readInt("Az masodik szam: ");
    int c=Console.readInt("Az harmadik szam: ");
    int min=a;
    if (b<min)
      min=b;
    if (c<min)
      min=c;
    System.out.println("A legkisebb: "+min);
  }
}

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

2. Kérjük be 10 kör sugarát, majd írjuk ki a területük átlagát!

import extra.*;
public class Gy5plussz_2{
  public static void main(String[]args){
    double r, osszeg=0, atlag;
    for(int i=1; i<=10; i++){
      r=Console.readDouble("Sugar: ");
      osszeg+=r*r*Math.PI;
    }
    atlag=osszeg/10;
    System.out.println("Az atlag terulet: "+atlag);
  }
} 

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

3. Olvassunk be 20 számot, és számoljuk meg, hány egyjegyű van közöttük!

import extra.*;
public class Gy5plussz_3{
  public static void main(String[]args){
    int szam, n=0;
    for(int i=1; i<=20; i++){
      szam=Console.readInt("Szam: ");
      if(szam>-10 && szam<10) n++;
    }
    System.out.println(n+" egyjegyu volt kozottok");
  }
} 

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

4. Írjon metódust, melynek visszatérési értéke két megadott értékhatár
(paraméterek) közötti egész számok szorzata!

import extra.*;
public class Gy5plussz_4{
 
  //feltételezhetjük, hogy also<=felso
  public static int szorzat(int also, int felso){
    int szorzat=also;
    for(int i=also+1;i<=felso;i++)
      szorzat*=i;
    return szorzat;
  }
 
  public static void main(String[]args){
    System.out.println(szorzat(2,4));
  }
} 

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

5. Kérd be a-t, b-t, c-t, s írasd ki az ax2+bx+c polinom zérushelyeit!

import extra.*;
public class Gy5plussz_5{

  public static void main(String[]args){
    double a=Console.readDouble("A: ");
    double b=Console.readDouble("B: ");
    double c=Console.readDouble("C: ");
    //feltételezhetjük, hogy egyik sem 0
    double d=b*b-4*a*c;
    if(d>0){
      double x1=(-b+Math.sqrt(d))/(2*a);
      double x2=(-b-Math.sqrt(d))/(2*a);  
      System.out.println("A ket gyok: "+x1+", "+x2);
    }else if(d==0){
      double x=-b/(2*a);
      System.out.println("A gyok: "+x);
    }else
      System.out.println("Nincs valos gyok.");
  }
} 

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

6. Írjuk ki a tökéletes számokat (osztóinak összege megegyezik a számmal, pl. 6) n-ig
a képernyőre!

import extra.*;
public class Gy5plussz_6{
 
  public static void main(String[]args){
    int n=Console.readInt("N: ");
    for(int i=1;i<=n;i++){
      int osszeg=0;
      for(int j=1;j<=i/2;j++)
        if(i%j==0) osszeg+=j;
      if(osszeg==i)  
        System.out.println(i+" ");
    }
  }
}

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

7. Írja meg a következő eljárást: Konzolra írja -360 foktól 360 fokig 30 fokonként
a szögértékeket és a szinuszukat ill. koszinuszukat!

import extra.*;
public class Gy5plussz_7{
  public static void szogfv(){
    for(int i=-360;i<=360;i+=30)
      System.out.println(i+": "+Math.sin(Math.toRadians(i))+"  "+
                            Math.cos(Math.toRadians(i)));
  }

  public static void main(String[]args){
    szogfv();
  }
}

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

8. Kérj be egy egész számot, írd ki a számjegyeinek az összegét!

import extra.*;
public class Gy5plussz_8{
 
  public static void main(String[]args){
    int szam=Console.readInt("Szam: ");
    int osszeg=0;
    do{
      osszeg+=szam%10;
      szam/=10;
    }while(szam!=0);
    System.out.println(osszeg);
  }
} 
1. Kérjen be konzolról egy szöveget! Írja ki a szöveget
a, csupa kisbetűvel!
b, úgy, hogy az összes szóköz helyett kötőjel szerepel!
c. külön sorba az első ill. a második felét!
d, úgy, hogy a szöveg első és második fele fel van cserélve (a középső karakter marad)!

import extra.*;

public class Gyak6_1 {
  public static void main(String[] args) {
    String szoveg = Console.readLine("szoveg: ");
    String ujSzoveg;
  
    // a) feladat:
    ujSzoveg = szoveg.toLowerCase();
    System.out.println("Kisbetuvel: "+ujSzoveg);

    // b) feladat:
    ujSzoveg = szoveg.replace(' ','-');
    System.out.println("szokoz helyett -: "+ujSzoveg);

    // c) feladat:
    System.out.println(szoveg.substring(0,szoveg.length()/2));
    System.out.println(szoveg.substring(szoveg.length()/2));  

    // d) feladat:
    int n = szoveg.length();
    if (n%2 == 0)
      ujSzoveg = szoveg.substring(n/2)+szoveg.substring(0,n/2);
    else
      ujSzoveg = szoveg.substring(n/2+1)+szoveg.charAt(n/2)+
        szoveg.substring(0,n/2);
    System.out.println("Elso, masodik fele felcserelve: "+ujSzoveg);
  
   }
}

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

2. Kérjen be a konzolról szövegeket egy adott végjelig, majd írja ki közülük a leghosszabbat!

import extra.*;

public class Gyak6_2{
 
  public static void main(String[]args){
    String s, max;
    s=Console.readLine("Kerem a szoveget (\"*\" végjelig): ");
    max=s;
    while(!s.equals("*")){
      if(s.length()>max.length())
        max=s;
      s=Console.readLine("Kerem a szoveget (\"*\" végjelig): ");
    }
    System.out.println("a leghosszabb: "+max);
  }
}

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

3. Írjon metódust, mely megszámolja, hogy a paraméterben megadott szövegben
a, hány szóköz van!
b. hány „and” szó (vagy szórészlet) van!

import extra.*;

public class Gyak6_3{
 
  static int szokoz(String szoveg){
    int n=0;
    for(int i=0;i<szoveg.length();i++)
      if(szoveg.charAt(i)==' ')
        n++;
    return n;
  }
 
  static int andSzam(String szoveg){
    int n=0;
    int index=szoveg.indexOf("and");
    while(index!=-1){
      n++;
      index=szoveg.indexOf("and",++index);
    }
    return n;
  }
 
  public static void main(String[] args){
    String szoveg=Console.readLine("szoveg: ");
    System.out.println(szokoz(szoveg)+" szokoz van benne.");
    System.out.println(andSzam(szoveg)+" and szocska van benne.");
  }
}

1. Az előadáson látott program két árut kezeljen, pl. paradicsomot és paprikát.

class Aru{
  private String nev;
  private double egysegar;
  private double menny;
 
  public Aru(String aNev, double aEgysegar){
    nev = aNev;
    egysegar = aEgysegar;
    menny = 0;
  }
 
  public String getNev(){
    return nev;
  }
 
  public double getEgysegar(){
    return egysegar;
  }
 
  public void setEgysegar(double aEgysegar){
    if (aEgysegar >= 0)
      egysegar = aEgysegar;
  }

  public double getMenny(){
    return menny;
  }
 
  public double getAr(){
    return menny*egysegar;
  }
 
  public void hozzatesz(double aMenny){
    if(aMenny>0)
      menny += aMenny;
  }
 
  public void elvesz(double aMenny){
    if(aMenny>0 && aMenny<=menny)
      menny -= aMenny;
  }
 
  public String toString(){
    return nev+"\tEgysegar: "+egysegar+"\tMenny: "+menny+"\tAr: "+getAr();
  }
 
}//Aru

public class RaktarProgram{  
  public static void main(String [] args){  
    Aru aru1, aru2;  
    aru1 = new Aru("Paradicsom",300);  
    aru2 = new Aru("Paprika",250);  
    aru1.hozzatesz(125);  
    System.out.println(aru1);  
    System.out.println(aru2);  
    aru1.elvesz(25);  
    aru2.hozzatesz(100);  
    aru2.setEgysegar(280);  
    System.out.println(aru1);  
    System.out.println(aru2);  
    // stb...

  }
}

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

2. Készítsen egy KaveAutomata osztályt, melynek adatai: kávémárka, ár (Ft/dl), a tartályban
lévő mennyiség, a tartály kapacitása. A konstruktor paramétereken keresztül inicializálja
a fajtát, az árat és a kapacitást, a tartály legyen tele.
Készítse el az alábbi metódusokat:
- beállító és lekérdező metódusok az árra.
- vesz: paraméterként adhatjuk meg, hogy hány dl-t veszünk, visszatérési érték
  a fizetendő összeg. Ha nincs a venni kívánt mennyiség a tartályban,
  akkor -1 legyen a visszatérési érték.
- feltölt: tele tölti a tartályt, visszatérési értéke a betöltött mennyiség.
- toString: az összes adat kiírására.
A vezérlő KaveProgram osztályban hozzon létre egy KaveAutomata osztályú objektumot,
majd szimulálja a működését.

import extra.*;

class KaveAutomata{
  private String marka;
  private double ar;
  private double mennyiseg;
  private double kapacitas;
 
  public KaveAutomata(String marka, double ar, double kapacitas){
    this.marka = marka;
    this.ar = ar;
    this.kapacitas = kapacitas;
    mennyiseg = kapacitas;
  }

/* vagy
  public KaveAutomata(String aMarka, double aAr, double aKapacitas){
    marka = aMarka;
    ar = aAr;
    kapacitas = aKapacitas;
    mennyiseg = kapacitas;
  }
*/

  public double getAr(){
    return ar;
  }

  public void setAr(double ar){
    this.ar = ar;
  }

//a feledatspecifikációban nem szereplő plussz metódus
  public double getMennyiseg(){
    return mennyiseg;
  }
 
  public double vesz(double menny){
    if (menny<=mennyiseg){
      mennyiseg-=menny;
      return menny*ar;
    }
    else{
      return -1;
    }
  }
 
  public double feltolt(){
    double kell=kapacitas-mennyiseg;
    mennyiseg=kapacitas;
    return kell;
  }
 
  public String toString(){
    return "\nMarka: "+marka+"\nAr: "+ar+"\nKapacitas: "+kapacitas+
      " Mennyiseg: "+mennyiseg;
  }

}

public class KaveProgram{

  public static void main(String[] args) {
    KaveAutomata automata = new KaveAutomata("Omnia",100,50);
 
    //Például: egy ciklusban ismételten vásárolunk az automatából, amíg ki nem ürül.
    //Utána feltöltjük.
    double fiz;
    do{
      fiz = automata.vesz(Console.readDouble("Hany decit: "));
      if (fiz!=-1){
        System.out.println(fiz+" Ft-ot kell fizetnie");
      }else{
        System.out.println("Nincs annyi");
      }
      System.out.println(automata);
    }while(automata.getMennyiseg()>1);
    System.out.println("Feltoltes "+automata.feltolt()+" dl");
  }
}

-----------------
A vezérlő osztály bonyolultabb módon, mikor abból is hozunk létre objektumot:

public class KaveProgram{
  private KaveAutomata automata;
 
  public KaveProgram(){
    automata = new KaveAutomata("Omnia",100,50);
  }
 
  public void vezerel(){
    double fiz;
    do{
      fiz = automata.vesz(Console.readDouble("Hany decit: "));
      if (fiz!=-1){
        System.out.println(fiz+" Ft-ot kell fizetnie");
      }else{
        System.out.println("Nincs annyi");
      }
      System.out.println(automata);
    }while(automata.getMennyiseg()>1);
    System.out.println("Feltoltes "+automata.feltolt()+" dl");
  }


  public static void main(String[] args) {
    KaveProgram kaveProgram  = new KaveProgram();
    kaveProgram.vezerel();
  }
}
  
--------------------------------------------------------------------------

3. Egy terepasztal működését akarjuk szimulálni. Készítsen egy Auto osztályt, melynek adatai: rendszám, x pozíció, y pozíció, szög. A konstruktor paramétereken keresztül inicializálja a rendszámot, x pozíciót, y pozíciót, a szöget állítsa 0-ra. Készítse el az alábbi metódusokat:
- beállító és lekérdező metódusok a rendszámra.
- megy: az autó az aktuális irányában a paraméterként megadott távolságot tegye meg.
- fordul: a paraméterként megadott szöggel forduljon el.
- toString: a rendszám és a pozíció kiírására.
A vezérlő Terepasztal osztályban hozzon létre két Auto osztályú objektumot, majd szimulálja azok működését.

class Auto{
 
  private String rendszam;
  private int x, y, iranyszog;
 
  public Auto(String rendszam, int x, int y){
    this.rendszam = rendszam;
    this.x = x;
    this.y = y;
    iranyszog = 0;
  }
 
  public void setRendszam(String aRendszam){
    rendszam = aRendszam;
  }
 
  public String getRendszam(){
    return rendszam;
  }
 
  public void megy(int tav){
    x += tav * Math.cos(Math.toRadians(iranyszog));
    y += tav * Math.sin(Math.toRadians(iranyszog));
  }
 
  public void fordul(int szog){
    iranyszog += szog;
  }
 
  public String toString(){
    return rendszam+" pozicioja: ("+x+", "+y+")";
  }
 
}

public class Terepasztal{
  public static void main(String [] args){
    Auto auto1, auto2;
    auto1 = new Auto("ABC123",10,20);
    auto2 = new Auto("XYZ123",0,0);
    //Például:
    System.out.println(auto1+"\n"+auto2+"\n");
    auto1.megy(10);
    System.out.println(auto1+"\n"+auto2+"\n");
    auto1.fordul(30);
    System.out.println(auto1+"\n"+auto2+"\n");
    auto1.megy(20);
    System.out.println(auto1+"\n"+auto2+"\n");
    auto2.fordul(150);
    System.out.println(auto1+"\n"+auto2+"\n");
    auto2.megy(20);
    System.out.println(auto1+"\n"+auto2+"\n");
  }
}

-----------------
A vezérlő osztály bonyolultabb módon, mikor abból is hozunk létre objektumot:
public class Terepasztal{
  private Auto auto1, auto2;
 
  public Terepasztal(){
    auto1 = new Auto("ABC123",10,20);
    auto2 = new Auto("XYZ123",0,0);
  }
 
  public void vezerel(){
    System.out.println(auto1+"\n"+auto2+"\n");
    auto1.megy(10);
    System.out.println(auto1+"\n"+auto2+"\n");
    auto1.fordul(30);
    System.out.println(auto1+"\n"+auto2+"\n");
    auto1.megy(20);
    System.out.println(auto1+"\n"+auto2+"\n");
    auto2.fordul(150);
    System.out.println(auto1+"\n"+auto2+"\n");
    auto2.megy(20);
    System.out.println(auto1+"\n"+auto2+"\n");
  }
 
  public static void main(String [] args){
    Terepasztal terepasztal = new Terepasztal();
    terepasztal.vezerel();
  }
}

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();
  }
}
1. Jelenítse meg a konzolon a Holnap ”jo” leszek! üzenetet! ( \” )

public class Gyak2_1 {
  public static void main(String[] args) {
    System.out.println("Holnap \"jo\" leszek");
  }
}

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

2. Kérje be a konzolról a felhasználó nevét, majd írja ki a következő
jókívánságot: Kedves X! Sikeres Java programozást!

import extra.*;
public class Gyak2_2{
  public static void main(String [] args){
    String nev;
    nev = Console.readLine("Nev: ");
    System.out.println("Kedves "+nev+"! Sikeres Java programozast!");
  }
}

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

3. Kérje be egy hasáb három élének hosszúságát, majd írja ki a hasáb
felszínét és térfogatát!

import extra.*;
public class Gyak2_3{
  public static void main(String [] args){
    int a = Console.readInt("a: ");
    int b = Console.readInt("b: ");  
    int c = Console.readInt("c: ");
    int f = 2 * (a*b + a*c + b*c);
    int v = a * b * c;
    System.out.println("A hasab felszine: " + f);
    System.out.println("A hasab terfogata: " + v);
  }
}

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

4. Kérje be egy gömb sugarát, majd írja ki a gömb felszínét és térfogatát!

import extra.*;
public class Gyak2_4{
  public static void main(String [] args){
    double r, f, v;
    r = Console.readDouble("A gomb sugara: ");
    f = 4 * r * r * Math.PI;
    v = 4 * Math.pow(r,3) * Math.PI / 3;
    //vagy: v = 4 * r *r * r * Math.PI / 3;
    System.out.println("A gomb felszine: " + Format.left(f,0,2));
    System.out.println("A gomb terfogata: " + Format.left(v,0,2));
  }
}

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

5. Kérjen be egy pénzösszeget, majd írja ki, hogy milyen címletekben lehet
minimális számú pénzzel kifizetni úgy, hogy 5000, 1000, 500, 100-as címletek
állnak rendelkezésre!

import extra.*;
public class Gyak2_5{
  public static void main(String[] args){
    int cimlet1=5000, cimlet2=1000, cimlet3=500, cimlet4=100;
    int db1, db2, db3, db4;
    int osszeg=Console.readInt("A penzosszeg: ");
    db1=osszeg/cimlet1;
    osszeg%=cimlet1;
    db2=osszeg/cimlet2;
    osszeg%=cimlet2;
    db3=osszeg/cimlet3;
    osszeg%=cimlet3;
    db4=osszeg/cimlet4;
    System.out.println(cimlet1+": "+db1+" db");
    System.out.println(cimlet2+": "+db2+" db");
    System.out.println(cimlet3+": "+db3+" db");
    System.out.println(cimlet4+": "+db4+" db");
  }
}

1. Az előadáson látott program két árut kezeljen, pl. paradicsomot és paprikát.

class Aru{
  private String nev;
  private double egysegar;
  private double menny;
 
  public Aru(String aNev, double aEgysegar){
    nev = aNev;
    egysegar = aEgysegar;
    menny = 0;
  }
 
  public String getNev(){
    return nev;
  }
 
  public double getEgysegar(){
    return egysegar;
  }
 
  public void setEgysegar(double aEgysegar){
    if (aEgysegar >= 0)
      egysegar = aEgysegar;
  }

  public double getMenny(){
    return menny;
  }
 
  public double getAr(){
    return menny*egysegar;
  }
 
  public void hozzatesz(double aMenny){
    if(aMenny>0)
      menny += aMenny;
  }
 
  public void elvesz(double aMenny){
    if(aMenny>0 && aMenny<=menny)
      menny -= aMenny;
  }
 
  public String toString(){
    return nev+"\tEgysegar: "+egysegar+"\tMenny: "+menny+"\tAr: "+getAr();
  }
 
}//Aru

public class RaktarProgram{  
  public static void main(String [] args){  
    Aru aru1, aru2;  
    aru1 = new Aru("Paradicsom",300);  
    aru2 = new Aru("Paprika",250);  
    aru1.hozzatesz(125);  
    System.out.println(aru1);  
    System.out.println(aru2);  
    aru1.elvesz(25);  
    aru2.hozzatesz(100);  
    aru2.setEgysegar(280);  
    System.out.println(aru1);  
    System.out.println(aru2);  
    // stb...

  }
}

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

2. Készítsen egy KaveAutomata osztályt, melynek adatai: kávémárka, ár (Ft/dl), a tartályban
lévő mennyiség, a tartály kapacitása. A konstruktor paramétereken keresztül inicializálja
a fajtát, az árat és a kapacitást, a tartály legyen tele.
Készítse el az alábbi metódusokat:
- beállító és lekérdező metódusok az árra.
- vesz: paraméterként adhatjuk meg, hogy hány dl-t veszünk, visszatérési érték
  a fizetendő összeg. Ha nincs a venni kívánt mennyiség a tartályban,
  akkor -1 legyen a visszatérési érték.
- feltölt: tele tölti a tartályt, visszatérési értéke a betöltött mennyiség.
- toString: az összes adat kiírására.
A vezérlő KaveProgram osztályban hozzon létre egy KaveAutomata osztályú objektumot,
majd szimulálja a működését.

import extra.*;

class KaveAutomata{
  private String marka;
  private double ar;
  private double mennyiseg;
  private double kapacitas;
 
  public KaveAutomata(String marka, double ar, double kapacitas){
    this.marka = marka;
    this.ar = ar;
    this.kapacitas = kapacitas;
    mennyiseg = kapacitas;
  }

/* vagy
  public KaveAutomata(String aMarka, double aAr, double aKapacitas){
    marka = aMarka;
    ar = aAr;
    kapacitas = aKapacitas;
    mennyiseg = kapacitas;
  }
*/

  public double getAr(){
    return ar;
  }

  public void setAr(double ar){
    this.ar = ar;
  }

//a feledatspecifikációban nem szereplő plussz metódus
  public double getMennyiseg(){
    return mennyiseg;
  }
 
  public double vesz(double menny){
    if (menny<=mennyiseg){
      mennyiseg-=menny;
      return menny*ar;
    }
    else{
      return -1;
    }
  }
 
  public double feltolt(){
    double kell=kapacitas-mennyiseg;
    mennyiseg=kapacitas;
    return kell;
  }
 
  public String toString(){
    return "\nMarka: "+marka+"\nAr: "+ar+"\nKapacitas: "+kapacitas+
      " Mennyiseg: "+mennyiseg;
  }

}

public class KaveProgram{

  public static void main(String[] args) {
    KaveAutomata automata = new KaveAutomata("Omnia",100,50);
 
    //Például: egy ciklusban ismételten vásárolunk az automatából, amíg ki nem ürül.
    //Utána feltöltjük.
    double fiz;
    do{
      fiz = automata.vesz(Console.readDouble("Hany decit: "));
      if (fiz!=-1){
        System.out.println(fiz+" Ft-ot kell fizetnie");
      }else{
        System.out.println("Nincs annyi");
      }
      System.out.println(automata);
    }while(automata.getMennyiseg()>1);
    System.out.println("Feltoltes "+automata.feltolt()+" dl");
  }
}

-----------------
A vezérlő osztály bonyolultabb módon, mikor abból is hozunk létre objektumot:

public class KaveProgram{
  private KaveAutomata automata;
 
  public KaveProgram(){
    automata = new KaveAutomata("Omnia",100,50);
  }
 
  public void vezerel(){
    double fiz;
    do{
      fiz = automata.vesz(Console.readDouble("Hany decit: "));
      if (fiz!=-1){
        System.out.println(fiz+" Ft-ot kell fizetnie");
      }else{
        System.out.println("Nincs annyi");
      }
      System.out.println(automata);
    }while(automata.getMennyiseg()>1);
    System.out.println("Feltoltes "+automata.feltolt()+" dl");
  }


  public static void main(String[] args) {
    KaveProgram kaveProgram  = new KaveProgram();
    kaveProgram.vezerel();
  }
}
  
--------------------------------------------------------------------------

3. Egy terepasztal működését akarjuk szimulálni. Készítsen egy Auto osztályt,
melynek adatai: rendszám, x pozíció, y pozíció, szög.
A konstruktor paramétereken keresztül inicializálja a rendszámot, x pozíciót,
y pozíciót, a szöget állítsa 0-ra. Készítse el az alábbi metódusokat:
- beállító és lekérdező metódusok a rendszámra.
- megy: az autó az aktuális irányában a paraméterként megadott távolságot tegye meg.
- fordul: a paraméterként megadott szöggel forduljon el.
- toString: a rendszám és a pozíció kiírására.
A vezérlő Terepasztal osztályban hozzon létre két Auto osztályú objektumot, majd szimulálja azok működését.

class Auto{
 
  private String rendszam;
  private int x, y, iranyszog;
 
  public Auto(String rendszam, int x, int y){
    this.rendszam = rendszam;
    this.x = x;
    this.y = y;
    iranyszog = 0;
  }
 
  public void setRendszam(String aRendszam){
    rendszam = aRendszam;
  }
 
  public String getRendszam(){
    return rendszam;
  }
 
  public void megy(int tav){
    x += tav * Math.cos(Math.toRadians(iranyszog));
    y += tav * Math.sin(Math.toRadians(iranyszog));
  }
 
  public void fordul(int szog){
    iranyszog += szog;
  }
 
  public String toString(){
    return rendszam+" pozicioja: ("+x+", "+y+")";
  }
 
}

public class Terepasztal{
  public static void main(String [] args){
    Auto auto1, auto2;
    auto1 = new Auto("ABC123",10,20);
    auto2 = new Auto("XYZ123",0,0);
    //Például:
    System.out.println(auto1+"\n"+auto2+"\n");
    auto1.megy(10);
    System.out.println(auto1+"\n"+auto2+"\n");
    auto1.fordul(30);
    System.out.println(auto1+"\n"+auto2+"\n");
    auto1.megy(20);
    System.out.println(auto1+"\n"+auto2+"\n");
    auto2.fordul(150);
    System.out.println(auto1+"\n"+auto2+"\n");
    auto2.megy(20);
    System.out.println(auto1+"\n"+auto2+"\n");
  }
}

-----------------
A vezérlő osztály bonyolultabb módon, mikor abból is hozunk létre objektumot:
public class Terepasztal{
  private Auto auto1, auto2;
 
  public Terepasztal(){
    auto1 = new Auto("ABC123",10,20);
    auto2 = new Auto("XYZ123",0,0);
  }
 
  public void vezerel(){
    System.out.println(auto1+"\n"+auto2+"\n");
    auto1.megy(10);
    System.out.println(auto1+"\n"+auto2+"\n");
    auto1.fordul(30);
    System.out.println(auto1+"\n"+auto2+"\n");
    auto1.megy(20);
    System.out.println(auto1+"\n"+auto2+"\n");
    auto2.fordul(150);
    System.out.println(auto1+"\n"+auto2+"\n");
    auto2.megy(20);
    System.out.println(auto1+"\n"+auto2+"\n");
  }
 
  public static void main(String [] args){
    Terepasztal terepasztal = new Terepasztal();
    terepasztal.vezerel();
  }
}

1. Készítsen egy olyan 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);
  }
} 

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

2. Készítsünk egy 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 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;
  }
}

--------------------------------------------------------------------
3. Egy 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();
  }
}

------------------------------------------------
4. A 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();
  }
}