一、Java基础

一、Java三大开发平台

1、Java SE

Java Standard Edition，Java 标准版，提供了 Java 最核心的语法，以及面向对象、集合、I/O 流、Swing 等核心功能

2、Java EE

Java Enterprise Edition，Java 企业版，提供了 Java 企业级开发特性，例如 Servlet、JSP、JDBC、消息队列、EJB 等。所有的企业级功能都基于该版本开发

3、Java ME

Java Mobile Edition，Java 移动版，提供了使用 Java 开发移动设备的相关技术

二、变量

1、计算机存储数据的硬件设备

(1)主存储器

        ·主存储器指的是内存
        ·特点
            存取效率极高，速度极快
            所存储的数据断电就会销毁
            CPU 只会和内存进行数据交换

 (2)副存储器

        ·副存储器值得时其他存储设备
        ·特征
            存取效率极慢
            存储数据量大，能够永久保存数据

2、变量的概念

根据所存储数据的类型，在计算机内存中，开辟一块用于存储该数据的内存空间，称之为变量
    变量的本质就是一块内存空间
    变量对应的内存空间中，一次性只能够存储一个值，当存储第二个值时，第一个值会被丢弃

3、变量的组成

(1)数据类型/变量类型

【1】整数型

        1、字节型
                byte
                由 8 bit 组成
                取值范围：-128 ~ 127
         2、短整型
                short
                由 16 bit 组成
                取值范围：-32768 ~ 32767
         3、整型
                int
                由 32 bit 组成
                取值范围：-2147483648 ~ 2147483647
                在 Java 中，如果写出一个整数，并且没有明确该整数的类型，那么 Java 将该整数默认为 int 类型
          4、长整型
                long
                由 64 bit 组成
                取值范围：-9223372036854775808 ~ 9223372036854775807
                如果需要明确一个整数是 long 类型，则需要在其后面增加后缀：L、l，建议使用 L

【2】浮点型

        1、单精度型
                    float
                    由 32 bit 组成
                    如果需要明确一个浮点数是 float 类型，则需要在其后面增加后缀：F、f，建议使用 F
        2、双精度型
                    double
                    由 64 bit 组成
                    在 Java 中，如果写出一个浮点数，并且没有明确该浮点数的类型，那么 Java 将该浮点数默认为 double 类型

【3】字符型

                char
                由 16 bit 的无符号整数组成
                Java 的字符采用了 Unicode 编码方案，能够编码 65535 个字符
                char 类型的值使用单引号（''）表示，而且一次只能够存储一个字符

【4】布尔型

                boolean
                可取值
                    true
                    false

(2)变量名

【1】变量名的本质是该内存空间的内存地址，为了方便使用从而使用变量名代指该内存地址
【2】命名规则
            Java 的变量名可以由字母、数字、下划线（_）和美元符（$）组成
            不能以数字开始
            不能使用 Java 关键字

【3】变量值

空间中的具体数据

4、变量的创建

(1)变量的声明

【1】通知计算机需要开辟一块内存空间，用于存储数据
【2】特点
            计算机并不会在内存中开辟空间
            声明的变量是无法直接使用的
            要想使用声明的变量，必须使用赋值运算符 “=” 进行赋值之后，才能使用
【3】语法结构：数据类型  变量名；

(2)变量的初始化

【1】通知计算机根据存储数据类型，在内存开辟空间，命名为对应的变量名，并且将所给定的数据存入该空间
【2】特点
            将空间开辟、命名、存储数据一次性完成
【3】语法结构：数据类型  变量名 = 变量值

5、变量的使用

【1】变量的作用域

