java基础

java概述
    Java是一种面向对象编程的语言，也是一种面向Internrt编程的语言，基于C++，安全可靠。
    * java语言的特点
        简单易学----高级语言，完成面向对象的语言
        跨平台性----java开发的程序可以在不同的操作系统中运行，而且效果一致
            跨平台的原理：java提供了一个翻译的功能，这个翻译的功能可以将java代码
                      翻译为不同操作系统平台能够识别的指令
                      jvm(java 虚拟机)---提供翻译功能
                      jvm：本身不跨平台
        安全性------被加载到内存中之后，java会自动的将占用内存进行释放---自动垃圾回收，而c++写的程序必须有程序员手动释放
        面向对象
    * java的技术体系
         javase:(j2se)------ java的标准版，用来开发一些桌面应用程序，提供技术支持 
         javame(j2me)----- java的微缩版，嵌入式开发，移动设备开发，提供技术支持---------android
         javaee(j2ee)------ java的企业版，对java的企业级的应用提供技术支持。12306，crm，erp，oa




java开发环境的搭建
    * java开发环境的构成
        jre:---java 运行环境，用来执行java程序，jre包含java的核心的类库和jvm 虚拟机
        jdk:---java 开发工具包，用来给程序员使用，开发java程序，jdk包含java的开发工具和jre
    * 开发环境的获取途径
        www.oracle.com------数据库oracle数据库，甲骨文公司
        java.sun.com
        注意：安装路径不要使用中文安装目录，也不要出现空格



path环境变量的配置
    * 作用
        让java的开发工具在任意目录都可以运行------方便开发使用
    * 步骤
        第一步：计算机--------属性-------高级系统设置-------环境变量-------系统变量
        第二步： 编辑path:在path里面指定jdk中bin目录即可
    * 原理
        在命令行输入命令的时候会根据path环境变量指定的目录中依次寻找指定的exe文件
    * 实际开发中配置方法:-----动态配置  
        第一步：新建环境变量JAVA_HOME=C:\Java\jdk1.7.0_17
        第二步：编辑path，path=%JAVA_HOME%/bin
        %JAVA_HOME%:作用动态获取JAVA_HOME变量中的值


classpath环境变量的配置
    * 作用：让class文件在任意目录都可以执行
        exe程序是window平台可执行程序，为了让exe任意目录都可以执行，配置path环境变量
        class文件是java可执行程序，同样情况class文件能不能做到任意目录都可以执行  ？ 需要配置classpath
        如果没有配置classpath,会在当前目录寻找,如果配置了,就会按照classpath寻找,不会在当前目录寻找
    * 步骤
        第一步：计算机--------属性-------高级系统设置-------环境变量-------系统变量
        第二步： 新建classPath:在classPath里面指定class文件所在目录即可
        注意: .表示当前目录
    * set命令的用法(配置临时环境变量,本次命令行有效)
        set 环境变量名   ---- 查看当前配置的环境变量的值
        set 环境变量名=值
        set 环境变量名=%环境变量名%;xxx         
    * 查找特点
        按照配置的顺序查找，在实际开发中，不需要配置当前目录，如果在classpath中不到就提示错误即可




关键字
    就是在java语言系统中已经被定义过或者被使用过的单词，这些单词都有特殊的含义和用法，全部为小写



标识符
    Java 语言中，对各种变量、方法和类等要素命名时使用的字符序列称为标识符。
    Java 标识符的命名规则
        标识符由字母、下划线“_” 、美元符“$”或数字组成。
        标识符应以字母、下划线 、美元符开头。
        Java中严格区分大小写。
    Java当中的一些常用规范：
        1、包：多单词组成时，全部小写
        2、类名接口名：多单词组成时，所有的单词首字母大写
        3、变量名：多单词组成时，第二个单词首字母大写
        4、常量名：所有的字母大写，用下划线连接
        


注释
    用于注解说明解释程序的文字就是注释。提高了代码的阅读性。
    * 单行注释,格式：//注释文字
    * 多行注释,格式：/* 注释文字 */
    * 文档注释,格式：/** 注释文字 */
    对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行。
    对于文档注释，是java特有的注释，其中注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。



