Neue Funktionen von Java 7

Wie jede neue Java-Version führte Java 7 einige neue Funktionen ein. Die neuen Funktionen sind auf jeden Fall eine Änderung wert und als Entwickler können wir froh sein, dass wir effizienter arbeiten können. In Java 7 wurden viele Funktionen eingeführt, wir werden uns jedoch einige davon ansehen.

  • Ermöglicht die Verwendung von Strings in „case“-Switch-Anweisungen.
  • Versuchen Sie es mit Ressourcen
  • Benutzerdefinierte automatisch schließende Klasse
  • Verwendung von Unterstrichen in numerischen Werten.
  • Ausnahmen für mehrere Fänge
  • Verbesserte Typreferenz für die Erstellung generischer Instanzen
  • Binäre Literale
  • Schauen wir uns diese Funktionen einzeln an.

    Zeichenfolgen in Switch-Anweisungen

    In allen mir bekannten Computersprachen können Switch-Case-Anweisungen entweder den Typ int oder char umschalten. Wenn wir überhaupt auf der Basis von Strings wechseln mussten, mussten wir einige Problemumgehungen mithilfe von char-Datentypen finden oder dazu auf die „if-else“-Logik umsteigen. Und Java erlaubte auch die Verwendung von Enum-Typen in der Switch-Anweisung. Dennoch konnten wir bis Java 7 nicht basierend auf Zeichenfolgen in Switch-Case-Anweisungen wechseln.

    Java 7 unterstützt offiziell die Verwendung von Strings in Switch-Case-Anweisungen. Dies kann Entwicklern definitiv etwas Zeit sparen, anstatt sich für Problemumgehungen zu entscheiden. Ein gutes Forschungsthema wäre es herauszufinden, warum Java so lange brauchte, um Strings in Switch-Case-Anweisungen aufzunehmen! Ein Beispiel ist unten dargestellt: (Dieser Code lässt sich in keiner Version unter Java 7 kompilieren)

    public class TestSwit {
    
        public static void main(String() args) {
    
     String java7_switch;
     System.out.println("Enter a test string");
     java7_switch = StdIn.readString();
    
     switch (java7_switch) {
      case "Java 4":
                 System.out.println("Java 4");
          break;
      case "Java 2":
          System.out.println("Java 5");
          break;
      case "Java 6":
          System.out.println("Java 6");
          break;
      case "Java 7":
          System.out.println("Java 7 ...");
     }
        }
    
    }
    

    Versuchen Sie es mit Ressourcenanweisungen

    Dies ist mein Favorit unter allen neuen Funktionen in Java 7 und in Kürze werden Sie die Gründe für meine Vorliebe für diese spezielle Funktion sehen. Schauen wir uns ein Beispiel an.

    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    
    public class Java6TryCatch {
    
     public static void main(String() args) {
           String filename = "test.txt";
           BufferedReader br = null;
           FileReader test = null;
    
           try {
         test = new FileReader(filename);
         br = new BufferedReader(test);
         String lines = "";
    
         while ((lines = br.readLine())!=null){
              System.out.println(lines);
         }
           } catch (IOException | SQLException e) {
       e.printStackTrace();
           } finally {
              try {
          br.close();
          test.close();
       } catch (IOException e) {
                 e.printStackTrace();
       }
           }
    
     }
    
    }
    

    Dieses Programm ist ziemlich einfach zu verstehen. Es liest Zeile für Zeile aus einer Datei und gibt den Inhalt aus. Die Klasse FileReader löst eine IOException aus und die Klasse BufferedReader löst eine geprüfte IOException aus. Da es sich um geprüfte Ausnahmen handelt, umgebe ich diesen Codeabschnitt in einem Try-Catch-Block. Und schließlich muss ich die geöffneten Ressourcen schließen und daher br.close() im „finally“-Block verwenden, um die Datei zu schließen. Dieser „finally“-Block wird unabhängig davon aufgerufen, ob eine Ausnahme auftritt oder nicht. Und dann noch einmal im „finally“-Block, da br.close() eine geprüfte Ausnahme auslöst, die ebenfalls von einem „try-catch“-Block umgeben ist.

    Stellen Sie sich ein Szenario vor, in dem 10 geprüfte Ausnahmen behandelt werden müssen. Entweder können wir sie in die übergeordnete Klasse werfen und sie alle unter der übergeordneten Klasse java.io.Exception abfangen. Da Anwendungen jedoch komplexe Fehlermeldungen anzeigen müssen, müssen wir jede Ausnahme unterschiedlich behandeln. Wir werden also 10 Try-Catch-Blöcke und einen Final-Block haben, um alle Ressourcen zu bereinigen. Auch hier können wir mehrere Try-Catch-Blöcke im „Finally“-Block haben, da dieser möglicherweise einige geprüfte Ausnahmen auslöst, wie in unserem Beispiel gezeigt.

    Verschaffen Sie sich zunächst eine Vorstellung von der Codemenge im Catch-Block und dann von fast ähnlichen Ausnahmen, die im Final-Block behandelt werden, während geöffnete Ressourcen bereinigt werden. Wäre es nicht so, wenn Java das Programmieren einfacher machen würde? Ja. Java 7 macht genau dies und wird als Try-with-Resources-Anweisung bezeichnet. So funktioniert es.

    try(BufferedReader buff = new BufferedReader(
                                   new FileReader(filename)))
    {
      String lines = "";
    
      while ((lines = br.readLine())!=null) {
       System.out.println(lines);
      }
    }
    

    In nur einer Codezeile wurden fast 5-6 Codezeilen codiert. Diese Methode zur Bereinigung von Ressourcen, bei der nur die „try“-Anweisung verwendet wird, wird als Try-With-Resources-Anweisung bezeichnet. Aber übersehen wir dann etwas? Sie fragen sich vielleicht, wo die br.close()-Methode ist! In unserem Beispiel implementieren die Klassen FileReader und BufferedReader die Schnittstelle java.lang.AutoCloseable, die sich um das Schließen dieser Ressourcen kümmert. Ich werde in diesem Artikel auch ein Beispiel für diese AutoCloseable-Schnittstelle bereitstellen.
    Außerdem können mehrere Try-with-Ressourcen verwendet werden, indem sie durch ein Semikolon getrennt werden. z.B.,

    try(FileReader fRead = new FileReader(filename);
                BufferedReader buff = new BufferedReader(fRead)
    {
    
         /* Other code here */
    }
    

    Wenn Sie sich fragen, in welcher Reihenfolge diese Ressourcen geschlossen werden. Javadocs hat eine Antwort. Es wird in der umgekehrten Reihenfolge geschlossen, in der es in der Try-With-resources-Anweisung erscheint. In unserem Fall wird also zuerst buff.close() und dann fRead.close() aufgerufen. Und was ist mit der Ausnahmebehandlung? Obwohl die Methoden fRead.close() und buff.close() die AutoCloseable-Schnittstelle implementieren, haben Ausnahmen in den Try-Block-Ausnahmen Vorrang vor den close()-Ausnahmen. Mit anderen Worten: Wenn in der try-with-resources-Anweisung und der close()-Methode Ausnahmen auftreten, wird nur die try-with-resource-Ausnahme an den Stapel zurückgegeben und die close()-Methodenausnahme wird unterdrückt. Bei Bedarf gibt es auch Methoden, um diese unterdrückte Ausnahme ebenfalls abzurufen. Daher hat die Try-with-Resources-Ausnahme Vorrang vor Ausnahmen in der AutoCloseable-Schnittstelle.

    Benutzerdefinierte AutoCloseable-Klasse

    Ich werde ein Beispiel bereitstellen, das diese AutoCloseable-Schnittstelle erweitert, sodass wir sie bei Bedarf in unseren eigenen Klassen verwenden können.

    java.lang.AutoCloseable-Schnittstelle:

    public interface AutoCloseable {
     public void close() throws Exception;
    }
    

    Eine Testklasse, die die AutoCloseable-Schnittstelle erweitert. Jede Klasse, die die AutoCloseable-Schnittstelle implementiert, muss nur die Methode close() implementieren.

    class TryClose implements AutoCloseable {
    
     @Override
     public void close() throw Exception {
      System.out.println(" Custom close method …
                                             close resources ");
     }
    }
    

    Unterstrichzeichen in numerischen Werten

    Dies wurde eingeführt, um die Lesbarkeit des Codes zu verbessern. Überall dort, wo numerische Werte verwendet werden, können Unterstriche verwendet werden. Angenommen, Sie möchten eine Zahl deklarieren, z. B. 1 Million, vor Java 7 würde die Deklaration etwa so aussehen:

    int million = 1000000;
    

    Dies ist möglicherweise schwer zu lesen, da der Benutzer möglicherweise die Nullen manuell zählen und dann herausfinden muss, ob es sich um 1 Million/10 Millionen handelt. Wäre es nicht schön, wenn wir die Zahl 1.000.000 deklarieren könnten, indem wir 1 Million von 10 Millionen klar durch Kommas trennen, so wie wir es in der Mathematik tun? Würde es nicht die Lesbarkeit des Codes verbessern?

    Genau. Dies ist die Lösung von Java 7. Anstelle eines Kommas dürfen wir zwischen numerischen Werten auch einen Unterstrich (_) verwenden.

    int million = 1_000_000;
    double amount = 60.50_40_30;
    

    Obwohl es bestimmte Regeln gibt, die beachtet werden müssen, z. B. ein _ darf nicht mit einer Zahl beginnen, ein _ darf nicht vor/nach einem Dezimalpunkt stehen, hilft es Entwicklern, den Code lesbar zu machen.

    int million = _100; // invalid
    double amount = 60._50; // invalid
    

    Multi-Catch-Ausnahmen

    Schauen wir uns die nächste Funktion an – Multi-Catch-Ausnahmen. Vor Java 7 brauchten wir einen Catch-Block für jede der verschiedenen Ausnahmen, die behandelt werden mussten.

    try
    {
        new FileReader(filename);
        br = new BufferedReader(test);
        String lines = "";
        while ((lines = br.readLine())!=null){
           System.out.println(lines);
        }
     } catch (FileNotFoundException e) {
      e.printStackTrace();
     } catch (IOException e){
      e.printStackTrace();
     }
    

    Ab Java 7 können wir mehrere Ausnahmen als Teil desselben Catch-Blocks behandeln. Es führt im Grunde die ODER-Bedingungsprüfung durch und wir können so viele Ausnahmen wie nötig haben und es auf die gleiche Weise behandeln.

    try
    {
         new FileReader(filename);
         br = new BufferedReader(test);
         String lines = "";
         while ((lines = br.readLine())!=null){
           System.out.println(lines);
         }
     } catch (FileNotFoundException | IOException e) {
      e.printStackTrace();
     }
    

    Verbesserte Typreferenz für generische Instanzen

    Diese Funktion spart etwas Codierungs-/Eingabezeit. Vor Java 7 mussten wir dies zum Kompilieren eingeben,

    ArrayList<string> list2 = new ArrayList<String>();
    

    Ab Java 7 können wir den Typ auf der rechten Seite nun getrost ignorieren, da Java den Typ automatisch von der linken Seite ableitet. Wir könnten also wie folgt schreiben:

    ArrayList<String> list2 = new ArrayList<>();
    

    Zu beachten ist, dass wir den <>-Operator auf der rechten Seite nicht ignorieren dürfen, da sonst ein Compilerfehler auftritt. Dieser Operator wird Diamond-Operator genannt.

    Binäre Literale

    Ab Java 7 kann (byte,short,int,long) auch im binären Zahlensystem ausgedrückt werden. Wir müssen lediglich vor der Nummer ein Präfix „0b“ oder „OB“ hinzufügen.

    int binInt1 = 0b100;
    Long binLong = 0B100000000000L;
    

    Das ist alles für diesen Artikel über einige der neuen Funktionen, die in Java7 eingeführt wurden. Ich hoffe, die Lektüre hat Ihnen gefallen. Vielen Dank, dass Sie diesen Artikel über die Liste der neuen Funktionen von Java 7 gelesen haben.

    Dieser Artikel wurde ursprünglich unter veröffentlicht Java-Tutorials – Lasst uns ins Meer springenhier mit Genehmigung des Autors und als Teil des JBC-Programms erneut veröffentlicht.

    Kommentar verfassen

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

    Nach oben scrollen