java基础

Java语言

Java基础

Java简介

Jdk

 JDK是 Java 语言的软件开发工具包，主要用于移动设备、嵌入式设备上的java应用程序。JDK是整个java开发的核心，它包含了JAVA的运行环境，JAVA工具和JAVA基础的类库。

jdk1.8新特性

1、Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 default关键字即可。

2、新增lambda表达式。

3、提供函数式接口。

4、Java 8 允许你使用 :: 关键字来传递方法或者构造函数引用

5、我们可以直接在lambda表达式中访问外层的局部变量。

组成

    JDK包含的基本组件包括：

    javac – 编译器，将源程序转成字节码

    jar – 打包工具，将相关的类文件打包成一个文件

    javadoc – 文档生成器，从源码注释中提取文档

    jdb – debugger，查错工具

    java – 运行编译后的java程序（.class后缀的）

    appletviewer：小程序浏览器，一种执行HTML文件上的Java小程序的Java浏览器。

    Javah：产生可以调用Java过程的C过程，或建立能被Java程序调用的C过程的头文件。

    Javap：Java反汇编器，显示编译类文件中的可访问功能和数据，同时显示字节代码含义。

    Jconsole: Java进行系统调试和监控的工具

常用的包

    java.lang： 这个是系统的基础类，比如String等都是这里面的，这个包是唯一一个可以不用引入  (import)就可以使用的包。

    java.io： 这里面是所有输入输出有关的类，比如文件操作等。

    java.nio：为了完善io包中的功能，提高io包中性能而写的一个新包 ，例如NIO非堵塞应用

    java.net: 这里面是与网络有关的类，比如URL，URLConnection等。

    java.util： 这个是系统辅助类，特别是集合类Collection，List，Map等。

    java.sql： 这个是数据库操作的类，Connection， Statement，ResultSet等。

    javax.servlet：这个是JSP，Servlet等使用到的类。

常用基本工具

    1. Javac: Java源程序编译器，将Java源代码转换成字节码。
2. Java: Java解释器，直接从字节码文件，又称为类文件.执行Java应用程序的字节代码。
　 3. appletviewer.exe Java applet浏览器。appletviewer命令可在脱离万维网浏览器境的情况下运行applet
　  4. jar: java应用程序打包工具，可将多个类文件合并为单个JAR归档文件。
　  5.Javadoc: Java API文档生成器从Java源程序代码注释中提取文档，生成API文档HTML页。
　  6. jdb: Java调试器(debugger),可以逐行执行程序.设置断点和检查变Md 

Jvm 

是一种用于计算是设备的规范，它是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功能来实现的。

  Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。一般的高级语言如果要在不同的平台上运行，至少需要编译成不同的目标代码。而引入Java语言虚拟机后，Java语言在不同平台上运行时不需要重新编译。Java语言使用Java虚拟机屏蔽了与具体平台相关的信息，使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。Java虚拟机在执行字节码时，把字节码解释成具体平台上的机器指令执行。这就是Java的够“一次编译，到处运行”的原因。 

支持的数据类型

      byte://1字节有符号整数的补码

        short://2字节有符号整数的补码

        int://4字节有符号整数的补码

        long://8字节有符号整数的补码

        float://4字节IEEE754单精度浮点数

        double://8字节IEEE754双精度浮点数

        char://2字节无符号Unicode字符

规格

JVM的设计目标是提供一个基于抽象规格描述的计算机模型，为解释程序开发人员提供很好的灵活性，同时也确保Java代码可在符合该规范的任何系统上运行。JVM对其实现的某些方面给出了具体的定义，特别是对Java可执行代码，即字节码（Bytecode）的格式给出了明确的规格。这一规格包括操作码（指令序列号，用来告诉CPU需要执行哪一条指令）和操作数的语法和数值、标识符的数值表示方式、以及Java类文件中的Java对象、常量缓冲池在JVM的存储映象。这些定义为JVM解释器开发人员提供了所需的信息和开发环境。Java的设计者希望给开发人员以随心所欲使用Java的自由。

JVM定义了控制Java代码解释执行和具体实现的五种规格，它们是：

JVM指令系统

JVM寄存器

JVM 栈结构

JVM 碎片回收堆

JVM 存储区

操作数与操作数

            操作数指出指令执行的操作所需要数据的来源。操作数是汇编语言指令的一个字段。例如：MovAX 5678H 操作数（AX 5678H）。在操作这个字段中可以放操作数本身，也可以放作地址，还可以放操作地址的计算方法。       

操作符

    指令系统的每一条指令都有一个操作符，它表示该指令应进行什么性质的操作。不同的指令用操作符这个字段的不同编码来表示，每一种编码代表一种指令。组成操作符字段的位数一般取决于计算机指令系统的规模。

     Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特性 。Java可以编写桌面应用程序、Web   应用程序、分布式系统和嵌入式系统应用程序等

安全性：为防止把计算机内的机密文件泄露给无关的用户，必须采取某种安全保密措施，这些措施的有效程序如何就称为计算机系统的安全性或保密性。  

语言规范

    JCP（Java Community Process）是一个开放的国际组织，主要由Java开发者以及被授权者组成，职能是发展和更新Java技术规范、参考实现（RI）、技术兼容包（TCK）。

JCP维护的规范包括Java ME、Java SE、Java EE、XML、OSS、JAIN等。组织成员可以提交JSR（Java Specification Requests），通过特定程序以后，进入到下一版本的规范里面。

    JSR是早期提议和最终发布的Java平台规范的具体描述。通常，一个新的JSR的提出是为了增加或者规范Java平台的功能。某个具体的JSR由专家组共同来制定，工作由组长协调。例如，CLDC1.0（Connected Limited Device Configuration，JSR30）由Sun公司的Antero Taivalsaari担任组长，同时专家组的成员还包括Siemens、Motorola、Nokia、Symbian等。Java ME平台规范是在JSR68中定义的，规范组长是Sun公司的Jon Courtney。

    JSR完成后，相关的规范及JavaAPI会在JCP的官方网站发布。设备制造商可以在自己的产品中实现某个JSR，如MIDP2.0（JSRll8）。但是这些都必须要通过TCK（Technology Compatibility Kit）测试以确保技术兼容性。[32] 

    按照技术类别可以分成以下几类：

    1、J2EE平台规范[33] 

    2、J2SE平台规范[34] 

    3、J2ME平台规范[35] 

    4、运营支持系统规范（OSS）[36] 

    5、综合网络的Java 应用（JAIN）[37] 

  6  、XML 操作规范[38] 

Java语法基础

变量和常量

path环境变量：

      环境变量（environment variables）一般是指在操作系统中用来指定操作系统运行环境的一些参数，如：临时文件夹位置和系统文件夹位置等。

    环境变量是在操作系统中一个具有特定名字的对象，它包含了一个或者多个应用程序所将使用到的信息。例如Windows和DOS操作系统中的path环境变量，当要求系统运行一个程序而没有告诉它程序所在的完整路径时，系统除了在当前目录下面寻找此程序外，还应到path中指定的路径去找。用户通过设置环境变量，来更好的运行进程。

      path环境变量中有很多系统自带的变量，所有我们一般要新建一个java_home变量以后如果jdk的安装目录更换了，只要修改java_home这个变量就可以，在path中引用java_homne就可以

classpath：   

            Classpath设置的目的，在于告诉Java执行环境，在哪些目录下可以找到您所要执行的Java程序(.class)所需要的类或包。

               jdk1.5之后不用设置默认就是当前目录下 

 set classpath=D:\和set classpath=D:\;的区别：

                加分号jvm不仅在d:盘下找class文件，还会在当前目录下找。

                 可以配置rt.jar让jvm自动去找

标识符

          java中的标识符：由字母（a-zA-Z）0-9 _ $组成 不能以数字开头。严格区分大小写。

          标识符的规范：方法的命名小写，类的命名首字母大写，多个单词首字母大写，不能用关键字和保留字。

关键字 

            关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。

            goto是java的保留字，但不使用。

            保留字：现在没有付给goto变量特殊含义，但是以后不确定。

 注释：使用javadoc工具可以生成开发者文档。

            格式：javadoc -d 存放文档的路径 java的源文件

                         javadoc生成文档时总是报java.lang.IllegalArgumentException错误,是classpath里面字符冲突引起的

                         我在classpath中包含了%JAVA_HOME%\lib;解决方法是重新设置classpath去除其它环境变量的引用，直接使用目                               录名称，重新启动一下cmd或者Eclipse.。 

常量

常量是指在整个操作过程中其值保持不变的数据，通常在命令或程序中直接给出其值，字符常量是用单引号括起来的单个普通字符或转义字符，属于编程语言。如：'a','!'. 

                //char字符：一个能单，String字符串：多个不能单。            
                    String st = "string";//对：
                    st = 'string';//错：字符串一定要用双引号
                    char str = 'char';//错
                    str = 's';//对：只能定义单个字符

运算符：++a和a++的区别:       

            int a = 5, b = 5;

System.out.println(a++); // 先输出5，然后再对a进行累加

System.out.println(++b);//先累加再输出。输出6.

java中的变量

局部变量

在方法，构造函数或块中声明。

创建局部变量的方法，构造函数或块时进入，一旦退出方法，构造函数或块中的变量将被销毁。

访问修饰符不能用于局部变量。

局部变量是可见的，只有内声明的方法，构造函数或块。

局部变量在堆栈级别内部实现。

局部变量没有默认值，因此声明的时候应该给它初始值。注意：只有在使用局部变量的时候才要赋默认值。

成员变量               

 一：实例变量

在方法或块和类之间声明，没有用static修饰的变量

当空间分配给某个对象在堆中，插槽为每个实例变量创建值。

实例变量认为必须由一个以上的方法，构造函数或块，或一个对象的状态的关键部分必须出现在整个类中引用的值。

实例变量可以在使用前或后级的级别声明。

访问修饰符可以给出实例变量。

实例变量对于所有方法，构造函数和块在类中可见。通常，建议，使这些变量私有（接入层）。然而能见度子类可以给这些变量与使用访问修饰符。

实例变量有默认值。对于数字的默认值是0，为布尔值是false和对象引用为null。值可以在声明或构造函数中分配。

二：类变量(静态变量)：

类变量也称为静态变量在类的static关键字声明的，但在方法或块外面。

每个类变量只有一个副本，不管有多少对象从它被创建。

静态变量很少使用不是被声明为常量等。常量是被声明为公共/私营，最终和静态变量。常量变量从来没有从他们的初始值改变。

静态变量被存储在静态存储器中。这是罕见的使用静态变量以外声明为final，用作公共或私有常数。

在程序启动时的静态变量被创建，在程序停止销毁。

能见度类似于实例变量。然而，大多数静态变量声明为 public，因为它们必须可用于类的使用者

默认值是相同的实例变量。对于数字，默认值是0;为布尔值，它是假的，和对象引用，它为null。值可以在声明或构造函数中分配。另外值可以在特殊的静态初始化块进行分配。

静态变量可以通过调用与类名来访问。 ClassName.VariableName.

当定义的变量为 public static final ，那么变量的名称（常量）都是大写。如果静态变量是不公开的和最终的命名语法是相同的实例变量和局部变量。

静态代码块

静态代码块独立于类成员，jvm加载类时会执行静态代码块，每个代码块只执行一次，按顺序执行

成员变量是用来描述一类事物的公共属性。

局部变量如果出了所在的花括号就失效。                          
成员变量的初始值：

        int 0；

        float 0.0f；

        double 0.0；

        char ‘ ’一个空字符

       引用类型 null；

成员变量和静态变量的区别：

    作用上的区别：
          1、所有的对象都共享该对象的静态成员数据。

          2、成员变量是描述一类事物的公共属性。

    数量和存储位置的区别：

         1、类变量是在存储在方法区中的。并且只有一份。

         2、实例变量是存储在栈内存中的，有n个对象就有n个。

     生命周期不同：

         1、类变量是随着类加载的时候加载的，随着类的消亡而消亡。（一般程序退出类才消亡）

         2、实例变量是随着对象的创建而存在的，随着类垃圾器收集后而消失。

