Java基础概述

Posted 2020-10-16

案例：猜数字小游戏

需求：产生一个随机数，用户输入数字进行猜这个数字，如果猜大了，就提示猜大了，猜小了就提示猜小了，直到猜中为止。

/*
猜数字小游戏
思路：1、有一个随机数，所以要创建Random类来实现随机数
         2、需要用户去输入这个数字，要创建Scanner类来实现输入的功能
         3、用户输入的数字一直到和随机数相同才，所以需要循环（while）去实现
         4、需要一个判断语句去判断是否猜中，根据不同的结果返回不同的提示
*/
import java.util.Random;
import java.util.Scanner;
public class GuessGame{
         public static void main(String[] args){
                   System.out.println("请输入1~100的整数：");
                   //实现随机数
                   Random ran = new Random();
                   int ranNumber = ran.nextInt(100)+1;
                   //需要用户输入数据
                   Scanner sc = new Scanner(System.in);
                   //while循环
                   while(true){
                            int scNumber = sc.nextInt();
                            if(ranNumber>scNumber){
                                     System.out.println("猜小了");
                            }else if(ranNumber<scNumber){
                                     System.out.println("猜大了");
                            }else{
                                     System.out.println("猜中了");
                                                                          break;
                            }
                   }       
         }
}

switch选择语句

switch选择语句的格式：

switch(表达式){

    case 常量1:

       要执行的语句;

       break;

    case 常量2:

       要执行的语句;

       break;

    case 常量3:

       要执行的语句;

       break;

    …

    default:

       要执行的语句；

       break;

}

执行流程：将表达式和case的常量值进行比较，如果相等，就执行该case下的语句，break跳出整个switch语句，如果都没有匹配的，就执行default下的语句。

下面的代码演示了switch语句的具体体现：

/*
switch选择语句的体现
需求：
如果是1，就输出星期一
如果是2，就输出星期二
如果是3，就输出星期三
如果是4，就输出星期四
如果是5，就输出星期五
如果是6，就输出星期六
如果是7，就输出星期日
*/
public class SwitchDemo{
         public static void main(String[] args){
                   //定义一个变量来和要输出的代码进行匹配
                   int week = 7;
                   switch(week){
                            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;
                   }
         }
}

运行结果：

case具有穿透性，什么是穿透性，就是当表达式和常量匹配后，如果下面的case没有break，会直接执行他们的执行语句，知道遇到break为止。

具体代码的体现如下：

/*
case的穿透性体现
需求：在星期一到星期五为工作日，星期六到星期天为休息日
*/
public class SwitchDemo_1{
         public static void main(String[] args){
                   //定义一个变量来和case的值进行匹配
                   int week = 2;
                   switch(week){
                            case 1:
                            case 2:
                            case 3:
                            case 4:
                            case 5:
                                     System.out.println("今天是工作日");
                                     break;
                            case 6:
                            case 7:
                                     System.out.println("今天是休息日");
                                     break;
                            default:
                                     System.out.println("没有这个星期");
                                     break;
                   }
         }
}

运行结果：

数组

当数据有很多时，这时候使用定义变量的方式会变得很麻烦，而且代码会变得很繁琐，这是就需要用到数组。数组就是一组数据的集合，每个数据被称为是元素，同一数据类型的数组可以放入很多指定数据类型的同数据。，注意必须是同类型的数据才能放入同类型的数组中。

定义数组的格式：数据类型[] 数组名 = new 数据类型[元素的个数];

格式分析：数据类型：要存储数据的数据类型，存储什么数据就定义什么数据类型

      []代表数组的意思

      数组名：给这个数组起一个名字，起名遵循标识符的规则就可以。

      new就是创建一个新的数组

     元素的个数就是要存储元素的长度（长度不可以被改变）。

比如：定义一个整数类型的数组，长度为4

    int[] arr = new int[4];

如何去操作数组中的元素呢？这就需要对数组进行索引的操作。什么是索引呢，通俗讲就是数组元素的编号，它的索引是从0开始的，最大值是数组的长度减1，下面就用一段代码来演示如何用索引对数组进行操作。

