Java学习3

（一）、if语句

格式1：单条件判断

执行流程：

注意事项：
1.大括号开头可以另起一行写，建议写在第一行的末尾
2.在语句体中，如果只有一句代码，大括号可以省略不写
3.如果对一个布尔类型变量进行判断。不要用==号。直接把变量写在小括号里

格式2：双条件判断

执行过语句体1，则不会执行2

格式3：多条件判断

从上往下依次判断，只要有一个为真就执行当前语句体
全是假就执行最后一个else的语句体

（二）、switch语句

使用场景：把有限个数据一一列举出来，我们任选其一

格式：

执行流程：

注意事项：
1.表达式计算出的值类型为byte、short、int、char。jdk5以后可以是枚举，7以后可以是String
2.case后面跟的是和表达式进行比较的值
3.case后的值必须是字面量，不能是变量且值不能重复
4.default不一定写在最下面，可以省略但不建议
5.case穿透：语句体没有写break产生的，没有break会一直执行一直到遇见break或右大括号

switch的新特性（jdk12以上的版本）
可以省略break，并且不会触发case穿透，只有一行代码可以省略括号

case 1->{
	System.out.println("一");
	//将语句体写在括号里
}
default->{
System.out.println("一");
}

（三）、for循环

一个循环尽量只做一件事
使用场景：知道循环次数或者循环范围
格式：

执行流程：

如果将变量定义在循环里面，则变量只能在当次循环有效

（四）、while循环

使用场景：不知道循环的次数和范围，只知道循环的结束条件
格式：

与for循环的区别：

练习1：

package tdjava;

import sun.awt.geom.AreaOp;

public class iflx {
    public static void main(String[] args) {
        double height=8844430;
        double paper=0.1;
        int count=0;
        while(paper<height){
            paper=paper*2;
            count++;
        }
        System.out.println(count);
    }
}

练习2：

package tdjava;

public class t2 {
    public static void main(String[] args) {
        int x=123;
        int temp=x;//定义一个临时变量存储x的初始值
        int num=0;//记录倒过来的值
        while(x!=0){
            //从右往左获取每一位的数字
            int ge=x%10;
            //每次循环去掉获取过的值
            x=x/10;
            //拼接获取到的数字
            num=num*10+ge;
        }
        System.out.println(num);
        System.out.println(x);
        System.out.println(num==temp);//打印是不是回文数的判断结果
    }
}

练习3：

package tdjava;

public class t3 {
    public static void main(String[] args) {
        int d1=20;//被除数
        int d2=3;//除数
        int count=0;
        while (d1>=d2){
            d1=d1-d2;
            count++;
        }
        System.out.println(count);//商
        System.out.println(d1);//余数
    }
}
//原理是不断的用被除数-除数，只要被除数>=除数就一直循环，循环次数就是商，最后的被除数的值就是余数

do while：

会先执行循环体再判断，不论条件是否正确，循环体都会执行一次

（五）、循环练习

5.1无限循环：三种形式

注意：无限循环下方不能再写代码，因为永远不会执行到

5.2跳转控制语句

continue： 结束本次循环，继续下次循环
break：结束整个循环

5.3 逢七过

package tdjava;

public class t5 {
    public static void main(String[] args) {
        for (int i = 1; i <= 100; i++) {
            //判断 7倍数 十位7 个位7
            //满足一个即可
            if(i%7==0 ||i/10%10==7||i%10==7){
                System.out.println(i);
            }
        }
    }
}

5.4 平方根

package tdjava;

import java.util.Scanner;

//从1开始，用数字的平方根与number比较
//如果相等就是平方根
//如果大于number那么就是前一个数就是平方根的整数部分
public class t6 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("输入一个整数");
        int number=sc.nextInt();
        for (int i = 0; i < number; i++) {
            if(i*i==number){
                System.out.println(i+"就是"+number+"的平方根");
                break;//符合条件直接退出循环，提高效率
            }else if(i*i>number){
                System.out.println((i-1)+"就是"+number+"平方根的整数部分");
                break;//符合条件后直接退出循环
            }
        }  
    }
}

5.5 判断质数

package tdjava;

import java.util.Scanner;

public class t7 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("输入一个整数");
        int number =sc.nextInt();
        //可以定义一个变量表示标记，类型为布尔
        boolean flag=true;
        //循环从2开始，到number-1结束。判断有没有数字可以被number整除
        for (int i = 2; i < number - 1; i++) {
            if(number%i==0){
                flag=false;
                break;
            }
        }
        if(flag){
            System.out.println(number +"是一个质数");
        }else{
            System.out.printf(number+"不是一个质数");
        }
    }
}

思路2：循环结束到number的平方根

5.6 猜数字游戏

使用Random类生成随机数：

