javase基础笔记

Javace基础
Javaweb 前段技术  数据库技术Servlet
 ssm框架：
    Spring Springmvc Mybatis 主流三大框架
互联网架构阶段（Java的提升，大数据的基础）   
    java高级阶段
    大数据基础阶段
大数据阶段
    离线阶段

    实时阶段

Java简介:
    JAVA之父:
        James Gosling（高司令）詹姆斯.高斯林
    Java是一门高级编程语言，1995年由sun公司推
出的。
    2009年，sun公司被Oracle（甲骨文）公司收购。
    Oak吸收了C++的优点，摒弃了C++的缺点，采用了面向对象、跨平台等新思想
    Oak是Java的前身，后改名为JAVA，
    JAVA logo：咖啡杯
Oracle 数据库: 
    优点：稳定性 安全性  查询效率  存储量级相对高
    缺点：收费高
MySQL数据库:
    优点：免费

    
Java应用场景:
    1、嵌入式
    2、安卓开发
        Java开发-》安卓开发
        安卓开发-》Java开发
    3、网站后端开发--Java最重要的阵地  如京东、淘宝
    4、大数据、人工智能
        Hadoop框架原生语言是Java编写
Java语言的特点：
    1、开源：开放源代码
    2、面向对象：核心编程思想
    3、跨平台
    4、简单易学：和C语言相对比简单
    5、安全
跨平台：
    跨平台又称平台无关性   
    平台：
        操作系统：
            Windows  
            Linux
            安卓
            Mac系统
不跨平台的问题：
    1、人力 时间成本高
    2、不方便
概念：
    Java语言开发的程序，无需任何修改可以在任意一个平台上正常运行
JAVA原理：
    如：
        小明（JAVA）出国旅游 城市有韩国、美国、日本（平台），他直接去听不懂当地的语言，当地的也听不懂他说啥，他找一个翻译（JVM），就可以了
总结：
    1、Java跨平台的核心是JVM（java虚拟机）。JVM将Java程序转换为当前操作系统可以理解的指定，然后由系统来执行程序，完成Java程序的运行。
    2、JVM（JAVA  虚拟机）是JAVA跨平台的核心。将JAVA程序翻译成当前操作系统可以理解的指令，当前操作系统来调用自己的资源执行程序。
注意：
    1、不同的平台对应的JVM
    2、
2、跨平台的缺点？
    相比不跨平台的语言来说 效率有所降低
    效率影响不明显

Java环境的安装和配置
    
JVM    JRE    JDK
    JVM：Java虚拟机   是JAVA跨平台核心
    JRE：Java运行时环境   JRE=JVM+核心类库
    JDK：Java开发工具包   JDK=KRE+开发工具
安装JDK：
    Oracle官网下载
    JDK需要下载当前系统的版本
    JDK的版本号：
        JDK1.0-JDK1.1-JDK1.2----
        JDK里程碑的版本   JDK5
            提供了很多新特性    自动装箱      自动拆箱    泛型等
        JDK6-JDK7
        目前市场用JDK8，比较稳定 

检查当前环境是否已经安装JDK
    win+r快捷键打开命令面板
    输入Java -version命令
安装JDK-傻瓜式安装：
    修改安装目录-不要安装在C盘  安装路径中不要包含中文 空格 特殊字符

JRE安装弹窗可以不安装
配置环境变量：
    用户变量：
        只对当前用户生效
    系统变量：
        对所有用户生效
    定义JAVA_HOME环境变量：
        变量值 JDK的安装目录 具体到bin的上一级目录
    Path:Windows系统变量
        %JAVA_HOME%\bin
    再次测试是否能执行java -version命令

入门案例
    文件重命名快捷键F2
定义类（Java基本单位）：
    class 类名{}
        例如：class HelloWorld {}
    {}表示范围
执行程序
编译：
    .java文件编译成.class文件（字节码文件）
    格式：Javac Java文件名（.java）
        例如：Javac HelloWorld.Java
运行：
    格式：Java 类名（运行不加后缀）
        例如：java HelloWrold
注意：
    1、类中
    2、
    
在类中定义main方法
    main方法 主函数 程序入口
    格式：public static void main(String[] args){}
        public（公共的）
输出语句
    打印输出语句
    格式：System.out.println();
        例如：System.out.println("HelloWorld");
注意：
    1、一个Java文件中可以定义多个类
    2、每个类在编译之后都会产生一个对应的字节码文件，文件名和类名保持，，，（一个文件里面有两个类的话就有两个字节码文件）
    3、文件名和类名可以不一致
    4、如果类被public修饰，则要求类名必须和文件名保持一致，否则会报错
        一个Java文件中只能有一个public修饰的类
    5、单词拼写一定要正确  Java严格区分大小写，符号的全半角区分（只能半角）

