目录
下面看一个简单的 Java 程序，它将输出字符串?Hello World
public class HelloWorld {
/* 第一个Java程序
* 它将输出字符串 Hello World
*/
? ? public static void main(String[] args) {
? ? ? ? System.out.println("Hello World"); // 输出 Hello World
? ? }
}
单行注释以双斜杠?//?开始：?
eg:? ?// 单行注释
? ? ? ? int x = 10; // 初始化一个变量x为10
多行注释以?/*开始，以?*/结束：
eg:? ?/* 多行注释
? ? ? ? ? ?可以用来注释多行代码 */
? ? ? ? ?int y = 20; // 初始化一个变量y为20
文档注释以?/**?开始，以?*/?结束，通常出现在类、方法、字段等的声明前面，用于生成代码文档，这种注释可以被工具提取并生成 API 文档，如 JavaDoc。
eg:? ?/**
? ? ? ? ?* 文档注释
? ? ? ? ?* 通常包含有关类、方法或字段的详细信息 */
? ? ? ? ?public class MyClass {
? ? ? ? ? ? ?// 类的成员和方法
? ? ? ? ?}?
Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。?
注意：
建议：
?下面列出了 Java 关键字。所有的关键字都是小写的，这些保留字不能用于常量、变量、和任何标识符的名称。
注：Java 的 null 不是关键字，类似于 true 和 false，它是一个字面常量，不允许作为标识符用。
| 类别 | 关键字 | 说明 |
|---|---|---|
| 访问控制 | private | 私有的 |
| protected | 受保护的 | |
| public | 公共的 | |
| default | 默认 | |
| 类、方法和变量修饰符 | abstract | 声明抽象 |
| class | 类 | |
| extends | 扩充、继承 | |
| final | 最终值、不可改变的 | |
| implements | 实现（接口） | |
| interface | 接口 | |
| native | 本地、原生方法（非 Java 实现） | |
| new | 创建 | |
| static | 静态 | |
| strictfp | 严格浮点、精准浮点 | |
| synchronized | 线程、同步 | |
| transient | 短暂 | |
| volatile | 易失 | |
| 程序控制语句 | break | 跳出循环 |
| case | 定义一个值以供 switch 选择 | |
| continue | 继续 | |
| do | 运行 | |
| else | 否则 | |
| for | 循环 | |
| if | 如果 | |
| instanceof | 实例 | |
| return | 返回 | |
| switch | 根据值选择执行 | |
| while | 循环 | |
| 错误处理 | assert | 断言表达式是否为真 |
| catch | 捕捉异常 | |
| finally | 有没有异常都执行 | |
| throw | 抛出一个异常对象 | |
| throws | 声明一个异常可能被抛出 | |
| try | 捕获异常 | |
| 包相关 | import | 引入 |
| package | 包 | |
| 基本类型 | boolean | 布尔型 |
| byte | 字节型 | |
| char | 字符型 | |
| double | 双精度浮点 | |
| float | 单精度浮点 | |
| int | 整型 | |
| long | 长整型 | |
| short | 短整型 | |
| 变量引用 | super | 父类、超类 |
| this | 本类 | |
| void | 无返回值 | |
| 保留关键字 | goto | 是关键字，但不能使用 |
| const | 是关键字，但不能使用 |
变量就是指代在内存中开辟的存储空间，用于存放运算过程中需要用到的数据。
声明变量的语法如下：
DataType 变量名;变量声明操作已经告诉了编译器变量的数据类型。声明了变量后我们就可以使用赋值语句为其赋值?。
// 变量声明语句
int a;
// 赋值语句
a = 1;精简语法，可将变量的声明和赋值同时进行
int a = 1, b = 2;基本数据类型是CPU可以直接进行运算的类型，包括：
整数类型
| 整型 | 占用字节空间大小 | 取值范围?? | 默认值 |
| byte | 1字节? | ?-128 ~ 127 | 0 |
| short | 2字节? | -32768 ~ 32767 | 0 |
| int | 4字节? | ?-2^31 ~ （2^31） - 1 | 0 |
| long? | 8字节? | -2^63 ~ （2^63） - 1 | 0L |
?浮点类型（小数）
| 浮点型 | 占用字节空间大小 | 取值范围?? | 默认值 |
| float? | 4字节? | 10^38? | 0.0F |
| double? | 8字节? | 10^308? | 0.0 |
字符类型
| 字符型? | 占用字节空间大小 | 取值范围?? | 默认值 |
| char? | 2字节? | 0 ~ 65535? | ?‘\u0’ |
?布尔类型
| 布尔型 | 占用字节空间大小 | 取值范围?? | 默认值 |
| boolean? | 视情况而定 | true、false | false |
?低级变量可以直接转换为高级变量。
如果把范围小的数据，赋值给范围大的数据时，不会出现精度的缺失；反之，则可能会出现精度的缺失。当字符串执行加法运算就是拼接字符串。
?范围小的数据类型 变量 = （范围小的数据类型）范围大的数据。
强制类型转换也许会出现精度的缺失或溢出的情况。
实例变量是在类中声明，但在方法、构造函数或块之外，它们属于类的实例，每个类的实例都有自己的副本，如果不明确初始化，实例变量会被赋予默认值（数值类型为0，boolean类型为false，对象引用类型为null）。
eg:
public class Student {
// 实例变量 name
public String name;
// 实例变量 age
public int age;
// 构造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
}
// 打印学生基本信息的方法
public void printInfo() {
System.out.println("学生姓名为：" + name);
System.out.println("学生年龄为：" + age);
}
public static void main(String[] args) {
// 实例化两个学生对象
Student student1 = new Student("a", 20);
Student student2 = new Student("b", 18);
// 分别调用打印学生基本信息方法，打印两个对象下的两个实例变量
student1.printInfo();
student2.printInfo();
}
}运行结果：
学生姓名为：a
学生年龄为：20
学生姓名为：b
学生年龄为：18实例变量和实例对象相关，因此需要通过new关键字实例化出对象，通过对象才能访问其实例变量（也称实例属性）。 上述代码中，name和age就是用于存储其对象的属性，我们实例化了两个学生对象，其实例变量name和age，在每个对象实例中是唯一的。
类变量是在类中用 static 关键字声明的变量，它们属于类而不是实例，所有该类的实例共享同一个类变量的值，类变量在类加载时被初始化，而且只初始化一次。
另外，类变量可以被声明为常量，通过使用final关键字以表示变量永远不会改变。
eg:
public class Course {
// 类变量 courseType
public static String courseType = "class";
// 常量 COURSE_NAME
public static final String COURSE_NAME = "Java";
public static void main(String[] args) {
// 分别打印类变量和常量
System.out.println(Course.courseType);
System.out.println(Course.COURSE_NAME);
}
}运行结果：
class
Java类变量和类相关，因此不需要使用new关键字实例化对象后再调用，可以直接通过类名 +?.点运算符 + 类变量名的方式调用。
上述代码中，courseType?和COURSE_NAME都使用static关键字修饰，它们都可以直接通过Course.变量名的方式调用。
局部变量是在方法范围内被声明和使用的。它们没有任何关键字修饰，可以根据变量声明的位置来认定局部变量（即方法的左花括号和右花括号之间），因此，局部变量只可以对声明它们的方法可见。方法返回后，它们将被销毁。
eg1:
public static void main(String[] args) {
// 局部变量 name
String name = "a";
// 局部变量 age
int age = 20;
System.out.println("姓名：" + name);
System.out.println("年龄：" + age);
}eg2：
public class PrintNumber {
public void printer() {
int num = 10;
for(int i = 1; i <= num; i ++) {
System.out.println(i);
}
}
}局部变量和方法相关，因此只能在方法内部局部定义和使用，在第二个实例中没有代码注释，请思考printer方法中有哪几个局部变量。
参数是方法或构造函数声明中的变量，用于接收调用该方法或构造函数时传递的值，参数变量的作用域只限于方法内部。
eg:
// Student 类构造方法
public Student(String name, int age) { // name 和 age 就是传递给Student构造方法的参数
this.name = name;
this.age = age;
}
代码块12345注意，方法体中的this.name和this.age指代的是实例变量，而?name和age是参数，它们被用于赋值给实例变量。
| 操作符 | 描述 |
|---|---|
| + | 加法 - 相加运算符两侧的值 |
| - | 减法 - 左操作数减去右操作数 |
| * | 乘法 - 相乘操作符两侧的值 |
| / | 除法 - 左操作数除以右操作数 |
| ％ | 取余 - 左操作数除以右操作数的余数 |
| ++ | 自增: 操作数的值增加1 |
| -- | 自减: 操作数的值减少1 |
前缀自增自减法(++a,--a):?先进行自增或者自减运算，再进行表达式运算。
后缀自增自减法(a++,a--):?先进行表达式运算，再进行自增或者自减运算。?
| 运算符 | 描述 |
|---|---|
| == | 检查如果两个操作数的值是否相等，如果相等则条件为真。 |
| != | 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 |
| >? | 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。 |
| <? | 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。 |
| 操作符 | 描述 |
|---|---|
| ＆ | 如果相对应位都是1，则结果为1，否则为0 |
| | | 如果相对应位都是 0，则结果为 0，否则为 1 |
| ^ | 如果相对应位值相同，则结果为0，否则为1 |
| ? | 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 |
| <<? | 按位左移运算符。左操作数按位左移右操作数指定的位数。 |
| >>? | 按位右移运算符。左操作数按位右移右操作数指定的位数。 |
| >>>? | 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 |
| 操作符 | 描述 |
|---|---|
| && | 称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。 |
| | | | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。 |
| ！ | 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。 |
| 操作符 | 描述 | 例子 |
|---|---|---|
| = | 简单的赋值运算符，将右操作数的值赋给左侧操作数 | C = A + B将把A + B得到的值赋给C |
| + = | 加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 | C + = A等价于C = C + A |
| - = | 减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 | C - = A等价于C = C - A |
| * = | 乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 | C * = A等价于C = C * A |
| / = | 除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 | C / = A，C 与 A 同类型时等价于 C = C / A |
| （％）= | 取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数 | C％= A等价于C = C％A |
| << = | 左移位赋值运算符 | C << = 2等价于C = C << 2 |
| >> = | 右移位赋值运算符 | C >> = 2等价于C = C >> 2 |
| ＆= | 按位与赋值运算符 | C＆= 2等价于C = C＆2 |
| ^ = | 按位异或赋值操作符 | C ^ = 2等价于C = C ^ 2 |
| | = | 按位或赋值操作符 | C | = 2等价于C = C | 2 |
条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
variable x = (expression) ? value if true : value if false
首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
dataType[] arrayRefVar;
// 首选的方法
dataType arrayRefVar[];
// 效果相同,但不是首选方法,在Java中采用是为了让 C/C++ 程序员能够快速理解java语言
数组变量的声明，和创建数组可以用一条语句完成，如下所示：
dataType[] arrayRefVar = new dataType[arraySize];
另外，你还可以使用如下的方式创建数组。
dataType[] arrayRefVar = {value0, value1, ..., valuek};
JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。
语法格式如下：
for(type element: array){
System.out.println(element);
}
定义方式
1.数据类型[ ] [ ] 数组名 = new 数据类型 [ 行的个数 ] [ 列的个数 ] ;
2.数据类型[ ] [ ] 数组名 = { { 第0行初始值 } , { 第1行初始值 } , . . . , { 第n行初始值 } } ;
java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。
具有以下功能：