Einführung

Dieser Artikel wurde mit claw44 geschrieben.
Dies ist eine Studiennotiz, wenn Sie die Grundlagen bis zu einem gewissen Grad von Null studieren.
Da ich beiläufig schreibe, was ich studiert habe, ist der Inhalt reichlich und nicht sehr organisiert.

Referenz

Inhalt

▼ Dinge, die Sie vergessen / Fehler machen könnten

Beschreiben Sie eine Klasse pro Datei.
Dateiname und Klassenname sollten einschließlich Groß- und Kleinschreibung kombiniert werden.
Der Einzug ist "4 Leerzeichen".
Klassenvariablen sind mit "statisch" gekennzeichnet.
Der Zugriff auf Instanzvariablen ist "this.variable"
Der Zugriff auf Klassenvariablen ist "Klassenname. Variablenname"
Es scheint, dass "Variablen" "Felder" genannt werden.

▼ Namensregeln

Basic

Zahlen können nicht als Anfangsbuchstabe verwendet werden
Groß- und Kleinschreibung beachten

Name der Klasse

Pascal-Methode
PermissionsIntro
AsyncTask
FileCopy
MainActivity

Methodenname

Verbreitet

camelCase Methode (Kleinbuchstaben )
sendFile()
checkVersion()

Methode, die eine boolesche Variable zurückgibt

Benennen Sie die Methode so, dass sie einen Satz darstellt
ist + Adjektiv
hat + letzten Teil
kann + Verb
Beispiel
isEmpty()
hasChanged()
canAccess()

Variablennamen

camelCase Methode (Kleinbuchstaben )
count
errorMsg

Konstante

All-großgeschriebener "Schlangenfall"
MAX_LENGTH
DIR_PATH

Praktische Symmetriewortliste

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

▼ Verwendung des Zitats richtig

' wird für ein Zeichen verwendet
" Für Zeichenfolgen verwenden

▼ Arten von Variablen und wie man sie definiert

Datentyp

char type ist 1 Zeichen
String-Typ ist eine Zeichenkette. Nur String, der erste Buchstabe ist in Großbuchstaben.
Der lange Typ ist wie ein int-Typ mit einer großen Kapazität. Fügen Sie am Ende des Werts "L" hinzu.
Der Float-Typ ist wie ein Double-Typ mit einer großen Kapazität. Fügen Sie am Ende des Werts "F" hinzu.

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

int i = 10;
long l = 10000000L;

double d = 234.222;
float f = 234.987F;

Referenztyp

Array

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

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

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

▼ Überprüfen Sie die Länge des Arrays

int i = array.length;

▼ Ausgabe in die Befehlszeile

Standardausgabe

System.out.println();  //Mit Zeilenumbrüchen
System.out.print();    //Keine Zeilenumbrüche

Fehlerausgabe

System.err.println();  //Mit Zeilenumbrüchen
System.err.print();    //Keine Zeilenumbrüche

▼ Inkrement-Dekrement-Operator

Existiert. (Es gab es nicht in Rubin ...)

x++;
x--;

x += 1;
x -= 1;

▼ Typkonvertierung

Nummer ⇒ Zeichenkette

String s = String.valueOf(i);

Zeichenkette ⇒ Nummer

int i = Integer.parseInt(s);

Ganzzahl ⇔ Gleitkomma

double d = (double)i;

int i = (int)d;

▼ Steueranweisung

Lassen Sie ein Leerzeichen zwischen "if" und den Klammern der Bedingung.

if (Bedingungen){
     //wird bearbeitet
} else if (Bedingungen){
     //wird bearbeitet
} else {
}

switch

switch(Variable){
Fallwert 1:
        //wird bearbeitet
        //Prozess, wenn der Wert der Variablen "Wert 1" ist.
        break;

Fallwert 2:
Fallwert 3:
        //wird bearbeitet
        //Prozess, wenn der Wert der Variablen "Wert 2" oder "Wert 3" ist.
        break;

    default:
        //wird bearbeitet
        break;
}

