在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) | 将数组中的元素拼接成字符串返回 |
文章浏览阅读1.3w次。转载自 http://www.miui.com/thread-2003672-1-1.html 当手机在刷错包或者误修改删除系统文件后会出现无法开机或者是移动定制(联通合约机)版想刷标准版,这时就会用到线刷,首先就是安装线刷驱动。 在XP和win7上线刷是比较方便的,用那个驱动自动安装版,直接就可以安装好,完成线刷。不过现在也有好多机友换成了win8/8.1系统,再使用这个_mt65驱动
文章浏览阅读1k次。SonarQube是一个代码质量管理平台,可以扫描监测代码并给出质量评价及修改建议,通过插件机制支持25+中开发语言,可以很容易与gradle\maven\jenkins等工具进行集成,是非常流行的代码质量管控平台。通CheckStyle、findbugs等工具定位不同,SonarQube定位于平台,有完善的管理机制及强大的管理页面,并通过插件支持checkstyle及findbugs等既有的流..._sonar的客户端区别
文章浏览阅读3.4k次,点赞2次,收藏27次。神经图灵机是LSTM、GRU的改进版本,本质上依然包含一个外部记忆结构、可对记忆进行读写操作,主要针对读写操作进行了改进,或者说提出了一种新的读写操作思路。神经图灵机之所以叫这个名字是因为它通过深度学习模型模拟了图灵机,但是我觉得如果先去介绍图灵机的概念,就会搞得很混乱,所以这里主要从神经图灵机改进了LSTM的哪些方面入手进行讲解,同时,由于模型的结构比较复杂,为了让思路更清晰,这次也会分开几..._神经图灵机方法改进
文章浏览阅读2.8k次。一、模型迭代方法机器学习模型在实际应用的场景,通常要根据新增的数据下进行模型的迭代,常见的模型迭代方法有以下几种:1、全量数据重新训练一个模型,直接合并历史训练数据与新增的数据,模型直接离线学习全量数据,学习得到一个全新的模型。优缺点:这也是实际最为常见的模型迭代方式,通常模型效果也是最好的,但这样模型迭代比较耗时,资源耗费比较多,实时性较差,特别是在大数据场景更为困难;2、模型融合的方法,将旧模..._模型迭代
文章浏览阅读2.3k次。1、前言上传图片一般采用异步上传的方式,但是异步上传带来不好的地方,就如果图片有改变或者删除,图片服务器端就会造成浪费。所以有时候就会和参数同步提交。笔者喜欢base64图片一起上传,但是图片过多时就会出现数据丢失等异常。因为tomcat的post请求默认是2M的长度限制。2、解决办法有两种:① 修改tomcat的servel.xml的配置文件,设置 maxPostSize=..._base64可以装换zip吗
文章浏览阅读1k次,点赞17次,收藏22次。Opencv自然场景文本识别系统(源码&教程)_opencv自然场景实时识别文字
文章浏览阅读1.3k次。拷贝虚拟机文件时间比较长,因为虚拟机 flat 文件很大,所以要等。脚本完成后,以复制虚拟机文件夹。将以下脚本内容写入文件。_exsi6.7快速克隆centos
文章浏览阅读2k次。本文主要实现基于二度好友的推荐。数学公式参考于:http://blog.csdn.net/qq_14950717/article/details/52197565测试数据为自己随手画的关系图把图片整理成文本信息如下:a b c d e f yb c a f gc a b dd c a e h q re f h d af e a b gg h f bh e g i di j m n ..._本关任务:使用 spark core 知识完成 " 好友推荐 " 的程序。
文章浏览阅读367次。南京大学高级程序设计期末复习总结,c++面向对象编程_南京大学高级程序设计
文章浏览阅读3.1k次,点赞2次,收藏12次。实现朴素贝叶斯分类器,并且根据李航《统计机器学习》第四章提供的数据训练与测试,结果与书中一致分别实现了朴素贝叶斯以及带有laplace平滑的朴素贝叶斯%书中例题实现朴素贝叶斯%特征1的取值集合A1=[1;2;3];%特征2的取值集合A2=[4;5;6];%S M LAValues={A1;A2};%Y的取值集合YValue=[-1;1];%数据集和T=[ 1,4,-1;..._朴素贝叶斯 matlab训练和测试输出
文章浏览阅读1.6k次。Markdown 文本换行_markdowntext 换行
文章浏览阅读6.7w次,点赞2次,收藏37次。win10 2016长期服务版激活错误解决方法:打开“注册表编辑器”;(Windows + R然后输入Regedit)修改SkipRearm的值为1:(在HKEY_LOCAL_MACHINE–》SOFTWARE–》Microsoft–》Windows NT–》CurrentVersion–》SoftwareProtectionPlatform里面,将SkipRearm的值修改为1)重..._错误: 0xc0000022 在运行 microsoft windows 非核心版本的计算机上,运行“slui.ex