流程控制语句

   switch语句：

                            
                            //switch语句不建议用于区间范围的条件。用if（）{}else if{}
                            switch（条件）{
                            //条件只能是：char int short byte enum String  String是jdk7新加的。
                              如果用枚举那么case中只写枚举值就可以了
                            //case后面跟的必须是常量。case expressions must be constant expressions
                            //如果不写break，程序会从上往下执行直到遇到break语句就退出。
                            //default语句无论放在哪，都是先执行case语句，如果case都不符合条件，再最后执行default。
                                case ：
                                break;
                                  .
                                  .
                                 default:
                                 break;
                            }

             do-while循环：

                 while(false){

                             //编译报错（unreachable code:执行不到的代码）：因为这样写false是常量，java编译器检查到为 常量并且是false，代码永远不会被执行，所有编译报错。

                               System.out.println("xx");

                            }

                  //循环体至少被执行一次。先执行后判断

              do{

              

                   }while(布尔条件);

             for循环语句： 

                     

             int count=0;

             for(System.out.println("a");count<-1;System.out.println("c")){

                 System.out.println("b");

                       count++;

               }

            //结果：先执行a语句，再执行条件语句，符合条件执行循环体，再执行c语句。

             注意： 

                 for(;;)syso();一个语句可以这样写

             for 关键字后面括号中的三个表达式必须用 “;” 隔开，三个表达式都可以省略，但 “;” 不能省略。   

               “循环初始化”可以再外面定义，整个循环中只执行一次，省略“循环条件”会造成死循环。

 

            转义字符： 

                 \b:退格键

             \n:换行

             \t:tab建                      

             \r:回车：光标移动到开始

             \\:反斜杠

continue和break：

            break cannot be used outside of a loop or a switch

               break不能在loop或switch外面使用。

            continue cannot be used outside of a loop

               continue不能在loop外面使用。

            continue：跳过本次循环，执行下一轮循环

            break（默认跳出所作用的循环）：跳出整个循环。

          return：返回。结束当前方法直接返回。

函数

方法：

    所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块。方法是处理问题过程的一种抽象。

  语法：

    访问修饰符 返回值 方法名（形参列表）{

        方法体

     }    

java的参数传递方式分为：按值传递和按引用传递。

方法重载

    什么是方法的重载：

答：如果同一个类中包含了两个或两个以上方法名相同、方法参数的个数、顺序或类型不同的方法，则称为方法的重载

   重载的依据：

        1、在同一个类中。

        2、方法名相同。

        3、方法参数的个数、顺序或类型不同

        4、与方法的修饰符和返回值无关。       

          protected String method1(int b,int i){

            return null;

         }

          public void method1(int i,int b,int c){

           }

 

方法重写

重写是在继承关系下,父类方法无法满足子类需求,子类进行重写。  

  重写的依据：

        1、方法名、返回值、形参列表要和父类一致。其中返回值是其子类。

        2、子类抛出的异常要小于或等于父类的。(IOException)子类<=父类(Exception)

        3、子类的访问修饰符级别不能小于父类的。(public)子类>=父类(prote cted)

           父类 

        protected A a(){

    System.out.println("ss");

    return null;

  }  

子类

    public C a(){

        访问修饰符的权限要大于父类的。public>protected.

         返回值必须是父类或其子类。C是A的子类。

         子类抛出的异常要比父类的小。

    System.out.println("xx");

    return null;

    }

构造函数

用于对类的成员变量进行初始化。

    注意：函数名要和，类名一致并且没有返回值。可以被重载。

       构造函数不能手动调用，在new的时候由jvm自动调用的

    如果一个类中没有显示定义构造函数，则在编译时系统会提供一个缺省的无参的构造函数。

main方法的详解    

  为什么是public修饰：因为要保证在任何情况下jvm都能找到给方法。

    为什么是static修饰：可以不用对象就直接调用，因为jvm不知如何给其创建什么样的对象。

    为什么用main做函数名：因为main是jvm能识别得到的特殊标识符。

    args：参数，怕程序启动的时候需要参数。格式：java Demo aa bb cc

 

 

数组

什么是数组？   

             所谓数组，就是相同数据类型的元素按一定顺序排列的集合，就是把有限个类型相同的变量用一个名字命名，然后用       编号区分他们的变量的集合，这个名字称为数组名，编号称为下标。组成数组的各个变量称为数组的分量，也称为数       组的元素，有时也称为下标变量。数组是在程序设计中，为了处理方便， 把具有相同类型的若干变量按有序的形式组       织起来的一种形式。这些按序排列的同类数据元素的集合称为数组。

栈内存：

       在方法中定义的一些基本的变量或对象的引用变量都在方法的栈内存中分配。      

       java就在栈内存中为这个变量分配内存空间，当超出变量的作用域后，java会自动释放掉为该变量所分配的内存空间。

堆内存：

              由new创建的数组或对象。在堆中分配的内存，由jvm自动回收垃圾器管理。

               在堆中创建了一个数组或对象后，同时还在栈内存中定义一个特殊的变量。(引用变量)

         引用变量实际上保存的是数组或对象在堆内存中的地址（也称为对象的句柄），以后就可以在程序中使用栈的引用变量来访 问堆中的数组或对象。

                如：new String();在堆中分配内存后，还在栈中定义一个指向该对象的地址的变量。

 

数组的定义格式：      

            int arr[] = new int[长度];

               int arr[]  = {} ；

               int arr[] = new int[]{};

二维数组：

                    注意：在使用new创建多维数组的时候至少要给出最高维的大小。

                    int arr [][] = new int[这里一定要指最高维][];

Arrays类

                它封装了一组静态方法用于对数组进行排序、查找、复制、等操作。

           数组之间的复制可以使用：

          System.arraycopy(Object 源数组，int 源数组的起始位置，Object 目标数组，int 目标数组中的起始位置，int 源数组被复制的个数)

   

staticList

asList(T... a) 
          返回一个受指定数组支持的固定大小的列表。//将数组变成集合。

 

面向对象

     面向对象(Object Oriented,OO)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。

面向对象程序设计（英语：Object-oriented programming，缩写：OOP）是一种程序设计范型，同时也是一种程序开发的方法。对象指的是类的实例。 

类：

       类是具有相同属性或行为的一类集合,类是一种抽象的数据类型

对象：  对象是对客观事物的抽象，

 

类对象的关系

    类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。

    类是对象创建的模板。

访问修饰符：

     注意：

      修饰符的位置是可以调换的，如：

        

     public 公共的  可以在类以外访问。

    protected 受保护的 只能在同一个包中访问及其子类。

    package 缺省值  说明只能在同一个包中使用。

    private 私有的  只能在本类中使用。

              static  静态的 全局的  静态的方法内不能使用super关键字和this关键字。Cannot use super in a static context     

              public的成员组成了类的对外的接口。

    abstract public  class Test{//修饰符可以调换位置的。

    }

                final public static int i=9;

 

外部类只能使用了public修饰或者是默认。

       
匿名对象：

    没有引用指向的对象如：new Object（）。

 

构造函数：用于对类的成员变量进行初始化。

    注意：函数名要和，类名一致并且没有返回值（也不能写void）。可以被重载。

       构造函数不能手动调用，在new的时候由jvm自动调用的

        

    如果一个类中没有显示定义构造函数，则在编译时系统会提供一个与该类一样修饰符的构造函数。

 构造函数和其他函数的区别：

        构造函数只有在创建对象的时候才会被调用。

        构造函数是用来初始化一个对象的。普通函数是用于描述一个类事物的公共行为的。

                                面向对象的三大特征：封装、继承、多态。

构造代码块：优先于构造函数执行

               

                是给对象（无论什么对象）进行统一的初始化。

                构造函数则是给对应的对象初始化。

                代码块的类别：

                            1、构造代码块：在方法外定义。

                            2、局部代码块：在方法中定义，可以缩短局部变量的生命周期从而节省一点点内存。

                            3、静态代码块： static {} 类加载的时候就已经执行。

                成员变量和构造代码块是按照顺序执行的，总是在构造函数之前执行。   

    一个类文件是在要用的时候加载到内存的，而静态代码块是在类加载的时候执行的并且只执行一次。

this关键字：

                 代表了当前调用者对象

                 可以在一个构造函数中调用另一个构造函数。

                  注意：在一个构造函数中调用另一个构造函数时必须是第一个语句。            

static关键字：

    static函数中不能使用this及super关键字，因为静态的函数可以用类名直接调用。

 instanceof关键字：  判断一个对象是否是某个类别。格式：对象 instanceof 类别

                    注意：该关键字只能在继承或者实现关系下使用。如：狗继承动物，狗对象是狗类，猫继承动物，狗和猫  比报错。

                    一般用于多态，一般在做强制类型转换的时候，用其先前判断一下

final关键字：用final修饰变量值是不可修改的、修饰方法，该方法不可重写、修饰类，该类不可继承。

                      final修饰的引用不能再引用。如：final Demo d = new Demo(); d=new Demo()×

                        一般定义常量：public static final 标识符=值。

                                            ？用static ：因为每次创建对象就会维护一份，没必要。

抽象类

类是对象的抽象，抽象类是一类事物的抽象。

由abstract修饰的方法该方法是抽象方法，修饰类就是抽象类。

应用：

   我们在描述一类事物的时候，发现该种事物确实存在某种行为，但是这种行为目前不是具体的，我们可以抽取这种行为的声明 。        

如：动物有移动的行为，在描述动物这个类的时候，无法确定其移动的方式是怎么样的，因为狗用跑，而鱼则是摇尾巴。所    有无法去具体实现它，只能定义成抽象的方法强制其子类去重写该方 法。

注意：

      1、继承抽象类的子类必须要求其实现抽象类的抽象方法。

    2、出现抽象方法的类一定要是抽象类。

    3、抽象类不能创建对象。？因为抽象类中可能存在抽象方法。

   4、有构造函数。？其构造函数是给其子类创建对象的时候去初始化其属性的。

 abstract不能和private、static、final共同使用

接口

程序的解耦。

拓展功能。

复用性。

定义约束规范(如:一个网站的各个模块由不同人员开发，由于每个人的开发方式不同这时就要一种约束规范)。

注意：

        1、 接口是一种特殊的类。 

        2、接口中的变量默认是public static final 修饰的。常量

        3、接口中的函数默认是public abstract修饰的。抽象的

        4、接口不能被实例化。也没有构造函数。

        5、接口之间是可以多继承的，（但类不能：类单继承多实现。？）

        6、普通类实现接口的时候必须要实现接口里的所有方法。抽象类实现接口可以不是实现方法。

java中为什么是单继承多实现？如：类A中有print方法，类B也有print方法，类C继承A和B，由于A和B有相同的方法，    在使用的时候不知调用哪个，接口就不同，不管实现了多少个相同方法接口。只实现一个就可以。

 

面向对象三大特性

继承is-a关系：

    继承是从已有的类中派生出来的新类。这个新类拥有已有类的数据属性和行为。

    子类对象可以当成父类对象。而父类对象不能当成子类对象。如：轿车可以看成是交通工具，但不能把交通工具看成就是轿车

    在java中类不支持多继承，但是接口可以多继承。

    why：继承使软件的代码得到重用。软件的重用性不仅节省了程序的开发时间。

  方法的重写：

           如果子类中定义的某个方法与父类的某个方法相同方法署名（方法头）则称为重写。

            子类的对象调用这个方法时，将使用的是子类的方法（如果需要父类的方法可以用super关键字，super关键字不能在静  态的方法中使用）。    

  继承下的构造方法和finalize方法：

                        一组类之间可以通过多重继承，就形成类似一颗树的继承层次结构，继承层次下的构造方法是如何调用的呢？子类对象的实例化过程开始于一系列的的构造方法的调用。

                       默认情况下：

                                    子类的构造方法中隐式调用了父类的无参构造函数。                

                        构造方法的调用：

                                     在调用的请求中，最先调的构造方法总是根类Object的构造方法，最后才是各个子类的构造方法。

                        finalize方法在继承下的调用次序：与构造方法相反。先调用各个子类的finalize再调用Object的。

                            ？ 为什么在别的类中不能用其他类的引用调用finalize方法。

    继承中注意：

                    1、父类私有的成员不能继承。

                    2、父类的构造函数不能继承，创建子类对象的时候默认调用了父类的无参构造函数。

                    3、当父类没有无参构造函数时，在子类的构造函数中一定要显示地调用父类的构造函数。 

                  this和super不能同时调用构造函数。                        

封装： 

      （Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。

      好处：调用者不用关心其内部的具体的实现,提高代码重用性。 安全性：就是在赋值的时候判断值是否合理。

多态:

前提：要在继承或实现的关系下。父类的引用可以指向子类对象或者父类接口指向实现类的对象。

        动物  d  = new 狗();  狗 g = new 狗();//父类引用类型可以指向子类对象。

    注意：

       1、在父类和子类存在相同名字的成员变量(包括静态的)时，访问的是父类的成员变量。

             2、在父类和子类存在相同名字的成员函数时，访问的是子类的函数。静态相反。

             3、多态情况下，不能访问子类特有的成员。？编译看左边，运行不一定看右边。

                               java编译器在编译的时候，看该引用类型是否有指定的成员。  

        总结：多态情况下，访问的都是父类的成员，除了同名的非静态函数。

