introduction

Cet article a été rédigé en utilisant claw44.
Ceci est une note d'étude lors de l'étude des bases de zéro dans une certaine mesure.
Depuis que j'écris ce que j'ai étudié avec désinvolture, le contenu est abondant et peu organisé.

référence

Contenu

▼ Choses que vous pourriez oublier / faire des erreurs

Décrivez une classe par fichier.
Le nom du fichier et le nom de la classe doivent être combinés, y compris la casse.
Le retrait est "4 blancs".
Les variables de classe sont marquées de «static»
L'accès aux variables d'instance est this.variable
L'accès aux variables de classe est nom de classe.nom de variable
Il semble que les «variables» sont appelées «champs».

▼ Règles de dénomination

De base

Les nombres ne peuvent pas être utilisés comme première lettre
Sensible aux majuscules et minuscules

nom de la classe

Méthode Pascal
PermissionsIntro
AsyncTask
FileCopy
MainActivity

Nom de la méthode

Commun

méthode camelCase (cas inférieur du chameau)
sendFile()
checkVersion()

méthode qui renvoie une variable booléenne

Nommez la méthode pour qu'elle représente une proposition
est + adjectif
a + partie passée
can + verbe
Exemple
isEmpty()
hasChanged()
canAccess()

Nom de variable

méthode camelCase (cas inférieur du chameau)
count
errorMsg

constant

«Cas de serpent» en majuscules
MAX_LENGTH
DIR_PATH

Liste de mots de symétrie pratique

add / remove
insert / delete
get / set
start / stop
begin / end
send / receive
first / last
get / release
put / get
up / down
show / hide
source / target
open / close
source / destination
lock / unlock
old / new
next / previous

▼ Utilisation correcte du devis

`` '' est utilisé pour un caractère
`" ʻUtiliser pour les chaînes

▼ Types de variables et comment les définir

Type de données

le type de caractère est 1 caractère
Le type de chaîne est une chaîne de caractères. Seulement String, la première lettre est en majuscule.
Le type long est comme un type int avec une grande capacité. Ajoutez "L" à la fin de la valeur.
Le type à flotteur est comme un type double avec une grande capacité. Ajoutez "F" à la fin de la valeur.

char a = 'a';
String s = "hello world!";

int i = 10;
long l = 10000000L;

double d = 234.222;
float f = 234.987F;

Type de référence

Tableau

int[] array;
array = new int[3];

int[] array;
array = new int[] {100, 200, 300};

int[] array = {100, 200, 300};

▼ Vérifiez la longueur de la matrice

int i = array.length;

▼ Sortie vers la ligne de commande

Sortie standard

System.out.println();  //Avec sauts de ligne
System.out.print();    //Aucun saut de ligne

Sortie d'erreur

System.err.println();  //Avec sauts de ligne
System.err.print();    //Aucun saut de ligne

▼ Opérateur de décrémentation d'incrémentation

Existe. (Il n'existait pas en rubis ...)

x++;
x--;

x += 1;
x -= 1;

▼ Conversion de type

Nombre ⇒ chaîne de caractères

String s = String.valueOf(i);

Chaîne de caractères ⇒ nombre

int i = Integer.parseInt(s);

Entier ⇔ virgule flottante

double d = (double)i;

int i = (int)d;

▼ Déclaration de contrôle

Laissez un espace entre ʻif` et les parenthèses de la condition.

if (conditions){
     //En traitement
} else if (conditions){
     //En traitement
} else {
}

switch

switch(variable){
valeur de cas 1:
        //En traitement
        //Traiter lorsque la valeur de la variable est "valeur 1".
        break;

valeur de cas 2:
valeur de cas 3:
        //En traitement
        //Traiter lorsque la valeur de la variable est "valeur 2" ou "valeur 3".
        break;

    default:
        //En traitement
        break;
}

▼ opérateur ternaire

conditions?Valeur renvoyée lorsqu'elle est positive:Valeur de retour en cas d'erreur;

Exemple:
String msg = i > 80 ? "good" : "so so...";

▼ Répéter la phrase (boucle)

Commun

break; ⇒ Quitter la boucle.
continue; ⇒ Parcourez les temps de boucle actuels et passez aux temps de boucle suivants.

while

while (conditions){
    //En traitement
}

do while

do {
    //En traitement
} while (conditions)

for

for (int i = 0; i < 10; i++){
    //En traitement
}

Extension pour

