语句块(有时叫做复合语句)，是用花括号扩起的任意数量的简单Java语句。块确定了局部变量的作用域。块中的程序代码，作为一个整体，是要被一起执行的。块可以被嵌套在另一个块中，但是不能在两个嵌套的块内声明同名的变量。语句块可以使用外部的变量，而外部不能使用语句块中定义的变量，因为语句块中定义的变量作用域只限于语句块。

代码中的语句:

public class Test19 {    public static void main(String[] args) {        int n;        int a;        {            int k;            int n; //编译错误：不能重复定义变量n        } //变量k的作用域到此为止    }}

每个方块就代表一个语句块,从中可以看出语句块的范围以及关系

01 Java中的方法

方法就是一段用来完成特定功能的代码片段，类似于其它语言的函数。

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

方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

方法的调用方式：

对象名.方法名(实参列表)

方法的详细说明

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

方法的声明和调用

public class Test20 {    /** main方法：程序的入口 */    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("超超哥哥和java...");    }}

注意事项

  1. 实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。  2. return 语句终止方法的运行并指定要返回的数据。  3. Java中进行方法调用中传递参数时，遵循值传递的原则(传递的都是数据的副本)：  4. 基本类型传递的是该数据值的copy值。  5. 引用类型传递的是该对象引用的copy值，但指向的是同一个对象。

01.1 Java中方法的重载

方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。调用时，会根据不同的参数自动匹配对应的方法。

雷区

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

//返回值不同不构成重载int a(String str){}与 void a(String str){} //只有形参名称不同是不构成方法重载的int a(String str){}与int a(String s){}

正确方法重载方式

public class Test21 {    public static void main(String[] args) {        System.out.println(add(3, 5));// 8        System.out.println(add(3, 5, 10));// 18        System.out.println(add(3.0, 5));// 8.0        System.out.println(add(3, 5.0));// 8.0        // 我们已经见过的方法的重载        System.out.println();// 0个参数        System.out.println(1);// 参数是1个int        System.out.println(3.0);// 参数是1个double    }    /** 求和的方法 */    public static int add(int n1, int n2) {        int sum = n1 + n2;        return sum;    }    // 方法名相同，参数个数不同，构成重载    public static int add(int n1, int n2, int n3) {        int sum = n1 + n2 + n3;        return sum;    }    // 方法名相同，参数类型不同，构成重载    public static double add(double n1, int n2) {        double sum = n1 + n2;        return sum;    }    // 方法名相同，参数顺序不同，构成重载    public static double add(int n1, double n2) {        double sum = n1 + n2;        return sum;    }    //编译错误：只有返回值不同，不构成方法的重载    public static double add(int n1, int n2) {        double sum = n1 + n2;        return sum;    }    //编译错误：只有参数名称不同，不构成方法的重载    public static int add(int n2, int n1) {        double sum = n1 + n2;                 return sum;    }  }

02 Java中控制语句

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。控制语句分为三类：顺序、选择和循环。

顺序结构

“顺序结构”代表“先执行a，再执行b”的逻辑。比如，先找个女朋友，再给女朋友打电话；先订婚，再结婚；

选择结构

“选择结构”代表“如果…，则…”的逻辑。比如，如果女朋友来电，则迅速接电话；如果看到红灯，则停车；

循环结构

“循环结构”代表“如果…，则再继续…”的逻辑。比如，如果没打通女朋友电话，则再继续打一次；如果没找到喜欢的人，则再继续找。

其实生活中的各种事情都可以用这几种结构来解释,编程的思想一定的顺从人类本身的思想,不会违反的来

03 Java中选择语句

选择结构用于判断给定的条件，然后根据判断的结果来控制程序的流程。

主要的选择结构有：if选择结构和switch多选择结构。有如下结构：

if单选择结构if-else双选择结构if-else if-else多选择结构switch结构03.1 Java选择语句中的if单结构

if(布尔表达式){语句块}

if语句对布尔表达式进行一次判定，若判定为真，则执行{}中的语句块，否则跳过该语句块。流程图如图所示:

配套练习:

public class Test1 {    public static void main(String[] args) {        //通过掷三个骰子看看今天的手气如何？        int i = (int)(6 * Math.random()) + 1;//通过Math.random()产生随机数        int j = (int)(6 * Math.random()) + 1;        int k = (int)(6 * Math.random()) + 1;        int count = i + j + k;        //如果三个骰子之和大于15，则手气不错        if(count > 15) {            System.out.println("今天手气不错");        }        //如果三个骰子之和在10到15之间，则手气一般        if(count >= 10 && count <= 15) { //错误写法：10<=count<=15            System.out.println("今天手气很一般");        }        //如果三个骰子之和小于10，则手气不怎么样        if(count < 10) {            System.out.println("今天手气不怎么样");        }        System.out.println("得了" + count + "分");    }}

解读:
Math类的使用

