java基础语法总结
java基础语法
- 一、Java概述
- 二、Java基础语法
- 1.变量
- 1.1. 变量的分类
- 2. 运算符
- 三、引用数据类型
- 四、流程控制语句
- 五、数组
- 1. 一维数组
- 2. 二维数组
一、Java概述
- JRE：java运行时的环境。
- JDK：java开发环境。
- JDK包含了JRE，JRE包含jvm。
二、Java基础语法
1.变量
- 变量：变量是内存中装载数据的小盒子，只能存取数据。
- 存储单元：
1B（byte字节） = 8bit
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB - 变量必须要有明确的类型，什么类型的变量装载什么类型的数据：
| 四类 | 八种 | 字节数 | 数据表示范围 |
| 整型 | byte | 1 | -128～127 |
| short | 2 | -32768～32767 | |
| int | 4 | -2147483648～2147483648 | |
| long | 8 | -263～263-1 | |
| 浮点型 | float | 4 | -3.403E38～3.403E38 |
| double | 8 | -1.798E308～1.798E308 | |
| 字符型 | char | 2 | 表示一个字符，如('a'，'A'，'0'，'家') |
| 布尔型 | boolean | 1 | 只有两个值true与false |
- 数据类型的转换
小转大，自动转；大转小，强制转；
byte -> short -> int -> long -> float -> double
1.1. 变量的分类
成员变量与局部变量：
成员变量：在方法体外，类体内声明的变量。
局部变量：在方法体内部声明的变量。
二者在初始化值方面的异同:
同：都有生命周期
异：局部变量除形参外，需显式初始化。
成员变量（属性）和局部变量的主要区别：
成员变量：
成员变量定义在类中，在整个类中都可以被访问。
成员变量分为类成员变量和实例成员变量，实例变量存在于对象所在的堆内存中。
成员变量有默认初始化值。
成员变量的权限修饰符可以根据需要，选择任意一个
局部变量：
局部变量只定义在局部范围内，如：方法内，代码块内等。
局部变量存在于栈内存中。
作用的范围结束，变量空间会自动释放。
局部变量没有默认初始化值，每次必须显式初始化。
局部变量声明时不指定权限修饰符
2. 运算符
- 算数运算符：
++,–后置时，先使用变量原有值参与运算操作，运算操作完成后，变量的值自增1或者自减1；++，–运算符前置时，先将变量的值自增1或者自减1，然后使用更新后的新值参与运算操作。 - 赋值运算符
运算符 运算规则 范例 结果 = 赋值 int a=2 2 += 加后赋值 int a=2，a+=2 4 -= 减后赋值 int a=2，a-=2 0 *= 乘后赋值 int a=2，a*=2 4 /= 整除后赋值 int a=2，a/=2 1 %= 取模后赋值 int a=2，a%=2 0
- 关系运算符
运算符 运算规则 范例 结果 == 相等于 4==3 False != 不等于 4!=3 True < 小于 4<3 False > 大于 4>3 True <= 小于等于 4<=3 False >= 大于等于 4>=3 True
- 逻辑运算符
运算符 运算规则 范例 结果 & 与 false&true False | 或 false|true True ^ 异或 true^flase True ! 非 !true Flase && 短路与 false&&true False || 短路或 false||true True
短路与&&:参与运算的两边数据，有false，则运算结果为false；
短路或||:参与运算的两边数据，有true，则运算结果为true；
逻辑非! : 参与运算的数据，原先是true则变成false，原先是false则变成true。
-
三元运算符
(条件表达式)？表达式1：表达式2； 先判断条件表达式的值，若为true，运算结果为表达式1；若为false，运算结果为表达式2。 -
运算符的优先级
优先级 描述 运算符 1 括号 ()、[] 2 正负号 +、- 3 自增自减，非 ++、--、! 4 乘除，取余 *、/、% 5 加减 +、- 6 移位运算 <<、>>、>>> 7 大小关系 >、>=、<、<= 8 相等关系 ==、!= 9 按位与 & 10 按位异或 ^ 11 按位或 | 12 逻辑与 && 13 逻辑或 || 14 条件运算 ?: 15 赋值运算 =、+=、-=、*=、/=、%= 16 位赋值运算 &=、|=、<<=、>>=、>>>=
三、引用数据类型
引用数据类型的格式：
数据类型 变量名 = new 数据类型();
每种引用数据类型都有其功能，我们可以调用该类型实例的功能：
变量名.方法名();
四、流程控制语句
-
选择结构 if
方式1:
格式：if(条件表达式) { 语句体; }执行流程：
如果条件表达式值为true, 执行语句体 如果条件表达式值为false,不执行语句体
方式2：
格式:
if(条件表达式) {
语句体1;
} else {
语句体2;
}
执行流程：
如果条件表达式值为true, 执行语句体1
如果条件表达式值为fales,执行语句体2
方式3：
格式：
if(条件表达式1) {
语句体1;
} else if (条件表达式2) {
语句体2;
} else if (条件表达式n...) {
语句体n...
}
...
else {
语句体n+1;
}
执行流程：
哪一个条件表达式成立，执行对应的语句体，
如果所有的条件表达式都不成立，执行最后else中的语句体
注意事项：
1、条件表达式无论是简单还是复杂，结果都是boolean类型的值
2、 如果语句体只有一条语句，大括号可以省略，
如果是多条语句，大括号不能省略，建议什么时候都写上大括号
-
循环语句For
格式：for (初始化表达式;条件表达式; 控制条件表达式) { 语句体; }
执行流程：
1，初始化表达式；
2，条件表达式
如果结果为true, 执行语句体
如果结果为flase, 循环结束
3, 当语句体执行后， 执行控制条件表达式
4，接下来，回到第二步, 直到条件表达式为false 循环结束
-
循环语句 while
格式：
初始化表达式：while (条件表达式) { 语句体; 控制条件表达式; }
执行流程：
1、初始化表达式；
2、条件表达式
如果结果为true, 执行语句体
如果结果为flase, 循环结束
3、当语句体执行后， 执行控制条件表达式
4、接下来，回到第二步, 直到条件表达式为false 循环结束跳转语句（break、continue）
-
循环语句 do…while
格式：
初始化表达式：do { 语句体; 控制条件表达式; } while (条件表达式);
执行流程:
1，初始化表达式；
2, 执行语句体
3, 执行控制条件表达式
4, 执行条件表达式,
如果结果为true, 继续执行语句体
如果结果为false, 循环结束
-
跳转控制语句
break; 跳出循环 continue; 结束本次循环
五、数组
1. 一维数组
-
定义格式：
数据类型[] 数组名 = new 数据类型[元素个数或数组长度];
int[] x = new int[100];
为了更好地理解数组的这种定义方式，可以将上面的一句代码分成两句来写，具体如下：
int[] x; // 声明一个int[]类型的变量
x = new int[100]; // 创建一个长度为100的数组
第一行代码 int[] x; 声明了一个变量x，该变量的类型为int[]，即一个int类型的数组。变量x会占用一块内存单元，它没有被分配初始值。内存中的状态如下图所示：
第二行代码 x = new int[100]; 创建了一个数组，将数组的地址赋值给变量x。在程序运行期间可以使用变量x来引用数组，这时内存中的状态会发生变化，如下图所示：
在上图中描述了变量x引用数组的情况。该数组中有100个元素，初始值都为0。数组中的每个元素都有一个索引(也可称为角标)，要想访问数组中的元素可以通过“x[0]、x[1]、……、x[98]、x[99]”的形式。需要注意的是，数组中最小的索引是0，最大的索引是“数组的长度-1”。在Java中，为了方便我们获得数组的长度，提供了一个length属性，在程序中可以通过“数组名.length”的方式来获得数组的长度，即元素的个数。
定义数组以及访问数组中的元素实列：
1public class ArrayDemo01 {
2 public static void main(String[] args) {
3 int[] arr; // 声明变量
4 arr = new int[3]; // 创建数组对象
5 System.out.println("arr[0]=" + arr[0]); // 访问数组中的第一个元素
6 System.out.println("arr[1]=" + arr[1]); // 访问数组中的第二个元素
7 System.out.println("arr[2]=" + arr[2]); // 访问数组中的第三个元素
8 System.out.println("数组的长度是：" + arr.length); // 打印数组长度
9 }
10}
当数组被成功创建后，数组中元素会被自动赋予一个默认值，根据元素类型的不同，默认初始化的值也是不一样的。具体如下表所示：
为数组的元素赋值，如下所示：
~~~java
1public class ArrayDemo02 {
2 public static void main(String[] args) {
3 int[] arr = new int[4]; // 定义可以存储4个整数的数组
4 arr[0] = 1; // 为第1个元素赋值1
5 arr[1] = 2; // 为第2个元素赋值2
6 // 下面的代码是打印数组中每个元素的值
7 System.out.println(“arr[0]=” + arr[0]);
8 System.out.println(“arr[1]=” + arr[1]);
9 System.out.println(“arr[2]=” + arr[2]);
10 System.out.println(“arr[3]=” + arr[3]);
11 }
12}
在定义数组时只指定数组的长度，由系统自动为元素赋初值的方式称作动态初始化。
静态初始化的2 种方式：
1、类型[] 数组名 = new 类型[]{元素，元素，……};
2、类型[] 数组名 = {元素，元素，元素，……};
采用静态初始化的方式为数组每个元素赋予初值：
~~~java
public class ArrayDemo03 {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4 }; // 静态初始化
// 下面的代码是依次访问数组中的元素
System.out.println("arr[0] = " + arr[0]);
System.out.println("arr[1] = " + arr[1]);
System.out.println("arr[2] = " + arr[2]);
System.out.println("arr[3] = " + arr[3]);
}
}
- 数组遍历
依次访问数组中的每个元素的操作称作数组的遍历。
使用for循环来遍历数组，如下所示：
public class ArrayDemo04 {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5 }; // 定义数组
// 使用for循环遍历数组的元素
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]); // 通过索引访问元素
}
}
}
- 数组常见的问题
3.1 数组最值
获取数组中元素的最大值，如下所示：
public class ArrayDemo05 {
public static void main(String[] args) {
int[] arr = { 4, 1, 6, 3, 9, 8 }; // 定义一个数组
int max = arr[0]; // 定义变量max用于记住最大数，首先假设第一个元素为最大值
// 下面通过一个for循环遍历数组中的元素
for (int x = 1; x < arr.length; x++) {
if (arr[x] > max) { // 比较 arr[x]的值是否大于max
max = arr[x]; // 条件成立，将arr[x]的值赋给max
}
}
System.out.println("max=" + max); // 打印最大值
}
}
注意，在for循环中的变量i是从1开始的，这样写的原因是程序已经假设第一个元素为最大值，for循环中只需要从第二个元素开始比较，从而提高程序的运行效率。
3.2. 数组越界异常ArrayIndexOutOfBoundsException
每个数组的索引都有一个范围，即0~length-1。在访问数组的元素时，索引不能超出这个范围，否则程序会报错。
3.3. 空指针异常NullPointerException:
在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现空指针异常。
如：
1public class ArrayDemo07 {
2 public static void main(String[] args) {
3 int[] arr = new int[3]; // 定义一个长度为3的数组
4 arr[0] = 5; // 为数组的第一个元素赋值
5 System.out.println("arr[0]=" + arr[0]); // 访问数组的元素
6 arr = null; // 将变量arr置为null
7 System.out.println("arr[0]=" + arr[0]); // 访问数组的元素
8 }
9}
上述代码中第4、5行代码都能通过变量arr正常地操作数组。第6行代码将变量置为null，当第7行代码再次访问数组时就出现了空指针异常NullPointerException。
2. 二维数组
-
定义方式：
第一种方式：int[][] arr = new int[3][4];
上面的代码相当于定义了一个3*4的二维数组，即二维数组的长度为3，二维数组中的每个元素又是一个长度为4的数组，接下来通过一个图来表示这种情况，如下图所示：
第二种方式：
int[][] arr = new int[3][];
第二种方式和第一种类似，只是数组中每个元素的长度不确定，接下来通过一个图来表示这种情况，如下图所示：
第三种方式：
int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};
上面的二维数组中定义了三个元素，这三个元素都是数组，分别为{1,2}、{3,4,5,6}、{7,8,9}，接下来通过一个图来表示这种情况：
- 二维数组元素遍历与数组元素累加和
class ArrayDemo09 {
public static void main(String[] args){
//一维数组的求累加和并遍历
int[] arr = {10,20,30,40,50};
int sum = 0;
for (int i=0; i<arr.length; i++) {
//System.out.println(arr[i]);
sum += arr[i];
}
System.out.println("sum= " + sum);
System.out.println("---------------------");
//二维数组的求累加和并遍历
int[][] arr2 = { {1,2},{3,4,5},{6,7,8,9,10} };
int sum2 = 0;
for (int i=0; i<arr2.length; i++) {
for (int j=0; j<arr2[i].length; j++) {
//System.out.println(arr2[i][j])
sum2 += arr2[i][j];
}
}
System.out.println("sum2= "+ sum2);
}
}
公司销售总和练习：
例如要统计一个公司三个销售小组中每个小组的总销售额以及整个公司的销售额。如下所示
第一小组销售额为{11, 12}万元
第二小组销售额为{21, 22, 23}万元
第三小组销售额为{31, 32, 33, 34}万元。
1public class ArrayDemo10 {
2 public static void main(String[] args) {
3 int[][] arr = new int[3][]; // 定义一个长度为3的二维数组
4 arr[0] = new int[] { 11, 12 }; // 为数组的元素赋值
5 arr[1] = new int[] { 21, 22, 23 };
6 arr[2] = new int[] { 31, 32, 33, 34 };
7
8 int sum = 0; // 定义变量记录总销售额
9 for (int i = 0; i < arr.length; i++) { // 遍历数组元素
10 int groupSum = 0; // 定义变量记录小组销售总额
11 for (int j = 0; j < arr[i].length; j++) { // 遍历小组内每个人的销售额
12 groupSum = groupSum + arr[i][j];
13 }
14 sum = sum + groupSum; // 累加小组销售额
15 System.out.println("第" + (i + 1) + "小组销售额为：" + groupSum + " 万元");
16 }
17 System.out.println("总销售额为: " + sum + " 万元");
18 }
19}
在上述代码中，第3行代码定义了一个长度为3的二维数组，并在4~6行代码中为数组的每个元素赋值。例程中还定义了两个变量sum和groupSum，其中sum用来记录公司的总销售额，groupSum用来记录每个销售小组的销售额。当通过嵌套for循环统计销售额时，外层循环对三个销售小组进行遍历，内层循环对每个小组员工的销售额进行遍历，内层循环每循环一次就相当于将一个小组员工的销售总额统计完毕，赋值给groupSum，然后把groupSum的值与sum的值相加赋值给sum。当外层循环结束时，三个销售小组的销售总额groupSum都累加到sum中，即统计出了整个公司的销售总额。
案例需求分析:
在全班同学中随机的打印出一名同学名字。
我们对本案例进行分析，得出如下分析结果：
1.存储全班同学名字
2.打印全班同学每一个人的名字
3.在班级总人数范围内，随机产生一个随机数，查找该随机数所对应的同学名字
在存储同学姓名时，如果对每一个同学都定义一个变量进行姓名存储，则会出现过多孤立的变量，很难一次性将全部数据持有。此时，我们可以使用数组解决多个数据的存储问题。
public static void main(String[] args) {
System.out.println("--------随机点名器--------");
// 创建一个存储多个同学名字的容器（数组）
String[] students = new String[3];
/**
* 1.存储全班同学名字
* 创建一个存储多个同学名字的容器（数组）
* 键盘输入每个同学的名字，存储到容器中（数组）
*/
//键盘输入多个同学名字存储到容器中
Scanner sc = new Scanner(System.in);
for (int i = 0; i < students.length; i++) {
System.out.println("存储第"+i+"个名称：");
students[i] = sc.next();
/**
* 2打印全班同学每一个人的名字
*/
//遍历数组，得到每个同学名字
for (int i = 0; i < students.length; i++) {
String name = students[i];
//打印同学名字
System.out.println("第"+i+"个学生名称：" + name);
/**
* 3.在班级总人数范围内，随机产生一个随机数
*/
//根据数组长度，获取随机索引
int index = new Random().nextInt(students.length);
//通过随机索引从数组中获取名称
String name = students[index];
//返回随机点到的名称
}
上述代码中，通过随机数类Random产生一个从0到数组长度的随机索引。使用该索引获取students数组中对应的值，便得到了全班同学的随机姓名。