Lottószimulátor - Futtató program

Most hogy készen van a Szelveny osztály, teszteljük azt. Ehhez kell egy úgynevezett tesztelő vagy futtató program. Nézzük meg hogy miért is van ez.

A Java tisztán objektum-orientált nyelv. Ez azt jelenti hogy minden objektum a programban. Az objektumok valamilyen osztály egy-egy példánya, mely a példányosítás során jön létre. Az egyes objektumpéldányok létrehozása kostruktorral történik. Ha nem definiálunk konstruktort akkor is létezik az osztály nevével azonos nevű metódus. Ennek fő feladata a memóriafoglalás és az objektum kezdeti állapotának beállítása. A Szelvény osztálynak két konstruktort definiáltunk. Egy paraméterezettet és egy paraméter nélkülit. A példányosítás után az objektumnak a publikus metódusain keresztül üzeneteket tudunk küldeni, illetve a publikus adattagok közvetlenül elérhetők (ezt én kerülendőnek tartom még akkor is ha triviális lenne a megoldás).

Minden osztályt külön forrásfájlban (.java kiterjesztésű fájl) kell definiálni. A forrásfájl nevének meg kell egyezni az osztály nevével. Így lett a Szelveny osztályunk a Szelveny.java fájlba definiálva.

Amikor egy osztályt a virtuális gépbe betöltünk akkor a JVM megpróbálja elindítani az osztály main() metódusát. Ha ilyet talál akkor elindul a metódus. Így indíthatók a programok.

Hozzunk létre most egy LottoTest osztályt, amibe létrehozzuk a main() metódust. Ennek is szabályai vannak, az alábbi kötött formában kell definiálni a main()-t.

1. public class LottoTest {
2.    public static void main(String[] args){
3.      //létrehozunk két szelvényt
4.      //sz1 automatikusan generált 5 számot fog tartalmazni
5.      Szelveny sz1 = new Szelveny();
6.      
7.      //sz2 a paramétrelistájában megadott öt számot tartalmazza
8.      Szelveny sz2 = new Szelveny(19,71,8,16,7);
9.  
10.    }
11. }

Ezzel létrehoztunk két objektumot, melyek tartalmaznak tippeket. Ezeket a tippeket írassuk most ki!
Rá kell jönnünk hogy a szelvény osztályban nem készítettünk metódust a kiíratásra, az adattag ami a tippeket tartalmazza az pedig private (nagyon helyesen), amihez ugyebár az objektumon kívülről nem lehet hozzáférni. Készítenünk kell hát valamilyen metódust ami kiíratja, vagy visszaadja a tippeket.
A Java-ban szokás definiálni egy toString() metódust. Ez kvázi szabvány. A metódus visszaad egy String típusú értéket mely tartalmazza azt a szöveget, amit az objektum adatairól  tartalmaz információt. Most ezt fogjuk megadni. Egyébként a számok tárolására használt TreeSet konténernek is van "gyári" toString() metódusa, amit fel is használunk.
Természetesen a Szelveny.java fájlt kell kiegészíteni a következő sorokkal:

1. public String toString(){
2.    // a TreeSet objektum toString() metódusát úgy írták meg hogy
3.    // [] jelek között, vesszővel elválasztva felsorolja
4.    // növekvő sorrendben az elemeit. Ez nekünk teljesen megfelel!
5.  
6.    return "Szelvény száma: "+szelvenyId+" Tippek: " + tippek.toString();
7. }

Ezek után már a tesztelő osztályunkban a példányosítások után használhatjuk is a szelvények toString()-jét a kiíratásra.

A kiíratáskor a kiertekel() metódust felhasználva, értékeltessük is ki a szelvényeket.

Ez lesz a tesztelő osztályunk tartalma:

1. public class LottoTest {
2.    public static void main(String[] args){
3.      //létrehozunk két szelvényt
4.      //sz1 automatikusan generált 5 számot fog tartalmazni
5.      Szelveny sz1 = new Szelveny();
6.      
7.      //sz2 a paramétrelistájában megadott öt számot tartalmazza
8.      Szelveny sz2 = new Szelveny(19,71,8,16,7);
9.  
10.      // ha nem adjuk meg cska az objektum nevét, akkor megpróbálja megfelelő típusúra konvertálni.
11.      //String típushoz a toString() metódust hívja automatikusan.
12.      System.out.println(sz1 + " Találatok száma: " + sz1.kiertekel(2,7,18,71,87));
13.      System.out.println(sz2 + " Találatok száma: " + sz1.kiertekel(2,7,18,71,87));    
14.  
15.    }
16. }

Futtatás hatására a kimenet hasonló lesz  (valószínű más számok jelennek meg az sz1 kiírásakor)

Szelvény száma: -1 Tippek: [8, 51, 66, 71, 75] Találatok száma: 1

Szelvény száma: -1 Tippek: [7, 8, 16, 19, 71] Találatok száma: 2

Lottó szimulátor - osztályok első nekifutásra

A lottó szimulátorral kapcsolatban először gondoljuk át hogy milyen osztályok szükségesek az alkalmazáshoz.

A Java egy tisztán objektumorientált programozási nyelv és mint minden ilyen nyelvben osztályokkal és az osztályok alkotta osztályhierarchivál dolgozunk. Az osztályok a való világ egyes elemeinek, objektumainak absztrakció útján történő leképezései.
Most próbáljuk meg a feladattal kapcsolatban az első absztrakciót elvégezni. Képzeljük el hogy milyen osztályok és azok milyen kapcsolatai fogják alkotni a Lottószimulátort! Most nem törekszünk teljes részletességre, csupán nagy vonalakba gondoljunk a feladatra.

