java基础知识梳理

1、JDK的下载、安装、环境变量配置
2、使用记事本开发Java程序
3、变量
    概念：存储数据的空间（装数据的容器），为了区分不同的变量，Java虚拟机会给每个变量分配一个地址值，这个地址值不便于程序员操作
        我们会给每个变量取个名
    变量命名规则：
        1）由字母、数字、下划线_、美元符号$组成
        2）不能以数字开头，不建议使用美元符号开头
        3）不能使用Java关键字（关键字是Java中有特殊含义的单词，Java中大概有50个关键字）
        4）变量名使用小驼峰命名法（变量名由多个单词组成时，第一个单词首字母小写，其余单词首字母大写）
        5）变量名做到见名知意
        6）变量名严格区分大小写
4、数据类型
    基本数据类型（8个）：
        数值类型：
            整型：
                byte、short、int、long
            浮点型（小数）：
                float、double
        非数值类型：
            字符型：
                char：使用单引号''括起来的数据，单引号中只能写一个英文符号或者一个中文汉字
            布尔型：
                boolean：布尔类型的数据只有两个数据，一个true，一个false
    引用数据类型（3个）：
        数组、类、接口
5、变量的使用
    声明变量：在内存中开辟一个空间用来存储数据
        数据类型 变量名;
            int num;
    赋值：将数据存储到变量中
        变量名 = 数据;
            num =200;
    操作数据：直接操作变量名就是操作变量中的数据
        输出数据：System.out.print(变量名);
        修改变量中的值：变量名 = 数据;
        
    
    声明变量、赋值可以合并写：
        数据类型 变量名 数据;
            int num = 200;
            
6、常量    
        使用final修饰的变量，称之为常量，常量值只能赋值一次
            常量名字母全部大写，如果由多个英文单词组成，那么多个英文单词之间使用_隔开
            一般在常量声明的时候给常量赋值
7、Scanner的使用
    作用：Scanner类是JDK中已经定义好的类，通过该类可以在程序运行过程中输入各种类型的数据
    使用步骤：
        1）第一步：导包
        2）第二步：创建Scanner对象
        3）第三步：调用方法获取不同类型的数据
            next()：获取字符串类型数据
            nextInt()：获取int类型数据
            nextDouble()：获取double类型数据
            
8、运算符：通过各种运算符对变量中的数据进行运算
    1）赋值运算符：=
        数据类型 变量名 = 表达式;
            表达式：操作数与运算符的结合体。例如 3+5，a+b
    2）算术运算符：
        基本算术运算符：+ - * / %(取模运算符/取余运算符) ++(自增) --(自减)
        复合算术运算符：+= -+ *= /= %=
    3）关系运算符(比较运算符)：> >= < <= == !=
        关系运算符的结果是布尔值，要么为true，要么为false
        > >= < <=只能进行数值类型数据的比较
        ==、!=既可以进行数字类型数据的比较，也可以进行引用数据类型地址值的比较
    4）逻辑运算符：&(单与) &&(双与/短路与) |(单或) ||(双或/短路或) !(非/取反)    
        逻辑运算符与和或，左右两边都需要有布尔类型的表达式，非运算只需要在右边有一个布尔值
        逻辑运算符的运算结果也为布尔值
        &&和||具有短路功能：&&左边和||左边表达式足以判断运算结果时，右边表达式不再判断
    5）条件运算符(三目运算符/三元运算符)：
        语法结构：
            条件?表达式1:表达式2;
        执行规律：
            条件为true，执行表达式1
            条件为false，执行表达式2
        
        扩展：条件运算符的嵌套
            语法结构：    
                条件1?(条件2?表达式1:表达式2):(条件3?表达式3:表达式4);
                执行规律：
                    首先判断条件1：
                        如果条件1为true，继续判断条件2：
                            如果条件2为true，执行表达式1
                            如果条件2为false，执行表达式2
                        如果条件1为false，继续判断条件3：
                            如果条件3为true，执行表达式3
                            如果条件3为false，执行表达式4
9、运算符优先级：表达式中同时包含多个运算符，运算符执行的先后问题就是优先级
    单目运算符优先级最高
    ()可以提升运算符优先级，()优先级最高
    算术运算符>关系运算符>逻辑运算符