想像一下：子类一旦出现和父类相同的方法是，就是重写了，所以当然访问的是子类的

作用：1、在接受形参的时候可以接受更多的类型。如：写一个方法接受所有图形。

     2、在返回值的时候可以返回更多的类型。

接口中的多态：

      访问的函数永远都是实现类的。访问的同名变量永远都是接口的。

强制类型转换:                   

如果要访问子类特有的方法怎么办？

      Fu f = new Zi()；Zi z = (Zi)f；强转。 

内部类

内部类分

     成员内部类：在类的成员位置定义类。

         创建对象：Outer.Inner i = new Outer().new Inner();

         私有的成员内部类只能由外部类提供方法才能得到对象。

         成员内部类一旦出现static的成员，该内部类也要是静态的（常量除外。）

         Outer.Inner.成员;访问成员内部类的静态成员。

局部内部类：在一个类的方法中定义类。只能在方法中使用

          如果局部内部类访问局部变量，那么该变量必须要是最终的，final修饰。

             为什么？

因为：局部变量一旦出了作用域就从内存中消失，而局部内部类一旦创建就等垃圾器回收后才能消失。这时如果还用着   局部变量那么就不合理了，其实访问的是局部变量的复制品。所以用final修饰不能让别人修改。   

匿名内部类：内部类没有名字

前提：必须是继承或实现关系下使用。

    匿名内部类可以有自己特有的成员。在没有赋给父类的引用的时候，是可以访问子类的特有方法的，因为没有赋给父类     的时候一 直是子类对象。           

异常

Throwable :所有错误和异常的父类。

    error:由jvm或硬件引发的错误。一般不会通过代码去处理。

             是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码 运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（VirtualMachineError），当 JVM 不再有继续执 行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。

    exception:是程序本身可以处理的异常。

异常处理：在异常不处理时或抛出处理的时候后面的代码是不会执行的。

    如果出现异常不处理的时候后面的代码是不会执行的。

    1、捕获处理：

        try{}catch(异常的类别){}

        注意：

          try-catch块后面的代码依然执行。

         try后面可以跟多个catch块。

         多个catch的时候一定要从小到大。否则编译报错。 

    2、抛出处理：

        Throw：抛出  Throws：可能抛出的异常。

        注意：

          1、如果出现抛出处理，那么后面的代码不会执行。

          2、在方法中如果出现抛出编译时异常，那么该方法一定要声明抛出，会强制要求调用者处理。           

          4、在一种情况下只能抛出一个异常。

自定义异常：

     写一个普通类继承Exception即可。

运行时异常：

     RunTimeException及其下面的子类都是运行时异常。

     方法内部抛出一个运行时异常，那么该方法可以声明抛出也可不抛出，调用者也可处理或不处理。

编译时异常：除了运行时异常剩余的都是编译时异常。

     方法内部抛出一个编译时异常，那么该方法一定要声明抛出，并且调用者一定要处理。

     为什么要严格要求编译时异常？

        因为运行时异常可以通过代码去避免的。如：除0异常，可以通过代码判断避免。

      编译异常是不可避免的：如读文件异常，不能通过代码避免。

finall块：必须是try块中使用，无论什么情况下都执行finally中的代码，除了jvm退出的时候。

 

Java语法进阶

Java中常用的类

Object类

Java常用的类

object中常用的方法：

        toString();返回该对象的hashCode码（Test@431067af），String类重写了该方法。

        为什么println(o)和println(o.toString())结果一样？

        因为println方法内部都是调用了Object的toString方法。

        equal()：判断两个对象是否是同一个对象。默认比较的是内存地址。而String类的equal(重写了Object的equal)方法比较的是两个字符串的内容是否相等。==在比较引用的时候就是内存地址。

        hashCode()：返回对象的哈希码相当于对象的内存地址。

              一般重写equal方法的时候，都会重写hashCode方法。

protected  Object

clone() 
          创建并返回此对象的一个副本。

 boolean

equals(Object obj) 
          指示其他某个对象是否与此对象“相等”。

protected  void

finalize() 
          当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

 Class

getClass() 
          返回此 Object 的运行时类。

 int

hashCode() 
          返回该对象的哈希码值。//默认是内存地址

 void

notify() 
          唤醒在此对象监视器上等待的单个线程。

 void

notifyAll() 
          唤醒在此对象监视器上等待的所有线程。

 String

toString() 
          返回该对象的字符串表示。

 void

wait() 
          在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。

 void

wait(long timeout) 
          在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。

 void

wait(long timeout, int nanos) 
          在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导致当前线程等待。

 

String类

有个字符串常量池：位于方法区，在方法区还有一个字符串常量池。

    String str = "string";

      这种方式创建字符串的时候，jvm会在字符串常量池中找有没有该字符串存在，如果有：就不会在常量池                          中创建，直接返回该对象在常量池中的地址。否则：先创建在返回。   

    String str = new String("string");

     首先jvm先在常量池中找有没有该字符串存在。

        如果有：就在堆中创建该字符串对象再返回在堆内存中的地址赋给str变量。

       如果没有：就先在常量池中创建该字符串常量。再到堆内存中创建该字符串对象，然后把堆内存中的地址                 赋给str变量。

     String str1 = new String("string");

    String str2 = "string";该指令不会在常量池中再创建，因为new String("string")已经在常量池中创建                        了"string"字符串。

    equals();重写了Object的equals方法。比较了两个字符串的内容是否一致。

用byte[]创建字符串对象的时候，输出的的是byte数组元素对应码表中的值。

字符串是常量，一旦创建就不能修改了，如果修改了就是另外一个对象了。

StringBuffer类    

  public StringBuffer() {

        super(16);//StringBuffBuilderer的初始长度是16个字符。如果字符数组长度不够了，就会自动增长1倍。

    }  

 extends AbstractStringBuilder(int capacity) {

        value = new char[capacity];//StringBuffer的父类AbstractStringBuffer维护了一个字符数组。

    }

public final class StringBuffer

extends Object

implements Serializable, CharSequence

线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。

可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。

StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。

例如，如果 z 引用一个当前内容为 "start" 的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含 "startle"，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含 "starlet"。

通常，如果 sb 引用 StringBuilder 的一个实例，则 sb.append(x) 和 sb.insert(sb.length(), x) 具有相同的效果。

当发生与源序列有关的操作（如源序列中的追加或插入操作）时，该类只在执行此操作的字符串缓冲区上而不是在源上实现同步。

每个字符串缓冲区都有一定的容量。只要字符串缓冲区所包含的字符序列的长度没有超出此容量，就无需分配新的内部缓冲区数组。如果内部缓冲区溢出，则此容量自动增大。从 JDK 5 开始，为该类补充了一个单个线程使用的等价类，即StringBuilder。与该类相比，通常应该优先使用 StringBuilder 类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。

构造方法摘要

StringBuffer() 
          构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。

 

StringBuffer(CharSequence seq) 
          public java.lang.StringBuilder(CharSequence seq) 构造一个字符串缓冲区，它包含与指定的 CharSequence 相同的字符。

 

StringBuffer(int capacity) 
          构造一个不带字符，但具有指定初始容量的字符串缓冲区。

 

StringBuffer(String str) 
          构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

 

System类

extends Object

System 类包含一些有用的类字段和方法。它不能被实例化（内部私有化构造函数）。

在 System 类提供的设施中，有标准输入、标准输出和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。

字段摘要

static PrintStream

err 
          “标准”错误输出流。

static InputStream

in 
          “标准”输入流。

static PrintStream

out 
          “标准”输出流。

 

方法摘要

static void

arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
          从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。

static String

clearProperty(String key) 
          移除指定键指示的系统属性。

static Console

console() 
          返回与当前 Java 虚拟机关联的唯一 Console 对象（如果有）。

static long

currentTimeMillis() 
          返回以毫秒为单位的当前时间。

static void

exit(int status) 
          终止当前正在运行的 Java 虚拟机。

static void

gc() 
          运行垃圾回收器。（只能说是建议jvm马上启动）

static Map<String,String>

getenv() 
          返回一个不能修改的当前系统环境的字符串映射视图。（根据环境变量的名字获取环境变量）

static String

getenv(String name) 
          获取指定的环境变量值。

static Properties

getProperties() 
          确定当前的系统属性。

static String

getProperty(String key) 
          获取指定键指示的系统属性。

static String

getProperty(String key, String def) 
          获取用指定键描述的系统属性。

static SecurityManager

getSecurityManager() 
          获取系统安全接口。

static int

identityHashCode(Object x) 
          返回给定对象的哈希码，该代码与默认的方法 hashCode() 返回的代码一样，无论给定对象的类是否重写 hashCode()。

static Channel

inheritedChannel() 
          返回从创建此 Java 虚拟机的实体中继承的信道。

static void

load(String filename) 
          从作为动态库的本地文件系统中以指定的文件名加载代码文件。

static void

loadLibrary(String libname) 
          加载由 libname 参数指定的系统库。

static String

mapLibraryName(String libname) 
          将一个库名称映射到特定于平台的、表示本机库的字符串中。

static long

nanoTime() 
          返回最准确的可用系统计时器的当前值，以毫微秒为单位。

static void

runFinalization() 
          运行处于挂起终止状态的所有对象的终止方法。

static void

runFinalizersOnExit(boolean value) 
          已过时。 该方法具有固有的不安全性。它可能对正在使用的对象调用终结方法，而其他线程同时正在操作这些对象，从而导致不正确的行为或死锁。

static void

setErr(PrintStream err) 
          重新分配“标准”错误输出流。

static void

setIn(InputStream in) 
          重新分配“标准”输入流。

static void

setOut(PrintStream out) 
          重新分配“标准”输出流。

static void

setProperties(Properties props) 
          将系统属性设置为 Properties 参数。

static String

setProperty(String key, String value) 
          设置指定键指示的系统属性。

static void

setSecurityManager(SecurityManager s) 
          设置系统安全性。

 

RunTime类

代表了应用程序的运行环境

每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。

应用程序不能创建自己的 Runtime 类实例。

· 

getRuntime()

· 

方法摘要

 void

addShutdownHook(Thread hook) 
          注册新的虚拟机来关闭钩子。

 int

availableProcessors() 
          向 Java 虚拟机返回可用处理器的数目。

 Process

exec(String command) 
          在单独的进程中执行指定的字符串命令。（根据指定的命令执行对应的可执行文件）：返回一个进程对象。

 Process

exec(String[] cmdarray) 
          在单独的进程中执行指定命令和变量。

 Process

exec(String[] cmdarray, String[] envp) 
          在指定环境的独立进程中执行指定命令和变量。

 Process

exec(String[] cmdarray, String[] envp, File dir) 
          在指定环境和工作目录的独立进程中执行指定的命令和变量。

 Process

exec(String command, String[] envp) 
          在指定环境的单独进程中执行指定的字符串命令。

 Process

exec(String command, String[] envp, File dir) 
          在有指定环境和工作目录的独立进程中执行指定的字符串命令。

 void

exit(int status) 
          通过启动虚拟机的关闭序列，终止当前正在运行的 Java 虚拟机。

 long

freeMemory() 
          返回 Java 虚拟机中的空闲内存量。

 void

gc() 
          运行垃圾回收器。

 InputStream

getLocalizedInputStream(InputStream in) 
          已过时。 从 JDK 1.1 开始，将本地编码字节流转换为 Unicode 字符流的首选方法是使用 InputStreamReader 和 BufferedReader 类。

 OutputStream

getLocalizedOutputStream(OutputStream out) 
          已过时。 从 JDK 1.1 开始，将 Unicode 字符流转换为本地编码字节流的首选方法是使用 OutputStreamWriter、BufferedWriter 和 PrintWriter 类。

static Runtime

getRuntime() 
          返回与当前 Java 应用程序相关的运行时对象。

 void

halt(int status) 
          强行终止目前正在运行的 Java 虚拟机。

 void

load(String filename) 
          加载作为动态库的指定文件名。

 void

loadLibrary(String libname) 
          加载具有指定库名的动态库。

 long

maxMemory() 
          返回 Java 虚拟机试图使用的最大内存量。

 boolean

removeShutdownHook(Thread hook) 
          取消注册某个先前已注册的虚拟机关闭钩子。

 void

runFinalization() 
          运行挂起 finalization 的所有对象的终止方法。

static void

