bases de la programmation Java

Syntaxe de base

Déclaration de variable / constante

 String　str　= null;    //variable
 final String STR = "msg";    //constant
 long l = 1111111111L;    //Le type long est déclaré avec L à la fin
 float f = 1111.111F;    //Le type float est finalement déclaré avec F
 double d = 1111.111;    //Le point décimal sera le double
 char c = 'c';    //le type de caractère est''alors
 str = "a\na\ta";    //\n:nouvelle ligne\t:languette

 //Déclarer int comme type de référence
 Integer I = new Integer(32);
 int n = I.intValue();

 //Nom de la façon de déclarer
 Integer I2 = 2;    // auto boxing
 int i = 1;    // auto unboxing

opérateur

Les opérateurs ont une priorité, avec la priorité la plus élevée du haut du tableau.

if

 if (Expression conditionnelle) {
     //En traitement
 } elseif (Expression conditionnelle) {
    　//En traitement
 } else {
     //En traitement
 }

Au fait, vous pouvez omettre {}, Dans ce cas, la dernière ligne des clauses if et else est exécutée.

switch

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

default est exécuté dans tous les cas. S'il n'y a pas de pause, tout ce qui est en dessous sera exécuté Les types disponibles sont byte, short, int, char, enum, String

while dowhile

 while (Expression conditionnelle) {
     //En traitement
 }

 do {
     //En traitement
 } while (Expression conditionnelle);

Le traitement est exécuté tant que l'expression conditionnelle est vraie. C'est la plaque de fer qui incrémente les variables utilisées dans l'expression conditionnelle dans le processus. La différence entre while et dowhile est le lieu du jugement.

for

 for (int i=0; i<5; i++){
     if (i < 2) {
          continue;    //Boucle suivante
     } else {
          break;       //Fin de boucle
     }
 }

Écrire pour ((1) déclaration de compteur; (2) expression conditionnelle; (3) augmentation / diminution de la variable de compteur). ①, ② et ③ peuvent être omis respectivement. for (;;); n'est pas une erreur.

• Il semble que l'instruction for soit en fait obsolète dans java8 ... En passant, si vous mettez une étiquette, vous pouvez atteindre ce niveau en une seule fois.

 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++;
        }
    }
}

Structure de classe

classe

 public class Animal {
    //constructeur
    Animal(){
        System.out.println("new Animal created");
    }
    //Constructeur avec arguments
    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!");
    }
}

interface

 //Déclaration d'interface
 interface Breath {
    //Les variables de membre deviennent statiques définitives sans autorisation
    String breath = "Breathing!";
    //La méthode d'interface n'a pas de corps
    void breath(String breath);
}

Ensuite, une classe enfant qui implémente la classe et l'interface Animal.

 //Héritage et implémentation d'interface
 public class Dog extends Animal implements Breath{
    //Le constructeur est implicitement super()Sera fait
    //Vous pouvez spécifier un constructeur avec un argument parent en le spécifiant.
    Dog(){
        super("Dog");
    }

    //passer outre
    //Erreur si la méthode abstraite de l'interface n'est pas remplacée.
    @Override
    public void breath(String breath) {
        System.out.println(breath);
    }

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

fonction principale

 public class Main {

    public static void main(String[] args) {

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

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

        //Toutes les variables membres de l'interface sont statiques finales
        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!
    }
 }

① est la création d'une instance Dog, et le constructeur de la classe Dog est appelé. ② est la méthode héritée. ③ est la méthode remplacée par la classe Dog de l'interface. ④ est une méthode remplacée par la classe Dog de la classe Animal. ⑤ place l'instance Dog dans la variable de type Animal. (L'inverse n'est pas possible) Puisque ⑥ est de type Animal, la respiration n'est pas implémentée et ne peut pas être utilisée. ⑦ est un type Animal, mais le nouveau est Chien, et même s'il est upcast, ce sera la caractéristique de Dog.

Valeur de retour et surcharge

La méthode qui renvoie la valeur de retour doit être précédée du type à renvoyer dans la déclaration et la clause de retour doit être écrite. La surcharge est la création de méthodes portant le même nom, avec différents nombres ou types d'arguments.

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

Classes abstraites et interfaces

La classe abstraite a une relation is-a avec la classe enfant. L'interface a une relation de pouvoir avec la classe enfant.

 abstract class Animal {
    String name;
 
    Animal(String name){
        this.name = name;
    }
    //Vous pouvez écrire un traitement spécifique.
    void sleep(){
        System.out.println("sleeping!");
    }
    //la méthode abstraite force la classe enfant à implémenter
    abstract void speak();
 }
 
 interface Animal2{
    String name = null;
 
    //Vous pouvez écrire le processus par défaut
    default void sleep(){
        System.out.println("sleeping!");
    }
    //Les méthodes ordinaires forcent les classes enfants à implémenter
    void speak();
 }

type d'énumération

 //Traité comme une classe sur les programmes énumérés
 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;
        }
    }
 }