A lottófogadásokat szelvényeken tudjuk megtenni. Az összes fogadást és azok kezelését is meg kell valósítani egy közös helyen. Első menetben erre a két osztályra lesz szükségünk.

Nézzük ezeket részletesebben.

Szükség lesz (vagy nem?) egy olyan osztályra, ami a tippek tárolására alkalmas. Ezt úgy kell elképzelni mint a fogadó fejében lévő lottószámok, amiket meg szeretne tenni. Tehát semmi más nem jellemzi, csak maguk az ember elméjében létező számokat tartalmazza, amiket vagy megtesz a lottón vagy nem. Tehát ez még nem maga a fogadás ez csak egy tipp. Ahhoz hogy fogadás legyen belőle, ahhoz ki kell tölteni egy lottószelvényt. A kérdés az hogy maga a számsor, ami egyéb más jellemzővel nem rendelkezik azt szükséges-e külön osztályban megvalósítani vagy sem. Elsőnek induljunk el úgy hogy mégse csináljunk ebből külön osztályt.

Tehát a tippet már eleve egy szelvényen kezeljük, mert amíg nem teszik meg a fogadást addig tökmindegy hogy benne van-e valaki fejében öt szám vagy sem.

A lottószelvény osztálynak tárolni kell tudni az öt számot, illetve van egy 7 jegyű egyedi sorszáma amivel majd a joker játékra lehet fogadni. A sorszámot a szelvény létrehozásakor generáljuk. A lottószelvény a sorsolás után lehet nyertes szelvény akkor, ha legalább két találat van rajta. A szelvényobjektumnak a létrehozásakor vagy megadjuk az öt számot amire fogadást kötnek, vagy ha nem akkor generálunk öt számot. Ez tehát kétféle konstruktort jelent (többalakúság). Az hogy egy szelvény nyertes-e, azt egy metódussal fogjuk kiértékelni. Paraméterül adjuk át a kihúzott öt számot és eredményül adja vissza hogy hányas találat van a szelvényen.

Az implementációban az öt lottószám tárolására használjunk egy konténert. Ehhez használjuk a TreeSet tárolóosztályt, aminek az a jellemzője, hogy egy elemet csak egyszer tartalmazhat és az elemeket rendezve tárolja. Természetesen Integer elemekkel dolgozunk. A generálást a Math osztály Random() metódusával generáljuk. Ez a 0 és 1 között generál egy lebegőpontos véletlen számot. Ezt először 1 és 90 közöttivé kell alakítani, majd típuskényszerítéssel (cast) egésszé kell alakítani.

Íme a lottószelvényeket tároló osztály Java forrása:

public class Szelveny {
  private int szelvenyId = -1; //jelöljük így a szelvényt amíg nincs sorszáma
  private TreeSet tippek = new TreeSet();
  private boolean joker = false;

  public Szelveny(){
     //generálni kell 5 különböző számot 1-90 között.
     //Ha egy számot már kisorsoltunk, akkor helyette új kell
     for(int i=1;i<=5;i++){
         int j;
         do 
            j=(int)(Math.random()*89+1);             
         while(tippek.contains(j));
         tippek.add(j);
     }
  }

  public Szelveny(int n1, int n2, int n3, int n4, int n5){
     //paraméterekben megkapjuk a tippeket. 
     //Az hogy a tippek helyesek-e azzal ne foglalkozzunk. 
     //Nem tudjuk hogy mi volt a célja a szelvény kitöltőjének, 
     //had töltse ki ahogy akarja. Majd a szelvény beadásakor 
     //kell eldönteni hogy elfogadjuk-e a tippet, vagy sem.

     tippek.add(n1);
     tippek.add(n2);
     tippek.add(n3);
     tippek.add(n4);
     tippek.add(n5);

  }

  public int kiertekel(int n1, int n2, int n3, int n4, int n5){
     //le kell ellenőrizni az öt számot egyenként.
     //a -1 azt jelenti hogy érvénytelen a szelvény
     int talalat = -1; 

     // érvényes a szelvény ha 5 tippet tartalmaz
     if (tippek.size()==5) talalat++;
     if (tippek.contains(n1)) talalat++;
     if (tippek.contains(n2)) talalat++;
     if (tippek.contains(n3)) talalat++;
     if (tippek.contains(n4)) talalat++;
     if (tippek.contains(n5)) talalat++;

     return talalat;
  }
}

LOTTÓ feladat Javában

Nemrég nézegettem az emelt szintű informatika érettségi feladatokat és ott láttam egy lottózós feladatot. Erről jutott eszembe, hogy csináljak gyakorlásként egy ilyen lottózós példát.
Java-ban fogom megcsinálni, lehet hogy nem egy lépcsőben hanem szépen lépésről lépésre.
Itt fogom blogolni, hátha hasznos lesz valakinek.


Előszöris a feladatot kéne megfoglamazni első lépésben, aztán lehet hogy még pontosítjuk.

Szóval a cél egy lottó szimulátor készítése a következő funkciókkal:

• 5-ös lottó (90-5) feladatról van szó
• Lehessen megadni fogadásokat (akármennyit)
• A fogadásokról készítsen statisztikát (később pontosítjuk hogy mit statisztikázzon)
• Sorsolja ki a nyerő számokat
• Statisztikázza és listázza ki a nyertes szelvényeket.
• Lehessen a lottószelvény sorszámával joker-re is fogadni.
• Sorsolja ki a jokert

Hát egyelőre ennyi feladat lenne. Rengeteg ötlet jut hirtelen eszembe amit még meg lehetne valósítani. (pl. fordított lottó. Először sorsoljon, aztán kezdjen el generálni fogadásokat addig amíg lesz egy 5-ös szelvény, vagy 4-es stb...)

A fent felsorolt pontokból indulok ki és ahogy haladok, blogolni fogom a részfeladatokat... (remélem)