黑马程序员--java基础流程控制与方法（下）

——- android培训、java培训、期待与您交流！ ———-

while循环：
基本格式：
while(循环判断语句){
循环体
}
完整结构：
初始化语句
while(循环判断语句){
循环体
循环变化语句
}

        for循环结构：            for(初始化语句;循环判断语句;循环变化语句){                循环体            }for循环和while可以相互转换，也就是说，for循环能做的while都能做。    循环四大要素：        初始化语句        循环判断语句        循环变化语句        循环体

class WhileDemo {    public static void main(String[] args) {        //求1-10之间的和        int sum = 0;        /*        for (int a = 1;a<=10;a++) {            sum = sum + a;        }        System.out.println(sum);            初始化语句：int a = 1;            循环判断：a<=10;            循环变化语句：a++;            循环体：sum = sum + a;        */        int a = 1;        while(a<=10){            sum = sum + a;            a++;        }        System.out.println(sum);    }}

while循环和for循环的区别（不绝对）：
for循环：在循环之外不能访问循环变量。
while循环：可以在循环之外访问循环变量。

    while循环更加适合不知道循环次数的循环。

class WhileFor {    public static void main(String[] args) {        int sum = 0;        /**/        int a = 1;        for (;a<=10;a++) {            sum = sum + a;        }        System.out.println(a);        /*        int a = 1;        while(a<=10){            sum = sum + a;            a++;        }        System.out.println(a);        */    }}

珠穆朗玛峰：
珠峰的高度：8848m
纸张的厚度：0.0002m
求，折叠多少次，纸张的厚度可以超过珠峰

