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

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

三元(三目、条件)运算符
格式：
(布尔表达式)?表达式1:表达式2;
如果布尔表达式结果为true，则三元表达式结果为”表达式1”
如果布尔表达式结果为false，则三元表达式结果为”表达式2”
注意事项：
1.表达式1和表达式2，必须有结果。
2.表达式1和表达式2的结果必须是同一类型或相互兼容。
如果表达式1和表达式2的结果是兼容类型，则结果是大类型。

class SanYuanYSF {
    public static void main(String[] args) {
        int a = 5;
        //int b = 1;
        double b = 1.0;

        //求a和b 的最大值。
        /*
            如果a>b 结果为a
            如果a>b不成立，则结果为b
        */
            double max = (a>b) ? a:"6";
            System.out.println(max);
    }
}

求5个数的最大值。

class SanYuanYSFTest {
    public static void main(String[] args) {
        //先有5个数
        int a1 = 9;
        int a2 = 15;
        int a3 = 6;
        int a4 = 8;
        int a5 = 13;

        //定义一个最大值。
        int max = a1;

        max = a1>a2?a1:a2;

        max =  max > a3 ? max : a3;

        max = max > a4 ? max : a4;

        max = max > a5 ? max : a5;

        System.out.println(max);


    }
}

假设：下课了，我要去卫生间。
如果，是男卫生，我就进去。

条件结构：其实指的是，代码执行不执行是发生在一定条件下的动作。
if，if-else，if-else-if
if表示如果。
if结构格式：
if(布尔表达式){
//如果布尔表达式成立，则执行这里.
}

    去卫生间的伪代码：
    if(卫生间是男卫生间){
        我们进去
    }


令狐冲去参加考试，成绩如果是大于90，奖励《辟邪剑谱》
    定义一个令狐冲的考试成绩。int score = 92;
    使用if结构去判断：
    判断条件：成绩>90
    如果判断条件成立，则奖励《辟邪剑谱》


if结构注意事项：
    1.if结构的判断条件，不管简单还是复杂，结果都必须是boolean类型
    2.如果if结构条件成立之后的执行语句，只有一句话，则｛｝可以省略。如果有多句则不允许省略。
        如果不写｛｝，则默认第一句话，是if结构的结构体。
    3.if可以嵌套使用

class IfDemo {
    public static void main(String[] args) {
        //定义一个令狐冲的武功考试成绩。
        int score = 92;
        //使用if结构去判断：
        if (score > 90) {
            System.out.println("奖励《辟邪剑谱》"); 
        }

        //考试生物,生物成绩
        int sw = 88;
        //如果武功>90，生物>85，则奖励《葵花宝典》
        /*
        if (score > 90) {
            if (sw > 85) {
                System.out.println("奖励《葵花宝典》"); 
            }
        }

        if (score > 90 && sw > 85) {    
            System.out.println("奖励《葵花宝典》"); 
        }*/


        /*
        //这是错误的，不能这么写。
        if ( 90 > score > 80) { 
            System.out.println("奖励《葵花宝典》"); 
        }
        */


    }
}

if-else的嵌套

class IfElseTest {
    public static void main(String[] args) {
        int x = 2, y = 1;
        if(x==1){  //必须x==1
            if(y==1){   //x==1并且y==1
                System.out.println("a");
            }else{      //x==1 并且 y!=1
                System.out.println("b");
            }
        }else{    //x!=1
            if(y==1){ //x!=1 并且 y==1
                System.out.println("c");
            }else{    //x!=1 并且 y!=1
                System.out.println("d");
            }
        } 
    }
}

令狐冲去参加比武大会
如果获得第一名，将出任武林盟主
如果获得第二名，将出任武当掌门
如果获得第三名，将出任峨嵋掌门
否则，将被逐出师门

class IfElseIfTest {
    public static void main(String[] args) {
        //先有名次
        int mc = 3;
        //如果获得第一名，将出任武林盟主
        if(mc == 1){
            System.out.println("出任武林盟主");
        }else if(mc == 2){ //如果获得第二名，将出任武当掌门
            System.out.println("出任武当掌门");
        }else if(mc == 3){ //如果获得第三名，将出任峨嵋掌门
            System.out.println("出任峨嵋掌门");
        }else{ //否则，将被逐出师门
            System.out.println("否则，将被逐出师门");
        }
    }
}

