java
    JDk(Java Development KIt) 必须安装
        是java开发工具包，包含了JRE和编译工具(javac.exe)和运行工具(java.exe)  通过官网http://www.oracle.com 下载
            JRE(Java Runtime Environment)
                是java的运行环境，包含JVM和核心类库
                    JVM(保证Java的跨平台)
                    核心类库
            开发工具
        JDK文件目录
            bin
                该路径下存放了JDK各种工具命令，javac和java就在这个目录
            conf
                该路径存放了JDK的相关配置文件
            include
                该路径存放了一些平台特定的头文件
            jmods
                该路径存放了JDK的各种模板
            legal
                该路径存放了JDK各种模板的授权文档
            lib
                该路径下存放了JDK工具的一些补充JAR包
    循环语句
        for循环语句
        while循环语句
            初始化变量为全局，外部可访问
                死循环常用    命令提示符窗口中Ctrl+C可以结束循环
        do...while循环语句
            至少执行一次
        跳转控制语句
            continue
                跳过本次循环
            break
                结束本层循环
        Random产生一个随机数
            步骤
                1导包
                    import java.util.Random;
                2创建对象
                    Random r = new Random();
                3获取随机数
                    int number = r.nextInt(10);
                        nextInt(10)里面是10所以它的获取范围是0 到10，包括0，不包括10；
    IDEA概述和安装
        IDEA全称Intellij IDEA,是用于java语言开发的集成环境,它是业界公认的目前用于java程序开发最好的工具
            集成环境
                把代码编写，编译，执行，调试等多种功能综合到一起的开发工具
                    下载：https://www.jetbrains.com/idea/
            快捷键
                快速生成main()方法
                    psvm,回车
                快速生成输出语句
                    sout,回车
                Ctrl+Alt+space(内容提示，代码补全)
                格式化
                    Ctrl+Alt+L
                看方法的源代码
                    Ctrl+B
                创建方法
                     ALt + Fn + i
                查看所有类的信息
                    Alt+7
    DOS命令
        1.按下win+R
        2.输入cmd
        常用命令
            盘符名称:
                盘符切换，E:回车，表示切换到E盘
            dir
                查看当前路径下的内容
            cd目录
                进入单级目录，cditheima
            cd..
                回退到上一级目录
            cd目录1\目录2\...
                进入多级目录，cditheima\JavaSE
            cd\
                回退到盘符目录。
            cls
                清屏
            exit
                退出命令提示符窗口
        执行 ：Java 类名
            范例：Java HelloWorld
        编译：Javac 文件名.java
            范例：javac HelloWorld.java
        ipconfig
            访问自己的ip地址
        打开命令提示符窗口
    注释
        单行注释
            //  注释信息
        多行注释
            /*注释信息*/
        文档注释
            /**注释信息*/
    关键字
        关键字就是被java语言赋予了特定含义的单词   关键字的字母全部小写
    常量
        在程序运行中，其值不可改变的量
            字符串常量
                用双引号括起来的内容
                    如："HelloWorld"
            整数常量
                不带小数的数字
                    如： 666，-88
            小数常量
                带小数的数字
                    如：13.14，-5.21
            字符常量
                用单引号括起来的内容
                    如：‘A’  ,  '0' , '我'
            布尔常量
                布尔值，表示真假
                    只有两个值：true ，false
            空常量
                一个特殊的值，空值
                    值是：null
    变量
        在程序运行过程中，其值可以发生改变的量
            格式：数据类型  变量名  = 变量值
                例 ： int  a = 10;
            long类型的变量定义的时候为防止整数过大后面需要加L       float类型需要加F 防止类型不兼容
    数据类型
        java语言是强类型语言，对于每一种数据都给出明确的数据类型，不同的数据类型也分配了不同的内存空间，所有它们表示的数据大小也是不一样的。
            基本数据类型
                数值型
                    整数（byte,short,int,long）
                        关键字
                            关键字
                                内存占用（字节）
                                    取值范围
                            byte(字节)
                                1
                                    -128~127
                            short(短整型)
                                2
                                    -32768~32767
                            int(默认)(整形)
                                4
                                    -2的31次方到2的31次方-1
                            long(长整型)
                                8
                                    -2的63次方到2的63次方-1
                    浮点数（float,double）
                        关键字
                            内存占用（字节）
                                取值范围
                        float(单精度)
                            4
                                负数：-3.402823E+38到-1.401298E-45          正数：1.401298E-45到3.402823E+38
                                说明：E+38是乘以10的38次方  E-45是乘以10的负45次方
                        double(默认)(双精度)
                            8
                                负数：-1.797693E+308到-4.9000000E-324  正数：4.9000000E-324到1.797693E+308
                    字符（char）
                        char
                            2
                                0-65535
                非数值型
                    布尔（boolean）
                        boolean
                            1
                                true,false
            引用数据类型
                类（class）
                    String字符串
                接口（inteface）
                数据（[]）
    类型转化
        自动类型转化
            把一个数据范围小的值变量赋值给另一个数值范围大的变量
                double
                    float
                        long
                            int
                                short
                                    byte
                                char
        强制类型转换
            把一个数据范围大的值变量赋值给另一个数值范围小的变量
                格式 目标数据类型  变量名 =(目标数据类型)值     如：int  a = (int)88.88  
                    运行结果是  88  一般不使用
    运算符和表达式
        算术运算符
            +（加）
            -（减）
            *（乘）
            /（除）
                整数相除只能得到整数，想要得到小数，必须有浮点数的参与
            %（取余）
        赋值运算符
            =
            +=
            -=
            *=
            /=
            %=
            扩展的赋值运算符隐含强制类型转换
        自增自减运算符
            ++
            --
            在前是先自增在运算  在后是先运算在自增
        关系运算符
            ==
            !=
            >
            >=
            <
            <=
        逻辑运算符
            &（与）
            |（或）
            ^（异或）
            !（非）
            &&（短路与）
            ||（短路或）
        三元运算符
            格式：关系表达式？表达式1:表达式2；
                首先计算关系表达式的值                                    如果值为true，表达式1就是运算结果                如果值为false，表达式2就是运算结果
                    例：a > b ? 10 : 20; 
    键盘录入
        Scanner使用的基本步骤
            1.导包
                import java.util.Scanner;
                    必须在类定义的上面
            2创建对象
                Scanner sc = new Scanner(System.in);
                    sc是变量名
            3接收数据
                int i = sc.nextInt();
                    i是变量名
    分支语句
        if语句
        swit语句
            格式：                                                                      switch(表达式){ case 值1:     语句体1;   break;    
                            default:    语句体;       break;}
    输出语句
        System.out.print(“内容”)
            输出内容不换行
        System.out.println("内容")
            输入内容换行，里面不传内容能起到换行作用
    单词
        desktop:桌面
        main函数/方法
            主方法 程序执行的入口
        \t(相当于Tab缩进)
    数组()array
        定义格式
            数据类型[] 变量名
                int[] arr
                    定义了一个int类型的数组，数组名是arr
                        推荐使用
            数据类型 变量名[]
                int arr[]
                    定义了一个int类型的变量，变量名是arr数组
        数组初始化概念
            java的数组必须先初始化，才能使用。  所谓初始化 就是为数组中的数组元素分配内存空间，并未每个数组元素赋值
                动态初始化
                    初始化时只指定数组长度，由系统为数组分配初始化值
                        格式
                            数据类型[] 变量名 = new 数据类型[数组长度]     例： int[] arr = new  int[3];
                静态初始化
                    初始化时指定每个元素的值，由系统决定元素的长度
                        格式
                            数据类型[] 变量名 = new 数据类型[]{数据1,数据2,数据3, ......}                                                      例：int[] arr = new int[]{1,2,3,....}
                                简化格式
                                    int[] arr = {1,2,3]
        内存分配
            栈内存
                储存局部变量  
                    定义在方法中的变量，例如 arr 使用完毕 ，立即消失
            堆内存
                储存new出来的内容(实体，对象)
                    数组在初始化时，会为储存空间添加默认值       整数：0  浮点数：0.0  布尔：false                   字符：空字符  引用数据类型：null  ； 每一个new出来的东西都有一个地址值 使用完毕，会在垃圾回收器空闲时回收
    方法(method)
        方法概述
            方法是将具有独特功能的代码块组织成一个整体，使其具有特殊功能的代码集
            方法必须先创建才可以使用，该过程成为方法定义
            方法创建后并不是直接运行的，需要手动使用后才执行，该过程成为方法调用
        方法定义和调用
            方法定义
                public static void 方法名(){ 方法体 }；
            方法调用
                方法名();   注意:要做main方法里面调用
        带参数方法的定义和调用
            带参数方法定义
                格式
                    public static void 方法名(数据类型 变量名){}
                        例
                            public static void ff( int num1 , int num2){}
                                数据类型和变量名 也叫形参
                注意
                    方法定义时，参数中的数据类型与变量名都不能缺少。
                    多个参数之间使用逗号(,)分隔
            带参数方法调用
                格式
                    方法名(参数)；参数: 变量或者值
                        例
                            ff(5,6);
                                里面的参数叫做 实参
                注意
                    方法调用时，参数的数量与类型必须方法定义中的相同
        带返回值方法的定义
            格式
                pulic static 数据类型  方法名(参数){                    
       retuen 数据类型；                                         
 }
                    方法定义时return后面的返回值与方法定义的数据类型要匹配，否则报错
            return返回值
        方法的注意事项
            方法的通用格式
                public static 返回值类型 方法名(参数){              
        方法体；                                                          
         return 数据；                                                
 }
                    public static
                        修饰符，目前记住这个格式
                    返回值类型
                        方法操作完毕之后返回的数据的数据类型             如果方法操作完毕，没有数据返回，这里写void，
                    方法名
                        调用方法时候使用的标识
                    参数
                        由数据类型和变量名组成，多个参数之间用逗号隔开
                    方法体
                        完成功能的代码块
                    return
                        如果方法操作完毕，有数据返回，用于把数据返回给调用者
                定义方法时，要做到两个明确
                    明确返回值类型
                        主要是明确方法操作完毕后是否有数据返回，如果没有，要写void；如果有，写对应的数据类型
                    明确参数
                        主要是明确参数的类型和数量
            方法不能嵌套定义
            void表示无返回值，可以省略return，也可以单独书写return，后面不能加数据
        方法的重载
            方法重载概述
                方法重载指同一个类中定义的多个方法之间的关系，满足后面条件的多个方法相互构成重载
                    1 多个方法在同一个类中
                    2 多个方法具有相同的方法名
                    3 多个方法对参数不相同，类型不同或者数量不同
            方法重载特点
                重载对应方法的定义，与方法的调用无关，但是方法在调用的时候，java虚拟机会通过参数的不同来区分同名的方法
                重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，不能通过返回值来判断两个方法是否相互构成重载
        方法的参数传递
            方法的参数传递(基本类型)
                对于基本数据的参数，形参的改变，不影响实际参数的值
            方法参数传递(引用数据类型)
                对应应用类型的参数，形参的改变，影响实际参数的值  因为引用数据类型它是引用堆内存的地址
    Debug
        概述
            Debug：是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序
                查看程序执行流程和调试程序
        操作流程
            Debug调试，又称为断点调试，断点其实是一个标记，告诉我们从哪里开始查看
                1.如何加断点
                    选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可
                2.如何运行加了断点的程序
                    在代码区域右键 Debug(调试)执行
                3.看哪里
                    看Debugger(调试器)窗口
                        帧
                            看代码执行到哪里了
                        变量
                            看代码执行过程中变量的变化
                    看Console(控制台)窗口
                        看程序执行过程中的结果展示
                4.点哪里
                    点StepInto(F7)这个箭头，也可以直接按F7     可以让程序继续向下执行
                    点Stop(停止)结束
                5.如何删除断点
                    选择要删除的断点，单击鼠标左键即可
    面向对象基础
        类和对象
            对象
                万物皆对象，客观存在的事物都叫对象
            面向对象
                人关注的事物信息
            类
                类是对现实中一类具有共同属性和行为的事物的抽象
                    特点
                        类是对象的数据类
                        类是具有相同属性和行为的一组对象的集合
            对象的属性
                对象具有的各种特征，每个对象的每个属性都有特定的值
            对象的行为
                对象能够执行的操作
            类和对象的关系
                类
                    类是对现实生活中一类具有共同属性和行为的事物的抽象
                对象
                    是能够看得到摸的着的真实存在的实体
                类和对象
                    类是对象的抽象                                                    
