Java的基本组成

Java的基本组成

Java 语言是一个非常广泛使用的编程语言，它具有简单性、可移植性、面向对象等特性。Java 语言的基本组成如下：

1.Java 关键字

Java 语言中的关键字（Keywords）是指具有特殊含义和作用的保留字，它们被用于描述程序的结构、实现逻辑和限定符号的含义等。Java 关键字总共有 50 个，不同的关键字用于不同的用途和场景，以下是 Java 关键字列表：

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

需要注意的是，Java 关键字是语言的一部分，不能用作变量名、方法名或类名等标识符。当使用关键字时，需要避免与 Java 关键字名称冲突。

2.标识符      

在Java中，标识符（Identifier）是指用来标识类、接口、方法、变量等的名字，包括变量名、常量名、方法名和类名等。标识符可以由字母、数字、下划线和美元符号组成，但必须满足以下规则：

1. 标识符的第一个字符必须是字母、下划线或美元符号；

2. 标识符不能以数字开头；

3. 标识符区分大小写；

4. 标识符不能是Java关键字。

下面是一些合法的标识符：

student _name

$age

count123

TOTAL

而以下则是不合法的标识符：

123count

#total

class 

new

需要注意的是，在命名标识符时应该采用有意义且易于阅读的名称，避免使用简写或缩写，并且按照惯例采用驼峰命名法（camel case）或下划线命名法（snake case）。例如，类名通常采用驼峰命名法，如 StudentInfo；变量名通常采用小驼峰命名法，如 studentName；常量名通常全部大写并采用下划线命名法，如 MAX_VALUE。

3.数据类型

在Java中，数据类型用于定义变量或常量可以存储的数据的类型和范围。Java的数据类型分为两类：基本数据类型和引用数据类型。

1. 基本数据类型

Java中的基本数据类型有8种：byte、short、int、long、float、double、char和boolean。它们分别代表不同的数据类型，其大小和取值范围不同。

• byte：8位带符号的二进制补码整数，取值范围为 -128 到 127。

• short：16位带符号的二进制补码整数，取值范围为 -32768 到 32767。

• int：32位带符号的二进制补码整数，取值范围为 -2147483648 到 2147483647。

• long：64位带符号的二进制补码整数，取值范围为 -9223372036854775808 到 9223372036854775807。

• float：32位单精度浮点数，取值范围为 ±1.40129846432481707e-45 到 ±3.40282346638528860e+38。

• double：64位双精度浮点数，取值范围为 ±4.94065645841246544e-324 到 ±1.79769313486231570e+308。

• char：16位无符号Unicode字符，取值范围为 \u0000 到 \uffff。

• boolean：1位表示true或false。

1. 引用数据类型

Java中的引用数据类型包括类、接口、数组等类型。引用数据类型表示一个对象的引用，而不是直接存储数据。每个对象都有自己的状态和行为，并且可以通过方法进行访问。

需要注意的是，在声明变量时应该指定合适的数据类型，这有助于程序编写和运行效率的提高。同时，Java也支持自动类型转换和强制类型转换，可以方便地在不同数据类型之间进行转换。

4.变量

在Java中，变量是用于存储数据的一种存储空间。在使用变量之前，需要先声明变量并指定其数据类型和名称。变量在声明后可以被赋值，并且在程序运行过程中可以修改其值。变量的作用域取决于变量的声明位置。

Java中的变量分为局部变量、成员变量和静态变量三种。

1. 局部变量

局部变量是在方法或代码块内声明的变量，它们只能在这些范围内被访问。局部变量必须在声明之后才能被使用，并且不能和成员变量或静态变量重名。

例如：

        public void printNum() {

        int num = 10; // 定义局部变量num，初始值为10

        System.out.println(num); // 输出10

}

2. 成员变量

成员变量是在类中定义的变量，它们可以在整个类中被访问。成员变量分为实例变量和类变量两种。

实例变量：也称为非静态变量，每个对象都有自己的实例变量副本。实例变量的值会因为不同对象的不同而不同，需要使用对象来访问。

类变量：也称为静态变量，它们是所有对象共享的。类变量只有一个副本，可以直接通过类名访问。

例如：

