java笔记2

四、控制语句、方法、递归算法

1.控制语句

a.条件判断结构（选择结构）

1.if单分支结构2.if-else双分支结构

if-else 与条件运算符的比较： 3.if-else if-else多分支结构4.switch多分支结构（多值情况） b.循环结构（while)c.循环结构（for)d.循环结构（do-while)e.嵌套循环

1.braek语句和continue语句 2.方法

1.语句块2.方法3.方法的重载 3.递归 五、一些练习

“顺序结构”代表“先执行 a，再执行 b”的逻辑。

“条件判断结构”代表“如果…，则…”的逻辑。

“循环结构”代表“如果…，则重复执行…”的逻辑。

语法结构：

​ if(布尔表达式){

​ 语句块

​ }

Math 类的使用

Math.random()该方法用于产生 0 到 1 区间的 double 类型的随机数，但是不包括 1。

int i = (int) (6 * Math.random()); //产生：[0，5]之间的随机整数。

语法结构：

​ if(布尔表达式){

​ 语句块 1

​ }else{

​ 语句块 2

​ }

//使用条件运算符
int a=3;
int b=4;
int c=a 
3.if-else if-else多分支结构 
public class Testif02 {
    public static void main(String[] args) {
        //随机产生一个[0.0, 4.0)区间的半径，并根据半径求圆的面积和周长
        double r=4*Math.random();
        //Math.pow(r,2)求半径r的平方
        double area=3.14*Math.pow(r,2);
        double circle=2*Math.PI*r;
        System.out.println("半径为"+r);
        System.out.println("面积为"+area);
        System.out.println("周长为"+circle);
        if(circle 
4.switch多分支结构（多值情况） 
语法结构：
 
​		switch (表达式) {

​				case 值 1: 

​						语句块 1;

​						[break];

​				case 值 2:

​						语句块 2;

​						[break];

​				 … … … … …

​				[default:

​						默认语句块;]

​		}
 
switch 会根据表达式的值从相匹配的 case 标签处开始执行，一直执行到 break 处或者是 switch 的末尾。如果表达式的值与任一 case 值不匹配，则进入 default 语句。switch 中表达式的值，是 int(byte、short、char 也可，long 不行)、枚举，字符串。 
public class TestSwitch02 {
    public static void main(String[] args){
        int month = 2; //1 表示 1 月，2 表示 2 月，....
        if(month==1||month==2||month==3){
            System.out.println("春季");
        }else if(month==4||month==5||month==6){
            System.out.println("夏季");
        }else if(month==7||month==8||month==9){
            System.out.println("秋季");
        }else{
            System.out.println("冬季");
        }
        System.out.println("========使用 switch 改造上面的代码，switch 特别适合多值判断=============");
        
        switch (month){
            case 1:
            case 2:
            case 3:
                System.out.println("春季");
                break;
            case 4:
            case 5:
            case 6:
                System.out.println("夏季");
                break;
            case 7:
            case 8:
            case 9:
                System.out.println("秋季");
                break;
            default:
                System.out.println("冬季");
        }
    }
}
 
b.循环结构（while) 
语法结构：
 
​		while (布尔表达式) {

​				 循环体; 

​		}
 
public class Testwhile {
    public static void main(String[] args) {
        
        
        int i=0;
        int sum1=0;
        //1+2+3+4+...+100=?
        while(i<=100){
            sum1+=i;
            i++;
        }
        System.out.println("sum1="+sum1);


        
        int n=0;
        int sum2=0;
        do{
            sum2+=n;
            n++;
        }while(n<=100);
        System.out.println("sum2="+sum2);

    }
}

 
输出结果： 
 sum1=5050
 sum2=5050
 
c.循环结构（for) 
语法结构：
 
​ for (初始表达式; 布尔表达式; 迭代因子) {
 
			循环体; 
 
​ }
 
for循环里定义的变量不能在for循环外使用
 
public class Testfor {
    public static void main(String[] args) {
        int sum=0;
        //1.求1-100之间的累加和
        for(int i=0;i<=100;i++){
            sum+=i;
        }
        System.out.println(sum);
        //2.循环输出9-1之间的数
        for (int x=1;x<=9;x++){
            System.out.print(x+" ");
        }
        System.out.println();
        //3.输出90-1之间能被3整除的数
        for (int n=1;n<=90;n++){
            if (n%3==0){
                System.out.print(n+" ");
            }
        }
        System.out.println();

    }
}

 
d.循环结构（do-while) 
语法结构：
 
​ do {
 
​ 循环体;
 
​ } while(布尔表达式) ;
 
while 与 do-while 的区别
 
 
while 循环：先判断再执行
  
do-while 循环：先执行再判断
  
运行结构，可以看出 do-while 总是保证循环体至少会被执行一次！
 
e.嵌套循环 
1.braek语句和continue语句 
break 用于强行退出整个循环 
public class TestBreak {
    public static void main(String[] args) {
        int total = 0; //定义计数器
        System.out.println("Begin");
        while(true) {
            total++; //每循环一次计数器加1
            int i = (int)(100*Math.random());
            //当i=88时，退出循环
            if (i == 88) {
                break;
            }
        }
        //输出循环的次数
        System.out.println("Game over,used"+total+"times.");
    }
}
 