1.一个变量从其声明或者是初始化的位置开始，到其所在的代码块结束，这个范围就是该变量的作用域
2.一个变量只有在其作用域之内，才能够被正常识别，一旦离开其作用域，该变量将无法识别
3.在该变量的作用域之内，不能再有创建的变量何其重名，在作用域之内，变量名是唯一的
4.一个变量一旦离开其作用域，该变量的内存空将会立刻被回收，该变量被销毁
5.成员变量和局部变量
            当一个变量的作用域是整个类时，该变量被称之为成员变量 指的是类的属性
            当一个变量的作用域仅仅在一个方法中时，该变量就称之为局部变量，例如方法的参数，或者是在方法中创建的变量

【2】数据转换类型

1.基本数据类型范围从小到大
2.自动类型转换：
       从小到大的转换过程
       由于从小范围数据类型转换为大范围数据类型时，Java 可以自动完成转换，称之为自动类型转换
3.强制类型转换
       从大到小的转换过程
       由于是从大到小进行转换，那么有可能转换的数据超出对应数据类型的范围，从而造成“溢出”的错误，因此无法自动完成转换
       语法结构：小范围数据类型  变量名  =     (小范围数据类型)变量名2

【3】变量的运算符

1.算数运算符

       {1}赋值运算符
                “=”
                赋值运算符的优先级别最低
       {2}普通算数运算符
                加法运算符：“+”
                减法运算符：“-”
                乘法运算符：“*”
                除法运算符：“/”
                取余运算符：“%”
                整数相除和取余的结果
       {3}复合算术运算符
                “+=”：num1 += num2，类似于 num1 = num1 + num2
                “-=”：num1 -= num2，类似于 num1 = num1 - num2
                “*=”：num1 *= num2，类似于 num1 = num1 * num2
                “/=”：num1 /= num2，类似于 num1 = num1 / num2
                “%=”：num1 %= num2，类似于 num1 = num1 % num2
                复合运算符自带强制类型转换
       {4}自增和自减运算符
                自增
                    后加加（i++）
                        1、取出当前变量 i 的值
                        2、将当前变量 i 的值赋予整个表达式 i++ 的值
                        3、将变量 i 的值自身加 1
                    前加加（++i）
                        1、取出当前变量 i 的值
                        2、将变量 i 的值自身加 1
                        3、将当前变量 i 的值赋予整个表达式 ++i 的值
                自减
                    后减减（i--）
                        1、取出当前变量 i 的值
                        2、将当前变量 i 的值赋予整个表达式 i-- 的值
                        3、将变量 i 的值自身减 1
                    前减减（--i）
                        1、取出当前变量 i 的值
                        2、将变量 i 的值自身减 1
                        3、将当前变量 i 的值赋予整个表达式 --i 的值

2.关系运算符

判断相等：“==”
判断不相等：“!=”
判断大于：“>”
判断大于等于：“>=”
判断小于：“<”
判断小于等于：“<=”
结果永远相反

3.逻辑运算符

{1}且运算（与运算）
 1.运算规则：是由当所有的判断都为真时，最终的结果才是真，只要有一个为假，最终结果就为假
 2. 运算分类
            短路且运算
                 “&&”
                 只要通过第一个、或者是前几个条件能够得到最终的结果，那么后面的条件将不在运行
           非短路且运算
                “&”
                只有将所有的条件全部运行完毕后，才会做出最后的判断
 {2}或运算
  1.运算规则：只要有一个判断条件为真时，最终的结果就为真，只有当所有的结果都判断为假时，最终的结果才为假
  2.运算分类
           短路或运算
                 “||”
                只要通过第一个、或者是前几个条件能够得到最终的结果，那么后面的条件将不在运行
           非短路或运算
                 “|”
                只有将所有的条件全部运行完毕后，才会做出最后的判断
 {3}取反运算（非运算）
                “!”
                将真变为假，将假变为真

4.三元运算符

{1}使用情况：根据判断条件的结果，为变量进行赋值
{2}语法结构：数据类型  变量名 = boolean 类型表达式  ？ 表达式1 ： 表达式2；(boolean为真时取表达式1，为假时取表达式2)

三、流程控制