关键字
概述:
    在Java中被赋予特定含义的单词
        例如：class - 定义类    public - 权限修饰符（公共的）
    Java中有50多个关键字
        true   false  null
    main不是方法，String是类型
关键字分为：
    访问控制、类方法和变量修饰符、程序控制语句、错误处理、包相关、基本类型、变量引用。
注意：
    1、关键字都是小写字母。
    2、开发工具eclipse  idea对于关键字有特殊的标识。
    3、const  goto是特殊的关键字，又称为保留字。
标识符
概述：
    在Java中给类、方法、变量、接口等起名字的字符序列
组成规则：
    1、英文大小写字母
    2、数字
    3、$  _
注意：
    1、标识符不能和关键字冲突
    2、数字不能开头也不能单独使用
    3、$_有特殊的应用场景  不建议随便使用
组成规范：
    建议最受  （不遵守编译运行不会受影响）
    1、见名知意    
    2、驼峰规则
        大驼峰：每个单词的首字母都大写
            类名（HelloWorld）、接口名、
        小驼峰：从第二个单词开始首字母大写
            方法名(mian  addUser)、变量名(userInfo)
注释
概述：
    解释说明
分类：
    行注释：
        作用于一行内容
        格式：//注释的内容
    块注释：
        注释多行内容
        格式：/*注释内容*/
    文档注释：
        提取说明文档
        提取文档注释的类必须使用public修饰
        文档注释一般用在类上、属性上、方法上
        格式：/**注释内容 */
        提取说明文档：
            javadoc -d 文档生成的目录  文件名
                例如：Javadoc  -d    d:\code\mydoc HelloWorld.java
注意 ：
    1、注释嵌套使用
        行注释可以嵌套使用
        块注释和文档注释不可以嵌套注释
    2、注释的作用
        测试代码可以通过注释在测试完成之后注释掉不影响正式的运行
        辅助调试错误
进制（常用十进制，计算机常用二进制）
概述：
    计数时进位的机制
分类：
    二进制:满二进一
    十进制:满十进一
    八进制:满八进一
    十六进制:满十六进一
进制转换：
    二进制<->十进制
        十转二：
            总结：十进制数除2取余数，直到商为0，将余数倒着组合即为二进制数
        二转十：
            总结：二进制的每一位上的数字乘以2的相应的幂次并求和，即得到十进制数
            幂次：最低位-最右边的位数    最高位-最左边的位数 位数-1    最低位-》最高位  +1
    二进制<->八进制（三位二进制可以表示一位八进制数）
        二转八：
            总结：从最低位开始 三位为一组，如果不够三位左侧补0，将每一组的二进制都转为0-7的数字，从左向右组合即为八进制数
        八转二：
            总结：将八进制每一位上的数组拆分为三位二进制数，如果不足三位左侧补0，从左向右组合即为二进制数
        
    二进制<->十六进制
        二转十六：

        十六转二：

计算机中数据的表现形式
    计算机中所有数据的运算和储存都是基于二进制来做的
二进制的单位：
    bit：二进制 比特位  只能表示 0 或者1
    Byte：字节 1Byte=8bit   不考虑正负的情况下：0000 0000->0     1111 1111->255
    KB:1KB=1024Byte        2^10=1024
    MB：1MB=1024KB
    GB：1GB=1024MB
    TB：1TB=1024GB
    PB：1PB=1024TB
码表（字符集-编码）：
    字符和整数值进行映射，从而实现字符到二进制的互相转换
    ASCII：
        只对常用英文字符和符号共128个字符进行了映射
        一个字符占用   一个   字节来存储
    GB1312，GBK：
        兼容ASCII码表
        加入了常用的中文汉字字符
        GBK中一个字符占用   两个   字节来存储
        中国系统默认的码表就是GBK
    unicode编码规则：
        兼容ASCII码表
        几乎涵盖去哪世界的字符
        没有指定占用多大的空间来存储字符
    UTF-16：
        基于unicode实现的码表
        一个字符占用   两个  字节来存储
    UTF-32：
        基于unicode实现的码表
        一个字符占用   四个   字节来存储
    UTF-8：
        基于unicode实现的码表
        采用了变长的字节数来存储字符
            常用字符一个字节表示
            一般字符两个字节表示
            不常用字符三个字节表示
            一般不用的字符 四个字节表示
            其中，一个中文汉字字符占用三个字节
