Java-Grundlagen: Datentypen, Speicher, Modifikatoren, Codeblöcke

Java-Datentypen

• Grundlegende Datentypen

• Werte: int, short, long

• Zeichen: char

• Boolean: boolean

• Referenzdatentyp

• Klasse (Klasse)

• Schnittstelle (Schnittstelle)

• Array[]

• Anzahl der belegten Bytes(1 byte= 8 bits)

• int: 4 Bytes

• char : Gibt 2 Bytes an. Wenn UTF-8-Kodierung verwendet wird, belegen Zahlen und Englisch 1 Byte, und Chinesisch benötigt 3 Bytes; wenn GBK-Kodierung verwendet wird, benötigt Chinesisch 2 Bytes

• float: 4-Zeichen-Abschnitt

• kurz: 2 Bytes

• lang: 8 Bytes

• doppelt: 8 Bytes

Hinweis: Der Standardwert für Ganzzahlen in Java ist Int und der Standardwert für Dezimalzahlen ist double

float f = 2.3; // 2.3默认为double，不能转为float，可能丢失精度float f = 2.3f; // true 末尾加f，表示这是一个float型long l = 12343565475989778034; // false, 默认为int，但是超出了范围long l = 12343565475989778034l; // 末尾加l，表示这是long型

Aber die erste Zeile des folgenden Codes ist korrekt.

byte b = 4; // 默认int，但经过检查4是在byte型范围内的，发生int -> byte的隐式强转b =  b + 3; // false，和为int，int型不能赋值给byte// aa和bb都是变量，其和不能确定是否在范围内byte aa = 3;byte bb = 4;byte cc = aa + bb; // falsebyte cc = 3 + 4; // 但若明确给出常量，则true

• Variablen (lokal) sind nur innerhalb eines Paares von {} gültig und werden dann zerstört. Lokale Codeblöcke können den Lebenszyklus lokaler Variablen bestimmen.

{  int a = 3;
}
System.out.println(a); // false, 已经出了这对{}，被销毁了

• Schalteranweisung

// 若不加break，从匹配到的那个case开始，之后如果都没break，都执行，不会跳出switch (expression) {  case x: 
    code;break;  case y:
    code;break;  default:
    code;break}

Funktionsüberladung und Umschreiben (Override @Override)

• Funktionsüberladung

• In derselben Klasse

• Mit demselben Namen

• Die Parameter sind unterschiedlich oder die Typen sind unterschiedlich

• Funktionsüberladung und Rückgabetyphaben nichts zu tun tun!

• Funktionsüberschreibung (@Override)

• Erbt die übergeordnete Klasse oder implementiert eine Ausrede, wenn etwas die Methode der übergeordneten Klasse überschreiben muss Definieren Sie die untergeordneten klassenspezifischen Methoden.

• Der Rückgabetyp, die Parameterliste und der Funktionsname sind alle konsistent. Modifikatoren sind im Allgemeinen gleich und im Allgemeinen ist bis auf die interne Implementierung alles gleich.

Array – Referenztyp

• Definition des Arrays

int[] a = {1, 23, 3};int[] b = new int[4]; // 此种定义方式必须指定数组长度int[] c = new int[]{1, 2, 3}; // 一般不这么写

• Zweidimensionales Array

int[][] arr2= new int[3][]; // 至少给第一维指定长度// 每行的列数相同,3行2列int[][] = arr2 = new int[3][2];// 每行列数不一样int[][] arr2= new int[3][];
arr2[0] = new int[2]; // 第1行arr2[1] = new int[3]; // 第2行arr2[2] = new int[4]; // 第3行

Stapelspeicher und Heapspeicher

• Stapelspeicher: speichert lokale Objekte, die freigegeben werden, wenn der Bereich endet

• Heapspeicher: speichert Arrays und Objekte, alles, was von new erstellt wurde, befindet sich im Heap In Speicher

int[] arr = new int[3];// 这句右边new一个引用数据到堆内存，给三个值默认初始化为0// a指向这个数组对象，即地址。也可以说new出来的数组把它的地址给了arr// arr = null; 表示空，不绑定地址了int[] a = new int[3];int[] b = new int[5];
a = b; // 把b的地址绑定到a，a和b都指向b的地址了System.out.println(arr); // 打印的是地址，格式为"[I@number",表示int，number为16进制表示的地址

Zugriffsmodifikator

• öffentlich: Jede Klasse oder jedes Paket kann darauf zugreifen

• privat: beschränkt auf den Zugriff in der aktuellen Klasse

