java入门

方法入门

定义一个方法的格式：
public static vo 方法名称（）{
方法体
}
方法名称的命名规则和变量一样，使用小驼峰。
方法体：也就是大括号当中可以包含任意条语句。

注意事项：
1.方法定义的先后顺序无所谓
2.方法的定义不能产生嵌套包含关系。
3.方法定义好了之后，不会执行的。如果想要执行，一定要进行方法的【调用】。

如何调用方法，格式：

方法名称();

public class Method{
	public static void main(String[] args){
farmer();//调用农民伯伯的方法
seller();//调用小商贩的方法
cook();//调用厨子的方法
	

	}
	
		//农民伯伯
		public static void farmer(){
System.out.println("播种");
System.out.println("浇水");
System.out.println("施肥");
System.out.println("除虫");
System.out.println("收割");
System.out.println("卖给小商贩");

}
//小商贩
		public static void seller(){
System.out.println("运输到市场");
System.out.println("提高价格");
System.out.println("吆喝");
System.out.println("卖给厨子");
		}
		//厨子
		public static void cook(){
		System.out.println("洗菜");
		System.out.println("切菜");
		System.out.println("炒菜");}
		System.out.println("装盘");
}

关于编译器

在给变量进行赋值的时候，如果右侧的表达式当中全是常量，没有任何变量，那么编译器javac将会直接将若干个常量表达式计算得到结果
short result = 5+8; 等号右边全都是常量，没有任何变量参与运算 编译之后，得到的.class字节码文件当中相当于【直接就是】：
short result =13;
右侧的常量结果数值没有超过左侧范围，所以正确。
这称为“编译器的常量优化”
但是注意：一旦表达式中有变量参与，那么就不能进行这种优化了。

public class Notice{
	public static void main(String[] args){
	short num1= 10;//正确写法，右侧没有超过左侧的范围
	short a = 5;
	short b = 8;
	//short + short --> int +int -->int
	//short result = a + b;//错误写法！左侧需要是int类型
	
	//右侧不用变量，而是采用常量，而且只有常量，而且只有两个常量，没有其他
	short result = 5 + 8;//13
	System.out.println(result);
	}
}

流程

顺序结构

public class Sequence{
		public static void main(String[] args){
		System.out.println("今天天气不错");
		System.out.println("挺风和日丽的");
		System.out.println("我们下午没有课");
		System.out.println("这的确挺爽的");
		}
}

判断语句

if语句第一种格式： if

if(关系表达式){
语句体;
}
执行流程
1.首先判断关系表达式看起结果是true还是false
2.如果是true就执行语句体
3.如果是false就不执行语句体

public class If{
		public static void main(String[] args){
		System.out.println("今天天气不错，发现一个网吧")；
		int age=16；
		if(age >=18){
	System.out.println("进入网吧，开始high");
	System.out.println("遇到HP队友");
	System.out.println("感觉不爽，下机");
}
		System.out.println("回家吃饭")：
		}
	}

if语句的第二种格式: if…else

if(关系表达式){
语句体1;
}else{
语句体2;
}

执行流程
1.首先判断关系表达式看其结果是true还是false
2.如果是true就执行语句体1
3.如果是false就执行语句体2

public class  IfElse {
	public static main(String[] args)[
//
int num = 13;
if(num%2 ==0){//如果除以2能够余数为0，说明是偶数
System.out.println("偶数");
}else{
System.out.println("奇数");
}
}

If语句的第三中格式：if…else if…else

if(判断条件1){
执行语句1;
}else if （判断条件2）{
执行语句2：
}
. . .
}else if（判断条件n）{
执行语句n；
}else{
执行语句n+1;
}

执行流程
首先判断条件1看起结果是true还是false
如果是true就执行语句体1
如果是false就继续看判断条件2 看其结果是true还是false
如果是true 就执行语句体2
如果是false就继续看判断条件…看其结果是true还是false
. . .

