Grundlagen der Java-Programmierung

Grundlegende Syntax

Variablen- / Konstantendeklaration

 String　str　= null;    //Variable
 final String STR = "msg";    //Konstante
 long l = 1111111111L;    //Langer Typ wird mit L am Ende deklariert
 float f = 1111.111F;    //Der Float-Typ wird schließlich mit F deklariert
 double d = 1111.111;    //Der Dezimalpunkt ist doppelt
 char c = 'c';    //char Typ ist''damit
 str = "a\na\ta";    //\n:Neue Zeile\t:Tab

 //Deklarieren Sie int als Referenztyp
 Integer I = new Integer(32);
 int n = I.intValue();

 //Name der Deklaration
 Integer I2 = 2;    // auto boxing
 int i = 1;    // auto unboxing

Operator

Operatoren haben eine Priorität, wobei die höchste Priorität oben in der Tabelle steht.

if

 if (Bedingter Ausdruck) {
     //wird bearbeitet
 } elseif (Bedingter Ausdruck) {
    　//wird bearbeitet
 } else {
     //wird bearbeitet
 }

Übrigens können Sie {} weglassen, In diesem Fall wird das Endergebnis der if- und else-Klauseln ausgeführt.

switch

 String singou = "red";
 switch (singou) {
     case "red":
            //wird bearbeitet
     break;
     case "yellow":
         //wird bearbeitet
     break;
     case "blue":
         //wird bearbeitet
     break;
     default:
         //wird bearbeitet
 }

Standard wird in allen Fällen ausgeführt. Wenn es keine Unterbrechung gibt, wird alles darunter ausgeführt Verfügbare Typen sind Byte, Short, Int, Char, Enum, String

while dowhile

 while (Bedingter Ausdruck) {
     //wird bearbeitet
 }

 do {
     //wird bearbeitet
 } while (Bedingter Ausdruck);

Die Verarbeitung wird ausgeführt, während der bedingte Ausdruck wahr ist. Es ist die Eisenplatte, die die Variablen erhöht, die im bedingten Ausdruck im Prozess verwendet werden. Der Unterschied zwischen while und dowhile ist der Ort des Urteils.

for

 for (int i=0; i<5; i++){
     if (i < 2) {
          continue;    //Nächste Schleife
     } else {
          break;       //Ende der Schleife
     }
 }

Schreiben Sie für ((1) Zählerdeklaration; (2) bedingten Ausdruck; (3) Erhöhen / Verringern der Zählervariablen). ①, ② und ③ können jeweils weggelassen werden. für (;;); ist kein Fehler.

• Es scheint, dass die for-Anweisung in java8 tatsächlich veraltet ist ... Übrigens, wenn Sie ein Etikett anbringen, können Sie sofort auf dieses Niveau aufbrechen.

 class Nest {
    public static void main(String[] args) {
        int num[][] = {
                        {0, 1, 2},
                        {3, 4, 5},
                        {6, 7, 8}
                      };
        int i = 0;
        label:
        while(true) {
            int j = 0;
            while(j < 3) {
                System.out.print(num[i][j]);
                j++;
                if(i == 1) break label;
            }
            i++;
        }
    }
}

Klassenstruktur

Klasse

 public class Animal {
    //Konstrukteur
    Animal(){
        System.out.println("new Animal created");
    }
    //Konstruktor mit Argumenten
    Animal(String species){
        System.out.println("new " + species + " created");
    }

    void animalMethod() {
        System.out.println("this is animal method!");
    }

    void characteristic() {
        System.out.println("I'm alive!");
    }
}

Schnittstelle

 //Schnittstellendeklaration
 interface Breath {
    //Mitgliedsvariablen werden ohne Erlaubnis statisch endgültig
    String breath = "Breathing!";
    //Die Schnittstellenmethode hat keinen Körper
    void breath(String breath);
}