随机数范围是从0开始，到随机数-1结束（包头不包尾，包左不包右）

生成任意范围的随机数：
1.让这个范围头尾都减去一个值，让他从0开始
2.尾巴+1
3.最终的结果，再加上第一步减去的数
如：7-15

既最大范围-最小范围加1为括号内的值，括号外最小范围的值

package tdjava;

import java.util.Random;
import java.util.Scanner;

public class t8 {
    public static void main(String[] args) {
        Random r=new Random();
        int number=r.nextInt(100)+1;

        //不知道循环次数，使用while循环，设置成死循环直到猜中才跳出循环
        while (true){
            Scanner sc=new Scanner(System.in);
            System.out.println("输入猜的数字");
            int guessn=sc.nextInt();
            if (guessn>number){
                System.out.println("大了");
            } else if (guessn<number) {
                System.out.println("小了");
            }else{
                System.out.println("正确");
                break;
            }
        }
    }
}

（六）、数组

数组指的是一种容器，可以用来存储同种类型数据的多个值
存储时需要结合隐式转换来考虑

6.1数组的定义

格式1：

格式2：

静态初始化：

简化格式：数据类型 [] 数组名 = {元素1，元素2}

动态初始化：创建时我们给出长度，虚拟机给出默认初始化的值

默认初始化的规律：
整数类型：0
字符类型：‘/u0000’ 既空格
小数类型：0.0
布尔类型：false
引用数据类型：null

数组的地址值：直接打印数组会获得数组的地址值
如：[D@776ec8df
[：表示是一个数组
D：表示数据类型是double
@：是一个间隔符，固定格式
776ec8df：真正的地址值

6.2 数组的访问

格式： 数组名[索引]
索引从0开始

6.3数组的储存

数组名[索引]=具体数据/变量

6.4 数组的遍历

将数组中的所有内容取出来
遍历指的是取出数据的过程，不要局限的理解为打印

package tdjava;

public class t4 {
    public static void main(String[] args) {
        int str[]={1,2,3,4};
        for (int i = 0; i < str.length; i++) {
            System.out.println(str[i]);
        }
    }
}

idea快捷键：数组名.fori

6.5 数组常见问题

索引越界异常：访问了不存在的索引

6.6 数组的内存图

Java的内存分配：

数组存在堆内存

6.6 数组练习

求最大值：max初始化的值必须是数组中的值

package tdjava;

public class t9 {
    public static void main(String[] args) {
        int[]arr={33,5,22,44,55};
        int max=arr[0];//用max来记录当前的最大值，每一个值都跟max比较，比max大就赋值为新的max
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]>max){
                max=arr[i];
            }
        }
        System.out.println(max);
    }
}

遍历数组求和：

package tdjava;

import java.util.Random;

public class t10 {
    public static void main(String[] args) {
       double sum=0;
        int count=0;//记录多少个数据比平均值小
        int []arr=new int [10];//动态初始化长度为10的数组
        for (int i = 0; i < arr.length; i++) {
            Random r= new Random();
            arr[i]=r.nextInt(100)+1;
        }//给数组赋值

        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }//求和

       double average=sum/arr.length;//平均值

        for (int i = 0; i < arr.length; i++) {
            if(arr[i]<average){
                count++;
            }
        }
        System.out.println("和为"+sum);
        System.out.println("平均数为"+average);
        System.out.println("比平均数小的有"+count+"个");
    }
}

交换数组：通过中间容器交换

（七）、方法

方法是程序中最小的执行单元
重复的代码，具有独立性的代码可以抽取到方法中
有利于提高代码的复用性，提高代码的可维护性

7.1 方法的定义和调用

方法必须先定义再调用
方法定义的技巧：

最简单方法的定义：

调用：方法名（）

带参方法的定义：

方法名（变量/具体的参数）
传入参数的类型和数量必须和定义的相同

形式参数：方法中定义的参数
实际参数：方法调用中的参数

带返回值的方法的定义：
方法的返回值就是方法运行完的最终结果

赋值调用 类型 变量=方法名（）

7.2 方法注意事项

1.方法与方法是平级，不能相互嵌套
2.方法不调用就不执行
3.方法的执行顺序与编写顺序无关
4.方法的返回值类型为void，表示该方法无返回值，没有返回值的方法可以省略return，如果要写不能跟具体数字（此时return表示为结束方法）
5.return语句下面不能写代码
6.方法有返回值，必须写return，表示返回值和结束方法

7.3 方法的重载

同一个类当中，方法名相同但是参数不同的方法就构成了重载。与返回值无关
参数不同：类型不同，顺序不同，个数不同
相同功能的方法会起成一个名字

7.4 方法的值传递

传递基本数据类型时，传递的是真实的值，形参的改变不影响实参
传递引用数据类型时，传递的是地址值，形参的改变会影响实参