runFinalizersOnExit(boolean value) 
          已过时。 此方法本身具有不安全性。它可能对正在使用的对象调用终结方法，而其他线程正在操作这些对象，从而导致不正确的行为或死锁。

 long

totalMemory() 
          返回 Java 虚拟机中的内存总量。

 void

traceInstructions(boolean on) 
          启用／禁用指令跟踪。

 void

traceMethodCalls(boolean on) 
          启用／禁用方法调用跟踪。

 

Date类(已被Calendar类替代)

 

Math类

 

 

Properties类

HashTable的子类，属于集合体系。

因为 Properties 继承于 Hashtable，所以可对 Properties 对象应用 put 和 putAll 方法。但不建议使用这两个方法，因为它们允许调用者插入其键或值不是 String 的项。相反，应该使用 setProperty 方法。如果在“不安全”的Properties 对象（即包含非 String 的键或值）上调用 store 或 save 方法，则该调用将失败。类似地，如果在“不安全”的 Properties 对象（即包含非 String 的键）上调用 propertyNames 或 list 方法，则该调用将失败。 

 

 Object

setProperty(String key, String value) 
          调用 Hashtable 的方法 put。//建议用此方法设置属性。

//生成配置文件。

 void

store(OutputStream out, String comments) 
          以适合使用 load(InputStream) 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。//默认使用ios8859-1来编码的

 void

store(Writer writer, String comments) 
          以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符。//如果有中文用此方法。

//读取配置文件

 void

load(InputStream inStream) 
          从输入流中读取属性列表（键和元素对）。

 void

load(Reader reader) 
          按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。//如果有中文用此方法。

 

Java多线程

单核cpu在同一片时间段中只能执行一个应用程序。cpu在做快速地切换着执行。

进程

        进程是正在运行的程序的实例，是操作系统执行的基本单元，分配内存。

        三个基本状态：                        

        1）就绪状态（Ready）：

          进程已获得除处理器外的所需资源，等待分配处理器资源；只要分配了处理器进程就可执行。就绪进程可以按多个优先级来划分队列。例如，当一个进程由于时间片用完而进入就绪状态时，排入低优先级队列；当进程由I/O操作完成而 进入就绪状态时，排入高优先级队列。

        2）运行状态(Running)：

          进程占用处理器资源；处于此状态的进程的数目小于等于处理器的数目。在没有其他进程可以执行时(如所有进程都在阻塞状态)，通常会自动执行系统的空闲进程。

        3）阻塞状态(Blocked)：

          由于进程等待某种条件（如I/O操作或进程同步），在条件满足之前无法继续执行。该事件发生前即使把处理器资源分配 给该进程，也无法运行。

线程

       有时也称轻量级进程，是程序执行流的最小单元。

            线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备运行的所有条件，逻辑上可以运行，在等待处理机；运行状   态是指线程占有处理机正在运行；阻塞状态是指线程在等待一个事件（如某个信号量），逻辑上不可执行。每一个程序都至少     有一个线程(java应用程序至少有两个，主线程和gc线程)，若程序只有一个线程，那就是程序本身。

多线程：好：解决了一个进程中能执行多个任务。

              坏：增加了cpu的负担，降低了一个线程在cpu中的执行效率。

自定义线程：    

        继承Thread类重写run方法调用start方法开启线程。

创建线程对象---.start()----可运行状态------运行状态--.wait()或.sleep()---阻塞------消亡

    如果线程调用了wait方法进入阻塞状态，必须等待其他线程唤醒，才能进入可运行状态。object的方法。

      如果线程调用了sleep方法进入阻塞状态，那么等时间过了就能就让可运行状态。 

       线程常用的方法：

                                            

线程安全与同步机制

出现线程安全问题原因：

                                  1、存在2个或2个以上线程对象 

                                        2、线程之间存在着共享着一个资源。

                                        3、多条语句在操作着共享资源。

用同步机制解决线程安全问题：

                                一：同步代码块：锁对象必须是同一个对象，唯一共享的。

                                                         synchronized(锁对象object){ //只有在线程安全问题的时候才用同步代码块，

                                                                                                    否则会降低效率。

                                                                                                sleep();//调用了sleep方法也不会释放锁 

                                                                                             }

                                    二：同步函数：

                                                            非静态同步函数的锁是this对象

                                                             静态同步函数的锁是当前类的class对象。

                                                    public synchronized void test(){

                                                                                                                 

                                                                                                       }

死锁现象

 

实现Runnable接口的实现类是线程类吗？不是。只有Thread及其子类才是线程类，才能开启线程       

线程实现方式二：

                    实现Runnable接口：(只有一个run方法)

 

  推荐使用方式二： 因为java是单继承多实现。                           

多线程的通讯

一个线程完成任务后去通知另一个线程。

 

       wait()：调用了该方法，必须要等待其他线程唤醒。

        notify();唤醒以调用该方法的线程池中的一个线程。

          notifyAll();唤醒线程池中所有在等待的线程。   

     stop();(过时了)停止一个线程。

    要用interrupt();中断线程。把线程从临时阻塞状态拉回可运行状态，但是有受伤/异常。

     isDaemon();//判断是不是后台线程。

    setDaemon(true);//设置线程为后台线程，默认都不是后台线程。 

    join方法： 如果一个线程执行了该方法，就意味着有新的线程加入，那么该线程就必须等待新加入的线程执行完毕后才能继          续往下执行。打酱油例子  

    后台线程(守护线程)：如果一个进程只剩下后台线程，那么该线程也结束掉。

    注意：wait和notify

             1、这两个方法必须在同步代码块中或同步函数中使用。

             2、必须由锁对象调用。因为要创建以锁对象为标识的线程池，才能在同一个线程池中。

         3、是Object的方法。因为锁对象是任意的，所有放到Object中，而不放到Thread中。

如果锁调用了wait方法。那么jvm就会创建一个以锁为标识符的线程池。

Java中的集合

数组：数组是存储同一种数据类型的集合(Object除外)。

    一旦初始化长度就固定了。    

   数组中的元素与元素之间的内存地址是连续的。

  集合存储的都是对象类型的数据。如：list.add(1)在jdk1.5之前是不允许的。list.add(new Integer(1));

Collection接口

所有单例集合的根接口

方法摘要

 boolean

add(E e) 
          确保此 collection 包含指定的元素（可选操作）。

 boolean

addAll(Collection<? extends E> c) 
          将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。

 void

clear() 
          移除此 collection 中的所有元素（可选操作）。

 boolean

contains(Object o) 
          如果此 collection 包含指定的元素，则返回 true。

 boolean

containsAll(Collection c) 
          如果此 collection 包含指定 collection 中的所有元素，则返回 true。

 boolean

equals(Object o) 
          比较此 collection 与指定对象是否相等。

 int

hashCode() 
          返回此 collection 的哈希码值。

 boolean

isEmpty() 
          如果此 collection 不包含元素，则返回 true。

 Iterator<E>

iterator() 
          返回在此 collection 的元素上进行迭代的迭代器。

 boolean

remove(Object o) 
          从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。

 boolean

removeAll(Collection c) 
          移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。

 boolean

retainAll(Collection c) 
          仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。

 int

size() 
          返回此 collection 中的元素数。

 Object[]

toArray() 
          返回包含此 collection 中所有元素的数组。

T[]

toArray(T[] a) 
          返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

Collection：所有单例集合的根接口。

List接口

List接口和它特有的方法：该集合中的元素是有序有重复的。

 

添加： 

 void

add(int index, E element) 
          在列表的指定位置插入指定元素（可选操作）。 

 

 boolean

addAll(int index, Collection<? extends E> c) 
          将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。

获取：

 E

get(int index) 
          返回列表中指定位置的元素。

 

 int

indexOf(Object o) 
          返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。

 

 int

lastIndexOf(Object o) 
          返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。

 

 List<E>

subList(int fromIndex, int toIndex) 
          返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。

修改：

 E

set(int index, E element) 
          用指定元素替换列表中指定位置的元素（可选操作）。

迭代：注意：在迭代过程中允许用迭代器改变集合中的元素个数，

      但不能使用集合对象改变集合中元素个数(修改元素可以)

ListIterator<E>

listIterator(int index) 从列表迭代器返回的第一个元素的索引。 //迭代器的第一个索引元素  

ListIterator特有的方法：

void add(E e) 把当前元素插入到当前游标指定的位置。
boolean hasPrevious()  如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。//判断有没有上一个元素。  E previous()返回列表中的前一个元素。//获取上一个元素，游标先向上移再取出元素。而next()方法是先取出元素，游标再向                         下移动

void set(E e) 用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。//要在next或previous后使用。                  

      

List集合的三种遍历方式：

    

-----ArrayList：

查询快，增删慢

        内部使用了Object数组实现的。默认长度是10个，长度不够时自动增长0.5倍。

        查询快？因为数组元素与元素之间的内存地址是连续的

        增删慢？因为如果是在长度不够的时候要创建一个比之前长0.5倍的数组，再把旧数组中的元素复制到新数      组中。删除的时候要把空位填满

构造方法摘要

ArrayList() 
          构造一个初始容量为 10 的空列表。如果长度不够用自动增长多少？ 自动增长0.5倍

 

ArrayList(Collection<? extends E> c) 
          构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。

 

ArrayList(int initialCapacity) 
          构造一个具有指定初始容量的空列表。

 

特有方法：

 void

ensureCapacity(int minCapacity) 
          如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。

 

 void

trimToSize() 
          将此 ArrayList 实例的容量调整为列表的当前大小。//比如数组的长度是10，但只有3个元素，就把列表的长度为3

-----LinkedList：增删快，查询慢。   

 

 void

addFirst(E e) 
          将指定元素插入此列表的开头。

 void

addLast(E e) 
          将指定元素添加到此列表的结尾。

 

 Iterator<E>

descendingIterator() 
          返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。

 

 E

removeFirst() 
          移除并返回此列表的第一个元素。

 

 E

removeLast() 
          移除并返回此列表的最后一个元素。

数据结构

   栈：先进后出

 void

push(E e) 
          将元素推入此列表所表示的堆栈。//添加元素到首位置

 

 E

pop() 
          从此列表所表示的堆栈处弹出一个元素。//移除集合的首元素并返回。

  队列：先进先出

 boolean

offer(E e) 
          将指定元素添加到此列表的末尾（最后一个元素）。

 

 E

poll() 
          获取并移除此列表的头（第一个元素）

Vector：内部也是维护了Object数组的，和ArrayList的实现一样，但是它是同步的，线程安全的。

Vector和ArrayList的区别：

    相同：内部都是用Object数组实现的。

    不同点：

        1、ArrayList是线程不安全的，操作效率高，Vector是线程安全的，操作效率低。

        2、ArrayList是Jdk1.2出现的，而Vector是1.0出现的。 

Enumeration<E>

elements() 
          返回此向量的组件的枚举。//迭代器

Set接口

Set接口：该集合中的元素是无序无重复的。

HashSet

------HashSet：由哈希表支持，不能保证set的迭代顺序。

        原理：往HashSet中添加元素时，先调用元素的HashCode方法得到哈希值。再经过计算就能算出元素的存储位置。

        如果该位置目前没有元素存在，那么就存该元素。

        如果该位置有元素，那么就会调用元素的equals方法比较，如果相同就不允许添加。

    

TreeSet

------TreeSet：基于TreeMap的NavigableSet实现。使用元素的自然顺序排序。 

    注意：往TreeSet中添加元素时，如果元素没有自然顺序也没有指定比较器那么报错。 

原理：内部用红黑树(二叉树)结构实现的。规则是左小右大。

构造方法摘要

TreeSet() 
          构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。

 

TreeSet(Collection<? extends E> c) 
          构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。

 

TreeSet(Comparator<? super E> comparator) 
          构造一个新的空 TreeSet，它根据指定比较器进行排序。

 

TreeSet(SortedSet<E> s) 
          构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet。

 

注意：如果添加的元素没有自然顺序，元素所属的类也没有实现Comparable接口，那么就必须在创建TreeSet的时候            传入一个比较器(Comparator)。

Comparable：

方法摘要

 int

compareTo(T o) 
          比较此对象与指定对象的顺序。//返回：负整数、0、正整数，根据此对象是小于、等于还是大于指定的对象。

迭代器

方法摘要

 boolean

hasNext() 
          如果仍有元素可以迭代，则返回 true。

 E

next() 
          返回迭代的下一个元素。

 void

remove() 
          从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。就是移除最后一次next()返回的元素。

  

 

 

 

Map接口