常量和变量
    * 常量表示不能改变的数据。(用final修饰的变量)
    * Java中常量的分类：
        1，整数常量。所有整数。
        2，小数常量。所有小数。
        3，布尔型常量。较为特有，只有两个数值。true false 。
        4，字符常量。将一个数字字母或者符号用单引号( ' ' )标识。
        5，字符串常量。将一个或者多个字符用双引号标识。
        6，null常量。只有一个数值就是:null。
        对于整数：java语言支持以下3种表示形式。
            八进制
            十进制
            十六进制
        负数的二进制表现形式:对应的正数二进制取反加1(补码)
    * 变量的概念：
        内存中的一个存储区域
        该区域有自己的名称（变量名）和类型（数据类型）
        该区域的数据可以在同一类型范围内不断变化
    * 使用变量注意：
        变量的作用范围（一对{}之间有效）
    * 定义变量的格式：
        数据类型 变量名 = 值;
        



数据类型
    Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间
    * 数据类型
        * 基本数据类型
            数值型
                整数类型(byte,short,int,long)
                浮点类型(float,double)
            字符型(char)
            布尔型(boolean)
        * 引用数据类型
            类(class)
            接口(interface)
            数组([])
    Java整型常量默认为int型，声明long型常量可以后加 l 或 L
    Java浮点型常量默认为double型，声明float型常量可以后加 f 或 F
    数据类型占用存储空间(字节)
        byte    1
        short   2
        int     4
        long    8
        float   4
        double  8
    * 类型转换
        java中可以从任意基本类型转型到另外的基本类型(例外 : boolean 类型不可以转换为其他的数据类型。)
        * 自动类型转换（也叫隐式类型转换）  
        * 强制类型转换（也叫显式类型转换） 
        表达式的数据类型自动提升
            所有的byte型、short型和char的值将被提升到int型。
            如果一个操作数是long型，计算结果就是long型；
            如果一个操作数是float型，计算结果就是float型；
            如果一个操作数是double型，计算结果就是double型。



运算符
    * 算术运算符,赋值运算符,比较运算符,逻辑运算符,位运算符,三元运算符,()
    算术运算符(+,-,*,/,%,++,--)
        如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。但被模数是负数就另当别论。
        对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。 
    赋值运算符(=,+=,-=,*=,/=,%=)
    比较运算符(==,!=,<,>,<=,>=,instanceof)
        比较运算符的结果都是boolean型，也就是要么是true，要么是false。
        比较运算符“==”不能误写成“=” 。
        Instanceof：用来判定对象类型是否是指定的类型。
    逻辑运算符(&,|,&&,||,^,!)
        逻辑运算符用于连接布尔型表达式
        异或( ^ )：两边不一样的时候为true
        “&”和“&&”的区别：双&时，如果左边为假，右边不参与运算。
        “|”和“||”的区别：双|时，如果左边为真，右边不参与运算。
    位运算符(<<,>>,>>>,&,|,^,~)
        位运算是直接对二进制进行运算
        <<  左移        空位补0，被移除的高位丢弃
        >>  右移        被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，空缺位补1
        >>> 无符号右移  被移位二进制最高位无论是0或者是1，空缺位都用0补。
        &   与          任何二进制位和0进行&运算，结果是0；和1进行&运算结果是原值。
        |   或          任何二进制位和0进行 | 运算，结果是原值；和1进行 | 运算结果是1。
        ^   异或        任何相同二进制位进行 ^ 运算，结果是0；不相同二进制位 ^ 运算结果是1。
        ~   反码        所有位取反
    三元运算符(条件运算符)
        格式
            (条件表达式)?表达式1:表达式2;
            如果条件为true，运算后的结果是表达式1；
            如果条件为false，运算后的结果是表达式2
    运算符的优先级决定了表达式的执行顺序,优先级不确定就用()括住,()的优先级最高。

        

