Der Unterschied zwischen C-Syntax und Java-Syntax

Der Unterschied zwischen C-Syntax und Java-Syntax:

1 Bezeichner: ( empfohlen) Studium: Java-Kurs)

Die in C verfügbaren Bezeichner sind Zahlen, Groß- und Kleinbuchstaben sowie Unterstriche und können nicht mit Zahlen beginnen

Die verfügbaren Bezeichner In Java gibt es außer C zusätzlich zu den drei Typen noch ein Dollarzeichen ($), das ebenfalls nicht mit einer Zahl beginnen kann.

2. Schlüsselwörter:

Schlüsselwörter in C sind:

auto   break    case    char   const
continue   default    do    double   else
enum   extern    float    for   goto
if   int    long    register   return
short   signed    sizeof    static   struct
switch   typedef    union    unsigned   void
volatile   while

Schlüsselwörter in Java Die Zeichen sind:

abstract   boolean    break    byte   case
catch   char    class    continue   default
do   double    else    extends   false
final   finally    float    for   if
implements    import   instanceof    int    interface
long   native    new    null   package
private   protected    public    return   short
this   throw    throws    transient   true
try   static    super    switch   synchronized
void   volatile    while

3. Datentypen:

Die Datentypen in C sind:

1 ) Grundtypen : Integer-Typ (einfacher Integer-Typ, kurzer Integer-Typ short [int] und langer Integer-Typ long [int] sowie vorzeichenbehafteter Typ [signed], vorzeichenloser Typ unsigned), Zeichentyp [signed/unsigned] char, Gleitkommatyp (Einzelpräzisions-Float, Doppelpräzisions-Double und Long Double), Aufzählungstyp

2) Konstruktionstyp: Array-Typ, Strukturtyp, Union-Typ

3) Zeigertyp

4) Nulltyp

注意下各类型一般所占字节数：

int: 2 Bytes

short: 2 Bytes

long: 4 Bytes

char: 1 Byte

float: 4 Bytes

double: 8 Bytes

long double: 16 Bytes

Mit Ausnahme des Char-Typs unterscheiden sich die oben genannten Speichertypen je nach System geringfügig. Die Anzahl der Ziffern mit niedriger Genauigkeit darf jedoch die Anzahl mit hoher Genauigkeit nicht überschreiten.

Datentypen in Java:

1) Grundtypen: Zeichentyp (char), numerischer Typ (Ganzzahltyp (Bytetyp) Byte , kurzer Integer-Typ, Integer-Typ int, langer Integer-Typ long), Gleitkommatyp (Float mit einfacher Genauigkeit, Typ mit doppelter Genauigkeit double)), Boolescher Typ (boolean (wahr oder falsch))

2 ) Zusammengesetzte Typen: Klassen, Schnittstellen, Arrays

Beachten Sie die Anzahl der von jedem Speichertyp belegten Bytes:

Byte: 1 Byte

short: 2 Bytes

int: 4 Bytes

long: 8 Bytes

char: 2 Bytes (Unicode-Kodierung)

float: 4 Bytes

double: 8 Bytes

Der den oben genannten Datentypen entsprechende Speicherplatz hat nichts mit der Plattform zu tun und ist auf diesen Wert festgelegt.

4. Konstanten und Variablen

1) Konstanten

Die Definition von Ganzzahlkonstanten in Java und C ist dieselbe , außer long Außer ganzzahligen Daten mit l oder L am Ende zeigen andere Typen numerische Werte direkt an. Vorzeichenlosen Konstanten in C wird ein u oder U vorangestellt. Für verschiedene Basen zeigt die Dezimalzahl direkt an, dass das höchste Bit nicht 0 enthalten darf, die Oktalzahl beginnt mit 0 und die Hexadezimalzahl beginnt mit 0x oder 0X.

Für Gleitkommatypen können sowohl C als auch Java nur die Dezimaldarstellung verwenden. Dezimalform und Exponentialform können verwendet werden. Wenn die Exponentialform ausgedrückt wird, werden Dezimalzahl und Exponent durch e oder E getrennt. Beachten Sie, dass Java zur Unterscheidung f oder F nach einfacher Genauigkeit und d oder D nach doppelter Genauigkeit benötigt.

Zeichenkonstanten werden durch ein einzelnes Zeichen oder eine in einfache Anführungszeichen eingeschlossene Escape-Zeichenfolge dargestellt. Beachten Sie insbesondere, dass der Zeichentyp in C nur Zeichen mit ASCII-Codes von 0 bis 255 darstellen kann. Java verwendet 2-Byte-Speichereinheiten mit Unicode-Kodierung, um Sonderzeichen darzustellen. Bei der Darstellung der Unicode-Kodierung werden u plus 4-stellige hexadezimale Zeichenfolgen verwendet.

Der Typ Boolean ist nur in Java verfügbar, daher ist besondere Aufmerksamkeit erforderlich.

Konstanten in Java werden mit dem Schlüsselwort final geändert, das nach der Zuweisung nicht mehr geändert werden kann; in C ist das Schlüsselwort, das nicht geändert werden kann, const und die Variable, die es ändert (beachten Sie, dass es sich um eine Variable handelt). , keine Konstante) muss bei der Definition definiert werden. Weisen Sie einen Anfangswert zu, und mit #define definierte Makrokonstanten haben keinen Typ.

2) Variablen

Die Definitionen von Variablen in Java und C sind grundsätzlich gleich, das heißt:

数据类型变量名[ = 变量初值];