public class Person {

// 实例变量

private String name;

private int age;

// 类变量

private static int count;

public Person(String name, int age) {

        this.name = name;

        this.age = age;

        count++;

}

public void printPerson() {

        System.out.println("姓名：" + name);

        System.out.println("年龄：" + age);

}

public static void printCount() {

        System.out.println("总人数：" + count);

        }

}

3.静态变量

静态变量，也称为类变量，是在类中定义的变量，它们是所有对象共享的。静态变量只有一个副本，可以直接通过类名访问，不需要实例化对象。静态变量在类加载时会被初始化，并且它们的值一直存在于内存中直到程序退出为止。

例如：

public class Circle {

        private double radius; // 普通实例变量

        private static double PI = 3.1415926; // 静态变量

        public double area() {

        return PI * radius * radius;

        }

        public static void setPI(double value) {

        PI = value;

        }

}

需要注意的是，在使用变量时应该根据其不同的作用范围来合理选择变量类型，并遵守变量命名规范。变量命名应具有描述性和可读性，最好采用驼峰命名法。

5.运算符

在Java中，运算符是用于执行基本计算、赋值和比较等操作的符号。Java的运算符可以分为以下几类：

算术运算符

Java中常见的算术运算符有加法运算符（+）、减法运算符（-）、乘法运算符（*）、除法运算符（/）和取模运算符（%）。这些运算符的作用以及优先级如下：

运算符	描述	优先级
+	加法	1
-	减法	1
*	乘法	2
/	除法	2
%	取模（求余数）	2

例如：

int a = 10;

int b = 3;

System.out.println(a + b); // 输出13

System.out.println(a - b); // 输出7

System.out.println(a * b); // 输出30

System.out.println(a / b); // 输出3

System.out.println(a % b); // 输出1

赋值运算符

Java中常见的赋值运算符有等号（=）、加等运算符（+=）、减等运算符（-=）、乘等运算符（*=）、除等运算符（/=）和取模等运算符（%=）。例如：

int a = 10;

a += 5; // 等价于 a = a + 5;

a -= 3; // 等价于 a = a - 3;

a *= 2; // 等价于 a = a * 2;

a /= 4; // 等价于 a = a / 4;

a %= 3; // 等价于 a = a % 3;

关系运算符

Java中常见的关系运算符有等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）和小于等于（<=）。例如：

int a = 10;

int b = 5;

System.out.println(a == b); // 输出false

System.out.println(a != b); // 输出true

System.out.println(a > b); // 输出true

System.out.println(a < b); // 输出false

System.out.println(a >= b); // 输出true

System.out.println(a <= b); // 输出false

逻辑运算符

Java中常见的逻辑运算符有与（&&）、或（||）和非（!）。例如：

boolean a = true;

boolean b = false;

System.out.println(a && b); // 输出false

System.out.println(a || b); // 输出true

System.out.println(!a); // 输出false

条件运算符

条件运算符也称为三目运算符，它是Java中唯一的一个三元运算符。它的格式为：条件表达式?表达式1:表达式2，如果条件表达式的值为true，则返回表达式1的值，否则返回表达式2的值。例如：

int a = 10;

int b = 5;

int max = (a > b)? a : b;

System.out.println(max); // 输出10

需要注意的是，在使用运算符时应该根据优先级和结合性规则加以控制，避免出现错误的结果。同时也需要注意类型转换，确保变量类型匹配

6.控制语句

Java 语言中的控制语句包括条件语句（if-else、switch）、循环语句（for、while、do-while）和跳转语句（break、continue、return）。这些语句用于控制程序流程和执行顺序。

控制语句是编程语言中的重要组成部分，可以用于控制程序的流程和执行顺序。Java语言中的控制语句包括：

条件语句：用于根据条件是否成立来执行不同的代码块。

if语句：用于判断一个条件是否成立，如果成立则执行一段代码，否则执行另一段代码。

if(条件) {

// 如果条件为true，执行这里的代码块

}else{

// 如果条件为false，执行这里的代码块

}

if-else语句：用于判断一个条件是否成立，并执行相应的代码块。

if-else if-else语句：用于判断多个条件并执行相应的代码块。

if(条件1) {

// 如果条件1为true，执行这里的代码块

}

elseif(条件2) {

// 如果条件1为false，但条件2为true，执行这里的代码块

}else{

// 如果条件1和条件2都为false，执行这里的代码块

}

