JAVA编程基础1
目录
基本语法
注释
1.单行注释
2.多行注释
3.文档注释
标识符
关键字
变量
创建变量
变量赋值
基本数据类型
数据类型转换
自动类型转换
强制类型转换
变量的种类
实例变量（Instance Variables）
静态变量或类变量（Class Variables）
局部变量（Local Variables）
参数变量（Parameters）
运算符
算术运算符
关系运算符
位运算符
逻辑运算符
赋值运算符
条件运算符
数组
声明数组变量
创建数组
For-Each 循环
多维数组
Arrays 类
基本语法
下面看一个简单的 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)。