判断结构
    * if语句和switch语句
    if语句
        三种格式
        1.
            if(条件表达式){
                执行语句；
            }
        2.
            if(条件表达式){
                执行语句；
            }else{
                执行语句；
            }
        3.
            if(条件表达式){
                执行语句；
            }else if (条件表达式)
            {
                执行语句；
            }
            ……
            else{
                执行语句；
            }
        if语句特点：
            第二种格式与三元运算符的区别：三元运算符运算完要有值出现。
            条件表达式无论写成什么样子，只看最终的值是true 或者 false;
    switch语句
        格式
            switch(表达式){
                case 取值1:
                    执行语句；
                    break；
                case 取值2:
                    执行语句；
                    break；
                ……
                default:
                    执行语句；
                    break；
            }
        switch语句特点：
            switch语句选择的类型只有四种：byte，short，int ，char。在JDK1.7后支持了String类型
            结束switch语句的两种情况：遇到break，执行到switch语句结束。
            如果匹配的case或者default没有对应的break，那么程序会继续向下执行，直到遇到break或者switch结尾结束。
        if和switch语句的应用：
            if：1、对具体值进行判断
                2、对区间进行判断。
                3、对运算结果是boolean类型的表达式进行判断。
            switch：
                1、对具体的值进行判断
                2、值的个数通常都是固定的。
            对于几个固定的值进行判断，建议使用switch语句，因为swtich语句将具体的答案加载进内存中，效率会高些。



循环结构
    * while语句,do while语句,for语句,增强for循环
    while语句
        while(条件表达式){
            执行语句；
        }
        先判断逻辑表达式的值。若=true.则执行其后面的语句,然后再次判断条件并反复执行，直到条件不成立为止
    do while语句
        do{
            执行语句；
        }while(条件表达式);
        先执行语句,再判断逻辑表达式的值,若为true,再执行语句,否则结束循环。
    for语句
        for(循环变量初始化；循环条件判断；更新循环变量){
            执行语句；
        }
        执行顺序:初始化-->判断-->(执行语句-->更新-->判断)-->...-->结束
        循环变量初始化,循环条件判断,更新循环变量 都可以省略,但分号不能省略
    增强for循环(JDK1.5新特性)
        for(数据类型  变量名:数组或者collection集合){
            执行语句;
        }
        增强for循环 可以遍历实现了Iterable接口的类
        通常增强for循环只用于遍历目标(修改不方便,增删不能做)
        在遍历过程中可以进行修改操作,不能进行增删操作(会抛异常)


break和continue
    break语句：应用范围：选择结构和循环结构。用于跳出循环或跳过后面的某些代码.
    continue语句：应用于循环结构。用于跳过本次循环,进行下一层循环.
    注意标号的使用
        W:for(){
            for(){
                break W;
            }
        }
    * 程序控制语句除了break和continue以外,还有return



方法
    * 方法的定义
        方法是一个定义在类中的具有独立功能的程序块
        格式:
            修饰符 返回值类型 方法名(参数类型 形式参数1，参数类型 形式参数2，…)
            {
                    执行语句;
                    return 返回值;
            }
            对于方法没有具体返回值的情况，返回值类型用关键字void表示，那么该方法中的return语句如果在最后一行可以省略不写。
    * 方法的重载
        在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可
        调用时根据参数个数,类型,顺序自动匹配具体的某个方法
        问题:返回值不同可以构成重载吗?
            答:当满足方法名称一样,参数个数或参数类型有一样不同时,返回值不一样可以构成重载.当前面的条件不满足时,不能构成重载
        问题:静态方法和非静态方法可以构成重载吗?
            答:语法不报错,但是逻辑上不是重载
    * 方法参数传递的问题
        基本类型参数 和引用类型参数
        方法参数相当于局部变量