中文乱码问题：
    现象：
        Java文件中写了中文汉字---码表  UTF-8
        cmd窗口中编译Java文件
        出现中文乱码编译报错
    原因：
        编码
            字符->二进制
            UTF-8：一个中文汉字字符占用三个字节
            中---三个字节
        解码
            二进制->字符
            cmd编译Java文件  默认码表 GBK：一个中文汉字字符占用两个字节
    总结：
        编码和解码的码表不一致
    解决方案：
        ANSI-系统默认码表
        将Java文件的码表修改为了GBK码表

字面值（直接量）
    概述：
        在Java中可以直接使用的数据值（直接输出的）
    分类：
        数值型字面值
            整数 
                默认十进制
                指定为其他进制：数值前加前缀
                    二进制：0b10    八进制：010    十六进制：0x10
            浮点数-小数
                

        字符型字面值
            必须通过一对  单引号   引起来单个字符
                例如：'a'  'A'  '中'   ' '都是字符型字面值
            注意：单引号中只能有一个字符，也不能为空
            转义字符：
                格式：\字符   \t制表符  \r回车   \n换行
                    例如：'\''  
        字符串字面值
            一对双引号引起来 可以没有字符一个字符  多个字符
            字符串中也可以写转义字符
        布尔型字面值
            布尔表示逻辑判断的结果
            true  正确的
            false  错误的
                true和false都是关键字
注意：
    System.out.println(true); 先输出内容之后进行换行
    System.out.print(true); 直接输出内容 不换行

    System.out.println();--换行
    System.out.print();--编译会报错

变量、常量
    变量：
        概念：类似于数学的未知数的定义    
        
        格式一：数据类型 变量名 = 初始化值；
        变量名：遵守标识符的组成规则 组成规范（小驼峰）
        初始值：直接量
        例如：int num = 6;(定义了一个int类型变量，变量名为num，初始值为6)
        格式二：数据类型 变量名；    变量名 = 初始化值；
        先声明 后赋值
        例如：int num；      num= 6;
        修改变量的值：
            变量名 = 新值；
        注意：
            在目前的程序中，变量名不能重复的  否则编译报错
            先定义变量 在使用变量；变量必须初始化之后才能正常使用
    常量：
        概念：在程序执行过程中 值不能发生改变的量就是常量
        格式：
            final 数据类型 常量名 = 初始化值；
        常量名：要求所有字母全部大写 多个单词之间通过_来分隔
        例如：final int PI=3;        final int MAX_VALUE = 90;
java数据类型
    分类：
        基本数据类型
        引用数据类型（数组  类  接口等）
    八大基本数据类型：
        四类八种：
            整数（4种）
                byte（字节型）、short（短整形）、int（整形）、long（长整形）
            最常用的数据类型就是int类型
            整数字面值默认是通过int类型来存储；当字面值超出了int类型的范围，编译会报错；如果想要指定整数字面值通过long类型来存储，需要字面值后边加L或者l后缀
            浮点型（2种）
                float（单精度浮点型）、double（双精度浮点型）
            1、最常用的浮点数类型就是double类型
            2、浮点数字面值默认是通过double类型存储，如果想要指定浮点数类型字面值通过float类型来存储，需要字面值后边加F或者f后缀
            3、float的有效数字的位数7-8位
            double的有效数字的位数15-16位
            4、浮点数字面值后边也可以加D或者d后缀表示用double类型来存储，一般可以省略不写
            5、java支持科学计数法的表达形式 但是默认是double类型
                300=3*10^2<->3e2        0.05=5*10^-2<->5e-2    150=1.5*10^2<->1.5e2
            字符型（1种）
                char（字符型）
            char是character单词的缩写
            1、char类型的变量可以通过整数直接赋值
                整数必须在码表的范围之内
                例如：char c = 97；//a
                将97转为二进制先进行存储，当
            布尔型（1种）
                boolean（布尔型）
            值为true或者false
    字符串型不是基本数据类型，是引用数据类型

数据类型的转换
    两种情形：
        自动数据类型转换
            
            数值型：从小到大的顺序
                
                byte->short->int->long--->float->double
                    整型可以自动转为浮点型，默认是在整数加.0
                char->int->long->float->double
                    根据码表将当前字符对应的编号转为int类型的值
        强制数据类型转换：
            格式：
                （要强转的数据类型）数值或者变量
                例如：
                    byte p2 =(byte)p1;
            注意：
                1、不是所有类型之间都可以进行强转的
                2、浮点数转为整数时，直接舍弃小数部分
                3、如果大类型的数据值超过了小类型的范围，则强转之后的结果可能会发生变化
                    例如：int i= 128；    byte b = （byte）i；        b的值为-128
                4、引用数据类型也可以强制转换

