Java笔记-04 控制语句 Java从入门到住院

文章目录

控制语句
选择语句
循环语句
break continue
语句块和方法
方法的重载
递归

控制语句

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：顺序结构、分支结构和循环结构

选择语句

if 单选择
if…else 双选择
if…else if…else多选择

public class TestIf { public static void main(String[] args) { int a = (int)(6 * Math.random()) + 1 ; //[0,1)区间内的数 int b = (int)(6 * Math.random()) + 1 ; int c = (int)(6 * Math.random()) + 1 ; int sum = a+b+c; //单选择 if (sum >= 15){ System.out.println("手气不错"); } if (sum >= 9 && sum < 15){ System.out.println("手气一般"); } //双选择 if(sum >= 15){ System.out.println("不错"); }else{ System.out.println("凑合"); } //多选择 if(sum <= 6){ System.out.println("小"); }else if(sum <= 9){ System.out.println("中"); }else{ System.out.println("大"); } } }

switch，表示多值相等的判断,switch可以是整数，枚举，字符串

public class TestSwitch { public static void main(String[] args) { char c = 'a'; int rand = (int) (26 * Math.random()); char c2 = (char) (c + rand); System.out.print(c2 + ": "); switch (c2) { case 'a': case 'e': case 'i': case 'o': case 'u': System.out.println("元音"); break; case 'y': case 'w': System.out.println("半元音"); break; default: System.out.println("辅音"); break; } } }

循环语句

当型和直到型
while，for，do…while

package MyPro03; public class TestWhile { public static void main(String[] args) { // while int sum = 0; int i = 1; while(i <=100){ sum += i; i++; } System.out.println(sum); //for int sum2 = 0; for(int j = 0; j<=100; j++){ sum2 += j; } System.out.println(sum2); //for多个条件，逗号分隔 for(int i1 = 0, j1 = 0; i1<=5; i1++,j1+=i1){ System.out.println(i1+","+j1); } //do...while int sum3 = 0; int k = 1; do{ sum3 += k; k++; }while (k<=100); System.out.println(sum3); } }

嵌套循环，循环里面有循环

package MyPro03; public class TestMFor { public static void main(String[] args) { //打印一行重复数字 System.out.println("数字："); for(int i = 1; i<=5; i++){ for(int j = 1; j<=5; j++){ System.out.print(i+"\t"); } System.out.println(); } System.out.println("\n乘法表:"); //乘法表 for(int k = 1; k<10; k++){ for(int j =1; j<=k; j++){ System.out.print(j+"*" + k +"="+k*j+""); } System.out.println(); } //1000以内被5整除的数的 System.out.println("\n被5整除的数："); int count = 0; for(int h = 0; h<=1000; ++h){ if(h % 5 ==0){ System.out.print(h+"\t"); count++; if(count % 10 == 0){ System.out.println(); } }} } }

【Java笔记-04 控制语句】

文章图片

break continue

break 结束整个循环
continue 结束本次循环，并开始下一个

public class TestBreak { public static void main(String[] args) { System.out.println("break"); for(int i = 0; i<6; ++i){ if(i == 3){ break; } System.out.println(i); } System.out.println("continue"); for(int i = 0; i<6; ++i){ if(i == 3){ continue; } System.out.println(i); } } }

带标签的break continue。for之前添加标签outer冒号，后面使用break outer或continue outer

//带标签的for示例，两个数相加，如果和为11就终止本次循环 public class TestLabelFor { public static void main(String[] args) { outer:for(int i = 1 ; i < 10; i++){ inner:for(int j = 1; j <= i; j++){ System.out.print(i+"+"+j+"="+(i+j)+""); if(i+j == 11){ System.out.println(); continue outer; }} System.out.println(); } } }

文章图片

语句块和方法

语句块，花括号里的内容是一个语句块，语句块的变量只在当前语句块有效。语句块(有时叫做复合语句)，是用花括号扩起的任意数量的简单Java语句。块确定了局部变量的作用域。块中的程序代码，作为一个整体，是要被一起执行的。块可以被嵌套在另一个块中，但是不能在两个嵌套的块内声明同名的变量。语句块可以使用外部的变量，而外部不能使用语句块中定义的变量，因为语句块中定义的变量作用域只限于语句块
方法：带名字的语句块。方法用于定义该类或该类的实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
定义：

[修饰符1修饰符2…]返回值类型方法名(形式参数列表){ Java语句；… … … }

对象名.方法名(实参列表)
方法的详细说明， 1. 形式参数：在方法声明时用于接收外界传入的数据。 2. 实参：调用方法时实际传给方法的数据。 3. 返回值：方法在执行完毕后返还给调用它的环境的数据。 4. 返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为为void。
return的两个作用，结束方法，返回值；
Java中进行方法调用中传递参数时，遵循值传递的原则(传递的都是数据的副本). 基本类型传递的是该数据值的copy值。引用类型传递的是该对象引用的copy值，但指向的是同一个对象

方法的重载

一个类多个同名方法
重载的方法，实际是完全不同的方法，只是名称相同而已!
构成方法重载的条件：
1.不同的含义：看参数类型数量和顺序，形参类型、形参个数、形参顺序不同
2.只有返回值不同不构成方法的重载，参数名称不同不重载

public class TestOverload { static double add(int x,double y){ return x + y; } static double add(double x,int y){ return x * y; } public static void main(String[] args) { System.out.println(add(3.0,5)); System.out.println(add(3,4.6)); } }

递归

递归结构包括两个部分：
1.定义递归头。解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。
2.递归体。解答：什么时候需要调用自身方法
简单的程序是递归的优点之一。但是递归调用会占用大量的系统堆栈，内存耗用多，在递归调用层次多时速度要比循环慢的多，所以在使用递归时要慎重。

package MyPro03; public class TestRecursion { public static void main(String[] args) { long t1 = System.currentTimeMillis(); System.out.println(factorial(40)); long t2 = System.currentTimeMillis(); System.out.println("Time:"+(t2 - t1)); } //阶乘 static double factorial(int n){ if(n == 1){ return 1; }else{ return n * factorial(n - 1); } } }