▼ ternärer Operator

Bedingungen?Rückgabewert bei positivem Wert:Rückgabewert im Fehlerfall;

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

▼ Satz wiederholen (Schleife)

Verbreitet

break; ⇒ Verlasse die Schleife.
continue; ⇒ Gehen Sie die aktuellen Schleifenzeiten durch und fahren Sie mit den nächsten Schleifenzeiten fort.

while

while (Bedingungen){
    //wird bearbeitet
}

do while

do {
    //wird bearbeitet
} while (Bedingungen)

for

for (int i = 0; i < 10; i++){
    //wird bearbeitet
}

Erweiterung für

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

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

▼ Qualifikation

Strichreihenfolge

Ziel	Auftrag
Feld	public protected private static final transient volatile
Methode	public protected private abstract static final synchronized native strictfp
Klasse	public protected abstract static final strictfp

Zugriffsmodifikator

Zugriffsmodifikator	Erläuterung
private	Nur von derselben Klasse zugänglich
protected	Zugriff über die aktuelle Klasse und Unterklasse
Keiner	Zugriff über Klassen im selben Paket wie die aktuelle Klasse
public	Von überall zugänglich

statischer Modifikator

Klassenvariablen / Methoden mit statischen
Ohne statische Instanzvariablen / -methoden
** Auf Instanzvariablen kann mit der statischen Methode nicht zugegriffen werden. ** ** **

letzter Modifikator

Variable ⇒ Kann nicht geändert werden
Klasse ⇒ Kann nicht vererbt werden
Methode ⇒ Kann nicht überschrieben werden.

abstrakter Modifikator

Wird beim Erstellen abstrakter Klassen und Methoden verwendet.

▼ Mezzot

Wie zu erklären

Modifikator Rückgabetyp Methodenname(Streit){
Methodenverarbeitung
}

public static void SayHello(){
    //wird bearbeitet
}

Hauptmethode

Erklärung

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

Methodenüberladung

Mehrere Definitionen können mit demselben Methodennamen vorgenommen werden, wenn Anzahl und Art der Argumente unterschiedlich sind. Das System überprüft die Anzahl und den Typ der Argumente, um zu bestimmen, welche Methodendefinition verwendet werden soll.

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

Methodenüberschreibung

Überschreiben Sie die in der Vererbungsklasse definierte

public class User {

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

public class AdminUser extends User {

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

Abstrakte Methode

In abstrakten Klassen definierte Methoden
Wenn Sie diese Methode in einer Klasse, die die abstrakte Klasse erbt, nicht überschreiben, wird eine Fehlermeldung angezeigt.

▼ Klasse

Erklärung

Name der Qualifier-Klasse{
  
}

class User {
  
}

Instanziierung

User jones = new User();

Erbe

Wenn Sie Klasse B erstellen, indem Sie Klasse A erben, können Sie die in Klasse A in Klasse B definierte Methode verwenden.

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

class AdminUser extends User {
}

Abstrakte Klasse

Überlassen Sie die Implementierung der konkreten Klasse. Gefühl nur zu definieren.
Regeln, die abstrakte Klassen nicht direkt instanziieren.

▼ Variablen aufrufen

Beschreibung	Erläuterung
`Variablennamen`	Lokale Variablen aufrufen
`this.Variablennamen`	Instanzvariablen aufrufen ⇒ Zum Zeitpunkt der Deklaration`static`Variablen nicht angehängt
`Name der Klasse.Variablennamen`	Klassenvariablen aufrufen ⇒ Zum Zeitpunkt der Deklaration`static`Die, die ich angezogen habe

▼ Konstruktor

Basic

Derjenige, der aufgerufen wird, wenn Sie "new class name ()" ausführen.
Definiert mit class name ()

//Zugriff auf Klassennamen(){}
//Es wird kein Rückgabetyp benötigt, da der Rückgabewert nicht zurückgegeben werden kann

public class User{
    public User(String name){
        //wird bearbeitet
    }
}

this()

Außerdem bedeutet this () in der Klasse einen Konstruktor. Es kann verwendet werden, wenn ein Konstruktor irgendwo in der Klasse aufgerufen wird. Oder beim Überladen des Konstruktors.

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

super()

Sie können jetzt den Konstruktor der übergeordneten Klasse aufrufen.
Kann nur in der ersten Zeile des Konstruktors verwendet werden.

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){}Anruf
        //Spezielle Bearbeitung nur für Kinderklasse hier
    }
}

