一、运算符
1.1 算术运算符
运算符 | 运算 | 示例 | 结果 |
---|---|---|---|
+ | 加 | 1 + 1 | 2 |
- | 减 | 3 - 2 | 1 |
* | 乘 | 3 * 2 | 6 |
/ | 除 | 4 / 2 | 2 |
% | 取模(求余数) | 5 % 2 | 1 |
1.2 自增自减运算符
++和–:
当该运算符放在操作数前面,则先减1或加1,操作数再参加运算
当该运算符放在操作数后面,则操作数先参加运算,再减1或加1
public class Demo01 {
public static void main(String[] args){
int a = 2;
int x = a + a++;
System.out.println(x); //4
System.out.println(a); //3
int b = 2;
int y = b + ++b;
System.out.println(y); //5
System.out.println(b); //3
}
}
1.3 赋值运算符
运算符 | 运算 | 示例 | 结果 |
---|---|---|---|
= | 赋值 | a=3 | a = 3 |
+= | 加等于 | a = 3, a += 2 | a = 5 |
-= | 减等于 | a = 3, a -= 2 | a = 1 |
*= | 乘等于 | a = 3, a *= 2 | a = 6 |
/= | 除等于 | a = 4, a /= 2 | a = 2 |
%= | 模等于 | a = 5, a %= 2 | a = 1 |
1.4 比较运算符
运算符 | 运算 | 示例 | 结果 |
---|---|---|---|
== | 赋值 | 4==3 | false |
!= | 加等于 | 3!=2 | true |
< | 小于 | 3<2 | false |
> | 大于 | 3>2 | true |
<= | 小于等于 | 4<=2 | false |
>= | 大于等于 | 5>=2 | true |
1.5 逻辑运算符
运算符 | 运算 | 示例 | 结果 |
---|---|---|---|
& | 与 | true & false | false |
| | 或 | true | false | true |
^ | 异或 | true ^ true | false |
! | 非 | !false | true |
&& | 短路与 | false && true | false |
|| | 短路或 | true | false | true |
异或可以简单理解为不一样即为true,一样即为false
与”&“、短路与“&&”在使用上的差别为:当短路与左边为false时,不再对右边进行运算,而与则会继续;同理,或“|”与短路或“||”也是一样
1.6 位运算符
运算符 | 运算 |
---|---|
& | 按位与 |
| | 按位或 |
~ | 按位非 |
^ | 按位异或 |
<< | 左位移 |
>> | 右位移 |
>>> | 无符号右位移 |
public class Demo02 {
public static void main(String [] args){
// 8:0000 0000 0000 0000 0000 0000 0000 1000
// -8:1000 0000 0000 0000 0000 0000 0000 1000
// 5:0000 0000 0000 0000 0000 0000 0000 0101
System.out.println(8 & 5); // 按位与 结果为0
System.out.println(8 | 5); // 按位或 结果为13
/*
取非后相当于反码,需要再转化为原码,5取反转化为源码后结果为-6
注意取反后符号位不会再变化
*/
System.out.println(~5); // 非 结果为-6
System.out.println(8 ^ 5); //按位异或 结果为13
System.out.println(8 << 2); // 左位移2位 结果为32
System.out.println(8 >> 3); // 右位移3位 结果为1
System.out.println(-8 >>> 3); // 无符号右位移3位 结果为536870911
}
}
二、条件语句结构
2.1 选择语句
1. if条件语句
if(条件语句) {
代码块;
}
2. if…else语句
if(条件语句) {
执行语句1;
} else {
执行语句2;
}
3. if…else if…else语句
if(条件语句1) {
执行语句1;
} else if (条件语句2) {
执行语句2;
}...
else{
执行语句n+1;
}
public class Demo03 {
public static void main(String[] args) {
//运行程序过程中,需要向程序中输入一些数据,借助Scanner类型操作
Scanner sc = new Scanner(System.in);
System.out.print("请输入分数(上限100):");
int grade = sc.nextInt();
if (grade < 60) {
System.out.print("成绩不及格!");
} else if (grade < 70) {
System.out.print("成绩为中!");
} else if (grade<80) {
System.out.print("成绩为良!");
} else if (grade<100) {
System.out.print("成绩为优!");
} else {
System.out.print("成绩不合法!");
}
}
}
2.2 三元运算符
判断条件 ? 表达式1 : 表达式2
public class Demo04 {
public static void main(String [] args) {
int x = 0, y = 1;
int max;
if(x > y) {
max = x;
} else {
max = y;
}
System.out.println(max); //1
}
}
public class Demo05 {
public static void main(String [] args) {
int x = 0, y = 1;
int max = x > y ? x : y;
System.out.println(max); //1
}
}
2.3 switch 条件语句
switch(条件语句) {
case1:
执行语句1;
break;
case2:
执行语句2;
break;
case3:
执行语句3;
break;
default:
执行语句4;
break;
}
import java.util.Scanner;
public class Demo06 {
public static void main(String [] args) {
Scanner sc = new Scanner(System.in);
int level = sc.nextInt();
switch(level) {
case 0:
System.out.println("档位0,风扇静止");
break;
case 1:
System.out.println("档位1,风扇转速500r/min");
break;
case 2:
System.out.println("档位2,风扇转速1000r/min");
break;
case 3:
System.out.println("档位3,风扇转速1500r/min");
break;
default:
System.out.println("档位不存在");
break;
}
System.out.println("OVER");
}
}
switch语法中的特殊情况
1. break缺失
- 会造成case穿透,执行多余的代码
- 如果能总结好规律,也可以提高效率
2. default缺失
- 能缺失,没有了默认的情况
3. default书写在其他位置
- 不影响运行,可读性变差
- 一般书写在最后面
三、循环结构语句
3.1 while循环语句
while(条件语句){
执行语句;
}
public class Demo07 {
public static void main(String [] args){
int x = 0;
while(x < 4) {
System.out.println("x = " + x);
x++;
}
}
}
while循环特殊情况
1. 一次都不执行
- 循环第一轮判断,条件是false,循环直接结束
2. 无限循环
- 循环条件恒为true
3.2 do…while循环语句
do {
执行语句;
} while(条件语句);
public class Demo08 {
public static void main(String [] args){
int x = 0;
do {
System.out.println("x = " + x);
x++;
} while(x < 4);
}
}
注意:do…while与while循环语句的区别在于do…while语句会无条件执行一次
3.3 for循环语句
for(初始化表达式;循环条件;操作表达式){
执行语句;
}
public class Demo09 {
public static void main(String [] args) {
int i, j = 0;
for(i = 1; i < 5; i++) {
j++;
}
System.out.println(j); //4
}
}
3.4 循环嵌套
指在循环体中再定义一个循环结构
public class Demo10 {
public static void main(String[] args) {
int i, j;
for (i = 1; i < 6; i++) {
for(j = 0; j < i; j++) {
System.out.print('*');
}
System.out.print('\n');
}
}
}
四、 跳转语句
4.1 break语句
常出现于循环语句,用于跳出循环体,执行循环体外的语句
4.2 continue语句
在循环语句中,终止本次循环,执行下次循环
五、方法
修饰符 返回值类型 方法名 (参数类型 参数名1,参数类型 参数名2, ...) {
执行语句;
...
return 返回值;
}
public class Demo11 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println(getMax(sc.nextInt(), sc.nextInt()));
}
public static int getMax(int a, int b){
int c;
return c = a > b ? a : b;
}
}
5.1 方法结构
1. 修饰符
-
public
公开的,java中的关键字,目前默认使用public
-
static
静态的,java中的关键字,目前默认使用static
后续会接触更多的修饰符
2. 返回值
-
void
返回值为空,今天会接触其他的返回值类型
其余返回值大体类似
5.2 形参和实参
形参
-
形参数定义在方法声明中小括号中的变量
只需要变量的声明,不用赋值
-
这些参数告知方法的调用者:此方法运行需要这些数据【是必须的】
实参
- 在方法中实际参与运行的数据
- 具体的数据
- 相当于给声明的形参赋值
5.3 方法重载
同一个作用域内具有相同方法名,但参数不同的方法
public class Demo12 {
public static void main(String[] args) {
System.out.println(getMax(2,5));
System.out.println(getMax(2,9,5));
}
public static int getMax(int a, int b) {
int c;
return c = a > b ? a : b;
}
public static int getMax(int a, int b, int c) {
int max = a > b ? a : b;
max = max > c ? max : c;
return max;
}
}
六、数组
数组类型 [] 数组名;
数组类型 [] 数组名 = new 数组类型[长度];
int[] X;
int[] y = new int[10];
6.1 数组默认初始值
数据类型 | 默认初始值 |
---|---|
byte、short、int、long | 0 |
float、double | 0.0 |
char | 空字符,即’\u0000’ |
boolean | false |
引用数据类型 | null,表示变量不引用任意对象 |
6.2 数组常见操作
1. 遍历
public class Demo13 {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4};
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " "); //1 2 3 4
}
}
}
2. 排序
public class Demo14 {
public static void main(String[] args) {
int[] arr1 = { 8, 7, 3, 5, 6, 1, 4 };
System.out.println("冒泡排序前:");
printArray(arr1); //8 7 3 5 6 1 4
bubbleSort(arr1);
System.out.println("冒泡排序后:");
printArray(arr1); //1 3 4 5 6 7 8
}
public static void printArray(int[] a) { //打印数组
for(int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
System.out.println('\n');
}
public static void bubbleSort(int[] a) { //冒泡排序
for(int i = 0; i < a.length - 1; i++) {
for(int j = 0; j < a.length - i - 1; j++) {
if(a[j] > a[j + 1]) { //比较相邻元素
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
}
6.4 二维数组
数据类型[][] 数组名 = new int[行的个数] [列的个数];
数据类型[][] 数组名 = new int[行的个数] [];
数据类型[] [] 数组名 = {{第0行初始值},{第1行初始值},...,{第n行初始值}}
int[][] arr1 = new int[1][2];
int[][] arr2 = new int[3];
int[][] arr3 = { { 1 ,2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } };
6.5 数组扩容
1. 概述
- 数组创建的时候需要指定长度,长度不能更改
- 如果数组中已经存满了数据,还有更多的数据需要存入,数组需要扩容
- 扩容的思路:
- 创建更大的新数组
- 把原来数组中的数据依次复制到新的数组
2. 扩容方式
手动扩容
使用循环挨个遍历数据,复制数据到新数组
public class Demo15 {
public static void main(String[] args) {
String[] nameWei = {"许褚","典韦","夏侯惇","夏侯渊","曹爽"};
String[] nameShu = {"赵云","马超","关羽","张飞","黄忠"};
// 创建更大的数组,存入原来数组中的数据和新加入的数据
String[] names = new String[nameWei.length + nameShu.length];
// 迁移数据
// 把nameWei中的数据迁移到新的数组
for (int i = 0; i < nameWei.length; i++) {
names[i] = nameWei[i];
}
for (int i = 0; i < names.length; i++) {
System.out.println(names[i]);
}
// 把nameShu中的数据迁移到新的数组
for (int i = 0; i < nameShu.length; i++) {
names[nameWei.length + i] = nameShu[i];
}
System.out.println("-----------------------");
for (int i = 0; i < names.length; i++) {
System.out.println(names[i]);
}
}
}
System.arraycopy方法
把源数据数组中的数据复制到目标数组
public class Demo16 {
public static void main(String[] args) {
/**
* public static void arraycopy(Object src,
int srcPos,
Object dest,
int destPos,
int length)
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。
*/
// 源数据数组
String[] nameWei = {"许褚","典韦","夏侯惇","夏侯渊","曹爽"};
String[] nameShu = {"赵云","马超","关羽","张飞","黄忠"};
// 创建新数组:目标数组
// 创建更大的数组,存入原来数组中的数据和新加入的数据
String[] names = new String[nameWei.length + nameShu.length];
// 使用系统提供的方法复制数据
System.arraycopy(nameWei, 0, names, 0, nameWei.length);
System.arraycopy(nameShu, 0, names, nameWei.length, nameShu.length);
for (int i = 0; i < names.length; i++) {
System.out.println(names[i]);
}
}
}
Arrays.copyOf方法
创建指定长度的数组,把源数据数组中的内容复制到新的数组
import java.util.Arrays;
public class Demo17 {
public static void main(String[] args) {
// 源数据数组
String[] nameWei = {"许褚","典韦","夏侯惇","夏侯渊","曹爽"};
String[] nameShu = {"赵云","马超","关羽","张飞","黄忠"};
// 把数组转换成为字符串
System.out.println(Arrays.toString(nameWei));
/**
* 创建一个新的数组,长度是20
* 把nameWei中的数据复制到新的数组
* 剩余的空间可以接纳更多的数据
*/
String[] newArray = Arrays.copyOf(nameWei, 5);
for (int i = 0; i < newArray.length; i++) {
System.out.println(newArray[i]);
}
// 把数组转换成为字符串,包含原数组中所有的内容
String str = Arrays.toString(newArray);
System.out.println(str);
}
}