Vlastní výjimka – Java – Fórum – Programujte.com

Zdravím,

snažím se procvičit si výjimky na školních příkladech a narazil jsem na problém.

K dispozici mám následující třídu Dancer:

public class Dancer
{
    private Dancer partner;
    private boolean female;
    private int number;

    /**
     * @param number Dancer's number
     * @param isFemale Dancer's genre
     */
    public Dancer(int number, boolean isFemale) {
        this.number = number;
        female = isFemale;
    }
    
    /**
     * @return true if the dancer has a partner
     */
    public boolean hasPartner() {
        return partner != null;
    }
    
    /**
     * @return true if the dancer is female
     */
    public boolean isFemale() {
        return female;
    }    

    /**
     * @return true if the dancer is male
     */
    public boolean isMale() {
        return !female;
    }  
    
    /**
     * @return dancer's number
     */
    public int getNumber() {
        return number;
    }

    /**
     * Breaks the dancing pair, i.e. unsets partner of this dancer and vice versa.
     * 
     * @return false if this dancer had no partner.
     */
    public boolean unsetPartner() {
        if (!hasPartner()) return false;
        partner.partner = null;
        partner = null;
        return true;
    }

Za úkol mám vytvořit hlídanou výjimku DancerException, která bude mít alespoň jeden konstruktor s textovým popisem chyby. Můj kód:

public class DancerException extends Exception
{
    public DancerException() {
        super();
    }
   
    public DancerException(String message) {
        super("Dancer exception.");
    }
}

Teď to, kde si nevím rady:

Do třídy Dancer doplňte metody pro vytvoření a zrušení tanečního páru podle následující dokumentace. Jakékoliv jiné změny ve třídě jsou nepřípustné.
Metoda void setPartner(Dancer partner) propojí tanečníka s partnerem A NAOPAK:

       /**
* Creates dancing pair. This method assignes the given dancer as a partner
* of this dancer and vice versa.
*
* @param partner Person to be assigned as our partner in dancing pair
* @throws NullPointerException if the partner parametr is null
* @throws DancingException if either this dancer or the given partner are alredy in a pair
*        (they already have a partner)
* @throws DancingException if this dancer and the given partner are of the same genre
*/
Pozn: Volání metody setPartner() na partnerovi uvnitř samotného setPartner() vede k zacyklení. Místo toho využijte fakt, že máme přístupné i privátní atributy partnera.

Zkoušel jsem to takhle:

public void setPartner(Dancer partner) throws NullPointerException, DancerException {      
        if(partner == null) throw new NullPointerException("partner");
        
        try {
            this.partner = partner;
            partner.partner = this;
        } catch (Exception e) {
            throw new DancerException(e.getMessage());
        }

Nicméně se nedomnívám, že je to podle té dokumentace správně.

Zkoušel jsem to takto, ale to není hlídaná výjimka a navíc to pak dělá neplechu dál v programu:

    public void setPartner(Dancer partner) throws NullPointerException, DancerException {
        if(partner == null) throw new NullPointerException("partner");
        
        if( (partner.hasPartner() != false) || (partner.partner.hasPartner() != false) )
            throw new DancerException("Dancer already has a partner.");
        
        if(this.partner.isMale() == partner.isMale()) throw new DancerException("Dancers have the same gender.");
           
        this.partner = partner;
        partner.partner = this;

Budu rád za každou radu. Díky.

V metodě setPartner špatně přistupuješ k instanci nad kterou je metoda volaná. Instance nad kterou je volaná metoda je v this. Opakuje se ti to tam vícekrát např. následující podmínka 

if( (partner.hasPartner() != false) || (partner.partner.hasPartner() != false) )

...by měla vypadat takhle

if( (partner.hasPartner() != false) || (this.hasPartner() != false) )

A když vyvoláš podmínku, tak ji musíš příslušně zachytit...

try {
	partner1.setPartner(Partner2);
} catch (DancerException e) {
	//zpracování DancerException 
} catch (NullPointerException e) {
	// zpracování NullPointerException
}

try {
	partner1.setPartner(Partner2);
} catch (DancerException e) {
	//zpracování DancerException 
} catch (NullPointerException e) {
	// zpracování NullPointerException
}

V tom try bloku přece nemůžu volat metodu setPartner, jinak se mi to zacyklí, ne?
A v catch bloku (DancerException e) mi překladač hlásí chybu:

"exception DancerException is never thrown in body of corresponding try statement".

Co dělám špatně?

Já pozn. chápu tak, že jde o to aby jsi neimplementoval metodu následovně

void setPartner(Dancer Partner){
...
Partner.setPartner(this);
...
}

Takže v tvém případě nezacyklí.

ad chyba: Dej to do try{}

...obdobně s tou instancí tom máš i unsetPartner, kam si ani žádného druhého partnera nepředáváš.

Jinak k přehlednosti a štěstí že to nedělá neplechu bych si dával pozor na užívání pojmenování instanční proměnné "partner" a pojmenování předaného parametru "partner" do metody jako v případě setPartner()

Dobře. I když to ale udělám takto, tak mi to nezachytí případy, kdy jeden nebo druhý tanečník již má partnera a ani případ, kdy jsou oba stejného pohlaví, o to mi jde.

        try {
            this.partner.setPartner(partner);
            partner.setPartner(this.partner);
} catch (DancerException e) {
//zpracování DancerException
} catch (NullPointerException e) {
// zpracování NullPointerException
}

#5 dawnMist
Jsi to nepochopil, to setPartner voláš jen pro jednoho a přiřazení tomu druhému je v rámci té metody, máš přístupné veškeré instanční proměnné obou partnerů. To ti také zmiňuje ta poznámka.

A asi jsem ti v tom teď udělal trošku guláš.... tady máš použítí dvou tanečníků, kdy se je snažím dát dohromady. Vyvolá to vyjímku "DancerException" se zprávou "Dancer exception." Pokud máš už správně opravenou tu metodu.

public static void main(String[] args) {
        Dancer A = new Dancer(1, false);
        Dancer B = new Dancer(2, false);
           
        try {
            A.setPartner(B);
        } catch (DancerException e){
            System.out.println(e.getMessage());
        } catch (NullPointerException e) {
            System.out.println(e.getMessage());
        }     
}

Teď s tou vyjímkou jsem si všimnul, že jsi původně zamýšlel ji mít definovavou jako 

public class DancerException extends Exception
{
    public DancerException() {
        super("Dancer exception.");
    }
   
    public DancerException(String message) {
        super(message);
    }
}

 Takže takhle nějak už by to mohlo jít?

try {
	this.partner.setPartner(partner);
      
	// pokud jeden z nich ma partnera
        if((this.partner.hasPartner() == true) || (partner.hasPartner() == true)) throw new DancerException();
      
        // pokud maji stejne pohlavi
        if(this.partner.female == partner.female) throw new DancerException();            
} catch (DancerException e){
	System.out.println(e.getMessage());
} catch (NullPointerException e) {
        System.out.println(e.getMessage());
}  

#8 dawnMist
Ta metoda má ty vyjímky vytvářet, ale ne hned odchytávat ne?

Uf, tak teď jsem opět zmaten. 

Metoda void setPartner(Dancer partner) propojí tanečníka s partnerem A NAOPAK:

/**
* Creates dancing pair. This method assignes the given dancer as a partner
* of this dancer and vice versa.
*
* @param partner Person to be assigned as our partner in dancing pair
* @throws NullPointerException if the partner parametr is null
* @throws DancingException if either this dancer or the given partner are alredy in a pair
*        (they already have a partner)
* @throws DancingException if this dancer and the given partner are of the same genre
*/

Ona je tam pak vytvořená ještě jiná třída, ve které jsou vytvořeni různí tanečníci a kontroluje správnost tady těchto mých tříd a jejich metod.

Takže ty tu metodu setPartner jen píšeš, ale dále nepoužívaš. Tak ji opravíš jen aby byla funkční.

    public void setPartner(Dancer partner) throws NullPointerException, DancerException {
        
        if(partner == null) 
            throw new NullPointerException("partner");
        
        if( (partner.hasPartner() != false) || (this.hasPartner() != false) )
            throw new DancerException("Dancer already has a partner.");
        
        if(this.isMale() == partner.isMale()) 
            throw new DancerException("Dancers have the same gender.");
           
        this.partner = partner;
        partner.partner = this;
    }

No, podle mě bych ji měl použít v dalším úkolu.

Vytvořte třídu DancingLesson představující taneční lekci. Třída bude mít uložené tanečníky v poli nebo seznamu a bude mít následující vlastnosti:

.

.

.
    Metoda boolean pair(int ladie, int gentleman) vytvoří taneční pár. Parametry ladie a gentleman jsou opět čísla tanečníků. Metoda NEBUDE VYHAZOVAT ŽÁDNOU VÝJIMKU. Pokud pár z jakéhokoliv důvodu nelze vytvořit, vrátí metoda false.

Takže tu metodu setPartner musím mít ošetřenou hlídanou výjimkou.

Nebo mi zde něco nedochází?

#12 dawnMist
Jo v dalším úkolu použiješ tu metodu setPartner, kde v metodě pair již budeš mít vyjímky ošetřené a zpracovávat se budou tak že vrátí ono false.

No jasně, mockrát děkuju! Jsem díky tobě snad konečně ty výjimky pochopil!

#14 dawnMist
Spíše jsi pochopil co po tobě chtěji, ve vyjímkách problém původně nebyl. Nejošklivější je to pojmenování partner.