(1) 顺序结构

        代码会从第一行开始，按照顺序逐行执行，直到所有代码都被执行完毕
        特点
            每一行代码都会被执行到
            每一行代码只会被执行一遍

(2) 分支结构/选择结构

【1】代码是否能够被执行到，会根据具体的条件进行判断，如果满足条件，该代码会被执行到，否则有可能一次都不会被执行

【2】if 分支结构

if 单分支结构
                语法结构：if(boolean 类型表达式){
                       //当boolean表达式为true时，所执行的代码块
                    }
                运行流程：先判断boolean为true时执行{}中的代码，为false结束
if...else 双分支结构
                语法结构：if(boolean 类型表达式){
                       //当boolean表达式为true时，所执行的代码块
                    }else{
                       //当boolean类型表达式为false时，执行次代码块
                    }
                运行流程：先判断boolean为true时执行{}中的代码，为false时执行else{}中的代码块

【3】switch...case 分支结构

为了解决 if...else if...else 多分支判断中的等值判断这一特殊情况
            语法结构switch(int 类型表达式){
                     case  1：
                    //当int类型表达式的值等于该case的int类型值1时，执行次代码
                    break；
                     case  2：
                    //当int类型表达式的值等于该case的int类型值2时，执行次代码
                    break；
                     case  1：
                    //当int类型表达式的值等于该case的int类型值3时，执行次代码
                    break；
                     default：
                    //当int类型表达式的值和所有的case的int类型值都不相等时，执行次代码
                    break；
                }

【4】switch 多分支和  if 多分支区别

解决问题的广度不同
        if 多分支结构可以解决所有的多分支判断情况
        switch 多分支结构只能够解决等值判断情况
需要的条件不同
        if 多分支结构需要的是 boolean 类型的表达式
        switch 多分支结构需要的是 int 类型的表达式
代码块数量不同
        if 多分支结构每个分支都是一个独立的代码块
        switch 多分支结构所有的分支都是一个代码块
执行效率
        if 多分支结构在大量分支下，运行效率较慢
        switch 多分支结构在大量分支下，运行效率较快
        采用了跳表结构，以空间换时间

【5】break 关键字的使用

        能够阻止代码继续向下执行其他的 case 中的代码块
        结束整个 switch 多分支结构

(3) 循环结构

【1】为了解决连续重复的问题

【2】循环结构的组成

        循环体：需要重复进行的动作
        循环条件：进行重复动作的条件

【3】while 循环结构

语法结构：while(boolean 类型表达式){
                    //循环体
                    }
执行流程：boolean为true时执行循环体，当为false时结束
运行特点：
                    循环体有可能一次都不执行
                        第一次判断 boolean 条件时就为 false
                    循环体执行的次数是不明确的

【4】do...while 循环结构

语法结构：do{
                    //循环体
                    }while(boolean 类型表达式)
执行流程：先执行一次循环体，如果boolean为true则继续执行循环体，为false结束
运行特点：
                    循环体至少能够保证执行一次
                    循环体执行的次数是不明确的

【5】for 循环结构

1.普通 for 循环结构
                    《1》语法结构：for(变化初始量；boolean  类型表达式；变化条件){
                        //循环体
                        }
                    《2》执行流程：boolean为true执行循环体，为false结束
                    《3》结构特点：
                        变量初始化只会执行一次
                        只要在循环结构中能够识别到该变量， 可以忽略该变量初始化
                        如果不设置 boolean 类型表达式，则默认为 true
                            有可能进入死循环
                        如果不设置变化条件，那么有肯能无法引起 boolean 判断的变化，就导致 boolean 表达式永远为 true，进入死循环
                    《4》运行特点
                        循环体运行次数较为明确
                        循环体有可能一次都不执行

2.增强型 for 循环结构
                    《1》当遍历数组、集合时，为了能够更加高效的获得每个元素中所存储的值，而不必我们自己创建下标进行获取，因此产生了增强型 for 循环
                    《2》语法结构：for(声明存入数据的变量；需要循环的结构){
                        //循环体
                        }
                    《3》执行过程：依次取出数组或集合中的每个数据，存入“:”前所声明的变量中，在循环体重，就可以使用该变量

