[Java] Zelf exceptions schrijven

[maartenvdv737]

Ik heb vandaag deze tutorial gelezen over exceptions.

Daar staat wel goed uitgelegd wat exceptions zijn, wanneer je ze moet gebruiken, hoe je try en catch gebruikt, maar niet echt duidelijk staat er hoe je een eigen exception schrijft.

Nu heb ik een beetje rondgezocht en ben op het volgende uitgekomen:

code:

class MijnException extends Exception {
 
  String mijn_s; 

  public MijnException ( String s ) {
   mijn_s = s;
  }

  public String getMessage() {
   System.out.println(mijn_s);
  }
}

class Main {
 public static void main (String argv[]) {
  try {
   //statement
  }
  catch(MijnException e) {
   e.getMessage();
  }
  finally() {
   // doe altijd dit
  }
}

Nu vroeg ik mij af, hoe bepaal je nou op welke fout (Exception) in try MijnException moet reageren? Of reageert hij nu gewoon op alle foutmeldingen omdat ik hem extend van Exception?

- Dus ongeacht wat ik in het try { } blok zet, kan ik nu altijd mijn eigen "algemene" error message maken?

- En waar roep ik nu de constructor van MijnException aan? Oftewel, waar geef ik mijn foutmelding mee?

- Moet ik, als ik gebruik maak van try/catch, achter die public .. main () nog 'throws Exception' zetten?

[whoami]

Je moet even een Java-boek erbij pakken of nog wat andere tutorials lezen.

met het

code:

throw

statement kan je een exceptie gooien.

[Martkrui]

Op donderdag 27 juni 2002 08:50 schreef maartenvdv het volgende:
Nu vroeg ik mij af, hoe bepaal je nou op welke fout (Exception) in try MijnException moet reageren? Of reageert hij nu gewoon op alle foutmeldingen omdat ik hem extend van Exception?

- Moet ik, als ik gebruik maak van try/catch, achter die public .. main () nog 'throws Exception' zetten?

Er moet wel een object zijn (in de try) die die exception throwed...

Meestal gebruik je eigen exceptions omdat je een eigen object heb geschreven en een niet std exception terug wilt geven met meer info...

oftewel... een exception op zich is niet veel. Het is een beschrijving van een fout. Nou nog een object dat die fout kan maken.


[edit] staat ook in je tutorial :
http://java.sun.com/docs/books/tutorial/essential/exceptions/throwing.html

[whoami]

Op donderdag 27 juni 2002 08:50 schreef maartenvdv het volgende:
Nu vroeg ik mij af, hoe bepaal je nou op welke fout (Exception) in try MijnException moet reageren? Of reageert hij nu gewoon op alle foutmeldingen omdat ik hem extend van Exception?

Je moet voor iedere exceptie die kan optreden een catch - blok voorzien.
Als er een exception optreedt, dan wordt er naar het catch blok gesprongen en geëvalueerd of dat catch blok moet uitgevoerd worden. De catch-blokken worden van boven naar beneden geëvalueerd tot wanneer er een gepast catch-blok gevonden is die de exception moet afhandelen.

Als je dus een 'MijnException' exception throwed, die afgeleid is van Exception en uw catch blokken zien er zo uit:

code:

catch (Exception)
{
}
catch (MijnException)
{
}

Dan wordt het eerste catch-blok uitgevoerd (Exception). MijnException is afgeleid van Exception dus is het eigenlijk ook een Exception. MijnException - handler wordt dan nooit uitgevoerd.

- En waar roep ik nu de constructor van MijnException aan? Oftewel, waar geef ik mijn foutmelding mee?

Je kunt dat mbhv het throw statement doen.

[maartenvdv737]

code:

class MijnException extends Exception {
 
  String mijn_s; 

  public MijnException ( String s ) {
   mijn_s = s;
  }

  public String getMessage() {
   System.out.println(mijn_s);
  }
}

class Main {
 public static void main (String argv[]) {
  try {
   int i = 16/0;
  }
  catch(MijnException e) {
   throw new MijnException("Je wilt door nul delen!");
  }
  catch(Exception e) {
   System.out.println("Er is een andere fout opgetreden");
  }
  finally() {
   // doe altijd dit
  }
}

Gaat dit zo goed? Of sla ik de plank helemaal mis?

Waar ik dus mee zit is, hoe weet MijnException dat die fout op 'delen door 0' slaat?

[Alarmnummer]

vb van een checked exception.

code:

public class DeSimpsonsZijnErNIetVoorException extends Exception{
    public DeSimpsonsZijnErNIetVoorException(String message){
      super(message); 
    }

