「讲课」Java基础篇（1）

package com.junbao.java;

/**
 * author : Majunbao
 * github : https://github.com/MaJunBaox
 * time   : 4/27/22 2:43 PM
 * desc   :
 */
public class ArrayDemo2 {
    public static void main(String[] args) {
        /**
         * 标识符：常用语变量，常量，方法，的名称
         *      标识符不能有空格，开头不能是数字 ，不能是关键词 ，不能是特殊符号 ，可以以$开头 可以是_开头
         *      举例： class  void  static  Class  1sum  ￥num  sum  _name $com  age2
         *          符合的：Class sum  _name  $com   age2
         *          不符合的： 关键字：class void  static
         *                   数字开头：1sum
         *                   特殊符号：￥num
         *
         * 关键词：关键字就是 public  class static void extends等
         *      关键词不能用作变量或常量的名称
         *
         * 基本数据类型：
         *          int ，byte ，short ，long ，double ，float，char ，boolean
         *
         * 引用数据类型：
         *          String ， 对象 ，类 ，数组等
         *          除基本数据类型以外的，都是引用数据类型
         *
         * 基本数据类型的比较：
         *          基本数据类型使用 == 号，比较值是否相等
         *              举例：
         *                  int a = 1； int b =2 ；
         *                  if（a==b）输出false
         *          > 大于号 < 小于号 只能比较基本数据类型
         *
         * 应用数据类型的比较：
         *          引用数据类型使用 equals()进行比较值
         *              举例：
         *                  String a ="a"; String b = "b";
         *                  if(a.equals(b)) 输出false
         *                  String c = "a"；
         *                  if(a.equals(c)) 输出true
         *                  因为a 和 c的值相等
         *                  if(a==c) 输出false
         *          equals()比较值是否相等 == 比较引用地址是否相等
         *
         *
         * 变量：可以改变的量 叫做变量
         *      int age =10； age可以被改变 所以叫做变量
         *      String name = "a"；变量
         *      float f1 = 1f； 变量
         *      double d1 = 1.0； 变量
         *
         * 常量：被final修饰的变量叫做常量 ，常量不能被改变
         *      final String name = "a"; 常量
         *
         *
         * 数组：
         *      一维数组
         *      二维数组
         *
         *      创建方式有2中：
         *              1. int[] intArray = {1,2,3,4};
         *              2. int[] intArray = new int[4];
         *      数组的下标 是 从0 开始的
         *      第一种方式：必须指定数组的值 ，如果长度 为6 ，其他地方 没有赋值 ，则值为0
         *          举例：定义int类型数组，长度为6，下标2的位置 值为3
         *              int[] intArray = {0,0,3,0,0,0};
         *
         *      第二种方式：必须指定数组的长度 new int[4] ，4代表数组的长度为4，数组小标的默认值为0
         *          举例：int[] intArray = new int[4];
         *              输出intArray[0] ,结果为 0
         *              输出intArray[1] ,结果为 0
         *              输出intArray[4] ,报错 下标越界
         *      两种创建方式的区别：
         *              1.第一种需要指定数组的值 ，第二种不需要 ，默认值为0
         *
         *
         *      数组的取值，赋值
         *          取值：
         *              举例：
         *                  int[] intArray = {1,2,3,4};
         *                  取值：intArray[0] 输出1
         *                  取值：intArray[1] 输出2
         *                  取值：intArray[4] 报错 下标越界
         *
         *          赋值：
         *              举例：
         *                  int[] intArray = {1,2,3,4};
         *                  赋值：intArray[0] = 2 将下标为0位置的1 ，更改为2
         *                  赋值：intArray[1] = 3 将下标为1位置的2 ，更改为3
         *                  赋值：intArray[4] = 3 报错 下标越界
         *
         *              如何拿到数组的长度？
         *                  通过数组名称.length
         *                      举例：
         *                          int[] intArray = {1,2,3,4};
         *                          输出（intArray.length）结果 4
         *
         *         注意：两种创建方式的取值 ，赋值操作是一样的
         *
         *        如何遍历取出数组中的值，并输出?
         *          for(int i = 0 ; i < intArray.length ; i ++){
         *               System.out.print(intArray[i])
         *          }
         *          理解：int i = 0 ; 变量  ，i < intArray.length；条件 ，i ++ 自增
         *
         *
         *       二维数组：
         *          1.int[][] intArray ={{1,2,3},{4,5,6},{7,8,9}};
         *
         *          2.int[][] intArray =new int[3][3];
         *
         *          数组的长度：intArray.length
         *
         *          可以把二维数组看成 ，一维数组里面的元素 是 一个 一维数组
         *          数组长度就查{}里面有多少个小括号
         *
         *          如何取值，赋值？
         *              取值:
         *                  首先拿到里面的元素的数组 ，然后在拿元素数组里面的值
         *                  举例 取出元素5的值，首先插元素为5在第几个{}里面，然后查元素5在大{}的下标为几得位置
         *                  intArray[1] 取出的是 {4,5,6} ,{4,5,6}可以看成一维数组 ，我们再取出一维数组的5
         *                  intArray[1][1] ,5的下标是1 ，下标从0开始 ，所以是intArray[1][1]
         *              赋值：
         *                  还是以5为例子 ，把5改成10
         *                  首先拿到5所在{}的下标 ，5的大括号下标是1
         *                  然后拿到5所在一维数组的下标 ，{4,5,6} 5在下标为1的位置
         *                  intArray[1][1] = 10； 即可
         *          如何循环取出二维数组的值？
         *              分析：首先吧二位数组理解成是两个一维数组，一个一维数组里面的值，又是一个一维数组，这个就是二维数组
         *                    ，那想拿到里面的值 ，必须遍历 ，一维数组 ，在一维数组里，在遍历一维数组才行
         *
         *                  int[][] intArray ={{1,2,3},{4,5,6},{7,8,9}};
         *
         *                  1.首先遍历intArray二维数组
         *                  for(int i = 0 ; i < intArray.length ; i ++){
         *                      取出里面的一维数组 intArray[0] 取出的就是 {1,2,3}的一维数组
         *                      依次取出里面的一维数组，分别是 intArray[0]，intArray[1]，intArray[2]
         *                      intArray[0] 里面得值是{1,2,3} ,是一个一维数组 ，我们需要 遍历他 输出里面的值，实际上和一维数组遍历一样
         *                      首先拿到一维数组的长度 intArray[0].length ,循环遍历
         *
         *                      intArray[i].length 为什么是i ， 因为有3个一维数组需要遍历 ，intArray[0]的 intArray[1]的 intArray[2]的
         *                      for(int j = 0 ， j < intArray[i].length ; j++){
         *                             这时候 和 一维数组 取值 一样 ，首先 通过intArray[i]拿到{1,2,3} ，然后通过intArray[i][j]取值
         *                             int num = intArray[i][j]；
         *                             System.out.print(num);
         *
         *                             或者System.out.print(intArray[i][j]);
         *
         *                             输出的结果是 1，2，3，4，5，6，7，8，9
         *                      }
         *                  }
         *
         *   与或非
         *      &&短路与
         *      || 或
         *      ！ 非
         *
         *      &&：有一个为假就为假
         *      ||： 有一个为真就为真
         *      ！： 非真既假
         *
         *      &&与&的区别 ：&&如果第一个条件不符合 ，不会继续判断其他条件 ，直接为假
         *                  & 如果第一个条件不符合，还是会继续判断其他条件
         *
         *
         *  switch的使用
         *      Scanner scanner = new Scanner(System.in);
         *      int num = scanner.nextInt();
         *
         *      switch(num){
         *          case:1:
         *             System.out.Print("1");
         *          break;
         *          case:2:
         *             System.out.Print("2");
         *          break;
         *          case:3:
         *             System.out.Print("3");
         *          break;
         *          default:
         *             System.out.Print("输入错误");
         *          break;
         *
         *      }
         *
         *      解释：输入一个数 ，如果是1或者2或者3，正常输出 ，如果输入其他数字 提示输入错误
         *
         *      if else的使用
         *
         *      if(条件){
         *
         *      }else if(条件){
         *
         *      }else{
         *
         *      }
         *
         *      如果if里面的语句成立 ，则直接走if里 ，不成立 ，会继续判断else if ，如果else if 成立 ，则直接走 else if ，不成立 ，如果还有else if
         *      继续判断else if ，如果没有else if ，则直接走else
         *
         *
         *      while的使用
         *
         *      while(条件){
         *
         *      }
         *      如果while条件成立 ，会一直循环，直到while的条件不成立才会停止
         *
         *      do while的使用
         *      do{
         *
         *      }while(条件)
         *      如果do while条件成立 ，会一直循环，直到do while的条件不成立才会停止
         *
         */



    }
}