String[] names = {"Fujiwara", "Sakai", "Yamato"};

for (String name : names) {
    System.out.println(name);
}

▼ Qualificatif

Ordre de course

Cible	Commande
champ	public protected private static final transient volatile
Méthode	public protected private abstract static final synchronized native strictfp
classe	public protected abstract static final strictfp

Modificateur d'accès

Modificateur d'accès	La description
private	Uniquement accessible à partir de la même classe
protected	Accessible à partir de la classe et de la sous-classe actuelles
Aucun	Accessible à partir des classes du même package que la classe actuelle
public	Accessible de n'importe où

modificateur statique

Variables / méthodes de classe avec statique
Sans variables / méthodes d'instance statique
** Les variables d'instance ne sont pas accessibles à partir de la méthode statique. ** **

modificateur final

Variable ⇒ Ne peut pas être modifiée
Classe ⇒ Ne peut pas être hérité
Méthode ⇒ Ne peut pas être remplacée.

modificateur abstrait

Utilisé lors de la création de classes et de méthodes abstraites.

▼ Mezzot

Comment déclarer

Modificateur Nom de la méthode de type de retour(argument){
Traitement de la méthode
}

public static void SayHello(){
    //En traitement
}

Méthode principale

Déclaration

    public static void main(String[] args){
      
    }

Surcharge de méthode

Plusieurs définitions peuvent être faites avec le même nom de méthode si le nombre et le type d'arguments sont différents. Le système examine le nombre et le type d'arguments pour déterminer la définition de méthode à utiliser.

public class MyApp{

    public static void sayHi(String name){
        System.out.println("Hi! " +name);
    }

    public static void sayHi(){
        System.out.println("Hi! Nobody");
    }

    public static void main(String[] args){
        sayHi("Jones"); // Hi! Jones
        sayHi();        // Hi! Nobody
    }
}

Remplacement de méthode

Écraser celui défini dans la classe d'héritage

public class User {

    public void hello() {
        System.out.println("Hello World!");
    }
}

public class AdminUser extends User {

    @Override  //Annotation
    public void hello() {
        System.out.println("Hello World override!");
    }
}

Méthode abstraite

Méthodes définies dans les classes abstraites
Si vous ne remplacez pas cette méthode dans une classe qui hérite de la classe abstraite, vous obtiendrez une erreur.

▼ Classe

Déclaration

Nom de classe de classe de qualificatif{
  
}

class User {
  
}

Instanciation

User jones = new User();

Héritage

Si vous créez la classe B en héritant de la classe A, vous pouvez utiliser la méthode définie dans la classe A dans la classe B.

class User {
    void sayHi(){
        System.out.println("hi!");
    }
}

class AdminUser extends User {
}

Classe abstraite

Laissez l'implémentation à la classe concrète. Se sentir juste pour définir.
Règles qui n'instancient pas directement les classes abstraites.

▼ Appel de variables

La description	La description
`Nom de variable`	Appel de variables locales
`this.Nom de variable`	Appeler des variables d'instance ⇒ Au moment de la déclaration`static`Variables non jointes
`nom de la classe.Nom de variable`	Appel de variables de classe ⇒ Au moment de la déclaration`static`Celui que je mets

▼ Constructeur

De base

Celui qui est appelé lorsque vous faites nouveau nom de classe ().
Défini avec nom de classe ()

//Nom de la classe d'accès(){}
//Aucun type de retour n'est nécessaire car la valeur de retour ne peut pas être retournée

public class User{
    public User(String name){
        //En traitement
    }
}

this()

De plus, this () écrit dans la classe signifie un constructeur. Il peut être utilisé lors de l'appel d'un constructeur quelque part dans la classe. Ou lors de la surcharge du constructeur.

class User{
    private String name;
    User(String name){
        this.name = name;
    }
    
    User() {
        this("no name");
    }
    
}

super()

Vous pouvez maintenant appeler le constructeur de la classe parent.
Ne peut être utilisé que sur la première ligne du constructeur.

public class User {
    protected String name;

    public User(String name){
        this.name = name;
    }
}

public class AdminUser extends User {

    public AdminUser(){
        super("AdminUser desu");                // User(String name){}appel
        //Traitement spécial uniquement pour la classe enfant ici
    }
}

(Classe) Initialiseur

Lorsqu'il est exécuté lorsque la classe est objectivée.

class User {
    private static int count; //Variable de classe

    static {
        User.count = 0;
    }
}