注意：Map集合中的键是不可重复的，值可以重复。

    Map没有继承Iterable接口所以不能直接迭代，要利用单例集合的迭代器。

 V

put(K key, V value) 
               返回这个键以前关联的值。如果没有返回null。

 

 V

remove(Object key) 
             根据这个键删除map中一条数据，返回该键对应的值。

迭代：

 Set<K>

keySet() 
          返回此映射中所包含的键的 Set 视图。

 

Set<Map.Entry<K,V>>

entrySet() 
          返回此映射所包含的映射关系的 Set 视图。

 

 Collection<V>

values() 
          返回此映射所包含的值的 Collection 视图。 

 

HashMap

HashMap：存储元素的时候，用键的规则按哈希表存储，和HashSet一样。

构造方法摘要

HashMap() 
          构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。

 

HashMap(int initialCapacity) 
          构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。

 

HashMap(int initialCapacity, float loadFactor) 
          构造一个带指定初始容量和加载因子的空 HashMap。

 

HashMap(Map<? extends K,? extends V> m) 
          构造一个映射关系与指定 Map 相同的新 HashMap。

 

TreeMap

TreeMap：如果键具备自然顺序存储的时候也具备顺序。

构造方法摘要

TreeMap() 
          使用键的自然顺序构造一个新的、空的树映射。

 

TreeMap(Comparator<? super K> comparator) 
          构造一个新的、空的树映射，该映射根据给定比较器进行排序。//如果元素不具备自然顺序，要传入一个比较器或实现 Comparable接口。

 

TreeMap(Map<? extends K,? extends V> m) 
          构造一个与给定映射具有相同映射关系的新的树映射，该映射根据其键的自然顺序 进行排序。

 

TreeMap(SortedMap<K,? extends V> m) 
          构造一个与指定有序映射具有相同映射关系和相同排序顺序的新的树映射。

 

集合工具类：Collections

 1、对List进行二分查找

staticint

binarySearch(List<? extends Comparable> list, T key) 
          使用二分搜索法搜索指定列表，以获得指定对象。

staticint

binarySearch(List list, T key, Comparator c) 
          使用二分搜索法搜索指定列表，以获得指定对象。

 2、对List集合进行排序 

static<T extends Comparable> void

sort(List list) 
          根据元素的自然顺序 对指定列表按升序进行排序。

staticvoid

sort(List list, Comparator c) 
          根据指定比较器产生的顺序对指定列表进行排序。//如果元素不具备自然顺序，那么要传入一个比较器。

 3、查找集合中的最小值或最大值。

static<T extends Object & Comparable> T

max(Collection coll) 
          根据元素的自然顺序，返回给定 collection 的最大元素。

staticT

max(Collection coll, Comparator comp) 
          根据指定比较器产生的顺序，返回给定 collection 的最大元素。

static<T extends Object & Comparable> T

min(Collection coll) 
          根据元素的自然顺序 返回给定 collection 的最小元素。

staticT

min(Collection coll, Comparator comp) 
          根据指定比较器产生的顺序，返回给定 collection 的最小元素。

 4、对List集合进行反转  

static void

reverse(List list) 
          反转指定列表中元素的顺序。

staticComparator

reverseOrder() 
          返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。

 5、把不同步的集合变成同步的   

staticList

synchronizedList(List list) 
          返回指定列表支持的同步（线程安全的）列表。

static<k,v>Map<k,v>

synchronizedMap(Map<k,v> m) 
          返回由指定映射支持的同步（线程安全的）映射。

staticSet

synchronizedSet(Set s) 
          返回指定 set 支持的同步（线程安全的）set。

 

 

Java中IO流

File类

IO流InputStream和OuputStream

    主要解决设备与设备之间的数据传输，硬盘--内存，内存--硬盘

 可以描述一个文件件或文件

字段摘要： 

static String

separator 
          与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。

static char

separatorChar 
          与系统有关的默认名称分隔符。

 

构造方法摘要

File(File parent, String child) 
          根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。

 

File(String pathname) 
          通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

 

File(String parent, String child) 
          根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

 

File(URI uri) 
          通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。

 

目录分割符：

    linux(/)中和Windows(\或/)的目录分割符是不一样的。

 

绝对路径:"D:\\io\\test.txt"

相对路径："..\\..\\test.txt"，与程序所在的路径相对。

    注意：如果资源文件和程序不是在同一盘下面，是不能写相对路径的。

    .:表示当前路径

    ..:表示上一级路径

常用的方法：

创建

boolean

createNewFile() 
          当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。//如果已经存在就不创建。

 

 boolean

mkdir() 
          创建此抽象路径名指定的目录。//只能创建单级文件夹

 boolean

mkdirs() 
          创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。//创建多级文件夹

 

 boolean

renameTo(File dest) 
          重新命名此抽象路径名表示的文件。//如果dest和file不在同一个盘就是移动。不能在文件夹之间操作。只在根目录中操作文件。

删除

boolean

delete() 
          删除此抽象路径名表示的文件或目录。//注意：只能删除空的文件夹或文件。

 void

deleteOnExit() 
          在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。//jvm退出的时候删除文件或空文件夹，一般用来删除临时文件

判断

boolean

exists() 
          测试此抽象路径名表示的文件或目录是否存在。

 

 boolean

isAbsolute() 
          测试此抽象路径名是否为绝对路径名。

 boolean

isDirectory() 
          测试此抽象路径名表示的文件是否是一个目录。

 boolean

isFile() 
          测试此抽象路径名表示的文件是否是一个标准文件。

 boolean

isHidden() 
          测试此抽象路径名指定的文件是否是一个隐藏文件。

获取

 String

getName() 
          返回由此抽象路径名表示的文件或目录的名称。//不管存不存在，获取路径中的最后部分做为名称。

 

 String

getPath() 
          将此抽象路径名转换为一个路径名字符串。//根据创建文件对象时传入的路径

 

 String

getAbsolutePath() 
          返回此抽象路径名的绝对路径名字符串。

 

 long

length() 
          返回由此抽象路径名表示的文件的长度。//返回文件的字节大小，如果文件不存在返回0

 

 String

getParent() 
          返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。

 

 long

lastModified() 
          返回此抽象路径名表示的文件最后一次被修改的时间。//返回文件内容最后一次被修改的时间。

文件夹相关

static File[]

listRoots() 
          列出可用的文件系统根。//返回系统的盘

 

String[]

list() 
          返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。//返回该路径下的所有文件或文件夹(不包括子孙文件或)

 String[]

list(FilenameFilter filter) 
          返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。

 

 File[]

listFiles() 
          返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。//返回该路径下的文件或文件夹对象

 File[]

listFiles(FileFilter filter) 
          返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

 File[]

listFiles(FilenameFilter filter) 
          返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

例子：查找指定文件夹下的所有文件或文件夹。递归思想

 

 

 

 

 String

getAbsolutePath() 
          返回此抽象路径名的绝对路径名字符串。

IO流

注意：

1、凡是缓冲流都不具备读写能力,所有在创建缓冲流的时候要传入流。

2、如果想要提高读取效率可以用BufferedInputStream或自定义字节数组实现。

3、缓冲输出字节流写数据的时候是先写到字节数组中，当(close()/流关闭时会调用flush())或flush()一下或内部的字   节数组已满时才能真正写到文件中

4、字节流是不能写字符串的，要借助String的getBytes()方法把字符串转成字节再写。

5、什么时候使用字节流，什么时候使用字符流？

  字节流：读取图片等不需要转换成字符的时候使用字节流。

  字符流：读取字符数据的时候使用。

6、输出字符流内部维护了1kb的字符数组，缓冲输入输出流的内部都是维护了8kb的数组来提高效率。

7、转换流的好处是可以指定码表来读写数据。

字节流

输入字节流InputStream

---InputStream：该抽象类是所有输入字节流的超类。

---------FileInputStream:文件输入字节流

            用于读取诸如图像数据之类的原始字节流

read()：从流中读取一个字节数据，如果没有读到数据就返回-1。

 int

read() 
          从此输入流中读取一个数据字节。

 int

read(byte[] b) 
          从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。

 int

read(byte[] b, int off, int len) 
          从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。

    FileInputStream读取文件数据：

注意：new String(buf,0,length);因为读取是一次覆盖一次的，所以不用 new String(buf);

 

-------BufferedInputStream：缓冲输入字节流，内容是维护了8kb的字节数组。

构造方法摘要

BufferedInputStream(InputStream in) 
          创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

 

BufferedInputStream(InputStream in, int size) 
          创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

 

 

输出字节流OutputStream

----OutputStream：该抽象类是所有输出字节流的超类。

--------------FileOutputStream:文件输出字节流

   

 void

write(byte[] b) 
          将 b.length 个字节从指定 byte 数组写入此文件输出流中。

 void

write(byte[] b, int off, int len) 
          将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。

 void

write(int b) 
          将指定字节写入此文件输出流。//一次只能写一个字节数据

 图片的拷贝

 

---------------BufferedOutputStream：缓冲输出字节流，内部也是维护一个8kb字节数组

        注意：写数据的时候是先写到字节数组中，当close()(流关闭)或flush()一下时才能写到文件中。

字符流

 

字符流：其实是对二进制数据进行解码或编码。

输入字符流Reader

----------Reader：抽象类。所有输入字符流的基类。

-------------------FileReader：文件输入字符流。

构造方法摘要

FileReader(File file) 
          在给定从中读取数据的 File 的情况下创建一个新 FileReader。

 

FileReader(FileDescriptor fd) 
          在给定从中读取数据的 FileDescriptor 的情况下创建一个新 FileReader。

 

FileReader(String fileName) 
          在给定从中读取数据的文件名的情况下创建一个新 FileReader。 

 

-----------------BufferedReader：缓冲输入字符流。内部维护了一个8kb字符数组。拓展Reader的功能readLine()   

构造方法摘要

BufferedReader(Reader in) 
          创建一个使用默认大小输入缓冲区的缓冲字符输入流。

 

BufferedReader(Reader in, int sz) 
          创建一个使用指定大小输入缓冲区的缓冲字符输入流。

 

 

String

readLine() 
          读取一个文本行。//如果读完了就返回null，返回的值是不包含\r(13)\n(10)的

自己实现的readLine方法：

 

输出字符流Writer

----------Writer：该抽象类是所有输出字符流的基类。    

-----------------FileWriter：文件输出字符流

构造方法摘要

FileWriter(File file) 
          根据给定的 File 对象构造一个 FileWriter 对象。

 

FileWriter(File file, boolean append) 
          根据给定的 File 对象构造一个 FileWriter 对象。//如果文件已经有数据用该构造函数可以往其后面追加数据。

 

FileWriter(FileDescriptor fd) 
          构造与某个文件描述符相关联的 FileWriter 对象。

 

FileWriter(String fileName) 
          根据给定的文件名构造一个 FileWriter 对象。

 

FileWriter(String fileName, boolean append) 
          根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。

 

           注意：1、该类内部使用了1kb数组来提高写的效率，必须要等数组满了或close或flush才能真正                     把数据写到文件中。

            2、如果在写数据的时候要追加用FileWriter(file，true)构造函数。 

 

----------------BuffereWriter：缓冲输出字符流。内部维护了一个8kb的字符数组来缓冲的。

            拓展了newLine()换行，在有数据的时候换行再写。

 

 

 

 

其他流

SequenceInputStream序列流

SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。 

Enumeration：早期的迭代器，如Vertor的迭代。 

构造方法摘要

SequenceInputStream(Enumeration<? extends InputStream> e) 
          通过记住参数来初始化新创建的 SequenceInputStream，该参数必须是生成运行时类型为 InputStream 对象的 Enumeration 型参数。

 

SequenceInputStream(InputStream s1, InputStream s2) 
          通过记住这两个参数来初始化新创建的 SequenceInputStream（将按顺序读取这两个参数，先读取 s1，然后读取 s2），以提供从此 SequenceInputStream 读取的字节。

 

用SequenceInputStream合并多个文件

 

对象序列化和反序列化

ObjectInputStream：对象的输入流，把对象读到程序中也叫反序列化。

 

 

ObjectOutputStream：对象的输出流，把对象写到硬盘中也叫序列化。

 

构造方法摘要

protected

ObjectOutputStream() 
          为完全重新实现 ObjectOutputStream 的子类提供一种方法，让它不必分配仅由 ObjectOutputStream 的实现使用的私有数据。

 

ObjectOutputStream(OutputStream out) 
          创建写入指定 OutputStream 的 ObjectOutputStream。

