假设认识Java的第三天

假设认识Java的第三天必会的知识

1. 方法的入门：
   在我们平时学习中，我们编写一个功能的时候，能不能把一些常用的功能，提取到一个地方，下次用的时候直接调用。
   a.方法：就是将一个功能抽出来，把代码单独定义一个大括号中，形成一个独立的功能。
   当我们需要这个功能的时候，就可以直接调用，这样实现了代码的复用性，也解决了代码冗余的现象
   b.方法的定义：
   格式：
   修饰符 返回值类型 方法名（参数列表）{
   代码…
   return;
   }
   c.定义格式的解释：
   修饰符：目前固定写法public static
   返回值类型：目前固定写void，其他的返回值类型后面写
   方法名：就是我们的方法起个名，满足我们标识符的规则就可以
   参数列表：目前无参数，带参数我们后面带参的返回值一起将。
   return: 方法的结束，因为返回值目前我们的写的是void，方法的大括号的return可以不写

public class Dome {
    public static void main(String[] args) {
        //方法的调用
    addAddStudent();
    }
//无参无返回值的方法的简单的定义
    public static void addAddStudent() {
        System.out.println("欢迎！");
        return;//void下return 可以省略
    }
}

调用练习
将三元运算代码抽取我们的自定义方法中，并调用

public class test01 {
    public static void main(String[] args) {
        //通过方法名调用我们的方法
        operater();
    }
//定义不带参数和返回值的方法，三元运算
    public static void operater() {
        int i=0;
        i=(i==2?200:300);
        System.out.println(i);
        int j=0;
        j=(3<4?400:500);
        System.out.println(j);
    }
}
/*注意事项：
1、方法定义必须定义在类中方法外
2、方法不能定义再另外一个方法的里面*/

扩展

public class test02 {
    public static void main(String[] args) {
        short s=1;
        s+=1;
        // s=s+1;编译有错误
        System.out.println(s);

    }
}

分析：s+=1逻辑上可以看做是s=s+1,计算结果被提升为int类型，在向short类型转换发生错误，因此范围大的赋值给取值范围小的类型。但是，s=s+1进行运算它进行了两次，+=是一个运算符，只能运算一次，并带有强制转换的功能。

public class test03 {
    public static void main(String[] args) {
        byte b1=1;
        byte b2=2;
        byte b3=1+2;//没问题
        byte b4=b1+b2;//报错
    }
}

分析：b3=1+2,1和2都是常量，为固定不变的数据，在编译的时候（编译器javac），已经确定了1+2的结果并有超过byte类型的取值范围，可以赋值给变量b3，因此b3=1+2.是正确。
反之，b4=b2+b1; b2和b1是变量，变量的值是可以发生变化，在编译的时候，编译器javac不确定b2+b1的结果是什么，因此会将结果以int类型进行处理，所有int类型不能赋值给我们的byte类型，因此编译报错。

2. 流程控制：
   在一个程序执行过程中，各条语句的执行顺序对程序的结果是有直接的影响的，也就是说，程序的流程对运行的结果有直接的影响，所以，我们必须清楚每条语句的执行流程，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。
   a.顺序结构

public class test04 {
    public static void main(String[] args) {
        //顺序执行，根据编写的顺序，从上到下执行
        //ctrl+d;复制一行
        System.out.println("1");
        System.out.println("2");
        System.out.println("3");
        System.out.println("4");
    }
}

3. 判断语句：
   a.判断语句if
   格式：
   If(关系表达式){
   语句体;
   }
   执行流程：首先判断关系表达式看其结果是true还是false，如果为true那么就会执行语句体。如果为false，那么就会跳过语句体。

public class test05 {
    public static void main(String[] args) {
        System.out.println("开始");
        //定义两个变量
        int a=10;
        int b=20;
        //变量使用if判断
        if (a==b){
            System.out.println("a 等于b");
        }
        int c=10;
        if (a==c){
            System.out.println("a等于c");
        }
        System.out.println("结束");
    }
}

b.判断语句if–else
格式：
If（关系表达式）{
语句体1；
}else{
语句体2；
}
执行流程：首先判断关系表达式看其结果true还是false，如果是true就会执行语句体1，如果是false，那么就会执行语句体2。

public class test06 {
    public static void main(String[] args) {
        //
        int a=1;
        if (a%2==0){
            System.out.println("a是一个偶数");
        }
        else {
            System.out.println("a是一个奇数");
        }
        System.out.println("结束");
    }
}

c.判断语句if…else if()
格式：
If(关系表达式1){
执行语句体1;
}else if(关系表达式2){
执行语句体2;
}else if(关系表达式3){
执行语句体3;
}else{
语句体;
}