Als nächstes eine untergeordnete Klasse, die die Animal-Klasse und die Schnittstelle implementiert.

 //Vererbung und Schnittstellenimplementierung
 public class Dog extends Animal implements Breath{
    //Der Konstruktor ist implizit super()Getan werden
    //Sie können einen Konstruktor mit einem übergeordneten Argument angeben, indem Sie es angeben.
    Dog(){
        super("Dog");
    }

    //überschreiben
    //Fehler, wenn die abstrakte Methode der Schnittstelle nicht überschrieben wird.
    @Override
    public void breath(String breath) {
        System.out.println(breath);
    }

    //überschreiben
    @Override
    public void characteristic() {
        System.out.println("I have 4 legs!");
    }
 }

Hauptfunktion

 public class Main {

    public static void main(String[] args) {

        Dog dog = new Dog();        //①new Dog created

        dog.animalMethod();         //②this is animal method!

        //Alle Mitgliedsvariablen der Schnittstelle sind statisch final
        dog.breath(Breath.breath); //③Breathing!

        dog.characteristic();      //④I have 4 legs!

        Animal dogA = new Dog();  //⑤new Dog created

        //dogA.breath();          //⑥

        dogA.characteristic();    //⑦I have 4 legs!
    }
 }

① ist die Erstellung einer Dog-Instanz, und der Konstruktor der Dog-Klasse wird aufgerufen. ② ist die geerbte Methode. ③ ist die Methode, die von der Dog-Klasse der Schnittstelle überschrieben wird. ④ ist eine Methode, die von der Dog-Klasse der Animal-Klasse überschrieben wird. ⑤ fügt die Dog-Instanz in die Variable Animal type ein. (Das Gegenteil ist nicht möglich) Da ⑥ ein Tiertyp ist, wird der Atem nicht implementiert und kann nicht verwendet werden. ⑦ ist ein Tiertyp, aber der neue ist Hund, und selbst wenn er ausgestoßen ist, ist er das Merkmal von Hund.

Rückgabewert und Überladung

Der Methode, die den Rückgabewert zurückgibt, sollte der Typ vorangestellt werden, der in der Deklaration zurückgegeben werden soll, und die Rückgabeklausel muss geschrieben werden. Überladen ist die Erstellung von Methoden mit demselben Namen und unterschiedlichen Anzahlen oder Arten von Argumenten.

 class Calc {
    int sum(int a, int b) {
        return a + b;
    }
    //Überlast
    int sum(int a, int b, int c) {
        return a + b + c;
    }
 }

Abstrakte Klassen und Schnittstellen

Die abstrakte Klasse hat eine Beziehung zur untergeordneten Klasse. Die Schnittstelle hat eine Can-Do-Beziehung zur untergeordneten Klasse.

 abstract class Animal {
    String name;
 
    Animal(String name){
        this.name = name;
    }
    //Sie können eine bestimmte Verarbeitung schreiben.
    void sleep(){
        System.out.println("sleeping!");
    }
    //Die abstrakte Methode zwingt die untergeordnete Klasse zur Implementierung
    abstract void speak();
 }
 
 interface Animal2{
    String name = null;
 
    //Sie können den Prozess standardmäßig schreiben
    default void sleep(){
        System.out.println("sleeping!");
    }
    //Gewöhnliche Methoden zwingen untergeordnete Klassen zur Implementierung
    void speak();
 }

Aufzählungstyp

 //Wird in aufgezählten Programmen als eine Klasse behandelt
 enum Output {
    OK, NG,
 }
 
 public class Enum {
 
    public static void main(String[] args) {
        Output out;
 
        out = Output.NG;
 
        switch (out) {
        case OK:
            System.out.println("OK!");
            System.out.println(out.ordinal()); // 0
            break;
        case NG:
            System.out.println("NG!");
            System.out.println(out.ordinal()); // 1
            break;
        }
    }
 }

Zugriffsmodifikatoren und statische

Zugriffsmodifikator

Es gibt vier Zugriffsmodifikatoren für Java.

Durch die Kombination dieser können Daten ausgeblendet und gekapselt werden. Ausblenden von Daten: Trennen Sie Mitglieder (Attribute und Operationen) in öffentliche und private und vermeiden Sie den direkten Zugriff auf Attribute von außen. Kapselung: Um ein Attribut und die Operation zu haben, um auf das Attribut in einem im Objekt zuzugreifen.

 public class Parser {
 
    private String str = null;
 
    public String getStr() {
        return str;
    }
    private void setStr(String param) {
        str = param;
    }
 }