运算符
    概述：
        有特定运算规则的符号
    分类：
        算数运算符
        赋值运算符
        关系运算符
        逻辑运算符
        三目运算符
        位运算符
    算数运算符：+  -  *  /  %    ++    --
        +   -    *：
            +(求和运算)  -（求差运算）  *（求积运算）
            场景使用：
                1、输出语句中对字面值直接使用
                2、输出语句中对变量进行运算
                3、将运算的结果保存在变量
            结果的数据类型：
                1、结果数据类型和运算元素中大的数据类型保持一致
                2、byte  short  char 类型的变量参与运算时 会自动提升为int类型
                面试题：
                    byte b1 = 3;
                    byte b2 = 4;
                    byte sum = b1+b2;
                        编译会报错 
                        变量的值只有在运行时才能确定 编译时只会进行变量类型的检查
                    如何改错？
                        1、强制类型转换
                            byte sum = (byte)(b1+b2);
                        2、修改结果的数据类型
                            int sum = b1+b2;
                    byte sum1 = 3+4;
                        编译不会报错
                        原因：
                            1、编译期间只检验变量的类型 不确定变量的值
                            2、编译期间进行优化  对于字面值会在编译期间由虚拟机进行运算 所以以上程序编译之后 byte sum1 = 7;并检查7在不在byte的范围之内，如果超出范围，编译报错。
        /：
            /(求商运算)
            int/int结果必然为int类一商取整 直接舍弃小数部分
            除数不能为0：编译没问题 但是运行抛出异常
            正浮点数/0：Infinity 无穷大
            负浮点数/0：-Infiniti 无穷小
            0.0/0：NaN--Not a Number   非数字
                    
        %：
            %(取余  模余运算)
            整除：余数是否为0
            奇偶数：对2取余 判断余数是否为0
        ++  --：
            ++(自增运算符)   
                格式：变量++；让变量的值自增1
                理解：x++；理解为x=(type)(x+1);
            
            --(自减运算符)
                格式：变量--；让变量的值自减1
                理解：x--;理解为x=(type)(x-1);
            注意：
                1、如果++--单独使用 可以放在变量前边 也可以放在变量后边
                2、如果++--不是单独使用：
                    如果变量在前，++在后，先使用变量的值，再让变量的值+1
                    如果++在前，变量在后，先让变量的值+1，在使用变量的值
                3、++--只能作用于变量,不能作用于数据值和常量
    赋值运算符：=  +=  -=  *=  /=  %=  &=  |=    . . .
        特点：
            赋值运算符的优先级是最低的
        连等赋值：
            从右向左执行的
            int b = a = 3 ；
                程序第一步先执行a=3；要求变量a必须声明或定义过，否则编译会报错
                第二步执行int b = a；
        +=：
            格式：x+= r；相当于 x = (type)(x+ y);
            x:只能是变量，不能是常量 字面值
    关系运算符：>  <  >=  <=  ==  !=
        特点：运算结果必然为boolean类型
    逻辑运算符：&   |   ！ ^    &&    ||
        特点：只能对boolean类型的值做运算
        &&(与 且):
            true&true=true
            true&false=false
            false&true=false
            false&false=false

            总结：
                都为true结果为true，有false结果为false
        |（或）：
            true|true=true
            true|false=true
            false|true=true
            false|false=false
            总结：
                同为false,结果为false;一旦有true,结果就为true
        !(非  取反)：
            !x
            x=true  !x=false
            x=false !x=true
        ^(异或) 

            x^y:
            x的取值要么为true 要么为false;y同理
            true^true=false
            true^false=true
            false^true=true
            false^false=false
            总结：
                如果相同，结果为false；不同，结果为true;

 
        &&(双与  短路与)：
            提高程序的执行效率

            案例引入：
            false&&(1+2+3+…+10000000>738479832)=false
            总结：
                &&左边为false时，右边不再执行，结果必然为false;
                &&左边如果为true，则效果等同于&.

        ||(双或  短路或)

            案例引入：
            true||(1+2+3+…+10000000>738479832)=true

            总结：
                ||左边为true时，右边不再执行，结果必然为true;
                ||左边如果为false，则效果等同于|.
    三目运算符（三元表达式）：
        单目运算符（一元表达式）
            例如：++  --  !
        双目运算符（二元表达式）
            例如：+  -  &  >
        三目运算符的格式：
            表达式或值？表达式1或值1：表达式2或值2
            执行流程：
                1、执行表达式或值
                true:表达式1或值1
                false:表达式2或值2
            要求：表达式或值必须为boolean类型
    位运算符：
        了解即可 不要求深入
        特点：
            整数做运算，先将运算的整数转为二进制，对二进制数来做运算。
        &(按位与)  |(按位或)  ~(按位取反)  ^(按位异或)  
            &：(按位与)
                x&y  例如：   1&2=0
                1--true  0-false
                1&1=1  1&0或0&1或0&0=0
            |：（按位或）
                x|y    例如：   1|2=3
                1--true  0-false
                1|1或1|0或0|1=1 0|0=0
            ^:(按位异或)
                特点：一个数异或同一个数两次 结果是该数本身
                x^y   1^2=
                1-true 0-false
                1^1=0 0^0=0  1^0=1  0^1=1

            ~：（按位取反）
                ~x  例如：  ~1=-2
                    ~1=0  ~0=1
                     ~i=-(i+1)
                正数：原码=反码=补码
                负数：
                原码：符号位1   十进制转换出来的二进制
                反码：符号位不变，其余位依次取反
                补码：反码+1

        <<(按位左移) >>(按位右移)  >>>(按位无符号右移)
            <<:(按位左移)
                x<<y  将x的二进制整体左移y位 左侧多出来的直接舍弃  右侧空出来的补0
            >>:(按位右移)
                x>>y   将x的二进制整体右移y位 右侧多出来的直接舍弃  左侧空出来的补和符号位一致的数字
            >>>:(按位无符号右移)
                x>>>y   将x的二进制整体右移y位 右侧多出来的直接舍弃  左侧空出来的补0
        

