Java-Entwicklungstraining

01. Aufbau einer Java-Entwicklungsumgebung

0101. Java-Installation

010101. jdk1.8.0_241 Adresse herunterladen

https://www.oracle.com/cn/java/technologies/javase-jdk8-downloads.html

010102. Bitte gemäß Verfahrensanleitung installieren.

010103. Einstellung JAVA_HOME

0102. IDE-Installation

010201. IntelliJ IDEA 2019.3 Adresse herunterladen

https://www.jetbrains.com/idea/download/download-thanks.html?platform=windows&code=IIC

010202. Bitte gemäß Verfahrensanleitung installieren.

のダブルクリック

010203. Andere

• Japanische Lokalisierung verdunkeln (https://mergedoc.osdn.jp/)
• VSCODE(https://code.visualstudio.com/docs/?dv=win64user)

02. Java-Grundlagen

0201.Java-Basic-Syntax

■ Wenn Sie an Java-Programme denken, gibt es die folgenden Elemente.

• Objekt --Klasse --Methode --Instanzvariablen

■ Erstes Java-Programm

java

public class Test {
    /**
     * First program
     * @param args
     */
    public static void main(String []args){
        System.out.println("Hello World!");
    }
}

cmd

C:\Users\luyu1\IdeaProjects\Learn20200314\src>javac Test.java
C:\Users\luyu1\IdeaProjects\Learn20200314\src>java Test

■ Grundlegende Syntax Bei Java-Programmen ist es sehr wichtig, Folgendes zu beachten:

• Fallempfindlich --Klassenname (von Großbuchstaben)
• Methodenname (aus Kleinbuchstaben) --Klassenname = Dateiname speichern
• Ausführungseingang (public static void main (String args []))

■ Java-Kennung In Java gibt es einige Punkte, die bei Bezeichnern zu beachten sind.

• Alle Bezeichner müssen mit einem Buchstaben (A bis Z oder a bis z), einem Währungsbuchstaben ($) oder einem Unterstrich (_) beginnen.

• Der Bezeichner kann eine beliebige Kombination von Zeichen nach dem ersten Zeichen enthalten.

• Schlüsselwörter können nicht als Bezeichner verwendet werden.

――Das Wichtigste ist, dass bei der Kennung zwischen Groß- und Kleinschreibung unterschieden wird.

• Beispiele für gültige Bezeichner: Alter, $ Gehalt, _Wert, __ 1_Wert.

• Beispiele für falsche Bezeichner: 123abc, -salary.

java

■ Java-Modifikator Es gibt zwei Kategorien von Modifikatoren.

• Zugängliche Modifikatoren - Standard, öffentlich, geschützt, privat

• Unzugängliche Modifikatoren - final, abstract, strictfp

java

■ Java-Variablen Nachfolgend sind die Java-Variablentypen aufgeführt

• Lokale Variablen
• Klassenvariablen (statische Variablen) --Instanzvariablen (nicht statische Variablen)

java

■ Java-Array Ein Array ist ein Objekt, in dem mehrere Variablen desselben Typs gespeichert sind.

■ Java-Aufzählung

java

class FreshJuice {
   enum FreshJuiceSize{ SMALL, MEDIUM, LARGE }
   FreshJuiceSize size;
}

public class FreshJuiceTest {

   public static void main(String args[]) {
      FreshJuice juice = new FreshJuice();
      juice.size = FreshJuice.FreshJuiceSize.MEDIUM ;
      System.out.println("Size: " + juice.size);
   }
}

■ Java-Schlüsselwörter Die folgende Liste zeigt reservierte Java-Begriffe.

■ Java-Kommentare Unterstützt einzeilige und mehrzeilige Kommentare. Alle im Kommentar verfügbaren Zeichen werden vom Java-Compiler ignoriert.

java

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    * This is an example of multi-line comments.
    */

   public static void main(String []args) {
      // This is an example of single line comment
      /* This is also an example of single line comment. */
      System.out.println("Hello World");
   }
}

■ Verwenden Sie Leerzeilen Zeilen, die wahrscheinlich nur kommentierte Leerzeichen enthalten, werden als Leerzeilen bezeichnet, und Java ignoriert sie insgesamt.

■ Vererbung In Java können Klassen von Klassen abgeleitet werden. Wenn Sie eine neue Klasse erstellen müssen und diese bereits einen Teil des benötigten Codes enthält, können Sie die neue Klasse grundsätzlich aus Ihrem vorhandenen Code ableiten. In diesem Szenario werden vorhandene Klassen als Oberklassen und abgeleitete Klassen als Unterklassen bezeichnet.

■ Schnittstelle In der Java-Sprache können Schnittstellen als Verträge darüber definiert werden, wie Objekte miteinander kommunizieren. Schnittstellen spielen eine wichtige Rolle im Konzept der Vererbung.

Die Schnittstelle definiert die Methode und muss von der abgeleiteten Klasse (Unterklasse) verwendet werden. Die Implementierung der Methode liegt jedoch vollständig in der Unterklasse.

0202. Java-Objekte und Klassen

Java ist eine objektorientierte Sprache. Als Sprache mit objektorientierten Funktionen unterstützt Java die folgenden Grundkonzepte:

• Polytyp --Erbe
• Kapselung --Abstrakt --Klasse
• Objekt
• Instanz
• Methode
• Nachricht vorbei

Dieses Kapitel beschreibt Konzeptklassen und Objekte.

Objekt - Ein Objekt hat einen Zustand und ein Verhalten. Beispiel: Ein Hund hat einen Zustand der Farbe, des Namens, der Rasse, des Verhaltens usw. und schüttelt, füttert und frisst. Das Objekt ist eine Instanz der Klasse.

Klasse-A-Klasse kann als Vorlage / Plot definiert werden, die das Verhalten / den Status beschreibt, das von einem Objekt dieses Typs unterstützt wird.

■ Java-Objekte Schauen wir uns einmal genauer an, was ein Objekt ist. In der realen Welt können wir viele Objekte, Autos, Hunde, Menschen usw. um uns herum finden. Alle diese Objekte haben Zustände und Verhaltensweisen.

Wenn man einen Hund betrachtet, ist sein Zustandsname, seine Rasse, seine Farbe und sein Verhalten bar, winken und rennen.

Beim Vergleich von Softwareobjekten mit realen Objekten weisen sie sehr ähnliche Eigenschaften auf.

Softwareobjekte haben auch Zustände und Verhaltensweisen. Der Status des Softwareobjekts wird im Feld gespeichert und das Verhalten über die Methode angezeigt.

Daher arbeiten Methoden in der Softwareentwicklung im internen Zustand von Objekten, und die Kommunikation zwischen Objekten erfolgt über Methoden.

■ Java-Klasse Eine Klasse ist eine Klasse, in der einzelne Objekte erstellt werden.

Unten finden Sie eine Beispielklasse.

java

public class Dog {
   String breed;
   int age;
   String color;

   void barking() {
   }

   void hungry() {
   }

   void sleeping() {
   }
}

Die Klasse kann einen der folgenden Variablentypen enthalten:

Lokale Variablen - Variationen, die innerhalb einer Methode, eines Konstruktors oder eines Blocks definiert sind, werden als lokale Variablen bezeichnet. Die Variable wird innerhalb der Methode deklariert und initialisiert, und die Variable wird zerstört, wenn die Methode abgeschlossen ist.

Instanzvariablen - Instanzvariablen sind Methoden innerhalb einer Klasse, jedoch außerhalb der Methode. Diese Variablen werden initialisiert, wenn die Klasse instanziiert wird. Auf Instanzvariablen kann innerhalb einer Methode, eines Konstruktors oder eines Blocks dieser bestimmten Klasse zugegriffen werden.

Klassenvariablen - Klassenvariablen sind Variablen, die innerhalb einer Klasse und nicht innerhalb einer Methode mit statischen Schlüsselwörtern deklariert werden.

Die Klasse kann eine beliebige Anzahl von Methoden für den Zugriff auf die Werte verschiedener Methodentypen enthalten. Im obigen Beispiel sind Bellen (), Hunger (), Schlafen () die Methoden.

Im Folgenden finden Sie einige wichtige Themen, die bei der Prüfung von Java-Sprachklassen behandelt werden müssen.

■ Konstruktor Eines der wichtigsten Unterthemen bei der Diskussion von Klassen ist der Konstruktor. Jede Klasse hat einen Konstruktor. Wenn Sie einen Klassenkonstruktor nicht explizit schreiben, erstellt der Java-Compiler einen Standardkonstruktor für diese Klasse.

Jedes Mal, wenn ein neues Objekt erstellt wird, wird mindestens ein Konstruktor aufgerufen. Die Hauptregel des Konstruktors lautet, dass der Konstruktor denselben Namen wie die Klasse haben muss. Eine Klasse kann mehrere Konstruktoren enthalten.

Unten finden Sie ein Beispiel für einen Konstruktor

java

public class Dog {
   String breed;
   int age;
   String color;
   
   public Dog(){
   }
   public Dog(String breed){
     this.breed = breed;
   }
   void barking() {
   }

   void hungry() {

   }

   void sleeping() {
   }
}

■ Erstellen Sie ein Objekt Die Klasse bietet eine Darstellung des Objekts. Grundsätzlich werden Objekte aus Klassen erstellt. Verwenden Sie in Java das Schlüsselwort new, um ein neues Objekt zu erstellen. Beim Erstellen eines Objekts aus einer Klasse sind drei Schritte erforderlich

--Declaration - Eine Variablendeklaration mit einem Variablennamen vom Objekttyp. --Instantiate-Erstellen Sie ein Objekt mit dem Schlüsselwort "new". --Initialisierung - Auf das Schlüsselwort "new" folgt ein Aufruf des Konstruktors. Dieser Aufruf initialisiert ein neues Objekt.

java

public class Dog {
   String breed;
   int age;
   String color;
   
   public Dog(){
   }
   public Dog(String breed){
     this.breed = breed;
   }
   void barking() {
   }

   void hungry() {

   }

   void sleeping() {
   }
   public static void main(String []args) {
      Dog dog1 = new Dog("afador");
   }
}

■ Zugriff auf Instanzvariablen und -methoden Auf Instanzvariablen und -methoden wird über die erstellten Objekte zugegriffen. Um auf die Instanzvariablen zuzugreifen, finden Sie hier den vollständig qualifizierten Pfad

java

public class Dog {
   private String breed;
   public static int age;
   private String color;
   
   public Dog(){
   }
   public Dog(String breed){
     this.breed = breed;
   }
   private void barking() {
     System.out.println("I am barking!");
   }

   protected void hungry() {
     System.out.println("I am hungry!");
   }

   public void sleeping() {
       System.out.println("I am sleeping!");
   }
   public static void main(String []args) {
      Dog dog1 = new Dog();
      
      String s1 = dog1.breed;//ok?
      int s2 = dog1.age;//ok?
      dog1.barking();//ok?
      dog1.hungry();//ok?
      dog1.sleeping();//ok?
   }
}

■ Regeln für die Deklaration von Quelldateien Schauen wir uns als letzten Teil dieses Abschnitts die Regeln für die Deklaration von Quelldateien an. Diese Regeln sind wichtig, wenn Klassen, Importanweisungen und Paketanweisungen in der Quelldatei deklariert werden.

• Es kann nur eine öffentliche Klasse pro Quelldatei geben.

• Die Quelldatei kann mehrere nicht öffentliche Klassen enthalten.

• Der Name der öffentlichen Klasse muss der Name der Quelldatei sein, wobei am Ende .java hinzugefügt wird. Beispielsweise sollte der Klassenname die öffentliche Klasse Employee {} und die Quelldatei Employee.java sein.

• Wenn die Klasse in einem Paket definiert ist, muss das Paket die erste Zeile der Quelldatei sein.

• Wenn eine Importanweisung vorhanden ist, muss diese zwischen der Paketanweisung und der Klassendeklaration geschrieben werden. Wenn kein Paket vorhanden ist, muss sich die Importanweisung in der ersten Zeile der Quelldatei befinden.

• Import und Paket bedeutet alle Klassen, die in der Quelldatei vorhanden sind. Sie können in der Quelldatei keine unterschiedlichen Importe und / oder Pakete für unterschiedliche Klassen deklarieren.

Klassen haben mehrere Zugriffsebenen und es gibt verschiedene Arten von Klassen. Abstrakte Klasse, Abschlussklasse usw. Diese werden im Kapitel Zugriffsqualifizierer erläutert.

Neben den oben genannten Klassentypen verfügt Java auch über spezielle Klassen, die als innere Klassen und anonyme Klassen bezeichnet werden. ■ Java-Paket Einfach ausgedrückt ist dies eine Möglichkeit, Klassen und Schnittstellen zu klassifizieren. Bei der Entwicklung einer Anwendung in Java werden Hunderte von Klassen und Schnittstellen erstellt. Daher ist es unerlässlich, diese Klassen zu klassifizieren und das Leben viel einfacher zu machen.

java

package jp.co.learning;

■ Importanweisung In Java kann der Compiler den Quellcode oder die Klasse leicht finden, wenn ein vollständig qualifizierter Name angegeben wird, einschließlich des Paket- und Klassennamens. Mit der import-Anweisung kann der Compiler den geeigneten Speicherort angeben, um eine bestimmte Klasse zu finden.

In der folgenden Zeile muss der Compiler beispielsweise alle im Verzeichnis java_installation / java / io verfügbaren Klassen laden

java

import java.io.*;

■ Beispielbeispiel 1 In Beispiel 1 werden zwei Klassen erstellt. Sie sind Employee und EmployeeTest.

Öffnen Sie zuerst den Editor und fügen Sie den folgenden Code hinzu. Denken Sie daran, dass dies eine Employee-Klasse und die Klasse eine öffentliche Klasse ist. Speichern Sie dann diese Quelldatei als Employee.java.

Die Employee-Klasse verfügt über vier Instanzvariablen: Name, Alter, Bezeichnung und Gehalt. Diese Klasse verfügt über einen explizit definierten Konstruktor, der Parameter akzeptiert.

java

package jp.co.learning;
import java.io.*;
public class Employee {

   String name;
   int age;
   String designation;
   double salary;

   // This is the constructor of the class Employee
   public Employee(String name) {
      this.name = name;
   }

   // Assign the age of the Employee  to the variable age.
   public void empAge(int empAge) {
      age = empAge;
   }

   /* Assign the designation to the variable designation.*/
   public void empDesignation(String empDesig) {
      designation = empDesig;
   }

   /* Assign the salary to the variable	salary.*/
   public void empSalary(double empSalary) {
      salary = empSalary;
   }

   /* Print the Employee details */
   public void printEmployee() {
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

Wie bereits in diesem Lernprogramm erwähnt, beginnt der Prozess mit der Hauptmethode. Um diese Employee-Klasse auszuführen, müssen Sie daher eine Hauptmethode und ein Objekt erstellen. Erstellen Sie separate Klassen für diese Aufgaben.

Hier ist die EmployeeTest-Klasse: Diese Klasse erstellt zwei Instanzen der Employee-Klasse und ruft Methoden für jedes Objekt auf, um jeder Variablen Werte zuzuweisen.

Speichern Sie den folgenden Code in der Datei EmployeeTest.java.

java

package jp.co.learning;
import java.io.*;
public class EmployeeTest {

   public static void main(String args[]) {
      /* Create two objects using constructor */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("Mary Anne");

      // Invoking methods for each object created
      empOne.empAge(26);
      empOne.empDesignation("Senior Software Engineer");
      empOne.empSalary(1000);
      empOne.printEmployee();

      empTwo.empAge(21);
      empTwo.empDesignation("Software Engineer");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

0203. Java-Konstruktor

In Java stehen zwei Arten von Konstruktoren zur Verfügung.

• Parameterloser Konstruktor
• Parametrisierter Konstruktor

■ Parameterloser Konstruktor

java

Public class MyClass {
   Int num;
   MyClass() {
      num = 100;
   }
}

Prüfung

java

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass();
      MyClass t2 = new MyClass();
      System.out.println(t1.num + " " + t2.num);
   }
}

■ Parametrisierter Konstruktor

java

public class MyClass {
   int x;
   
   // Following is the constructor
   MyClass(int i ) {
      x = i;
   }
}

Prüfung

java

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass( 10 );
      MyClass t2 = new MyClass( 20 );
      System.out.println(t1.x + " " + t2.x);
   }
}

0204. Java-Basic-Datentyp

In Java gibt es zwei Datentypen.

• Primitiver Datentyp
• Referenz- / Objektdatentyp

■ Grunddatentyp byte

• Der Byte-Datentyp ist eine 8-Bit-Ganzzahl mit 2 Vorzeichen
• Der Mindestwert ist -128 (-2 ^ 7)
• Der Maximalwert beträgt 127 (einschließlich) (2 ^ 7 -1)
• Der Standardwert ist 0
• Da Bytes viermal kleiner als Ganzzahlen sind, verwenden Sie hauptsächlich Byte-Arrays anstelle von Ganzzahlen, um Platz in großen Arrays zu sparen.
• Beispiel: Byte a = 100, Byte b = -50

short

--Kurzdatentypen sind 16-Bit-Ganzzahlen mit 2 Komplementen

• Der Mindestwert beträgt -32.768 (-2 ^ 15)
• Der Maximalwert beträgt 32.767 (einschließlich beider Enden) (2 ^ 15 -1) --Kurzdatentypen können auch zum Speichern von Speicher als Byte-Datentypen verwendet werden. short ist doppelt so klein wie eine ganze Zahl
• Der Standardwert ist 0.
• Beispiel: kurz s = 10000, kurz r = -20000

int

• Der Datentyp Int ist eine 32-Bit-Ganzzahl mit 2 Vorzeichen.
• Der Mindestwert beträgt -2.147.483.648 (-2 ^ 31)
• Der Maximalwert beträgt 2.147.483.647 (einschließlich beider Enden) (2 ^ 31 -1)
• Im Allgemeinen werden Ganzzahlen als Standarddatentyp für Ganzzahlwerte verwendet, sofern keine Speicherprobleme vorliegen.
• Der Standardwert ist 0
• Beispiel: int a = 100000, int b = -200000

long

--long Datentyp ist eine 64-Bit-Ganzzahl mit 2 Vorzeichen

• Der Mindestwert beträgt -9.223.372.036.854.775.808 (-2 ^ 63)
• Der Maximalwert beträgt 9.223.372.036.854.775.807 (einschließlich) (2 ^ 63 -1) --Dieser Typ wird verwendet, wenn Sie einen größeren Bereich als int benötigen
• Der Standardwert ist 0L
• Beispiel: lang a = 100000L, lang b = -200000L

float

• Der Fließkomma-Datentyp ist ein 32-Bit-IEEE 754-Gleitkomma mit einfacher Genauigkeit --Float wird hauptsächlich verwendet, um Speicher in großen Arrays von Gleitkommazahlen zu sparen
• Der Standardwert ist 0.0f --Floating Point-Datentypen werden nicht für exakte Werte wie Währung verwendet --Beispiel: float f1 = 234.5f

double

--double Datentyp ist 64-Bit IEEE 754 Gleitkomma mit doppelter Genauigkeit

• Normalerweise wird dieser Datentyp als Standarddatentyp für Dezimalzahlen verwendet und ist normalerweise die Standardauswahl
• Verwenden Sie keinen doppelten Datentyp für genaue Werte wie Währung
• Der Standardwert ist 0.0d
• Beispiel: double d1 = 123.4

boolean

--Boolean Der Datentyp repräsentiert 1 Informationsbit

• Nur zwei mögliche Werte: wahr und falsch --Dieser Datentyp wird für einfache Flags verwendet, die True / False-Bedingungen verfolgen
• Der Standardwert ist false --Beispiel: boolean one = true

char

Der Datentyp --char ist ein einzelnes 16-Bit-Unicode-Zeichen

• Der Mindestwert ist '\ u0000' (oder 0) --Maximum ist '\ uffff' (oder enthält 65.535) --Der Zeichendatentyp wird zum Speichern beliebiger Zeichen verwendet --Beispiel: char letterA = 'A'

■ Referenz- / Objektdatentyp

0205. Java-Variablentyp

Alle Variablen müssen deklariert werden, bevor sie verwendet werden können. Grundformat: data type variable [ = value][, variable [ = value] ...] ; Beispiel:

java

int a, b, c;         // Declares three ints, a, b, and c.
int a = 10, b = 10;  // Example of initialization
byte B = 22;         // initializes a byte type variable B.
double pi = 3.14159; // declares and assigns a value of PI.
char a = 'a';        // the char variable a iis initialized with value 'a'

Es gibt drei Arten von Variablen.

• Lokale Variablen --Instanzvariablen
• Klasse / statische Variablen

■ Lokale Variablen

• Lokale Variablen werden in Methoden, Konstruktoren oder Blöcken deklariert.

• Lokale Variablen werden beim Eingeben einer Methode, eines Konstruktors oder eines Blocks erstellt und beim Beenden einer Methode, eines Konstruktors oder eines Blocks zerstört.

• Zugriffsmodifikatoren können nicht für lokale Variablen verwendet werden.

• Lokale Variablen sind nur innerhalb der deklarierten Methode, des Konstruktors oder des Blocks sichtbar.

• Lokale Variablen werden intern auf Stapelebene implementiert.

• Lokale Variablen haben keine Standardwerte, daher müssen Sie sie deklarieren und ihnen Anfangswerte zuweisen, bevor Sie sie zum ersten Mal verwenden.

java

public Class Test{
  //Konstrukteur
  public Test(){
    String str = "test1";
    System.out.println(str);
  }
  //Methode
  private void test1(){
    String str = "test";
    System.out.println(str);
    
    int test;
    if(test==0){
       int t1 = 1;
       test = t1;
    }
    System.out.println(test);
    System.out.println(t1);
  }

  public static void main(String[] args){
    Test test = new Test();
    test.test1();
  }
}

■ Instanzvariablen Instanzvariablen werden innerhalb der Klasse deklariert, jedoch außerhalb von Methoden, Konstruktoren oder beliebigen Blöcken.

Wenn Speicherplatz für Objekte im Heap zugewiesen wird, werden Slots für jeden Wert der Instanzvariablen erstellt.

Instanzvariablen werden erstellt, wenn ein Objekt mit dem Schlüsselwort "new" erstellt wird, und werden zerstört, wenn das Objekt zerstört wird.

Instanzvariablen enthalten Werte, auf die von wichtigen Teilen des Status eines Objekts verwiesen werden muss, die über mehrere Methoden, Konstruktoren, Blöcke oder Klassen hinweg existieren müssen.

Instanzvariablen können vor oder nach der Verwendung auf Klassenebene deklariert werden.

Sie können Zugriffsmodifikatoren für Instanzvariablen angeben.

Instanzvariablen sind für alle Methoden, Konstruktoren und Blöcke in der Klasse sichtbar. Im Allgemeinen wird empfohlen, diese Variablen privat zu halten (Zugriffsebene). Sie können jedoch Zugriffsmodifikatoren verwenden, um diese Variablen in der Unterklasse sichtbar zu machen.

Instanzvariablen haben Standardwerte. Für Zahlen ist der Standardwert 0, für Boolesche Werte ist er falsch und für Objektreferenzen ist er null. Werte können in der Deklaration oder im Konstruktor zugewiesen werden.

Auf Instanzvariablen kann direkt zugegriffen werden, indem der Variablenname in der Klasse aufgerufen wird. Innerhalb einer statischen Methode (wenn die Instanzvariable zugänglich ist) muss sie jedoch mit einem vollständig qualifizierten Namen aufgerufen werden. ObjectReference.VariableName.

Beispiel:

java

import java.io.*;
public class Employee {

   //Diese Instanzvariable ist für alle untergeordneten Klassen sichtbar.
   public String name;

   //Die Gehaltsvariable ist nur in der Employee-Klasse sichtbar.
   private double salary;

   //Die Namensvariable wird im Konstruktor zugewiesen.
   public Employee (String empName) {
      name = empName;
   }

   //Der Gehaltsvariablen wird ein Wert zugewiesen.
   public void setSalary(double empSal) {
      salary = empSal;
   }

   //Diese Methode druckt Mitarbeiterdetails.
   public void printEmp() {
      System.out.println("name  : " + name );
      System.out.println("salary :" + salary);
   }

   public static void main(String args[]) {
      Employee empOne = new Employee("Ransika");
      empOne.setSalary(1000);
      empOne.printEmp();
   }
}

■ Klassen- / statische Variablen

• Klassenvariablen, auch als statische Variablen bezeichnet, werden innerhalb der Klasse mit dem Schlüsselwort static deklariert, jedoch außerhalb der Methode, des Konstruktors oder des Blocks.

• Es gibt nur eine Kopie jeder Klassenvariablen pro Klasse, unabhängig von der Anzahl der daraus erstellten Objekte.

--Statische Variablen werden nur selten verwendet, wenn sie als Konstanten deklariert sind. Konstanten sind Variablen, die als öffentlich / privat, endgültig und statisch deklariert sind. Konstante Variablen ändern sich nie von ihren Anfangswerten.

--Statische Variablen werden im statischen Speicher gespeichert. Es ist selten, etwas anderes als statische Variablen zu verwenden, die als endgültig deklariert und als öffentliche oder private Konstanten verwendet werden.

--Statische Variablen werden beim Starten des Programms erstellt und beim Stoppen des Programms zerstört.

• Die Sichtbarkeit ähnelt Instanzvariablen. Die meisten statischen Variablen werden jedoch als öffentlich deklariert, da sie Benutzern der Klasse zur Verfügung stehen müssen.

• Der Standardwert entspricht der Instanzvariablen. Für Zahlen ist der Standardwert 0. Falsch für Boolesche Werte. Null für Objektreferenzen. Werte können in der Deklaration oder im Konstruktor zugewiesen werden. Darüber hinaus können Sie Werte in speziellen statischen Initialisierungsblöcken zuweisen.

• Sie können auf statische Variablen zugreifen, indem Sie den Klassennamen ClassName.VariableName aufrufen.

• Wenn Sie eine Klassenvariable als public static final deklarieren, wird der Variablenname (Konstante) in Großbuchstaben angegeben. Wenn die statischen Variablen nicht öffentlich und endgültig sind, ist die Benennungssyntax dieselbe wie zum Beispiel für lokale Variablen.

java

import java.io.*;
public class Employee {

   //Gehaltsvariablen sind private statische Variablen
   private static double salary;

   //ABTEILUNG ist eine Konstante
   public static final String DEPARTMENT = "Development ";

   public static void main(String args[]) {
      salary = 1000;
      System.out.println(DEPARTMENT + "average salary:" + salary);
   }
}

0206.Java-Modifier-Typ

Modifikatoren sind Schlüsselwörter, die Sie diesen Definitionen hinzufügen, um ihre Bedeutung zu ändern.

• Zugriffssteuerungsmodifikator
• Modifikator ohne Zugriff

■ Zugriffssteuerungsmodifikator

Java bietet eine Reihe von Zugriffsmodifikatoren zum Festlegen von Zugriffsebenen für Klassen, Variablen, Methoden und Konstruktoren. Die vier Zugriffsebenen sind:

• Wird auf dem Paket angezeigt. Dies ist die Standardeinstellung. Kein Modifikator erforderlich.
• Wird nur in Klassen angezeigt (privat).
• Öffentlich für die Welt.
• Erscheint in Paketen und allen Unterklassen (geschützt).

■ Modifikator ohne Zugriff Java bietet viele Nichtzugriffsmodifikatoren, um viele andere Funktionen zu erreichen.

--Statischer Modifikator zum Erstellen von Klassenmethoden und -variablen.

• Endgültiger Modifikator, der die letzte Klasse, Methode und Variable implementiert.

--Abstraktmodifikator zum Erstellen abstrakter Klassen und Methoden.

• Synchronisierte und flüchtige Modifikatoren für synchrone und flüchtige Threads.

0207.Java-Basic-Operator

Sie können alle Java-Operatoren in folgende Gruppen einteilen:

--Arithmetischer Operator

• Beziehungsoperator

• Bit Operator

• Logischer Operator --Aufgabenverwalter

• Andere Betreiber

■ Arithmetischer Operator Arithmetische Operatoren werden in Formeln genauso verwendet wie in der Algebra. Die folgende Tabelle zeigt die arithmetischen Operatoren.

In den folgenden 3 Java-Dateien listet "/%" die in normalen Projekten häufig verwendeten Seitenumbruchberechnungen als Beispiel auf.

ruby:Datei: jp.co.learning.Config.java

package jp.co.learning;

/**
*Klasse: Platzierung
*Verfasser: AAAAAA
*Autorendatum: 2020/03/01
*/
public class Config{
    /*
     *Standardwert zur Anzeige der maximalen Anzahl von Datensätzen pro Seite
     */
    public final static int DEFAULT_EACH_PAGE_CNT = 0;

}

ruby:Datei: jp.co.learning.Page.java

package jp.co.learning;
/**
*Klasse: Seitenumbruch
*Verfasser: AAAAAA
*Autorendatum: 2020/03/01
**/
public class Page{

　　 /**
     *Anzahl der anzuzeigenden Datensätze
     **/
　　 private int records;
    /**
     *Anzahl der Seiten mit Datensätzen
     **/
    private int pageCnt;
    /**
     *Anzahl der Datensätze auf der letzten Seite
     **/
    private int endPageCnt;
　　 /**
     *Anzahl der anzuzeigenden Datensätze
     **/
　　 private int eachPageCnt = Config.DEFAULT_EACH_PAGE_CNT;

　　 /**
     *Konstrukteur
     **/
     public Page(int records){

        this.records = records;

     }
　　 /**
     *Neue Seite
     **/
     public void changePage(){

         //Wenn die Anzahl der Datensätze = 0 ist, wird direkt 0 zurückgegeben.
         if(records == 0){
           return;
         }
         //Anzahl der Datensätze>Wenn es 0 ist, wird die Verarbeitung der Seitenumbruchberechnung durchgeführt.
         if(records % eachPageCnt == 0){
           endPageCnt = eachPageCnt;
           pageCnt = records / eachPageCnt;
         }else{
           endPageCnt = records % eachPageCnt;
           pageCnt = records / eachPageCnt + 1;
         }
     }
     /**
     *Holen Sie sich die Gesamtzahl der Seiten
     * @return:Gesamtzahl der Seiten
     **/
     public int getPageCnt(){
         return this.pageCnt;
     }
     /**
     *Holen Sie sich die Anzahl der Datensätze auf der letzten Seite
     * @return:Anzahl der Datensätze auf der letzten Seite
     **/
     public int getEndPageCnt(){
         return this.endPageCnt;
     }
}

ruby:Datei: jp.co.learning.Test.java

package jp.co.learning;
/**
*Klasse: Seitenumbruch-Testklasse
*Verfasser: AAAAAA
*Autorendatum: 2020/03/01
**/
public class Test{
  /**
   *Testeingang
   **/
   public static void main(String[] args){
       //Legen Sie vorübergehend die Anzahl der aus der Datenbank extrahierten Datensätze fest
       int records = 100;

       //Erstellen Sie eine Seiteninstanz mit der Page-Klasse und führen Sie eine Seitenumbruchberechnung durch
       Page page = new Page(records);
       page.changePage();

       //Geben Sie die berechnete Anzahl von Seiten und die Anzahl von Datensätzen auf der letzten Seite aus
       System.out.println("Gesamtzahl der Seiten:"+page.getPageCnt());
       System.out.println("Anzahl der Datensätze auf der letzten Seite:"+page.getEndPageCnt());
   }
}

■ Beziehungsoperatoren

■ Bitoperator Java definiert mehrere Bitoperatoren, die auf Ganzzahltypen wie Long, Int, Short, Char und Byte angewendet werden können.

Bitoperatoren arbeiten an Bits und führen bitweise Operationen durch. Angenommen, a = 60 und b = 13. Jetzt im Binärformat sieht es so aus:

a = 0011 1100

b = 0000 1101

a＆b = 0000 1100

a | b = 0011 1101

a ^ b = 0011 0001

〜a = 1100 0011

Die folgende Tabelle zeigt die bitweisen Operatoren.

Angenommen, die ganzzahlige Variable A enthält 60 und die Variable B 13.

■ Logischer Operator Die folgende Tabelle zeigt die logischen Operatoren

Angenommen, die Boolesche Variable A gilt für wahr und die Variable B für falsch.

■ Zuweisungsoperator Im Folgenden sind die Zuweisungsoperatoren aufgeführt, die von der Java-Sprache unterstützt werden.

■ Andere Bediener

• Bedingter Operator (? :) Bedingte Operatoren werden auch als ternäre Operatoren bezeichnet. Der Operator ist wie folgt geschrieben:

variable x = (expression) ? value if true : value if false

Beispiel:

java

public class Test {

   public static void main(String args[]) {
      int a, b;
      a = 10;
      b = (a == 1) ? 20: 30;
      System.out.println( "Value of b is : " +  b );

      b = (a == 10) ? 20: 30;
      System.out.println( "Value of b is : " + b );
   }
}

--Instanz des Betreibers Dieser Operator wird nur für Objektreferenzvariablen verwendet. Der Operator prüft, ob das Objekt von einem bestimmten Typ ist (Klassentyp oder Schnittstellentyp). Die Instanz des Operators ist wie folgt geschrieben:

( Object reference variable ) instanceof  (class/interface type)

Beispiel:

java

public class Test {

   public static void main(String args[]) {

      String name = "James";

      // following will return true since name is type of String
      boolean result = name instanceof String;
      System.out.println( result );
   }
}

0208. Java-Schleifensteuerung

Im Allgemeinen werden die Anweisungen nacheinander ausgeführt. Die erste Anweisung der Funktion wird zuerst ausgeführt, dann die zweite Anweisung. Programmiersprachen bieten eine Vielzahl von Steuerungsstrukturen, die komplexere Ausführungspfade ermöglichen. In ** Schleifenanweisungen ** erlauben wir die mehrfache Ausführung einer Anweisung oder einer Gruppe von Anweisungen, was in den meisten der folgenden Programmiersprachen eine übliche Form von Schleifenanweisungen ist.

Die Programmiersprache Java bietet die folgenden Arten von Schleifen, um die Schleifenanforderungen zu erfüllen: Klicken Sie auf den folgenden Link, um mehr zu erfahren.

0209.Java-Bedingte Verzweigung

Es gibt eine oder mehrere Bedingungen, die vom Programm ausgewertet oder getestet werden, eine Anweisung, die ausgeführt wird, wenn die Bedingung als wahr bestimmt wird, und optional eine andere Anweisung, die ausgeführt wird, wenn die Bedingung bestimmt wird. ist. Das Folgende ist eine übliche Form der typischen Entscheidungsstruktur, die in den meisten Programmiersprachen zu finden ist.

Die Programmiersprache Java bietet die folgenden Arten von Entscheidungsanweisungen: Klicken Sie auf den folgenden Link, um mehr zu erfahren.

?? :Operator

Exp1 ? Exp2 : Exp3;

0210.Java-Numerische Klasse

0211.Java-Zeichenklasse

0212.Java-String-Klasse

0213.Java-Array

0214.Java-Datum und Uhrzeit

0215. Java-Regulärer Ausdruck

0216. Java-Methode

0217. Java-Dateien und E / A.

0218. Java-Ausnahme

0219.Java-Innere Klasse

03. Java objektorientiert

04. Java Luxus

05. Projektentwicklung