static

Klassenfelder und Klassenmethoden können implementiert werden, indem Variablen und Methoden statisch hinzugefügt werden.

class StaticClass {
 
    //statisches Element
    static String staticStr;
    static String getStaticStr(){
        return staticStr;
    }
    //Instanzmitglied
    String instanceStr;
    String getInstatnceStr() {
        return instanceStr;
    }
 
    //statischer Initialisierer
    static {
        StaticClass.staticStr = "staticStr";
    }
    //Instanzinitialisierer
    {
        instanceStr = "instanceStr";
    }
 }
 
 class Main {
 
    public static void main(String[] args) {
 
        //statische Referenz
        StaticClass.staticStr = StaticClass.staticStr + "Main";
        System.out.println(StaticClass.getStaticStr());  //staticStrMain
 
        //Instanzreferenz
        StaticClass stsCls = new StaticClass();
        stsCls.instanceStr = stsCls.instanceStr + "Main";
        System.out.println(stsCls.instanceStr);  //instanceStrMain
    }
 }

Der Initialisierer kann Variablen initialisieren. Der Initialisierer wird übrigens vor der Instanziierung und der Konstruktor nach der Instanziierung ausgeführt. Statische Elemente (statische Elemente) bleiben erhalten, bis die Anwendung gestoppt wird Instanzmitglieder bleiben nur so lange erhalten, bis die Instanz getötet wird.

Generischer Typ und Platzhalter

Generischer Typ

Wenn Sie nicht wissen, welcher Typ passt, bis Sie ihn verwenden, können Sie den generischen Typ verwenden. Zunächst der generische Typ der Klasse.

//Durch Verallgemeinern des Typs kann er mit verschiedenen Typen verwendet werden.
//T ist Brauch(Type).. Alles ist gut
class GenericSample {
    private T value;
    public void setValue(T val) {
        value = val;
    }
    public T getValue() {
        return value;
    }
}
public class Generics {
    public static void main(String[] args) {
        GenericSample i = new GenericSample<>();
        i.setValue(10);
        System.out.println(i.getValue());  //10
        GenericSample s = new GenericSample<>();
        s.setValue("Hello");
        System.out.println(s.getValue());  //Hello
    }
}

Als nächstes folgt der generische Typ von Konstruktoren und Methoden.

class MethodConstractorSample {
 
    //Stellen Sie dem Konstruktor ein formelles Argument vor
     MethodConstractorSample(T arg) {
        System.out.println(arg);
    }
    //Setzen Sie ein formales Argument vor den Rückgabewert der Methode
    //(T kann auch als Rückgabewert verwendet werden)
    public static  boolean genericSample(T arg) {
        T t = arg;
        if (t != null) {
            return true;
        } else {
            return false;
        }
    }
}

Platzhalter

Platzhalter: Verwenden Sie diese Option, wenn Sie eine Klasse oder Methode verwenden, wenn Sie den Typ erst kennen, wenn Sie ihn ausführen.

class WildCard {
    //Ein Beispiel, in dem die Rückgabe einer Liste behoben ist, Sie jedoch erst dann wissen, um welchen Listentyp es sich handelt, wenn Sie ihn ausführen.
    public List createList(boolean s) {
        if (s) {
            return new ArrayList();
        } else {
            return new ArrayList();
        }
    }
}

Referenz

Sammlung

Eine Sammlung ist eine Klasse, die einen Typ bestimmt und aufeinanderfolgende Werte dieses Typs hat. Es gibt Liste, Karte und Satz, von denen jeder seine eigenen Eigenschaften hat. (Klassen sind unter diesen drei, Liste, Karte, Satz sind Schnittstellen)

List

Es ist eine Wende. Es gibt ArrayList und LinkedList. ArrayList: Die Suche ist schnell. LinkedList: Das Hinzufügen / Löschen erfolgt schnell.

List<Integer> list = new ArrayList<>();
 
list.add(10);
list.add(20);
System.out.println(list.get(1));  //20