开发工具
    记事本：
        无需单独安装
        开发效率低
    eclipse：
        免费 内存占用率比较低
        安装配置非常简单 绿色免安装
    intellij idea：
        智能提示优化
        Debug代码调试功能非常完善 非常的
        主题界面风格
        插件安装非常的方便
        收费 占用内存率比较高
        idea的使用：
            项目 Project
                本质上是文件夹
            模块 Module
            src-代码源码
            包 Package
                单级包
                多级包
                    规范：
                        公司的域名的道写形式作为多级包的开头
            类        
补充知识点
    如何定义字符串类型
        1、String类   表示字符串类型 引用数据类型
        String 变量名 = 初始化值；
            例如：String name = “hello”；
    +  字符串拼接符
        案例：
            "hello"+"world"=>"helloworld"
            "hello"+8 => "hello8"
            8+"hello" => "8hello"
            "hello"+3.5 => "hello3.5"
            "hello"+'a' => "helloa"
            "hello"+true => "hellotrue"
            "hello"+1+2 => "hello"+1->"hello1"+2->"hello12"
            1+2+"hello" => 3+"hello"->"3hello"
            "hello"+'a'+1 => "helloa1"
            1+'a'+"hello" => 98+"hello"->"98hello"
        应用场景：

            1、案例  求a b的最大值
                int max = a>b ? a : b;
                System.out.println("最大值为："+max);

            2、案例 
                int a = 4;
                int b = 3;
            输出等式：
                4+3=7
                System.out.println(a+"+"+b+"="+(a+b));//4+3=7
    
        2、Scanner类
            作用：
                获取用户输入的数据
            Scanner使用步骤：
                1、导入Scanner所在包
                    import java.util.Scanner;
                    位置：类定义的上边
                2、创建Scanner类的对象
                    Scanner sc = new Scanner（System.in）;
                3、调用sc的方法来获取数据
                    nextlnt()--获取用户输入的整数
                    nextDouble()--获取用户输入的浮点数
                    next()--获取用户输入的字符串
                    调用方法：
                        
                    调用方法的格式：
                        sc.nextInt();--获取用户输入的一个整数
                        int num = sc.nextInt();
                        double num1 = sc.nextDouble();
                        String str = sc.next();
                4、关闭Scanner
                    sc.close();--关闭Scanner