public class IfElseIfElse{
		public static main(String[] args){
		//x和y的关系满足如下：
		//如果x>=3, 那么y= 2x + 1；
		//如果 -1<x<3,那么y = 2x;
		//如果x <= -1,那么 y = 2x -1;
		//根据给定的x的值，计算出y的值并输出。
		//定义变量
		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);
}
}

语句练习

指定考试成绩，判断成绩等级。
！90-100 优秀
！80-89 好
！70-79 良
！60-69 及格
！60以下 不及格

public class IfPractice {
    public static void main(String[] args) {
        int score = 500;

        if(score<0 || score>100){
            System.out.println("成绩是错误的");
    }else if (score>=90 && score<=100){
            System.out.println("优秀");
        }else if (score>=80 && score<=89){
            System.out.println("好");
        }else if (score>=70 && score<=79){
            System.out.println("良");
        }else if (score>=60 && score<=69){
            System.out.println("及格");
        }else {
            System.out.println("不及格");
        }
    }
}

练习：用if语句替换三元运算符

题目：使用三元运算符和标准的if-else语句分别实现：取两个数字当中的最大值

public class	Max{
	public static void main(String[] args){
int a =10;
int b =20;
//首先使用三元运算符
//int max =a>b? a:b;
使用今天的if 语句
int max;
if(a>b){
max=a;}
else{
max=b;
}
System.out.println("最大值:"+max);
}
}

选择语句switch

语句格式：
switch（表达式）{
case 常量值1：
break；
case 常量值2：
语句体2；
break；
. . .
default:
语句体n+1;
break；
}
执行流程
1.首先计算出表达式的值
2.其次，和case以此比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
3.最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

public class Switch {
    public static void main(String[] args){
        int num = 20;
        switch (num){
            case 1:
                System.out.println("星期1");
                break;
            case 2:
                System.out.println("星期2");
                break;
                case 3:
                System.out.println("星期3");
                break;
                case 4:
                System.out.println("星期4");
                break;
            case 5:
                System.out.println("星期5");
                break;
            case 6:
                System.out.println("星期6");
                break;
            case 7:
                System.out.println("星期天");
                break;
            default:
                System.out.println("数据不合理");
                break;
        }
    }
}

switch语句使用的注意事项

1.多个case后面的数值不可以重复。
2.switch后面小括号当中只能是下列数据类型：
基本数据类型：byte/short/char/int
引用数据类型：String字符串、enum枚举
3.switch语句格式可以很灵活：前后顺序可以颠倒，而且还可以省略。

匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止。

public class SwitchNotice {
    public static void main(String[] args){
        int num=1;
        switch (num){

            case 2:
                System.out.println("我");
                break;
            case 3:
                System.out.println("大家");
                break;
            case 1:
                System.out.println("你");
                break;
            default:
                System.out.println("他");
        }
    }
}

循环语句

循环结构的基本组成部分，一般可以分成四部分：
1.初始化语句：在循环开始最初执行，而且只做唯一一次。
2.条件判断：如果成立，则循环继续；如果不成立，则循环退出。
3.循环体：重复要做的事情内容，若干语句。
4.步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。

for循环语句格式

语句格式：
for（初始化表达式①；布尔表达式②；步进表达式④）{
循环体③
}
执行流程
1.执行顺序：①②③④>②③④>②③④. . . ②不满足为止。
2.①负责完成循环变量初始化
3.②负责判断是否满足循环条件，不满足则跳出循环
4.③具体执行的语句
5.④循环后，循环条件所涉及变量的变化情况

public class For {
    public static void main(String[] args){
        for(int i=59;i<=100;i++){
            System.out.println("我错了"+i);
        }
        System.out.println("程序停止");

    }
}

while循环

while循环有一个标准格式，还有一个扩展格式。

标准格式：
while（条件判断）{
循环体
}

扩展格式：
初始化语句；
while（条件判断）{
循环体；
步进语句；
}