    分析：        定义珠峰的高度，和纸张的厚度            double zg = 8848;            double zh = 0.0002;        初始化语句：定义纸张折叠的次数。int count = 0;        循环判断：zh < zg   纸张的厚度小于珠峰的高度时继续循环        循环变化：count++;        循环体：zh = zh * 2;

class WhileTest {    public static void main(String[] args) {        //定义珠峰的高度，和纸张的厚度        double zg = 8848;        double zh = 0.0002;        //初始化语句：定义纸张折叠的次数        int count = 0;        while(zh < zg){            //循环体，每次让纸张的厚度乘以2            zh = zh * 2;            //循环变化，每折叠一次，让折叠次数+1            count++;        }        System.out.println(count);    }}

do-While循环格式：
基本格式：
do{
循环体
}while(循环判断);
完整格式：
初始化语句;
do{
循环体
循环变化语句。
}while(循环判断);

class DoWhileDemo {    public static void main(String[] args) {        //定义的和        int sum = 0;        /*        for (int a = 1;a<=10;a++) {            sum = sum + a;        }        //初始化        int a = 1;        while(a<=10){ //a<=10是循环判断            //循环体            sum = sum + a;            //循环变化            a++;        }        */        //do-while循环        //初始化        int a = 1;        do{            //循环体            sum = sum + a;            //循环变化            a++;        }while(a<=10); //a<=10是循环判断        System.out.println(sum);    }}

do-while和While的区别
while循环：先判断，然后去执行。
do-while循环：先执行后判断。

for、while和do-while循环：    首选for，然后选择while，最后选择do-while。    如果已知循环次数的循环，首选for    如果不知道循环次数，首选while    如果要求先执行后判断，或者是要求至少执行一次，则选do-while

class DoWhileWhile {    public static void main(String[] args) {        //初始化语句        /*        int a = 0;        while(a > 0){            System.out.println("While循环");            //循环变化            a++;        }        */        int a = 0;        do{            System.out.println("do-While循环");            a--;        }while(a > 0);    }}

求1-100之间的和

class XunHuanTest {    public static void main(String[] args) {        /*            求和必须先有一个和            int sum = 0;            求1-100之间的和            初始化语句：int a = 1;            循环判断：a <= 100            循环变化：a++            循环体：sum = sum + a;        */        //求和必须先有一个和        int sum = 0;        /*        //for循环        for (int a = 1;a <= 100;a++) {            sum = sum + a;        }        //while循环        int a = 1;        while(a <= 100){            sum = sum + a;            a++;        }        */        //do-while循环        int a = 1;        do{            sum = sum + a;            a++;            }while(a <= 100);        System.out.println(sum);    }}

去买衣服，总共有5家商店，每家商店有3件衣服。买衣服的时候，每一件都要去试一下。
现在有5家商店。
初始化语句：int a = 1;
循环判断：a<=5
循环变化：a++
循环体：进入商店，开始试衣服
每家有3件衣服。
初始化：int b = 1;
判断：b<=3
变化：b++
循环体：试衣服

需求增加：    假设，我在第三家商店，试第2件衣服的时候，发现，很满意，买了。后边的我们就不再试衣服了。break只能结束当前循环，而且只能结束一层。使用标签解决这种问题：    标签格式：        标签名:循环体    //就是给这个循环起了个别名    使用：        break 标签名;    //结束名字叫做"标签名"的循环        continue 标签名; //结束名字叫做"标签名"的本次循环

class BiaoQianDemo {    public static void main(String[] args) {        //控制5家商店        wc:for (int a = 1;a<=5;a++) {            System.out.println("进入第"+ a +"家商店，开始试衣服");            //控制三件衣服            for (int b = 1;b<=3;b++) {                System.out.println("正在试第"+ b +"件衣服");                //在这里判断如果是第三家商店，第二件衣服，我们就买了，然后停止。                if (a==3 && b==2) {                    break wc;                }            }        }        //        System.out.println("一块去吃个饭吧，吃包子");    }}

我要去餐厅吃“狮子头”，我觉的自己太饿了，所以觉得一口气能吃10个。
初始化语句：从第一个开始吃。所以int a = 1;
循环判断：a<=10
循环变化：a++
循环体：就是吃“狮子头”

吃到第5个的时候，我发现，吃不了了。所以我说，停下来，不吃了。break：让循环停止执行。break作用：    1.结束switch语句结构。    2.结束循环。break注意事项：    a.break结束的是循环，必须放在switch或循环中。    b.break后边的代码不会被执行，也就是说，当程序遇到break时，直接停止语句结构。    c.同一级别break的后边不能直接写代码。

class BreakDemo {    public static void main(String[] args) {        for (int a = 1;a<=10;a++) {            System.out.println("吃“狮子头”,正在吃第"+a+"个");            if(a==5){                //System.out.println("吃不了了。停下来，不吃了");                break;            }            System.out.println("----------");        }       }}

买苹果，买了10个，然后准备把他全部吃掉.
吃到第5个的时候，发现，这里边多了点蛋白质，这第5个苹果就不再吃了

continue:只能在循环中使用。    作用：结束本次循环，执行下次循环    当程序遇到continue时，本次循环结束，执行下次循环。    注意：        continue同一级别下，continue后不能直接写代码。

class ContinueDemo {    public static void main(String[] args) {        for (int a = 1;a<=10;a++) {                     if (a == 5) {                //这个苹果不吃了                continue;            }            System.out.println("吃第"+a+"个苹果");        }           }}

方法:
参数只和调用有关系。
有参方法：
调用:方法名(参数列表);
无参方法：
调用:方法名();
返回值只和方法调用之后的使用有关。和方法的调用没有任何关系。
有返回值方法：
“方法的调用”可以当作值来使用。
无返回值方法：
“方法的调用”不可以当作值来使用。

class MethodDemo {    public static void main(String[] args) {        /*        //有参方法：            ycwf(1);  //有参无返回值            ycyf(1);  //有参有返回值        //无参方法：            wcwf();   //无参无返回值            wcyf();   //无参有返回值        */        //有返回值：            int a = wcyf();   //无参有返回值            int b = ycyf(1);  //有参有返回值        //无返回值：            System.out.println(wcwf());   //无参无返回值            System.out.println(ycwf(1));  //有参无返回值    }    //无参无返回值方法    public static void wcwf(){        System.out.println("无参无返回值");    }    //无参有返回值，返回值就是1    public static int wcyf(){        System.out.println("无参有返回值");        return 1;    }    //有参无返回值，参数就是int类型    public static void ycwf(int a){        System.out.println("有参无返回值");    }    //有参有返回值，参数int类型，返回值就1    public static int ycyf(int a){        System.out.println("有参有返回值");        return 1;    }}

对于重复的内容，Java给我们提供了一项技术，让我们可以把重复性的内容抽取出来，当我们使用时，直接拿出来使用。
这种技术就是“方法(函数)”

方法(函数)：就是在类中，完成特定功能的代码块。方法其实就是一个功能或者一个动作。当我们需要复用一段代码时，我们需要把这段代码提取出来做成一个模块，而这个模块就是方法。方法的优点：    1.提高了代码的复用性。    2.提高了代码的可维护性。方法意义：    对于现实生活中而言，方法其实就是一个功能或者一个动作。比如，"吃饭"、"睡觉","学习"这些都叫做方法。    我现在让你去"学习",这个就是我在调用你的“学习”方法。方法的组成：    访问修饰符：限制我们方法的调用。  public static    返回值：方法执行之后都会有结果，方法给我们带回来的结果就是返回值。        返回值类型：给我们带回来的结果的数据类型        返回值：给我们带回来的结果    方法名：给方法起的名字。    参数：方法执行的要求。        参数类型：要求的类型。        参数名：参数的名字    方法体：方法具体的代码。方法的分类：    对于方法而言，返回值和参数的不同，可以让方法分为4类。    没有参数，没有返回值的方法。//无参无返回值方法    没有参数，有返回值方法。    //无参有返回值    有参数，没有返回值方法      //有参无返回值    有参数，有返回值方法      //有参有返回值方法。方法的格式：    访问修饰符 返回值类型 方法名(参数类型1 参数名,参数类型2 参数名2……){        //方法体        return 返回值。    }    注意：        1.这个方法格式，是完整的方法格式。        2.()里边的参数，有一个统一称呼叫做参数列表。        3.()里边的参数可以有多个，可以没有。        4.如果方法没有返回值，方法不允许出现“return 返回值”.方法的特点：    1.方法与方法平级。不允许嵌套定义。    2.方法必须调用才会执行。    写一个方法，叫做定义一个方法，也就是说，写方法其实就是定义方法。

class FunctionDemo {    public static void main(String[] args) {                    System.out.println("-------------------");    }    public static void sum(){        int a = 11;        int b = 6;        int sum = a + b;        System.out.println(sum);    }}

无参无返回值方法
格式：
访问修饰符 void 方法名(){
//方法体
}