/*
索引的操作演示
*/
public class ArrayDemo{
         public static void main(String[] args){
                   //定义一个长度为3的整数数组
                   int[] arr = new int[3];
                   //对数组的每个元素用索引进行打印
                   System.out.println(arr[0]);
                   System.out.println(arr[1]);
                   System.out.println(arr[2]);
         }
}

运行结果：

如何获取数组的长度：数组名.length

数组的最小索引是0，最大索引就是数组名.length-1

数组还有另外两种定义的方式，这种方式不用定义长度，而是直接可以定义元素：

格式一：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,…,元素n };

格式二：数据类型[] 数组名 = {元素1,元素2,元素3,…,元素n };

两种方式相比较，第二种方式更为常用，下面对两种格式用代码进行体现：

/*
数组定义的另外两种格式
*/
public class ArrayDemo_1{
         public static void main(String[] args){
                   //第一种格式：定义一个整数类型的数组
                   int[] arr = new int[]{1,3,6,8,0,5};
                   //获取该数组的长度
                   System.out.println(arr.length);
                   //使用索引对数组进行操作
                   System.out.println(arr[3]);
                   System.out.println("--------------------");
                  
                   //第二种格式：定义一个整数类型的数组
                   int[] arr1 = {9,4,1,8,3};
                   //获取该数组的长度
                   System.out.println(arr1.length);
                   //使用索引对数组进行操作
                   System.out.println(arr1[3]);
         }
}

运行结果：

如何用索引对数组中的元素进行赋值？看下面的代码演示：

/*
使用索引对元素进行赋值操作
*/
public class ArrayDemo_2{
         public static void main(String[] args){
         //定义一个长度为4的整数数组
         int[] arr = new int[4];
         //用索引对元素赋值
         arr[1] = 3;
         System.out.println(arr[1]);
         System.out.println(arr[2]);
         }
}

运行结果：

数组的遍历

所谓遍历就是通过索引的方式，将数组中的元素全部进行获取，下面通过代码来实现数组的遍历：

/*
数组的遍历实现
*/
public class ArrayDemo_3{
         public static void main(String[] args){
                   //定义一个数组
                   int[] arr = {4,5,6,8,9,1,3};
                   //利用for循环遍历数组
                   for(int i = 0;i < arr.length;i++){
                            System.out.print(arr[i]);
                   }
         }
}

运行结果：

数组异常的情况

数组最常见的异常有两种：

1.         数组角标越界异常，这种异常通常是因为索引不存在或者是角标超出数组的长度

2.         空指针异常，这种异常通常是将该数组arr= null，这时这个数组已经不存在了，所以会操作空指针异常

下面通过一段代码将两个异常出现的情况进行演示：

/*
数组异常的代码实现
*/
public class ArrayDemo_4{
         public static void main(String[] args){
                   //第一种异常情况：角标越界异常
                   int[] arr = new int[3];
                   //System.out.println(arr[3]);//Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
                  
                   //第二种异常情况：空指针异常
                   arr = null;
                   System.out.println(arr[3]);//Exception in thread "main" java.lang.NullPointerException
         }
}

案例：获取一个数组中的最大值

/*
获取数组的最大值
思路：
1、定义一个整数数组，给出具体的元素
2、定义一个变量max来记录住数组角标为0的元素，
3、进行数组的遍历
5、使用判断语句用max和其他角标的元素进行比较，max的值如果小的话，就把这个元素的值赋值给max，这样max里面的值一直是最大的哪那个值
6、打印max的值即可
*/
 
public class ArrayBestTest{
         public static void main(String[] args){
                   //1、定义一个整数数组，给出具体的元素
                   int[] arr = {4,8,60,80,119};
                   //2、定义一个变量max来记录住数组角标为0的元素
                   int max = arr[0];
                   //进行数组的遍历
                   for(int i = 1;i < arr.length;i++){
                            //使用判断语句用max和其他角标的元素进行比较
                            if(max < arr[i]){
                                     //将大的值赋值给max
                                     max = arr[i];
                            }
                   }
                   //6、打印max的值即可
                   System.out.println(max);
         }
}