成绩>=90 ：奖励葵花宝典
90>成绩>=80 ：奖励辟邪剑谱
80>成绩>=60 ：废除武功
成绩<60 ：逐出师们

if-else-if结构：
    格式：
        if(条件1){
            //如果条件1成立，则执行这里
        }else if(条件2){
            //如果条件1不成立，条件2成立，则执行这里
        }else if(条件3){
            //如果条件1不成立，条件2也不成立，但是条件3成立，则执行这里
            ……   
        }else{
            //以上条件都不成立，则执行这里。
        }

说明：
    1.if-else-if中可以有任意多个条件。
    2.最后一个else可以没有。
    3.if-else能使用的时候，尽量使用if-else

class IfElseIfDemo {
    public static void main(String[] args) {
        //先有成绩
        int score = 50;
        /*
        //If结构
        //成绩>=90 ：奖励葵花宝典
        if(score >= 90){
            System.out.println("奖励葵花宝典");
        }
        //90>成绩>=80 ：奖励辟邪剑谱
        if (90 > score && score >= 80) {
            System.out.println("奖励辟邪剑谱");
        }
        //80>成绩>=60 ：废除武功
        if (80 > score && score >= 60) {
            System.out.println("废除武功");
        }
        //成绩<60 ：逐出师们
        if (score < 60) {
            System.out.println("逐出师们");
        }



        //if-else结构
        //成绩>=90 ：奖励葵花宝典
        if(score >= 90){
            System.out.println("奖励葵花宝典");
        }else{
            //90>成绩>=80 ：奖励辟邪剑谱
            if (score >= 80) {
                System.out.println("奖励辟邪剑谱");
            }else{
                //80>成绩>=60 ：废除武功
                if (score >= 60) {
                    System.out.println("废除武功");
                }else{      //成绩<60 ：逐出师们
                    System.out.println("逐出师们");
                }
            }
        }
        */

        //if-else-if结构
        //成绩>=90 ：奖励葵花宝典
        //90
        if(score >= 90){
            System.out.println("奖励葵花宝典");
        }else if (score >= 80) { //90>成绩>=80 ：奖励辟邪剑谱
            System.out.println("奖励辟邪剑谱");
        }else if (score >= 60) { //80>成绩>=60 ：废除武功
            System.out.println("废除武功");
        }else{      //成绩<60 ：逐出师们
            System.out.println("逐出师们");
        }

    }
}

如果我要去卫生间，我要看一下，如果是男卫生间，我才进去。
if（如果是男卫生间）｛
进去
｝
否则在java用使用else来表示
if-else结构
if(布尔表达式){
//如果“布尔表达式”结果为true,则执行这里
}else{
//如果布尔表达式结果为false，则执行else部分
}

令狐冲参加考试：如果成绩大于95就奖励“小师妹”，如果成绩小于等于95，奖励“小师弟”
    先有一个成绩，int score = 98;
    判断条件：成绩>95
    if（成绩>95）{
        奖励小师妹
    }else{
        奖励小师弟
    }

class IfElseDemo {
    public static void main(String[] args) {
        //先有一个成绩，
        int score = 90;
        //判断条件：成绩>95
        if(score > 95){
            System.out.println("奖励小师妹");
        }else{
            System.out.println("奖励小师弟");
        }

    }
}

三元运算符：
布尔表达式？值1：值2；
if-else结构：
if(布尔表达式){

    }else{

    }

区别：
    1.三元运算符的值必须只有一条语句。
    2.三元运算符的值，必须是有结果的。


    求两个数的最大值。

class IfElseSanYuan {
    public static void main(String[] args) {
        int a = 5;
        int b = 6;
        int max;
        //三元运算符
        max = a > b ? a:b;

        //ifelse结构
        if (a > b) {
            //max = a;
            System.out.println("a比较大");
        }else{
            //max = b;
            System.out.println("a比较大");
        }

        System.out.println(max);
    }
}