(Klassen-) Initialisierer

Bei Ausführung, wenn die Klasse objektiviert ist.

class User {
    private static int count; //Klassenvariable

    static {
        User.count = 0;
    }
}

(Instanz-) Initialisierer

Wird vor dem Konstruktor aufgerufen, wenn die Klasse instanziiert wird.

class User {
    private static int count; //Klassenvariable

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

▼ Paket

Verzeichnisaufbau

`Konstruktion`


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

Erklärung

Wenn Sie zu Beginn Folgendes schreiben, wird die Java-Datei als Teil des Pakets erkannt.

`MyApp.java`


package com.dotinstall.myapp.model;

import

Sie können die Java-Datei in das Paket importieren, indem Sie wie folgt schreiben.

`MyApp.java`


import com.dotinstall.myapp.model.User;

Wenn Sie alle Java-Dateien im Paket importieren möchten, führen Sie die folgenden Schritte aus.

`MyApp.java`


import com.dotinstall.myapp.modem.*;

▼ interface

Die in der Schnittstelle beschriebene "Variable" wird zwangsweise mit "public", "static" und "final" angegeben.
In der Schnittstelle wird "Mezot", geschrieben mit "ohne Modifikator", als "öffentlich" und "abstrakt" angegeben.
Wenn Sie beim Schreiben einer Klasse den Standardmodifikator hinzufügen, können Sie die Verarbeitung der Methode schreiben. (public)
Es scheint, dass auch die statische Methode angewendet wird. (public)

Erklärung

interface Printable {
    double VERSION = 1.2;       //Konstante
    void print();               //Abstrakte Methode
    default void getInfo() {}   //Standardmethode
    static static_method() {}   //statische Methode
}

Wie benutzt man

class User implements Printable {
}

▼ Aufzählungstyp (Aufzählung)

Beispielcode

enum Fruit {
    Banana(1, "Philippinen"),
    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")) {
        //wird bearbeitet
    }

values()

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

▼ Ausnahmebehandlung

Eigene Ausnahmeklassendefinition

Erweitern Sie die Exception-Klasse.
Im Konstruktor der Exception-Klasse kann eine Fehlermeldung gesetzt werden.

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

Bei der Entscheidung über die Fehlermeldung zum Zeitpunkt des Wurfs ↓

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

Rufen Sie Ihre eigene Ausnahmeklasse auf

Wenn Sie im Konstruktor eine Fehlermeldung definiert haben.

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

Wenn Sie beim Werfen eine Fehlermeldung einfügen möchten.

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

Fehlerbehandlung (try / catch / finally)

try {

    } catch (ArithmeticException e) { //Fehlerklasse+Variablennamen
        //wird bearbeitet
    } catch (MyException e) {         //Fehlerklasse+Variablennamen
        //wird bearbeitet
    } finally {
        //wird bearbeitet
}

▼ Wrapper Class

FIXME

Ausgelassen

▼ Generics

FIXME
Irgendwie wird der Variablentyp wie das Argument undefiniert, sodass der Variablentyp ausgewählt werden kann, wenn die Klasse in eine Instanz konvertiert wird. Es scheint.
Es scheint, dass konstante Typen wie "int" und "double" nicht verwendet werden können und nur Referenztypen wie "Integer" und "Double" verwendet werden können.
Als ich es nachgeschlagen habe, schien es sehr tief zu sein, also habe ich es aufgegeben, es nachzuschlagen.

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
Es ist schön, mehr zu lernen.

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('+');
        }

    }
}