Modificateurs d'accès et statiques

Modificateur d'accès

Il existe quatre modificateurs d'accès pour java.

En les combinant, les données peuvent être masquées et encapsulées. Masquage des données: séparez les membres (attributs et opérations) en public et privé et évitez l'accès direct aux attributs de l'extérieur. Encapsulation: Pour avoir un attribut et l'opération pour accéder à l'attribut en un dans l'objet.

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

static

Les champs de classe et les méthodes de classe peuvent être implémentés en ajoutant des éléments statiques aux variables et aux méthodes.

class StaticClass {
 
    //membre statique
    static String staticStr;
    static String getStaticStr(){
        return staticStr;
    }
    //Membre d'instance
    String instanceStr;
    String getInstatnceStr() {
        return instanceStr;
    }
 
    //initialiseur statique
    static {
        StaticClass.staticStr = "staticStr";
    }
    //Initialiseur d'instance
    {
        instanceStr = "instanceStr";
    }
 }
 
 class Main {
 
    public static void main(String[] args) {
 
        //référence statique
        StaticClass.staticStr = StaticClass.staticStr + "Main";
        System.out.println(StaticClass.getStaticStr());  //staticStrMain
 
        //Référence d'instance
        StaticClass stsCls = new StaticClass();
        stsCls.instanceStr = stsCls.instanceStr + "Main";
        System.out.println(stsCls.instanceStr);  //instanceStrMain
    }
 }

L'initialiseur peut initialiser des variables. Par ailleurs, l'initialiseur est exécuté avant l'instanciation et le constructeur est exécuté après l'instanciation. Les éléments statiques (membres statiques) sont conservés jusqu'à l'arrêt de l'application, alors que Les membres d'instance sont conservés uniquement jusqu'à ce que l'instance soit supprimée.

Type générique et joker

Type générique

Si vous ne savez pas quel type conviendra jusqu'à ce que vous l'utilisiez, vous pouvez utiliser le type générique. Tout d'abord, le type générique de la classe.

//En généralisant le type, il peut être utilisé avec différents types.
//T est coutume(Type).. Tout va bien
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
    }
}

Vient ensuite le type générique de constructeurs et de méthodes.

class MethodConstractorSample {
 
    //Mettre un argument formel avant le constructeur
     MethodConstractorSample(T arg) {
        System.out.println(arg);
    }
    //Mettez un argument formel avant la valeur de retour de la méthode
    //(T peut également être utilisé comme valeur de retour)
    public static  boolean genericSample(T arg) {
        T t = arg;
        if (t != null) {
            return true;
        } else {
            return false;
        }
    }
}

Caractère générique

Caractère générique: à utiliser lors de l'utilisation d'une classe ou d'une méthode lorsque vous ne connaissez pas le type avant de l'exécuter.

class WildCard {
    //Un exemple où il est résolu de renvoyer une liste, mais vous ne savez pas de quel type de liste il s'agit avant de l'exécuter.
    public List createList(boolean s) {
        if (s) {
            return new ArrayList();
        } else {
            return new ArrayList();
        }
    }
}

Référence

collection

Une collection est une classe qui détermine un type et a des valeurs consécutives de ce type. Il existe des listes, des cartes et des ensembles, chacun ayant ses propres caractéristiques. (Les classes sont en dessous de ces trois, List, Map, Set sont des interfaces)

List

Il y a un virage. Il existe ArrayList et LinkedList. ArrayList: la recherche est rapide. LinkedList: L'ajout / la suppression est rapide.

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

Set N'autorisez pas les valeurs en double. Il existe HashSet, TreeSet et LinkedHashSet. HashSet: Hors service. TreeSet: trié par valeur. LinkedHashSet: triés dans l'ordre dans lequel ils ont été ajoutés.

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

Map A une clé et une valeur.

Il existe HashMap, TreeMap et LinedHashMap. HashMap: aucune commande. TreeMap: Trier par clé. LinedHashMap: triés par ordre d'ajout.

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

