下载文档第一篇：JAVAEE基础总结(showdy)
Java基础知识总结（超级经典）
写代码：
1，明确需求。我要做什么？ 2，分析思路。我要怎么做？1,2,3。
3，确定步骤。每一个思路部分用到哪些语句，方法，和对象。4，代码实现。用具体的java语言代码把思路体现出来。
学习新技术的四点： 1，该技术是什么？
2，该技术有什么特点(使用注意)： 3，该技术怎么使用。demo 4，该技术什么时候用？test。
--一：java概述：
1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器；
1994年将Oak语言更名为Java； DOS命令(掌握): DOS:磁盘操作系统。
DOS命令：是DOS操作系统的命令，是一种面向磁盘的操作命令，主要包括目录操作类命令、磁盘操作类命令、文件操作类命令和其它命令。
DOS命令行:运行Dos命令的窗口。
A:盘符切换： d: 回车
/ 105
B:cd命令
cd 目录 进入指定的单级目录
cd d:目录1目录2...进入指定的多级目录 cd..回退上一级目录
cd 回到当前所在盘符的根目录
C:cls 清屏
Exit 退出
Java的三种技术架构: JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发； JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础； JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序；
1，JDK：Java Development Kit，java的开发和运行环境，java的开发工具和jre。
2，JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。3，配置环境变量：让java jdkbin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。环境变量的配置：
1）：永久配置方式：JAVA_HOME=%安装路径%Javajdk path=%JAVA_HOME%bin 2）：临时配置方式：set path=%path%;C:Program FilesJavajdkbin 特点：系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。
classpath的配置: 1）：永久配置方式：classpath=.;c:;e:
2）：临时配置方式：set classpath=.;c:;e:
/ 105
注意：在定义classpath环境变量时，需要注意的情况
如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件； 如果指定了classpath，那么会在指定的目录下查找要运行的类文件。还会在当前目录找吗？两种情况：
4，javac命令和java命令做什么事情呢？
要知道java是分两部分的：一个是编译，一个是运行。
javac：负责的是编译的部分，当执行javac时，会启动java的编译器程序。对指定扩展名的.java文件进1）：如果classpath的值结尾处有分号，在具体路径中没有找到运行的类，会默认在当前目录再找一次。2）：如果classpath的值结果出没有分号，在具体的路径中没有找到运行的类，不会再当前目录找。一般不指定分号，如果没有在指定目录下找到要运行的类文件，就报错，这样可以调试程序。
行编译。生成了jvm可以识别的字节码文件。也就是class文件，也就是java的运行程序。
java：负责运行的部分.会启动jvm.加载运行时所需的类库,并对class文件进行执行.一个文件要被执行,必须要有一个执行的起始点,这个起始点就是main函数.运算符号：
1）、算术运算符。
+b;b = 3;a = a1;
if(max return-1; mid =(max+min)>>1;} / 105 return mid;}--------------------------java分了5片内存。 1：寄存器。2：本地方法区。3：方法区。4：栈。5：堆。 栈：存储的都是局部变量(函数中定义的变量，函数上的参数，语句中的变量)； 只要数据运算完成所在的区域结束，该数据就会被释放。 堆：用于存储数组和对象，也就是实体。啥是实体啊？就是用于封装多个数据的。 1：每一个实体都有内存首地址值。 2：堆内存中的变量都有默认初始化值。因为数据类型不同，值也不一样。3：垃圾回收机制。 -三：面向对象：★★★★★ 特点：1：将复杂的事情简单化。 2：面向对象将以前的过程中的执行者，变成了指挥者。3：面向对象这种思想是符合现在人们思考习惯的一种思想。 过程和对象在我们的程序中是如何体现的呢？过程其实就是函数；对象是将函数等一些内容进行了封装。 匿名对象使用场景： 1：当对方法只进行一次调用的时候，可以使用匿名对象。如：new Person().age = 17;//使用一次之后就被销毁了。 2：当对象对成员进行多次调用时，不能使用匿名对象。必须给对象起名字。 3.可作为实际参数进行传递；只在堆里面开辟存储区域, 如：method(new Person()); 在类中定义其实都称之为成员。成员有两种： 1：成员变量：其实对应的就是事物的属性。 / 105 2：成员函数：其实对应的就是事物的行为。 所以，其实定义类，就是在定义成员变量和成员函数。但是在定义前，必须先要对事物进行属性和行为的分析，才可以用代码来体现。 private int age;//私有的访问权限最低，只有在本类中的访问有效。注意：私有仅仅是封装的一种体现形式而已。 私有的成员：其他类不能直接创建对象访问，所以只有通过本类对外提供具体的访问方式来完成对私有的访问，可以通过对外提供函数的形式对其进行访问。 好处：可以在函数中加入逻辑判断等操作，对数据进行判断等操作。 总结：开发时，记住，属性是用于存储数据的，直接被访问，容易出现安全隐患，所以，类中的属性通常被私有化，并对外提供公共的访问方法。 这个方法一般有两个，规范写法：对于属性 xxx，可以使用setXXX(),getXXX()对其进行操作。 类中怎么没有定义主函数呢？ 注意：主函数的存在，仅为该类是否需要独立运行，如果不需要，主函数是不用定义的。主函数的解释：保证所在类的独立运行，是程序的入口，被jvm调用。 成员变量和局部变量的区别： 1：成员变量直接定义在类中。 局部变量定义在方法中，参数上，语句中。2：成员变量在这个类中有效。 局部变量只在自己所属的大括号内有效，大括号结束，局部变量失去作用域。3：成员变量存在于堆内存中，随着对象的产生而存在，消失而消失。局部变量存在于栈内存中，随着所属区域的运行而存在，结束而释放。 / 105 构造函数：用于给对象进行初始化，是给与之对应的对象进行初始化，它具有针对性，函数中的一种。特点： 1：该函数的名称和所在类的名称相同。2：不需要定义返回值类型。3：该函数没有具体的返回值。 记住：所有对象创建时，都需要初始化才可以使用。 注意事项：一个类在定义时，如果没有定义过构造函数，那么该类中会自动生成一个空参数的构造函数，为了方便该类创建对象，完成初始化。如果在类中自定义了构造函数，那么默认的构造函数就没有了。 一个类中，可以有多个构造函数，因为它们的函数名称都相同，所以只能通过参数列表来区分。所以，一个类中如果出现多个构造函数。它们的存在是以重载体现的。 构造函数和一般函数有什么区别呢？ 1：两个函数定义格式不同。 2：构造函数是在对象创建时，就被调用，用于初始化，而且初始化动作只执行一次。 一般函数，是对象创建后，需要调用才执行，可以被调用多次。 什么时候使用构造函数呢？ 分析事物时，发现具体事物一出现，就具备了一些特征，那就将这些特征定义到构造函数内。 构造代码块和构造函数有什么区别？ 构造代码块：是给所有的对象进行初始化，也就是说，所有的对象都会调用一个代码块。只要对象一建立。就会调用这个代码块。 构造函数：是给与之对应的对象进行初始化。它具有针对性。 / 105 Person p = new Person();创建一个对象都在内存中做了什么事情？ 1：先将硬盘上指定位置的Person.class文件加载进内存。 2：执行main方法时，在栈内存中开辟了main方法的空间(压栈-进栈)，然后在main方法的栈区分配了一个变量p。 3：在堆内存中开辟一个实体空间，分配了一个内存首地址值。new 4：在该实体空间中进行属性的空间分配，并进行了默认初始化。5：对空间中的属性进行显示初始化。6：进行实体的构造代码块初始化。 7：调用该实体对应的构造函数，进行构造函数初始化。（）8：将首地址赋值给p，p变量就引用了该实体。(指向了该对象)------------------------------封 装（面向对象特征之一）：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。 好处：将变化隔离；便于使用；提高重用性；安全性。 封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。 this:代表对象。就是所在函数所属对象的引用。 this到底代表什么呢？哪个对象调用了this所在的函数，this就代表哪个对象，就是哪个对象的引用。开发时，什么时候使用this呢？ 在定义功能时，如果该功能内部使用到了调用该功能的对象，这时就用this来表示这个对象。 this 还可以用于构造函数间的调用。调用格式：this(实际参数)； this对象后面跟上.调用的是成员属性和成员方法(一般方法)； this对象后面跟上()调用的是本类中的对应参数的构造函数。 / 105 注意：用this调用构造函数，必须定义在构造函数的第一行。因为构造函数是用于初始化的，所以初始化动作一定要执行。否则编译失败。 static：★★★ 关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。 特点： 1，想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。 2，被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。3，静态随着类的加载而加载。而且优先于对象存在。 弊端： 1，有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。2，静态方法只能访问静态成员，不可以访问非静态成员。 因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。3，静态方法中不能使用this，super关键字。 因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。4，主函数是静态的。 什么时候定义静态成员呢？或者说：定义成员时，到底需不需要被静态修饰呢？ 成员分两种： 1，成员变量。（数据共享时静态化）该成员变量的数据是否是所有对象都一样： 如果是，那么该变量需要被静态修饰，因为是共享的数据。如果不是，那么就说这是对象的特有数据，要存储到对象中。2，成员函数。（方法中没有调用特有数据时就定义成静态） / 105 如果判断成员函数是否需要被静态修饰呢？ 只要参考，该函数内是否访问了对象中的特有数据： 如果有访问特有数据，那方法不能被静态修饰。 如果没有访问过特有数据，那么这个方法需要被静态修饰。 成员变量和静态变量的区别： 1，成员变量所属于对象。所以也称为实例变量。静态变量所属于类。所以也称为类变量。2，成员变量存在于堆内存中。静态变量存在于方法区中。 3，成员变量随着对象创建而存在。随着对象被回收而消失。静态变量随着类的加载而存在。随着类的消失而消失。4，成员变量只能被对象所调用。 静态变量可以被对象调用，也可以被类名调用。 所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。 静态的注意：静态的生命周期很长。 静态代码块：就是一个有静态关键字标示的一个代码块区域。定义在类中。 作用：可以完成类的初始化。静态代码块随着类的加载而执行，而且只执行一次（new 多个对象就只执行一次）。如果和主函数在同一类中，优先于主函数执行。 Public：访问权限最大。 static：不需要对象，直接类名即可。void：主函数没有返回值。Main：主函数特定的名称。 / 105 (String[] args)：主函数的参数，是一个字符串数组类型的参数，jvm调用main方法时，传递的实际参数是 new String[0]。 jvm默认传递的是长度为0的字符串数组，我们在运行该类时，也可以指定具体的参数进行传递。可以在控制台，运行该类时，在后面加入参数。参数之间通过空格隔开。jvm会自动将这些字符串参数作为args数组中的元素，进行存储。 静态代码块、构造代码块、构造函数同时存在时的执行顺序：静态代码块 构造代码块 构造函数； 生成Java帮助文档：命令格式：javadoc –d 文件夹名 –auther –version *.java /** //格式 *类描述 *@author 作者名 *@version 版本号 */ /** *方法描述 *@param 参数描述 *@return 返回值描述 */ 设计模式：解决问题最行之有效的思想。是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 java中有23种设计模式： 单例设计模式：★★★★★ 解决的问题：保证一个类在内存中的对象唯一性。 比如：多程序读取一个配置文件时，建议配置文件封装成对象。会方便操作其中数据，又要保证多个程序读到的 17 / 105 是同一个配置文件对象，就需要该配置文件对象在内存中是唯一的。 Runtime()方法就是单例设计模式进行设计的。 如何保证对象唯一性呢？ 思想： 1，不让其他程序创建该类对象。2，在本类中创建一个本类对象。 3，对外提供方法，让其他程序获取这个对象。 步骤： 1，因为创建对象都需要构造函数初始化，只要将本类中的构造函数私有化，其他程序就无法再创建该类对象； 2，就在类中创建一个本类的对象； 3，定义一个方法，返回该对象，让其他程序可以通过方法就得到本类对象。（作用：可控） 代码体现： 1，私有化构造函数； 2，创建私有并静态的本类对象； 3，定义公有并静态的方法，返回该对象。--------------//饿汉式 class Single{ private Single(){} //私有化构造函数。 private static Single s = new Single();//创建私有并静态的本类对象。public static Single getInstance(){ //定义公有并静态的方法，返回该对象。 return s;} } / 105 --------------//懒汉式:延迟加载方式。 class Single2{ private Single2(){} private static Single2 s = null;public static Single2 getInstance(){ if(s==null) s = new Single2(); return s;} }----继 承（面向对象特征之一） 好处： 1：提高了代码的复用性。 2：让类与类之间产生了关系，提供了另一个特征多态的前提。 父类的由来：其实是由多个类不断向上抽取共性内容而来的。 java中对于继承，java只支持单继承。java虽然不直接支持多继承，但是保留了这种多继承机制，进行改良。 单继承：一个类只能有一个父类。多继承：一个类可以有多个父类。 为什么不支持多继承呢？ 因为当一个类同时继承两个父类时，两个父类中有相同的功能，那么子类对象调用该功能时，运行哪一个呢？因为父类中的方法中存在方法体。 但是java支持多重继承。A继承B B继承C C继承D。 多重继承的出现，就有了继承体系。体系中的顶层父类是通过不断向上抽取而来的。它里面定义的该体系最基本最共性内容的功能。 所以，一个体系要想被使用，直接查阅该系统中的父类的功能即可知道该体系的基本用法。那么想要使用一个体系时，需要建立对象。建议建立最子类对象，因为最子类不仅可以使用父类中的功能。还可以使用子类特有 / 105 的一些功能。 简单说：对于一个继承体系的使用，查阅顶层父类中的内容，创建最底层子类的对象。 子父类出现后，类中的成员都有了哪些特点： 1：成员变量。 当子父类中出现一样的属性时，子类类型的对象，调用该属性，值是子类的属性值。 如果想要调用父类中的属性值，需要使用一个关键字：super This：代表是本类类型的对象引用。 Super：代表是子类所属的父类中的内存空间引用。 注意：子父类中通常是不会出现同名成员变量的，因为父类中只要定义了，子类就不用在定义了，直接继承过来用就可以了。 2：成员函数。 当子父类中出现了一模一样的方法时，建立子类对象会运行子类中的方法。好像父类中的方法被覆盖掉一样。所以这种情况，是函数的另一个特性：覆盖(复写，重写)什么时候使用覆盖呢？当一个类的功能内容需要修改时，可以通过覆盖来实现。3：构造函数。 发现子类构造函数运行时，先运行了父类的构造函数。为什么呢? 原因：子类的所有构造函数中的第一行，其实都有一条隐身的语句super(); super(): 表示父类的构造函数，并会调用于参数相对应的父类中的构造函数。而super():是在调用父类中空参数的构造函数。 为什么子类对象初始化时，都需要调用父类中的函数？(为什么要在子类构造函数的第一行加入这个super()?)因为子类继承父类，会继承到父类中的数据，所以必须要看父类是如何对自己的数据进行初始化的。所以子类在进行对象初始化时，先调用父类的构造函数，这就是子类的实例化过程。 / 105 注意：子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super();如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。 如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。 问题：super()和this()是否可以同时出现的构造函数中。 两个语句只能有一个定义在第一行，所以只能出现其中一个。 super()或者this():为什么一定要定义在第一行？ 因为super()或者this()都是调用构造函数，构造函数用于初始化，所以初始化的动作要先完成。 继承的细节： 什么时候使用继承呢？ 当类与类之间存在着所属关系时，才具备了继承的前提。a是b中的一种。a继承b。狼是犬科中的一种。英文书中，所属关系：“ is a ” 注意：不要仅仅为了获取其他类中的已有成员进行继承。 所以判断所属关系，可以简单看，如果继承后，被继承的类中的功能，都可以被该子类所具备，那么继承成立。如果不是，不可以继承。 细节二： 在方法覆盖时，注意两点： 1：子类覆盖父类时，必须要保证，子类方法的权限必须大于等于父类方法权限可以实现继承。否则，编译失败。 / 105 2：覆盖时，要么都静态，要么都不静态。(静态只能覆盖静态，或者被静态覆盖) 继承的一个弊端：打破了封装性。对于一些类，或者类中功能，是需要被继承，或者复写的。这时如何解决问题呢？介绍一个关键字，final:最终。 final特点： 1：这个关键字是一个修饰符，可以修饰类，方法，变量。2：被final修饰的类是一个最终类，不可以被继承。3：被final修饰的方法是一个最终方法，不可以被覆盖。4：被final修饰的变量是一个常量，只能赋值一次。 其实这样的原因的就是给一些固定的数据起个阅读性较强的名称。 不加final修饰不是也可以使用吗？那么这个值是一个变量，是可以更改的。加了final，程序更为严谨。常量名称定义时，有规范，所有字母都大写，如果由多个单词组成，中间用 _ 连接。 抽象类: abstract 抽象：不具体，看不明白。抽象类表象体现。 在不断抽取过程中，将共性内容中的方法声明抽取，但是方法不一样，没有抽取，这时抽取到的方法，并不具体，需要被指定关键字abstract所标示，声明为抽象方法。 抽象方法所在类一定要标示为抽象类，也就是说该类需要被abstract关键字所修饰。 抽象类的特点： 1：抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。 2：抽象方法只定义方法声明，并不定义方法实现。3：抽象类不可以被创建对象(实例化)。 / 105 4：只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。 抽象类的细节： 1：抽象类中是否有构造函数？有，用于给子类对象进行初始化。2：抽象类中是否可以定义非抽象方法？ 可以。其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。 3：抽象关键字abstract和哪些不可以共存？final , private , static 4：抽象类中可不可以不定义抽象方法？可以。抽象方法目的仅仅为了不让该类创建对象。 --模板方法设计模式： 解决的问题：当功能内部一部分实现时确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。 abstract class GetTime{ public final void getTime(){ //此功能如果不需要复写，可加final限定 } public abstract void code();//抽象不确定的功能，让子类复写实现 long start = System.currentTimeMillis();code();//不确定的功能部分，提取出来，通过抽象方法实现 long end = System.currentTimeMillis();System.out.println(“毫秒是：”+(end-start));} class SubDemo extends GetTime{ public void code(){ //子类复写功能方法 for(int y=0;y<1000;y++){ System.out.println(“y”);} / 105 } } 接 口：★★★★★ 1：是用关键字interface定义的。 2：接口中包含的成员，最常见的有全局常量、抽象方法。 注意：接口中的成员都有固定的修饰符。 成员变量：public static final 成员方法：public abstract interface Inter{ public static final int x = 3;public abstract void show();} 3：接口中有抽象方法，说明接口不可以实例化。接口的子类必须实现了接口中所有的抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。 4：类与类之间存在着继承关系，类与接口中间存在的是实现关系。继承用extends ；实现用implements ； 5：接口和类不一样的地方，就是，接口可以被多实现，这就是多继承改良后的结果。java将多继承机制通过多现实来体现。 6：一个类在继承另一个类的同时，还可以实现多个接口。所以接口的出现避免了单继承的局限性。还可以将类进行功能的扩展。 7：其实java中是有多继承的。接口与接口之间存在着继承关系，接口可以多继承接口。 接口都用于设计上，设计上的特点：（可以理解主板上提供的接口） 1：接口是对外提供的规则。2：接口是功能的扩展。3：接口的出现降低了耦合性。 / 105 抽象类与接口： 抽象类：一般用于描述一个体系单元，将一组共性内容进行抽取，特点：可以在类中定义抽象内容让子类实现，可以定义非抽象内容让子类直接使用。它里面定义的都是一些体系中的基本内容。接口：一般用于定义对象的扩展功能，是在继承之外还需这个对象具备的一些功能。 抽象类和接口的共性：都是不断向上抽取的结果。 抽象类和接口的区别： 1：抽象类只能被继承，而且只能单继承。 接口需要被实现，而且可以多实现。 2：抽象类中可以定义非抽象方法，子类可以直接继承使用。 接口中都有抽象方法，需要子类去实现。3：抽象类使用的是 is a 关系。 接口使用的 like a 关系。4：抽象类的成员修饰符可以自定义。 接口中的成员修饰符是固定的。全都是public的。 在开发之前，先定义规则，A和B分别开发，A负责实现这个规则，B负责使用这个规则。至于A是如何对规则具体实现的，B是不需要知道的。这样这个接口的出现就降低了A和B直接耦合性。 ---多 态★★★★★（面向对象特征之一）：函数本身就具备多态性，某一种事物有不同的具体的体现。 体现：父类引用或者接口的引用指向了自己的子类对象。//Animal a = new Cat();多态的好处：提高了程序的扩展性。 多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性) / 105 多态的前提： 多态的出现思想上也做着变化：以前是创建对象并指挥对象做事情。有了多态以后，我们可以找到对象的共性类型，直接操作共性类型做事情即可，这样可以指挥一批对象做事情，即通过操作父类或接口实现。class 毕姥爷{ void 讲课(){ } void 钓鱼(){ System.out.println(“钓鱼”);System.out.println(“企业管理”);1：必须要有关系，比如继承、或者实现。2：通常会有覆盖操作。 } } class 毕老师 extends 毕姥爷{ void 讲课(){ System.out.println(“JAVA”);} void 看电影(){ System.out.println(“看电影”);} } class { public static void main(String[] args){ 毕姥爷 x = new 毕老师();//毕老师对象被提升为了毕姥爷类型。x.讲课();x.看电影();//错误.毕老师 y =(毕老师)x;//将毕姥爷类型强制转换成毕老师类型。 / 105 // // y.看电影();//在多态中，自始自终都是子类对象在做着类型的变化。 } }导入：类名称变长，写起来很麻烦。为了简化，使用了一个关键字：import，可以使用这个关键字导入指定包中的类。记住：实际开发时,到的哪个类就导入哪个类，不建议使用*.import packa.*;//这个仅仅是导入了packa当前目录下的所有的类。不包含子包。import packa.abc.*;//导入了packa包中的子包abc下的当前的所有类。 如果导入的两个包中存在着相同名称的类。这时如果用到该类，必须在代码中指定包名。 常见的软件包: java.lang : language java的核心包，Object System String Throwable jdk1.2版本后，该包中的类自动被导入。 java.awt : 定义的都是用于java图形界面开发的对象。 javax.swing: 提供所有的windows桌面应用程序包括的控件,比如：Frame , Dialog, Table, List 等等,就是java的图形界面库。 java.net : 用于java网络编程方面的对象都在该包中。 java.io : input output 用于操作设备上数据的对象都在该包中。比如：读取硬盘数据，往硬盘写入数据。java.util : java的工具包，时间对象，集合框架。 java.applet: application+let 客户端java小程序。server+let--> servlet 服务端java小程序。 jar ：java的压缩包，主要用于存储类文件，或者配置文件等。 命令格式：jar –cf 包名.jar 包目录 解压缩：jar –xvf 包名.jar / 105 将jar包目录列表重定向到一个文件中：jar –tf 包名.jar >c:1.txt--多线程：★★★★ 进程：正在进行中的程序。其实进程就是一个应用程序运行时的内存分配空间。 线程：其实就是进程中一个程序执行控制单元，一条执行路径。进程负责的是应用程序的空间的标示。线程负责的是应用程序的执行顺序。 一个进程至少有一个线程在运行，当一个进程中出现多个线程时，就称这个应用程序是多线程应用程序，每个线程在栈区中都有自己的执行空间，自己的方法区、自己的变量。 jvm在启动的时，首先有一个主线程，负责程序的执行，调用的是main函数。主线程执行的代码都在main方法中。 当产生垃圾时，收垃圾的动作，是不需要主线程来完成，因为这样，会出现主线程中的代码执行会停止，会去运行垃圾回收器代码，效率较低，所以由单独一个线程来负责垃圾回收。 随机性的原理：因为cpu的快速切换造成，哪个线程获取到了cpu的执行权，哪个线程就执行。 返回当前线程的名称：Thread.currentThread().getName()线程的名称是由：Thread-编号定义的。编号从0开始。线程要运行的代码都统一存放在了run方法中。 线程要运行必须要通过类中指定的方法开启。start方法。（启动后，就多了一条执行路径）start方法：1）、启动了线程；2）、让jvm调用了run方法。 创建线程的第一种方式：继承Thread，由子类复写run方法。步骤： 1，定义类继承Thread类； 2，目的是复写run方法，将要让线程运行的代码都存储到run方法中； / 105 3，通过创建Thread类的子类对象，创建线程对象； 4，调用线程的start方法，开启线程，并执行run方法。 线程状态： 被创建：start()运行：具备执行资格，同时具备执行权； 冻结：sleep(time),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格； 临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权； 消亡：stop() 创建线程的第二种方式：实现一个接口Runnable。步骤： 1，定义类实现Runnable接口。 2，覆盖接口中的run方法（用于封装线程要运行的代码）。3，通过Thread类创建线程对象； 4，将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。为什么要传递呢？因为要让线程对象明确要运行的run方法所属的对象。 5，调用Thread对象的start方法。开启线程，并运行Runnable接口子类中的run方法。 / 105 Ticket t = new Ticket();/* 直接创建Ticket对象，并不是创建线程对象。 因为创建对象只能通过new Thread类，或者new Thread类的子类才可以。所以最终想要创建线程。既然没有了Thread类的子类，就只能用Thread类。*/ Thread t1 = new Thread(t);//创建线程。/* 只要将t作为Thread类的构造函数的实际参数传入即可完成线程对象和t之间的关联 为什么要将t传给Thread类的构造函数呢？其实就是为了明确线程要运行的代码run方法。*/ t1.start(); 为什么要有Runnable接口的出现？ 1：通过继承Thread类的方式，可以完成多线程的建立。但是这种方式有一个局限性，如果一个类已经有了自己的父类，就不可以继承Thread类，因为java单继承的局限性。 可是该类中的还有部分代码需要被多个线程同时执行。这时怎么办呢？ 只有对该类进行额外的功能扩展，java就提供了一个接口Runnable。这个接口中定义了run方法，其实run方法的定义就是为了存储多线程要运行的代码。 所以，通常创建线程都用第二种方式。 因为实现Runnable接口可以避免单继承的局限性。 2：其实是将不同类中需要被多线程执行的代码进行抽取。将多线程要运行的代码的位置单独定义到接口中。为其他类进行功能扩展提供了前提。 所以Thread类在描述线程时，内部定义的run方法，也来自于Runnable接口。 实现Runnable接口可以避免单继承的局限性。而且，继承Thread，是可以对Thread类中的方法，进行子类复写的。但是不需要做这个复写动作的话，只为定义线程代码存放位置，实现Runnable接口更方便一些。所 / 105 以Runnable接口将线程要执行的任务封装成了对象。------------------------//面试 new Thread(new Runnable(){ //匿名 }){ public void run(){ System.out.println(“runnable run”);} public void run(){ System.out.println(“subthread run”);} }.start();//结果：subthread run --------------------------Try { Thread.sleep(10);}catch(InterruptedException e){}// 当刻意让线程稍微停一下，模拟cpu 切换情况。 多线程安全问题的原因： 通过图解：发现一个线程在执行多条语句时，并运算同一个数据时，在执行过程中，其他线程参与进来，并操作了这个数据。导致到了错误数据的产生。 涉及到两个因素： 1，多个线程在操作共享数据。2，有多条语句对共享数据进行运算。 原因：这多条语句，在某一个时刻被一个线程执行时，还没有执行完，就被其他线程执行了。 解决安全问题的原理： 只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行就可以解决这个问题。 如何进行多句操作共享数据代码的封装呢？ / 105 java中提供了一个解决方式：就是同步代码块。 格式： synchronized(对象){ // 任意对象都可以。这个对象就是锁。需要被同步的代码； }-同步：★★★★★ 好处：解决了线程安全问题。 弊端：相对降低性能，因为判断锁需要消耗资源，产生了死锁。 定义同步是有前提的： 1，必须要有两个或者两个以上的线程，才需要同步。2，多个线程必须保证使用的是同一个锁。 同步的第二种表现形式： 同步函数：其实就是将同步关键字定义在函数上，让函数具备了同步性。 同步函数是用的哪个锁呢？ 通过验证，函数都有自己所属的对象this，所以同步函数所使用的锁就是this锁。 当同步函数被static修饰时，这时的同步用的是哪个锁呢？ 静态函数在加载时所属于类，这时有可能还没有该类产生的对象，但是该类的字节码文件加载进内存就已经被封装成了对象，这个对象就是该类的字节码文件对象。 所以静态加载时，只有一个对象存在，那么静态同步函数就使用的这个对象。这个对象就是 类名.class 同步代码块和同步函数的区别？ / 105 同步代码块使用的锁可以是任意对象。 同步函数使用的锁是this，静态同步函数的锁是该类的字节码文件对象。 在一个类中只有一个同步，可以使用同步函数。如果有多同步，必须使用同步代码块，来确定不同的锁。所以同步代码块相对灵活一些。 ------------------------★考点问题：请写一个延迟加载的单例模式？写懒汉式；当出现多线程访问时怎么解决？加同步，解决安全问题；效率高吗？不高；怎样解决？通过双重判断的形式解决。 //懒汉式：延迟加载方式。 当多线程访问懒汉式时，因为懒汉式的方法内对共性数据进行多条语句的操作。所以容易出现线程安全问题。为了解决，加入同步机制，解决安全问题。但是却带来了效率降低。 为了效率问题，通过双重判断的形式解决。class Single{ private static Single s = null;private Single(){} public static Single getInstance(){ //锁是谁？字节码文件对象； if(s == null){ synchronized(Single.class){ if(s == null) s = new Single(); } } return s;} }--------------------------同步死锁：通常只要将同步进行嵌套，就可以看到现象。同步函数中有同步代码块，同步代码块中还有同步函数。 线程间通信：思路：多个线程在操作同一个资源，但是操作的动作却不一样。1：将资源封装成对象。 2：将线程执行的任务(任务其实就是run方法。)也封装成对象。 / 105 等待唤醒机制：涉及的方法： wait:将同步中的线程处于冻结状态。释放了执行权，释放了资格。同时将线程对象存储到线程池中。notify：唤醒线程池中某一个等待线程。notifyAll:唤醒的是线程池中的所有线程。 注意： 1：这些方法都需要定义在同步中。2：因为这些方法必须要标示所属的锁。你要知道 A锁上的线程被wait了,那这个线程就相当于处于A锁的线程池中，只能A锁的notify唤醒。3：这三个方法都定义在Object类中。为什么操作线程的方法定义在Object类中？ 因为这三个方法都需要定义同步内，并标示所属的同步锁，既然被锁调用，而锁又可以是任意对象，那么能被任意对象调用的方法一定定义在Object类中。 wait和sleep区别： 分析这两个方法：从执行权和锁上来分析： wait：可以指定时间也可以不指定时间。不指定时间，只能由对应的notify或者notifyAll来唤醒。sleep：必须指定时间，时间到自动从冻结状态转成运行状态(临时阻塞状态)。wait：线程会释放执行权，而且线程会释放锁。Sleep：线程会释放执行权，但不是不释放锁。 线程的停止：通过stop方法就可以停止线程。但是这个方式过时了。 停止线程：原理就是：让线程运行的代码结束，也就是结束run方法。怎么结束run方法？一般run方法里肯定定义循环。所以只要结束循环即可。第一种方式：定义循环的结束标记。 第二种方式：如果线程处于了冻结状态，是不可能读到标记的，这时就需要通过Thread类中的interrupt方法，将其冻结状态强制清除。让线程恢复具备执行资格的状态，让线程可以读到标记，并结束。 / 105 ---------< java.lang.Thread >----------interrupt()：中断线程。 setPriority(int newPriority)：更改线程的优先级。getPriority()：返回线程的优先级。 toString()：返回该线程的字符串表示形式，包括线程名称、优先级和线程组。Thread.yield()：暂停当前正在执行的线程对象，并执行其他线程。 setDaemon(true)：将该线程标记为守护线程或用户线程。将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。join：临时加入一个线程的时候可以使用join方法。 当A线程执行到了B线程的join方式。A线程处于冻结状态，释放了执行权，B开始执行。A什么时候执行呢？只有当B线程运行结束后，A才从冻结状态恢复运行状态执行。----------------------------Lock接口：多线程在JDK1.5版本升级时，推出一个接口Lock接口。 解决线程安全问题使用同步的形式，(同步代码块，要么同步函数)其实最终使用的都是锁机制。 到了后期版本，直接将锁封装成了对象。线程进入同步就是具备了锁，执行完，离开同步，就是释放了锁。在后期对锁的分析过程中，发现，获取锁，或者释放锁的动作应该是锁这个事物更清楚。所以将这些动作定义在了锁当中，并把锁定义成对象。 所以同步是隐示的锁操作，而Lock对象是显示的锁操作，它的出现就替代了同步。 在之前的版本中使用Object类中wait、notify、notifyAll的方式来完成的。那是因为同步中的锁是任意对象，所以操作锁的等待唤醒的方法都定义在Object类中。 而现在锁是指定对象Lock。所以查找等待唤醒机制方式需要通过Lock接口来完成。而Lock接口中并没有直接操作等待唤醒的方法，而是将这些方式又单独封装到了一个对象中。这个对象就是Condition，将Object中的 48 / 105 三个方法进行单独的封装。并提供了功能一致的方法 await()、signal()、signalAll()体现新版本对象的好处。 < java.util.concurrent.locks > Condition接口：await()、signal()、signalAll()； -------------------------class BoundedBuffer { final Lock lock = new ReentrantLock(); final Condition notFull = lock.newCondition();final Condition notEmpty = lock.newCondition();final Object[] items = new Object[100];int putptr, takeptr, count;public void put(Object x)throws InterruptedException { lock.lock();try { while(count == items.length)notFull.await();items[putptr] = x;if(++putptr == items.length)putptr = 0;++count;notEmpty.signal(); } finally { lock.unlock();} } public Object take()throws InterruptedException { lock.lock();try { while(count == 0)notEmpty.await(); Object x = items[takeptr];if(++takeptr == items.length)takeptr = 0;--count;notFull.signal();return x;} finally { lock.unlock();} } }---API：（Application Programming Interface,应用程序编程接口）是一些预先定义的函数，目的是提供应用程序与开发人员基于某软件或硬件的以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。 / 105 --< java.lang >--String字符串：★★★☆ java中用String类进行描述。对字符串进行了对象的封装。这样的好处是可以对字符串这种常见数据进行方便的操作。对象封装后，可以定义N多属性和行为。 如何定义字符串对象呢？String s = “abc”;只要是双引号引起的数据都是字符串对象。 特点：字符串一旦被初始化，就不可以被改变，存放在方法区中的常量池中。-----------------------String s1 = “abc”;// s1指向的内存中只有一个对象abc。 String s2 = new String(“abc”);// s2指向的内容中有两个对象abc、new。 System.out.println(s1==s2);//false System.out.println(s1.equals(s2));//true，字符串中equals比较的是字符串内容是否相同。------------------------字符串的方法： 1：构造方法：将字节数组或者字符数组转成字符串。 String s1 = new String();//创建了一个空内容的字符串。String s2 = null;//s2没有任何对象指向，是一个null常量值。 String s3 = “";//s3指向一个具体的字符串对象，只不过这个字符串中没有内容。//一般在定义字符串时，不用new。String s4 = new String(”abc“);String s5 = ”abc";一般用此写法 new String(char[]);//将字符数组转成字符串。 new String(char[],offset,count);//将字符数组中的一部分转成字符串。 2：一般方法： 按照面向对象的思想： / 105 JavaEE学习方法总结 学习JavaEE已经有一段时间了，自以为对JavaEE也是有一点认识和理解的。如果有菜鸟也想学习JavaEE的话，那么，下面推荐一下我的学习步骤（仅代表我个人）: 一、掌握Java的基本语法 如Logic Java、Java OOP等，精通面向对象的思想：封装、继承和多态，以及后面学的接口。其中封装和继承稍微简单一点，多态比较难一点；但能不能理解好多态，又是能不能理解面向对象思想的重要一步；而接口，学习起来并不难，难就难在如何运用好,在这里，教大家一个理解接口的简单方法：接口其实就是一种规范。 二、系统的学习一下数据库 数据库中的内容比较多，像数据库中的五大范式、数据仓库、数据挖掘等这些很专业的知识，我们没必要掌握；而数据库中的SQL语句则是一定要精通的，这对以后的学习很有帮助。对于有些常会出错的，一定要注意，比如Select语句中where后面多个条件的连接用的是and而不是逗号；Insert语句中Values后接的是（），括号中的值用逗号隔开；Update语句后面一定要有关键字Set；Delect删除记录时，一定要记得加where条件；聚合函数Count后面要加（*）或者你取的数据库表的别名。个人建议:最好能熟练运用SQLServer、DB2、MySQL、Oracle中的一个或几个。 三、灵活运用JSP、Servlet、JavaBean 掌握最基本的JSP代码、JSP指令（page、include、taglib指令）、JSP动作、Servlet和一些XML配置文件方面的知识，JSP比起以后要学的Struts而言，难度要小很多，但是光看书是不够的，一定要多做一些小项目。推荐大家按照书上的例子做一些小的网站，最好采用JSP + Servlet + JavaBean的设计模式，这样可以为以后学习MVC打下基础。 四、透彻的理解MVC编程思想 关于书上经典的案例一定要会做，代码可以记不住，但MVC的编程思想一定要理解好并能够灵活的运用。虽然，MVC并不能算是一种技术，但我个人觉得它太过于重要了，所以依然把它单独列为一个阶段，可见其重要。如果这个理解不了，JavaEE以后就真的没法学了。 五、精通Struts框架 学习Struts，要认真琢磨它的运行原理和执行流程，特别是ActionForm、Action组件的作用和Struts-config.xml这个核心配置文件每一处用到的配置。学到这一步，才算是真正接触了JavaEE，以前学的东西都不过是为SSH这三大框架的学习做好铺垫。当然，这个时候就要用到J2EE的开发工具了，个人推荐eclipse或者MyEclipse，其实MyEclipse也就是饿clipse的豪华版，一个收费，一个不收费。此外，还要熟悉Struts标签，掌握自定义标签是如何使用的。但这个时候千万不要追求大而全，只学习几种常用的标签就可以了，重点放在bean和logic标签上，Struts的html标签和普通的html标签没什么区别，所以……你懂的。还有，要准确的理解：Action、ActionForm、biz、dao这几个层之间的关系。其实本质还是MVC的设计模式。Action作为控制器的作用：响应用户请求，调用后台逻辑，跳转其他页面。多思考一下，多问自己几个为什么。譬如Struts框架既然是一个半成品，那我们使用它的好处是什么，它是如何响应客户端请求的，我们又是如何扩展和配置的等等。最后，在学习一下Struts2，Struts2虽然和Struts1在名称上很相像，但二者有本质上的区别：Struts2是在另一个著名框架WebWork基础上发展而来。 六、了解Hibernate和Spring框架 现在Hibernate和Spring也是相当流行的。Hibernate使用时只需要操纵对象，使开发更对象化，抛弃了数据库中的思想，完全的面向对象思想。但它在只针对某一对象(单个对象)简单的查改删增比较实用，批量修改、删除则不是它的强项。Spring是一个非侵入性的轻量级框架，允许在应用系统中自由地选择和组装Spring的各功能模块，并且不强制要求应用中的类必须从Spring 的系统API中的某个类来继承或者实现某个接口。同时也提供和其它框架集成的接口，如与Hibernate、Struts 的集成等，便于应用开发。 七、推荐学习使用的软件（都是我用过的，没用的暂时忽略） 1.Web容器：TomCat 7.0、TomCat 6.0。个人感觉没什么区别，还有，改端口号是在tomcat的conf文件下server.xml配置文件中。2.开发工具：MyEclipse 9.0、Eclipse 3.2。注意3.2版本是装不上Tomcat 7 的。 3.网页设计工具：Dreamweaver CS5、CS3。个人推荐用CS5，因为用CS3时，JavaScript代码不注意写错了，找都找不到，很头疼的；CS5带了纠错的功能，虽然还不能像Eclipse那样，不过已经很不错了。 4.数据库：SQL Server 2005/ 2000、Oracle 11g。Oracle 不怎么会用，学习中…… 上面是我粗略地勾勒了一下学习JavaEE的曲线。归纳一下：学习Java是需要循序渐进、实例驱动、思考总结的。至于其他的，估计大家到工作以后在慢慢琢磨，不过学这东西，还要看大家的天赋和造化了，反正我是看的云里雾里的，头都大了。这里面涉及的知识点都很多，需要我们耐心细致地学习。大家在做项目的时候会发现各种各样的异常和问题。不要害怕，因为这些错误都是我们的好朋友，我们要把它们通通都记录下来，并坚韧地排除掉它们。这里要记住：尽量避免重复犯错，不要在同一个地方跌倒两次。总之，这个一个相对比较枯燥、耗时间和耗精力的阶段。我们要做的就是不断地参考，不断地思考，不断地总结，最好还能和志同道合的人不断地争论。记得我最疯狂的一次是一天都没出门，从早上7点起来开始敲代码，一直到凌晨1点，连吃饭都在寝室解决。其实当你真正进入代码的世界，你会将周围的一切都忘了。 最后，祝大家学的实用，学的开心！！ 长孙冷雪 2011年8月6日 学习Java EE 心得体会 这学期通过对Java EE五部分的学习，掌握了java 的基本开发方法，学习JavaEE 基础部分分为6大部分，分别是基础服务，Java Web开发，Web Service，JSF框架，EJB部分和JPA。 其中第一部分是基础服务部分，此部分包括六章：第一章是概述，介绍了java EE 的发展历史，架构，组件，服务，容器等概念，并介绍了平台角色以及开发环境和应用服务的选择与安装。第二章讲了使用JNDI 访问明明和目录服务，介绍了什么是命名和服务目录，以及如何通过JNDI 访问Weblogic 提供的命名目录服务。 第三章 讲了使用JDBC 访问数据库，介绍了JDBC的基本用法以及连接池的配置和访问。第四章讲了使用JTA 进行事物处理，介绍了事物处理概念以及如何通过JTA进行事务处理。第五章 RMI ：远程方法调用，介绍了RMI 的结构以及如何使用RMI进行编程。第六章，使用JMS接发消息，介绍了消息服务的概念，在Weblogic 中消息服务相关的配置以及如何通过JMS开发消息发送和接受程序。 J2EE是一种技术，旨在简化企业应用程序的设计和实施。在本教程中，您将学习J2EE是什么，它的好处，J2EE的主要组成部分，企业应用框架的演变，为什么要使用J2EE，J2EE平台架构，J2EE API和技术和J2EE参考实现。在继续之前，我们的J2EE讨论让定义企业应用程序是什么。企业应用程序是一个应用程序，它可能要继续使用他们，同时添加或迁移到一个新的利用互联网，电子商务等新技术的应用，集传统的现有应用程序和数据库。 Java EE 架构分为四层，客户端层，Web层，EJB层和数据库层，其中，数据库层为系统提供数据存储和数据库管理功能，在整个企业级应用中可能村爱很多个数据库，并且采用不同类型的数据库管理系统进行管理。EJB层也称为业务逻辑层，用于完成系统中复杂的或者共享的业务，这些功能主要是提供客户端层和Web层调用，用户不会直接调用该层。Web层是基于HTTP 的访问方式，客户通过Web层访问系统的业务逻辑和数据等。客户端层包括Applet客户端和Application客户端，客户通过客户端的形式访问系统的业务逻辑和数据等。逻辑中的四层可能不同时出现在系统中，例如某个系统可能只提供Web形式的客户端，并且不使用EJB技术，此时系统图只留下Web层和数据库层。 Java运行环境定义了五种类型的应用组件，包括客户端组件Application和Applet，Web层组件JSP和Servlet，EJB组件等，这些组件类型是Java EE 产品必须支持的。 其中的JPA是我学习的重点。JPA包括以下3方面的技术：(1).ORM映射元数据，JPA支持XML和JDK 5.0注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对象持久化到数据库表中.（2).JPA 的API，用来操作实体对象，执行CRUD操作，框架在后台替我们完成所有的事情，开发者从繁琐的JDBC和SQL代码中解脱出来。(3).查询语言，这是持久化操作中很重要的一个方面，通过面向对象而非面向数据库的查询语言查询数据，避免程序的SQL语句紧密耦合。JPA的优势包括：1 标准化，JPA 是 JCP 组织发布的 Java EE 标准之一，因此任何声称符合 JPA 标准的框架都遵循同样的架构，提供相同的访问 API，这保证了基于JPA开发的企业应用能够经过少量的修改就能够在不同的JPA框架下运行。2 对容器级特性的支持，JPA 框架中支持大数据集、事务、并发等容器级事务，这使得 JPA 超越了简单持久化框架的局限，在企业应用发挥更大的作用。3 简单易用，集成方便，JPA的主要目标之一就是提供更加简单的编程模型：在JPA框架下创建实体和创建Java 类一样简单，没有任何的约束和限制，只需要使用 javax.persistence.Entity进行注释；JPA的框架和接口也都非常简单，没有太多特别的规则和设计模式的要求，开发者可以很容易的掌握。JPA基于非侵入式原则设计，因此可以很容易的和其它框架或者容器集成。4 可媲美JDBC的查询能力，JPA的查询语言是面向对象而非面向数据库的，它以面向对象的自然语法构造查询语句，可以看成是Hibernate HQL的等价物。JPA定义了独特的JPQL（Java Persistence Query Language），JPQL是EJB QL的一种扩展，它是针对实体的一种查询语言，操作对象是实体，而不是关系数据库的表，而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有 SQL 才能够提供的高级查询特性，甚至还能够支持子查询。5 支持面向对象的高级特性，JPA 中能够支持面向对象的高级特性，如类之间的继承、多态和类之间的复杂关系，这样的支持能够让开发者最大限度的使用面向对象的模型设计企业应用，而不需要自行处理这些特性在关系数据库的持久化。 第二部分是Java Web 开发，其中第七章主要讲了Java Web应用概述，介绍Java Web的主要技术，发展历史，文档结构，并通过一个简单的例子介绍了Servlet和JSP的运行原理。第八章主要讲了JSP的基本语法，对JSP的基本语法，指令，动作，内部对象和如何在MyEclipse中开发进行了介绍。第九章主要讲了JavaServlet技术，介绍如何编写Servlet，如何使用Servlet与客户端进行交互以及Servlet过滤器和Servle监听器的使用。第十章主要讲EL，介绍EL的基本用法。其中的JSP是我学习的重点。JSP技术使用Java编成语言编写类XML的tags和scriptlets，来封装产生动态网页的处理逻辑。网页还能通过tags和scriptlets访问存在于服务端的资源的应用逻辑。JSP将网页逻辑与网页设计和显示分离，支持可重用的基于组件的设计，使基于Web的应用程序的开发变得迅速和容易。Web服务器在遇到访问JSP网页的请求时，首先执行其中的程序段，然后将执行结果连同JSP文件中的HTML代码一起返回给客户。插入的Java程序段可以操作数据库、重新定向网页等，以实现建立动态网页所需要的功能。JSP与JavaServlet一样，是在服务器端执行的，通常返回给客户端的就是一个HTML文本，因此客户端只要有浏览器就能浏览。JSP页面由HTML代码和嵌入其中的Java代码所组成。服务器在页面被客户端请求以后对这些Java代码进行处理，然后将生成的HTML页面返回给客户端的浏览器。Java Servlet是JSP的技术基础，而且大型的Web应用程序的开发需要Java Servlet和JSP配合才能完成。JSP具备了Java技术的简单易用，完全的面向对象，具有平台无关性且安全可靠，主要面向因特网的所有特点。利用JSP技术，动态信息由JSP页面来表现，JSP页面由安装在Web服务器或者使用JSP的应用服务器上的JSP引擎执行。JSP引擎接受客户端对JSP页面的请求，并且生成JSP页面作为对客户端的响应。JSP页面通常被编译成为Java Servlets，这是一个标准的Java扩展。页面开发人员能够访问全部的Java应用环境，以利用Java技术的扩展性和可移植性。当JSP页面第一次被调用时，如果它还不存在，就会被编译成为一个Java Servlets类，并且存储在服务器的内存中。这就使得在接下来的对该页面的调用中，服务器会有非常快的响应（这避免了CGI－BIN为每个HTTP请求生成一个新的进程的问题）。JSP页面可以包含在多种不同的应用体系结构或者模型中，可以用于由不同协议、组件和格式所组成的联合体中。基于JSP的动态信息发布技术是一个开放的、可扩展的建立动态Web页面的标准。不论采用什么创建工具，开发人员都可以使用JSP页面来创建可移植的Web应用，在不同的Web应用服务器上运行。 第三部分主要讲Web Service，本部分内容主要包括三章。第十三章主要讲Web Service概述没介绍了什么是Web Service以及相关概念，包括WSDL，SOAP和UDDI.第十四章主要讲Java EE 对Web Service的支持，包括JAXR,JAXB和SAAJ.第十五章主要是使用JAX-WS开发Web Service，介绍如何使用JAX-WS 编写WebService以及访问WebService的客户端，包括在MyEcilipse中的开发。Webservice 的概念是使用一个标准的输出接口来定义代码提供的功能，以便让外界可以通过这个标准的输出接口来调用，而所谓的标准输出接口就是wsdl，wsdl是一个xml组成的文件，描述了实现程序对外提供函数的原型，客户端可以通过wsdl来调用实现程序提供的服务代码。 第四部分主要讲了JSF 框架，内容包括五章。第十六章讲了JSF概述，介绍了JSF 的体系结构，JSF的组成和生命周期等。第十七章将了一个简单的JSF应用，介绍了在MyEclipse中如何开发JSF应用。第十八章主要讲了UI组件，介绍了JSF提供的界面控件。第十九章主要讲了在JSP中使用JSF，介绍了本地化，转换器，时间监听器，验证器和导航的使用。第二十章主要是Bean，介绍了辅助Bean的配置，访问和编写。 在这部分中我主要学习了怎样使用JSF编程，其过程主要包括以下几点：第一步，创建web工程J2ee下创建web project，这没什么说的了，不过以前在eclipse中总是不知道怎么创建web应用，够傻的，原来需要插件，在myeclipse提供了全套的插件。不过Myeclipse需要破解。中国程序员似乎很少用正版的。言归正传，Myeclipse中需要在Open Perspective中选择J2ee enterprse视图。然后创建web project。这跟delphi的New一个project不太一样，delphi把所有可以new的都放在一个窗口中，而eclipse有不同的视图来提供管理，这算一种进步吧，插件化的进步。接下来需要 Add JSF Capability，因为这个类库（不知道是否应该称为类库）支撑了JSF开发需要的组件。第二步，创建bean.在New-àother中的Myeclipse-àweb-JSF下有managed bean，创建bean可以连Java类文件一起创建，且可以将需要的属性一起完成，myeclipse可以自动完成属性的get，set方法。是个比较酷的功能。第三步，创建，编辑jsp文件.在工程的webroot-->web-inf下面有一个facesconfig.xml文件，这个文件是Javabean的管理文件，同时它管理了页面之间的切换关系，起到导航页面的作用。有趣的是这个文件居然有个漂亮的design界面，可以在上面创建新的jsp文件，且可以用拖拽方式定义页面之间的关系，让所有页面的关系看起来很直观。感觉这里是个很酷的设计。页面的导航是根据一个字符串来作为判断依据的，所以在配置导航关系时，只要设定From outcome的值为调用bean方法的返回值即可。值得注意的是，JSF对于导航值只允许string类型。Jsp页面的编写其实很方便，即使不太懂，因为myeclipse提供了拖拽式的页面设计，如果熟练直接写代码也很好玩吧。我以前一直很讨厌html的代码，因为觉得太机械了，且不好记忆，这会得硬着头皮学了，不过在这种拖拽式的设计中可以省不少力气。记得jsp中使用Java采用””的方式，这会是：”#{}” 直接以bean来调用。第四步，本地化.如果需要考虑国际化的问题，那么需要创建一个.properties的文件，否则可以跳过这里。.properties文件需要创建到源码文件的目录下，否则在指定位置时便会找不到它。.properties文件的配置非常简单，如同一个ini文件。如：“username=user name”, 如果要显示中文的话，这里需要转化为unicode，jdk带了一个native2ascii的小工具可以轻松转换，不过这个玩意每次复制的时候都要先将编辑设为“标记”。不知道有没有更方便的工具。另外如果要支持中文的.properties文件需要以_zh_CN结尾才行。在jsp文件中使用下面形式定义：然后就如同Java中的类一样使用了.第五部分主要是EJB部分，内容包括四章，地二十一章介绍了EJB 的目标，发展历史，特点，角色，分类以及变成规约。第二十二章主要对会话Bean的开发以及运行原理进行了介绍。第二十三章介绍了消息驱动Bean以及客户端程序的编写。第二十四章讲解了如何访问数据源，定时服务和事务处理对象。其中EJB为学习的重点，EJB(Enterprise JavaBean)是J2EE的一部分，定义了一个用于开发基于组件的企业多重应用程序的标准。其特点包括网络服务支持和核心开发工具(SDK)。在J2EE里，Enterprise Java Beans(EJB)称为Java 企业柄，是Java的核心代码，分为整体柄和片段柄和消息柄三个部分，其中的消息柄将在以后再作讨论。EJB是sun的服务器端组件模型，最大的用处是部署。 第一章 javaEE体系架构 web回顾： web的核心技术就是servlet和JSP，然而组成一个基本的web应用程序还有：客户端浏览器、HTTP协议、javabean、xml、标记库、web服务器和web容器等技术，通过采用JSP+servlet+javaBean技术实现web应用的开发（也就是MVC模式），MVC中的每一个组件，她们都充当着不同的角色servlet就是充当控制器角色负责处理业务和控制业务流程，JSP充当视图角色负责输出响应的结果，javabean充当模型角色，负责具体的业务逻辑和业务数据。 详解：当客户端浏览器向web服务器发出HTTP请求，所请求的消息通过控制器，然后控制器从中获得信息，接着控制器把业务逻辑将信息交给一个适当的模型对象，这个模型对象与数据库进行交互，并且按照请求信息的要求进行处理、应答并收集信息，然后把控制权转交给控制器，控制权得到接过信息后决定采用什么样的视图向客户端浏览器显示响应信息，在这一过程中，控制器并不是直接将信息给某个视图做显示，通常这是一个包括把数据放置在适当的javaweb作用域范围对象的过程，这个作用域对象在控制器和视图之间共享。Javaweb应用开发的层次： 表示层->业务层->持久层 表示层采用了HTML、jsp、XML等视图技术。 业务层中使用java的组件技术javabean实现业务逻辑，在持久层使用jdbc完成业务数据的持久化，在逻辑分层中采用MVC模式将表示层与业务层进行分离，这样便于修改和加入表示层，把处理过程放置在分离的业务层中也更便于测试。采用DAO模式将业务层与持久层分离，从而使得层与层之间进行数据传输。Web应用的优缺点： 优点：1.web应用能够在servlet容器中运行，便于管理 负载小、对业务层对象的访问叫简单，可以在不同的Servlet之间移植。 然而Web应用也存在一定的缺陷： 1.她只针对一个服务器和一个数据库，性能较低，应用有限。2.无法完成相应的事务处理。 二、JavaEE 1.什么是javaEE企业级应用? JavaEE是一套设计、开发、汇编和部署企业应用程序的规范，目的与核心是提供相应的服务。JavaEE体系结构的优缺点： 优点：分布式组件、应用程序的可移植性、可靠与稳定性。缺点：较高的资源需求、较高的应用程序服务器费用 JavaEE框架总结 框架是什么？ 框架是半成品，它把程序员需要写可以重用的代码封装起来。学习框架重点学习什么？ 重点学习工作原理、明白整个工作流程；明白工作流程中哪些是框架自动生成的、哪些需要程序员自己写的；明确该框架适用于什么场合； 1.三层架构 软件的架构可以分为：表现层、业务逻辑层和数据访问层。 2.MVC架构 MVC架构分为：控制层（Controller）、模型层（Model）和视图层（View）。 Http RequestController(控制层)接受请求转发请求委托模型层进行数据处理Model(模型层)处理请求返回结果浏览器Http Response返回结果视图渲染JSTLView(视图层)接受请求转发请求 3.Struts2框架 （1）该框架中程序员都需要写什么？ 配置：web.xml、struts.xml文件。编写Action类和结果视图（如jsp）。（2）Struts2用来干什么： 核心功能：MVC控制器。 扩展功能：struts标签库(view);集成dwr,来实现Ajax的功能；国际化。 4.Spring框架： （1）Spring的核心功能： AOP（面向切面编程）：将公共的功能抽取出来（如转账时的权限验证、环境验证）。IOC（控制反转，DI依赖注入）：通过xml或注解的方式获取类(对象)、给属性赋值。由Spring容器控制对象的生命周期（创建、初始化、销毁）；该创建对象的方式解决了上层需要new下层的对象的问题，实现层与层之间的解耦。（2）Spring IOC工作原理图： 目标类package com.itheima11.helloworld;public class HelloWorld {public void hello(){System.out.println(“hello world”);}}ApplicationContext.xml文件 （3）Spring AOP工作原理图： 目标接口public interface PersonDao {public void savePerson();}切面public class Transaction {public void beginTransaction(){System.out.println(“begin transaction”);}public void commit(){System.out.println(“commit”);}}目标类public class PersonDaoImpl implements PersonDao{public void savePerson(){System.out.println(“save person”);}}applicationContext.xml文件 目标接口public interface PersonDao {public void savePerson();}切面类public class Transaction {public void beginTransaction(){System.out.println(“begin transaction”);}public void commit(){System.out.println(“commit”);}}目标类public class PersonDaoImpl implements PersonDao{public void savePerson(){System.out.println(“save person”);}}代理类public class PersonDaoProxy implements PersonDao{private PersonDao personDao;private Transaction transaction;public PersonDaoProxy(PersonDao personDao,Transaction transaction){this.personDao = personDao;this.transaction = transaction;}public void savePerson(){this.transaction.beginTransaction();this.personDao.savePerson();this.transaction.commit();}}测试类public class ProxyTest {@Testpublic void testProxy(){PersonDao personDao = new PersonDaoImpl();Transaction transaction = new Transaction();PersonDaoProxy proxy = new PersonDaoProxy(personDao, transaction);proxy.savePerson();}} Spring AOP工作原理二 5.Hibernate框架： 持久层框架（还有JPA/JDO/MyBatis/toplink） 应用程序Configuration配置文件映射文件SessionFactory获取Session数据操作回滚操作异常事务关闭Session正常提交数据库 Hibernate框架执行流程 Hibernate映射文件：Person.hbm.xml com.mysql.jdbc.Driver root admin jdbc:mysql://localhost:3306/day22 org.hibernate.dialect.MySQLDialect 需要开发的程序：实体类、工具类、测试类、数据表。 6.SpringMVC框架 7.MyBatis框架第二篇：JavaEE学习方法总结
第三篇：JavaEE学习心得与总结
第四篇：JavaEE体系架构总结
第五篇：JavaEE框架总结