    public DeSimpsonsZijnErNIetVoorException(String message,Throwable cause){
    super(message,cause);
   }
}

en throwen met:
throw new DeSimpsonsZijnErNIetVoorException("rot tennis");


Een check exception moet je propageren. Je kan ook unchecked exceptions opwerpen (die hoef je niet te propageren). Unchecked exceptions zijn typisch programeurs fouten, zoals IndexOutOfBoundsException,NullPointerException ed. Deze mag je zelf ook opwerpen als je merkt dat er iets in je code is fout gegaan.

[whoami]

Je slaat de plank mis. Ik denk dat je de tutorials nog eens goed gaat moeten bekijken.

Je moet opgeven dat er een exceptie is gebeurd en dan pas wordt er naar het catch-blok gesprongen.

Dus zo:

code:

try
{
  if (noemer == 0)
  {
     throw MijnException("deling door 0");
  }
  quotient = teller / noemer;
}
catch(e MijnException)
{
  Console.WriteLn (e.Message);
}

_{Is geen Java-code daar ik geen Java ken.}

[Martkrui]

Yez.. thats it...
Meestal wordt de exception dan ge-throwed in een object, maar dit is wel het idee

[edit] ik bedoelde de reply van whoami ... sorry

[maartenvdv737]

code:

class MijnException extends Exception {
 
  String mijn_s; 

  public MijnException ( String s ) {
   super(s)
  }
}

class Main {
 public static void main (String argv[]) {
  try {
   int i = 16/argv[0];
  }
  catch(MijnException e) {
   throw new MijnException("Je wilt door nul delen!");
  }
  catch(Exception e) {
   System.out.println("Er is een andere fout opgetreden");
  }
  finally() {
   // doe altijd dit
  }
}

Goed, ik heb het nu zo:

Maar de 1 zegt nu dat ik de plank mis sla, en de ander die zegt dat het zo goed is.

Hoe kan ik nou altijd in een try-blok al die exception throwen? Stel nou dat ik daar niet met een 'if' op iets wil controleren, maar bijvoorbeeld een bestand wil uitlezen of dat je een statement hebt: 'int i = 16/argv[0];'
Moet je dan persé checken op:

code:

if(argv[0] == 0)
 throw new MijnException("je wilt door 0 delen");

[whoami]

Op donderdag 27 juni 2002 09:14 schreef maartenvdv het volgende:


Maar de 1 zegt nu dat ik de plank mis sla, en de ander die zegt dat het zo goed is.

Probeer het uit zou ik zeggen. (De ander zegt trouwens niet dat het goed is dacht ik?)

[Alarmnummer]

Het voorbeeld is een beetje lullig gekozen, maar het zou ook kunnen dat een methode (eventueel in een ander object) deze exception opwerpt:

code:

try{
   diskDrive.startMotor();
   diskDrive.readBytes(1000);
}catch(DiskDriveException e){
   ....
}

Je gaat nu naar het diskdrive object toe en gaat daar een aantal handelignen op verrichten. Beide methodes (startMotor en readBytes) kunnen een DiskDriveException opwerpen, dus die moet je verwerken, of je moet ze verder omhoog sturen.

[maartenvdv737]

Op donderdag 27 juni 2002 09:26 schreef Alarmnummer het volgende:
Het voorbeeld is een beetje lullig gekozen, maar het zou ook kunnen dat een methode (eventueel in een ander object) deze exception opwerpt:

code:

try{
   diskDrive.startMotor();
   diskDrive.readBytes(1000);
}catch(DiskDriveException e){
   ....
}

Je gaat nu naar het diskdrive object toe en gaat daar een aantal handelignen op verrichten. Beide methodes (startMotor en readBytes) kunnen een DiskDriveException opwerpen, dus die moet je verwerken, of je moet ze verder omhoog sturen.

Aha, dus als ik het goed begrijp kan je een methode een exception laten throwen die je met catch kan opvangen. Gebruik je geen methodes, dan zal je de exception zelf moeten throwen.

Maar dan snap ik alleen nog niet wat nou het voordeel van dit:

code:

try{
 if (argv[0] == 0){
  throw new MijnException("je deelt door 0");
 }
 int 1 = 2/argv[0];
}
catch(MijnException e){
 e.getMessage();
}

boven dit is:

code:

if (argv[0] != 0){
 int i = 2/argv[0];
}
else{
 System.out.println("je deelt door 0");
}

[whoami]

Op donderdag 27 juni 2002 09:53 schreef maartenvdv het volgende:


Aha, dus als ik het goed begrijp kan je een methode een exception laten throwen die je met catch kan opvangen. Gebruik je geen methodes, dan zal je de exception zelf moeten throwen.

Idd, maar in die methode staat er dus ook wel een throw statement die die exception gooit.

Maar dan snap ik alleen nog niet wat nou het voordeel van dit:

code:

try{
 if (argv[0] == 0){
  throw new MijnException("je deelt door 0");
 }
 int 1 = 2/argv[0];
}
catch(MijnException e){
 e.getMessage();
}

boven dit is:

code:

if (argv[0] != 0){
 int i = 2/argv[0];
}
else{
 System.out.println("je deelt door 0");
}

Het voordeel van exceptions is, dat bij het optreden van een type fout, alle code die die fout moet afhandelen op een centrale plaats staat, en dat je die code maar 1 x moet zetten. Ik vind het zelf ook leesbaarder.

[Alarmnummer]

Op donderdag 27 juni 2002 09:53 schreef maartenvdv het volgende:

[..]

Aha, dus als ik het goed begrijp kan je een methode een exception laten throwen die je met catch kan opvangen. Gebruik je geen methodes, dan zal je de exception zelf moeten throwen.

Maar dan snap ik alleen nog niet wat nou het voordeel van dit:

code:

try{
 if (argv[0] == 0){
  throw new MijnException("je deelt door 0");
 }
 int 1 = 2/argv[0];
}
catch(MijnException e){
 e.getMessage();
}

boven dit is:

code:

if (argv[0] != 0){
 int i = 2/argv[0];
}
else{
 System.out.println("je deelt door 0");
}

Bij wiskunde is dat soms wel mogelijk, maar met sommige dingen gewoon niet. Bv.

code:

if(diskdrive.isGoed()){
    diskdrive.startMotor();
    diskdrive.readBytes();
}else{
   ....
}

voor het zelfde geld crached net de diskdrive nadat je isGoed hebt aangeroepen. Dit zijn dingen waar jij dus geen controle over hebt, (en de code zou ook een ware chaos worden).

[maartenvdv737]

Ok, bedankt iedereen.
Ik heb mijn programmaatje nog even gecompiled en het kon inderdaad niet op mijn manier

ter informatie:

code:

class MijnException extends Exception {
 
