大纲预览
- Java里的控制语句
- 控制语句
- 选择结构
- **if单选择结构**
- **if-else双选择结构**
- **if-else if-else 多选择语法结构**
- **switch多选择结构**
- 循环结构
- **while循环**
- do-while循环结构
- for循环
- 循环的嵌套
- break和continue语句
- 语句块
- 方法(method)
- 方法的重载(overload)
- 递归结构
Java里的控制语句
控制语句
流程控制语句用来控制程序中各语句执行的顺序，主要有顺序结构，循环结构，选择结构
选择结构
if单选择结构，if-else双选择结构，if-else if-else 多选择结构，switch结构
补充：
Math类的使用
- java.lang包中的Math类提供了一些用于数学计算的方法
- Math.random()该方法用于产生一个0-1区间的double类型的随机数，但是不包括1。
int i = (int)(6*Math.random()); //产生[0，5]之间的随机数if单选择结构
语法结构：
if(布尔表达式){
语句块;
}if单选择结构示例小程序：
/**
* 测试if单分支选择语句的掷骰子小程序
* @author Bo
*
*/
public class TestIf1 {
public static void main(String[] args) {
//掷三个骰子
int x = (int)(6*Math.random())+1;
int y = (int)(6*Math.random())+1;
int z = (int)(6*Math.random())+1;
int sum = x+y+z;
System.out.println("您掷的点数为" + sum);
if(sum>15) {
System.out.println("恭喜你获得一等奖！");
}
if(sum>=10&&sum<=15) {
System.out.println("恭喜获得二等奖！");
}
if(sum>=8&&sum<10) {
System.out.println("恭喜获得三等奖！");
}
if(sum<8) {
System.out.println("很遗憾，您没有获奖！");
}
}
}if-else双选择结构
语法结构
if(布尔表达式){
语句块1;
}else{
语句块2;
}if-else双选择结构示例程序：
/**
* 测试if-else双选择语句
* @author Bo
*
*/
public class TestIf2 {
public static void main(String[] args) {
//随机产生[0.0,4.0)区间的半径，求圆的面积和周长
double r = 4*Math.random();
double area = Math.PI*Math.pow(r, 2);
double circle = 2 * Math.PI*r;
System.out.println("圆的半径为" + r);
System.out.println("圆的面积为" + area);
System.out.println("圆的周长为" + circle);
if(area>circle) {
System.out.println("圆的面积大于周长");
}else {
System.out.println("圆的周长大于面积");
}
}
}if-else if-else 多选择语法结构
if(布尔表达式1){
语句块1;
}else if(布尔表达式2){
语句块2;
}……
else if(布尔表达式n){
语句块n;
}else{
语句块n+1;
}switch多选择结构
常用来对多值进行判断并选择。
语法格式：
switch(表达式){
case 值1:
语句块1;
[break];
case 值2:
语句块2;
[break];
…………
case 值n:
语句块n;
[break];
[default:
默认语句;]
//[]方括号的意思代表可选，可写可不写
}switch选择语句示例程序：
public class TestSwitch {
public static void main(String[] args) {
char c = 'a';
int rand = (int)(24*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("辅音");
}
}
}循环结构
循环结构分为两大类，一类是当型，一类是直到型。(其中直到型用的比较少，主要使用的是当型)
while循环
语法结构
while(布尔表达式){
循环体;
}经典示例，求1到100的累加和
public class TestWhile {
public static void main(String[] args) {
int i = 0;
int sum = 0;
while(i<=100) {
sum+=i;
i++;
}
System.out.println(sum); //结果为5050
}
}do-while循环结构
语法结构：
do{
循环体;
}while(布尔表达式);do-while会先执行循环体，再判断布尔表达式的值，真，则继续执行，直到为假停止，因此do-while至少会执行一次。
for循环
for循环语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构。
语法格式：
for(初始表达式;布尔表达式;迭代因子){
循环体;
}无限循环
for(;;){
循环体;
}
//这种用法相当于while(true)循环的嵌套
在一个循环里面嵌套一个或多个循环。while ,do-while ,for，可以任意嵌套多层
嵌套循环示例：九九乘法表
public class TestFor {
public static void main(String[] args) {
for(int i=1;i<10;i++) {
for(int j=1;j<=i;j++) {
System.out.print(j + "*" +i + "=" +(i*j) + '\t');
}
System.out.println();
}
}break和continue语句
break用于强行退出循环，不执行循环中剩余的语句。
continue用于退出本次循环。
带标签的break和continue
“标签”是指后面跟一个冒号的标识符，例如“lable”，对java唯一用到标签的地方是在循环语句之前，而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们可以中断到存在标签的地方。
示例：使用带标签的break和continue控制嵌套循环跳转(打印101-150之间所有的质数)
public class TestLableBreak {
public static void main(String[] args) {
outer: for(int i=101;i<150;i++) {
for(int j=2;j<i/2;j++) {
if(i % j ==0){
continue outer; //结束本次内循环，跳到标签为outer的外循环
}
}
System.out.println(i +" ");
}
}
}语句块
语句块即用花括号{}括起来的任意数量java语句，块确定了局部变量的作用域，块中的程序代码，作为一个整体，是一起被执行。块可以嵌套在另一个块中，但不能在两个嵌套的块中声明同名的变量。语句块中定义的变量作用域只限于语句块。
方法(method)
方法说白了就是一段带名字的语句块，一段用来完成特定功能的代码片段。可以反复被调用，类似于其他语言的函数
方法用于定义该类或该类的实例的行为特征和功能实现。方法是类和对象行为特征的抽象。
在面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
方法声明格式：
[修饰符1 修饰符2 ……] 返回值类型 方法名(形式参数列表){
java语句;……
}方法的调用方式
对象名.方法名(实参列表)
方法的详细说明
- 形式参数：在方法声明时用于接收外界传入的数据。
- 实参：调用方法时实际传给方法的数据
- 返回值：方法在执行完毕后返回给调用它的环境的数据。
- 返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为void
在调用方法的时候，如果方法前面加static则可以直接在main方法中进行调用，如示例1，如果没有加static则需要在main方法中new一个对象，来进行调用，如示例2
示例1：
public class TestFangfa {
public static void main(String[] args) {
int num1 = 10;
int num2 = 20;
int sum = add(num1, num2);
System.out.println("sum ="+ sum);
print();
}
public static int add(int x,int y) {
int sum=x+y;
return sum;
}
public static void print() {
System.out.println("这是一个打印方法！");
}
}示例2
public class TestMethod {
public static void main(String[] args) {
//通过对象调用一个普通方法
TestMethod tm = new TestMethod();
tm.print();
}
void print() {
System.out.println("这是一个用于打印的普通方法");
System.out.println("123456789");
}
}注意
- java中进行方法调用中传递参数时，遵循值传递的原则(传递的都是数据的副本)
- 基本类型传递的是该数据值的copy值
- 引用类型传递的是该对象引用的copy值，但指向的是同一个对象
方法的重载(overload)
重载的方法实际是完全不同的方法，只是名称相同，都是独立的方法。
构成方法重载的条件：
- 不同的含义：形参类型，形参个数，形参顺序不同
- 只有返回值不同不构成方法的重载。
如：
int a(String str){}与 void a(String str){} //不构成方法重载- 只有形参的名称不同，不构成方法的重载
如：
int a(String str){} 与 int a(String s){} //不构成方法重载方法重载的示例：
public class TestOverload {
public static void main(String[] args) {
System.out.println(add(1,2));
System.out.println(add(1,2,3));
System.out.println(add(5.0,2));
System.out.println(add(1,3.0));
}
/*两个数求和*/
public static int add(int x,int y) {
int sum = x+y;
return sum;
}
/*方法名相同，参数的个数不同，构成重载*/
public static int add(int x,int y,int z) {
int sum = x+y+z;
return sum;
}
/*方法名相同，参数类型不同，构成重载*/
public static double add(double x,int y) {
double sum = x+y;
return sum;
}
/*方法名相同，参数顺序不同，构成重载*/
public static double add(int x,double y) {
double sum = x+y;
return sum;
}
/*
//会编译错误，因为只有返回值不同，不构成方法的重载
public static double add(int x,int y) {
double sum = x+y;
return sum;
}
//会编译错误，只有参数名称不同，不构成方法的重载
public static int add(int z,int k) {
int sum = z+k;
return sum;
}
*/
}递归结构
递归的基本思想就是自己调用自己
利用递归可以解决一些复杂的问题，如斐波那契数列的计算，汉诺塔，快排等问题。
递归结构包括两个部分：
- 递归头：即什么时候不调用自身方法，如果没有递归头，程序将陷入死循环，也就是递归结束的条件
- 递归体：什么时候需要调用自身方法。
示例：
static int count = 0;
static void a(){
System.out.println("a");
count++;
if(count<10){ //递归体
a();
}else{ //递归头
return;
}
}示例：利用递归思想计算阶乘
public class TestDigui {
public static void main(String[] args) {
long d1 = System.currentTimeMillis();
System.out.printf("%d阶乘的结果为：%s\n",10,factorial(10));
long d2 = System.currentTimeMillis();
System.out.printf("递归费时：%s",d2-d1);
}
/*利用递归求阶乘的一个方法*/
static long factorial(int n) {
if(n==1) {
return 1;
}else {
return n*factorial(n-1);
}
}
}递归会使程序简单，但会占用大量的系统堆栈，内存耗用多，在递归调用层次多的时候速度比循环慢的多
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