10、流程控制
    顺序结构：程序代码从上往下依次执行
    选择结构（分支结构）：
        1）if选择结构
            （1）单分支if选择结构：
                    语法结构：    
                        if(条件){
                            //代码块语句;
                        }
                    执行流程：
                        判断条件，如果条件为true，执行代码块语句，执行完结束if结构，如果条件为false，就跳过if结构
            （2）双分支if选择结构：
                    语法结构：
                        if(条件){
                            //代码块语句1;
                        }else{
                            //代码块语句2;
                        }
                    执行规律：    
                        判断条件，如果条件为true，执行代码块语句1，如果条件为false，执行代码块语句2，执行完相应的语句块之后，就结束if-else结构
            （3）多分支if选择结构：
                    语法结构：
                        if(条件1){
                            //代码块语句1;
                        }else if(条件2){
                            //代码块语句2;
                        }else if(条件3){
                            //代码块3;
                        }......
                        
                        }else if(条件n){
                            //代码块n;
                        }else{
                            //代码块m;
                        }
                    执行规律：    
                            判断条件1，如果条件1为true，执行代码块1，执行完代码块1之后就结束整个if-else-if结构
                            如果条件1为false，判断条件2，如果条件2为true，执行代码块2，执行完代码块2之后就结束整个if-else-if结构
                            如果条件2为false，判断条件3，如果条件3为true，执行代码块3，执行完代码块3之后就结束整个if-else-if结构
                            ....
                            如果条件n为true，执行代码块n，执行完代码块n之后就结束整个if-else-if结构
                            如果所有的条件都为false，执行else里面的代码块m
                    注意事项：
                        else里面的代码是所有条件都不成立时执行，else也可以省略不写，如果省略不写，所有条件不成立，那么整个if-else-if结构都不执行
            （4）嵌套if选择结构：在一个if结构中包含另外一个if结构
                    语法规则：
                        if(条件){
                            //代码块语句;
                            if(条件){
                            //代码块语句;
                            }else{
                                //代码块语句;
                            }
                        }else{
                            //代码块语句;
                            if(条件){
                            //代码块语句;
                            }else{
                                //代码块语句;
                            }
                        }
                    执行规律：
                        按照if结构执行规律，一层一层的执行代码即可
        2）switch选择
            语法结构：    
                switch(表达式){
                    case 值1:
                        代码块语句1;
                        break;
                    case 值2:
                        代码块语句2;
                        break;
                    ......
                    case 值n:
                        代码块语句n;
                        break;
                    default:
                        代码块语句m;
                        break;
                }
            执行规律：    
                计算表达式的值，将表达式的值与case后面的值进行匹配，如果表达式的值与case后面的相同，就执行相应的代码块语句，执行完代码块语句后，执行break，结束整个Switch选择结构
                如果表达式的值与所有的case值都不匹配，执行default里面的代码块语句m，执行完代码块语句m之后，执行break，结束整个Switch选择结构
            注意事项：    
                1）case后面的值不能相同
                2）break的作用结束Switch结构，如果没有break，代码会继续执行到下一个case里面，直到遇到break或者直行道default里面，这个现象称之为case穿透现象
                3）default语句是所有case值与表达式值不匹配时执行的，default语句可以写在任意位置，一般写在末尾。default语句也可以省略不写，如果case值与表达式值不匹配，又没有default语句，那么Switch结构就不会执行
        3）比较switch选择结构和多分支if选择结构：
            相同点：都可以处理多分支的情况
            不同点：switch选择结构只能处理条件是等值（具体的值）问题，多分支if选择结构既可以处理条件是等值问题，也可以处理条件是范围类型问题
    循环结构：需要重复性（反复）执行的问题使用循环结构解决
        1）while循环
            语法结构：    
                初始值;
                while(条件){
                    循环操作代码块;
                    迭代代码语句;
                }
            执行规律：    
                首先执行一次初始值代码
                判断循环条件，如果循环条件为true，就执行循环操作代码块和迭代代码语句，然后再去判断循环条件，根据循环条件的结果决定是否继续执行循环操作
                    如果循环条件为false，就结束整个while循环结构，继续执行while循环结构后面的代码
            注意事项：    
                条件是布尔值
                while循环是先判断循环条件，再根据循环条件的结果决定是否执行循环操作，如果第一次循环条件就不成立，那么循环操作一次都不执行
        2）do-while循环
            语法结构：    
                初始值;
                do{
                    循环操作代码;
                    迭代代码;
                }while(条件);
            执行规律：    
                首先执行一次初始值代码
                然后去执行循环操作代码和迭代代码
                再去判断循环条件，根据循环条件的结果决定是否继续执行循环操作代码
            注意事项：    
                条件是布尔值
                do-while循环是先执行一次循环操作代码。然后再去判断循环条件，根据循环条件的结果决定是否继续执行循环操作，如果第一次判断循环条件就不成立，do-while循环操作只执行一遍
        3）for循环
            语法结构：
                for(初始值代码;循环条件;迭代代码){
                    循环操作代码
                }
            执行规律：    
                首先执行一次初始值代码
                判断循环条件，如果循环条件为true，就执行循环操作代码块和迭代代码语句，然后再去判断循环条件，根据循环条件的结果决定是否继续执行循环操作
                    如果循环条件为false，就结束整个while循环结构，继续执行while循环结构后面的代码
            注意事项：
                条件是布尔值
                for循环是先判断循环条件，再根据循环条件的结果决定是否执行循环操作，如果第一次循环条件就不成立，那么循环操作一次都不执行
        4）多重循环结构：在一个循环结构中包含另外一个完整的循环结构，不管怎么嵌套，严格按照循环结构执行规律来做就可以了
            在这里以双重for循环为例：
            语法结构：    
                for(初始值代码;循环条件;迭代代码){
                    循环操作代码
                    for(初始值代码;循环条件;迭代代码){
                        循环操作代码
                    }
                }
            执行规律：    
                根据循环结构的执行规律，判断外层循环结构的循环条件，如果外层循环结构的条件为true，进入{} 中执行相应代码，以及判断内层循环结构条件，再根据内层循环条件的结果决定是否执行内层循环结构的循环操作代码
                执行完内层循环操作代码，外层循环迭代代码再执行
                
                外层循环变量变化1次，内层循环变量变化1遍（只有内层循环操作全部执行完之后，外层循环才会进行迭代）
                外层循环变量控制行数，内层循环变量控制列数
