Java InputMismatchException

[yxy]

Hi,

mir ist aufgefallen, dass ich die InputMismatchException für eine Verwendung importieren muss.
Die "standard" Exception muss ich aber nicht importieren.

Liegt es daran, dass die "standard" Exception in der Klasse "Object" bereits definiert ist, die InputMismatchException aber nicht?

package Exceptions;

import java.util.Scanner;
import java.util.InputMismatchException; //muss ich nicht bei (Exception ex) importieren

public class MainClass {

    public static void main(String[] args) {
        Scanner userInput = new Scanner(System.in);
        while (true) {
            System.out.println("Zahl eingeben: ");
            try {
                double i = userInput.nextDouble();
                System.out.println("Eingegeben wurde: " + i);
                break;
            } catch (InputMismatchException ex) {    //oder allg:(Exception ex) 
                userInput.next();       
                System.out.println("Falsche Eingabe");
            }
        }
    }
}

 

[Faust2011]

Exception gehört zum Package java.lang und das muss niemals importiert werden. Demgegenüber lebt Deine genannte Exception im Package java.util.

 

[yxy]

Danke

Übrigens, bitte mach keine weiteren Threads zu Deinen Java-Themen auf, sondern nutze dazu einen! Das sollte reichen, danke.

Also ein Thread für mehrere Fragen?

 

[Faust2011]

Ja, genau. Du hast doch bestimmt noch ein paar Fragen rund um Java, oder?

 

[yxy]

Ok, dann mache ich es so.

2. Frage:

Folgender Fehler wird bei unterem Code ausgegeben:
constructor MySimpleException in class MySimpleException cannot be applied to given types

Code:

    package Exceptions;
  
    public class MainClass2 {
  
        public static void main(String[] args) {
            MainClass2 koko = new MainClass2();
            try {
                koko.methodeOne();
            } catch (MySimpleException ex) {
                ex.getMessage();
            }
        }
  
        public void methodeOne() throws MySimpleException {
            int i = -5;
            methodeTwo(i);
        }
  
        public void methodeTwo(int i) throws MySimpleException {
            if (i < 0) {
                throw new MySimpleException("Zahl kleiner als Null");
            }
        }
    }

Code:

    package Exceptions;
  
    public class MySimpleException extends Exception {
     
    }

Lösung:

public class MySimpleException extends Exception {

    MySimpleException(String s) {
        super(s);
    }
}

Meine Interpretation:
Wenn ich das nicht mache, wird auf den Standardkonstruktor der Klasse zugegriffen, der keinen Parameter erwartet.
Durch: "MySimpleException(String s)" sage ich, dass ich einen Klassen-Konstruktor haben will, der eine Übergabe eines Strings als Parameter erwartet.
Durch: "super" reiche ich den übergebenen Parameter an den Konstruktor der Oberklasse weiter.

D.h. die Konsstruktoren der Oberklasse werden nicht an die Unterklasse vererbt. Immer wenn ich eine neue Unterklasse erstelle in der ich keine Konstruktoren schreibe, gibt es für die Klasse nur den Standardkonstruktor.

Richtig?

Ergänzung (16. Mai 2018)

Aber warum geht dann folgendes nicht?:
Der Standardkonstruktor der keinen Parameter erwartet, muss ich doch nicht extra definieren?

 package Exceptions;

    public class MainClass2 {

        public static void main(String[] args) {

            MainClass2 koko = new MainClass2();

            try {
                koko.methodeOne();
            } catch (MySimpleException ex) {
                ex.getMessage();
            }
        }
        public void methodeOne() throws MySimpleException {
            int i = -5;
            methodeTwo(i);
        }
        public void methodeTwo(int i) throws MySimpleException {
            if (i < 0) {
                throw new MySimpleException();//*********************************************************
            }
        }
    }
    package Exceptions;

    public class MySimpleException extends Exception {

    MySimpleException(String s) {
        super(s);                   //*
    }
    }

 

[DefconDev]

Hast du überhaupt eine Idee wofür super steht?
Vielleicht solltest du dir erst ein mal eine gute Lektüre schnappen und sie sich in Ruhe zu Gemüte führen.

 

[yxy]

Mit Java super können wir nämlich die Konstruktoren der Oberklasse aufrufen.

http://www.codeadventurer.de/?p=3027

Oder ist diese Erklärung nicht ganz korrekt?

 

[Drexel]

Ist schon richtig Konstruktoren werden nicht vererbt.

In C# generiert der Compiler wenn Du keinen Konstruktor angibst den leeren Standardkonstruktor. Wenn Du aber einen Konstruktor definierst macht der Compiler nichts weiter automatisch(wäre auch unsinnining), d.h. es gibt nur die Konstruktoren, die Du explizit definierst hat. Ich vermute Java hält es genauso.

 

[yxy]

Achso, darum gibt es dann in Beispiel zwei #5 nur noch einen Konstruktor, der einen String als Parameter fordert.

 

[andy_m4]

http://www.codeadventurer.de/?p=3027
Oder ist diese Erklärung nicht ganz korrekt?

Ehrlich gesagt hab ich bei

Das Schlüsselwort Java super wirkte wie Juckpulver auf meinem Kopf.

aufgehört zu lesen.

Ich glaub Hades85 meinte mehr so Literatur im Stile von Java ist auch eine Insel, wo eigentlich auch ziemlich erschöpfend auf die Grundlagen von Java eingegangen wird. Inkl Klassen/Objekte und auch Exceptions.

Sicherlich ist Programmierung nicht etwas, was man durch Lesen eines Buches lernen kann, sondern wo das Machen eine ganz große Rolle spielt.

Nichtsdestotrotz kann die Lektüre solcher Werke ganz nützlich sein, weil man eben auch Zusammenhänge erklärt bekommt. Wie funktioniert das überhaupt und warum sind Sachen so, wie sie sind usw.
Mal weg von der konkreten Codezeile mehr hin zum "Big Picture".

Denn letztlich sollte es nicht nur darum gehen, seinen Code irgendwie zum laufen zu kriegen, sondern man sollte auch wirklich verstehen was da passiert.
Das ist anstrengend. Aber nur so kommt man vorwärts.

 

[yxy]

Ehrlich gesagt hab ich bei
aufgehört zu lesen.

Ja, das kann ich mir vorstellen xD.

 

[Drexel]

Btw lerne zu googlen und offizielle Dokumentationen zu nutzen. Hier stehts: https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html
Dort steht auch, dass der Compiler einen default Konstruktor ohne Argumente anlegt, wenn man keine Konstruktoren definiert, der auch auch automatisch den leeren Konstruktor der Super-/Basisklasse aufruft. Also wenn Du volle Kontrolle ohne implizite Mechanismen haben willst, definierst Du Deine Konstruktoren besser.

 

[Faust2011]

@yxy: Was ist eigentlich der Hintergrund Deiner Beschäftigung mit Java?