程序流程

一、方法的声明和调用

1. 语句块：是用花括号括起来的任意数量的简单Java语句。

• 块中的程序代码作为一个整体，会被一起执行；
• 块可以被嵌套在另一个块中，但是不能在两个嵌套的语句块中声明同名变量；
• 语句块可以使用外部变量，而外部不能使用语句块中定义的变量，因为语句块中定义的变量作用域只限于语句块

2. 方法

• 方法就是一段用来完成特定代码功能的代码片段，类似于其他语言的函数；
• 方法用于定义该类或该类的实例的行为特征和功能实现；
• 方法是类和对象行为特征的抽象，面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

3. 方法的声明

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

4. 方法的调用

对象名.方法名（实参列表）

5. 方法的详细说明

• 形式参数：在方法声明时用于接收外界传入的数据；
• 实参：调用方法时实际传给方法的数据；
• 返回值：方法在执行完毕后返还给调用它的环境的数据，无返回值时，用void；
• 返回值类型：事先约定好的返回值的数据类型，如无返回值，必须显示指定为void。

6. 注意事项：

• 实参的数目、数据类型和次序必须和所调用的方法声明的形参列表相对应;
• return语句终止方法的运行并指定要返回的数据。

7. 举例：调用方法计算三个数的和

• 源代码：

public class TestMethod{
    public  static int add(int a,int b,int c){
        int sum = a + b + c;
        return sum;
    }
    public static void main(String[] args) {
        int x = add(3,5,7);
        System.out.println("x = "+ x);
    }
}

• 运行结果：
  

二、使用Scanner获得键盘输入

• Scanner 是 Java5 的新特征，用于扫描输入文本的扫描器，它可以使用正则表达式来解析基本类型和字符串；
• Scanner 使用分隔符模式将其输入分解为标记，默认情况下该分隔符模式与空白匹配；
• 可以使用不同的 next 方法将得到的标记转换为不同类型的值。

• next()和nextLine()的区别：

  • next():

    • 读取到有效字符后才可以结束输入；
    • 输入有效字符后再其后面输入的空格作为分隔符或者结束符；
    • 在输入有效字符之前遇到的空格，会自动将其去掉；

  • nextLine()：

    • 以Enter为结束符,nextLine()返回的是输入回车之前的所有字符。

• 例：

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

        System.out.println("请输入你的名字：");
        String name = scanner.nextLine();

        System.out.println("请输入你的爱好：");
        String favor = scanner.nextLine();

        System.out.println("=================");
        System.out.println(name);
        System.out.println(favor);
    }
}

• 运行结果：
  

三、程序流程

（一）、顺序结构

在Java程序中，语句执行的基本顺序按各语句出现的位置的先后顺序执行，称之为顺序结构。

（二）、选择结构：

选择结构：根据条件来控制代码的执行分支，也称分支结构。

Java包括两种控制分支的条件语句：if 语句和switch语句。

1. if 语句：包含多种形式：单分支、双分支和多分支；

• 单分支结构:该语句的作用是当条件表达式的值为true时，执行if后的语句块，否则不做任何操作，控制转到if语句的结束点。

a.语法形式：

if（条件表达式）{
	语句块;
}

b.流程图如下：

2. 双分支结构：该语句的作用是当条件表达式的值为true时，执行if后的 语句块1，否则执行else后的语句块2，

• 语法形式：

if（条件表达式）{
 语句块1
 }else{
	语句块2
 }

• 流程图如下：
  

3. 多分支结构：该语句的作用是根据不同的条件表达式的值确定执行哪个语句块。

• 语法结构：

    if（条件表达式1）{
		语句块1；
	} else if（条件表达式2）{
		语句块2；
	}	...
	else if（条件表达式n）{
		语句块n;
	}		else {
	语句块n+1；
	}

• 流程图如下：

对于多重分支，虽然可以使用嵌套的if语句实现，但如果分支较多，则嵌套的if语句层次较多，结构较复杂，程序可读性较差，此时可利用switch语句。

4. Switch语句：是一个控制语句，它通过将控制传递给其体内的case语句来处理多个选择。

• switch语句会根据表达式的值从相匹配的case标签处开始执行，一直执行到break语句处，表示结束了switch语句，或是switch语句的末尾，如果表达式的值与任一case的值不匹配，则进入default语句;

• case标签在JDK1.5之前必须是整数（long类型除外），但在JDK1.7之后允许使用String。