public class While {
    public static void main(String[] args){
      int i=1;//初始化语句
      while (i<=10){//条件判断
          System.out.println("我错了"+i);//循环语句
          i++;//步进语句
      }
    }
}

dowhile循环

do-while循环的标准格式：
do{
循环体
}while（条件判断）;

扩展格式：
初始化语句
do{
循环体
步进语句
}while（条件判断）;

public class DoWhile {
    public static void main(String[] args){
       int i =1;//初始化语句
        do{
            System.out.println("原谅你了"+i);
            i++;
        }while (i<=10);//条件判断
    }
}

循环练习题

for循环做的

/*题目：求出1-100之间的偶数和。
思路：1.从1-100一个一个检查2.判断（if）偶数：num%2==0
3.需要一个变量用来累加操作。类似于存钱罐。
*/
public class HundredSum {
    public static void main(String[] args){
         int sum=0;//用来累加的存钱罐
            for(int i=1;i<=100;i++){
                if (i%2==0){
                    //如果是偶数
                    sum+=i;
                }
            }
            System.out.println("结果是"+sum);
    }
}

while做的

public class HundredSum {
    public static void main(String[] args){
         int sum=0;//用来累加的存钱罐
        int i=1;
          while (i<=100){
              if (i%2==0){
                  sum+=i;
              }


              i++;

          }System.out.println("结果是"+sum);
    }
}

dowhile做的

public class HundredSum {
    public static void main(String[] args){
        int sum=0;//用来累加的存钱罐
      int i=1;
      do {
          if (i%2==0){
              sum+=i;
          }

          i++;
      }while (i<=100);
      System.out.println("结果是"+sum);
        
    }
}

三种循环的区别

三种循环的区别
1.如果条件判断从来没有满足过，那么for循环和while循环将会执行0次，但是do-while循环会执行至少一次。
2.for循环的变量在小括号当中定义，只有循环内部才可以使用。
3.while循环和do-while循环初始化语句本来就在外面，所有出来循环之后还可以继续使用。

public class LoopDifference {
    public static void main(String[] args){
        for (int i=1;i<0;i++){
            System.out.println("帅");
        }
       // System.out.println(i);//这一行是错误写法，因为变量定义在for循环小括号内，只有for循环自己才能使用
        System.out.println("=============");

    int i=1;
    do{
        System.out.println("丑");
        i++;
    }while (i<0);
//现在已经超出了do-while循环的范围，我们仍然可以使用变量i。
        System.out.println(i);//2
    }
}

循环控制break语句

break关键字的用法有常见的的两种：
1.可以用在switch语句当中，一旦执行，整个switch语句立刻结束。
2.还可以用在循环语句当中，一旦执行，整个循环语句立刻结束，打断循环。

关于循环的选择，有一个小建议：
凡是次数确定的场景多用for循环；否则多用while循环。

public class Break {
    public static void main(String[] args){
        for (int i=1;i<=10;i++){
            //如果希望从第4次开始，后续全都不要了，就要打断循环
            if (i==4){//如果当前是第四次
                break;//打断循环
            }
            System.out.println("Hello"+i);
        }
    }
}

循环控制—continue语句

continue关键字
一旦执行，立刻跳过当前次循环剩余内容，马上开次下一次循环。

public class Continue {
    public static void main(String[] args){
        for (int i=1;i<=10;i++){
            if (i==4){//如果现在是第四层
                continue;//那么跳过当前次循环，马上开始下一次循环
            }
            System.out.println(i+"层到了");
        }
    }
}

死循环

永远停不下来的循环，叫做死循环
死循环的标准格式：
while（true）{
循环体
}

public class DeadLoop {
    public static void main(String[] args){
       while(true) {


           System.out.println("java");
           //break;
       }
        }
            
        }

循环嵌套

public class LoopHourAndMinute {
    public static void main(String[] args){
        for (int hour = 0; hour <24 ; hour++) {//外层是小时

            for (int minute=0;minute<60;minute++){//内层是分钟
                System.out.println(hour+"点"+minute+"分");
            }


        }
    }
}