java学习——Day04：java流程控制和java方法

一、Java流程控制

1.用户交互Scanner

基础语法

//基本语法：
Scanner s=new Scanner(System.in);
//通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取之前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据

//举例：
package com.study.scanner;

import java.util.Scanner;

public class Demo01{
    
    public static void main(String[] args){
        
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner=new Scanner(System.in);
        
        System.out.println("使用next方式接收：");
        
        //判断用户有没有接收字符串
        if(scanner.hasNext()){
            //使用next方式接收
            String str=scanner.next();
            System.out.println("输出的内容为："+str);
        }
        
        
        //凡是属于IO流的类如果不关闭会一直占用资源，要养成良好的习惯用完就关掉!!!!!
        scanner.close();
    }
}

/*next与nextLine的区别
1.scanner.next();
  一定要读取到有效字符后才可以结束输入；
  对输入有效字符前遇到的空白，next()方法自动将其去掉
  只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
  next()不能得到带有空格的字符串
2.scanner.nextLine();接收的输入遇见enter结束
  以Enter作为结束符，即nextLine()返回的是输入回车之前的所有字符
  可以获得空白
例如：输入hello world!
1输出hello，2输出hello world!

scanner进阶使用

package com.study.scanner;

import java.util.Scanner;

public class Demo02{
    
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        
        int i=0;
        float f=0.0f;
        System.out.println("请输入整数：");
       
        if(scanner.hasNextInt()){
            i=scanner.nextInt();
            System.out.println("整数数据："+i);
        }
        else{
            System.out.println("输入的不是整数数据！");
        }
        
        System.out.println("请输入小数：");
       
        if(scanner.hasNextFloat()){
            f=scanner.nextFloat();
            System.out.println("小数数据："+f);
        }
        else{
            System.out.println("输入的不是小数数据！");
        }
        
        scanner.close();
    }
}

Scanner实例：

package com.study.scanner;

import java.util.Scanner;

public class Demo03{

    public static void main(String[] args){
        //我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字结束
        Scanner scanner=new Scanner(System.in);

        //和
        double sum=0;
        //计算输入了多少个数字
        int m=0;

        //通过循环判断是否还有输入，并在里面对每一次求和进行求和统计
        while(scanner.hasNextDouble()){
            double x=scanner.nextDouble();
            m++;
            sum=sum+x;
            System.out.println("你输入了第"+m+"个数据，然后当前结果sum="+sum);
        }

        System.out.println(m+"个数的和为："+sum);
        System.out.println(m+"个数的平均值为："+(sum/m));

            scanner.close();
    }
}

2.顺序结构

​ Java的基本结构就是顺序结构，如不特别说明，就是一句一句执行。

​ 它是任何一个算法都离不开的一种基本算法结构。

3.if选择结构

//1.if单选结构
/*
语法格式：
if(布尔表达式){
    //如果布尔表达式为ture，则执行此处语句
}
*/
package com.study.struct;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);

        System.out.println("请输入内容：");
        
        String s=scanner.nextLine();
        
        //equals:判断字符是否相等
        if(s.equals("hello")){
            System.out.println(s);
        }

        System.out.println("End");
        scanner.close();
        
    }
}

/******************************************************************/
//2.if双选择结构
/*
语法格式：
if(布尔表达式){
	//如果布尔表达式为ture
}else{
	//如果布尔表达式为false
}
*/
package com.study.struct;

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);

        System.out.println("请输入分数：");
        //考试分数大于60为几个，否则不及格
        int score=scanner.nextInt();

        if(score>=60){
            System.out.println("考试及格");
        }else{
            System.out.println("考试不及格");
        }

        scanner.close();
    }
}

/******************************************************************/
//3.if多选择结构
/*
语法格式：
if(布尔表达式1){
	//如果布尔表达式1为ture
}else if(布尔表达式2){
	//如果布尔表达式2为ture
}else if(布尔表达式3){
	//如果布尔表达式3为ture
}else{
	//如果以上布尔表达式都为flase
}
*/
package com.study.struct;

import java.util.Scanner;