11、跳转语句
    1）break：
        作用场景：switch选择结构中、循环结构
        作用：结束整个switch选择结构、结束整个循环结构
    2）continue语句：
        作用场景：只能作用在循环结构中
        作用：结束当前（本次）循环结构后续操作，继续执行下一次循环操作
    3）return：
        作用场景：方法中
        作用：结束方法的执行返回到方法调用处，除了结束方法作用外，也可以在结束方法的同时返回一个结果
12、程序调试：
    1）设置断点
    2）单步运行
    3）观察变量
13、数组
    1）概念：存储数据的空间（装数据的容器），可以存储多个相同类型的数据
    2）数组组成部分：
        数据类型 数组名 下标(从0开始) 数组元素
    3）数组操作数
        声明数组：
            数据类型[] 数组名;
        分配空间：
            数组名 = new 数据类型[数组长度];
        赋值：
            数组名[下标] = 数据;
        操作数组元素：
            数组名[下标];
            
        声明数组、分配空间合并写：
            数据类型[] 数组名 = new 数据类型[数组长度];
        声明数组、分配空间、赋值合并写：
            数据类型[] 数组名 = new 数据类型[]{数据1,数据2,...,数据n};
        声明数组、分配空间、赋值合并简写：
            数据类型[] 数组名 = {数据1,数据2,...,数据n};
    4）数组应用
        数组遍历：
            普通for循环遍历：
                for(int i =0;i<数组名.length;i++){
                    System.out.print(数组名[i]);
                }
            增强for循环遍历：
                for(数据类型 变量名 : 数组名){
                    System.out.print(变量名);
                }
        求数组最大值/最小值：
            （1）假设数组中的第一个元素为最大值或者最小值
            （2）循环依次取出数组中的元素与假设的最大值或者最小值比较，如果取出的值比最大值大或者比最小值小，就成为新的假设的最大值或者最小值
            （3）比较结束后，获得最大值或者最小值
        向排序好的数组中插入数据：
            （1）新建一个比原来数组长度大一的新数组
            （2）将原来数组中的元素按照下标顺序存储在新数组中
            （3）获取要插入的元素
            （4）通过循环比较，得到插入数组要插入的位置
            （5）从插入位置开始及之后的元素依次往后移动一位
            （6）将要插入的元素储存到插入位置中
        冒泡排序(升序)：
            //外层循环控制比较的轮数
            for(int i =0;i<数组名.length-1;i++){
                //内层循环控制每一轮的比较次数
                for(int j =0;j<数组名.length-1-i;j++){
                    //比较相邻的两个元素，满足条件，交换数据
                    if(数组名[j]>数组名[j+1]){
                        数据类型 变量名 = 数组名[j];
                        数组名[j] = 数组名[j+1];
                        数组名[j+1] = 变量名
                    }
                }
            }
14、多维数组：数组的嵌套，数组的元素还是一个数组
    1）二维数组：二维数组的本质还是一个一维数组，只是这个一维数组的元素还是一个一维数组
    2）二维数组的操作
        声明数组：
            数据类型[][] 数组名;
        分配空间：
            数组名 = new 数据类型[数组长度][数组长度];
        赋值：
            数组名[下标][下标] = 数据;
        操作数组元素：
            数组名[下标][下标];
            
        声明数组、分配空间合并写：
            数据类型[][] 数组名 = new 数据类型[数组长度][数组长度];
        声明数组、分配空间、赋值合并写：
            数据类型[][] 数组名 = new 数据类型[][]{{数据1,数据2,...,数据n},{数据1,数据2,...,数据n},...,{数据1,数据2,...,数据n}};
        声明数组、分配空间、赋值合并简写：
            数据类型[][] 数组名 = {{数据1,数据2,...,数据n},{数据1,数据2,...,数据n},...,{数据1,数据2,...,数据n}};;
    3）二维数组操作
        遍历二维数组
            for(int i =0;i<数组名.length;i++){
                for(int j =0;j<数组名[i].length;j++){
                    System.out.print(数组名[i][j]+" ");
                }
                //换行
                System.out.println();
            }