continue 用于结束本次循环，继续下一次 
public class TestContinue {
    //把100-150之间不能被3整除的数输出，并且每行输出5个
    public static void main(String[] args) {
        int count=0; //定义计数器
        for(int i=100;i<=150;i++){
            if(i%3==0){
                continue;
            }
            //否则（不是3的倍数），输出该数
            System.out.print(i+" ");
            count++; //每输出一个数，计数器加1
            //根据计数器判断每行是否已经输出了5个数
            if (count%5==0){
                System.out.println();
            }
        }
    }
}
 
带标签的continue语句 
2.方法 
1.语句块 
语句块（也叫复合语句）。语句块中定义的变量只能用于自己，外部不能使用。
 
语句块可以使用外部的变量，而外部不能使用语句块的变量；
 
public class Test00{
    public static void main(String[] args){
        int n;
        int a;
        {
          	int k;
          	int n;	//编译错误：不能重复定义变量n
        }	//变量k的作用域到此为止
    }
}
 
2.方法 
1.方法(method)：一段用来完成特定功能的代码片段，类似于其它语言的函数(function)。
 
2.方法用于定义该类或该类的实例的行为特征和功能实现。
 
3.面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。
 
4.面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
 
方法声明格式：
 
​ [修饰符 1 修饰符 2 …] 返回值类型 方法名(形式参数列表){
 
​ Java 语句；… … …
 
​ }
 
方法的调用方式：
 
普通方法
对象名.方法名（实参列表）
静态方法
类名。方法名（实参列表）
【示例】方法的声明及调用
 
public class TestMothod1 {
    
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
//调用求和的方法：将num1与num2的值传给add方法中的n1与n2
        // 求完和后将结果返回，用sum 接收结果
        int sum = add(num1, num2);
        System.out.println("sum = " + sum);//输出：sum = 30
//调用打印的方法，该方法无返回值
        print();
    }
    
    public static int add(int n1, int n2) {
        int sum = n1 + n2;
        return sum;//使用return 返回计算的结果
    }
    
    public static void print() {

        System.out.println("KZY最cool");
    }
}
 
 
3.方法的重载 
重载：一个类中可以定义多个名称相同，但形式参数列表不同的方法。
 
​ 重载的方法，实际是完全不同的方法，只是名称相同而已！
 
构成方法重载的条件：
 
 
形参列表不同的含义：形参类型、形参个数、形参顺序不同
  
只有返回值不同不构成方法的重载
 
 
如：int a(String str){}与 void a(String str){}不构成方法重载
 
只有形参的名称不同，不构成方法的重载
 
如：int a(String str){}与 int a(String s){}不构成方法重载
 
3.递归 
递归的基本思想就是“自己调用自己”。
 
递归是一种常见的算法思路，在很多算法中都会用到。比如：深度优先搜索
 
（DFS:Depth First Search）等
 
五、一些练习 
1.打印出实心 10×10 正方形、空心 10×10 正方形
 
public class homework6 {
    public static void main(String[] args) {
        //实心
        for(int m=0;m<10;m++){   //十行
            for(int n=0;n<10;n++){  //每行十个
                System.out.print("*  ");
            }
            System.out.println();
        }
        System.out.println("-----------------------------------");
        //空心
        for(int a=0;a<10;a++){  //共十行
            for(int b=0;b<10;b++) {  //每行十位(十列）
                if (a == 0 | a == 9) {   //
                    System.out.print("*  ");
                } else{
                    if (b == 0 | b == 9) {
                    System.out.print("*  ");
                    } else {
                    System.out.print("   ");
                    }
                }
            }
            System.out.println();
        }

    }
}
 
2.*薪水计算器
 
通过键盘输入用户的月薪，每年是几个月薪水。输出用户的年薪输出一行字“如果年薪超过 10 万，恭喜你超越 90%的国人”，“如果年薪超过 20 万，恭喜你超越 98%的国人”。直到键盘输入数字 88，则退出程序（使用 break 退出循环）键盘输入 66，直接显示“重新开始计算…”，然后算下一个用户的年薪。 
import java.util.Scanner;
public class SalaryCalulator {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        System.out.println("**************薪水计算器********************");
        System.out.println("1.输入88，退出程序n2.输入66，计算下一个年薪");
        while(true){
            System.out.println("请输入月薪：");
            int monthSalary=s.nextInt();
            System.out.println("请输入一年几个月薪资：");
            int months=s.nextInt();
            int yearSalary=monthSalary*months;  //年薪
            System.out.println("年薪是："+yearSalary);
            if (yearSalary>=200000){
                System.out.println("恭喜你超越98%的国人");

            }else if(yearSalary>=100000){
                System.out.println("恭喜你超越 90%的国人");
            }

            System.out.println("输入88，退出系统；输入66，继续计算");
            int comm=s.nextInt();
            if(comm==88){
                System.out.println("系统退出");
                break;
            }
            if(comm==66){
                System.out.println("重新计算下一个人的薪资");
                continue;
            }

        }
    }

}