public class test07 {
    public static void main(String[] args) {
        int x=5;
        int y ;
        if (x>=3){
            y=2*x+1;
        }
        else if (x>=-1&&x<3){
            y=2*x;
        }
        else  {
            y=2*x-1;
        }
        System.out.println("y的值为："+y);
    }
}

4. 选择语句—switch
   a.格式：
   switch(表达式){
   case 常量值1：语句体;break;
   case 常量值2：语句体;break;
   case 常量值3：语句体;break;
   case 常量值4：语句体;break;
   default: 语句体;break;
   }
   b.执行流程：
   首先要计算出表达式的值，其次，和case依次做比较，一旦有对应的值，就会执行相应的语句，在执行过程中，遇到break就会结束。最后，如果所有的case的和表达式的值不匹配，就会执行我们的default语句体部分，然后程序结束。

public class test8 {
    public static void main(String[] args) {
        int weekday=6;
        switch (weekday){
            case 1:
                System.out.println("星期一");break;
            case 2:
                System.out.println("星期二");break;
            case 3:
                System.out.println("星期三");break;
            case 4:
                System.out.println("星期四");break;
            case 5:
                System.out.println("星期五");break;
            case 6:
                System.out.println("星期六");break;
            case 7:
                System.out.println("星期日");break;
                default:
                    System.out.println("输入的数字有误");break;
        }
    }
}

在switch语句中，表达式的数据类型：可以是byte，short，int，char，enum（枚举）,在jdk1.7以后，可以接受字符串。

5. 循环语句：
   循环语句可以在满足循环条件的基础上，反复执行一段代码，这段被重复执行的代码被称为循环内容，当我们反复执行这个循环体的时候，需要在合适的时候把循环条件修改false，从而结束循环，否则循环会一直执行下去，形成死循环。
   5.1.循环语句: for（掌握）：
   a.格式：
   for(初始化表达式1;布尔表达式2;步进表达式4){
   循环体3;
   }
   b.执行流程：
   1----2----3----4----2----3----4----2----直到我们的布尔表达式2不满足条件可以退出。
   初始化表达式1：完成我们的循环标量初始化
   布尔表达式2：负责判断满足循环条件，不满足则跳出循环
   循环体3：当你们满足条件的时候，具体要执行的语句
   步进表达式4：循环后，循环条件所涉及到变量的变化情况。

public class test09 {
    public static void main(String[] args) {
        for (int i = 1; i <100 ; i++) {
            System.out.println("HolleWorld");
        }

    }
}

5.2循环语句：while（掌握）
a.格式：
初始化表达式1;
while(布尔表达式2){
循环体3;
步进表达式4;
}
b.执行流程：
1-----2------3-----4-----2----3-----4----2。。直到我们的2不满足条件，我们的循环结束

public class test10 {
    public static void main(String[] args) {
        int i=1;
        while (i<10)
            System.out.println("a");
        i++;
    }
}

5.3循环语句：do…while（了解）
a.格式：
初始化表达式1;
do{
循环体2;
步进表达式3;
}while(布尔表达式4)
b.执行流程：
1-----2-----3-----4------2----3------4 直到4不满足条件。

public class dowhile {
    public static void main(String[] args) {
        int x=1;
        do {
            System.out.println("a"+x);
            x++;
        }
        while (x<=10);
    }
}
/*do---while循环的特点：无条件执行一次循环体，即使我们的将循环条件写为false，
也依旧会循环一次，这样循环的具有一定的风险性，初学者不建议使用。*/

d.循环语句的区别：
控制语句所控制的变量，在for循环结束，就不能再访问了，而while循环结束后还是可以继续使用的，如果你想继续使用，就使用while循环，否则使用for循环。原因就是，for循环结束后，该变量就从内存中消失，能够提高我们的内存的使用率。
在已经知道循环次数的时候，使用for，在不知道循环次数的时候，使用while。

6. 跳出语句
   break：
   使用场景：a.终止我们的switch语句，在选择结构中使用
   b.在循环语句中
   离开了这两个场景就没用。

public class test12 {
    public static void main(String[] args) {
        for (int i = 1; i <100 ; i++) {
            //打印两次HolleWorld循环结束
            if (i==3){
                break;
            }
            System.out.println("HolleWorld");
        }
    }
}
/*HolleWorld
HolleWorld
*/

continue：
使用场景：结束本次循环，继续下一次循环

public class test13 {
    public static void main(String[] args) {
        for (int i = 1; i <10 ; i++) {
            if (i==3){
                continue;
            }
            System.out.println("HolleWorld"+i);
        }
    }
}
/*结果
HolleWorld1
HolleWorld2
HolleWorld4
HolleWorld5
HolleWorld6
HolleWorld7
HolleWorld8
HolleWorld9*/