Variablen kann ein Anfangsbuchstabe zugewiesen werden Wert oder nicht, aber in Java müssen auf lange Ganzzahlen und Gleitkommazahlen entsprechende Identifikationszeichen (z. B. l, f) folgen.

Besonderer Hinweis: Aufgrund von Unterschieden bei den Compilern müssen C-Deklarationsvariablen vor ausführbaren Anweisungen platziert werden, da sonst Kompilierungsfehler auftreten können.

Logische Operatoren und bitweise Operatoren

Logische Operatoren &&, ||, ! Es gibt drei Typen, die dieselbe Bedeutung haben. Der Unterschied besteht darin, dass das Operationsergebnis in C 0 und nicht 0 ist, während es in Java nur wahr oder falsch sein kann. Es gibt auch &, |, ^ (XOR) in Java. Der Unterschied zwischen & und &&, | und || besteht darin, dass es sich bei ersterem um einen Verknüpfungsoperator handelt, d und nach &, und wenn vor && falsch, wird kein Urteil gefällt. Wenn || vorher und nachher wahr ist, wird kein Urteil gefällt. ^ bedeutet, dass beide gleich und falsch sind.

Die in C und Java verfügbaren bitweisen Operatoren sind: &, |, ^, ~ (Inversion), << (Linksverschiebung), >> (Rechtsverschiebung), ihre Bedeutungen sind grundsätzlich gleich . Die Rechtsverschiebung negativer Zahlen in C variiert je nach System (es kann eine arithmetische Rechtsverschiebung oder eine logische Rechtsverschiebung sein), während >> in Java eine arithmetische Rechtsverschiebung darstellt, d. h. das höchste Bit mit dem Vorzeichenbit gefüllt. Der logische Rechtsverschiebungsoperator (vorzeichenlose Rechtsverschiebung) in Java ist >>>, der eine komplementäre Rechtsverschiebung verwendet und 0 zum High-Bit hinzufügt.

PS：有心的读者可能会发现，如果你定义了一个byte或者short类型的负数，如-10，采用>>>方法进行无符号右移后输出的结果是-5，按照上面说的高位添0应该是正数。而int或long类型的就不会是负数，这是为什么呢？

我认为这是因为Java在进行>>>运算时采用的最低数据类型是int类型，导致高位数据全为1（计算机内存储的数据是以补码存储的，所以负数的byte或short类型转成int类型高位全填充1），移位时高位的最后一个1移到低位的第一位，然后截取成我们定义的数据类型（byte或short），所以我们看到的数还是负数。从这里我们可以看出，在byte和short类型的数据做>>>运算的时候可能得不到我们想要的值，千万注意。

6、数组

C中数组的定义如下：

类型说明符数组名[常量表达式];

定义可与初始化同时进行，如：int a[10] = {0,1,2,3,4,5,6,7,8,9};中括号内的常量可以省略。

Java中数组定义有两种方式：

数据类型 数组名[];或
数据类型 []数组名;

定义和初始化可同时进行，如：int []a = {0,1,2,3,4,5,6,7,8,9};

注意Java中数组如果在定义时没有进行初始化，在进行初始化的时候需要先分配内存，即：

数组名 = new 数据类型[常量表达式];

也可在定义同时进行内存分配：

数据类型数组名[] = new 数据类型[常量表达式];

C和Java都不支持变长数组，引用的时候都是 数组名[下标]。区别是：Java的下标范围为0～数组长度-1，不在该范围会抛出数组下标越界异常，而C有效范围也是0～数组长度-1，但下标超出此界不会报错。

多维数组中，数组元素都是按行排列的。

还有一点要注意：C中定义数组不进行初始化则数组元素值是不可预知的，而Java中分配内存而不进行初始化数组中是有默认值的。

7、语句

C和Java语句区别不大，主要是：

1）方法/函数调用时C直接调用函数，Java调用方法时方法名前面要加对象名。

2）C中两个嵌套的复合语句同时定义同名变量是可以的，而Java不可以。

8、类、域、方法和全局变量、函数

1）类是C中没有的，Java中类定义如下：

[修饰符] class 类名[extends 父类名][implements 接口名]
{
//类体
}

其中修饰符可以为以下一个或多个访问修饰符：

abstract：抽象类。

final：最终类。

public：公共类。

2）域（成员变量）和全局变量类比：

Java中域的定义如下：

[修饰符] 类型 成员变量名;

修饰符可选以下一个或多个关键字：

public：公共成员。

protected：本类或同一个包的其他类以及其它包该类的子类可访问。

private：私有成员。

final：常量，确定后不能改变。

static：静态变量。

transient：临时变量。

volatile：备份变量。

各类型成员变量默认初始化为：

整型变量：0

浮点型变量：0.0

布尔型变量：false

字符型变量：空格

类变量：null

C中全局变量定义同一般变量：

[存储类别] 数据类型 变量表列;

其中存储类别可选：

auto：自动变量，当不申明存储类别时隐式默认该值。

static：静态变量。

register：寄存器变量。

extern：外部变量。

3）方法和函数类比：

Java中方法的定义如下：

[修饰符] 返回类型 方法名([参数表列])
{
//方法体
}

修饰符可选以下一个或多个：

public：公共方法。

protected：本类或同一个包的其他类以及其它包该类的子类可访问。

private：私有方法。

abstract：抽象方法，只有方法头没有方法体。

static：静态方法。

C中函数的定义如下：

[存储类别] [数据类型] 函数名([形参表列]) 
{
//函数体
}

存储类别可选：

extern：外部函数。

static：静态函数。

Das obige ist der detaillierte Inhalt vonDer Unterschied zwischen C-Syntax und Java-Syntax. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!