数组
    * 概述
        数组是同一种类型数据的集合。其实数组就是一个容器。
        数组是多块连续的内存空间
        数组的长度声明以后不可改变,意思是只能修改,不能增加和删除.
        可以自动给数组中的元素从0开始编号，方便操作这些元素。
    * 创建格式:
        1. 元素类型[] 数组名 = new 元素类型[int len];
        2. 元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
        3. 元素类型[] 数组名 = {元素，元素，……};
        注意,第三种方式只能在数组声明时使用
    * 操作数组:
        数组名.length:获取数组中的元素个数。
        存放数据:数组名[index] = 值;
        获取数据:数组名[index]
    二维数组
        1. 元素类型[][] 数组名 = new 元素类型[元素个数或数组长度][元素个数或数组长度];
        2. 元素类型[][] 数组名 = new 元素类型[元素个数或数组长度][];
        3. 元素类型[][] 数组名 = {{值1,值2,...},...};
    * 常见操作:最值,排序
    * 相关工具类:java.utils.Arrays
        * Arrays类常用方法:
            static <T> List<T> asList(T... a) 
                数组转换为集合。 由数组转换成的集合不能进行增删操作(会报异常)
                    数组中的元素是引用类型时,转换的集合其实还是原来的数组,原来的数组改变,转换的集合也跟着改变
                    数组中的元素是基本类型时,集合会将数组添加到第一位
            static int binarySearch(Object[] a, Object key) 
                使用二分搜索法来搜索指定数组，以获得指定对象的索引。
            static boolean[] copyOfRange(boolean[] original, int from, int to) 
                将指定数组的指定范围复制到一个新数组。 
            static void sort(Object[] a) 
                根据元素的自然顺序对指定对象数组按升序进行排序。 
            static <T> void sort(T[] a, Comparator<? super T> c) 
                根据指定比较器产生的顺序对指定对象数组进行排序。
            static String toString(Object[] a) 
                返回指定数组内容的字符串表示形式。 




内存结构(暂时不深入)
    Java程序在运行时，需要在内存中分配空间。
    为了提高运算效率，又对空间进行了不同区域的划分，每一片区域都有特定的处理数据方式和内存管理方式。
    * 栈内存
         用于存储局部变量，当数据使用完，所占空间会自动释放。
    * 堆内存
        数组和对象，通过new建立的实例都存放在堆内存中。
        每一个实体都有内存地址值
        实体中的变量都有默认初始化值
        实体不再被引用，会在不确定的时间内被垃圾回收器回收
    * 方法区
    * 本地方法区
    * 寄存器
    * 栈内存和堆内存的区别
        栈存储局部变量，方法
        堆存储成员变量和实体

        栈内存中的内容一旦使用完毕就被释放，生命周期较短
        堆内存中的内容需要JVM进行垃圾回收，生命周期较长

        栈内存中的变量，没有默认值
        堆内存中的变量，都有默认值



转义字符
    通过\来转变后面字母或者符号的含义。
    \n:换行。在linux中只有\n.
    \b:退格 相当于backspace.
    \r:按下回车键;window系统中，回车符是有两个字符来表示的:\r\n.不同操作系统对应的符号是不一样的。
    \t:制表符 相当于tab键。
    \",\\:表示"或\本身.



面向对象
    * 概述
        面向对象是相当面向过程而言,面向对象和面向过程都是一种思想
        它让复杂的问题简单化，它把执行者变成了指挥者。
        开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。
        设计的过程：其实就是在管理和维护对象之间的关系。
    * 面向对象的特征：
        * 封装(encapsulation)
        * 继承(inheritance)
        * 多态(polymorphism)
    * 封装
        是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
        好处：
            将变化隔离。
            便于使用。
            提高重用性。
            提高安全性。
        封装原则：
            将不需要对外提供的内容都隐藏起来。
            把属性都隐藏，提供公共方法对其访问。



类和对象
    * 概述
        类是具体事物的抽象，概念上的定义。
    * 语法
        修饰词 class 类名{
            类体;
        }
    在类中定义的变量和方法都称为类中的成员。
    * 成员
        成员变量---属性
        成员方法---行为
    对象即是该类事物实实在在存在的个体。
    * 对象创建格式
        类型 对象名 = new 构造方法([参数,..]);
    * 成员调用格式
        对象名.变量
        对象名.方法(参数)
    
    