for each for (type de contenu Nom de variable du contenu: tableau et collection) Tous les contenus des tableaux et des collections peuvent être traités.

En utilisant la collection ci-dessus, cela ressemble à ceci.

for (Integer data : list) {
    System.out.println(data);  //10, 20
}
 
//Map.Entry<K,V>Est le type (interface) du contenu de la carte
//hashMap.entrySet()Le type de retour de est Set<Map.Entry<K,​V>>
for (Map.Entry<String, Integer> score : hashMap.entrySet()) {
    System.out.println(score.getKey() + " : " + score.getValue());
    //ito : 60
    //sato : 50
}

Gestion des exceptions

La gestion des exceptions utilise Exception. Soulevez une exception, attrapez-la et essayez de lever votre propre exception.

public class ExceptionSample {
 
    public static void main(String[] args) {
 
        try {
 
            //NumberFormatException se produit ici
            String s = "No.1";
            System.out.println(Integer.parseInt(s));
 
        } catch (ArithmeticException e) {
 
            System.err.println("ArithmeticException: " + e.getMessage());
 
        //NumberFormatException n'est pas une sous-classe d'ArithmeticException
        //Prise en exception
        } catch (Exception e) {
 
            //GetMessage pour recevoir le message
            System.err.println("Exception: " + e.getMessage());
 
        } finally {
            try {
                //Lancer MyException
                getErr();
 
            //Attrapez MyException
            }catch(MyException e){
                System.err.println(e.getMessage());
            }
        }
    }
 
    //Si vous ne l'attrapez pas vous-même, renvoyez une exception à l'appelant.
    static void getErr() throws MyException {
        throw new MyException("MyException!");
    }
}
 
//La définition de l'exception d'origine est étendue
//Vous pouvez définir le message dans le constructeur.
class MyException extends Exception {
    public MyException(String s) {
        super(s);
    }
}

·production

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

Style Lambda

Une expression lambda est une expression qui crée une instance qui implémente une interface. Si vous omettez la classe anonyme qui omet la classe locale, elle devient une expression lambda.

Classe locale

public static void main(String[] args) {
 
    //Classe locale:Déclarer une classe dans une méthode
    class Local implements Runnable {
        public void run() {
            System.out.println("Hello LocalClass!");
        }
    }
    Runnable runner = new Local();
    runner.run(); // Hello LocalClass!
}

Classe anonyme

public static void main(String[] args) {
 
    //Classe anonyme:Omettre la déclaration de classe locale qui implémente l'interface
    // new Runnable(){}Créer une instance de classe anonyme qui ressemble à une instance exécutable
    Runnable runner2 = new Runnable() {
        public void run() {
            System.out.println("Hello NoNameClass!");
        }
    };
    runner2.run(); // Hello NoNameClass!
}

Style Lambda

public static void main(String[] args) {
 
    //Style Lambda:Omettre la classe anonyme
    // ()Est exécuté()Arguments de
    // ->{}Est l'implémentation de la méthode run
    //Devinez le type d'interface par le type de destination d'affectation
    Runnable runner3 = () -> {
        System.out.println("Hello Lambda!");
    };
    runner3.run(); // Hello Lambda!
 
    //Passez une instance de classe anonyme à la méthode method et découvrez plus tard à partir de l'argument Runnable
    method(() -> {
        System.out.println("Hello Lambda!");
    });
}

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

En d'autres termes, l'expression lambda est à peu près correcte si vous pensez que la méthode est générée par () -> {}. Plus précisément, le contenu de {} est le contenu de l'implémentation et le contenu de () est la méthode de l'argument, Création d'une instance de classe anonyme d'un type d'interface.

Puisque () ne sait pas quelle méthode, la méthode abstraite ne peut être utilisée que pour une seule interface.

Interface fonctionnelle

Une interface avec une méthode abstraite. Parfait pour le style lambda.

// Function<Type d'argument T,Valeur de retour R>La méthode d'interface est R appliquer(T)
Function<Integer, String> asterisker = (i) -> {
    System.out.println("Function");
    return "*" + i;
};
String result = asterisker.apply(10);
System.out.println(result); // *10
//BiFunction a 2 arguments
 
// Consumer<Type d'argument>La méthode est nulle accepter(T)
Consumer<String> buyer = (goods) -> {
    System.out.println(goods + "j'ai acheté");
};
buyer.accept("balle de riz"); // balle de rizを購入しました。
//BiConsumer a 2 arguments
 
//Predicate<Type d'argument>La méthode est un test booléen(T)
Predicate<String> checker = (s) -> {
    return s.equals("Java");
};
boolean result2 = checker.test("Java");
System.out.println(result2); // true