（八）、引用数据类型和基本数据类型

基本数据类型变量存储的是一个具体的值
数据值存储在自己的空间，赋值给其他变量也是赋的真实的值

引用数据类型变量存储的是地址值，引用了其他空间的数据
数据值存储在其他空间，自己的空间存储地址值。赋值给其他变量的是地址值

（九）、综合训练

9.1 飞机票

package tdjava;

import java.util.Scanner;

public class z1 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入月份");
        int month=sc.nextInt();
        System.out.println("请输入机票原价");
        double pnumber=sc.nextDouble();
        System.out.println("请输入座位类型 0是头等舱 1是经济舱");
        int ptype=sc.nextInt();
        if (month>=5 && month<=10){
            if(ptype==0){
                pnumber=pnumber*0.9;
                System.out.println( "价格为" + pnumber);
            }else {
                pnumber=pnumber*0.85;
                System.out.println( "价格为" + pnumber);
            }
        } else{
            if(ptype==0){
                pnumber=pnumber*0.7;
                System.out.println( "价格为" + pnumber);
            }else {
                pnumber=pnumber*0.65;
                System.out.println( "价格为" + pnumber);
            }
        }
    }
}

cctrl+alt+M 自动抽取方法

9.2 验证码

package tdjava;

import java.util.Random;

public class z2 {
    public static void main(String[] args) {
        //1.先将所有字母放进数组当中
        char[] chs=new char[52];
        for (int i = 0; i < chs.length; i++) {
          if(i<=25){
              chs[i]=(char)(97+i);
          }else{
              chs[i]=(char)(65+i-26);
          }
        }
        //2.随机抽取4次
        String result="";
        Random r=new Random();
        for (int i = 0; i < 4; i++) {
            int randomindex=r.nextInt(chs.length);
            result+=chs[randomindex];
        }
        //3.随机抽取数字0-9
        result=result+r.nextInt(10);
        System.out.println(result);
    }
}

9.3 评委打分

package tdjava;

import java.util.Scanner;

public class z3 {
    public static void main(String[] args) {
        //1.定义数组存储分数
        int[] score=new int[6];
        Scanner sc =new Scanner(System.in);
        for (int i = 0; i < score.length; i++) {
            System.out.println("请输入评委打分(0-100)");
            int doc=sc.nextInt();
            if(doc>=0 && doc<=0){
                score[i]=doc;
            }else{
                System.out.println("分数有误");
                i--;
            }
        }
        //2.求出数组中的最大值
        int max=score[0];
        for (int i = 1; i < score.length; i++) {
            if(max<score[i]){
                max=score[i];
            }
        }
        //3.求出数组中的最小值
        int min=score[0];
        for (int i = 1; i < score.length; i++) {
            if(min>score[i]){
                min=score[i];
            }
        }
        //4.求数组的和
        int num=0;
        for (int i = 0; i < score.length; i++) {
            num+=score[i];
        }
        //5.计算平均分：（总和-最大值-最小值）/4
        System.out.println("平均分为" +(num-max-min)/4);
    }
}

9.4数字加密

package tdjava;

import java.util.Scanner;

public class z4 {
    public static void main(String[] args) {
        //1.把整数里的每一位放到数组中
        //1.1计算数组长度
        Scanner sc=new Scanner(System.in);
        System.out.println("输入一个大于0的数字");
        int number=sc.nextInt();
        int temp=number;//用于第三步
        int count=0;
        while (number!=0){
            number=number/10;
            count++;
        }//循环每次去掉一位数，count加1，直到0结束
        //1.2定义数组
        int[] arr=new int[count];
        //1.3把整数上的每一位都添加到数组当中去
        int index=arr.length-1;
        while (temp!=0){
            int ge=temp%10;
            temp=temp/10;
            arr[index]=ge;
            index--;
        }
        //2.加密
        for (int i = 0; i < arr.length; i++) {
            arr[i]=arr[i]+5;
        }
        for (int i = 0; i < arr.length; i++) {
            arr[i]=arr[i]%10;
        }
        for (int i = 0,j=arr.length-1; i < j; i++,j--) {
            int temp1=arr[i];
            arr[i]=arr[j];
            arr[j]=temp1;
        }
        //3.把数组中的每一位进行拼接，得到加密后的结果
        int number1=0;
        for (int i = 0; i < arr.length; i++) {
            number1=number1*10+arr[i];
        }
        System.out.println("加密后为" + number1);
    }
}

解密：%10返回的一步

9.5 抽奖

第一种：

package tdjava;

import java.util.Random;