成员变量和局部变量
    成员变量：
        成员变量定义在类中，在整个类中都可以被访问。
        成员变量随着对象的建立而建立，存在于对象所在的堆内存中。
        成员变量有默认初始化值。
    局部变量：
        局部变量只定义在局部范围内，如：方法内，语句内等。
        局部变量存在于栈内存中。
        作用的范围结束，变量空间会自动释放。
        局部变量没有默认初始化值。
    * 成员变量和局部变量的区别
        1、源代码中定义位置不同：
            成员变量：定义在类中，在整个类中有效。
            局部变量：定义在方法中，在局部范围内有效。
            简单一句话：作用范围不一样，成员变量作用于整个类中，局部变量作用于方法中，或者语句中。
        2、在内存中的位置和生命周期不同：
            成员变量：随着对象的创建的而出现在堆内存中，随着对象被回收而消失。
            局部变量：随着变量所属局部区域的运行，而出现在栈内存中，随着所属区域运行结束而释放。
        3、变量使用的初始化：
            成员变量：因为堆内存中都有默认初始化值，对于引用型变量默认值就是null;
            局部变量：因为在栈内存中都没有默认初始化值，必须手动初始化后才可以参与运算。



匿名对象
    即没有名字的对象，简化书写用的。
    例:new C().bb();
    匿名对象两种使用情况
        当对对象方法仅进行一次调用的时
        匿名对象可以作为实际参数进行传递

    

构造方法
    * 特点：
        方法名与类名相同
        没有返回值类型
    * 作用：
        对对象进行初始化。
    * 注意：
        默认构造方法的特点。(没有显式定义构造方法则默认存在一个无参的构造方法)
        多个构造方法是以重载的形式存在的。
        构造方法第一句必须为this([参数])或super([参数]),没有的话自动隐式添加super();
    * 构造代码块
        格式: 
            {
                构造代码块中的执行语句。
            }
        定义在类中，是一个独立的代码块，作用给所有对象进行初始化，在构造方法之前执行。(创建对象时一定会执行)
        注意区分静态代码块：静态代码块是给类进行初始化，随着类的消失而消失。



构造方法和一般方法的区别：
    * 格式不同：
        构造方法：修饰符 类名（参数列表）{}
        一般方法：修饰符 返回值类型 自定义方法名（参数列表）{}
    * 调用方式不同
        构造方法：构造方法是在对象已经建立就执行对应的构造方法，给对象进行初始化。
        一般方法：对象创建后，再调用一般方法。
    * 作用不同
        构造方法：是对对象进行初始化的.
        一般方法：给对象提供更多的功能，方便与对象的调用。
    * 调用次数不同
        构造方法：对象创建时，就调用一次，因为初始化动作最先执行，只执行一次
        一般方法：对象创建后，可以被多次调用。



static(静态)关键字
    * 用于修饰成员（成员变量和成员方法）
    * 被修饰后的成员的特点
        随着类的加载而加载(非静态的特点随着对象的加载而加载)
        优先于对象存在(所以不能访问对象的内容，但是对象可以访问它的内容)
        被所有对象所共享
        可以直接被类名调用
    * 使用注意
        静态方法只能访问静态成员(通过对象访问非静态成员)
        静态方法中不可以使用this，super
        主方法main是静态的
    * 静态代码块
        格式：
            static
            {
                静态代码块中的执行语句。
            }
        特点：随着类的加载而加载而且只执行一次，类一加载静态代码块就执行。
        作用：用于给类进行初始化的，注意区别构造代码块：给对象都进行初始化。



静态变量和成员变量的区别
    * 存储位置上来区分
        静态变量存储在方法区的静态区
        实例变量存储在堆内存
    * 生命周期来区分
        静态变量跟随类的加载而加载，跟着类的消失而消失，最长
        实例变量跟随对象的加载而加载，跟对象的消失而消失，相对较短
    * 从调用上区分
        静态变量可以被类名调用，可以被对象调用
        实例变量，只能被对象调用
    * 从所属区分
        静态变量属于类，属于对象共享数据
        实例变量属于对象，对象的特有数据



