for循环结构
Java流程控制
1.顺序结构
Java的基本结构就是顺序结构，代码是按照顺序一句一句来执行
顺序结构是最简单的算法结构
2.选择结构
if单选择结构:
if(布尔表达式){
//如果布尔表达式为true将执行的语句
}
if双选择结构:
if(布尔表达式){
//如果布尔表达式的值为true
}else{
//如果布尔表达式的值为false
}
if多选择结构:
if(){
}else if(){
}else if(){
}else if(){
}else{
}
public class If {
public static void main(String[] args) {
//分数大于60就是及格，分数小于60就是不及格
System.out.println("请输入成绩：");
Scanner scanner = new Scanner(System.in);
/*
if语句至少有1个else语句，else语句在所有的else if语句之后
if语句可以有若干个else if语句，他们必须在else语句之前
一旦其中一个else if语句检测为true，其他的else if以及else语句都将跳过执行
*/
int score = scanner.nextInt();
if (score == 100){
System.out.println("恭喜满分");
}else if (score < 100 && score>= 90){
System.out.println("A级");
}else if (score < 90 && score>= 80){
System.out.println("B级");
}else if (score < 80 && score>= 70){
System.out.println("C级");
}else if (score < 70 && score>= 60){
System.out.println("D级");
}else if (score < 60 && score>= 0){
System.out.println("不及格");
}else {
System.out.println("成绩不合法");
}
scanner.close();
}
}
嵌套的if结构:
if(布尔表达式1){
//如果布尔表达式1的值为true执行代码
if(如果布尔表达式2){
//如果布尔表达式2的值为true执行代码
}
}
switch多选择结构：
JDK7新特性expression表达式可以是字符串，因为字符串的本质还是数字
反编译 Java---class(字节码文件)-----反编译（IDEA）
switch(expression){
case value:
//语句
break;//可选
case value:
break;//可选
//可以有任意数量的case语句
default: //可选
//语句
}
public class Switch {
public static void main(String[] args) {
//case穿透
char grade = 'A';
switch (grade){
case 'A':
System.out.println("优秀");
break;//没有break的话会形成case穿透，下面所有的case都会输出
case 'B':
System.out.println("良好");
case 'C':
System.out.println("及格");
case 'D':
System.out.println("再接再厉");
case 'E':
System.out.println("挂科");
default:
System.out.println("未知等级");
}
}
}
3.循环结构：break & continue
while循环：
while(布尔表达式){
//循环内容
}
只要布尔表达式为true，循环就会一直执行下去
到多数情况会让循环停止下来，需要一个表达式失效的方式来结束循环
少数情况需要循环一直执行下去，如服务器的请求响应监听
循环条件为true会造成无限循环（死循环），正常业务逻辑应该避免死循环
public class While {
public static void main(String[] args) {
//输出1-100
int i = 0;
while (i < 100){
i++;
System.out.println(i);
}
}
}
public class DoWhile {
public static void main(String[] args) {
//死循环
while (true){
//等待客户端连接
//定时检查
//........
}
}
}
while循环计算1到100的和：
public class While {
public static void main(String[] args) {
int sum = 0;
int i = 0;
while (i <= 100){
sum = sum + i;
i++;
}
System.out.println(sum);
}
}
do...while循环
对于while循环如果不满足条件则不能进入循环，但有时候需要不满足条件也至少执行一次
do...while循环和while循环相似，不同的是，do....while循环至少会执行一次
do{
//代码语句
}while（布尔表达式）
while与do...while的区别
while先判断后执行，do...while是先执行后判断
do...while总是保证循环体会被至少执行一次
public class DoWhile {
public static void main(String[] args) {
int sum = 0;
int i = 0;
do {
sum = sum + i;
i++;
}while(i <= 100);
System.out.println(sum);
}
}
public class DoWhile {
public static void main(String[] args) {
int i = 0;
do {
System.out.println(i);
}while(i < 0);
System.out.println("=============================");
while(i < 0){
System.out.println(i);
}
}
}
for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构
for循环执行的次数在执行前就确定的。
for(初始化;布尔表达式;更新){
//代码语句
}
public class ForCycle {
public static void main(String[] args) {
//初始化 //条件判断 //迭代
for (int i = 1; i <= 100; i++) {
System.out.println(i);
}
System.out.println("for循环结束");
/*
关于for循环有几点说明：
最先执行初始化步骤，可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句
然后，检测布尔表达式的值，如果为true，循环体被执行，如果为false，循环终止，开始执行循环体后面的语句
执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）
再次检测布尔表达式，循环执行上面的过程
*/
}
}
for(; ;){} //死循环
计算0到100之间奇数、偶数的和分别为多少
public class For {
public static void main(String[] args) {
//计算0到100之间的奇数和偶数的和
int oddSum = 0;
int evenSum = 0;
for (int i = 0; i <= 100; i++) {
if (i % 2 != 0){ //奇数判断
oddSum = oddSum + i;
}else{
evenSum = evenSum + i; //偶数判断
}
}
System.out.println("奇数的和：" + oddSum);
System.out.println("偶数的和" + evenSum);
}
}
用while或for循环输出1-100之间能被5整除的数，并且每行输出3个
public class DoWhile {
public static void main(String[] args) {
//用while或for循环输出1-100之间能被5整除的数，并且每行输出3个
for (int i = 1; i <= 100; i++) {
if (i % 5 == 0){
System.out.print(i + "\t");
}
if (i % (5*3) == 0){ //每3个换一行
System.out.println(); //与这种写法结果一样都是输出完换行System.out.print("\n");
//println输出完换行
//print输出完不换行
}
}
}
}
Java5中引入了用于数组的增强型for循环
for循环打印9*9乘法表
/*
打印9*9乘法表
*/
public class ForTable {
public static void main(String[] args) {
//1.先打印第一列
//2.把固定的1用一个循环包起来
//3.去掉重复项
//调整样式
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + "*" + i + "=" + i*j + "\t");
}
System.out.println();
}
}
}
增强for循环
用于数组或集合的for循环
public class StrongFor {
public static void main(String[] args) {
int[] numbers = {10,20,30,40,50};//定义了一个数组
//遍历数组的元素
for (int x:numbers){
System.out.println(x);
}
}
}
break、continue
break用于强行退出循环，不执行循环中剩余语句
continue用于终止某次循环，跳过循环中尚未执行语句，接着进行下一次是否执行的判定
public class BreakCycle {
public static void main(String[] args) {
int i = 0;
while(i<100){
if (i == 30) {
break;
}
i++;
System.out.println(i);
}
System.out.println("跳出while循环");
}
}
public class ContinueCycle {
public static void main(String[] args) {
int i = 0;
while (i<100){
i++;
if(i%10 == 0){
System.out.println();
continue;
}
System.out.print(i+"\t");
}
}
}
打印三角形：5行
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
for (int j = 5; j >= i; j--) {
System.out.print(" ");
}
for (int j = 1;j <= i;j++){
System.out.print("*");
}
for (int j = 1;j < i;j++){
System.out.print("*");
}
System.out.println();
}
}
Java方法：
Java方法是语句的集合，是解决一类问题有序步骤组合
//main方法
public static void main(String[] args) {
//实际参数：实际调用传递的参数
int add = add(1, 2);
}
//加法
//形式参数用来定义方法
public static int add(int a,int b){
return a + b;
}
方法的定义：
方法包含方法头和方法体
修饰符 返回值类型 方法名（参数类型 参数名）{
...
方法体
...
return 返回值；
}
修饰符是可选的，方法可能有返回值，参数也是可选
方法调用
对象名.方法名（实参列表）
Java支持两种调用方法的方式，根据方法是否返回值来选择
当方法返回一个值得时候，方法调用通常被当做一个值，例如：
int larger = max(30,40);
如果方法返回值是void，方法调用一定是一条语句，例如：
System.out.println("Hello,World!")
两个数比较大小，调用方法：
public static void main(String[] args) {
int max = max(10,20);
System.out.println(max);
}
public static int max(int a,int b){
int result = 0;
if (a == b){
System.out.println("a == b");
return 0 ;
}
if(a > b){
result = a;
}else{
result = b;
}
return result;
}
方法的重载：
重载就是在一个类中，有相同的方法名，但是形式参数的类型或数量不同
方法重载的规则：
方法名称必须相同
参数列表必须不同（个数不同、或类型不同、参数排列顺序不同）
方法返回类型可以相同也可以不同
仅仅返回类型不同不足以成为方法的重载
实现底层逻辑：编译器根据调用方法的参数个数，参数类型等逐个去匹配
本文来自博客园，作者：冷月_1991，转载请注明原文链接：https://www.cnblogs.com/wangzhen1991/p/for.html
浙公网安备 33010602011771号