  1.java.lang包中的Math类提供了一些用于数学计算的方法。  2.Math.random()该方法用于产生一个0到1区间的double类型的随机数，但是不包括1。    int i = (int) (6 * Math.random()); //产生：[0，5]之间的随机整数

注意点:

  1.如果if语句不写{}，则只能作用于后面的第一条语句.所以强烈建议，任何时候都写上{}，即使里面只有一句话！

03.2 Java选择语句中的if-else双选择结构

if(布尔表达式){ 语句块1}else{       语句块2}

当布尔表达式为真时，执行语句块1，否则，执行语句块2。也就是else部分。流程图如图所示。

配套练习:

public class Test3 {    public static void main(String[] args) {        int a=2;         int b=3;        if (a<b) {            System.out.println(a);        } else {            System.out.println(b);        }    }}

日常我们使用的时候还会有下面这种使用方法:
用条件运算符代替if-else

public class Test4 {    public static void main(String[] args) {        int a=2;        int b=3;        System.out.println((a<b)?a:b);    }}

03.3 Java选择语句中的if-else if-else多选择结构

if(布尔表达式1) {语句块1;} else if(布尔表达式2) {语句块2;}……else if(布尔表达式n){    语句块n;} else {    语句块n+1;}

当布尔表达式1为真时，执行语句块1;否则，判断布尔表达式2，当布尔表达式2为真时，执行语句块2;否则，继续判断布尔表达式3······;如果1~n个布尔表达式均判定为假时，则执行语句块n+1，也就是else部分。流程图如图所示。

根据个人的理解来看实际上就是 每次都做判断 比如做个性别分类:

一个人妖对其性别分类(下面是中文解释):

来了个人妖if(是个男人?){  输出他是个男人       //这里显然不是,所以就跳到下面} else if(是个女人?){  输出她是个女人      //这里显然不是,所以跳到下面语句块}else{  他/她是个人妖      //这里就输出了结果}

所以和if-else的结构来对比,就是每次不满足布尔表达式的时候,进入else的语句块后会再做判断而不是执行else后面的语句块

配套练习

public class Test5 {    public static void main(String[] args) {        int age = (int) (100 * Math.random());        System.out.print("年龄是" + age + "， 属于");        if (age < 15) {            System.out.println("儿童， 喜欢玩！");        } else if (age < 25) {            System.out.println("青年， 要学习！");        } else if (age < 45) {            System.out.println("中年， 要工作！");        } else if (age < 65) {            System.out.println("中老年， 要补钙！");        } else if (age < 85) {            System.out.println("老年， 多运动！");        } else {            System.out.println("老寿星， 古来稀！");        }    }}

03.4 Java选择语句中的switch多选择结构

switch (表达式) {case 值1: 语句序列1;[break];case 值2: 语句序列2;[break];     … … …      … …[default: 默认语句;]}

switch语句会根据表达式的值从相匹配的case标签处开始执行，一直执行到break语句处或者是switch语句的末尾。如果表达式的值与任一case值不匹配，则进入default语句(如果存在default语句的情况)。根据表达式值的不同可以执行许多不同的操作。switch语句中case标签在JDK1.5之前必须是整数(long类型除外)或者枚举，不能是字符串，在JDK1.7之后允许使用字符串(String)。

要注意，当布尔表达式是等值判断的情况，可以使用if-else if-else多选择结构或者switch结构，如果布尔表达式区间判断的情况，则只能使用if-else if-else多选择结构。

个人理解:实际上就是对号入座,比如这样说:

我的座位号是7

我就按照我的位置去逐排的去找,找到了,就坐下,找不到就坐备用席

switch (我的座位号是7) {case 座位号1: 已经就坐到座位号1;[break];case 座位号2: 已经就坐到座位号2;[break];     … … …      … …[default: 没有我的座位号,只好坐在备用的位置;]}

配套练习

public class Test6 {    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("辅音");        }    }}

04 Java中循环结构

循环结构分两大类，一类是当型，一类是直到型。

当型：

当布尔表达式条件为true时，反复执行某语句，当布尔表达式的值为false时才停止循环，比如：while与for循环。

直到型：

先执行某语句， 再判断布尔表达式，如果为true，再执行某语句，如此反复，直到布尔表达式条件为false时才停止循环，比如do-while循环。

04.1 Java循环结构中的while循环

while (布尔表达式) {    循环体;}

在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。

语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。

配套练习:
练习中的while(i<=100)就是结束条件

public class Test7 {    public static void main(String[] args) {        int  i = 0;        int  sum = 0;        // 1+2+3+…+100=?        while (i <= 100) {            sum += i;//相当于sum = sum+i;            i++;        }        System.out.println("Sum= " + sum);    }}

04.2 Java循环结构中的do-while循环

do {        循环体;     } while(布尔表达式) ;

简单的来说就是先执行一次循环体,然后再做判断

do-while循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行循环体，当条件为假时结束循环。do-while循环的循环体至少执行一次。do-while循环结构流程图如图所示。

配套练习

public class Test8 {    public static void main(String[] args) {        int i = 0;        int sum = 0;        do {            sum += i; // sum = sum + i            i++;        } while (i <= 100);//此处的；不能省略        System.out.println("Sum= " + sum);    }}

延伸扩展

while 和do-while的区别

浓缩成一句话来说就是又没有先执行语句块,

while:没有先执行语句块,因为是先判断后再根据条件看是否执行

do-while:先执行语句块,不管满足不满足do-while都会至少执行一次语句块

public class Test9 {    public static void main(String[] args) {        //while循环：先判断再执行        int a = 0;        while (a < 0) {            System.out.println(a);            a++;        }        System.out.println("-----");        //do-while循环：先执行再判断        a = 0;        do {            System.out.println(a);            a++;        } while (a < 0);    }}

4.3 Java循环结构中的for循环

for (初始表达式; 布尔表达式; 迭代因子) {      循环体;}

for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行初始表达式;随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环;最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。