public class z5 {
    public static void main(String[] args) {
        int[] arr={2,588,888,1000,10000};//表示奖池
        int[] newArr=new int[arr.length];//储存抽奖结果
        //抽奖
        Random r=new Random();
        for (int i = 0; i < 5;) {
            int index=r.nextInt(arr.length);
            int prize=arr[index];
            boolean flag=contains(newArr,prize);
            if(!flag){
                newArr[i]=prize;
                i++;
            }
        }
        for (int i = 0; i < newArr.length; i++) {
            System.out.println(newArr[i]);
        }
    }
    //定义一个方法判断抽到的奖品是否已经被抽取
    public static boolean contains(int[] arr,int price){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==price){
                return true;
            }
        }
        return false;
    }
}

第二种：

package tdjava;

import java.util.Random;

public class z5_1 {
    public static void main(String[] args) {
        //直接打乱奖池里的顺序
         int[] arr={2,588,888,1000,10000};
        Random r=new Random();
        for (int i = 0; i < arr.length; i++) {
            int index=r.nextInt(arr.length);
            int temp=arr[i];
            arr[i]=arr[index];
            arr[index]=temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

9.6 双色球

package tdjava;

import java.util.Random;
import java.util.Scanner;

public class z6 {
    public static void main(String[] args) {
        //1.生成中奖号码
        int[] arr=createNumber();
        //用户输入号码
        int[] userInputArr=userInput();
        //判断有没有中奖
        int redCount=0;
        int blueCount=0;

        //判断红球
        for (int i = 0; i < userInputArr.length-1; i++) {
            int redNumber=userInputArr[i];
            for (int j = 0; j < arr.length-1; j++) {
                if (redNumber==arr[j]){
                    redCount++;
                    break;
                }
            }
        }
        int blueNumber=userInputArr[userInputArr.length-1];
        if (blueNumber==arr.length-1){
            blueCount++;
        }

        if (redCount==6 && blueCount==1){
            System.out.println("中一等奖");
        }else if (redCount==6&&blueCount==0){
            System.out.println("二等奖");
        } else if (redCount==5&&blueCount==1) {
            System.out.println("中三等奖");
        } else if (redCount==4&&blueCount==1) {
            System.out.println("中四等奖");
        }else if (redCount==4&&blueCount==0){
            System.out.println("中四等奖");
        } else if (redCount==3&&blueCount==1) {
            System.out.println("中五等奖");
        } else if (redCount==2&&blueCount==1) {
            System.out.println("中五等奖");
        } else if (redCount==1&&blueCount==1) {
            System.out.println("中六等奖");
        }else if (redCount==0&&blueCount==1){
            System.out.println("中六等奖");
        }else {
            System.out.println("没中奖");
        }



    }

    public static int[] userInput(){
        int[] arr=new int[7];
        Scanner sc=new Scanner(System.in);
        //输入红球
        for (int i = 0; i < 6; ) {
            System.out.println("请输入第"+(i+1)+"个红球号码");
            int redNumber=sc.nextInt();
            if (redNumber>=1 && redNumber<=33){
                boolean flag=contains(arr,redNumber);
                if (!flag){
                    //有效
                    arr[i]=redNumber;
                    i++;
                }else {
                    System.out.println("已存在，重新输入");
                }
            }else {
                System.out.println("超出范围，重新输入 ");
            }


        }
        //输入蓝球
        System.out.println("输入蓝球号码");
        while (true){
            int blueNumber=sc.nextInt();
            if (blueNumber>=1 && blueNumber<=16){
                arr[arr.length-1]=blueNumber;
                break;
            }else {
                System.out.println("当前蓝球号码不符合要求");
            }
        }
        return  arr;
    }
    public static int[] createNumber(){
        //1.创建数组添加中奖号码
        //6红 1蓝
        int[] arr=new int[7];

        //2.生成随机号码,添加到数组中
        //红球不重复，蓝球可以跟红球重复
        Random r=new Random();
        //生成红球
        for (int i = 0; i < 6; ) {
      int redNumber=  r.nextInt(33)+1;
      boolean flag=contains(arr,redNumber);
        if (!flag){
            arr[i]=redNumber;
            i++;
        }

        }
        int blueNumber=r.nextInt(16)+1;
        arr[arr.length-1]=blueNumber;

        return arr;
    }
    //判断数字是否存在
    public static boolean contains(int[] arr,int number){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==number){
                return true;
            }
        }
        return  false;
    }

}

9.7 二维数组

静态初始化：

简化格式：

建议：定义时，每个单独的一维数组写一行
每一个一维数组是二维数组中的元素

获取元素：arr[i][j]
i：二维数组的索引，得到的是一维数组
j：一维数组的索引，得到的是一维数组中的元素

二维数组中的遍历：两个循环嵌套
第一个范围是arr.length
第二个范围是arr[i].length

动态初始化：

m是二维数组的长度
n表示二维数组的长度