(Instance) Initialiseur

Appelé avant le constructeur lorsque la classe est instanciée.

class User {
    private static int count; //Variable de classe

     {
        System.out.println("Instant Initializer")
    }
}

▼ Paquet

Structure du répertoire

`Construction`


/(root)
├── README.md
└── com
    └── dotinstall
        └── myapp
            ├── MyApp.java
            └── model
                ├── AdminUser.java
                └── User.java

Déclaration

Si vous écrivez ce qui suit au début, le fichier java sera reconnu comme faisant partie du package.

`MyApp.java`


package com.dotinstall.myapp.model;

import

Vous pouvez importer le fichier java dans le package en écrivant comme suit.

`MyApp.java`


import com.dotinstall.myapp.model.User;

Si vous souhaitez importer tous les fichiers java du package, suivez les étapes ci-dessous.

`MyApp.java`


import com.dotinstall.myapp.modem.*;

▼ interface

La variable décrite dans l'interface est donnée de force avec public, static et final.
Dans l'interface, mezot écrit sans aucun modificateur reçoit public et abstract.
Si vous ajoutez le modificateur par défaut lors de l'écriture d'une classe, vous pouvez écrire le traitement de la méthode. ("public")
Il semble que la méthode statique soit également appliquée. ("public")

Déclaration

interface Printable {
    double VERSION = 1.2;       //constant
    void print();               //Méthode abstraite
    default void getInfo() {}   //méthode par défaut
    static static_method() {}   //méthode statique
}

Comment utiliser

class User implements Printable {
}

▼ Type d'énumération (enum)

Exemple de code

enum Fruit {
    Banana(1, "Philippines"),
    Apple(2, "Aomori"),
    Orange(3, "Ehime");

    private int id;
    private String pref;

    private Fruit(int id, String pref) {
        this.id = id;
        this.pref = pref;
    }

    public int getId() {
        return this.id;
    }
    public String getPref() {
        return this.pref;
    }
}

valueOf()

    Fruit frt;
    frt = Fruit.Apple;

    if (frt == Fruit.valueOf("Apple")) {
        //En traitement
    }

values()

for (Fruit frt : Fruit.values()) {
    System.out.println(frt.getPref());
}

▼ Gestion des exceptions

Propre définition de classe d'exception

Étendez la classe Exception.
Un message d'erreur peut être défini dans le constructeur de la classe Exception.

class MyException extends Exception {
    public MyException() {
        super ("error message");
    }
}

Lors du choix du message d'erreur au moment du lancer ↓

class MyException extends Exception {
    public MyException(String errorMessage) {
        super (errorMessage);
    }
}

Appelez votre propre classe d'exception

Si vous avez défini un message d'erreur dans le constructeur.

if (b < 0) {
    throw new MyException();
}

Si vous souhaitez insérer un message d'erreur lors du lancement.

if (b < 0) {
    throw new MyException("error message");
}

Gestion des erreurs (try / catch / finally)

try {

    } catch (ArithmeticException e) { //Classe d'erreur+Nom de variable
        //En traitement
    } catch (MyException e) {         //Classe d'erreur+Nom de variable
        //En traitement
    } finally {
        //En traitement
}

▼ Wrapper Class

FIXME

Omis

▼ Generics

FIXME
D'une manière ou d'une autre, le type de variable tel que l'argument est rendu non défini afin que le type de variable puisse être sélectionné lorsque la classe est convertie en instance. Il semble.
Il semble que les types constants tels que ʻintetdouble ne peuvent pas être utilisés, et que seuls les types de référence tels que ʻInteger et Double peuvent être utilisés.
Quand je l'ai recherché, il semblait être très profond, alors j'ai abandonné la recherche.

class MyData<T> {
    public void printIt(T x) {
        System.out.println(x);
    }
}

public class MyApp{


    public static void main (String[] args){

            MyData<Integer> i = new MyData<>();
            i.printIt(29);
    }
}

▼ Thread / Multi Thread

FIXME
C'est bien d'en savoir plus.

class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.print('.');
        }
    }
}


public class MyApp{


    public static void main (String[] args){
        MyRunnable r = new MyRunnable();
        Thread t = new Thread(r);
        t.start();

        for (int i = 0; i < 500; i++) {
            System.out.print('+');
        }

    }
}

▼ Classe anonyme