对象的序列化：    

 

 

 注意：1、对象的输出必须要对象所在的类实现Serializable接口。

    2、serialVersionUID是用于记录对象的class文件的版本信息的，它是由类的包名，类名，成员等算出来的数        字，所有在序列化的时候要给个UID，不然在反序列化的时候如果类新加个属性，那么就报错，反序列化失        败。

    3、如果一个类中不想有成员被序列化到硬盘，那么可以用transient关键字。

 

 

PrintStream打印流

System.out就是一个PrintStream，默认就是向控制台输出信息的，可以使用setOut()指定在哪输出。

把数据转成字符串再打印。

收集异常的日志信息。

InputStreamReader：字节转字符的输入流。

OutputStreamWriter：字节转字符的输出流

 

Java网络编程

网页编程：要基于html的来，如：OA办公系统，一些网站。

网络编程：不需要html就能数据传输。如QQ。

计算机网络：

       计算机网络，是指将地理位置不同的具有独立功能的多台计算机及其他外部设备，通过通信线路连接起来，        在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

网络通信三要素：

    ip：网卡没有就没有IP地址

       子网掩码：将某个Ip地址划分成网络地址和主机地址两部分。

    分类：

        A类：一个网络号+三个主机号。2的24次方（政府）

        B类：两个网络号+两个主机号。2的16次方（学校或银行）

        C类：三个网络号+一个主机号。2的8次方（私人IP）

        java中使用InetAddress类来描述IP。

    端口号：

    协议：

       UDP：

          把数据封装成数据包发送，不需要建立链接。如：对讲机、说话、qq发消息。

         面向无链接，速度快，不可靠，有可能丢失数据包。

          大小有限制，64kb

       TCP：

         面向链接，通过三次握手机制，可靠协议。

        java中网络通讯也称Socket编程(套接，插座)。

 

注意：1、如果没有装网卡那么就没有IP地址。

InetAdress(IP类):  

static InetAddress

getLocalHost() 
          返回本地主机。

 

 String

getHostAddress() 
          返回 IP 地址字符串（以文本表现形式）。

根据名字获取其他主机的IP地址：

static InetAddress

getByName(String host) 
          在给定主机名的情况下确定主机的 IP 地址。

 

UDP下的通讯：不分服务和客户端，之分发送和接收。方式很类似码头货物传输。

DatagramSocket：UDP服务。

DatagramPacket：UDP数据包

udp协议发送数据：

  udp发送端：

    

 

udp接收端：

 

JavaWeb

Xml

html:标签是有w3c组织规定的,负责网页的结构

 

--xml:标签是由开发者按照xml语法定义的,描述带关系的数据

     作用:可做小型的数据库和配置文件。

    标签:

         <.student>或<.student><. student="">是空标签。

       xml需要xml解析器来来解析,浏览器已经内置了xml解析器。

       标签名严格区分大小写,不能用数字开头。名称中间不允许空格。

        一个xml文件有且仅有一个根标签。

       在记事本中写xml有中文浏览器解析乱码是记事本默认保存的编码是GBK。

      

    属性:和html不同属性值一定要以引号包含,不能单双混用。一个标签内不能出现重复属性。    

    注释:

         html或xml:(<.!-- --="">)//去掉=""

         css:(/.* 多行注释 */)

         js:(/.* 多行注释 */)、(/ 单行注释 /) 

         java:(/.* */)、(/ 单行注释 /)、(/.** 文档注释 */)

    文档声明:<.?xml version="1.0" encoding="utf-8">encoding:用什么编码去解析xml文件。

        在工具中写xml文件保存的时候会根据encoding的码表去编码保存。

    转义字符:在xml中有特殊的含义的字符需要原样输出。   

        <-<>-> "-" &-&

    CDATA块:一次转义多个特殊字符。<.![cdata[需要转义的字符]]>

    处理指令:告诉解析引擎如何去解析xml文档

        如:<.?xml-stylesheet type="text/css" href="1.css">告诉引擎使用了哪个css文件

          xml-stylesheet:提取xml文件的内容 href:css样式  

            

--XML的解析

方式一:DOM解析

        把xml的不同部分用一个个对象来描述,通过对象去操作xml。

        dom解析工具:JAXP(官方的)、JDOM(非官方)、Dom4J(非官方)

        三大框架默认读取xml的工具就是dom4j           

        Document:代表了整个xml文档,通过document对象得到其他节点对象

        dom解析原理:xml解析器一次性把整个xml加载到内存,在内存中创建文档树对象,通过文档树就可以得到树上的其他节点,通过节点对象就能操作xml文档的内容。 

              不适合读取大容量的xml文件     

              节点-Node:所有节点的抽象

                       标签节点-Element、属性节点-Attribute、文本节点-Text、注释-comment

        Dom4j工具:原理就是基于dom解析的一个流行的非官方工具(不在jdk中)    

                 注意:1、只有Element节点才有子节点。  

            读取xml文档:

                SAXReader reader = new SAXReder();

                 Document doc = reader.read(文件);              

 

        获取节点文本:

          

         按照文档格式拼接读取xml

        

        

            修改XML文档:

                XMLWriter writer = new XMLWriter(输出流,format/格式);

                format.setEncoding("编码");//生成和解析都是用该编码。

                Compact-紧凑的格式/Pretty-漂亮的格式

                DocumentHelper.createDocument();//创建一个文档对象。

 

XPath技术       

    XPath技术: 独立的一门语言,dom4j内置了该技术,快速的定位标签。

        导包:jaxen.jar

        类似文件系统。

       选择标签节点:

        /:开始表示根标签,中间表示子父关系,绝对路径去找。/aa/bb:根元素下的所有aa标签下所有bb标签。

        //://aa//bb:整个xml文档的所有aa标签下的所有bb标签。

        *:表示通配符。//*---所有元素

        [第几个.last()]:条件,可以配合使用。/aa/aa[1]---选择aa标签下的第一个aa元素。

       选择属性节点:

        [@id]--选择有id属性。   

        [not(@id)]--选择没有id属性            

        and : 表示与。

       选择文本:

        text()://name/text()--选择不分层次下name的文本。

        

方式二:SAX解析

        SAX解析工具:org.xml.sax(官方的)

        SAX解析原理:加载一点就解析一点。

        SAXParse:读取xml文档。

        SAXParser saxParser = SAXParserFactory.newInstance().newSAXParser();

            saxParse.parse(file,dh);

            file:xml文档

            dh:处理类

SAX解析和Dom解析区别:

    1.dom是一次性把xml文档加载到内存,用Document对象了描述。而SAX解析是加载一点就解析一点。

    2.dom解析是基于对象操作而SAX是基于事件。

    3.dom解析不仅可以解析xml文档还能操作xml文档,而SAX只能解析xml文档。

 

 

xml约束:

    语法有w3c组织定义,约束由开发者根据需求定义。

    dtd约束:       

                            <!DOCTYPE note [    
                              
                              
                              
                              
                              
                            ]>

    引入外部dtd:

        本地文件系统引入:在本机中

         

        公共的外部引入:在网络上

        

        dtd语法:

            约束标签:或

               类别:

                EMPTY:空标签,表示该元素必须是空元素。

                #PCDATA:普通字符串,表示该元素必须普通字符串(不能包含子标签)

                ANY:元素的内容可以是任何内容。

               标签出现次数:

                     默认一定要出现并且一定是一次。

                     +:至少出现一次。

                     *:零次或多次。

                     ？:零次或一次。

            约束属性:            

                              

                #REQUIRED:属性值是必需的

                #IMPLIED:属性不是必需的    
                     #FIXED value:属性值是固定的                                             类型:

                

CDATA

值为字符数据 (character data)

(en1|en2|..)

此值是枚举列表中的一个值

ID

值为唯一的 id:不能用数字开头。

           Schema约束:为了克服dtd的局限。 后缀名:.xsd      

                Schema对名称空间支持的非常好。            

               名称空间:告诉xml文档的哪个元素被哪个schema文档约束。  

                不同的标签可以有不同schema文档约束。

            targetNameSpace:定义名称空间

 

Tomcat

2016-11-17-

服务器:

    提供计算机服务的设备。

    根据服务器提供的服务不同,分:文件服务器,数据库服务器,web服务器等

web应用的目录

    项目:

       静态资源

       WEB-INF:

           classes、lib、web.xml

-tomcat:Apache旗下的web服务器软件。

        tomcat作用:共享本地资源给外部访问。

        常见问题:

            安装了点击startup.bat闪退？

                原因:tomcat是java开发的需要jvm,tomcat启动的时候会先到系统环境变量中JAVA_HOME变量找到对应的jdk的jvm,还会去找Catalina环境变量,去开启tomcat。

                解决:配置JAVA_HOME变量。

            如果配置了JAVA_HOME变量还是闪退,可能就是classpath变量冲突。

            修改tomcat的默认端口:

                    conf/server.xml在60行左右。port属性。

             CATALINA环境变量:不用配置。

                     设置tomcat的根目录固定的,启动时会加载该目录下tomcat。    

                     如果没有CATALINA变量就会在启动命令的tomcat目录。

Tomcat目录介绍     

  tomcat目录介绍:

                webapps:存放要共享给外部访问的资源。

                    注意:不能单独共享一个资源,要放到一个目录中。

                bin:存放的是可执行的命令

                conf:tomcat的配置目录,sever.xml是核心配置。

                work:tomcat的运行目录,jsp产生的临时文件都放这里。

             javaweb应用的根目录:web-inf

                    web-inf里面的内容不能直接由浏览器访问

                    web-inf/classes:存放的是程序的class文件

                    web-inf/lib:存放的是程序要用到的jar包。

                    web-inf/web.xml:web应用的配置文件

                注意:web-inf不能通过浏览器直接访问

                    

请求访问服务器过程

http://localhost:端口/目录/.. 首先在本机中找dns映射文件(hosts)去映射localhost对应的ip,如果本机中映射不到,就联网到网络运营商的dns服务器中找。进入到监听该端口的软件,再进入到目录..

静态资源和动态资源:

       用户多次访问的时候,源码有可能发生变化的就是动态资源。

       用户多次访问的时候,源码不会发生变量的就是静态资源。 

--tcp/ip协议:数据传输协议。

      关注的是数据是否传输成功。

--http协议:超文本传输协议,所有www文本都必须遵守这个标准。

      一次请求必须有一次响应。

      关注的是数据的传输格式。

https是web安全协议，是基于http协议，http是大众化非安全协议

 

 

http请求

    GET /test/servlet HTTP/1.1-------请求行

                  http的版本:

                    1.0:建立连接后,客户端只能发送一次请求连接就关闭。

                    1.1:建立连接后,可以多次发送请求。

    ---------请求头:

    Host: localhost:8080:当前访问的主机。

    Connection: keep-alive:浏览器跟服务器连接的状态,close关闭连接、keep-alive保存连接

    Cache-Control: max-age=0

    浏览器接受的数据类型。

    Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8

    Upgrade-Insecure-Requests: 1

     浏览器的类型--谷歌或IE...

    User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko)Chrome/49.0.2623.75 Safari/537.36

    Accept-Encoding: gzip, deflate, sdch:浏览器接受的数据压缩格式 

    Accept-Language: zh-CN,zh;q=0.8:浏览器接受的语言

    referer:当前的请求来自哪里。

     if-modify-Since:浏览器最后的缓存时间。

    cookie:浏览器缓存信息。

                     ------空行

    xxxxx                    ------实体内容,有参数的post提交才有实体内容。

图片的加载也是一次请求。相同图片由于浏览器帮我们优化了所以相同的资源只请求一次。

http响应       

        HTTP/1.1 200 OK                   --响应行

        Server: Apache-Coyote/1.1         --响应头（key-vaule）

        Content-Length: 24 

        Date: Fri, 30 Jan 2015 01:54:57 GMT

                                               --一个空行

        this is hello servlet!!!                  --实体内容

 

        响应行:http协议版本和状态码。

--常见的响应头:

Location: http://www.it315.org/index.jsp   -表示重定向的地址，该头和302的状态码一起使用。

Server:apache tomcat                 ---表示服务器的类型

Content-Encoding: gzip                 -- 表示服务器发送给浏览器的数据压缩类型

Content-Length: 80                    --表示服务器发送给浏览器的数据长度

Content-Language: zh-cn               --表示服务器支持的语言

Content-Type: text/html; charset=GB2312   --表示服务器发送给浏览器的数据类型及内容编码

Last-Modified: Tue, 11 Jul 2000 18:23:51 GMT  --表示服务器资源的最后修改时间

Refresh: 1;url=http://www.it315.org     --表示定时刷新

Content-Disposition:attachment; filename=aaa.zip --表示告诉浏览器以下载方式打开资源（下载文件时用到）

