Exception

[Mosquera]

Moin,

ich habe gerade versucht eine Exception abzufangen, er führt auch den Anweisungsblock aus, aber komischerweise erscheint die Exception trotzdem in der Konsole.
Ich pack euch hier mal den Code rein.

package ebkherne.hbit3.gaußalgorithmus;

import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;

import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class Logik extends JPanel implements ActionListener {

    private JLabel lblError, lbl_X1, lbl_X2, lbl_X3, lbl_Erg;
    private JTextField txt_1X1, txt_1X2, txt_1X3, txt_1Erg;
    private JTextField txt_2X1, txt_2X2, txt_2X3, txt_2Erg;
    private JTextField txt_3X1, txt_3X2, txt_3X3, txt_3Erg;
    private JButton btnBerechnen;
    private Double[][] Matrix = new Double[3][4];
    private Double[][] Matrix_2 = new Double[3][4];
    private Double[][] Matrix_3 = new Double[3][4];
    private Double[][] Matrix_4 = new Double[3][4];
   
   
    public Logik(int X, int Y) {
       
       
        // erste Reihe
        txt_1X1 = new JTextField();
        txt_1X1.setBounds(20, 40, 100, 20);
        this.add(txt_1X1);
       
        txt_1X2 = new JTextField();
        txt_1X2.setBounds(130, 40, 100, 20);
        this.add(txt_1X2);
       
        txt_1X3 = new JTextField();
        txt_1X3.setBounds(240, 40, 100, 20);
        this.add(txt_1X3);
       
        txt_1Erg = new JTextField();
        txt_1Erg.setBounds(350, 40, 100, 20);
        this.add(txt_1Erg);
       
        // zweite Reihe
        txt_2X1 = new JTextField();
        txt_2X1.setBounds(20, 80, 100, 20);
        this.add(txt_2X1);
           
        txt_2X2 = new JTextField();
        txt_2X2.setBounds(130, 80, 100, 20);
        this.add(txt_2X2);
               
        txt_2X3 = new JTextField();
        txt_2X3.setBounds(240, 80, 100, 20);
        this.add(txt_2X3);
               
        txt_2Erg = new JTextField();
        txt_2Erg.setBounds(350, 80, 100, 20);
        this.add(txt_2Erg);
       
        // dritte Reihe
        txt_3X1 = new JTextField();
        txt_3X1.setBounds(20, 120, 100, 20);
        this.add(txt_3X1);
                   
        txt_3X2 = new JTextField();
        txt_3X2.setBounds(130, 120, 100, 20);
        this.add(txt_3X2);
                       
        txt_3X3 = new JTextField();
        txt_3X3.setBounds(240, 120, 100, 20);
        this.add(txt_3X3);
                       
        txt_3Erg = new JTextField();
        txt_3Erg.setBounds(350, 120, 100, 20);
        this.add(txt_3Erg);
       
        // Button
        btnBerechnen = new JButton("Berechnen");
        btnBerechnen.setBounds(350, 160, 100, 20);
        this.add(btnBerechnen);
        btnBerechnen.addActionListener(this);
       
        // Labels
        lblError = new JLabel();
        lblError.setBounds(20, 160, 300, 20);
        this.add(lblError);
       
        lbl_X1 = new JLabel("X1");
        lbl_X1.setBounds(20, 10, 100, 20);
        this.add(lbl_X1);
       
        lbl_X2 = new JLabel("X2");
        lbl_X2.setBounds(130, 10, 100, 20);
        this.add(lbl_X2);
       
        lbl_X3 = new JLabel("X3");
        lbl_X3.setBounds(240, 10, 100, 20);
        this.add(lbl_X3);
       
        lbl_Erg = new JLabel("Ergebnis");
        lbl_Erg.setBounds(350, 10, 100, 20);
        this.add(lbl_Erg);
       
        this.setPreferredSize(new Dimension(X, Y));
        this.setLayout(null);
    }

    @Override
    public void actionPerformed(ActionEvent ae) {
       
        if(ae.getActionCommand().equals("Berechnen")) {
           
            // Fang Exception ab
            try {
                Matrix[0][0] = Double.parseDouble(txt_1X1.getText());
                Matrix[0][1] = Double.parseDouble(txt_1X2.getText());
                Matrix[0][2] = Double.parseDouble(txt_1X3.getText());
                Matrix[0][3] = Double.parseDouble(txt_1Erg.getText());
               
                Matrix[1][0] = Double.parseDouble(txt_2X1.getText());
                Matrix[1][1] = Double.parseDouble(txt_2X2.getText());
                Matrix[1][2] = Double.parseDouble(txt_2X3.getText());
                Matrix[1][3] = Double.parseDouble(txt_2Erg.getText());
               
                Matrix[2][0] = Double.parseDouble(txt_3X1.getText());
                Matrix[2][1] = Double.parseDouble(txt_3X2.getText());
                Matrix[2][2] = Double.parseDouble(txt_3X3.getText());
                Matrix[2][3] = Double.parseDouble(txt_3Erg.getText());
            } catch (NumberFormatException nfe) {
                lblError.setText("Überprüfen Sie bitte die Felder!");
            }
           
            // Zahlen in Array übergeben
            // Keine Ahnung was hiermit passieren soll
            Matrix[0][0] = Double.parseDouble(txt_1X1.getText());
            Matrix[0][1] = Double.parseDouble(txt_1X2.getText());
            Matrix[0][2] = Double.parseDouble(txt_1X3.getText());
            Matrix[0][3] = Double.parseDouble(txt_1Erg.getText());
           
            Matrix[1][0] = Double.parseDouble(txt_2X1.getText());
            Matrix[1][1] = Double.parseDouble(txt_2X2.getText());
            Matrix[1][2] = Double.parseDouble(txt_2X3.getText());
            Matrix[1][3] = Double.parseDouble(txt_2Erg.getText());
           
            Matrix[2][0] = Double.parseDouble(txt_3X1.getText());
            Matrix[2][1] = Double.parseDouble(txt_3X2.getText());
            Matrix[2][2] = Double.parseDouble(txt_3X3.getText());
            Matrix[2][3] = Double.parseDouble(txt_3Erg.getText());
           
            // I und II angleichen
            double Erg_I_Mal_II_1 = Matrix[0][0] * Matrix[1][0];
            double Erg_I_Mal_II_2 = Matrix[0][0] * Matrix[1][1];
            double Erg_I_Mal_II_3 = Matrix[0][0] * Matrix[1][2];
            double Erg_I_Mal_II_4 = Matrix[0][0] * Matrix[1][3];
           
            double Erg_II_Mal_I_1 = Matrix[1][0] * Matrix[0][0];
            double Erg_II_Mal_I_2 = Matrix[1][0] * Matrix[0][1];
            double Erg_II_Mal_I_3 = Matrix[1][0] * Matrix[0][2];
            double Erg_II_Mal_I_4 = Matrix[1][0] * Matrix[0][3];
           
            // I - II
            double Erg_I_Minus_II_1 = Erg_I_Mal_II_1 - Erg_II_Mal_I_1;
            double Erg_I_Minus_II_2 = Erg_I_Mal_II_2 - Erg_II_Mal_I_2;
            double Erg_I_Minus_II_3 = Erg_I_Mal_II_3 - Erg_II_Mal_I_3;
            double Erg_I_Minus_II_4 = Erg_I_Mal_II_4 - Erg_II_Mal_I_4;
           
            // neue Matrix - neue Werte übernehmen
            Matrix_2[0][0] = Matrix[0][0];
            Matrix_2[0][1] = Matrix[0][1];
            Matrix_2[0][2] = Matrix[0][2];
            Matrix_2[0][3] = Matrix[0][3];
           
            Matrix_2[1][0] = Erg_I_Minus_II_1;
            Matrix_2[1][1] = Erg_I_Minus_II_2;
            Matrix_2[1][2] = Erg_I_Minus_II_3;
            Matrix_2[1][3] = Erg_I_Minus_II_4;
           
            Matrix_2[2][0] = Matrix[2][0];
            Matrix_2[2][1] = Matrix[2][1];
            Matrix_2[2][2] = Matrix[2][2];
            Matrix_2[2][3] = Matrix[2][3];
           
            // I und III angleichen
            double Erg_I_Mal_III_1 = Matrix_2[0][0] * Matrix_2[2][0];
            double Erg_I_Mal_III_2 = Matrix_2[0][0] * Matrix_2[2][1];
            double Erg_I_Mal_III_3 = Matrix_2[0][0] * Matrix_2[2][2];
            double Erg_I_Mal_III_4 = Matrix_2[0][0] * Matrix_2[2][3];
           
            double Erg_III_Mal_I_1 = Matrix_2[2][0] * Matrix_2[0][0];
            double Erg_III_Mal_I_2 = Matrix_2[2][0] * Matrix_2[0][1];
            double Erg_III_Mal_I_3 = Matrix_2[2][0] * Matrix_2[0][2];
            double Erg_III_Mal_I_4 = Matrix_2[2][0] * Matrix_2[0][3];
           
            // I - III
            double Erg_I_Minus_III_1 = Erg_I_Mal_III_1 - Erg_III_Mal_I_1;
            double Erg_I_Minus_III_2 = Erg_I_Mal_III_2 - Erg_III_Mal_I_2;
            double Erg_I_Minus_III_3 = Erg_I_Mal_III_3 - Erg_III_Mal_I_3;
            double Erg_I_Minus_III_4 = Erg_I_Mal_III_4 - Erg_III_Mal_I_4;
           
            // neue Matrix - neue Werte übernehmen
            Matrix_3[0][0] = Matrix_2[0][0];
            Matrix_3[0][1] = Matrix_2[0][1];
            Matrix_3[0][2] = Matrix_2[0][2];
            Matrix_3[0][3] = Matrix_2[0][3];
           
            Matrix_3[1][0] = Matrix_2[1][0];
            Matrix_3[1][1] = Matrix_2[1][1];
            Matrix_3[1][2] = Matrix_2[1][2];
            Matrix_3[1][3] = Matrix_2[1][3];
           
            Matrix_3[2][0] = Erg_I_Minus_III_1;
            Matrix_3[2][1] = Erg_I_Minus_III_2;
            Matrix_3[2][2] = Erg_I_Minus_III_3;
            Matrix_3[2][3] = Erg_I_Minus_III_4;
           
            // II und III angleichen
            double Erg_II_Mal_III_1 = Matrix_3[1][1] * Matrix_3[2][0];
            double Erg_II_Mal_III_2 = Matrix_3[1][1] * Matrix_3[2][1];
            double Erg_II_Mal_III_3 = Matrix_3[1][1] * Matrix_3[2][2];
            double Erg_II_Mal_III_4 = Matrix_3[1][1] * Matrix_3[2][3];
           
            double Erg_III_Mal_II_1 = Matrix_3[2][1] * Matrix_3[1][0];
            double Erg_III_Mal_II_2 = Matrix_3[2][1] * Matrix_3[1][1];
            double Erg_III_Mal_II_3 = Matrix_3[2][1] * Matrix_3[1][2];
            double Erg_III_Mal_II_4 = Matrix_3[2][1] * Matrix_3[1][3];
           
            // II - III   
            double Erg_II_Minus_III_1 = Erg_II_Mal_III_1 - Erg_III_Mal_II_1;
            double Erg_II_Minus_III_2 = Erg_II_Mal_III_2 - Erg_III_Mal_II_2;
            double Erg_II_Minus_III_3 = Erg_II_Mal_III_3 - Erg_III_Mal_II_3;
            double Erg_II_Minus_III_4 = Erg_II_Mal_III_4 - Erg_III_Mal_II_4;
           
            // neue Matrix - neue Werte übernehmen
            Matrix_4[0][0] = Matrix_3[0][0];
            Matrix_4[0][1] = Matrix_3[0][1];
            Matrix_4[0][2] = Matrix_3[0][2];
            Matrix_4[0][3] = Matrix_3[0][3];
           
            Matrix_4[1][0] = Matrix_3[1][0];
            Matrix_4[1][1] = Matrix_3[1][1];
            Matrix_4[1][2] = Matrix_3[1][2];
            Matrix_4[1][3] = Matrix_3[1][3];
           
            Matrix_4[2][0] = Erg_II_Minus_III_1;
            Matrix_4[2][1] = Erg_II_Minus_III_2;
            Matrix_4[2][2] = Erg_II_Minus_III_3;
            Matrix_4[2][3] = Erg_II_Minus_III_4;
           
            System.out.println("Letzte Matrix: ");
            for (int row = 0; row < 3; row++) {
                for (int column = 0; column < 4; column++) {
                    System.out.print(Matrix_4[row][column] + "  ");
                }
                System.out.println();
            }
            System.out.println();
           
            // verbleibene Variable in III. Gleichung nach Variable auflösen und Ergebnis zwischenspeichern
            double Erg_Z = Matrix_4[2][3] / Matrix_4[2][2];
           
            // Ergebnis in II einsetzen, nach Variable auflösen und zwischenspeichern
            double Erg_Y_1 = Matrix_4[1][3] - Matrix_4[1][2] * (Erg_Z);
            double Erg_Y_2 = Erg_Y_1 / Matrix_4[1][1];
           
            // beide Variablen in I einsetzen, nach Variable auflösung und Ergebnis zwischenspeichern
            double Erg_X_1 = Matrix_4[0][3] - (Matrix_4[0][1] * Erg_Y_2 + Matrix_4[0][2] * (Erg_Z));
            double Erg_X_2 = Erg_X_1 / Matrix_4[0][0];
           
            // Ergebnis präsentieren
            System.out.println("Z-Ergebnis: " + Erg_Z);
            System.out.println("Y-Ergebnis: " + Erg_Y_2);
            System.out.println("X-Ergebnis: " + Erg_X_2);
        }
   
    }

}

Ich bedanke mich im Voraus!

Mit freundlichen Grüßen,
Leon Dossin

 

[YOES1805]

So wie ich das kenne erscheint in der Konsole immer, dass eine Exception abgefangen wurde.

 

[mrBrown]

Du fängst die Exception ab, führst danach (bei "// Keine Ahnung was hiermit passieren soll") aber noch mal das gleiche aus, wodurch die gleiche Exception noch mal geworfen wird.

So wie ich das kenne erscheint in der Konsole immer, dass eine Exception abgefangen wurde.

Nein, da tauchen nur nicht-gefangene Exceptoin oder das, was man selbst ausgeben lässt.

 

[YOES1805]

Dann hab ich jetz was neues dazu gelernt danke dir

 

[Mosquera]

Habe die Lösung. Ich musste im catch nach dem setzen des Textes noch ein return dran hängen.
Das ist das doppelt hatte war kein Problem, trotzdem danke für alle Antworten.

 

[mrBrown]

Das ist das doppelt hatte war kein Problem

Doch, genau das war das Problem.
Das return im catch ist eine mögliche Lösung dafür.