• Standard (es werden keine Modifikatoren geschrieben, Standard): Auf dasselbe Paket kann zugegriffen werden, auf verschiedene Unterklassen des Pakets nicht Zugriff entweder

• geschützt: Nur Unterklassen desselben Pakets und verschiedener Pakete können darauf zugreifen. (Der Bereich ist etwas größer als der Standardwert)

public static void main(String args[])

Dies ist ein festes Format!

Warum muss es so geschrieben werden?

• public: Die Außenwelt (JVM) ruft die Funktion main() auf, um den Zugriff zu erleichtern

• statisch: statische Funktion, nicht Klassenmitgliedsfunktionen können direkt über 类名.main() ohne neue Objekte aufgerufen werden.

• void: Die Funktion main() führt lediglich die Aufgabe aus und muss keinen Wert zurückgeben.

• main(): JVM erkennt das Wort main(), wenn es die Schreibmethode von public static void main(String args[]) erfüllt, wird es als Einstiegspunkt des Programms betrachtet und startet die Ausführung.

• String args[]: Befehlszeilenparameter, die

public static void abc(String args[]) // 函数名不是main，不是主函数public static void main() // 缺少命令行参数 String args[]也不是主函数static void abc(String args[]) // 不是主函数，一定要是public static void main(String args[])

statisch statisch

sein müssen

Statische Funktion

Statische Funktion wird im Allgemeinen als Werkzeugfunktion verwendet, in der Klassenmitglieder nicht verwendet werden können. Es können nur statische Mitglieder oder Methoden verwendet werden. aber Mitgliedsfunktionen Sie können jedoch statische Daten und Methoden verwenden.

Statische Variable

static int moneyDies sind statische Daten. Es kann von vielen Objekten gemeinsam genutzt werden. Wenn Objekt A a ändert, ändert sich auch a in Objekt B. Jeder nutzt den gleichen Geldbetrag.

package Test;public class StaticDemo {private static int money = 100;public int getMonney() {return money;
    }public void useMoney() {
        money--;
    }public static void main(String[] args) {
        StaticDemo a = new StaticDemo();
        StaticDemo b = new StaticDemo();// a用了一块a.useMoney();// 还剩99System.out.println(a.getMonney());// b用的是同一份moneyb.useMoney();// 还剩98System.out.println(b.getMonney());
    }
}

• 成员变量和静态变量

1. 成员变量随对象的建立而建立，随对象消亡而消亡。13dd6e535e0887248bab718236989bd4 静态变量随着类（和对象即实例区别开）的加载而加载，随类的消亡而消亡。即静态成员是先于实例存在的，还没new出对象就存在了。

2. 成员对象只能是new出新实例后调用。13dd6e535e0887248bab718236989bd4 静态成员可以直接使用，类名.静态变量即可。

3. 成员变量被称为实例变量。13dd6e535e0887248bab718236989bd4 静态变量被称为类 变量。

4. 成员变量位于堆内存的对象中，是对象的特有数据。 13dd6e535e0887248bab718236989bd4 静态变量位于方法区（的静态区）中，也叫对象的共享数据。

Q：static为何不能调用非静态方法或者数据？

A：因为静态数据先于对象就已经产生，成员变量还不存在，不能访问。同理static函数中不能出现this、super关键字。

Q: 什么时候用static？

A：1. 静态变量，共享数据时，各个对象都使用同一个数据，不必作为对象特有的数据时候。如每个学生的姓名是特有的，但是每个学生可以共用同一个图书馆。

1. 静态方法，无需访问类成员时（非静态），就可以定义为静态，一般为工具函数。

各种代码块

public class Abc {  
  // 构造代码块，没有static。每new一个对象，就执行一次，故称为构造代码块
  // 针对不同的对象，进行相同的初始化，而构造函数对不同的对象进行不同的初始化，如给不同的人传入不同的名字和年龄进行初始化
  {
    System.out.println("我是构造代码块")
  }  // 构造函数
  Abc() {
    System.out.pritnln("我是构造函数，后于构造代码块执行")；
  }  // 静态代码块最先执行，不论放在main()前面还是后面，都先于main加载，且只执行一次
  static {
  System.out.println("我最先");
}  public static void main(String args[]) {
    Abc a = new Abc(); // 先进入先构造代码块，// 以下是局部代码块，b只在这对{}内有效{      int b = 3;
    }
    System.out.println(b); // false，b已经被释放
  }
}

！！！总的来说，执行顺序：static代码块 --> main() --> 构造代码块 --> 构造方法

Das obige ist der detaillierte Inhalt vonJava-Grundlagen: Datentypen, Speicher, Modifikatoren, Codeblöcke. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!