Set Lassen Sie keine doppelten Werte zu. Es gibt HashSet, TreeSet und LinkedHashSet. HashSet: Außer Betrieb. TreeSet: Nach Wert sortiert. LinkedHashSet: Sortiert in der Reihenfolge, in der sie hinzugefügt wurden.

Set<Integer> hashSet = new HashSet<Integer>();
 
hashSet.add(10);
hashSet.add(20);
hashSet.add(10);
System.out.println(hashSet.size());  //2

Map Hat einen Schlüssel und einen Wert.

Es gibt HashMap, TreeMap und LinedHashMap. HashMap: Keine Bestellung. TreeMap: Nach Schlüssel sortieren. LinedHashMap: Nach Reihenfolge sortieren.

Map <String, Integer> hashMap = new HashMap<>();
 
hashMap.put("sato", 50);
hashMap.put("ito", 60);
 
System.out.println(hashMap.get("sato"));  //50

for each für (Art des Inhalts Variablenname des Inhalts: Array und Sammlung) Alle Inhalte von Arrays und Sammlungen können verarbeitet werden.

Mit der obigen Sammlung sieht es so aus.

for (Integer data : list) {
    System.out.println(data);  //10, 20
}
 
//Map.Entry<K,V>Ist der Typ (Schnittstelle) des Inhalts der Karte
//hashMap.entrySet()Der Rückgabetyp von ist Set<Map.Entry<K,​V>>
for (Map.Entry<String, Integer> score : hashMap.entrySet()) {
    System.out.println(score.getKey() + " : " + score.getValue());
    //ito : 60
    //sato : 50
}

Ausnahmebehandlung

Die Ausnahmebehandlung verwendet die Ausnahme. Eine Ausnahme auslösen, abfangen und versuchen, eine eigene Ausnahme auszulösen.

public class ExceptionSample {
 
    public static void main(String[] args) {
 
        try {
 
            //NumberFormatException tritt hier auf
            String s = "No.1";
            System.out.println(Integer.parseInt(s));
 
        } catch (ArithmeticException e) {
 
            System.err.println("ArithmeticException: " + e.getMessage());
 
        //NumberFormatException ist keine Unterklasse von ArithmeticException
        //Fang in Ausnahme
        } catch (Exception e) {
 
            //GetMessage zum Abrufen der Nachricht
            System.err.println("Exception: " + e.getMessage());
 
        } finally {
            try {
                //MyException auslösen
                getErr();
 
            //Catch MyException
            }catch(MyException e){
                System.err.println(e.getMessage());
            }
        }
    }
 
    //Wenn Sie es nicht selbst fangen, geben Sie eine Ausnahme an den Anrufer zurück.
    static void getErr() throws MyException {
        throw new MyException("MyException!");
    }
}
 
//Die Definition der ursprünglichen Ausnahme wird erweitert
//Sie können die Nachricht im Konstruktor festlegen.
class MyException extends Exception {
    public MyException(String s) {
        super(s);
    }
}

·Ausgabe

 Exception: For input string: "No.1"
 MyException!

Lambda-Stil

Ein Lambda-Ausdruck ist ein Ausdruck, der eine Instanz erstellt, die eine Schnittstelle implementiert. Wenn Sie die anonyme Klasse weglassen, die die lokale Klasse weglässt, wird sie zu einem Lambda-Ausdruck.

Lokale Klasse

public static void main(String[] args) {
 
    //Lokale Klasse:Deklarieren Sie eine Klasse in einer Methode
    class Local implements Runnable {
        public void run() {
            System.out.println("Hello LocalClass!");
        }
    }
    Runnable runner = new Local();
    runner.run(); // Hello LocalClass!
}

Anonyme Klasse

public static void main(String[] args) {
 
    //Anonyme Klasse:Lassen Sie die lokale Klassendeklaration aus, die die Schnittstelle implementiert
    // new Runnable(){}Erstellen Sie eine anonyme Klasseninstanz, die wie eine ausführbare Instanz aussieht
    Runnable runner2 = new Runnable() {
        public void run() {
            System.out.println("Hello NoNameClass!");
        }
    };
    runner2.run(); // Hello NoNameClass!
}

Lambda-Stil