• 语法形式：

    switch(控制表达式1) {
	case （常量表达式1）；
		语句序列1；
		[break];
	case （常量表达式2）；
		语句序列2；
		[break];
		... ...
	[default;
		语句序列n+1；]			]
}

• 流程图如下：

（三）、循环结构

1. for循环语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构

• 语法形式

for（初始化设置表达式;执行循环条件；循环变量的增减量）{
循环语句序列;
}

• 流程图
  

• 举例：1.求1-100之内的和，1-100之内奇数的和，1-100偶数的和

源代码：

	public static void fun(int n) {
            int sum = 0;
            int sumOdd = 0;
            int sumEve = 0;
            for(int i = 1;i <= n;i++) {
                sum =sum + i;
            }
            for(int i = 1;i <= n;i =i + 2) {
                sumOdd = sumOdd + i;
            }
            for(int i = 2;i <= n;i = i + 2) {
                sumEve =sumEve + i;
            }
            System.out.println("sum = "+sum);
            System.out.println("sumOdd = "+sumOdd);
            System.out.println("sumEve = "+sumEve);
        }
    public static void main(String[] args) {
        fun(100);
    }

运行结果：

四、练习

1. 用for循环求斐波那契数列的前40项的和。(1，1，2，3，5，8…)

• 程序代码：

    public class TestFib {
    public static void main(String[] args) {
        int fib;		//定义斐波那契数列第n项为fib；
        int f1 = 1;		
        int f2 = 1;		//斐波那契数列的前两个数为1；
        int sum = 2;		//sum为该数列的前n项和，初始化sum =2，为数列的前两项之和；
        System.out.println("f (1) = 1");
        System.out.println("f (2) = 1");		//分别打印斐波那契数列的前两项；
        for(int i = 3;i <= 40;i++) {
            fib = f1 + f2;		//当i = 3时，数列第三项为第一项和第二项之和；
            f1 = f2;		//将f2的值传递给f1，此时f1代表数列的第i-2项;
            f2 = fib;		//将第n项的值赋给f2，f2代表数列的第i-1项；
            sum = sum + fib;	//未执行此语句时，sum为数列的前i-1项和，赋值操作完成后，sum代表数列的前i项和；
            System.out.print("f (" + i +")" + " = " );
            System.out.println(fib);		//分别打印数列的第i项；程序中i=40；
        }
        System.out.println("斐波那契数列前四十项的和为："+ sum );		//输出斐波那契数列的前40项和的和；
    }
}

• 运行结果：
  

2. 用for循环产生20个double类型的随机数，取值在[10,20)之间;调用Math.random()

• 程序代码：

public class TestFib {
    public static void main(String[] args) {
        for (int i = 1; i <= 20; i++) {
            double a = Math.random() * 10 + 10;		//生成[10，20）之间的随机数
            System.out.print("random_number "+ "("+ i +") = ");
            System.out.println(a);
  		}
    }
}

• 运行结果：
  

3. 输入一个数字，求他是几位数，并且顺序输出，逆序输出

• 程序代码：

import java.util.Scanner;
public class TestDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个数字");
            String str = scanner.next();
            StringBuffer stringBuffer = new StringBuffer(str);	
            System.out.println("该数字有" + str.length() + "个数");
            System.out.println("顺序输出为：" + str);
            System.out.println("逆序输出为：" + stringBuffer.reverse());		//返回stringBuffer对象的颠倒顺序；
    }
}

• 运行结果：
  

4. 求一个数字的二进制数有几个1；

• 进制转换
  • 十进制转二进制：Integer.toBinaryString();
  • 十进制转八进制：Integer.toOctalString();
  • 十进制转十六进制：Integer.toHexString();
• 程序代码：

    import java.util.Scanner;
	public class TestBs {
        public static int number1(int n){
            int i = 0;		//i表示1的个数；
                while (n != 0) {
                    i++;
                    n = n & (n - 1);		//将n和n-1按位与
                }
                return i;
                       }
         public static void main(String[] args) {
                Scanner scanner = new Scanner(System.in);
                System.out.println("请输入一个数:");
                int x = scanner.nextInt();
                int y = number1(x);		//number1（）的返回值赋给y,此时y代表这个数的二进制表示形式中1的个数；
                System.out.println("这个数的二进制表示形式是："+Integer.toBinaryString(x));
                System.out.println("这个数的二进制表示形式中有"+ y + "个1");

       }
}

• 运行结果：