package zlomky;

/*******************************************************************************
 * Třída Zlomek definuje zlomky a potřebné operace, aby se zlomky bylo
 * možno počítat obdobně jako s čísly. Definuje proto operace pro sčítání,
 * odčítání, násobení a dělení dvou zlomků a zlomku a čísla, 
 * jakož i operace pro převod celého čísla na zlomek a zlomku na číslo.
 *
 * @author     Rudolf Pecinovský
 * @version    0.00.000,  0.0.2003
 */
public class Zlomek
{
//== KONSTANTNÍ ATRIBUTY TŘÍDY =================================================
//== PROMĚNNÉ ATRIBUTY TŘÍDY ===================================================
//== KONSTANTNÍ ATRIBUTY INSTANCÍ ==============================================
//== PROMĚNNÉ ATRIBUTY INSTANCÍ ================================================
//== PŘÍSTUPOVÉ METODY VLASTNOSTÍ TŘÍDY ========================================
//== OSTATNÍ METODY TŘÍDY ======================================================

//##############################################################################
//== KONSTRUKTORY A TOVÁRNÍ METODY =============================================

    /***************************************************************************
     * Vytvoří novou instanci třídy Zlomek s hodnotou danou čitatelem a
     * jmenovatelem dodanými jako parametry. Hodnota čitatele a jmenovatele 
     * uložená v atributech však bude již zkrácená a jmenovatel bude kladný.
     * 
     * @param c  Zadávaný čitatel
     * @param j  Zadávaný jmenovatel
     */
    public Zlomek(int c, int j)
    {
    }
    
    
    /***************************************************************************
     * Kopírovací konstruktor -- vytvoří novou instanci 
     * se stejnými hodnotami atributů, jaké má zlomek zadaný jako parametr.
     *
     * @param z  Kopírovaný zlomek
     */
    public Zlomek(Zlomek z)
    {
    }
    
    
    /***************************************************************************
     * Vytvoří zlomek, který bude mít hodnotu čísla zadaného jako parametr.
     *
     * @param číslo  Hodnota vytvářeného zlomku
     */
    public Zlomek(int číslo)
    {
    }
    

    
//== PŘÍSTUPOVÉ METODY VLASTNOSTÍ INSTANCÍ =====================================

    /***************************************************************************
     * Vrátí hodnotu čitatele.
     * 
     * @return hodnota čitatele              
     */     
    public int getČitatel()
    {
        return 0;
    }


    /***************************************************************************
     * Vrátí hodnotu jmenovatele.
     * 
     * @return hodnota jmenovatele              
     */     
    public int getJmenovatel()
    {
        return 0;
    }



//== PŘEKRYTÉ METODY IMPLEMENTOVANÝCH ROZHRANÍ =================================
//== PŘEKRYTÉ ABSTRAKTNÍ METODY RODIČOVSKÉ TŘÍDY ===============================
//== PŘEKRYTÉ KONKRÉTNÍ METODY RODIČOVSKÉ TŘÍDY ================================
    
    /***************************************************************************
     * Vrátí řetězec reprezentující zlomek ve tvaru
     * [čitatel/jmenovatel]  -  např. [7/2]
     *
     * @return Textová reprezentace zlomku.
     */
    public String toString()
    {
        return "";
    }
    
    
    
//== NOVĚ ZAVEDENÉ METODY INSTANCÍ =============================================
    