public static void main(String[] args) {
 
    //Lambda-Stil:Anonyme Klasse weglassen
    // ()Es läuft()Argumente von
    // ->{}Ist die Implementierung der Ausführungsmethode
    //Erraten Sie den Schnittstellentyp anhand des Typs des Zuweisungsziels
    Runnable runner3 = () -> {
        System.out.println("Hello Lambda!");
    };
    runner3.run(); // Hello Lambda!
 
    //Übergeben Sie eine anonyme Klasseninstanz an die Methodenmethode und ermitteln Sie dies später anhand des Arguments Runnable
    method(() -> {
        System.out.println("Hello Lambda!");
    });
}

public static void method(Runnable r) {
    r.run();
}

Mit anderen Worten, der Lambda-Ausdruck ist ungefähr korrekt, wenn Sie glauben, dass die Methode durch () -> {} generiert wird. Insbesondere ist der Inhalt von {} der Implementierungsinhalt und der Inhalt von () ist die Methode des Arguments. Erstellen einer anonymen Klasseninstanz eines Schnittstellentyps.

Da () nicht weiß, welche Methode verwendet wird, kann die abstrakte Methode nur für eine Schnittstelle verwendet werden.

Funktionsschnittstelle

Eine Schnittstelle mit einer abstrakten Methode. Perfekt für den Lambda-Stil.

// Function<Argumenttyp T.,Rückgabewert R.>Die Schnittstellenmethode ist R Apply(T)
Function<Integer, String> asterisker = (i) -> {
    System.out.println("Function");
    return "*" + i;
};
String result = asterisker.apply(10);
System.out.println(result); // *10
//BiFunction hat 2 Argumente
 
// Consumer<Argumenttyp>Methode ist nichtig zu akzeptieren(T)
Consumer<String> buyer = (goods) -> {
    System.out.println(goods + "ich kaufte");
};
buyer.accept("Reisbällchen"); // Reisbällchenを購入しました。
//BiConsumer hat 2 Argumente
 
//Predicate<Argumenttyp>Die Methode ist ein Boolescher Test(T)
Predicate<String> checker = (s) -> {
    return s.equals("Java");
};
boolean result2 = checker.test("Java");
System.out.println(result2); // true

STREAMAPI

Ein praktischer Satz von Funktionsschnittstellen, die in der Collection-Klasse verwendet werden können.

List<Integer> list = new ArrayList<>();
list.add(-1);
list.add(0);
list.add(1);
list.add(3);
list.add(2); 
 
    //Collection.stream()Rückgabewert:Stream
list.stream()                                           //Generierung von Stream-Instanzen basierend auf der Sammlung
    //filter(Predicate<T>)Rückgabewert:Stream
    .filter((i) -> { return i > 0; })                   //Gibt einen Stream zurück, der diejenigen ausschließt, die die Bedingungen nicht erfüllen.
    //sorted(Comparator<T>)Rückgabewert:Stream
    .sorted((i1, i2) -> { return i1 - i2; })            //Argument 1-Argument 2 in aufsteigender Reihenfolge Argument 2- Argument 1で降順
    //map(Function<T, R>)Rückgabewert:Stream
    .map((i) -> { return "*" + i + "*"; })              //Führen Sie für jede Verarbeitung im mittleren Bereich durch.
    //forEach(Consumer<T>)Rückgabewert:void
    .forEach((i) -> { System.out.print(i + " "); });    //Wenden Sie Consumer auf alle Elemente an
    //*1* *2* *3*

Auslassung des Lambda-Ausdrucks

Wenn bestimmte Bedingungen erfüllt sind, können verschiedene Auslassungen vorgenommen werden.

//Grundform
Predicate javaChecker = (String s) -> { return s.equals("Java"); };
//Typ weggelassen, wenn es ein Argument gibt
Predicate javaChecker = (       s) -> { return s.equals("Java"); };
//Wenn der Typ weggelassen wird()Auch weggelassen
Predicate javaChecker =         s  -> { return s.equals("Java"); };
//Wenn es nur eine Zeile und keine Rückgabe gibt{}Kürzung
Consumer buyer =         goods     ->   System.out.println(goods + "ich kaufte");
//kehre auch zurück{}Gleichzeitig weggelassen mit
Predicate javaChecker =         s  ->          s.equals("Java");