public class Demo03 {
    public static void main(String[] args) {

        Scanner scanner=new Scanner(System.in);

        System.out.println("请输入分数：");
        //考试分数大于60为几个，否则不及格
        int score=scanner.nextInt();

        if(score==100){
            System.out.println("恭喜满分！");
        }else if (score<100&&score>=90){
            System.out.println("优秀");
        }else if(score<90&&score>=70){
            System.out.println("良好");
        }else if(score>=60&&score<70){
            System.out.println("及格");
        }else if(score>=0&&score<60){
            System.out.println("不及格");
        }else
        {
            System.out.println("输入成绩不合法！");
        }
        scanner.close();
    }
}

/******************************************************************/
//4.if嵌套结构
/*
语法格式：
if(布尔表达式1){
	//布尔表达式1为ture
	if(布尔表达式2){
		//布尔表达式2为ture
	}
}
*/
//典型的例子为2分法查找

【注意】：if多选择结构，假如其中一个语句为ture，剩下的语句都不再执行！！！

4.Switch选择结构

/*
语法格式：
switch(express){
	case value:
		//语句
		break;
	case value:
		//语句
		break;
	case value:
		//语句
		break;
	default:
		//语句
}
*/
//express变量类型可以是：byte、short、int、char、String(JK7开始可以用String)

package com.study.struct;

public class Demo04 {
    public static void main(String[] args) {
        //case穿透
        char grade='C';

        switch (grade){
            case 'A':
                System.out.println("优秀");
                break;
            case 'B':
                System.out.println("良好");
                break;
            case 'C':
                System.out.println("及格");
                break;
            case 'D':
                System.out.println("不及格");
                break;
            default:
                System.out.println("输入不合法");
        }
    }
}

【注意】：case后面不加break，会导致程序会把匹配到的case后面的语句全部执行！！！

//JDK7新特性，表达式结构可以是字符串！！！
//字符的本质还是数字
//反编译 java————class（字节码文件）————反编译（IDEA）
//project里面有个输出路径out，里面存放的字节码文件，将其放到src文件夹里，再用IDEA打开，就可以看到反编译之后的文件,即源码，就能看法为什么支持String

5.While循环结构

/*
语法格式：
while(布尔表达式){
	//循环表达式
}
*/
package com.study.struct;

public class whileDemo01 {
    public static void main(String[] args) {
        //输出1~100
        int i=0;

        while(i<100){
            i++;
            System.out.println(i);
        }
    }
}
//一般会设定一个限制，让循环停止下来

6.DoWhile循环

/*
语法格式:
do{
    //代码语句
}while(布尔表达式)
*/
//Dowhile至少会执行一次，先执行后判断，而while先判断后执行

7.For循环

最有效，最灵活的循环结构

/*
语法格式：
for(初始化；布尔表达式；更新){
	//代码语句
}
*/
package com.study.struct;

public class ForDemo01 {
    public static void main(String[] args) {
        int a=1;        //初始化条件
        while(a<=100){  //条件判断
            System.out.println(a);//循环体
            a+=2;                  //迭代
        }

        System.out.println("while循环结束！");

        for(int i=1;i<=100;i++){
            System.out.println(i);
        }
        System.out.println("for循环结束！");
    }
}
//快捷键：100.for可实现同样功能
//死循环
for(;;){
    
}

练习题

package com.study.struct;

public class ForDemo02 {
    public static void main(String[] args) {
        //练习1：计算0到100之间奇数和偶数的和

        int evenSum=0;
        int oddSum=0;
        for (int i = 0; i <= 100; i++) {
            if(i%2!=0){
                oddSum+=i;
            }else{
                evenSum+=i;
            }
        }
        System.out.println("奇数的和："+oddSum);
        System.out.println("偶数的和："+evenSum);

        //练习2：用while循环或for循环输出1-100之间能被五整除的数，并且每行输出3个
        for (int i = 0; i <= 100; i++) {
            if(i%5==0){
                System.out.print(i+"\t"); 
            }
            if(i%(5*3)==0){   //每行3个
                System.out.print("\n");
            }

        }
    }
}
//println输出完会换行
//print输出完不会换行
//\t相当于tab一下
//\n相当于回车