  public MijnException ( String s ) {
   super(s);
  }
}

class MainProgram {

 static int deler = 1;
 static int my_r[] = new int[1]; 

 public static void main (String argv[]) {
  try {
   if(deler == 0){
     throw new MijnException("je deelt door 0");
   }
   int i = 16 / deler;
   System.out.println(my_r[1]);
  }
  catch(MijnException e) {
   System.out.println(e.getMessage());
  }
  catch(Exception e) {
   System.out.println("Er is een andere fout opgetreden");
  }
  finally {
   // doe altijd dit
  }
 }
}

Zet je deler nu op 0, dan krijg je mijn foutmelding, zet je deler op 1 en roep je een array buiten zijn bereik aan, dan wordt het afgevangen door de algemene Exception.

[Alarmnummer]

waarom gebruik je altijd een finally? Dit is niet nodig hoor. Doe maakje alleen als je wilt dat iets zeker gebeurd (als er wel of geen exception is opgetreden. bv:

code:

try{
   diskdrive.startMotor();
   diskdrive.readBytes(1000);
catch(DiskDriveExcepton e){
   e.printSTackTrace();
}finally{
   try{
    diskdrive.stopMotor(); 
   }catch(DiskDriveException e){
     //hoeft niets mee gedaan te worden.
   }
}

Je wilt hoe dan ook (ook al is er wel of geen exception opgetreden) dat de diskdrive gaat stoppen met ronddraaien. Dat kun je dus op deze manier aanpakken.

En je ziet ook dat ik een printStackTrace gebruik. Dit is super handig om te achterhalen waar de foutmelding heeft plaatst gevonden.

[Verwijderd]

Ik heb momenteel mijn java boeken niet bij de hand, maar volgens mij kan je ook zo iets doen.

code:

public class MyException extends Exception
{
 // vul hier de code in voor de exception
}

public class EenClass
{
 public void eenMethod() throws MyException
 {
  //plaats hier uw code
  if(conditie)
  {
   throw new MyException();
  }
 }
}

public class Test
{
 public void test()
 {
  EenClass ec = new EenClass();
  try
  {
   ec.eenMethod();    //als er iets mis gaat wordt er een MyException afgevuurd
   int a = 100/0;     //geeft een andere Exception

  }
  catch( MyException e)
  {
   //van ec.eenMethod----------------
   e.printStackTrace();
  }
  catch(Exception e)
  {
   //van int a = 100/0;
   e.printStackTrace();
  }
}

[Alarmnummer]

Ik doe ook maar iets

precies.

[Verwijderd]

Volgens mij bestaan exceptions ook uit types.

Kijk hier http://java.sun.com/apis.html eens bij java.lang

[Alarmnummer]

Op donderdag 27 juni 2002 11:48 schreef Chub het volgende:
Volgens mij bestaan exceptions ook uit types.

Kijk hier http://java.sun.com/apis.html eens bij java.lang

Wat wil je hier nou mee zeggen? Als je niets zinnigs weet te zeggen zeg dan niets, of leg in ieder geval uit wat je hiermee bedoelt! Hier wordt de topic starter echt niet mee geholpen. Dus aub dit soort commentaar voor je houden.