【6】break 和 continue

break 关键字在循环结构
                    阻止所在循环结构的继续运行
                    跳出当前循环结构，继续后续代码
                    break 只能对所在循环结构起作用，而不会影响到外层循环
continue 关键字在循环结构
                    结束本轮循环结构循环体的继续运行，开始下一轮循环
                    continue 只能对所在循环起作用，而不会影响外层循环

四、数组

(1) 数组基础

1.由于变量一次性只能够存储一个数据，如果需要存储多个，就需要创建多个变量，操作这些变量会极大的带来不便
2.在内存中所开辟的一块用于存储多个数据类型相同数据的连续空间，就称之为数组
3.数组的特点
        数组本身也属于变量，是一个数组类型的变量
            数组类型属于引用数据类型
        数组用于存储多个数据
        数组所存储的数据类型必须是相同的
        数组中所存储的数据个数一旦确定，将不再发生变化
            数组的长度一旦确定，将不再发生变化
        数组存储各个数据的内存空间是连续的
4.数组相关概念
        长度：该数组能够存储数据的个数
        元素：用于存储每个数据的空间
        下标：
            每个元素对应的编号称之为该元素的下标
            要想操作每个元素，必须通过下标来确定该元素
            元素的下标从 0 开始
            下标的本质是对应元素距离第一个元素的偏移量
            数组的下标从 0 开始，而且长度一旦确定不在发生改变，因此一个数组的下标是在一定范围内
                数组下标的范围
                下标一旦超出范围，就会产生运行时异常

(2) 数组创建

1.声明
        语法结构 1：     存储数据类型[]  数组名；
            Java 数组创建标准形式
        语法结构 2：     存储数据类型   数组名[];
            为了兼容 C 语言所保留的
        对声明的数组进行赋值
            用于指定每个元素所存储的数据:     数组名  =  new 存储数据类型[]  {各个元素存储的值}；
            值设定数组的长度，不为每个元素进行赋值：   数组名  =  new  存储数据类型[数组长度];
2.初始化
        创建数组的同时，为每个元素进行赋值
            语法结构 1：  存储数据类型[]  数组名  =  {各个元素的值}；
            语法结构 2：  存储数据类型[]  数组名  =new  存储数据类型[]  {各个元素的值}；
        创建数组时，只设置数组的长度
3.如果值设置了数组长度，而没有对各个元素赋值，那么 Java 会按照不同数据类型进行赋予默认值
4.基本数据类型
            整数型：0
            浮点型：0.0
            字符型：空格
            布尔型：false
        引用数据类型：null

(3) 数组使用

1.获得数组的长度，该结果是一个 int 类型的值：   数组名.length
2.通过下标操作元素
        取出下标对应元素的值：  数组名[下标]
        向对应下标元素进行赋值：  数组名[下标]=赋予的值；
3.使用 java.util.Arrays 操作数组
        Arrays.toString(数组名)：可以将数组变为格式良好的字符串，借助于 System.out.println() 在控制台显示
        Arrays.fill(数组名, 需要赋的值)：将对应数组每个元素都赋予所给定的值
        Arrays.equals(数组1, 数组2)：比较两个数组是否完全相同
        Arrays.copyOf(旧数组, 需要复制的长度)：能够按照给定的长度对旧数组进行复制

五、方法

(1) 基础

1.为了解决程序中某些算法或者流程不连续重复问题
2.方法是将一个算法或者是业务流程代码集中在一个被命名的代码块中，如果需要使用通过该名字即可完成运行，我们将这种结构称之为方法（Method）
        其他编程语言该结构也称之为函数（function）

(2) 语法结构

修饰符  返回值类型  方法名  ([参数列表]){
            //方法体
        }
    最典型的方法是 main()

(3) 方法的调用