8.打印九九乘法表

package com.study.struct;

public class ForDemo03 {
    public static void main(String[] args) {
        //练习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();
        }
    }
}

9.增强for循环

/*
语法格式：
for(声明语句：表达式)
{
	//代码语句
}
*/
package com.study.struct;

public class ForDemo04 {
    public static void main(String[] args) {
        int[] numbers={10,20,30,40,50};//定义一个数组

        for(int x:numbers){
            System.out.println(x);
        }
    }
}

10.break、continue、goto

break：在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。只是跳出循环，不影响循环之外的代码运行。

continue：在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判断。

goto：Java目前不用goto，但仍保留了下来，用标签跳转

break是辞职，continue是请假。

package com.study.struct;

public class BreakDemo {
    public static void main(String[] args) {
        //打印101-150之间的所有质数
        int count=0;

        outer:for(int i=101;i<=150;i++){
            for(int j=2;j<i/2;j++){
                if(i%j==0){
                    continue outer;
                }
            }
            System.out.print(i+" ");
        }
    }
}

11.打印三角形及Debug

package com.study.struct;

public class TestDemo01 {
    public static void main(String[] args) {
        //打印三角形 10行

        for (int i = 1; i <= 10; i++) {
            for (int j = 10; 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();
        }
    }
}

Debug:工具栏小甲壳虫，可以打断点

二、Java方法

1.方法的定义和调用

java方法是语句的集合，它们在一起执行一个功能。

例如：System.out.println();中System是类，out是对象，println就是方法。

设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，这样有利于后期的扩展。

package com.study.method;

public class Demo01 {
    //main方法
    public static void main(String[] args) {
        int sum=add(1,2); //sum就是一个方法
        System.out.println(sum);
    }

    //加法
    public static int add(int a,int b){    //加上static成为类变量，此时main才能调用
        return a+b;
    }
}

方法类似于其他语言中的函数，方法包含一个方法头和一个方法体。

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

2.方法重载

重载就是在一个类中，有相同的函数名称，但是参数不同。

参数的数据类型、参数的数量、参数的排序不同都可以，仅仅返回类型不同不足以成为方法重载。

3.命令行传递参数

有时候希望运行一个程序时再传递给它消息。这要靠传递命令行参数给main()函数实现。

package com.study.method;

public class Demo02 {
    public static void main(String[] args) {
        //args.length 数组长度
        for(int i=0;i< args.length;i++){
            System.out.println("args["+i+"]:"+args[i]);
        }
    }
}
//1.打开文件所在位置，cmd进入终端，javac Demo02.java编译成class文件
//2.用../退出到src文件夹，java Demo02 this is zhengxu，即可输出
//args[0]:this
//args[1]:is
//args[2]:zhengxu
//this is zhengxu 相当于传递给main()函数的参数
//退出到src是因为class里面含有package，必须退到保存包的src中，否则无法运行

4.可变参数

JDK1.5开始，Java支持传递同类型的参数给一个方法

在方法声明中，在指定参数类型后加一个省略号(…)。

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

package com.study.method;

public class Demo03 {
    public static void main(String[] args) {
        //调用可变参数的方法
        printMax(2,3,4,5,6,5);
        printMax(new double[]{1,2,3});
    }

    public static void printMax(double... numbers){
        if(numbers.length==0){
            System.out.println("No argument passed");
            return;
        }

        double result=numbers[0];

        //排序
        for (int i = 1; i < numbers.length; i++) {
            if(numbers[i]>result){
                result=numbers[i];
            }
        }
        System.out.println("The max value is"+result);
    }
}
//可变参数其实就类似于一个数组

5.递归讲解

递归：自己调用自己！

递归结构包含两个部分：

​ 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。

​ 递归体：什么时候需要调用自身方法。

//小计算可以用递归，大计算会导致栈溢出
package com.study.method;

public class Demo04 {
    public static void main(String[] args) {

        System.out.println(f(5));
    }

    public static int f(int n){
        if(n==1){
            return 1;   //n=1就是边界条件，调用到这停止
        }else{
            return n*f(n-1); //递归，阶乘
        }
    }
}