Omettre la classe d'implémentation Interface? Ne définissez pas.
Si vous ne l'utilisez qu'une seule fois, ne vous souciez-vous pas de le définir?
Je ne l'ai pas essayé, mais il semble que la même chose puisse être faite non seulement avec Interface mais aussi avec super class. (Déclarez une classe concrète et instanciez-la en même temps.)

interface Foo {
    void sampleMethod();
}

public class MyApp{
    public static void main (String[] args){
        Foo unNamed = new Foo() {                    //Ici, de la classe qui implémente Foo
            @Override                                //Définition et instanciation
            public void sampleMethod(){              //Cela se fait en même temps.
                System.out.println("print it!");     // (Foo est une interface.)
            }
        };

        unNamed.sampleMethod();
    }
}

▼ Expression Lambda / interface fonctionnelle

Cela ne peut être utilisé qu'avec ** interfaces avec une seule méthode abstraite **.
FIXME

interface Foo {
    void sampleMethod(String text);          //Définition de la méthode abstraite
}


public class MyApp{
    public static void main (String[] args){

        Foo rambda = (text) -> {             //Définition de la méthode concrète
            System.out.println(text);        //Je vais le faire ici.
        };

        rambda.sampleMethod("do it !");
    }
}

▼ math / random

FIXME
Omis

▼ ArrayList

ʻImport java .util. *; Vous devez faire `.
ajouter à. C'est une liste qui peut être supprimée.

import java.util.*;

public class MyApp{
    public static void main (String[] args){

        List<Integer> sales = new ArrayList<>();

        sales.add(10);
        sales.add(20);
        sales.add(30);

        for (Integer i = 0; i < sales.size(); i++) {
            System.out.println(sales.get(i));
        }

        for (Integer sale : sales) {
            System.out.println(sale);
        }
    }
}

▼ HashSet

FIXME

import java.util.*;

public class MyApp{
    public static void main (String[] args){

        Set<Integer> sales = new HashSet<>();

        sales.add(10);
        sales.add(20);
        sales.add(30);

        for (Integer sale : sales) {
            System.out.println(sale);
        }
    }
}

▼ HashMap

FIXME

  import java.util.*;
  
  public class MyApp{
      public static void main (String[] args){
  
          Map<String, Integer> students = new HashMap<>();
  
          students.put("uta", 80);
          students.put("jones", 60);
          students.put("tatsuya", 70);
  
          students.remove("jones");
  
          System.out.println(students.get("tatsuya"));
          System.out.println(students.size());
  
          for (Map.Entry<String, Integer> student : students.entrySet()) {
              System.out.println(student.getKey() + ':' + student.getValue());
          }
  
      }
  }

[Java] Notes d'étude

référence

Contenu

▼ Choses que vous pourriez oublier / faire des erreurs

▼ Règles de dénomination

De base

nom de la classe

Nom de la méthode

Commun

méthode qui renvoie une variable booléenne

Nom de variable

constant

Liste de mots de symétrie pratique

▼ Utilisation correcte du devis

▼ Types de variables et comment les définir

Type de données

Type de référence

Tableau

▼ Vérifiez la longueur de la matrice

▼ Sortie vers la ligne de commande

Sortie standard

Sortie d'erreur

▼ Opérateur de décrémentation d'incrémentation

▼ Conversion de type

Nombre ⇒ chaîne de caractères

Chaîne de caractères ⇒ nombre

Entier ⇔ virgule flottante

▼ Déclaration de contrôle

▼ opérateur ternaire

▼ Répéter la phrase (boucle)

Commun

Extension pour

▼ Qualificatif

Ordre de course

Modificateur d'accès

modificateur statique

modificateur final

modificateur abstrait

▼ Mezzot

Comment déclarer

Méthode principale

Surcharge de méthode

Remplacement de méthode

Méthode abstraite

▼ Classe

Déclaration

Instanciation

Héritage

Classe abstraite

▼ Appel de variables

▼ Constructeur

De base

(Classe) Initialiseur

(Instance) Initialiseur

▼ Paquet

Construction

Déclaration

MyApp.java

MyApp.java

MyApp.java

Déclaration

Comment utiliser

▼ Type d'énumération (enum)

Exemple de code

▼ Gestion des exceptions

Propre définition de classe d'exception

Appelez votre propre classe d'exception

Gestion des erreurs (try / catch / finally)

▼ Classe anonyme

▼ Expression Lambda / interface fonctionnelle

`Construction`

`MyApp.java`

`MyApp.java`

`MyApp.java`