Struct(结构)
一、 顺序结构:
顺序结构是任何一个算法都离不开的一种基本算法结构(语句与语句、框与框之间是按从上到下的顺序进行的。
package com.java.struct;
public class ShunXuDemo {
public static void main(String[] args) {
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);
/*
1
2
3
4
5
/*
//顺序结构是任何一个算法都离不开的一种基本算法结构(语句与语句、框与框之间是按从上到下的顺序进行的)
}
}
二、选择结构:
2.0 if单选择结构
语法格式:
if(布尔表达式){
//如果布尔表达式为true将执行的语句
}
例子:
package com.java.struct;
import java.util.Scanner;
public class IfDemo01 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入内容:");
String s = scanner.nextLine();
//equals 判断字符串是否相等
if (s.equals("hello world")){
System.out.println(true); //如果是的话...
}
System.out.println(false); //否则是...
scanner.close();
}
}
2.1 if双选择结构
语法格式:
if(布尔表达式){
//如果布尔表达式的值为true
}else{
//如果布尔表达式的值为false
}
例子:
package com.java.struct;
//if双选择结构
import java.util.Scanner;
public class IfDemo02 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//练习题:成绩大于60为及格,小于60不及格
System.out.println("请输入成绩:");
int score = scanner.nextInt(); //score是成绩的意思
if (score>60){
System.out.println("及格");
}else {
System.out.println("不及格");
}
scanner.close();
}
}
2.2 if多选择结构
语法格式:
if(布尔表达式 1){
//如果布尔值表达式 1 的值为true执行代码
}else if(布尔表达式 2){
//如果布尔值表达式 2 的值为true执行代码
}else if(布尔表达式 3){
//如果布尔值表达式 3 的值为true执行代码
}else {
//如果以上布尔值表达式的值都不为true执行
}
if语句至多有1个else语句,else语句在所有的else if 语句之后;
if语句可以有若干个else if 语句,它们必须在else语句之前;
一旦其中一个为蓝色 if语句检测为true,其他的else if以及else语句都将跳过执行。
例子:
package com.java.struct;
//if多选择结构
import java.util.Scanner;
public class IfDemo03 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩:");
int i = scanner.nextInt();
if (i==100){
System.out.println("恭喜满分!");
}else if(i>90 && i<100){
System.out.println("A");
}else if(i>80 && i<90){
System.out.println("B");
}else if(i>70 && i<80){
System.out.println("C");
}else if(i>60 && i<70){
System.out.println("D");
}else if(i<60 && i>=0){
//写代码要严谨,提前把代码的漏洞补好,设定好范围。
System.out.println("不合格");
}else {
System.out.println("成绩不合法");
}
scanner.close();
}
}
2.3 嵌套的if结构
(因为不常用,了解就好了。)
使用嵌套的 if…else 语句是合法的。也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if语句。你可以像 if 语句一样嵌套 else if…else。
语法格式:
if(布尔表达式 1){
//如果布尔值表达式 1 的值为true执行代码
if(布尔表达式 2){
//如果布尔值表达式 2 的值为true执行代码
}
}
3.0 Switch多选择结构
(1) 多选择结构还有一个实现的方式就是switch case 语句。switch case 语句判断一个变量与一系列值中某个值是否相等,每个值称为一个分支
(2)switch语句中的变量类型可以是:
- byte、short、int或者char。
- 从JavaSE 7 开始:switch支持字符串String类型了
- 同时 case 标签必须为字符串常量或者字面量。
语法格式:
switch(expression){
case value :
//语句
break;//可选
case value :
//语句
break;//可选
//你可以有任意数量的case语句
default : //可选
//语句
}
例子:
package com.java.struct;
public class SwitchDemo01 {
public static void main(String[] args) {
//case穿透 switch 匹配一个具体的值
char grade = 'A';
switch (grade){
case 'A' :
System.out.println("优秀"); //有break,结果为优秀
break; //可选
case 'B' :
System.out.println("良好");
//没有break就会发生 case穿透 的现象,结果为良好、及格到重开吧!
case 'C' :
System.out.println("及格");
case 'D' :
System.out.println("再接再厉");
case 'E' :
System.out.println("重开吧!");
default :
System.out.println("未知信息");
}
}
}
3.1 String(字符串)
package com.java.struct;
public class SwitchDemo02 {
public static void main(String[] args) {
String name = "hong";
switch (name){
case "xxx":
System.out.println("xxx");
break;
case "hong":
System.out.println("1x1");
break;
default :
System.out.println("000");
}
}
}
3.2 拓展(反编译)
字符的本质还是数字、每一个对象都有一个hascode
switch就是通过对象(字符)的hascode值是否一致来比较的
- 打开结构,复制地址
- 搜素地址,并打开文件夹
- 复制目标文件.class
- 回到IDEA选择目标文件打开OPen In Explorer
- 将文件粘贴,搞定!
反编译的结果:
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
package com.java.struct;
public class SwitchDemo02 {
public SwitchDemo02() {
}
public static void main(String[] args) {
String name = "xxx";
byte var3 = -1;
switch(name.hashCode()) {
case 119160:
if (name.equals("xxx")) {
var3 = 0;
}
break;
case 3208448:
if (name.equals("hong")) {
var3 = 1;
}
}
switch(var3) {
case 0:
System.out.println("xxx");
break;
case 1:
System.out.println("1x1");
break;
default:
System.out.println("000");
}
}
}
二、循环结构:
4.0 while循环结构
while是最基本的循环,它的方法结构为:
while( 布尔表达式 ){
//循环内容
}
- 只有布尔表达式为true,循环就会一直下去。
- 我们大多数情况是会让循环停止下来的,所以我们需要一个让表达式失效的方式来结束循环。
- 少部分情况需要循环一直运行,比如服务器的请求响应监听等。
- 循环条件一直为true就会造成无限循环【死循环】,我们正常的业务编程中应该尽量避免死循环。它会影响程序性能或者造成程序卡死崩溃!
例子:
package com.java.struct;
public class WhileDemo01 {
public static void main(String[] args) {
//输出1-1000
int a = 0;
while (a<1000){
a++; //输出的下一项都加一
System.out.println(a);
//成功输出1到1000
}
}
}
4.1 while(true){} 死循环
package com.java.struct;
public class WhileDemo02 {
public static void main(String[] args) {
//无限循环(死循环)
while(true){
System.out.println("2222");
//在正常业务中,要避免用死循环
}
}
}
4.2 例题:利用循环计算1+2+3+…+100=?
package com.java.struct;
public class WhileDemo03 {
public static void main(String[] args) {
//输出1+2..+100的结果
int a = 0; //设置初始值
int sum = 0; //设置总值
while (a<=100){
sum = sum + a;
a++;
}
System.out.println(sum); //输出sum,就可以看到结果5050了
}
}
4.3 do while循环结构
- 对于while语句而言,如果不满足条件,则不能进入循环。但有时候我们需要即使不满足条件,也至少执行一次。
- do…while 循环和 while 循环相似,不同的是,do…while 循环至少执行一次。
语法格式:
do {
//代码语句
}while (布尔表达式);
例子:
package com.java.struct;
public class DoWhileDemo01 {
public static void main(String[] args) {
int a = 0; //设置初始值
int sum = 0; //设置总值
do {
sum = sum + a; //代码语句
a++;
} while (a<=100);
System.out.println(sum); //5050
}
}
4.4 while与do while的区别
1. while先判断后执行,dowhile是先执行后判断!
2. do…while总是保证循环体会被至少执行一次!
package com.java.struct;
public class DoWhileDemo02 {
public static void main(String[] args) {
//了解while先判断后执行,dowhile先执行后判断!
//通过对比得出:dowhile至少执行一次
int a = 0;
while (a<0){
System.out.println(a);
a++;
} //因为a等于0而不小于0,所以判断错误,不执行(while先判断后执行)
System.out.println("========================");
do {
System.out.println(a);
a++;
} while (a<0);
//执行结果为0,后续判断错误了。执行了一次(dowhile先执行后判断)
}
}
5.0 for循环结构
- 虽然所有循环结构都可以用while或者 do…while表示,但Java提供了另一种语句——for循环,使一些循环结构变得更加简单。
- for循环语句是支持迭代的一种通用结构,是最有效、最灵活的循环结构。
- for循环执行的次数是在执行前就确定的。
快捷键:输入数字.for或者fori,回车
语法格式:
for(初始化; 布尔表达式 ; 更新){
//代码语句
}
例子:
package com.java.struct;
public class ForDemo01 {
public static void main(String[] args) {
//输出0到100的数
//方法一,while
int a = 0; //初始化条件
while (a<=100){ //条件判断
System.out.println(a); //循环体
a+=2; //迭代
}
System.out.println("while循环结束!");
//方法二(优先)
for (int i = 0; i <= 100; i++) {
//初始化//条件判断//迭代
System.out.println(i);//循环体
}
System.out.println("for循环结束!");
//从结果得出,for比while的可读性更高,且方便
//for快捷键,输入100.for回车
}
}
5.1 for死循环
for ( ; ; ) {
System.out.println();
}
5.2 练习1
计算0到100的奇数和偶数的和
package com.java.struct;
public class ForDemo02 {
public static void main(String[] args) {
//练习1,计算0到100的奇数和偶数的和
int oddSum = 0;
int eveSum = 0;
for (int i = 0; i <= 100; i++) {
if (i%2!=0){ //奇数 , %取余 ,!=不等于
/*
i除以2的余数不等于0时,成立
*/
oddSum+=i; //oddSum = oddSum + i;
} else { //偶数
eveSum+=i;
}
}
System.out.println("奇数的和:"+oddSum);
System.out.println("偶数的和:"+eveSum);
}
}
5.3 练习2
用while或for循环输出1到1000之间能被5整除的数,并且每行输出3个
package com.java.struct;
public class ForDemo03 {
public static void main(String[] args) {
//用while或for循环输出1到1000之间能被5整除的数,并且每行输出3个
//for
for (int i = 0; i <= 1000; i++) {
if (i % 5 == 0) {
System.out.print(i + "\t"); // \t制表符
}
/*
println 输出完会换行
print 输出完不会换行
*/
if (i%(5*3)==0 && i!=0) { //每行
System.out.println();
//System.out.print("\n");
}
}
/*
i取余后,乘以15等于0的话输出换行(每行3个)
(因为题目要求是1到1000之间可以被5整除的数,且每行3个)
(所以3*5可以认为每行有3个可以被5整除的数,而能整除的数取余后一定是0,相乘结果为0)
完美达成条件
*/
}
}
5.4 打印九九乘法表
- 我们先试着打印第一列
- 把固定的1再用一个循环包起来
- 去掉重复项,i1<=i
- 调整样式
package com.java.struct;
public class ForDemo04 {
public static void main(String[] args) {
//打印九九乘法表
for (int i = 1; i <= 9; i++) {
for (int i1 = 1; i1 <= i; i1++) {
System.out.print(i+"*"+i1+"="+(i*i1) + "\t"); //换行
}
System.out.println(); //换列
}
}
}
//结果:
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
进程已结束,退出代码0
5.5 打印三角形
package com.java.struct;
public class TestDemo01 {
public static void main(String[] args) {
//打印三角形,5行
for (int i = 1; i <= 5; i++) {
for (int i1 = 5; i1 >= i; i1--) {
System.out.print(" ");
//第一步做一个倒直角三角形,再输出成空格为后面提供条件
}
for (int i2 = 1; i2 <= i; i2++) {
//再做个相反的正的
System.out.print("*");
}
for (int i3 = 1; i3 < i; i3++) {
//最后做个相对应的
System.out.print("*");
}
System.out.println();
}
}
}
//结果:
*
***
*****
*******
*********
进程已结束,退出代码0
6.0 增强for循环
(目前了解就好,之后数组再重点使用)
- Java5引入了一种主要用于数组或者集合的增强型for循环。
语法格式:
for(声明语句 : 表达式)
{
//代码句子
}
- 声明语句:声明新的局部变量,该变量的类型必须与数组元素的类型匹配。其作用域限定在循环语句块,其值与此时数组元素的值相等。
- 表达式:表达式是要访问的数组名,或者是返回值为数组的方法。
6.1 拓展:break与continue
- break:在任何循环语句的主体部分,均可用break控制循环的流程。break用于强行退出循环,不执行循环中剩下的语句。(break也在switch中使用)
- continue 语句用在循环语句体中,用于终止某次循环过程,即跳过循环体中尚未执行的语句,接着进行下一次是否执行循环的判定。