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