Transfer-Encoding: chunked

Set-Cookie:SS=Q0=5Lb_nQ; path=/search   --表示服务器发送给浏览器的cookie信息（会话管理用到）

Expires: -1                    --表示通知浏览器不进行缓存      

Cache-Control: no-cache         --表示通知浏览器不进行缓存

Pragma: no-cache            --表示通知浏览器不进行缓存

Connection: close/Keep-Alive      --表示服务器和浏览器的连接状态。close：关闭连接 keep-alive:保存连接

        

  

--url:统一资源定位符。只能定位互联网的内容,是uri的子集

--uri:统一资源标识符。用于标识任何资源文件。

常见的请求方式:get或post

    GET和POST提交表单的区别:

        1、get方式提交在地址栏中会加上参数,post则是在请求信息里面的实体内容中

        2、get方式提交数据大小不能超过1kb,post没有限制。

 

常见的状态码:

        200:请求处理完成并且完美返回。

        302:用户的请求路径需要进一步细化。

        404:表示访问的资源找不到。

        500:服务器内部错误。

Servlet

--servlet:java用于开发动态资源的技术。

    servlet特点:普通的java类,要继承HttpServlet。

        servlet类由web服务器软件调用的。        

       配置: tomcat加载的时候加载。 

        <.servlet>

        <.serlvet-name>servlet

        <.servlet-class>wei.servlet.ServletDemo

          <. servlet="">

          <.servlet-mapping>

        <.servlet-name>servlet

        <.url-pattern>/servlet---必须要以/开头。

          <. servlet-mapping="">

HttpServerRequest对象

    HttpServerRequest:用于获取请求的信息

        request.getInputStream();得到实体内容用输入流。post方式提交的参数。

        request.getprotocal();//获取请求的http版本。

        request.getQueryString();//获取get方式提交的参数。a=1&b=4

        request.getParameter(name);//获取表单的参数值,只能获取单个值,不能获取到复选框。

        request.getParameterValues(name);//获取同个参数名字的多个值。

        request.getParameterNames();//获取所有参数的名称。

 request.getRemoteHost();//获取用户的IP的地址。

 

编码问题

        可以在server.xml-60行左右,改变tomcat服务器的默认编码。加一句URIEncoding="utf-8";

        request.setCharacterEncoding("utf-8");//解决请求乱码问题,对get方式无效。

         //response.setCharacterEncoding("utf-8");//设置响应的编码是utf-8 

        response.setContentType("text/html;charset=utf-8");设置响应的编码和响应内容的类型。

HttpServerResponse

HttpServerResponse:用于修改响应信息。

请求重定向

  请求重定向:发送302状态码+location的响应头。和 sendRedirect("")一样            

注意:当浏览器遇到302状态码就会再次向服务器请求,请求的路径就是location。请求重定向向服务器发送了2次请求。