1.方法无法自动运行，需要经过调用之后才能够运行
2.Java 唯一运行的结构是 main()，因此如果需要方法运行，则必须在 main() 中进行调用
3.调用方法的语法结构就是在需要调用时写出该方法名和一对”()“，表示调用该方法

(4) 方法的参数

1.方法体能够成功运行时，所需要外界给定的一些数据，称之为方法的参数
2.方法的参数是以变量声明的语法结构体现的，如果该方法需要多个参数，则每个声明的变量之间通过“,”隔开
3.当调用具有参数的方法时，必须给定参数列表所约定的该数据类型的具体数据
4.调用方法时，所传递数据和参数的名字无关，之和顺序有关

(5) 形参和实参

1.形式参数，简称形参，指的是在创建方法时，所设置的参数列表中的参数就是形参，形参最大的特点本身是没有任何值的，仅仅表示该方法运行需要该数据类型的值
2.实际参数，简称实参，指的是在调用方法时，实际传入该方法的参数，这个参数就具有具体的值，能够参与方法的运行了。

(6) 可变参数

1.当一个方法所需要参数个数不定，就可以使用可变参数
2.特点:
            参数的个数不定，可以没有，也可以有一个，也可以有多个
            要求这些参数的数据类型必须相同
            在方法体中，可变参数最终会被存储在一个对应数据类型的数组中，参数名就是这个数组的数组名

 (7) 方法的返回

1.当一个方法运行完毕后，能够通过该方法获得一个结果，这个这个结果就是方法的返回
2.返回的类型
        {1}没有返回数据
            当这个方法运行之后，没有任何结果交给方法的调用者，那么这样的方法就是没有返回的方法
            对于没有返回的方法，必须使用 void 关键字在方法的返回值类型出表明
        {2}有返回数据
            当这个方法运行完毕之后，会有一个具体的数据交给调用者，那么这样的方法就是有返回的方法
            对于有返回类型的方法，必须在方法的返回值类型出明确能够返回数据的具体类型
            在方法中，必须明确的使用关键字 return 携带一个该类型的数据，表示将该数据返回给调用者
3方法返回的特点
        如果一旦该方法声明了返回值类型，那么必须在方法体中明确使用 return 关键字来携带一个该类型的数据表示返回
        返回的结果数据会交给方法的调用者
        一个方法一次性只能返回一个结果
4.return 关键字
        表示方法运行到此处结束，返回调用者。无论方法是否有返回，都可以使用 return 产生该作用
        在有返回的方法中，还会将所携带的数据交给调用者

 (8) 方法的重载与重写

1.方法的重载（Overload）
        {1}在同一个类中，出现方法名相同，但是参数列表不同的若干个方法，我们将这些方法就称之为重载
        {2}重载的目的时为了减轻方法调用者负担，提高方法灵活性而产生
        {3}最大的重载现象就是构造方法的重载
2.方法的重写（Override）
        {1}目的：为了能够使继承于父类的方法更加适应子类对象的情况，从而产生了方法的重写
        {2}在继承关系中，子类将继承于父类的方法，保持方法名和参数列表不便的情况下，对方法体的修正，称之为方法的重写
        {3}重写的规定
            方法名和参数列表必须和继承于父类的方法完全相同
            方法的访问限定修饰符不能严格于父类的方法
            返回值类型必须和父类方法相同，或者是父类方法返回值的子类
            如果父类方法使用了 static 修饰，那么子类重写后也必须使用 static 修饰，如果没有，那么子类也不能存在
            子类重写父类方法后，不能抛出比父类更多的异常
        {4}为了强制检测子类是否按照要求重写了父类方法，可以在子类方法生增加 @Override 进行强制检测
    
3.场景不同:
                  方法重载  是在同一个类
                   方法重写  是在父类与子类之间
4.定义不同：
                   方法重载  方法名相同   参数列表不同   与返回值无关
                   方法重写  方法名相同   参数列表相同   与返回值有关