控制结构
    概述：
        控制程序语句的执行
    分类：
        顺序结构：
            从上到下 从左到右
            基本的控制结构
        分支结构：
            if判断语句
            switch case选择语句
        循环结构

            分支结构：
                if判断语句：
                    判断条件的值必须是boolean类型
                    格式一：
                
                        if（判断语句){当前判断条件为true时要执行的代码块；}
                    格式二：
                        if（判断语句）{当前判断为true时要执行的代码块；} else{当条件不成立 时要执行的代码块；}
                    格式三：if (){}else if(){} …………else{}
                        if（判断语句1）{当前判断为true时要执行的代码块；} else if(判断语句2){当判断条件1不成立且判断条件2成立时要执行的代码块；}else if(判断语句3){当判断条件1不成立且判断条件2不成立且判断条件3成立时要执行的代码块；}else{当所有的判断条件均不成立时要执行的代码块；}
                    if嵌套:
                        内层的if看作外层if的代码块
                        案例：
                            月份案例 先if else判断数据合法性  再if else if else判断季节范围
                注意：
                    1、如果代码块的内容只有一行 可以省略{}
                    2、变量的作用域问题
                        变量定义开始到所属的{}的结束
                        在同一个作用域中变量不能重名
                switch case选择语句：
                    格式：
                        switch(值或者表达式或变量){case值1：当值和值1匹配时要执行的代码块；case值2：当值和值2匹配时要执行的代码块；…… default：当值和case后所有的值都不匹配时要执行的代码块；}
                    注意：
                        switch只支持int（byte chort  char）类型、String字符串、枚举的数据匹配
                    问题：
                        case穿透
                        解决方案：break；--break语句--该语句执行直接结束switch case
                        case穿透在某些场景可以简化代码
                if和switch case  的区别：
                    范围性的比较适用if语句，一对一的匹配则适合用switch case
                    if应用更广泛一些Switch case在某些某些特定场景下可以进行的简化
            循环结构：
                while do.while  for 
                    循环四要素：
                        1、初始化条件语句；
                        2、循环条件语句；
                        3、改变循环体条件语句；
                        4、循环体
                while：
                    格式：
                        初始化条件语句；while（循环条件）{循环体；改变循环条件语句；}
                    执行流程：
                        1、初始化条件语句；
                        2、循环条件boolean值
                            true：循环体；改变循环条件语句；重复步骤2 false：循环结束
                do.while:
                    格式：
                        初始化条件语句；
                        do{循环体；改变循环条件的语句；}while（循环条件）；
                    执行流程：
                        1、初始化条件语句
                        2、循环体；
                        3、改变循环条件的语句
                        4、循环条件
                            true：重复步骤2
                            false：结束循环
                while和do.while 的区别：
                    while循环可能一次都执行不到循环体；do while至少循环一次循环体；
                注意：
                    while后边必须以分号结束
                for：
                    格式：
                        for(初始化条件语句;循环条件；改变循环条件的语句){循环体；}
                    执行流程：
                        1、初始化条件
                        2、循环条件--boolean值
                            true：循环体；改变循环条件语句；重复步骤2
                            false：循环结束
                三种循环的联系和区别：
                    1、一般来说 三种循环可以互相转换的
                    2、while、for和do while的区别
                        while和for有可能一次都不执行循环体
                        do while至少执行一次循环体
                    3、如果不确定循环次数 建议使用while循环
                    4、while的初始化条件语句中定义的变量再循环结束后还可以正常访问
                    for循环的初始化条件语句中定义的白能量则只在for内部生效 出了for循环访问不了
                死循环：
                    while(true){}
                    for(;;){}
                    循环没有了出口
                    一般情况下，在编写代码时要考虑死循环的问题；
                    某些特殊场景可能需要专门去构建死循环的应用。
                    死循环的体现：
                        不停的输出相同的内容  不会停止
                        卡死的假象
                循环、判断嵌套：
                    循环和if语句来嵌套
                循环和循环嵌套：
                    将内层循环看做外层代码
    循环跳转语句：
        break；
        continue;
        break continue 关键字
            break;--break语句
                应用场景：
                    switch case语句中  结束switch case
                    循环语句  结束循环
            continue;--continue语句
                应用场景：
                    循环语句  跳过本次循环，继续下一次循环
            多层循环中：
                break; continue;语句对它所属的且离它最近的循环生效
            
            结束方法    
                return;--return 语句        
    变量的作用域：
        从变量定义开始带它所属的结束
        在同结束一个作用域中，变量名不能重复