switch语句：用于根据不同的取值执行不同的代码块。

switch(变量或表达式) {

case值1:

// 如果变量或表达式的值等于值1，执行这里的代码块break;

case值2:

// 如果变量或表达式的值等于值2，执行这里的代码块break;

// ...default:

// 如果变量或表达式的值与所有case都不匹配，执行这里的代码块break; }

循环语句：用于重复执行一段代码块，直到满足指定条件为止。

for循环语句：用于重复执行一段代码块，可以控制初始化条件、循环条件和迭代操作。

for(初始化条件; 循环条件; 迭代操作) {

// 执行这里的代码块，直到循环条件为false

}

while循环语句：用于重复执行一段代码块，只要循环条件为true就会一直执行。

while(循环条件) {

// 执行这里的代码块，直到循环条件为false

}

do-while循环语句：与while循环类似，但它会先执行一次代码块再判断循环条件是否为true。

do{

// 执行这里的代码块，至少会执行一次

}while(循环条件);

跳转语句：用于跳过某些代码或直接结束代码块的执行。

• break语句：在循环语句或switch语句中使用，可以跳出整个语句块的执行，继续执行后面的代码。如果在嵌套的循环语句中使用break语句，则只会跳出内层循环。例如：

for (int i = 0; i < 10; i++) {

        if (i == 5) {

        break; // 跳出循环，继续执行后面的代码

        }

        System.out.print(i);

}

输出结果为：

0 1 2 3 4

• continue语句：在循环语句中使用，可以跳过当前的循环体中剩余的语句，直接进行下一次迭代。如果在嵌套的循环语句中使用continue语句，则只会跳过内层循环的当前迭代。例如：

for (int i = 0; i < 10; i++) {

        if (i % 2 == 0) {

        continue; // 跳过偶数，继续下一次循环

        }

        System.out.print(i);

}

输出结果为：

1 3 5 7 9

• return语句：在方法中使用，用于结束该方法的执行，并将一个值返回给调用者。如果一个方法声明了返回值类型，则必须使用return语句返回一个相应的值；如果一个方法没有返回值，则不需要使用return语句，或者只需要使用return关键字来结束方法的执行。例如：

public int add(int a, int b) {

        return a + b; // 返回a和b的和

}

public void printHello() {

        System.out.println("Hello world!"); // 无返回值 return; // 可以省略

}

7.方法

1. 方法的定义：方法由返回类型、方法名和参数列表组成。返回类型指定了该方法返回值的类型，可以是任何Java数据类型或void（表示无返回值）。方法名是唯一的标识符，用于调用该方法。参数列表指定了传递给方法的参数类型和名称，可以包含零个或多个参数，多个参数之间用逗号隔开。

2. 方法的调用：要调用一个方法，需要使用方法名和参数列表来指定该方法，并在其前面加上对象或类的名称（静态方法除外）。当调用一个方法时，JVM会将控制传递给该方法，并执行其中的语句。如果方法有返回值，则返回该值；否则，返回void。

3. 方法的重载：在同一个类中，可以定义多个同名但参数列表不同的方法，这就是方法的重载。方法的重载允许程序员使用相同的方法名执行不同的操作，从而提高代码的可读性和复用性。

4. 方法的参数与返回值：方法可以使用参数来接收外部传递进来的值，并根据这些值执行一些特定的操作。方法也可以使用返回值来将结果返回给调用者。在方法中，使用return语句返回指定的值或对象，如果方法没有返回值，则返回类型应该声明为void。

例如，下面是一个简单的Java方法：

public class Calculator {

        public int add(int a, int b) { // 定义一个add方法，接收两个整数参数并返回其和

        int sum = a + b;

        return sum; // 返回sum值

       }

}

要调用该方法，可以像这样：

Calculator calculator = new Calculator();

int result = calculator.add(1, 2); // 调用add方法计算1+2的结果

System.out.println(result); // 输出"3"

这里，我们首先创建了一个Calculator对象，然后调用它的add方法来计算1和2的和，并将结果存储在result变量中，并最终输出结果。

这些是 Java 语言的基本结构和组成部分，掌握了这些基础知识后，就能够开始学习和编写 Java 程序了。