单例设计模式
    * 一个类在内存中只存在一个对象。
    * 思想:
        1.  为了避免其他程序过多的建立该类对象。先控制禁止其他程序建立该类对象
        2.  还为了让其他程序可以访问到该类对象只好在本类中自定义一个对象。
        3.  为了方便其他程序对自定义对象的访问可以对外提供一些访问方法。
    * 实现:
        1、将构造方法私有化。
        2、在类中创建一个本类对象。
        3、提供一个方法可以获取到该类对象。
    * 常用实现:饿汉式和懒汉式
        饿汉式是在声明成员变量时就实例化对象
        懒汉式是在获取时判断是否为空,为空再实例化对象
        因为多线程技术的存在，并发访问会造成懒汉式不安全。



继承
    * 继承的概述
        多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承单独的那个类即可。
        多个类可以称为子类，单独这个类称为父类或者超类。
        子类可以直接访问父类中的非私有的属性和方法。
        通过 extends 关键字让类与类之间产生继承关系。class SubDemo extends Demo{}
    * 继承的特点
        1、提高了代码的复用性。
        2、继承的出现让类与类之间产生了关系，提供了多态的前提。
        3、Java支持单继承，对于多继承，java保留了这种机制并进行了改良(多层继承)，避免了多继承调用时的不确定性。
    * 子类的实例化过程
        子类中所有的构造方法默认都会访问父类中空参数的构造方法,每一个构造方法的第一行都有一条默认的语句super();
        当父类中没有空参数的构造方法时，子类的构造方法第一条语句必须通过this或者super语句指定要调用的构造方法。



方法重写
    * 概述
        子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。
    * 方法重写注意事项：
        父类中的私有方法不可以被覆盖。
        在子类覆盖方法中，继续使用父类被覆盖的方法可以通过super.方法名()获取。
        重写时，子类方法权限一定要大于等于父类方法权限
        静态只能重写静态。
    


this和super关键字
    * this是对象本身的引用
    * this的主要用法:
        1. this.属性 代表成员变量(与方法参数重名时可以使用)
        2. 非静态成员方法中this代表调用该方法的对象
        3. 构造方法中 this(参数) 为调用本类其它构造方法
    * super是父类对象的引用
    * super的主要用法:
        1. super.属性 代表父类成员变量(与子类成员变量重名时可以使用)
        2. 非静态成员方法中super代表调用该方法的对象的父类对象,super.方法()代表父类方法
        3. 构造方法中 super(参数) 为调用父类构造方法



final关键字
    final可以修饰类，方法，变量。
    final修饰的类不可以被继承。
    final修饰的方法不可以被覆盖。
    final修饰的变量是一个常量。只能被赋值一次。
    内部类只能访问被final修饰的局部变量。



类成员调用规则
    静态成员 : 通过所在类的类名调用,也可以通过所在类的对象调用(在本类中可省略类名,直接调用)
    非静态成员: 通过所在类的对象调用(在本类的非静态成员方法中可直接调用,相当于省略了this)
    本类成员 : this.成员
    父类成员 : super.成员



抽象类
    * 概述
        Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。
        抽象类和抽象方法必须用abstract关键字来修饰。
        抽象方法只有方法声明，没有方法体，定义在抽象类中。
        抽象类不可以被实例化，也就是不可以用new创建对象。
        抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。
    * 抽象方法格式
        修饰符 abstract 返回值类型 方法名(参数列表) ;
    * 抽象类和一般类异同点：
        相同：抽象类和一般类都用于描述事物，都可以定义成员。
        不同：抽象类中可以定义抽象成员方法，而一般类不可以。
              抽象类不可以实例化，一般类可以实例化。
    * 抽象关键字 不可以和哪些关键字共存
        final：修饰了类是一个最终类，不可以被继承，然后abstract修饰的类必须是父类，需要被继承
        static:抽象方法被static修饰，就具备了可以被类名直接调用的的特点，但是抽象方法被调用没有意义。
        priavte：因为抽象方法被私有，无法被覆盖。