  A. 初始化部分设置循环变量的初值  B. 条件判断部分为任意布尔表达式  C. 迭代因子控制循环变量的增减  for循环在执行条件判定后，先执行的循环体部分，再执行步进。  for循环结构的流程图如图3-18所示。

配套练习

public class Test10 {    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= " + sum);        //2.循环输出9-1之间的数        for(int i=9;i>0;i--){            System.out.print(i+"、");        }        System.out.println();        //3.输出90-1之间能被3整除的数        for(int i=90;i>0;i-=3){            System.out.print(i+"、");        }        System.out.println();    }}

04.4 Java循环结构中的嵌套循环

在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环。while、do-while与for循环可以任意嵌套多层

配套代码

public class Test15 {    public static void main(String args[]) {        for (int i = 1; i < 10; i++) { // i是一个乘数            for (int j = 1; j <= i; j++) { // j是另一个乘数                System.out.print(j + "*" + i + "=" + (i * j < 10 ? (" " + i * j) : i * j) + "  ");            }            System.out.println();        }    }}

上面是一个九九乘法表

很多人再看这个的时候一般都会乱,主要是不理解其中的逻辑

实际上就是外面第一层for执行后就在执行内部的for语句,知道内部的for语句不在执行了,再进行外面的for语句 之后的内容就重复执行,知道外部的for语句不再进行执行技巧: 如果不能理解的话可以去bil上搜索java断点 通过这种方式可以很直观的看到程序运行的顺序,也可以帮助大家更快的理解其中的运行原理.

04.5 Java循环结构中的break语句和continue语句

break

在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。

continue

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

continue用在while，do-while中，continue 语句立刻跳到循环首部，越过了当前循环的其余部分。continue用在for循环中，跳到for循环的迭代因子部分。)

配套解释-break

public class Test16 {    public static void main(String[] args) {        int total = 0;//定义计数器        System.out.println("Begin");        while (true) {            total++;//每循环一次计数器加1            int i = (int) Math.round(100 * Math.random());            //当i等于88时，退出循环            if (i == 88) {                break;            }        }        //输出循环的次数        System.out.println("Game over， used " + total + " times.");    }}

配套解释-continue

public class Test17 {    public static void main(String[] args) {        int count = 0;//定义计数器        for (int i = 100; i < 150; i++) {            //如果是3的倍数，则跳过本次循环，继续进行下一次循环            if (i % 3 == 0){                continue;            }            //否则（不是3的倍数），输出该数            System.out.print(i + "、");            count++;//没输出一个数，计数器加1            //根据计数器判断每行是否已经输出了5个数            if (count % 5 == 0) {                System.out.println();            }        }    }}