对象是类的实体
            类的定义
                类是java程序的基本组成单位
                类是行为和属性组成
                    属性
                        在类中通过成员变量来体现(类中方法为的变量）
                    行为
                        在类中通过成员方法来体现（相比去掉static）
                类定义的步骤
                    1 定义类
                        public class 类名 {}
                    2 编写类的成员变量
                                            变量1的数据类型 变量1                    
                    变量2的数据类型 变量2；
                    3 编写类的成员方法
                        方法1； 方法2；
            对象的使用
                创建对象
                    格式
                        类名 对象名 = new 类名();
                    范例
                        Phone p = new Phone();
                使用对象
                    使用成员变量 
                        格式
                            对象名.变量名
                        范例
                            p.brand
            成员变量和局部变量的区别
                成员变量
                局部变量
                类中位置不同
                    类中方法外
                    方法内或者方法声明上
                    内存中位置不同
                        堆内存
                        栈内容
                        生命周期不同
                            随着对象的存在而存在，随着对象的消失而消失
                            随着方法的调用而存在，随着方法的调用完毕而消失
                            初始化值不同
                                有默认的初始化值
                                没有默认的初始化值，必须先定义，赋值，才能使用
    private(权限修饰符)
        针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
            get变量名()方法
                用于获取成员变量的值，方法用public修饰
            set变量名(参数)方法
                用于设置成员变量的值，方法用public修饰
    this（关键字）
        this修饰的变量用于指代成员变量
            方法的形参如果与成员变量同名，不带this修饰的变量指的形参，而不是成员变量
            方法的形参没有与成员同名，不带this修饰的变量指的是成员变量
        thisy用于解决局部变量隐藏成员变量
            代表所在类的对象引用
                方法被那个对象调用，this就代表那个对象
    构造方法
        构造方法的概述
            构造方法是一直特殊的方法，作用于创建对象
                格式
        功能
            主要完成对象的数据的初始化
    字符串
        API概述
            API(APPlicaton Programming Interface):应用程序编程接口
                Java API：指的就是JDK中提供的各种功能的java类
        String概述
            String类在java.lang包下，所以使用的时候不需要导包
                String类代表字符串，java程序中所有的双引号字符串，都是String类的对象
            字符串的特点
                字符串不可变，他们的值在创建后不能被更改
                虽然String值是不可变的，但是它们可以被共享
                字符串效果上相对于字符数组(char[]),但是底层原理是字节数组(byte[])
        String 构造方法
            public String()
                创建一个空白字符串对象，不含有任何内容
            public String(char[] chs)
                根据字符数组的内容，来创建字符串对象
            public String(byte[] bys)
                根据字节数组的内容，来创建字符串对象
            String s = "abc";
                直接赋值的方式创建字符串对象，内容就是abc
                    推荐使用
        String成员方法
            public boolean equa(obj an obj)
                比较字符串的内容，严格区分大小写
            public char charAt(int index)
                返回指定索引处的char值
            pulic int length()
                返回此字符串的长度
            public String[] split(String regex)
                得到字符串中每一个数字数据 regex 分割 比如 逗号 空格
        String对象的·特点
            通过new创建的字符串对象，每一次new都会申请一个内容空间，虽然内容相同，但是地址值不同
            以“ ”方法给出的字符串，只要字符顺序和大小写相同，无论在程序代码中出现几次，JVM都只会建立一个String对象，并在字符池中维护
        字符串的比较
            使用 == 做比较
                基本类型
                    比较的是数据值是否相同
                引用类型
                    比较的是地址值是否相同
            equals()
                字符串是一个对象用 == 做比较，比较的是地址值，要比较内容是否相同，要通过equals()方法实现
        遍历字符串
            charAt()
                Public char charAt(int index)
                    返回指定索引处的char值，字符串的索引是从0开始
            lenght()
                获取字符串的长度
            遍历字符串通用格式
        StringBuilder
            StringBuilder概述
                StringBuilder是一个可变的字符串类，我们可以把他看成一个容器，这里指定的是StringBuilder对象中的内容是可变的
            String和StringBuilber的区别
                string的内容是不可变的
                StringBuilder得内容是可变的
            StringBuilder构造方法
                public StringBuilder()
                    创建一个空白可变的字符串对象，不含有任何内容
                public StringBuilder(String str)
                    根据字符串的内容，来创建可变字符串对象
            stringBuilder成员方法
                public StringBuilder append(任意数据类型)
                    添加数据，并返回对象本身
                public StringBuilder reverse()
                    放回相反的字符序列 反转
        StringBuilder和String相互转换
            StringBuilder转换为String
                public String toString();
                    通过toString()就可以实现StringBuilder转换为String
            String转换为StringBuilder
                public StringBuilder(String s);
                    通过构造方法就可以实现把String转换为StringBuilder
    集合基础
        集合概述
            提供一种存储空间可变的存储模型，存储的数据容量可以发生改变(动态数组)
        ArrayList<E>
            可调整大小的数组实现 使用需要导包
            <E>：是一种特殊的数据类型，泛型
            ArrayList构造方法和添加方法
                public ArrayList()
                    创建一个空的集合对象
                public boolean add(E e)
                    将指定的元素追加到此集合的末尾
                public void add(int index ， E element)
                    在此集合中的指定位置插入指定的元素
                public boolean remove(Object 0)
                    删除指定的元素，返回删除是否成功
                public E remove(int index)
                    删除指定索引处的元素，返回被删除的元素
                public E set(int index,E element)
                    修改指定索引处的元素，返回被修改的元素
                public E get(int index)
                    返回指定索引处的元素
                public int size()
                    返回集合中的元素个数
            遍历集合
                通过get()获取集合中的每一个元素
                通过size()获取集合长度
                通用格式
    继承
        继承概述
            继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法
        继承的格式
            格式
                oublic class 子类名 extends 父类名{}
                    关键字 extends 子继承父
            范例
                public class Zi extends Fu {}
                    Fu：是父类，也被称为基类，超类
                    Zi：是子类，也称派生类
        继承的好处和弊端
            好处
                提高了代码的复用性(多个相同的成员可以放到同一个类中)
                提高了代码的维护性(如果方法的代码需要修改，修改一次即可)
            弊端
                继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类不得不跟着变化，消弱了子类得独立性
        继承中变量的访问特点
            在子类方法中访问一个变量
        super
            super概述
                super关键字的用法和this关键字的用法相似
                    this代表本类对象的引用，
                    super代父类储存空间的标识(可以理解为父类对象引用)
        继承中构造方法的访问特点
            子类在所有的构造方法默认都会访问父类中无参的构成方法
                因为子类会继承父类中的数据，可能还会使用父类的数据，所以，子类初始化之前，一定要先完成父类数据的初始化
                每一个子类构造方法的第一语句默认都是super()
            如果父类中没有无参构造方法，只有带参构造方法
                通过使用super关键字去显示的调用父类的带参构造方法
                在父类中自己提供一个无参构造方法
                    推荐，自己给出
        方法重写
            方法重写概述
                子类中出现了和父类中一模一样的方法声明
            方法重写的应用
                当子类需要父类的功能，而功能主体子类有自己特定的内容时，可以重写父类中的方法，这样，既沿袭了父类的功能，又定义了子类特有的内容
            @Override
                是一个注释 ， 可以帮助我们检查重写方法声明的正确性
            方法重写注意事项
                私有方法不能被重写（父类私有成员子类不能被继承）
                子类方法访问权限不 能比父类低(public > 默认 > 私有)
        继承的注意事项
            java中类只支持单继承，不支持多继承
            java中类支持多层继承
    修饰符
        包(package)
            包的概述
                包其实就是文件件，作用是对类进行分类管理
            包的定义格式
                格式
                    package 包名；(多级包用.分开)
                范例
                    package com.java;
            带包的java类编译和执行
                手动键包（懒得写）
                自动键包
                    编译
                        java -d.HelloWorld.java
                    执行
                        java .com.java.HelloWrold
        导包
            导包的概述
                使用不同包下的类时，使用的时候要写类的全路径写起来太麻烦了，为了简化带包的操作，Java就提供了导包的功能
            导包的格式
                格式
                    import 包名；
                范例
                    import cn.java.Teachre
        修饰符
            权限修饰符
                private
                    同一个类中
                默认
                    同一个包中子类无关类
                protected
                    不同包的子类
                public
                    不同包的无关类
            状态修饰符
                final(最终态)
                    final关键字是最终的意思，可以修饰成员方法，成员变量，类
                    final修饰的特点
                        修饰方法
                            表明该方法说最终方法，不能被重写
                        修饰变量
                            变量是基本数据类型
                                表明该变量说常量，不能再次被赋值
                                基本数据类型的数据值不能发生改变
                            变量是引用数据类型
                                因为引用数据类型的变量，指向的是地址值，所有地址值不能改变，但是地址里面的内容可以改变的
                        修饰类
                            修饰类，表明该类是最终类，不能被继承
                static(静态)
                    static关键字是静态的意思，可以修饰成员方法，成员变量
                    static 修饰的特点
                        被类的所有对象共享,  这也是我们判断是否使用静态关键字的条件
                    static访问特点
                        非静态的成员方法
                            能访问静态和非静态的成员方法和变量
                        静态的成员方法
                            只能访问静态的成员方法和变量
    多态
        多态的概述
            同一个对象，在不同时刻表现出来的不同形态
        多态的前提和体现
            有继承/实现关系
            有方法重写
            有父类引用指向子类对象
        多态中成员访问特点
            成员变量
                编译看父类，执行看父类
            成员方法
                编译看父类，执行看子类
        多态的好处和弊端
            好处
                提高程序的扩展性
                具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作
            弊端
                不能使用子类的特有功能
        多态中的转型
            向上转型
                不能访问子类特有的方法
            向下转型
                转型为可以访问子类特有的方法
    抽象类(abstract)
        抽象类的概述
            在java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类
        抽象类的特点
            抽象类和抽象方法必须使用abstract关键字修饰
                public abstract class 类名{}
                public abstract void eat();
            抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
            抽象类不能实例化
                抽象类要实例化的话，要参照多态的方式，通过子类对象实例化，这叫抽象多态
            抽象类的子类
                要么重写抽象类中的所有抽象方法
                要么他本身是抽象类
        抽象类的成员特点
            成员变量
                可以是变量
                也可以是常量
            构造方法
                有构造方法，但是不能实例化，他的作用于子类访问父类数据的初始化
            成员方法
                可以有抽象方法：限定子类必须完成某些动作
                也可以有非抽象方法：提高代码的复用性，依靠子类继承实现
    接口
        接口的概述
            接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用，java中的接口更多的体现在对行为的抽象
        接口的特点
            接口用关键字interface修饰
                public interface 接口名{}
            类实现接口用implements表示
                public class 类名 implements 接口名{}
            接口不能直接实例化
                接口需要参照多态的方式，通过实现类对象实例化，这叫接口多态
                多态的形式
                    具体多态
                    抽象多态
                    接口多态
                多态的前提
                    有继承或者实现关系；有方法重写；有父（类/接口）引用指向（子/实现）类对象
            接口的实现类
                要么重写接口中的所有抽象方法
                要么是抽象类
        接口的成员特点
            成员变量
                只能是常量
                因为有默认修饰符 public static final
            构成方法
                接口没有构造方法，因为接口主要是对行为进行抽象，是没有具体存在
                一个类如果没有父类，默认继承在Object类
            成员方法
                只能是抽象方法
                默认修饰符 public abstract
        类和接口的关系
            类和类的关系
                继承关系，只能单继承，但是可以多层继承
            类和接口的关系
                实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
            接口和接口的关系
                继承关系，可以单继承，也可以多继承
        抽象类和接口的区别
            成员区别
                抽象类
                    变量，常量；有构造方法；由抽象方法，也有非抽象方法
                接口
                    常量；抽象方法
            关系区别
                类与类
                    继承，单继承
                类与接口
                    实现，可以单实现，也可以多实现
                接口与接口
                    继承，单继承，多继承
            设计理论区别
                抽象类
                    对类抽象，包括属性，行为
                接口
                    对行为抽象，主要是行为
    形参和返回值
        类名
            方法的形参是类名，其实需要的是该类的对象
            方法的返回值是类名，返回的是该类的对象
        抽象类
            方法的形参是抽象类名，其实需要的是该抽象类的子类对象
            方法的返回值是抽象类，返回的是该抽象类的子类对象
        接口
            方法的形参的接口名，其实需要的是该接口的·实现类
            方法的返回值是接口名，返回的是该接口的实现对象
    内部类
        内部类概述
            内部类就是在一个类中定义一个类，举例：在一个类A的内部定义一个类B,类B就是被成为内部类
        内部类的定义格式
            格式
        内部类访问特点
            内部类可以直接访问外部类的成员，包括私有
            外部类要访问内部类的成员，必须创建对象
        成员内部类
            按照内部类在类中定义的位置不同，可以分为如下两种形式
                在类得成员位置：成员内部类
                    成员内部类在外界创建对象使用
                        格式
                在类的局部位置：局部内部类
                    局部内部类是在方法定义的类，所以外界是无法直接使用。需要在方法内部创建对象并使用，该类可以直接访问外部类的成员，也可以访问方法内部的局部变量
                    匿名内部类
                        前提：继承一个类或者接口，这里的类可以是具体类也可以是抽象类，一般抽象类居多
                        格式
                        范例
                        它本质是一个继承了该类或者实现了该接口的子类匿名对象
    常用API
        Math
            Math类概述
                Math包含执行基本数字运算的方法
                而且它没有构造方法，不需要导包，成员都是静态的，可以直接通过类名调用
            Math类的常用方法
                public static int abc(int a)
                    返回参数的绝对值
                public static double ceil(double a)
                    放回大于或等于参数的最小double值，等于一个整数
                public static double floor(double a)
                    返回小于或等于参数的最大double值，等于一个整数
                public static int round(float a)
                    按照四舍五入返回最接近参数的int
                public static max(int a,inta b)
                    返回两个int值中的较大值
                publi static int min(int a,int b)
                    返回两个值中的较小值
                public static double pow(double a,double b)
                    放回a的b次幂的值
                public static double random()
                    返回值为double的随机数，范围（0.0，1.0）取得到0.0取不到1.0
        System
            System类的概述
                System包含几个有用的类字段和方法，它不能被实例化，它的成员都是被静态修饰，所以可以之间用类名调用
            System类的常用方法
                public static void exit(int status)
                    终止当前运行的java虚拟机，非零表示异常终止
                public static long currentTimeMillis()
                    返回当前时间(以毫秒为单位) 返回的是当前时间和1970年1月1日之间的时间差异；
        Object
            Object类的概述
                Object是类层次结构的根，每个类都可以将Object作为超累，所以类都直接或间接的继承该类   它的构造方法只有一个无参构造方法
            Object常用方法
                tostring
                    返回对象的字符串表达式，建议所有子类重写此方法 ，最好自动生成
                equals
                    比较对象是否相等，默认比较地址，重写可以比较内容，自动生成
        Arrays
            冒泡排序
                排序
                    将一组数据按照固定的规则排序
                冒泡排序
                    一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数据按要求完成排序
            Arrays类的概述
                Arrays类包含用于操作数组的各种方法（如排序和搜索），需要导包
            Arrays类的常用方法
                public static String toString(int[] a)
                    返回值读数组的内容的字符串表示形式
                public static void sort(int[] a)
                    按照数字顺序指定的数组
        基本类型包装类
            基本数据类型包装类的概述
                将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
                常用的操作之一：用于基本数据类型与字符串之间的转换
            基本数据类型对应的包装类
                byte
                    Byte
                short
                    Short
                int
                    Integer
                long
                    Long
                float
                    Float
                double
                    Double
                char
                    Character
                boolean
                    Boolean
            Integer类的概述
                包装一个对象在的原始类型int的值
            Integer类常用的方法
                public static Integer valueOf(int i)
                    返回表示指定的int值得Integer实例
                public static Integer valueOf(String s)
                    返回一个保存指定值得Integer对象String
            int和String得相互转换
                int转换String
                    public static String valueOf(int i)
                        返回int参数得字符串表示形式，该方法是String类中的方法
                String转换为int
                    public static int parseInt(String s)
                        将字符串解析为int类型，该方法是Integer类中的方法
            自动装箱和拆箱
                装箱
                    把基本数据类型转换为对应得包装类类型
                拆箱
                    把包装类类型转化为对应得基本数据类型
                注意：在使用包装类类型得时候，如果做操作，最好先判断是否为null，，推荐只要是对象，在使用前就必须进行不为null的判断
        日期类
            Date
                Date类的概述
                    Date代表了一个特定的时间，精确到毫秒
                Date类的构造方法
                    public Dat()
                        分配一个Date对象，并初始化，以便它代表被分配的时间，精确到毫秒
                    public Date(long date)
                        分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
                Dtae类的常用方法
                    public long getTime()
                        获取的是日期对象从1970年1月1日00:00:00到现在的毫秒值
                    public void setTime(long time)
                        设置时间，给的毫秒值
            SimpleDateFormat
                SimpleDateFormat类的概述
                    SimpleDateFormat是一个具体类，用于以区域设置敏感的方式格式化和解析日期，重点学习日期格式化和解析
                日期的时间的格式
                    日期和时间格式由日期和时间模式字符指定，在日期和时间模式字符串指定，在日期和时间模式字符中，从‘A’到‘z’以及从‘a’到‘z’引号字母被解释为表示日期或时间字符串的组件的模式字母
                常用的模式字母对应关系
                    y
                        年
                    M
                        月
                    d
                        日
                    H
                        时
                    m
                        分
                    s
                        秒
                SimpleDateFormat的构造方法
                    public SimpleDateFormat()
                        构造一个SimpleDateFormat，使用默认模式和日期格式
                    public SimpleDateFormat(String pattern)
                        构造一个SimpleDateFormat，使用给定的模式和默认的日期格式
                SimpleDateFormat格式化和解析日期
                    格式化(从Date到String)
                        public final String format(Date date)
                            将日期格式化成日期/时间字符串
                    解析  (从String到Date)
                        public Date parse(String source)
                            从给定的字符串的开始解析文本以生成日期
            Calendar
                Calendar类的概述
                    Calendar是一个抽象类，为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供一些方法
                getInstance类方法
                    Calendar rightNow= Calendar.getInstance();
                        Celendar提供了一个类方法getInstance用于获取Calendar对象，其日历字段已使用当前日期和时间初始化
                Calendar的常用方法
                    public int get(int field)
                        返回个定日历字段的值
                    public abstract void add(int field,int amount)
                        根据日历的规则，将指定的时间量添加或减去给定的日历字段
                    public final void set(int year,int month,int date)
                        设置当前的日历的年月日
    异常
        异常的概述
            异常就是程序出现了不正常的情况
        异常体系
            Throwable
                所有异常的祖宗类
                    Errot
                        严重的问题，不需要解决
                    Exception
                        Exception：称为异常类，它表示程序本身可以处理的问题
                            RuntimeException
                                在编译期间是不检查的，出现问题后，需要我们回来修改代码
                            非RuntimeException
                                编译期就必须处理，否则程序不能通过编译，就不能正常运行了
        JVM的默认处理方案
            如果程序出现问题，我们没有做任何处理，最终JVM会默认的处理
            1.把异常的名称，异常原因及异常出现的位置等信息输出在控制台
            2.程序停止执行
        异常处理
            如果程序出现问题，我们需要自己来处理有两种方案
            try .... catch .....
                格式
                执行流程
                    程序从try里面的代码开始执行，出现异常，会自动生成一个异常类对象，该异常对象将被提交给java运行时系统。当java运行时系统接收到异常对象时，会到catch中去找匹配的异常类找到后进行异常的处理。执行完毕之后，程序还可以继续往下执行
            throws(抛出)
                虽然我们通过try ...catch...可以对异常进行处理，但是并不是所有的情况我们都有权限进行异常的处理，也就是说，有些时候可能出现的异常是我们处理不了的，针对这种情况，java提供了throws的处理方案
                格式
                    throws 异常类名
                        注意：这个格式是跟在方法的括号后面的
            快捷键
                Alt+回车
        Throwable的成员方法
            public String getMessage()
                返回throwable的详细消息字符串
            public String toString()
                返回此可抛出的简短描述
            public void printStackTrace()
                把异常的错误信输出在控制台
        编译时异常和运行时异常的区别
            java中的异常被分为两大类：编译时异常和运行时异常，也被称为受检异常和非受检异常所有的RuntimeException类及其子类被称为运行时异常，其他的异常都是编译时异常
            编译时异常
                必须显示处理，否则程序就会发生错误，无法通过编译
            运行时异常
                无需显示处理，也可以和编译时异常一样处理
        自定义异常
            格式
            范例
            throws和throw的区别
                throws
                    用在方法声明后面，跟的是异常类名
                    表示抛出异常，由该方法的调用者来处理
                    表示出现异常的一种可能性，并不一定会发生这些异常
                throw
                    用在方法体内，跟的是异常对象名
                    表示抛出异常，由方法体内的语句处理
                    执行throw一定抛出了自定义的异常
    集合进阶
        集合类体系结构
            集合
                Collection单例(接口)：满足规则的一系列的元素
                    List可重复(接口)
                        ArrayList(实现类)
                        LinKedList(实现类)
                    Set不可重复(接口)
                        HashSet(实现类)
                        TreeSet(实现类)
                Map双列(接口)：key-->value映射关系
                    HashMap(实现类)
        Collection
            Collection集合概述
                是单列集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
                JDK不提供此接口的任何直接实现，它提供更具体子接口（如Set和List）实现
            创建Collection集合的对象
                多态的方式
                具体的实现类ArrayList
            Collection集合常用方法
                boolean add(E e)
                    添加元素
                boolean remove(Object 0)
                    从集合中移除指定的元素
                void clear()
                    清空集合中的所有元素
                boolean contains(Object 0)
                    判断集合中是否存在指定的元素
                boolean isEmpty()
                    判断集合是否为空
                int size()
                    集合的长度，也就是集合中元素的个数
            Collection集合的遍历
                Iterator
                    Iterator：迭代器，集合的专用遍历方式
                    Iterator<E> iterator();
                        返回此集合中元素的迭代器，通过集合的iterator()方法得到
                    迭代器是通过集合的iterator()得到的，所以我们说它是依赖于集合而存在的
                    Iterator的常用方法
                        E next()
                            返回迭代中的下一个元素
                        boolean hasNext();
                            如果迭代具有更多元素，则返回true
        List
            List集合的概述
                有序集合(也称为序列)，用户可以精确控制例表中每一个元素的插入位置，用户可以通过整数索引访问元素，并搜索例表中的元素
                与Set集合不同，例表通常允许重复的元素
            List集合的特点
                有序
                    存储和取出的元素顺序一致
                可重复
                    存储的元素可以重复
            List集合特有方法
                void add(int index,E element)
                    在此集合中的指定位置插入指定的元素
                E remove(int index)
                    删除指定索引处的元素。返回被删除的元素
                E set(int index,E element)
                    修改指定索引处的元素，返回被修改的元素
                E get(int index)
                    放回指定索引处的元素
            并发修改异常
                ConcurrentModificationException
                产生原因
                    迭代器遍历的过程中，通过集合修改了集合对的长度，造成了next方法的预期修改值和实际修改值不一致
                解决方案
                    用for遍历
            ListIterator(例表迭代器)
                概述
                    通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器
                    用于程序员沿 任一方法遍历例表的例表迭代器，在迭代期间修改例表，并获取例表中迭代器的当前位置
                ListIterator的常用方法
                    E next()
                        返回迭代中的下一个元素
                    boolean hasNext()
                        如果迭代具有更多元素，则返回true
                    E previous()
                        返回例表的下一个元素
                    boolean hasPrevious()
                        如果例表迭代器在相反方向遍历例表具有更多元素，则返回true
                    void add(E e)
                        将指定的元素插入例表
            增强for循环
                概述
                    增强for：简化数组的Collection集合的遍历
                    实现terable接口的类允许其对象成为增强for语句的目标
                    它是JDK5之后出现的，其内部原理是一个Iterator迭代器
                增强for的格式
                    格式
                    范例
            数据结构
                概述
                    数据结构是计算机存储，组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合
                    精心选择的数据结构可以带来更高的运行或者存储效率
                常见数据结构 栈
                    数据进入栈模型的过程称为
                        压/进栈
                    数据离开栈模型的过程称为
                        弹/出栈
                    栈是一种数据先进后出的模型
                    最先进去的是栈底元素
                    最后的是栈顶元素
                常见数据结构 队列
                    数据从后端进入队列模型的过程称为
                        入队列
                    数据从前端离开队列模型的过程称为
                        出队列
                    队列是一种数据先进先出的模型
                常见数据结构 数组
                    数据是一种查询块，增删慢的模型
                    查询数据通过索引定位，查询任意数据耗时相同，查询效率高
                    删除数据时，要将原始数据删除，同时后面每一个数据前移，删除效率低
                    添加数据时，添加位置后的每一个数据后移，在添加元素，添加效率极低
                常见数据结构 链表
                    结点
                        结点的存储位置(地址)
                        存储具体的数据
                        下一个结点的地址
                    查询数据是否存在，必须从头(head)开始查询
                    链表是一种增删块的模型(相对数组)
                    链表是一种查询慢的模型(相对数组)
            List集合常用子类特点
                ArrayList
                    底层数据结构是数组，查询块，增删慢
                LinkedList
                    底层数据结构是链表，查询慢，增删块
            LinKedList集合 特有功能
                public void addFirst(E e)
                    在该例表开头插入指定的元素
                public void addLast(E e)
                    将指定的元素追加到此列表的末尾
                public E getFirst()
                    返回此例表中的第一个元素
                public E getLast()
                    返回此列表中的最后一个元素
                public E removeFirst()
                    从例表中删除并返回一个元素
                public E removeLast()
                    从列表在删除1并返回最后一个元素
        Set
            Set集合概述和特点
                不包含重复元素的集合
                没有带索引的方法，所以不能使用普通for循环遍历
            哈希值
                概述
                    哈希值是根据对象的地址或者字符串或者数字算出的int类型的数据
                Object类中有一个方法可以获取对象的哈希值
                    public int hashCode();
                对象的哈希值特点
                    同一个对象多次调用hashCode()方法返回的哈希值是相同的
                    默认情况下，不同对象的哈希值是不同的。重写hashCode()方法，可以实现让不同的对象的哈希值相同
            HashSet集合
                概述和特点
                    底层数据结构是哈希表
                    对集合的迭代顺序不作任何保证，不保证存储和取出的元素顺序一致
                    没有带索引的方法，所以不能使用普通for循化遍历
                    由于是Set集合，所以是不包含重复元素的集合
                HashSet集合保证元素不重复分析
                    HashSet集合添加一个元素的过程
                    调用对象的hashCode()方法获取对象的哈希值
                        根据对象的哈希值计算对象的存储位置
                            该位置是否有元素存在
                                有
                                    遍历该位置的元素，和新存入的元素比较哈希值是否相同
                                        有相同的
                                            调用equals()方法比较对象内容是否相等
                                                返回true
                                                    说明元素重复，不存储
                    要保证元素唯一性，需要重写hashCode()和equals()
            常见数据结构 哈希表
                哈希表
                    JDk8之前，底层采用数据+链表实现，可以说是一个元素为链表的数组
                    JDK8以后，在长度比较长的时候，底层实现了优化
            LinKedHashSet集合
                概述和特点
                    哈希表和链表实现的Set接口，具有可预测的迭代次序
                    由链表保证元素的有序，也就是说元素的存储和取出顺序是一致的
                    由哈希表保证元素的唯一性，也就是说没有重复的元素
            TreeSet集合
                概述特点
                    元素有序，这里得顺序不是指存储和取出得顺序，而是按照一定得规则进行排序，具体排序方法取决于构造方法
                    没有带索引得方法，所以不能使用for循环遍历
                    元素不能重复
                构造方法
                    TreeSet()
                        根据其元素的自然排序进行排序
                    TreeSet(Comparator Comparator)
                        根据指定的比较强进行排序
                自然排序Comparable
                    用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序。对元素进行排序的
                    自然排序，就是让元素所属的类实现Comparable接口。并重写compareT0(To)方法
                    重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
                比较器排序Comparator
                    同treeSet集合存储自定义对象，带参构造方法使用的是比较器排序，对元素进行排序
                    比较器排序，就是让集合构造方法接收Comparator是实现类对象，重写compare(To 1，To2)方法
                    重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
        泛型
            泛型概述
                泛型是JDK5中引入的特性，它提供了编译时类型安全检查机制，该机制允许在编译时检查到非法的类型
                它的本质是参数化类型，也就是说所操作的数据类型被指定一个参数
                就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型
                这种参数类型可以用在类，方法和接口中，分别称为泛型类，泛型方法和泛型接口
                泛型只能是引用数据类型
            泛型定义格式
                <类型>
                    指定一种类型的格式，这里的类型可以看成是形参
                <类型1,类型2 ...>
                    指定多种类型的格式，多种类型之间用逗号隔开，
            泛型的好处
                把运行时期的问题提到了编译期间
                避免了强制转换
            泛型类
                泛型类定义格式
                    格式
                    范例
            泛型方法
                泛型方法的定义格式
                    格式
                    范例
            泛型接口
                泛型接口的定义格式
                    格式
                    范例
            类型通配符
                类型通配
                    <?>
                List<?>
                    为了表示各种泛型List的父类，可以使用类型通配符
                    表示元素类型未知的List，它的元素可以匹配任何的类型
                    这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中
                <? extends 类型>(类型通配符上限)
                    只代表某一类泛型List的父类
                    List<? extends Number>
                        它表示的类型是Number或者其子类型
                <? super 类型>(类型通配符下限)
                    List<? super Number>
                        它表示的类型是Number或者其父类
            可变参数
                概述
                    可变参数又称为参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的
                格式
                范例
                注意
                    这里的变量其实是一个数组
                    如果一个方法有多个参数，包含可变参数，可变参数要放在最后
                Arrays工具类中
                    public static <T>List<T> asList(T...a)
                        返回由指定数组支持的固定大小的例表
                        不能增删，只能改
                List接口中
                    public static <E>List<E> of(E... elements)
                        返回包含任意数量元素的不可变例表
                        不能增删改
                Set接口中
                    public static <E>Set<E> of(E... elements)
                        返回一个包含任意数量元素的不可变集合
                        不能重复，不能增删，Set没有修改方法
        Map
            Map集合概述
                Interface Map<K,V>
                    K:键的类型；V:值得类型
                将键映射到值的对象；不能包含重复的键，每一个键可以映射到最多一个值
            创建Map集合的对象
                多态的方式
            Map集合的基本功能方法
                V put(K key,V value)
                    添加元素
                V remove(Object key)
                    根据键删除键值对元素
                void cleat()
                    移除所有的键值对元素
                boolean containsKey(Object key)
                    判断集合是否包含指定的键
                boolean containsValue(Object value)
                    判断集合是否包含指定的值
                boolean isEmpty()
                    判断集合是否为空
                int size()
                    集合的长度，也就是集合中键值对的个数
            Map集合的获取功能方法
                V get(Object key)
                    根据键获取值
                Set<K>keySet()
                    获取所有键的集合
                Collection<V> values()
                    获取所有值的集合
                Set<Map.Entry<K,y>>entrySet()
                    获取所有键对对象的集合
        Collections
计算机存储单元
    1B(字节) = 8bit
    1KB  =  1024B
    1MB  =  1024KB
    1GB  =  1024MB
    1TB  =  1024GB
将元素存储到该位置