Dieser Artikel ist in drei Teile gegliedert.
Erstens: Literale Konstanten
Wenn wir eine Sprache lernen, ist die erste wörtliche Konstante, der wir begegnen, „Hallo Welt!“
Konstanten: Während des Programmablaufs werden die festen Größen Konstanten genannt.
public class Demo{
public static void main(String[] args){
System.Out.println("hello world!");
System.Out.println(100);
System.Out.println(3.14);
System.Out.println('a');
System.Out.println(true);
System.Out.println(false);
Darunter sind hello world!, 100, 3.14, a, true und false alles wörtliche Konstanten.
Konstanten können in 6 Kategorien eingeteilt werden:
1. String-Konstanten: eingeschlossen in „ “, wie „hello world!“ usw.
2. Integer-Konstanten: direkt geschriebene Zahlen, wie z. B.: 100 usw.
3. Fließkommakonstanten: direkt geschriebene Dezimalzahlen, wie
z ' Etc.
5. Boolesche Konstante: nur wahr und falsch
6. Leere Konstante: null
Zwei: Datentyp
Lassen Sie uns zuerst verstehen, was ein Datentyp ist?
Ein Datentyp ist ein Alias für einen Speicher fester Größe.
~~ Wenn Sie eine Variable definieren, müssen Sie einen geeigneten Typ auswählen, um ihn entsprechend den verschiedenen Werten zu definieren, die die Variable enthalten wird In Zukunft werden Datentypen in Java hauptsächlich in Grunddaten unterteilt Es gibt zwei Es gibt vier Typen
von Grunddatentypen : vier Typen: Integer, Fließkomma, Zeichen und Boolean Acht Typen : Byte, Short Integer, Integer, Long Integer, Gleitkommazahl mit einfacher Genauigkeit, Gleitkommazahl mit doppelter Genauigkeit, Zeichen, boolescher Wert. Wie unten gezeigt:
Hinweis:
1. Ob in einem 16-Bit- oder 32-Bit-System, int belegt 4 Bytes, ob in einem 32-Bit- oder 64-Bit-System, Long belegt 8 Bytes
2. Integer und Floating Point sind beide
3. Der Integer-Typ ist standardmäßig int, und der Fließkommatyp ist standardmäßig double
4. Strings sind Referenztypen Ergänzung
: Byte ist die Grundeinheit zur Darstellung von Speicherplatz in einem Computer Computer verwenden Binärdaten zur Darstellung von Daten Wir denken, dass 8 A Bit ist ein Byte (Byte),
darunter: 1KB=1024Byte, 1M=1024KB, 1G=1024M, 1T=1024G.
Drei: Variablen
3.1 Konzept
Im Programm können sich neben konstanten Konstanten einige Inhalte häufig ändern, wie z. B.: Alter, Größe, Noten, Berechnungsergebnisse mathematischer Funktionen usw. Für diese häufig geänderten Inhalte werden in Java-Programmen Variablen genannt. Datentypen werden verwendet, um verschiedene Arten von Variablen zu definieren.
3.2 Syntaxformat
Datentyp Variablenname = Initialwert;
int a=10;
double b=3.14;
3.3 Integer-Variablen
3.3.1 Definition von Integer-Variablen
//在定义时给出初值,在任何的系统下都占有4个字节.
int a=10;
//定义前没有给初始值,使用前必须设置初始值.
//范围:-2147483648 ～ 2147483647 (-2^31 --> 2^31-1)
int b;
b=10
3.3.2 Definition von Long-Integer-Variablen
//为了区分int和long类型,一般在long类型变量的初始值之后加L或l
//long在任何的系统下都占有8个字节.
//L更好区分一点.
//long的表示范围为:-2^63 - 2^63-1
long a= 10;
long b=10L;
long c=10L;
3.3.3 Definition von Short-Integer-Variablen
//short表示的范围为:-32768~32767,-2^15 - 2^15-1
//在任何的系统下都占有2个字节.
//short一般使用的比较少
short a=10;
3.3.4 Byte-Variable:
//byte在任何的系统下都占1个字节
//byte的范围是:-128~127,-2^7 ~ 2^7-1
byte a=10;
3.3.5 Fließkommazahl mit einfacher Genauigkeit
//float 在任何系统下都占用4个字节,一般在数字后加上f或者F.
//float 的范围是:-2^31 - 2^31-1
float num=1.0f;
3.3.6 Gleitkommazahl mit doppelter Genauigkeit
//double在任何的系统下都占有8个字节.
//double的范围是:-2^63 - 2^63-1
double a=1.0;
double b=2.0;
System.out.println(a/b);//输出0.5
double num=1.1;
System.out.println(num*num);//输出结果为:1.2100000000000002
3.3.7 Zeichenvariablen
//char占用2个字节,表示的范围是:-32768~32767,-2^15 - 2^15-1
//Java中使用 单引号+单个字母 的形式表示字符字面值
char c1= 'A';
char c2= '1';
//Java的字符型可以存放整型.
char c3= '牛';
3.3.8 Boolesche Variablen:
/* 1. Java的虚拟机规范中,并没有明确规定boolean占几个字节,
也没有专门用来处理boolean的字节码指令,
在Oracle公司的虚拟机实现中,boolean占用1个字节.
2.boolean 类型的变量只有两种取值, true 表示真, false 表示假
3.Java 的 boolean 类型和 int 不能相互转换~~~
不存在 1 表示 true, 0 表示 false 这样的用法.*/
boolean a=true;
boolean b=false;
4. Datentypkonvertierung und Typpromotion
4.1 Datentypkonvertierung
Einfach ausgedrückt geht es darum, eine Variable eines Datentyps in einen anderen Datentyp umzuwandeln. Beim Konvertierungsprozess müssen bestimmte Regeln eingehalten werden, und es kann nicht beliebig konvertiert werden. Die
Grundidee: Es kann nur der gleiche Typ beliebig konvertiert werden, und die Konvertierung von Low-Level nach High-Level kann automatisch konvertiert werden, aber die Konvertierung von High-Level zu Low-Level muss erzwungen werden.
Die Typkonvertierung in Java ist in zwei Kategorien unterteilt: automatische Typkonvertierung (implizite Typkonvertierung, dh kleiner Typ -> großer Typ) und erzwungene Typkonvertierung (explizite Typkonvertierung, dh großer Typ -> kleiner Typ).
4.1.1 Automatische Typkonvertierung (implizite Typkonvertierung)
Automatische Typkonvertierung bedeutet, dass der Code keiner Verarbeitung unterzogen werden muss und der Compiler ihn automatisch verarbeitet, wenn der Code kompiliert wird.
byte b=10;
int c=100;
c=b
System.out.println(c);
/*b是小类型,c大类型的,进行隐式类型转换,
将小类型的byte自动转换为大类型的int进行赋值*/
//例子:
float f=13.14f;
double d=99.99;
d=f;
System.out.println(d);
4.1.2 Zwang (Explizite Typumwandlung)
Wenn die Operation ausgeführt wird, muss der Code in einem bestimmten Format verarbeitet werden und kann nicht automatisch vervollständigt werden.
byte b=10;
int c=100;
b=c;
/*
此时代码会报错,因为b是byte型,是小类型的,而c是int型,相对与b来说是大类型的,
当b=c时,相当于将大类型赋值给小类型,会出现数据的丢失,所以程序会报错.
这个时候就需要强制类型转换.将b=c改为 b=(byte)c,程序就可以正常运行了;
*/
b=(byte)c;
System.out.println(b);
//例子:
float f=13.14f;
double d=99.99;
f=float(d);
System.out.println(f);
4.2 Typenförderung
Wenn verschiedene Datentypen miteinander verarbeitet werden, wird der kleinere Datentyp zum größeren Datentyp hochgestuft.
//例一:
byte b1=10;
byte b2=20;
int ret1=b1+b2;
System.out.println(ret1); //30
byte ret2=b1+b2;//此行会报错:从int到byte会有数据的丢失
/*
原因:在做加法运算时,b1,b2被提升为int类型了
byte+byte===>int+int---->int
解决方法:进行强制类型转换,把int型强转为byte型
即:byte ret2=(byte)(b1+b2);
*/
byte ret2=(byte)(b1+b2);
System.out.println(ret2);
//例二:
byte ret3=10+20;//此行不会出错,编译通过.
System.out.println(ret3);
/*
不会报错的原因:
10+20===>int+int--->int.
编译器在编译时,会直接计算10+20的结果
相当于 byte ret3=30;
30没有超过byte的取值范围,因此可以通过.
但是在例一当中,b1,b2是变量,加完之后结果是否会超过byte的取值范围就不知道了.
*/
Zeichenfolgenkonvertierung:
String s1="hello";
String s2="1234";
System.out.println(s1);
System.out.println(s2);
String s3=" world!!!";
s1=s1+s3;
System.out.println(s1);//输出:hello world!!!
int a=1234;
//需求:将a转换为字符串类型
String s4=""+a; //""为空字符串
System.out.println(s4); //输出1234
String s5=String.valueof(a);
System.out.println(s5); //输出1234
//需求:将数字类型字符串转换为整型数字
int b=Inteage.parseInt(s2);
System.out.println(b); //输出1234