数组
    引用数据类型
    概念：
        可以存储多个同一种数据类型且数组长度不可变、内容可变的容器
    定义数组的格式：
        格式一：
            数据类型 [] 数组名 = {元素1、元素2、元素3、……};
                例如：int[] num = {18,19,20};
            注意：
                数组的长度等于元素的个数
                当确定每个元素的数据值时可以使用该格式
                不支持先声明后赋值
        格式二：
            数组类型[] 数组名 = new 数据类型[数组的长度]；
                例如：int[] num = new int[10];
            注意：
                该格式明确指定了数组的长度，但是没有给出具体的元素值
                支持先声明后赋值
        格式三：
            数据类型[] 数组名 = new 数据类型[]{元素1，元素2，…};
            注意：
                数组的长度等于元素的个数
                当确认每个元素的数据值时可以使用该格式
                格式一是格式三的简化形式
                该格式不能再[]中指定数组的长度否则编译报错
                支持先声明后赋值
    数组的基本操作：
        索引（下标）
            范围：0~数组的长度-1
                如果超出了范围，则运行会抛出数组下标越界异常      ArrayIndexOutOfBoundsException 
            1、获取数组的元素值
                数组名[下标]
                    例如：num[0]--获取num数组的第一个元素
            2、设置数组的元素值
                数组名[下标] = 新值；
                    例如：num[0] = 19;
            3、获取数组元素的长度
                数组名.length--int类型的值
                    例如：num.length
            4、遍历数组
                三种方式
                    1、普通循环遍历数组
                    2、增强for循环
                        只能用于遍历数组、集合、Map映射等
                        格式：
                            for(数据类型 变量名:数组名){循环体}
                                例如：for(age:ages){System.out.println(age);}
                        变量的数据类型应该和数组的元素的数据类型保持一致
                    3、Arrays类来查看
                        Arrays类是JDK提供的数组操作的工具类
                        在java.utll包中，导包
                        Arrays.toString（数组名);--将数组元素拼接成了字符串返回
                            例如：System.out.println(Arrays.toString(ages));
                    注意：
                        增强for循环只适用于数组元素的查询 使用，不可用于数组元素的修改
                        只适用于查看数组元素的值或者将数组元素转为字符串
                    总结：

                        fori 和 foreach的区别：
                            如果只是查询数组元素或者使用数组元素  foreach更加简单直接
                            如果需要在遍历中修改或设置数组元素  则只能使用fori循环
    数组的应用：
        1、求数组所有之和
        2、求数组最大值/最小值
        3、数组的反转
        4、数组的排序
            数组的排序：
                冒泡排序
                    核心思想:    默认升序排序
                        要求用两个相邻的元素比较大小
                        如果前一个元素大于后一个元素 则交换位置

                选择排序
                    核心思想：默认升序排序
                    使用一个元素和之后的所有元素一次比较
                    如果当前元素大于比较元素 则交换位置
                插入排序  快速排序  归并排序等
                Arrays.sort(数组名)：
                    效率高
                        int[] nums = {3,1,5,4,6};        
        5、数组的查找
            1、数组的遍历 比较元素是否相等
            2、二分查找（折半查找）
                数值型 数组必须是有序数组
        6、数组的“扩容”、“缩容”
            数组一旦创建长度不可变，所以扩容、缩容本质上已经不是同一个数组了，而是一个新的数组对象
            JDK提供了两种方式实现扩容：
                System.arraycopy(原数组名,起始元素的下标,目标数组的起始下标,要拷贝的元素的个数);
                Arrays.copyOf(原数组名,新的长度)

    数组的内存：
        内存：
            当计算机重启或者断电时，内存中所有的数据会丢失
            效率高-快
        硬盘：
            无论是否重启，只要硬盘硬件不损坏，数据就不会丢失
            效率低-慢
        java的内存：
            栈内存 Stack
                方法执行在栈中开辟内存空间
                局部变量也是在栈中开辟空间
                for循环 判断等语句代码块执行完就会释放空间
                方法执行完方法的空间也会立刻释放
            堆内存 Heap
                new创建对象放在堆中
                要求堆中的数据必须要有值，如果没有明确给定数据值则使用数据类型对应的默认值
                    byte short int ：0            long：0L            float：'/u0000'空字符         boolean：false              引用数据类型：null
                堆中对象的空间释放由垃圾回收器完成
                    当堆中的对象没有任何引用指向时，被垃圾回收器扫描到，则会被回收
                    对象的回收不由程序员控制，完全是垃圾回收器自己决定
        方法区
        本地方法栈：
            native修饰的方法
        寄存器：
            程序计数器
        数组内存注意：
            1、直接输出num数组，输出的是数组的地址值

    二维数组
        定义的格式：
            格式一：
                数据类型[][] 数组名 = {{元素11，元素12，……},{元素21，元素22，……},{…………}，……};
                    例如：
                        int[] ages = {{18,20,19},{17,16,21,23}};
                            该元素包含两个一维数组。第一个一维数组包含3个元素，第二个一维数组包含4个元素
            格式二：
                数据类型[][] 数组名 = new 数据类型[一位数组的个数][每个一维数组中元素的个数]；
                    例如：
                        int[][] ages = new int [2][2]
                        
                特点：每个一维数组中元素个数都相同
            格式三：
                数据类型[][] 数组名 = new 数据类型[一维数组的个数][];
                    例如：
                        int[][] ages = new int[2][];
                            该二维数组包含两个一维数组，每个一位数组的个数不指定。
    基本操作：
        数组名[下标]
        数组名[下标][下标]
        数组名.length--获取到二维数组中一维数组的个数
        数组名[下标].length--获取到指定一维数组中元素的个数