接口
    * 定义格式:
        修饰词 interface 接口名{}
    * 接口中的成员修饰符是固定的。
        成员常量：public static final
        成员方法：public abstract
    * 接口的特点
        接口是对外暴露的规则。
        可以实现程序的功能扩展,降低耦合性。
        用来多实现
        接口是不可以创建对象的
        接口与接口之间是继承关系，而且可以多继承
    * 与抽象类的区别：抽象类有单继承的局限性，接口没有
    * 实现接口: class A implements I,I2{



抽象类和接口之间的共性与区别
    共性：它们都是不断抽取出来的抽象概念
    区别：
        1、抽象类只能被单继承、接口可以被多实现，避免了单继承的局限性。
        2、抽象类中可以定义抽象方法，和非抽象方法，它可以用于定义体系的基本共性的内容。接口中只能定义抽象方法，它主要用于对象的功能的扩展。
        3、抽象类中的成员修饰符都是自定义的，接口中的修饰符都是固定的。



多态
    * 作用：
        运行时根据实际类型确定调用的方法.多态的存在提高了程序的扩展性和后期可维护性
    * 前提：
        父类引用指向子类对象
        子类重写父类方法
    * 多态的特点
        * 非静态成员方法：
            编译时：查看父类中是否有所调用的成员。有则编译成功,没有则编译失败
            在运行时：查看运行时的实际类型中是否有所调用的方法。有则运行子类方法,没有则运行父类方法
        * 成员变量和静态方法：
            调用父类的成员。



内部类
    * 概述
        将一个类定义在另一个类的里面，里面那个类就称为内部类（内置类，嵌套类）。
    * 访问特点：
        内部类可以直接访问外部类中的成员，包括私有成员。
        而外部类要访问内部类中的成员必须要建立内部类的对象。
    * 内部类的位置
        * 内部类定义在成员位置上
            可以被 访问修饰词 static修饰符修饰。
            被static修饰的内部类只能访问外部类中的静态成员。
        * 内部类定义在局部位置上
            可以直接访问外部类中的成员。
            同时可以访问所在局部中的局部变量，但必须是被final修饰的。(类的生命周期比方法长)
    * 创建内部类对象(只有定义在成员位置上的内部类可以在外面访问到)
        外部类名.内部类名 变量 = 外部类对象.new 内部类名();
    * 匿名内部类
        * 就是建立外部类或者接口的子类匿名对象。
        * 格式
            new 抽象类或者接口(){覆盖类或者接口中的方法};
    


异常
    * 异常的体系
        Throwable
            Error(错误,程序无法解决的错误)
            Exception(异常,由代码问题引起的,可以被改正的)
                RuntimeException(运行时异常)
    * Throwable中的方法 
        String getMessage()
            获取异常信息。
        String toString()
            获取异常类名和异常信息。
        void printStackTrace()
            打印异常类名和异常信息，以及异常出现在程序中的位置。
        void printStackTrace(PrintStream s)
            通常用该方法将异常内容保存在日志文件中，以便查阅。
        StackTraceElement[] getStackTrace() 
            提供编程访问堆栈跟踪信息。 
        Throwable getCause() 
            返回此 throwable 的 cause；如果 cause 不存在或未知，则返回 null。 
    * throws和throw
        throws用于标识方法暴露出的异常。
        throw用于抛出异常对象。
        throws与throw的区别：
            thorws用在方法上，后面跟异常类名。
            throw用在方法内，后面跟异常对象。
    * 异常处理:try catch finally
        try
        {
            需要检测的代码；
        }
        catch(异常类  变量)
        {
            异常处理代码；
        }
        finally
        {
            定义一定会被执行的代码。通常用来关闭资源；
        }
        try后面至少跟一个语句块
        finally代码块只有一种情况不会被执行。就是在之前执行了System.exit(0)。
    * 异常分两种：编译异常和运行时异常
        1、编译被检测的异常：Exception
            这种异常通常都需要进行针对性的处理。
        2、运行时发生的异常：RuntimeException
            运行时发生的异常,无法在编码时进行预判捕获,通常是数据存在问题
            如:NullPointerException,ClassCastException,IndexOutOfBoundsException
        RuntimeException以及其子类如果在方法中被throw抛出，可以不捕获,也可以不在方法上throws。
    * 异常的处理原则：
        1、处理方式有两种：try 或者throw。
        2、调用到抛出异常的功能时，抛出几个就处理几个。
            一个try对应多个catch的情况。
        3、多个catch时父类的catch放到最下面。
        4、catch内需要定义针对性的处理方式。
            当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。
    * 自定义异常
        自定义类继承Exception或者其子类。
        通过构造方法定义异常信息。
        例：
            class DemoException extends Exception
            {
                DemoException(String message)
                {
                    super(message);
                }
            }
        通过throw将自定义异常抛出。
    * 异常的注意事项：
        在子类覆盖时：
            1、子类抛出的异常必须是父类异常的子类或者子集。
            2、如果父类或者接口的方法没有异常抛出时，子类不能抛。
    * java处理异常的机制是不断向上抛



包(package)
    * 概述
        给类提供多层命名空间,是一种封装形式,对类文件进行分类管理
        包在文件系统中体现为文件夹
        类名的全称的是  包名.类名。
    * 声明所在包
        package 包名;
        注意:必须写在程序文件的第一行。
    * 导入包 : import 包; 写在包声明下面
    * 包之间的访问
        被访问的包中的类权限必须是public的。
        类中的成员的权限：public或者protected(protected是为其他包中的子类提供的一种权限)
    * 命令行的包操作:
        编译带包的类:要进入到包中,javac 类名.java
        运行带包的类:退出所有包结构,java 类的全限定名称
    


权限修饰词
    public : 所有位置
    protected : 同包 或 不同包子类
    default : 同包
    private : 本类
    注意:
        类的修饰词只能是public,default
        修饰词限定的是使用位置(在其它类中,类A的对象也不能访问类A中的私有属性)
        不写的话默认为default
        修饰位置为类或类的成员,对局部变量不可用



jar包操作
    * 作用
        可以将自己的程序打包提供给别人使用
        java项目通常打包为jar包.指定入口类后生成jar文件,即可双击运行
        web项目通常打包为war包.通过war包放到服务器发布运行
        rar == jar == war,可以任意更改后缀名
    * 创建jar包
        jar -cvf 生成文件名称 要打包的文件
    * 自定义jar包的清单文件(为java项目指定入口类)
        jar –cvfm 生成文件名称 清单文件 要打包的文件
        //清单文件,名称任意,内容:Main-Class: 入口类全限定名称
        //注意:入口类全限定名称前有一个空格,后面有一个空行.清单文件和要打包的其它文件放到一起
        //例:jar –cvfm aaa.jar abc.txt A.class
    * 使用命令行执行jar文件
        java -jar jar文件名称
    注意
        web项目要进入项目文件夹的WebRoot文件夹下,打包所有文件(-cvf),war文件名称即要访问的项目名称,将war包放入tomcat下的webapps下即可(服务器软件启动时会自动解压)
        例: jar -cvf aaa.war *
    使用窗口测试jar文件能否双击运行,运行成功应该有个窗口出现
        import javax.swing.*;
        import java.awt.*;
        public class A{
            public static void main(String[] args){
                JFrame frame = new JFrame("测试");
                frame.setSize(300,200);
                frame.setVisible(true);
                frame.setDefaultCloseOperation(3);
            }
        }
    * jar文件不能直接双击运行的设置方式
        1.把打开方式设置为 : %JAVA_HOME%/bin/javaw.exe
            这时已经设置了使用javaw.exe应用程序来打开jar文件，可是实际上这时双击jar文件还是没有反应，这是因为没有设置打开文件参数导致的。
        2.在Windows开始菜单的搜索框中输入“regedit”，在上方搜索出的文件regedit上点击鼠标右键，在弹出的菜单中选择“以管理员身份运行”。
        3.在左边找到“HKEY_CLASSES_ROOT\Applications\javaw.exe\shell\open\command”，在其中文件打开命令中加入参数“-jar”（无引号），修改后的数值类似：“"C:\Java\jre7\bin\javaw.exe" -jar "%1"”（只需要添加-jar参数，无需修改其他信息），退出注册表编辑器。
        注意:
            jar文件所在路径不要有中文
            实验发现,jar文件只有在磁盘根目录下一定能打开,在其它目录下很少能打开
    


自我理解
    生活中所有的数据都是基本类型数据
    数组也是用来存放基本数据类型
    对象也是由基本类型组成
    String是字符数组
    StringBuffer是可变字符数组