定时刷新或跳转指定页面:

           setHeader("refresh","秒");每隔几秒就刷新该页面。

           setHeader("refresh","秒;url="");隔几秒跳转到指定的页面。

        设置响应编码和实体内容类型:

         setContentType("text/html;charset=");表示响应的内容为html类型的text。和设置content-type头一样。 text/html在tomcat的web.xml里找。

 以下载的形式响应:

        设置Content-Disposition头。  

Servlet详解  

精确匹配:<url-pattern>/xxxx</url-pattern>

模糊匹配:<url-pattern>/*</url-pattern>

后缀模糊匹配:<url-pattern>*.do</url-pattern>

缺省路径/|/*

项目缺省路径的访问过程:

首先在项目的web.xml去找对应的servlet,如果找到就交给项目的servlet处理。

如果找不到就去tomcat的web.xml中找,然后交个DefaultServlet处理。

DefaultServlet主要是处理项目的静态资源的

注意:

如果匹配到多个url-pattern,那么精确匹配的优先级高。以*.后缀名结尾的优先级最低。

路径只能是*或/开头,不能同时使用两种模糊匹配。如:/abc/*.do，可以/abc/*。

不建议用缺省路径,因为找不到项目下的静态资源文件。而静态资源文件是交个tomcat的DefaultServlet处理

Servlet的生命周期

生命周期：构造函数--init(cof)--service()--destroy()

默认情况下用户第一次访问的时候就创建servlet对象,和执行init()方法。每次访问都会执行公共的service()方法

Service()中调用了doget或dopost方法。

servlet默认创建由于开始可能有很多逻辑也要初始化，所有就造成了用户访问响应慢。所以在服务器启动的时候就要 创建 servlet对象。如:

  <servlet>

    <servlet-name>LifeServlet</servlet-name>

    <servlet-class>wei.servlet.LifeDemo</servlet-class>

    <load-on-startup>1</load-on-startup>//数字越大优先级越低。

<!-- servlet初始化参数设置,可以有多个，servlet参数只能有当前servlet获取。 -->

<init-param>

<param-name></param-name>

<param-value></param-value>

</init-param>

  </servlet>

Init()和init(conf)

Init()是sun公司提供给开发者初始化servlet的方法。

Init(conf)是servlet生命周期方法。

Servlet的线程安全问题：

Servlet在tomcat中是单实例多线程。

service中多线程,如果多个线程访问了servlet中共享的成员变量就会出现线程安全问题。

尽量不要在servlet中使用成员变量,如要用记得加锁

ServletConfig对象

--servletConfig对象：代表了servlet的配置

根本是直接在init(conf)方法中得到。经过封装后在servlet中直接getServletConfig()即可。

getInitParameter(name);//获取指定名字的servlet初始化参数。

getInitParameterNames();//获取所有servlet的初始化参数名。

getServletContext();//获取上下文对象。

getServletName();//获取servlet名称。

ServletContext对象

--servletContext对象

 <!-- 每个servlet都可以获取到web应用的初始化参数。-->

<context-param>

<param-name></param-name>

<param-value></param-value>

</context-param>

getInitParameters();得到web应用的所有参数名

setAttribute(key,value);设置域中的值。

getAttribute(key);获取域中的值。

removeAttribute(key);移除域中的某个值

getRequestDispatcher(path);转发

getRealPath(path);得到web应用的资源文件

getResourceAsStream(path);

重定向和转发

转发:

This.getServletContext().getRequestDispatcher(“路径”).forward(request,response);

request.getRequestDispatchet();

/代表了WebRoot目录下(当前web应用路径)

重定向:(实际是服务器向浏览器发送一个302和路径所在的资源)

response.sendRedirect("路径");

/表在webappps目录下。

注意:跳转后面的代码仍然执行。

response.sendRedirect(this.getServletContext().getContextPath()+"/ContactServlet");

System.out.println("跳转了后面的代码还执行。");

转发和重定向区别:

转发不能转到web应用以外的资源。重定向可以跳转到web应用以外的资源。

转发在浏览器中的url不会发生变化,而重定向浏览器的url会变成重定向的地址。

加载web应用资源路径问题：

.代表java命令运行的目录。

在myeclipse中的java项目就是代表项目的根目录

在web中代表了tomcat的bin目录下,应为启动java命令就是在该目录下。

     this.getServletContext().getRealPath(“/”);表示当前应用的根目录。

域对象

域对象:用于保存数据获取数据,可以在不同的动态资源之间共享数据。

1、ServletContext---context ：整个web应用都能用

2、HttpServletRequest---request ：只能在转发中用

3、HttpSession-----session ：会话中使用。

Session域:保存会话数据的

4、PageContext-----page ：只能在该页面中使用

会话管理

Cookie

Web应用的会话:

一次会话:从打开浏览器到访问资源再到关闭浏览器就是一次会话。

会话管理:

管理浏览器和服务器之间会话过程产生的数据

cookie技术:会话的数据保存在浏览器端。

Cookie核心类

创建:Cookie(name,value);没有无参的构造函数。

Void setPath(String url);//设置cookie的有效访问路径，以后只能使用url访问才能发送cookie数据给服务器。

默认是当前web应用下,通常不必要设置。

Void setMaxAge(int expiry);//设置cookie的有效时间。秒为单位

正整数:保存到浏览器缓存的目录中(硬盘) ,数值表示保存的时间。从不调用时开始计算。

  负整数:保存到浏览器的内存中,没有时间限制的，浏览器关闭就消失。

0:删除同名的cookie数据。

Void setValue(newValue);//设置cookie的值

Response.setCookie(cookie);//发送Cookie到浏览器端保存

Request.getCookies();//接受浏览器发送的cookie

注意:

一个web站点可以给web浏览器发送多个cookie,一个web浏览器也可以存储多个站点提供的cookie

浏览器一般只允许存储300个cookie,一个站点最多接受20个,每个cookie的大小限制为4kb。

Web浏览器不能存储中文cookie，数据保存到浏览器中

HttpSession--session域     

创建session对象:

request.getSession();//返回匹配ID的HttpSession，没有匹配就重新创建。

request.getSession(boolean boo);//false：返回匹配ID的HttpSession，没有匹配返回null,ture和上面一样。

设置session对象

默认情况下30分钟被服务器销毁。

setMaxInactiveInterval(int interval);//设置session的有效时间、单位是秒

<!-- 全局设置session的有效时间  单位是分钟-->

<session-config>

<session-timeout>1<session-timeout>

<session-config>

 

Invalidate();//销毁session对象。

getId();//获取session的ID

保存会话数据到session域中

setAttribute(name,obj);//添加会话数据

getAttribute(name);//获取session域中的对象。

removeAttribute(name);//删除会话数据

session原理

为什么浏览器关闭后就不能使用session域中的数据？

request.getSession();

初次创建HttpSession对象 的时候,会给session分配一个ID叫JSESSIONID

把JSESSIONID做为cookie的名字ID作为cookie的值响应给浏览器保存。

当浏览器再次访问的时候会把名为JSESSIONID的cookie请求给服务器。

服务器就会获取名为JSESIONID的cookie并和服务器中ID值对比，如果一致就直接返回HttpSession对象。

如果不一致就重新创建一个新的Session对象返回。

总结:通过JSESSIONID的cookie来找对应的HttpSession对象。

JSP

概念:

和servlet一样,都是用来开发动态网页的一种技术。由服务器调用。

JSP--java服务器页面,其实就是一个简化的servlet,是javaweb里面一种动态网页技术标准。

在传统的html中插入java程序段和标记,形成以.jsp为后缀的文件。

特点：

Work目录存放的是jsp运行的临时文件

为什么jsp其实就是servlet？

因为jsp继承了HttpJspBase类,而HttpJspBase类又继承了HttpServlet类

Jsp运行过程:

首先找到jsp文件,然后在tomcat把jsp文件翻译成java文件和编译放在work目录中。

第一次访问翻译-编译-tomcat创建jsp对象调用方法-返回结果。

第n次访问直接返回结果。

Servlet的声明周期:

构造函数

Init()方法

公共的Service();

Destroy();

Jsp的生命周期:

翻译

编译

构造函数

_jspInit()

_jspService()

_jspDestroy();

Jsp语法

1、jsp模板

Jsp中的html代码就是jsp的模板

2、jsp的表达式

<%=变量或表达式 %> 编译成 out.print();作用：向浏览器输出变量的值或字符串或表达式的计算果。

  3、jsp的脚本

<% java代码 %> 原封不动翻译。如果是变量就翻译成局部变量。

脚本里的代码会原封不动翻译在_jspService()方法中。所以不能在脚本中定义方法

4、jsp的声明

<%! 变量或方法 %>用来声明jsp的变量或定义方法。

声明里面的代码会原封不动翻译在类的成员位置。不能定义同名的方法或变量

如果是变量就翻译成成员变量

如果是方法是原封不动的翻译。

5、jsp的注释

Jsp:<%-- --%> 在html中的注释会翻译到java源文件,而jsp的注释不会。

Html:<!-- -->

JavaScript://

Jsp的三大指令

1、include指令<%@include file=”路径”%>

作用:用于包含其他的页面

合并起来再翻译成一个源文件的就是静态包含(源码包含)

这种包含被包含的页面只写body的内容即可。

2、page指令

作用:告诉tomcat如何去翻译一个jsp文件。

在工具中文件的编码也是参考pageEncoding

                 

全局错误页面处理:

在web.xml中

<!-- 如果是500错误，就跳到指定的页面 单独的错误页面优先于全局错误页面  -->

<error-page>

<error-code>500</error-code>

<location>/页面<location>

<error-page>

 

 

     3、taglib指令：导入标签库

<@tagliburi=”tld文件的uri” prefix=”前缀”>

 

Jsp的9个内置对象

HttpServletRequest-----------------------------------request

HttpServletResponse---------------------------------response

ServletConfig-------------------------------------------config

ServletContext-----------------------------------------application

HttpSession---------------------------------------------session

JspWriter-------------------------------------------------out

writer的时候先把数据放到缓冲区，再交给PrintWriter直接输送到浏览器

可以在page指令中设置缓冲区大小或关闭

out.getRemaining();//查看当前缓冲区剩余的大小。

out.getBufferSize();//查看缓冲大小

Throwable------------------------------------------------exception

Object(this)----------------------------------------------page

PageContext---------------------------------------------pageContext

作用:Jsp的上下文对象可以获取其他的8个内置对象，是一个域对象 只能在当前页面使用

场景:在自定义标签的时候用到。

pageContext.setAttribute(“”,””);//将数据设置在pageContext域中

pageContext.setAttribute(“”,””,int scope);//将数据设置到指定的域中

在哪个域中存数据就在哪个域中取。

pageContext.findAttribute(“”);//先到page域--request域--session域--context域

 

EL表达式

EL表达式：由于在jsp中写表达式很繁琐,所有用El表达式来替换

Jsp的核心语法:jsp表达式<%= %>和jsp脚本

Jsp开发原则:尽量在jsp中尽量不要写java代码

用El表达式来替换jsp的表达式：向浏览器输出域中的变量值逻辑计算结果

语法:${变量或表达式};//只适用域中的变量或表达式。

${name};//翻译成pageContext.findAttribute(name);

指定域去获取数据

${request.Scope.name};//从request域中获取数据

输出对象的属性值

${放在域中的对象.name};//获取域对象的name属性值。

${Student.name}==pageContext.findAttribute(“student”).getName();

输出集合

List

EL没有遍历功能,要使用标签才可以

${list[0].name};//获取集合中第一个元素的name属性值。

List[0]==get(index)

Map

${map[‘key’]};//获取指定key的map元素

EL和jsp表达式的区别

都是向浏览器输出变量的值或表达式的结果

El只能输出域中的数据。

判空：${name==null || name==””}  等价  ${empty name} ---name可能是null或空字符串

Jsp中的标签

Jsp的标签：替换jsp中的java脚本  <%   %>

1、内置标签/动作标签:特点---不需要在jsp页面中导入标签库

<jsp:forward page=””>

<jsp:param value=”value” name=”name” />

<jsp:param value=”value” name=”name” />;//参数标签

<jsp:param value=”value” name=”name” />

</jsp:forward>;//转发标签

<jsp:include page=””></jsp:include>;//动态包含

静态包含是指令,动态包含是用标签,静态不能传参。

2、jstl标签:外置标签需要在jsp页面中导入标签库

标签就是封装了java代码

Jstl  java standard tag library  java标准标签库

2.1核心标签库(c标 签  )

导入:<%@ taglib uri="http://java.sun.com/jsp/jstl/core"  prefix="c"%>

                           

 

<!-- 构建一个url -->

   <c:url var="url" value="down_down">

   <c:param name="fileName" value="${fileName}"></c:param>

   </c:url>

2.2国际化标签库(fmt标签库)

2.3El函数库(fn函数库)

2.4Xml标签库(x标签库)

  2.5Sql标签库( sql标签库)

2.6如果是javaee5以后就不用导包。

自定义标签：背后还是java代码

1、编写一个普通的java类继承SimpleTagSupper,其间接实现了SimpleTag接口--标签处理器类

2、覆盖doGet();

3、在web-inf的目录下建立一个tld文件,

4、在jsp中引入tld文件关联标签处理器类。

自定义标签的执行过程:

首先在翻译的时候先找taglib的uri对应的tld文件,和标签的前缀

当执行到有标签前缀的标签的时候就到tld文件中找到该标签对应的处理类。

然后调用里面的处理方法。

自定义标签的生命周期:

      SimpleTag接口

setJspContext(JspContext pc);//设置PageContext对象,我们就可以通过getJspCotnext();得到PageContext对象

setParent(JspTag parent);//设置父标签,如果没有就不执行

setJspBody(JspFagment jspBody);//把标签体内容封装到JspFagment对象中,通过getJspBody();获得标签体内容。

  doTag();//执行到标签的时候调用。

自定义标签的作用:

1、可以控制标签体的内容是否输出jspFragment.invoke(out);向浏览器输出标签体内容==用jspBody.invoke(null)

2、控制标签余下的内容是否输出。Throw new SkipPageException();

3、控制循环输出

 

 

JDBC

JDBC(java数据库连接)

是一种用于发送sql语句的javaAPI,可以为多种关系型数据库提供统一访问。

必须:数据库驱动(Driver)、协议、用户名、密码

数据库驱动由数据库厂商提供。

    //方式一:

Driver driver = new com.mysql.jdbc.Driver();

String url="jdbc:mysql://localhost:3306/wei";//连接数据库的协议

String user = "root";

String password = "password";

Properties propes = new Properties();

//必须用user和password

propes.setProperty("user", user);

propes.setProperty("password", password);

Connection conn1 = driver.connect(url, propes);

System.out.println(conn1);

//方式二:com.mysql.jdbc.Driver类实现了java.sql.Driver接口,而mysql的驱动类的静态代码块已经注册了驱动。

Class.forName("com.mysql.jdbc.Driver");//通过加载数据库驱动类从而执行的类的静态代码块。

Connection conn2 = DriverManager.getConnection(url,user,password);

System.out.println(conn2);

Driver:new com.mysql.jdbc.Driver()[新版本]|org.gjt.mm.mysql.Driver()[旧版本];

协议:jdbc:mysql(子协议)://localhost:3306/要连接的数据库

Driver--Connection,DriverManager--Connection

Driver接口

Driver接口:java数据库连接驱动,所有数据库的厂商都要实现Driver接口。

方法:connection(url,propeties);

DriverManager接口

DriverManager类:用于管理所有的数据库驱动。

方法:registerDriver(driver);//注册驱动

getConnection(url,user,password):获取连接对象。

Connection接口

Connection接口:表示程序和数据库连接的对象。

方法:

createStatement();//得到Statement对象

Statement接口:用于执行静态sql语句并返回它生成的结果

int executeUpdate(String sql);//执行静态的更新sql语句。如:DDL,DML

ResultSet  executeQuery(String sql);//执行静态的查询sql语句。如:DQL

Statement有sql注入风险。

如:SELECT * FROM users WHERE NAME='eric' OR 1=1 --'and password='123';

所以建议用:PrepareStatement

prepareStatement(String sql);//得到PrepareStatement对象。

PrepareStatement接口:表示预编译的sql语句

executeUpdate(String sql);//执行预编译的的更新sql语句

executeQuery(String sql);//执行预编译的查询语句

prepareCall(String sql);//得到CallableStatement对象

CallableStatement接口:用于执行存储过程的sql。如:call xx;可以执行预编译sql

ResultSet executeQuery(String sql):用于执行存储过程sql语句的方法

registerOutParameter(int sqlType);//java.sql.Types.varchar;

stmt.getString(1);//参数是预编译sql的占位符

注意:CallableStatement继承PrepareStatament继承Statement

ResultSet接口:封装了查询语句的返回结果的数据集

next();//让光标下移

getXX();//获取列的值

数据库是如何执行sql语句的？

1、接收sql语句并检查语法

2、检查是否有该权限

3、把sql语句放到缓冲区中

缓存区:Map<sql,执行任务>

“select * from user where id=1”,”执行任务1”

“select * from user where id=2”,”执行任务2”

“select * from user where id=？”,”执行任务？”

但mysql不支持PrepareStatement这种优化，oracle、SQLServer等支持。

Statement和PrepareStatement的区别:

1、语法不同，PrepareStatement可以使用预编译的sql,而Statement只能使用静态的sql

2、效率不同，PrepareStatement可以使用数据库缓冲池,所以效率比Statement略高

3、安全性，PrepareStatement可以防止sql注入，而Statement不能。

void setAutoCommit(boolean auto);//设置自动提交事务

//默认是true,如果是false表示手动提交事务

void commit();//手动提交事务：慎在finally中提交

void rollback();//回滚

void roolback(SavePoint sp);

con.setSavePoint();//设置回滚点

SavePoint setSavePoint(String name);//

批处理:

addBatch(String sql);//添加批处理

int[] executeBatch();//执行批处理

clearBatch();//清空

事务编程:事务(Transaction)是访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。

事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。

原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。

一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。

隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。

持久性（durability）。持久性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。

 

BeanUtils组件:

@Test

public void testDemo1()throws Exception{

TestEntity tt = new TestEntity();

BeanUtils.setProperty(tt, "name","真实");//用beanutils设置对象的值。

}

@Test

public void testDemo2()throws Exception{

TestEntity tt = new TestEntity();

tt.setId(1);

tt.setName("李四");

TestEntity newEntity = new TestEntity();

//利用beanutils组件把tt的值赋给newEntity对象

BeanUtils.copyProperties(newEntity, tt);//(目标，源文件)

System.out.println(newEntity.getName());

}

@Test

public void testDemo3()throws Exception{

//用BeanUtils将map拷贝到对象中

TestEntity tt = new TestEntity();

Map<String,Object> map = new HashMap<String,Object>();

map.put("id", 1);

map.put("name","李四");

BeanUtils.populate(tt, map);

System.out.println(tt.getName());

}

@Test

public void testDemo4()throws Exception{

//BeanUtils组件的时间类型转换,ConvertUtils注册日期

TestEntity tt = new TestEntity();

// 注册日期类型转换器：1， 自定义的方式

ConvertUtils.register(new Converter() {

@Override

public Object convert(Class type, Object value) {

// 判断

if (type != Date.class) {

return null;

}

if (value == null || "".equals(value.toString().trim())) {

return null;

}

try {

// 字符串转换为日期

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

return sdf.parse(value.toString());

} catch (ParseException e) {

throw new RuntimeException(e);

}

}

},Date.class);

/**注册日期类型转换器：2， 使用组件提供的转换器工具类

ConvertUtils.register(new DateLocaleConverter(), Date.class);

*/

BeanUtils.copyProperty(tt,"date","1990-12-2");

System.out.println(tt.getDate());

}

元数据:对数据库或表或字段的描述，..MateData();想要优化代码元数据不可少

DBUtils

DBUtils:简化jdbc对数据库的操作

QueryRunner:组件的核心工具类，定义了所有的与数据库的操作方法

注意:如果调用了没有conn的方法必须在创建QueryRunner的时候传入DataSource

update

query(Connection conn, String sql, ResultSetHandler<T> rsh)

ResultSetHandler:自定义封装结果

 BeanHandler:返回第一条记录的对象

BeanListHandler:用list封装全部记录返回

ScalarHandler:返回第一行的第一列 通常和count(*)使用，因为count(*)返回的就是一行一列

ArrayHandler:把第一行记录的列封装到数组中返回

ArrayListHandler:把记录的列封装到数组中全部返回-----List<Object[]> list

java.sql.SQLException: Before start of result set Query: select * from users Parameters: []:指针没有下移就使用rs

 

 

 

 

 

Java中的设计模式

常见的设计模式:单例、模板、装饰者、观察者、工厂。

单例设计模式

单例设计模式：保证一个类在内存中只有一个对象。

    如：servlet就是单例的，因为如果每个用户访问的时候都创建一次servlet，内存很快就会        溢出，也没必要。

    饿汉：推荐使用。            

     步骤：

        1、私有构造函数。

        2、提供一个公共静态方法返回该类的实例。

       3、声明一个该类类型的引用指向其对象。

 

     懒汉：会存在线程安全问题。

         1、私有构造函数。

        2、提供一个静态方法返回该类对象。

        3、声明一个本类类型的引用变量但不创建。

 

 

模板设计模式

解决某事物的步骤是固定的，只有某些是变化的。

装饰者设计模式

概念：在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能，它是通过创建一个     包装对象，也就是装饰包裹真实的对象。

虽然用继承也可以增强一个类的功能，但如果功能很多的话就导致继承体系的非常大，那么用装饰者就可以缩小继承体系。

以下情况使用Decorator模式

1. 需要扩展一个类的功能，或给一个类添加附加职责。

2. 需要动态的给一个对象添加功能，这些功能可以再动态的撤销。

3. 需要增加由一些基本功能的排列组合而产生的非常大量的功能，从而使继承关系变的不现实。

4. 当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子   类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。

例子：儿子工作是画画，母亲的工作是涂画色，爸爸的工作是上画框。

装饰者例子

 

观察者设计模式

 

 

 

 

Java基础核心笔记

 

 

Javaweb核心笔记