STREAMAPI

Un ensemble pratique d'interfaces fonctionnelles pouvant être utilisées dans la classe Collection.

List<Integer> list = new ArrayList<>();
list.add(-1);
list.add(0);
list.add(1);
list.add(3);
list.add(2); 
 
    //Collection.stream()Valeur de retour:Stream
list.stream()                                           //Génération d'instance de flux basée sur la collection
    //filter(Predicate<T>)Valeur de retour:Stream
    .filter((i) -> { return i > 0; })                   //Renvoie un Stream excluant ceux qui ne remplissent pas les conditions.
    //sorted(Comparator<T>)Valeur de retour:Stream
    .sorted((i1, i2) -> { return i1 - i2; })            //Argument 1-Argument 2 dans l'ordre croissant Argument 2- Argument 1で降順
    //map(Function<T, R>)Valeur de retour:Stream
    .map((i) -> { return "*" + i + "*"; })              //Effectuez pour chacun dans le traitement intermédiaire.
    //forEach(Consumer<T>)Valeur de retour:void
    .forEach((i) -> { System.out.print(i + " "); });    //Appliquer le consommateur à tous les éléments
    //*1* *2* *3*

Omission de l'expression lambda

Si certaines conditions sont remplies, diverses omissions peuvent être faites.

//Forme basique
Predicate javaChecker = (String s) -> { return s.equals("Java"); };
//Type omis lorsqu'il y a un argument
Predicate javaChecker = (       s) -> { return s.equals("Java"); };
//Lorsque le type est omis()Également omis
Predicate javaChecker =         s  -> { return s.equals("Java"); };
//Lorsqu'il n'y a qu'une seule ligne et pas de retour{}réduction
Consumer buyer =         goods     ->   System.out.println(goods + "j'ai acheté");
//revenir aussi{}Omis simultanément avec
Predicate javaChecker =         s  ->          s.equals("Java");

Référence

Thread le thread peut exécuter le traitement en même temps (traitement asynchrone) Hériter de la classe Thread et écrire le processus dans la méthode run Il peut être implémenté en passant une instance de type d'interface Runnable au constructeur Thread.

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) {
 
        //Modèles utilisant du fil brut
        MyThread mt = new MyThread();
        mt.start();
 
        //Modèle qui remplace la méthode d'exécution de la classe Runnable
        MyRunnable r = new MyRunnable();
        Thread t = new Thread(r);
        t.start();
 
        //Modèle pour passer l'instance de type Runnable directement au constructeur en notation lambda
        new Thread(() -> {
            for (int i = 0; i < 300; i++) {
                System.out.print('=');
            }
        }).start();
    }    //^^^^^^^^^*******^^^^^========...
}

Suspension / retard

sleep: en aval de l'expression attend à une heure fixe. join: le thread en aval attend que le thread spécifié se termine.

    public static void main(String[] args) throws Exception {
 
        new Thread(() -> {
            for (int i = 0; i < 300; i++) {
                System.out.print('^');
            }
        }).start();
 
        //Arrêtez-vous pendant 3 secondes
        Thread.sleep(3000);
 
        Thread t = new Thread(() -> {
            for (int i = 0; i < 300; i++) {
                System.out.print('=');
            }
        });
        t.start();
 
        // *Attendez d'avoir fini d'écrire.
        t.join();
 
        new Thread(() -> {
            for (int i = 0; i < 300; i++) {
                System.out.print('*');
            }
        }).start();
    }  //^^^...***...===...

Référence

Date Il semble bon d'utiliser LocalDateTime. La classe Date et la classe Calendar sont anciennes.

public static void main(String[] args) {
 
    //Principes de base de LocalDateTime
    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());
 
    //Spécifiez une date et une heure spécifiques
    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
 
    //Troncature du temps
    LocalDateTime.of(2015, 12, 15, 23, 30, 59).truncatedTo(ChronoUnit.HOURS); // 2015-12-15T23:00
 
    //12h00 le 1er du mois prochain
    d =
        LocalDateTime.now()
        .plusMonths(1)
        .withDayOfMonth(1)
        .withHour(12)
        .truncatedTo(ChronoUnit.HOURS);
 
    //Convertir en chaîne
    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
}

Référence Référence

Servlet

J'ai créé une application fonctionnelle. https://github.com/kikusan-16/servlet-learning

Si vous l'importez dans Eclipse, README décrit comment le démontrer facilement.