在Java中,程序的执行结构分为三种
顺序结构:代码从上往下,逐行依次执行,是程序执行的默认结构。
分支结构:程序在某一个节点遇到了多种向下执行的可能性,根据条件,选择一个分支继续执行。
循环结构:某一段代码需要被重复执行多次。
流程控制,就是通过指定的语句,修改程序的执行结构。 按照修改的不同的执行结构,流程控制语句可以分为:
分支流程控制语句:
循环流程控制语句:
略
if(condition){
//代码块1
}else{
//代码块2
}
逻辑: condition是一个boolean类型的变量, 或者一个boolean结果的表达式. 如果condition的值为true, 则代码段1执行, 否则, 代码段2执行
public class JavaSyntax {
public static void main(String[] args) {
int score = 99;
if (score>=60){
System.out.println("成绩及格!");
}else {
System.out.println("成绩不及格!");
}
}
}
if(condition1){
//代码块1
}else if(condition2){
//代码块2
}else{
//代码块3
}
逻辑: 先判断condition1, 如果condition1成立, 执行代码段1; 如果condition1不成立, 再判断condition2, 如果condition2成立, 执行代码段2, 否则执行代码段3
public class JavaSyntax {
public static void main(String[] args) {
// 1. 定义一个成绩
int score = 59;
// 2. 将成绩划分成不同的等级
// < 0 || > 100 : 错误成绩
// [0, 60): 不及格
// [60, 80): 良
// [80, 90): 中
// [90, 100]: 优
if (score < 0 || score > 100) {
System.out.println("错误成绩");
}
else if (score < 60) {
System.out.println("不及格");
}
else if (score < 80) {
System.out.println("良");
}
else if (score < 90) {
System.out.println("中");
}
else {
System.out.println("优");
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JuidFe04-1594201665245)(C:\Users\Ba-Ba\Desktop\wps156.jpg)]
switch(变量){
case值1:
//分支语句1
case值2:
//分支语句2
......
default:
}
程序逻辑:
public class Switch1 {
public static void main(String[] args) {
// 1. 定义一个变量, 记录第几个季节
int season = 1;
// 2. 根据season的值, 输出不同的季节
switch (season) {
case 1:
System.out.println("春天");
case 2:
System.out.println("夏天");
case 3:
System.out.println("秋天");
case 4:
System.out.println("冬天");
default:
System.out.println("这是一个适合学习的季节");
}
}
}
上述代码中, switch结构捕获变量season的值。 变量的值和第一个case是匹配的, 应该输出的结果是 “春天”。 但实际上的输出结果却是从春天开始的每一个输出。
因为在switch结构中有“穿透性”。
穿透性:
指的是, 当switch的变量和某一个case值匹配上之后, 将会跳过后续的case或者default的匹配,直接向后穿透。
为了杜绝穿透, 可以使用关键字 break:
这一段程序, season的值, 和case1匹配。 因此会输出“春天”, 然后向下穿透, 输出“夏天”。此时, 遇到了关键字 break。 将会结束穿透, 直接结束switch结构。
因此, 此时的输出结果是: 春天 夏天
略
for(循环初始部分;循环条件;循环迭代部分){
循环体
}
执行逻辑:
循环开始后, 先执行循环初始部分, 这一部分的代码只会执行一次。 在初始部分, 常常用于定义循环控制变量。
循环初始部分结束后, 判断循环条件。
如果循环条件成立, 执行循环体。
循环体执行结束后, 执行循环迭代部分。 这里常常用于对循环控制变量进行修改。
循环迭代部分执行结束, 再回到第二步, 判断循环条件。
如果循环条件成立, 继续执行循环体。 如果循环条件不成立, 循环结束。
循环体中的代码如果只有一句, 大括号可以省略。 但是从语法角度出发, 可以省略, 实际写程序的时候, 出于规范, 一般不省略。
public class For1 {
public static void main(String[] args) {
// 基础案例: 输出数字 1~100
// for (int number = 1; number <= 100; number++) {
// System.out.println(number);
// }
// 基础案例: 输出[1,100]范围内的奇数
// for (int num = 1; num <= 100; num++) {
// if (num % 2 != 0) {
// System.out.println(num);
// }
// }
// for (int num = 1; num <= 100; num += 2) {
// System.out.println(num);
// }
// 基础案例: 计算 1+2+3+4+...+100 = ?
// 思路:
// 定义一个变量, 用来记录累加的结果
// 再将所有的数字依次累加到这个和里面
int sum = 0;
for (int n = 1; n <= 100; n++) {
sum += n;
}
System.out.println(sum);
}
}
for循环小括号中的每一部分都可以省略不写, 但是分号不能省略。
for (int n = 1; n <= 100; n++)
System.out.println(n);
while(循环条件){
//循环体
}
程序逻辑:
public class JavaSyntax {
public static void main(String[] args) {
int n = 1;
while (n < 100) {
System.out.println(n);
}
}
}
do-while循环基本与while循环是一致的, 只是在执行逻辑上稍微有点区别:
public class JavaSyntax {
public static void main(String[] args) {
int n = 1;
do {
System.out.println(n);
} while (n < 100);
}
}
执行逻辑:
先执行循环体, 再判断循环条件是否成立。
如果循环条件成立, 继续执行循环体。
如果循环条件不成立, 结束循环。
break用在循环中, 表示无论循环条件是否成立, 立即结束循环。
public class JavaSyntax {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
if (i == 5) {
break;
}
System.out.println(i);
}
}
}
上述代码中, 如果i的值为5, 结束循环。 所以, 程序输出结果是
0
1
2
3
4
continue用在循环中, 表示立即停止本次循环, 开始下次循环。
public class JavaSyntax {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
if (i == 6) {
continue;
}
System.out.println(i);
}
}
}
当i的值是5的时候, 停止当次的循环, 立即进入下次循环。 所以, 程序输出的结果是
0
1
2
3
4
6
7
8
9
循环的实际使用中, 有些情况下, 需要使用到嵌套循环。 在嵌套循环中, 如果内层循环写了break或者continue, 此时只能作用于内层的循环。
public class Loop {
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
for(int j = 0;j<3;j++){
if (j == 2){
break;
}
System.out.println("i="+i+",j="+j);
}
}
}
}
上述代码中, 当内层循环j的值为2的时候, 结束内层循环。 所以, 程序的输出结果是
i = 0, j = 0
i = 0, j = 1
i = 1, j = 0
i = 1, j = 1
i = 2, j = 0
i = 2, j = 1
如果在内层循环中, 需要使用break或者continue关键字作用于外层的循环, 需要配合循环标签使用。
循环标签是一个标识符, 常写成全大写。 在循环的前面直接写标签, 添加一个冒号即可。
public class Loop {
public static void main(String[] args) {
loop:for (int i = 0; i < 3; i++) {
for(int j = 0;j<3;j++){
if (j == 2){
break loop;
}
System.out.println("i="+i+",j="+j);
}
}
}
}
上述代码中, break OUTER; 使得break关键字作用于指定的循环。 此时, 程序的输出结果是
i = 0, j = 0
i = 0, j = 1
在程序中, 有些情况下, 有些代码是需要被多次执行的。 如果需要在每次使用到这些逻辑的时候, 都去写代码实现, 此时代码将会非常的冗余, 不利于维护。
此时, 我们可以将这些需要被多次执行的逻辑单独包装起来, 在需要的时候直接调用即可。
方法, 就是为了实现这个需求而存在的。
方法, 其实就是一个实现特定功能的代码段, 方法中的逻辑可以被重复使用。
可以使用方法, 将需要多次执行的逻辑封装起来, 哪里需要,哪里直接调用即可。
降低了代码的冗余, 提高了代码的复用性与维护性。
[访问权限修饰符][其他修饰符]返回值类型 方法名字([参数列表]){
方法体
}
访问权限修饰符: 定义了方法的访问权限。
其他的修饰符: 定义了方法的其他的修饰。
返回值类型: 定义了方法返回的值的类型。
方法名字: 遵循小驼峰命名法的标识符。
方法体: 需要封装起来的, 可以被重复执行的代码段。
//这个方法中,封装了一个九九乘法表
//哪里需要乘法表,哪里调用即可
public static void diaplay(){
for (int line = 1;line<=9;line++){
for (int colume = 1;colume<=9;colume++){
System.out.println(colume+"x"+line+"="+colume*line+"\t");
}
}
}
方法写完后,其中的逻辑并不会立即执行。如果想让程序中的逻辑执行,需要调用方法。
调用方法, 直接使用方法的名字即可。
public class Test {
public static void main(String[] args) {
//方法的调用
diaplay();
}
//这个方法中,封装了一个九九乘法表
//哪里需要乘法表,哪里调用即可
public static void diaplay(){
for (int line = 1;line<=9;line++){
for (int colume = 1;colume<=9;colume++){
System.out.println(colume+"x"+line+"="+colume*line+"\t");
}
}
}
}
多数情况下, 方法与调用者之间需要进行数据的交互。 调用者必须提供必要的数据, 才能使用方法完成相应的功能。
例如:
ATM取款机, 封装了取钱的功能。 用户在使用ATM取款的时候, 需要插入银行卡。 此时, 就是使用者与功能集的数据交互。
自动贩卖机, 封装了贩卖的功能。 用户在使用自动贩卖机的时候, 需要选择购买的物品。 此时, 也是使用者与功能集的数据交互。
调用方法的时候, 需要将一些数据传入到方法中, 实现调用方与方法的数据交互。 这个被传入到方法中的数据, 被称为是 参数。
参数定义在方法的小括号中, 与变量的定义类似, 使用 [ 数据类型 标识符 ] 的方式定义。
//定义了一个打印若干分隔符的方法,数量由参数count定义
public static void diaplay(int count) {
for (int i = 0; i < count; i++) {
System.out.println("-");
}
System.out.println();
}
定义参数的注意事项:
参数定义在方法的参数列表中, 使用 [ 数据类型 标识符 ] 的形式定义。
如果需要定义多个参数, 多个参数之间以逗号分隔。
参数在定义的时候, 不允许赋初始值。
即便多个参数的类型都是相同的, 每一个参数也必须显式的定义类型。
在调用有参方法的时候, 必须给每一个参数进行赋值。 直接将这些值写入到小括号里面即可。
public class Test {
public static void main(String[] args) {
//方法的调用
diaplay(5);
}
//定义了一个打印若干分隔符的方法,数量由参数count定义
public static void diaplay(int count) {
for (int i = 0; i < count; i++) {
System.out.println("-");
}
System.out.println();
}
}
形参:
实参:
传参:
在进行方法调用的时候, 有些情况下是需要有逻辑执行结果的。
例如
ATM取款机, 用户在取完钱之后, 一定是要能够得到实际的钱的。 此时就是调用功能集得到的结果。
在前面定义方法的时候, 返回值类型部分, 写的是void。
void: 表示无,没有返回值。表示这个方法没有执行结果。
static int add(int a, int b){
return a+b;
}
注意事项
如果一个方法的返回值类型不是void, 则方法在执行结束之前, 必须要有return关键字返回一个结果。
表示方法的执行结果。
return关键字后面跟上方法的执行结果, 这个值的类型, 必须和方法定义中的返回值类型一致。
static int add(int a, int b){
return a+b; //将a+b的运算结果,作为整个方法的执行结果。
}
表示结束方法的执行
在一个返回值类型为void的方法中, 也可以使用return关键字。 此时, return后面什么都不要写。
return写在方法中, 表示结束方法的结束。
static int add(int a, int b){
return a+b;
//return执行后,后面的所有代码都不执行。
//方法结束。
}
在一个类的方法中, 如果多个方法满足如下条件, 则他们之间的关系就是重载
方法名相同
参数不同
注意: 方法的重载, 与返回值没有关系!
public class Test {
public static void calculate() {
}
public static void calculate(int a) {
}
public static void calculate(int a, int b) {
}
public static String calculate(String x, String y) {
return x + y;
}
}
调用重载方法的时候, 使用实参区分调用不同的方法。
public class Test {
public static void calculate() {
}
public static void calculate(int a) {
}
public static void calculate(int a, int b) {
}
public static String calculate(String x, String y) {
return x + y;
}
public static void main(String[] args) {
calculate();//无参方法调用
calculate(3);//一个参数方法调用
calculate(3, 4);//两个整型参数方法调用
calculate("a", "b");//两个字符串型参数方法调用
}
}
如何存储100名学生的成绩
如何让100名学生成绩全部+1
数组, 是一个数据容器。 可以存储若干个相兼容的数据类型的数据。
在上述案例中, 存储100名学生的成绩, 可以用数组来完成。 将这100个成绩存入一个数组中。 此时对这些数据进行统一操作的时候, 直接遍历数组即可完成。
double[] arrar1;
int[] array2;
String[] array3
实例化数组: 其实就是在内存中开辟空间, 用来存储数据。
public class Test {
public static void main(String[] args) {
// 实例化了一个数组, 可以存储5个数据
// 此时数组中的元素就是默认的5个0
int[] array1 = new int[5];
// 实例化了一个数组, 默认存储的是 1, 2, 3, 4, 5
// 此时数组的长度, 由这些存储的数据的数量可以推算出来为5
int[] array2 = new int[] {
1, 2, 3, 4, 5 };
// 实例化了一个数组, 默认存储的是 1, 2, 3, 4, 5
// 相比较于第二种写法, 省略掉了 new int[]
int[] array3 = {
1, 2, 3, 4, 5 };
}
}
数组的实例化的时候,需要使用到关键字new
数组, 其实是在堆上开辟的连续的空间。 例如 new int[5],就是在堆上开辟5个连续的4字节空间。
然后, 将堆上的内存地址, 给栈上的引用进行赋值。
下标, 就是数组中的元素在数组中存储的位置索引。
注意: 数组的下标是从0开始的, 即数组中的元素下标范围是 [0, 数组.length - 1)
访问数组中的元素, 需要使用下标访问。
public class Test {
public static void main(String[] args) {
//实例化一个数组
int[] array = {
1, 2, 3, 4, 5 };
//访问数组中的元素
array[2] = 300;//将数组中的第2个元素修改为300
System.out.println(array[2]);//此时输出的是300
}
}
在访问数组中的元素的时候, 注意下标的问题!
如果使用错误的下标访问数组中的元素, 将会出现 ArrayIndexOutOfBoundsException 异常!
public class Test {
public static void main(String[] args) {
//实例化一个数组
int[] array = {
1, 2, 3, 4, 5 };
//访问数组中的元素
array[10] = 300;//访问数组中下标为10的元素,此时数组的最大下标为4,会出现异常
}
}
数组遍历: 其实就是按照数组中元素存储的顺序, 依次获取到数组中的每一个元素。
思路: 循环依次获取数组中的每一个下标, 再使用下标访问数组中的元素
public class Test {
public static void main(String[] args) {
//实例化一个数组
int[] array = {
1, 2, 3, 4, 5};
//使用下标遍历数组
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
思路: 依次使用数组中的每一个元素, 给迭代变量进行赋值。
public class Test {
public static void main(String[] args) {
//实例化一个数组
int[] array = {
1, 2, 3, 4, 5};
//使用下标遍历数组
for (int ele : array) {
System.out.println(ele);
}
}
}
如果需要在遍历的同时, 获取到数组中的元素下标, 需要使用下标遍历法。
如果需要在遍历的同时, 修改数组中的元素, 需要使用下标遍历法。
如果仅仅是想要获取数组中的每一个元素, 不需要下标, 也不需要修改数组中的元素, 使用增强for循环。 因为这种方式, 遍历的效率比下标遍历法高。
排序,即排列顺序,将数组中的元素按照一定的大小关系进行重新排列。
在Java中, 常见的排序有:
选择排序:固定值与其他值依次比较大小,互换位置。
冒泡排序:相邻的两个数值比较大小,互换位置。
JDK排序:java.util.Arrays.sort(数组); // JDK提供默认的升序排序
…
有兴趣的可自行百度。
可以接收多个类型相同的实参,个数不限,使用方式与数组相同。
在调用方法的时候, 实参的数量可以写任意多个。
数据类型…形参名(必须放到形参列表的最后位,且只能有一个)
ststic void show(int...parameters){
//方法体
}
public class Test {
public static void main(String[] args) {
// int[] array = { 1, 2, 3 };
// showArray(array);
// 如果一个方法的参数,使用 ... 来定义,可以将这个数组中的元素,直接写到实参列表中
// 注意事项:
// 1. 在形参列表中,可变长度的参数,必须在形参列表的最后位
// 2. 一个形参列表中,只能存在一个...修饰的可变长度参数
showArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
}
public static void showArray(int a, int... array) {
for (int i : array) {
System.out.println(i + ",");
}
}
}
二维数组, 其实就是数组中嵌套数组。
二维数组中的每一个元素都是一个小的数组。
理论上来讲, 还可以有三维数组、四维数组, 但是常用的其实就是二维数组。
public class Array {
public static void main(String[] args) {
// 1. 实例化一个二维数组
// 第一个中括号中的3: 二维数组中包含了三个一维数组
// 第二个中括号中的5: 二维数组中的每一个一维数组长度为5
int[][] array = new int[3][5];
// 使用双下标访问数组中的元素
array[0][3] = 10;
// 这里得到的,是二维数组的长度,3
System.out.println(array.length);
// 2. 实例化一个二维数组
// 第一个中括号中的3: 二维数组中包含了三个一维数组
// 第二个中括号中什么都没有,代表现在二维数组中的三个元素是 null
int[][] array2 = new int[3][];
array2[0] = new int[]{
1, 2, 3};
// 3. 通过初始值实例化一个二维数组
int[][] array3 = {
{
1, 2, 3}, {
1, 2, 3, 4, 5}, {
2, 3, 4}};
}
}
方法 | 描述 |
---|---|
copyOf(int[] array, int newLength) | 从原数组中拷贝指定数量的元素,到一个新的数组中,并返回这个新的数组 |
copyOfRange(int[] array, int from, int to) | 从原数组中拷贝指定范围 [from, to) 的元素,到一个新的数组中,并返回这个新的数组 |
equals(int[] array1, int[] array2) | 判断两个数组是否相同 |
fill(int[] array, int element) | 使用指定的数据,填充数组 |
sort(int[] array) | 对数组进行排序(升序) |
binarySearch(int[] array, int element) | 使用二分查找法,到数组中查询指定的元素出现的下标 |
toString(int[] array) | 将数组中的元素拼接成字符串返回 |
文章浏览阅读2.7k次,点赞2次,收藏4次。如何不充钱就可以穿透多个端口?./ngrok authtoken 授权码之前这个操作的生成的yml文件中修改 端口可添加多个addr:port端口可随意配置_ngrok多个端口
文章浏览阅读5.9k次。char转uint8_t:static int char2uint(char *input, uint8_t *output){ for(int i = 0; i < 24; i++) { output[i] &= 0x00; for (int j = 1; j >= 0; j--) { char hb = input[i*2 + 1 - j]; if (hb >= '0' &..._char转uint8_t
文章浏览阅读6.5k次,点赞5次,收藏13次。陀螺仪允许您在任何给定时刻确定Android设备的角速度。简单来说,它告诉您设备绕X,Y和Z轴旋转的速度有多快。最近,即使是预算手机正在制造,陀螺仪内置,增强现实和虚拟现实应用程序变得如此受欢迎。通过使用陀螺仪,您可以开发可以响应设备方向的微小更改的应用程序。创建陀螺仪对象和管理器manager// Register it, specifying the polling interv..._安卓陀螺仪多少才算静止
文章浏览阅读4.7k次,点赞3次,收藏16次。当我们要分析一个lib库里的代码时,首先需要判断这是一个静态库还是一个导入库。库类型判断lib文件其实是一个压缩文件。我们可以直接使用7z打开lib文件,以查看里面的内容。如果里面的内容是obj文件,表明是静态库。如果里面的内容是dll文件,表明是导入库。导入库里面是不包含代码的,代码包含在对应的dll文件中。从lib中提取obj静态库是一个或者多个obj文件的打包,这里有两个方法从中提取obj:Microsoft 库管理器 7z解压Microsoft 库管理器(li_libtersafe
文章浏览阅读5.3k次,点赞3次,收藏3次。了解一下,省的脑壳痛 桥接模式对应的虚拟网络名称“VMnet0” 桥接模式下,虚拟机通过主机的网卡进行通信,若物理主机有多块网卡(有线的和无线网卡),应选择桥结哪块物理网卡桥接模式下,虚拟机和物理主机同等地位,可以通过物理主机的网卡访问外网(局域网),一个局域网的其他计算机可以访问虚拟机。为虚拟机设置一个与物理网卡在同个网段的IP,则虚拟机就可以与物理主机以及局域..._linux 查询网络适配器
文章浏览阅读3.4w次,点赞77次,收藏438次。# 前言2020 12月 1+X Web 前端开发中级 模拟题大致就更这么多,我的重心不在这里,就不花太多时间在这里面了。但是,说说1+X Web前端开发等级考证这个证书,总有人跑到网上问:这个证书有没有用? 这个证书含金量高不高?# 关于考不考因为这个是工信部从2019年才开始实施试点的,目前还在各大院校试点中,就目前情况来看,知名度并不是很高,有没有用现在无法一锤定音,看它以后办的怎么样把,软考以前也是慢慢地才知名起来。能考就考吧,据所知,大部分学校报考,基本不用交什么报考费(小部分学校,个别除._1+xweb前端开发中级
文章浏览阅读1.7k次。组织战略是组织实施各级项目管理,包括项目组合管理、项目集管理和项目管理的基础。只有从组织战略的高度来思考,思考各个层次项目管理在组织中的位置,才能够理解各级项目管理在组织战略实施中的作用。同时战略管理也为项目管理提供了具体的目标和依据,各级项目管理都需要与组织的战略保持一致。..._项目组织的具体形态的是战略管理层
文章浏览阅读1k次。目录基本统计量色彩空间变换亮度变换函数白平衡图像过曝的评价指标多视影像因曝光条件不一而导致色彩差异,人眼可以快速区分影像质量,如何利用图像信息辅助算法判断影像优劣。基本统计量灰度均值方差梯度均值方差梯度幅值直方图图像熵p·log(p)色彩空间变换RGB转单通道灰度图像 mean = 225.7 stddev = 47.5mean = 158.5 stddev = 33.2转灰度梯度域gradMean = -0.0008297 / -0.000157461gr_图像颜色质量评价
文章浏览阅读1.4k次。Simpson's rule for numerical integrationZ = SIMPS(Y) computes an approximation of the integral of Y via the Simpson's method (with unit spacing). To compute the integral for spacing different from one..._matlab利用幸普生计算积分
文章浏览阅读1.2w次,点赞28次,收藏61次。Hugging face 资源很不错,可是国内下载速度很慢,动则GB的大模型,下载很容易超时,经常下载不成功。很是影响玩AI的信心。经过多次测试,终于搞定了下载,即使超时也可以继续下载。真正实现下载无忧!究竟如何实现?且看本文分解。_huggingface_hub
文章浏览阅读3.5k次,点赞2次,收藏7次。其中 `DEFAULT CHARSET` 和 `COLLATE` 分别指定了表的默认编码和排序规则。其中 `DEFAULT CHARACTER SET` 指定了数据库的默认编码。其中 `Collation` 列指定了字段的排序规则,这也是字段的默认编码。此命令将更改表的默认编码和排序规则。此命令将更改字段的编码和排序规则。此命令将更改数据库的默认编码。_查看数据库编码
文章浏览阅读1.3k次,点赞7次,收藏24次。本文深入探讨了集成学习及其在随机森林中的应用。对集成学习的基本概念、优势以及为何它有效做了阐述。随机森林,作为一个集成学习方法,与Bagging有紧密联系,其核心思想和实现过程均在文中进行了说明。还详细展示了如何在Sklearn中利用随机森林进行建模,并对其关键参数进行了解读,希望能帮助大家更有效地运用随机森林进行数据建模。_bagging数据集