    /***************************************************************************
     * Vrátí hodnotu zlomku oříznutou na celé číslo.
     *
     * @return  Hodnota zlomku oříznutá na celé číslo.
     */
    public int intValue()
    {
        return 0;
    }
    
    
    /***************************************************************************
     * Vrátí hodnotu zlomku převedenou na reálné číslo typu double.
     *
     * @return  Hodnota zlomku převedená na reálné číslo typu double.
     */
    public double doubleValue()
    {
        return 0;
    }

    
    /***************************************************************************
     * Připočte ke zlomku zlomek zadaný jako parametr 
     * a vrátí zlomek, který je jejich součtem. 
     *
     * @param  z  Přičítaný zlomek.
     *
     * @return Zlomek, ktrerý je součtem obou zlomků.
     */
    public Zlomek plus(Zlomek z)
    {
        return null;
    }
    
    
    /***************************************************************************
     * Připočte ke zlomku celé číslo zadané jako parametr 
     * a vrátí zlomek, který je jejich součtem. 
     *
     * @param  číslo   Přičítané číslo.
     *
     * @return Zlomek, ktrerý je součtem obou hodnot.
     */
    public Zlomek plus(int číslo)
    {
        return null;
    }
    
    
    /***************************************************************************
     * Odečte od zlomku zlomek zadaný jako parametr 
     * a vrátí zlomek, který je jejich rozdílem. 
     *
     * @param  z  Odečítaný zlomek.
     *
     * @return Zlomek, ktrerý je rozdílem obou zlomků.
     */
    public Zlomek mínus(Zlomek z)
    {
        return null;
    }
    
    
    /***************************************************************************
     * Odečte od zlomku celé číslo zadané jako parametr 
     * a vrátí zlomek, který je jejich rozdílem. 
     *
     * @param  číslo   Odečítané číslo.
     *
     * @return Zlomek, ktrerý je rozdílem obou hodnot.
     */
    public Zlomek mínus(int číslo)
    {
        return null;
    }
    
    
    /***************************************************************************
     * Odečte zlomek od celého čísla zadaného jako parametr 
     * a vrátí zlomek, který je jejich rozdílem. 
     *
     * @param  číslo   Číslo, od kterého se zlomek odečte.
     *
     * @return Zlomek, ktrerý je rozdílem obou hodnot.
     */
    public Zlomek odečtiOd(int číslo)
    {
        return null;
    }
    
    
    /***************************************************************************
     * Vynásobí zlomek zlomkem zadaným jako parametr 
     * a vrátí zlomek, který je jejich součinem. 
     *
     * @param  z  Zlomek, kterým se násobí.
     *
     * @return Zlomek, ktrerý je součinem obou zlomků.
     */
    public Zlomek krát(Zlomek z)
    {
        return null;
    }
    
    
    /***************************************************************************
     * Vynásobí zlomek celým číslem zadaným jako parametr 
     * a vrátí zlomek, který je jejich součinem. 
     *
     * @param  číslo  Číslo, kterým se násobí.
     *
     * @return Zlomek, ktrerý je součinem obou hodnot.
     */
    public Zlomek krát(int číslo)
    {
        return null;
    }
    
    
    /***************************************************************************
     * Vydělí zlomek zlomkem zadaným jako parametr 
     * a vrátí zlomek, který je jejich podílem. 
     *
     * @param  z  Zlomek, kterým se dělí.
     *
     * @return Zlomek, ktrerý je podílem obou zlomků.
     */
    public Zlomek děleno(Zlomek z)
    {
        return null;
    }
    
    
    
    /***************************************************************************
     * Vydělí zlomek celým číslem zadaným jako parametr 
     * a vrátí zlomek, který je jejich podílem. 
     *
     * @param  z  Číslo, kterým se dělí.
     *
     * @return Zlomek, ktrerý je podílem obou hodnot.
     */
    public Zlomek děleno(int číslo)
    {
        return null;
    }
    
    
    /***************************************************************************
     * Vydělí zlomkem celé číslo zadané jako parametr 
     * a vrátí zlomek, který je jejich podílem. 
     *
     * @param  z  Číslo, které se dělí.
     *
     * @return Zlomek, ktrerý je podílem obou hodnot.
     */
    public Zlomek dělČíslo(int číslo)
    {
        return null;
    }

    
//== SOUKROMÉ A POMOCNÉ METODY TŘÍDY ===========================================
//== SOUKROMÉ A POMOCNÉ METODY INSTANCÍ ========================================
//== VNOŘENÉ A VNITŘNÍ TŘÍDY ===================================================
//== TESTY A METODA MAIN =======================================================
}

