黑马程序员--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培训、期待与您交流！ ———-