Anonyme Klasse

Die Interface-Implementierungsklasse weglassen? Nicht definieren.
Wenn Sie es nur einmal verwenden, müssen Sie es nicht definieren?
Ich habe es nicht ausprobiert, aber es scheint, dass das Gleiche nicht nur mit Interface, sondern auch mit Super Class gemacht werden kann. (Deklarieren Sie eine konkrete Klasse und instanziieren Sie sie gleichzeitig.)

interface Foo {
    void sampleMethod();
}

public class MyApp{
    public static void main (String[] args){
        Foo unNamed = new Foo() {                    //Hier von der Klasse, die Foo implementiert
            @Override                                //Definition und Instanziierung
            public void sampleMethod(){              //Es wird zur gleichen Zeit gemacht.
                System.out.println("print it!");     // (Foo ist eine Schnittstelle.)
            }
        };

        unNamed.sampleMethod();
    }
}

▼ Lambda-Ausdruck / Funktionsschnittstelle

Dies kann nur mit ** Schnittstellen mit einer abstrakten Methode ** verwendet werden.
FIXME

interface Foo {
    void sampleMethod(String text);          //Abstrakte Methodendefinition
}


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

        Foo rambda = (text) -> {             //Konkrete Methodendefinition
            System.out.println(text);        //Ich werde es hier tun.
        };

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

▼ math / random

FIXME
Ausgelassen

▼ ArrayList

Sie müssen java.util importieren. *;.
hinzufügen. Es ist eine Liste, die gelöscht werden kann.

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] Studiennotizen

Referenz

Inhalt

▼ Dinge, die Sie vergessen / Fehler machen könnten

▼ Namensregeln

Basic

Name der Klasse

Methodenname

Verbreitet

Methode, die eine boolesche Variable zurückgibt

Variablennamen

Konstante

Praktische Symmetriewortliste

▼ Verwendung des Zitats richtig

▼ Arten von Variablen und wie man sie definiert

Datentyp

Referenztyp

Array

▼ Überprüfen Sie die Länge des Arrays

▼ Ausgabe in die Befehlszeile

Standardausgabe

Fehlerausgabe

▼ Inkrement-Dekrement-Operator

▼ Typkonvertierung

Nummer ⇒ Zeichenkette

Zeichenkette ⇒ Nummer

Ganzzahl ⇔ Gleitkomma

▼ Steueranweisung

▼ ternärer Operator

▼ Satz wiederholen (Schleife)

Verbreitet

Erweiterung für

▼ Qualifikation

Strichreihenfolge

Zugriffsmodifikator

statischer Modifikator

letzter Modifikator

abstrakter Modifikator

▼ Mezzot

Wie zu erklären

Hauptmethode

Methodenüberladung

Methodenüberschreibung

Abstrakte Methode

▼ Klasse

Erklärung

Instanziierung

Erbe

Abstrakte Klasse

▼ Variablen aufrufen

▼ Konstruktor

Basic

(Klassen-) Initialisierer

(Instanz-) Initialisierer

▼ Paket

Konstruktion

Erklärung

MyApp.java

MyApp.java

MyApp.java

Erklärung

Wie benutzt man

▼ Aufzählungstyp (Aufzählung)

Beispielcode

▼ Ausnahmebehandlung

Eigene Ausnahmeklassendefinition

Rufen Sie Ihre eigene Ausnahmeklasse auf

Fehlerbehandlung (try / catch / finally)

Anonyme Klasse

▼ Lambda-Ausdruck / Funktionsschnittstelle

`Konstruktion`

`MyApp.java`

`MyApp.java`

`MyApp.java`