方法
    引出：
        每个数组遍历都需要些一个for循环，代码几乎都是重复的，开发效率低；
        将for循环遍历数组代码进行复用--java的方法
    概念:
        将一段代码重复利用
    方法的定义：
             public        static             void            main   (String[] args)     {}
        权限修饰符  静态修饰符 返回值数据类型 方法名   (参数列表){方法体；return返回值；}
        权限修饰符：public 公共的
        静态修饰符：方法可以加也可以不加static
        返回值类型：如果方法有返回值，则数据类型需要和返回值得数据类型保持一致；如果方法没有返回值，则数据类型声明为void（关键字）；
        方法名：标识符    小驼峰    
        参数列表：方法中的一些内容需要由调用方法的人来指定时，可以通过参数来进行数据传递
        可以没有参数 可以有一个或者多个参数
        方法体：方法的核心功能逻辑代码
        return 返回值：方法执行完成之后，需要给调用方法者反馈，则可以通过return加上要返回的数据值。
            return只能返回一个数据值
            return语句一旦执行 则当前方法就结束了
            return；--return语句 直接结束方法
    方法的定义位置：
        类中方法外
        方法定义的前后位置是无关
    注意：
        方法不调用不执行 什么时候调用什么时候执行

    方法的传参：
        调用方法时，将实际的数据值赋值给方法的参数的过程
        调用方法时，将实参的值赋值给参数
        形参：
            形式参数 方法定义时给出的参数
        实参：
            实际参数 调用方法时传参给形参的变量
        注意：
            如果参数是基本数据类型，则传递的是具体的数据值；对形参的修改不会对实参产生影响；
            如果参数是引用数据类型，则传递的是对象堆中的地址值；当形参通过该地址修改堆中的数据时，实参通过同一个地址访问到的就是堆中修改之后的数据值。

    方法的重载：
        在同一个类中方法名相同参数列表不同-方法重载
        参数列表不同：
            1、参数个数不同
            2、参数数据类型不同
            3、参数数据类型的顺序不同
        调用方法时如何确定调用哪一个重载之后的方法？
            根据实参的数据类型来匹配--最像的 没有最像的 考虑通过数据类型的自动转换 尝试匹配其他的方法
    案例：
        1、定义方法，实现打印1 2  3 … 10的功能--无参 无返回值
        2、定义方法，实现打印1 2  3 … n的功能--有参 无返回值
        3、定义方法，实现int数组遍历功能--有参 无返回值
        4、定义方法，实现两个int变量求和，将求和结果返回--有两个参数  有返回值
        5、定义方法，实现两个double变量求和，将求和结果返回--有两个参数  有返回值

    方法调用栈：
        每个方法执行都需要在栈内存创建空间--栈帧
        栈-数据结构 
        先进后出 后进先出
    队列-数据结构
        先进先出 后进后出
    注意：
        方法调用不能成环 运行会抛出异常
方法递归
    方法自己调用自己
    案例：
        1、定义方法  实现1+2+3+…+n的和
        参考代码：
            public static int add(int n){if(n==1){return 1;}return add(n-1)+n; }
    优点：
        思路简洁 明了
    缺点：
        内存占用较大  甚至如果递归较深的话  可能会出现栈内存溢出错误StackOverflowError 
    注意：
        递归必须向已知的方向递归  必须要有出口
    应用场景：
        File部分会使用方法递归
break      continue      return
    break;- 作用于循环
        结束循环
    continue;-作用于循环
        跳过本次循环
    return;-作用于方法
        结束方法
Debug代码调试
    Debug:eclipse  idea开发工具提供的代码调式模式
    Debug讲解的案例：
        定义方法  对int数组基于冒泡排序实现数组升序排序
    步骤：
        打断点：指定程序停止的位置
        左侧行数右边点击一下即可 再点以下即取消
        以Debug模式来运行程序
    注意：
        Debug多使用  熟练掌握