switch结构，是专门用来判断相等的语法结构
格式：
switch(表达式或者变量){
case 常量1:
//语句1 当switch的表达式或者变量的值是“常量1”，就是执行语句1
break;
case 常量2:
//语句2 当switch的表达式或者变量的值是“常量2”，就是执行语句2
break;
……
default: //这个东西就是switch结构的否则。
//语句
break;
}

令狐冲去参加比武大会
如果获得第一名，将出任武林盟主
如果获得第二名，将出任武当掌门
如果获得第三名，将出任峨嵋掌门
否则，将被逐出师门

class SwitchDemo {
    public static void main(String[] args) {
        //先有一个名次
        int mc = 3;
        switch(mc){
            case mc > 2:
                System.out.println("出任武林盟主");
                System.out.println("哈哈哈");
                break;
            case 2:
                System.out.println("出任武当掌门");
                System.out.println("呵呵呵");
                break;
            case 3:
                System.out.println("出任峨嵋掌门");
                System.out.println("嘿嘿嘿");
                break;
            default:  //这个东西就是switch结构的否则。
                System.out.println("逐出师门");
                System.out.println("呜呜呜");
                break;
        }
    }
}

switch结构注意事项：
1.case和default没有顺序要求。
2.case标签不允许重复。
3.switch结构的表达式或者变量的值，必须是byte、short、int、char、String(JDK1.7之后才可以)
4.default可以省略，建议永远不要省略。
5.break可以省略，但是不允许省略，如果省略，则会出现穿透效果。
6.case后边的值，必须是常量。

switch执行流程：
    1.先计算表达式，得到表达式的结果
    2.拿着结果去和case的值一一对比。
        如果找到了，则执行相应的case的模块。
        如果没找到，则去找default。
        如果default都没有找到，则switch结构结束。

        不管是找到了谁，只要找到了就执行相应的模块。执行相应模块时，遇到break，switch结构才结束。
        如果没有遇到就一直向下执行，直到遇到break或者switch结构模块结束。
        这种现象就叫做穿透。

class SwitchDemo2 {
    public static void main(String[] args) {
        int mc = 1;
        //int a = 1;
        switch(mc){
            default:  //这个东西就是switch结构的否则。
                System.out.println("逐出师门");
                System.out.println("呜呜呜");
                break;
            case 3:
                System.out.println("出任峨嵋掌门");
                System.out.println("嘿嘿嘿");
                break;
            case 1:
                System.out.println("出任武林盟主");
                System.out.println("哈哈哈");
                break;
            case 2:
                System.out.println("出任武当掌门");
                System.out.println("呵呵呵");
                break;


        }
    }
}

自己给定一个月份，判断属于哪个季节。（3-5月为春季、6-8月为夏季、9-11月为秋季、12,1,2月为冬季）

class SwitchTest {
    public static void main(String[] args) {
        //自己给定一个月份
        int month = 2;
        switch(month){
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;

            default:
                System.out.println("请输入1-12");
                break;  
        }

    }
}

循环结构：重复性的操作某一件事。
循环结构四大要素：
1.初始化语句。循环之前的准备工作。一般情况下，初始化语句用来定义循环变量
2.循环判断语句。用来判断循环是否继续执行下去。
3.循环变化语句。对于循环变量的改变或者操作。
4.循环体。循环的那个东西。

    循环结构有三种结构：
        for、while、do-while
        for循环结构的格式：
            for(初始化语句;循环判断语句;循环变化语句){
                循环体
            }

        for循环结构的执行流程：
            1.先执行初始化语句。
            2.循环判断语句
                如果结果为true，执行循环体。
                如果结果为false，结束循环。
            3.执行循环体。
            4.执行循环变化语句
            5.执行循环判断语句，其实是回到了第2步
        注意事项：
            1.循环判断语句结果必须是boolean类型。
            2.循环要避免死循环


循环变量：记录循环次数的那个变量。

案例：去操场跑圈，跑10圈。
    1.定义循环变量（跑的圈数）
        int num = 0;
    2.循环判断语句：结果必须是boolean类型。
        如果结果为true，则循环继续执行下去。
        圈数<10   时继续跑下去。
    3.循环变化语句：就是让循环变量+1，num = num+1;  //num++
    4.循环体“跑圈”

