目录
基本语法
下面看一个简单的 Java 程序，它将输出字符串 Hello World
public class HelloWorld {
/* 第一个Java程序
* 它将输出字符串 Hello World
*/
public static void main(String[] args) {
System.out.println("Hello World"); // 输出 Hello World
}
}
注释
1.单行注释
单行注释以双斜杠 // 开始：
eg: // 单行注释
int x = 10; // 初始化一个变量x为10
2.多行注释
多行注释以 /*开始，以 */结束：
eg: /* 多行注释
可以用来注释多行代码 */
int y = 20; // 初始化一个变量y为20
3.文档注释
文档注释以 /** 开始，以 */ 结束，通常出现在类、方法、字段等的声明前面，用于生成代码文档，这种注释可以被工具提取并生成 API 文档，如 JavaDoc。
eg: /**
* 文档注释
* 通常包含有关类、方法或字段的详细信息 */
public class MyClass {
// 类的成员和方法
}
标识符
Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
注意：
- 所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
- 首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
- 关键字不能用作标识符
- 标识符是大小写敏感的
建议：
- 包名的所有字母一律小写
- 类名和接口名每个单词的首字母大写
- 常量名的所有字母一律大写，单词间用_连接
- 变量名和方法名第一个单词首字母小写，从第二个单词开始每个单词首字母大写
- 标识符定义的单词要有意义，以便于阅读
关键字
下面列出了 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 |
数据类型转换
自动类型转换
低级变量可以直接转换为高级变量。
如果把范围小的数据，赋值给范围大的数据时，不会出现精度的缺失；反之，则可能会出现精度的缺失。当字符串执行加法运算就是拼接字符串。
强制类型转换
范围小的数据类型 变量 = （范围小的数据类型）范围大的数据。
强制类型转换也许会出现精度的缺失或溢出的情况。
变量的种类
实例变量（Instance Variables）
实例变量是在类中声明，但在方法、构造函数或块之外，它们属于类的实例，每个类的实例都有自己的副本，如果不明确初始化，实例变量会被赋予默认值（数值类型为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，在每个对象实例中是唯一的。
静态变量或类变量（Class Variables）
类变量是在类中用 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.变量名的方式调用。
局部变量（Local Variables）
局部变量是在方法范围内被声明和使用的。它们没有任何关键字修饰，可以根据变量声明的位置来认定局部变量（即方法的左花括号和右花括号之间），因此，局部变量只可以对声明它们的方法可见。方法返回后，它们将被销毁。
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方法中有哪几个局部变量。
参数变量（Parameters）
参数是方法或构造函数声明中的变量，用于接收调用该方法或构造函数时传递的值，参数变量的作用域只限于方法内部。
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};
For-Each 循环
JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。
语法格式如下：
for(type element: array){
System.out.println(element);
}
多维数组
定义方式
1.数据类型[ ] [ ] 数组名 = new 数据类型 [ 行的个数 ] [ 列的个数 ] ;
2.数据类型[ ] [ ] 数组名 = { { 第0行初始值 } , { 第1行初始值 } , . . . , { 第n行初始值 } } ;
Arrays 类
java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。
具有以下功能：
- 给数组赋值：通过 fill 方法。将指定的 x值分配给指定 x型数组指定范围中的每个元素。
- 对数组排序：通过 sort 方法,按升序。对指定对象数组根据其元素的自然顺序进行升序排列。
- 比较数组：通过 equals 方法比较数组中元素值是否相等。如果两个指定的 long 型数组彼此相等，则返回 true。
- 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