Referenz

Thread Thread kann die Verarbeitung gleichzeitig ausführen (asynchrone Verarbeitung) Erben Sie die Thread-Klasse und schreiben Sie den Prozess in die run-Methode Sie kann implementiert werden, indem eine Instanz vom Typ Runnable-Schnittstelle an den Thread-Konstruktor übergeben wird.

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 300; i++) {
            System.out.print('^');
        }
    }
}
 
class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 300; i++) {
            System.out.print('*');
        }
    }
}
 
public class Threads {
 
    public static void main(String[] args) {
 
        //Muster, die rohen Thread verwenden
        MyThread mt = new MyThread();
        mt.start();
 
        //Muster, das die Ausführungsmethode der Runnable-Klasse überschreibt
        MyRunnable r = new MyRunnable();
        Thread t = new Thread(r);
        t.start();
 
        //Muster zum Übergeben der Instanz vom Typ Runnable direkt an den Konstruktor in Lambda-Notation
        new Thread(() -> {
            for (int i = 0; i < 300; i++) {
                System.out.print('=');
            }
        }).start();
    }    //^^^^^^^^^*******^^^^^========...
}

Aussetzung / Verzögerung

Schlaf: Nach dem Ausdruck wartet zu einer festgelegten Zeit. join: Der Downstream-Thread wartet auf den Abschluss des angegebenen Threads.

    public static void main(String[] args) throws Exception {
 
        new Thread(() -> {
            for (int i = 0; i < 300; i++) {
                System.out.print('^');
            }
        }).start();
 
        //3 Sekunden lang anhalten
        Thread.sleep(3000);
 
        Thread t = new Thread(() -> {
            for (int i = 0; i < 300; i++) {
                System.out.print('=');
            }
        });
        t.start();
 
        // *Warten Sie, bis Sie mit dem Schreiben fertig sind.
        t.join();
 
        new Thread(() -> {
            for (int i = 0; i < 300; i++) {
                System.out.print('*');
            }
        }).start();
    }  //^^^...***...===...

Referenz

Date Es scheint gut zu sein, LocalDateTime zu verwenden. Die Datumsklasse und die Kalenderklasse sind alt.

public static void main(String[] args) {
 
    //LocalDateTime-Grundlagen
    LocalDateTime d = LocalDateTime.now();
    System.out.println(d.getYear());
    System.out.println(d.getMonth());
    System.out.println(d.getDayOfMonth());
    System.out.println(d.getHour());
    System.out.println(d.getMinute());
    System.out.println(d.getSecond());
    System.out.println(d.getNano());
 
    //Geben Sie ein bestimmtes Datum und eine bestimmte Uhrzeit an
    d = LocalDateTime.of(2015, 12, 15, 23, 30, 59);
    System.out.println(d.plusDays(20));       //2016-01-04T23:30:59
    System.out.println(d.minusDays(20));      //2015-11-25T23:30:59
    System.out.println(d.withDayOfMonth(20)); //2015-12-20T23:30:59
 
    //Verkürzung der Zeit
    LocalDateTime.of(2015, 12, 15, 23, 30, 59).truncatedTo(ChronoUnit.HOURS); // 2015-12-15T23:00
 
    //Am 1. des nächsten Monats um 12:00 Uhr
    d =
        LocalDateTime.now()
        .plusMonths(1)
        .withDayOfMonth(1)
        .withHour(12)
        .truncatedTo(ChronoUnit.HOURS);
 
    //In String konvertieren
    DateTimeFormatter f = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
    d = LocalDateTime.parse("2015/12/15 23:30:59", f);
    System.out.println(d.format(f));    //2015/12/15 23:30:59
    f = DateTimeFormatter.ofPattern("yyyy/MM/dd");
    System.out.println(d.format(f));    //2015/12/15
}

Referenz Referenz

Servlet

Ich habe eine funktionierende App erstellt. https://github.com/kikusan-16/servlet-learning

Wenn Sie es in Eclipse importieren, beschreibt README, wie Sie es einfach testen können.