class ForDemo {
    public static void main(String[] args) {
        /*
        for(int num = 0;num < 10;num++){
            System.out.println("继续跑"+(num+1));
        }
        */
    }
}

循环嵌套:java支持循环相互嵌套。
执行顺序：
1.先执行外层循环
2.外层循环执行一次，内层循环就执行一遍。

class ForForDemo {
    public static void main(String[] args) {
        //外层for循环
        for (int a = 1;a <= 3;a++) {
            System.out.println("外层循环："+a);
            for (int b = 1; b <= 3;b++) {
                System.out.println("内层循环："+b);
            }
        }
        /*
            外层循环：1
                内层循环：1
                内层循环：2
                内层循环：3
            外层循环：2
                内层循环：1
                内层循环：2
                内层循环：3
            外层循环：3
                内层循环：1
                内层循环：2
                内层循环：3
        */
    }
}

请输出一个4行5列的星星(*)图案

---

---

---

---

输出的时候，每个*都单独输出

class ForForTest1 {
    public static void main(String[] args) {
        /*
        //保证了4行。
        for (int a = 1;a<=4;a++) {
            System.out.println("*");
        }
        //这个循环输出5个*
        for (int b = 1;b<=5;b++) {
            System.out.print("*");
        }
        */

        //保证了4行。
        for (int a = 1;a<=4;a++) {
            //这个循环输出5个*
            for (int b = 1;b<=5;b++) {
                System.out.print("*");
            }
            System.out.println(); //这句话就是只换行            
        }

    }
}

在控制台输出九九乘法表。（\t:一个制表符的位置）

class ForForTest4 {
    public static void main(String[] args) {
        //外层保证9行
        for (int a = 1; a <= 9;a++) {
            //内层循环输出（行号a）个
            for (int b= 1;b<=a;b++) {
                System.out.print(b+"*"+a+"=" + a*b+"\t");
            }
            //换行
            System.out.println();
        }
    }
}

打印倒金字塔：
#######
#####
###
#

class ForForTest5 {
    public static void main(String[] args) {
        //保证4行
        for (int a = 1;a<=4;a++) {
            //空格
            for (int b = 1;b<=a-1;b++) {
                System.out.print(" ");
            }

            //#号
            for (int c = 1;c<=9-a*2;c++) {
                System.out.print("#");
            }
            System.out.println();
        }


    }
}

总结：

位移运算符(了解)
操作的是二进制数据。
三元运算符：
格式：
布尔表达式 ？表达式1：表达式2;
如果布尔表达式结果为true，则三元表达式取表达式1的值。
如果结果为false，取表达式2的值。
注意事项：
1.表达式1和表达式2的值的类型必须一样或者兼容。
运算符优先级：
赋值运算符是最后执行的。
顺序结构：
从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
格式：
switch(表达式或者变量){
case 值1:
执行语句1 //当表达式或者变量的值是”值1”，则执行这里。
break;
case 值2:
执行语句2 //当表达式或者变量的值是”值2”，则执行这里。
break;
……
default: //代表了否则。
执行语句 //当上述值都不等于表达式或者变量的值时，执行这里。
break;
}
注意事项：
1.case和default没有顺序要求。
2.case的值不允许重复。
3.case的值只能是常量。
4.表达式或者变量的值的类型只能为”byte、short int char String(JDK1.7之后才可以)”
5.default可以省略，但是不建议省略。
6.break可以省略，但是不允许省略，如果省略会反生穿透效果。

循环结构：
循环四要素：
1.初始化语句。循环之前的准备工作。一般用来定义循环变量。
2.循环判断语句。判断循环是否继续执行下去。
3.循环变化语句。循环之后的变化，一般操作控制循环变量。
4.循环体。循环的东西。
for循环格式：
for(初始化语句;循环判断语句;循环变化语句){
循环体
}
执行顺序：
1.先执行初始化语句
2.循环判断语句
如果结果为true，则执行下一步，执行循环体
如果结果为false，则循环结束。
3.循环体
4.执行循环变化
5.执行循环判断语句，其实就是回到了第2步。

    for(int a=1;a<=100;a++){

    }

循环嵌套:
执行流程：
1.先执行外层循环，然后执行内层循环。
2.外层循环执行一次，内层循环就执行一遍。

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