        无返回值方法的返回值类型是void    求两个数的和。        public static void sum(){                //方法体        }无参无返回值方法的调用：方法名();.1.方法的调用其实就是让方法里边的代码去执行。2.我们想让代码在那里运行，就让方法在哪里被调用。

class WcWfFunction {    //main方法是程序的开始。    public static void main(String[] args) {        //让方法在main方法中调用        sum();    }    //求两个数的和的方法。    public static void sum(){        int a = 5;        int b = 6;        int sum = a + b;        System.out.println(sum);    }}

无参有返回值:
格式：
访问修饰符 返回值类型 方法名(){
//方法体
return 返回值。
}

    求两个数的和。无参有返回值方法的调用：方法名();无参有返回值方法的调用“方法名()”，这个东西本身就可以看作是一个数值。这个值就是返回值。    既然是数值：        1.可以直接输出。        2.可以作为数值进行赋值。总结：    无参方法的调用：方法名();如果一个名字后边没有()，则一定是个变量，如果名字后有(),则这个名字一定是方法

class WcYfFunction {    public static void main(String[] args) {        //调用求和方法        //sum();        System.out.println(sum()); //sum();System.out.println(11);         //int c = sum();        //System.out.println(c);    }    public static int sum(){        int a = 5;        int b = 6;        int sum = a + b;        System.out.println("----");        return sum;    }    public static String test(){        String s = "我爱中国";        return "我爱Java";    }    //返回一个1    public static int re1(){        return 1;    }}

有参数，有返回值方法
格式：
访问修饰符 返回值类型 方法名(参数类型1 参数名,参数类型2 参数名2……){
//方法体
return 返回值。
}

    调用：方法名(参数列表);    有返回值方法"方法的调用"这个东西就可以当作是一个值来使用，这个值就是返回值。    方法的调用：只和参数有关系。        如果是无参方法调用：方法名();        有参方法调用：方法名(参数列表);

class YcYfFunction {    public static void main(String[] args) {        int a = 5;        int b = 6;        sum(a,b);        //System.out.println(sum);    }    //求两个数的和，这两个数，要求我们给，返回计算之后的和    public static int sum(int a,int b){        System.out.println(a);        System.out.println(b);        int sum = a + b;        return sum;    }}

有参数，没有返回值方法 :
访问修饰符 void 方法名(参数类型1 参数名,参数类型2 参数名2……){
//方法体
}

调用：方法名(参数列表);

class YcWfFunction {    public static void main(String[] args) {        String s = "HelloWorld";        say(s);        //调用sum方法        int a = 5;        int b = 6;        sum(a,b);    }    //输出    public static void say(String str){        System.out.println(str);    }    //求和方法，求两个数的和，当然这里边什么都没有    public static void sum(int a,int b){    }}

return和break都能立即结束循环。
break结束的只是循环。
return：结束的是方法。

class ReturnDemo {    public static void main(String[] args) {        for (int a = 1;a<=10;a++) {            System.out.println("吃“狮子头”,正在吃第"+a+"个");            if(a==5){                return;                //break;            }        }           System.out.println("学习《Java》");        System.out.println("学习《Java》");        System.out.println("学习《Java》");        System.out.println("学习《Java》");

总结：
方法分类：
有参和无参方法：
参数之和方法的调用有关系

。
有参方法的调用

：方法名(参数列表);
无参方法的调用

：方法名();
有返回值方法和无返回值方法
有无返回值只和方法的使用

有关，和方法调用无关。
有返回值方法：”

方法的调用”可以直接当作值来使用。赋值和打印

都可以。
无返回值方法：”

方法的调用”不能当作值来使用，他只是方法中代

码的运行。
方法的特点：
1.方法与方法平级，不能嵌套定义。
2.方法不调用不执行。
3.方法必须先定义然后才能调用。
4.一个类中不能出现两个完全相同的方

法。

顺序结构：语句顺序执行
从main方法开始，自上而下，从左到右，有（）先执行（）里边的。

条件结构：语句在满足条件下执行
if,
格式：
if(布尔表达式){
当布尔表达式结果为true时，执行｛｝中的内容
}
if-else,
格式：
if(布尔表达式){
当布尔表达式结果为true时，执行｛｝中的内容
}else{
当布尔表达式结果为false时，执行else模块中的内容。
}
if-else-if
格式：
if(条件1){
当条件1成立时，执行这里。
}else if(条件2){
当条件1不成立，条件2成立，则执行这里。
}else if(条件3){
当条件1不成立，条件2也不成立，条件3成立，则执行这里
}else{
上述条件都不成立时，执行这里。
}

选择结构：switch
格式：
swicth(表达式或者变量){
case 值1:
语句1; //当表达式或者变量的值是“值1”时，执行这里。
break;
case 值2:
语句2; //当表达式或者变量的值是“值2”时，执行这里。
break;
……
default: //代表否则，当表达式或者变量
语句; //当表达式或者变量的值和以上case都不匹配时，执行这里。
break;
}
注意事项：
1.case和default没有顺序要求。
2.case的值不允许重复
3.case的值只能是常量，
4.表达式或者变量的值的数据类型只能是“byte、short、int、char、String(JDK1.7之后可以使用)”
5.default可以省略，但不建议。
6.break可以省略，但是不允许省略，如果省略则会出现穿透效果。

循环结构：语句在满足条件下循环执行多次
循环四要素：
初始化语句：一般用来定义循环变量。
循环判断语句：用来判断循环是否继续执行下去。
循环变化语句：用来控制循环变量的变化。循环体执行之后执行。
循环体：被循环的内容。
for循环
格式：
for(初始化语句;循环判断语句;循环变化语句){
循环体
}
执行流程：
1.先执行初始化语句。
2.然后执行循环判断语句。
如果结果为true，则执行下一步，执行循环体。
如果结果为false，则循环结束。
3.执行循环体
4.执行循环变化语句
5.执行循环判断语句，其实就是回到了第2步。

while循环：    基本格式：        while(判断语句){            循环体        }    完整格式：        初始化语句;        while(循环判断语句){            循环体            循环变化语句        }do-while循环：    基本格式：        do{            循环体        }while(循环判断语句);    完整格式：        初始化语句;        do{            循环体            循环变化语句;        }while(循环判断语句);优先选择for，然后while，最后do-while如果知道循环次数的循环，选择for如果不知道循环次数的循环，选择while如果需要先执行后判断或者需要至少执行一次，则选择do-while

跳转语句
break：结束整个循环。
continue：结束本次循环，进行下次循环。
return：结束整个方法。

——- android培训、java培训、期待与您交流！ ———-