Java基础学习知识点总结

第一篇：Java基础学习知识点总结

黑马程序员_毕向东_Java基础视频教程

Java基础学习知识点总结 2016年01月06日

day01

一、基础知识：软件开发

1、什么是软件？软件：一系列按照特定顺序组织的计算机数据和指令的集合。

2、常见的软件：系统软件：如：DOS，Windows，Linux等。应用软件：如：扫雷，迅雷，QQ等。

3、什么是开发？制作软件。

二、基础知识：人机交互方式

4、软件的出现实现了人与计算机之间的更好的交互。

5、交互方式：图形化界面：这种方式简单直观，使用者易于接受，容易上手操作。命令行方式：需要有一个控制台，输入特定的指令，让计算机完成一些特定的操作。较为麻烦，需要记录住一些命令。

三、基础知识：常用的DOS命令

6、点击开始在运行栏输入“cmd”进入dos操作界面。

7、课程中常见的命令：

dir：列出当前目录下的文件以及文件夹。md：创建目录。rd：删除目录。

cd：进入指定目录。d：进入盘符。cd..：退回到上一级目录。cd/：退回到根目录。del：删除文件。

exit：退出dos命令行。

8、在dos命令行操作文件夹时，如忘记文件夹全称，可以输文件夹前几个名称后面用*代替。

四、基础知识：计算机语言

9、通过DOS命令行的演示，发现原来操作计算机就如同和计算机说话一样。

10、我们告诉它做什么，它就可以做什么。前提是，我们和它说的内容它必须识别才可以。这就是计算机语言。

11、什么是计算机语言？语言：是人与人之间用于沟通的一种方式。例如：中国人与中国人用中文沟通。而中国人要和韩国人交流，就要学习韩语。

12、计算机语言：人与计算机交流的方式。如果人要与计算机交流，那么就要学习计算机语。计算机语言有很多种，如：C，C++，Java等。这里，我们选择其中一种：Java语言。

五、基础知识：Java语言介绍

13、Java语言概述。是SUN（Stanford University Network，斯坦福大学网络公司）1995年推出的一门高级编程语言。是一种面向Internet的编程语言。随着Java技术在Web方面的不断成熟，已经成为Web应用程序的首选开发语言。是简单易学，完全面向对象，安全可靠，与平台无关的编程语言。

14、Java语言的三种技术架构。J2EE（Java 2 Platform Enterprise Edition）企业版（现更名：JAVAEE）：是为开发企业环境下的应用程序提供一套解决方案。该技术体系中包含的技术如Servlet Jsp等，主要针对于Web应用程序开发。J2SE（Java 2 Platform Standard Edition）标准版（现更名：JAVASE）：是为开发普通桌面和商务应用程序提供的解决方案。该技术体系是其他两者的基础，可以完成一些桌面应用程序的开发。比如Java版的扫雷。J2ME（Java 2 Platform Micro Edition）小型版（现更名：JAVAME）：是为开发电子消费产品和嵌入式设备提供的解决方案。该技术体系主要应用于小型电子消费类产品，如手机中的应用程序等。

15、Java语言的特点：跨平台性。什么是跨平台性？通过Java语言编写的应用程序在不同的系统平台上都可以运行。原理是什么？只要在需要运行Java应用程序的操作系统上，先安装一个Java虚拟机（JVM Java Virtual Machine）即可。由JVM来负责Java程序在该系统中的运行。

16、Java语言的特点：跨平台性。Java程序：Windows系统：Win版的JVM；Linux系统：lin版的JVM；MAC系统：mac版的JVM。因为有了JVM，所以同一个Java程序在三个不同的操作系统中都可以执行。这样就实现了Java程序的跨平台性。也称为Java具有良好的可移植性。

六、基础知识：Java语言的环境搭建

17、明确什么是JRE，JDK；下载JDK；安装JDK；配置环境变量；验证是否成功。

18、什么是JRE，JDK？JRE（Java Runtime Environment Java运行环境）：包括Java虚拟机（JVM Java Virtual Machine）和Java程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。JDK（Java Development Kit Java开发工具包）：JDK是提供给Java开发人员使用的，其中包含了Java的开发工具，也包括了JRE。所以安装了JDK，就不用再单独安装JRE了。其中的开发工具：编译工具（java.exe）打包工具（jar.exe）等。简单而言：使用JDK开发完成的Java程序，交给JRE去运行。

19、Java6.0 Platform

20、下载JCK（Java Development Kit Java开发工具包）。官方网址：www.xiexiebang.com、java.sun.com。下载完成后，安装在电脑上。然后打开DOS命令行，效验文件是否安装完毕，并利用DOS进行Javac.exe运行测试。为了更方便的使用Java开发工具，需要进行环境变量配置。配置成功后就可以进行Java程序的开发了。

21、环境变量配置。方法一：图形界面操作。我的电脑——属性——高级——环境变量；编辑Path环境变量，在变量值开始处加上Java工具所在目录，后面用分号和其他值分隔开即可；打开DOS命令行，任意目录下敲入javac；如果出现javac的参数信息，配置成功。这种配置方式，一劳永逸。具体流程：右键点击我的电脑打开属性，点击高级系统设置，点击高级，点击环境变量，找到系统变量，新建系统变量（变量名：JAVA_HOME，变量值：安装JKD的地址。如：D:ProgramStudioJDK1.7）点击确定，找到变量名为Path的变量，点击编辑，在变量值栏的最前面（放到前面时，先寻找）加入%JAVA_HOME%bin用分号隔开。方法二：DOS界面操作（可用于临时环境变量配置，借助别人的电脑开发Java程序）。具体流程：利用set命令：设置、查看环境变量的值。Set path：查看path的值。配置Java工具包：set path=D:ProgramStudioJDK1.7bin;%path%回车。测试javac。只对当前窗口有效。定义class路径：Set classpath=.;c:myclass。

七、基础知识：Java程序开发体验

22、Hello World。将Java代码编写到扩展名为.java的文件中；通过javac命令对该java文件进行编译；通过java命令对生成的class文件进行运行。Java文件——javac.exe编译——class文件——java运行——结果。

23、对于初学者，可以用记事本编写。按部就班，一步一步写代码。打开记事本。Java代码是以类的形式来体现的。代码如下： class TestFirstOne //Java定义类+类名（首字母大写）{ public static void main(String[] args)//主函数（保证类的独立运行）

{

System.out.println(“hello world”);//输出打印语句

} }

23、classpath配置。临时配置方式：dos配置。Set Classpath=代码路径。回车。Classpath先在环境变量中找，然后在当前路径（结尾没带分号不找）。Path先在当前路径查找，然后去环境变量中查找。一劳永逸方法和上面JDK环境变量配置方法一样。

24、Hello World组成部门。class是java程序中的关键字（关键字只能是小写）。{}类的区间用大括号定义（类中的内容为了增加阅读性，需要有阶梯感，如使用tab键）。public static void main(String[] args)定义主函数（使用大括号确定函数的内容）。

25、注释。三种方式：//单行注释，符号以后直到回车键的内容；/*多行注释，符号开始到符号结束以内的内容*/；/**java注释符号，可被提取出来制作软件开发手册*/。注释的作用：增加程序的阅读性；调试程序。

26、写代码要养成写注释的习惯。在写代码前注释相关信息。例如： /* 需求：定义一个Hello World小程序。思路： 1，2，步骤：

1，通过class关键字定义一个类。将代码都编写到该类中。

2，为了保证该的独立运行。在类中定义个主函数。格式public static void main(String[] args)3，保存成一个扩展名为java的文件。

4，在dos控制台中通过javac工具对java文件进行编译。5，在通过java命令对生成的class文件进行执行。作者：ZC 版本：v1.0 日期：2016.01.06 copyright：ZC */ 2016年01月07日

day02

一、基础知识：Java语言基础组成

1、组成：关键字、标识符、注释、常量和变量、运算符、语句、函数、数组

二、基础知识：关键字

2、关键字的定义和特点：定义：被Java语言赋予了特殊含义的单词。特点：关键字中所有字母都为小写。

3、用于定义数据类型的关键字：class、interface、byte、short、int、long、float、double、char、boolean、void。

4、用于定义数据类型值的关键字：true、false、null。

5、用于定义流程控制的关键字：if、else、switch、case、default、while、do、for、break、continue、return。

6、用于定义访问权限修饰的关键字：private、protected、public。

7、用于定义类，函数，变量修饰的关键字：abstract、final、static、synchronized。

8、用于定义类与类之间关系的关键字：extends、implements。

9、用于定义建立实例以及引用实例，判断实例的关键字：new、this、super、instanceof。

10、用于异常处理的关键字：try、catch、finally、throw、throws。

11、用于包的关键字：package、import。

12、其他修饰符关键字：native、strictfp、transient、volatile、assert。

三、基础知识：标识符

13、标识符：在程序中自定义的一些名称；由26个英文字母大小写，数字：0-9，符号_$组成；定义合法标识符规则：数字不可以开头、不可以使用关键字；Java中严格区分大小写；注意：在起名时，为了提高阅读性，要尽量有意义。

14、Java中的名称规范：包名：多单词组成时所有都小写，如：xxxyyyzzz；类名接口名：多单词组成时，所有单词的首字母大写，如：XxxYyyZzz；变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写，如：xxxYyyZzz；常量名：所有字母都大写，多单词时每个单词用下划线连接，如：XXX_YYY_ZZZ。

四、基础知识：注释

15、注释：对于单行和多行注释，被注释的文字，不会被JVM（Java虚拟机）解释执行；对于文档注释，是Java特有的注释，其中注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档；注释是一个程序员必须要具有的良好编程习惯；初学者编写程序可以养成习惯；先写注释再写代码；将自己的思想通过注释先整理出来，再用代码去体现；因为代码仅仅是思想的一种体现形式而已；用于注解说明解释程序的文字就是注释；提高了代码的阅读性。

16、Java中的注释格式：单行注释：格式：//注释文字；多行注释：格式：/*注释文字*/；文档注释：格式：/**注释文字*/。

五、基础知识：常量

17、常量表示不能改变的数值。

18、Java中常量的分类：整数常量：所有整数；小数常量：所有小数；布尔型常量：较为特有，只有两个数值：true和false；字符常量：将一个数字字母或者符号用单引号（’’）标识；字符串常量：将一个或者多个字符用双引号（””）标识；null常量：只有一个数值就是null。

19、对于整数：Java有三种表现形式：十进制：0-9，满10进1；八进制：0-7，满8进1，用0表示开头；十六进制：0-9，A-F，满16进1，用0x开头表示。

六、基础知识：进制转换

20、进制的转换特点：八位二进制表示一个字节（基本的数据单元）。三个二进制位表一个八进制位。四个二进制位表示一个十六进制位。ASCII码编码表。

21、二进制和十进制之间的转换：十进制转二进制：原理：对十进制数进行除2运算（除二取余法）；二进制转十进制：原理：二进制乘以2的N次的过程。

22、快捷方法：8421法则。

23、负数的二进制表现形式：对应的正数二进制取反加1。负数的最高位都是1。

七、基础知识：变量

24、变量的概念：内存中的一个存储区域；该区域有自己的名称（变量名）和类型（数据类型）；该区域的数据可以在同一类型范围内不断变化；理解：变量就如同数学中的未知数；变量：就是将不确定的数据进行存储，也就是需要在内存中开辟一个空间。

25、为什么要定义变量：用来不断的存放同一类型的常量，并可以重复使用。

26、使用变量注意：变量的作用范围（一对{}之间有效）；初始化值。

27、定义变量的格式：数据类型变量名=初始化值；注：格式是固定的、记住格式，以不变应万变。

28、Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同打小的内存空间。数据类型：基本数据类型（数值型（整数类型（byte，short，int，long）；浮点类型（float，double））；字符型（char）；布尔型（boolean））；引用数据类型（类（class）；接口（interface）；数据（[]））。注意：整数默认：int，小数默认：double。

29、数据类型空间：byte 8位二进制（一个8位二进制或1个字节）；short 16位二进制（二个8位二进制或2个字节）；int 32位二进制（四个8位二进制或4个字节）；long 64位二进制（八个8位二进制或8个字节）；float（单精度）32位二进制（四个8位二进制或4个字节）；double（双精度）64位二进制（八个8位二进制或8个字节）；char 取值：0-65535；boolean取值：true，false。

30、类型转换。不同类型的数据不能进行运算。需要进行数据类型提升，从小往大提升，自动数据类型提升。强制类型转换：格式：变量=（类型名）（需转换的数据）；什么时候使用强制转换：如：小数保留整数部分。

31、表达式的数据类型自动提升：所有的byte型、short型和char的值将被提升到int型；如果一个操作数是long型，计算结果就是long型；如果一个操作数是float型，计算结果就是float型；如果一个操作数是double型，计算结果就是double型。分析：system.out.println（‘a’）与system.out.println（‘a’+1）的区别。

八、基础知识：运算符

32、算数运算符：+正号，-负号，+加，-减，*乘，/除，%取模，++自增（前），++自增（后），--自减（前），--自减（后），+字符串相加（字符串数据和任何数据使用+都是相连接，最终都会变成字符串）。

33、转义字符：通过 来转变后面字母或者符号的含义。在Linux系统中换行是一个字符来表示n，windows系统中，换行由nr实现。n:换行。b:退格。相当于backspace键。r:按下回车键。t:制表符。相当于tab键。

34、赋值运算符：符号：=：赋值，+=：a+=5等价于a=a+5，-=，*=，/=，%=。

35、比较运算符：==：相等于；！=：不等于；<：小于；>：大于；<=：小于等于；>=：大于等于；instanceof：检查是否是类的对象。注意：比较运算符的结果都是boolean型，也就是要么是true，要么是false；比较运算符“==”不能误写成“=”。

36、逻辑运算符：&：AND（与）两边的boolean表达式结果，有一个为false，那么结果就是false，只要两边都为true，结果为true；|：OR（或）两边的boolean表达式结果，只要有一个为true，结果为true，只有两边都有false，结果为false；^：XOR（异或）两边的boolean表达式结果相同结果为false，两边不同结果为true；！：NOT（非）；&&：AND（短路）；||OR：（短路）。逻辑运算符用于连接boolean类型的表达式。&和&&的特点：&：无论左边是真是假，右边都运算；&&：当左边为假时，右边不运算。|和||的特点：|：两边都做运算；||：但左边为真时，右边不运算。

37、位运算符：<<：左移，如：3<<2=12等价于3*2^2=12；>>：右移，如：6>>2=1等价于6/2^2=1；>>>：无符号右移，如：3>>>1=1；&：与运算，如：6&3=2；|：或运算，如：6|3=7；^：异或运算，如：6^3=5；~：反码，如：~6=-7；位运算是直接对二进制进行运算。<<：其实就是乘以2的移动的位数次幂；>>：就是除以2的移动的位数次幂。>>：最高位补什么由原有数据的最高位值而定；如果最高位0，右移后，用0补空位；如果最高位1，右移后，用1补空位。>>>：无论最高位是什么，右移后，都用0补。一个数异或同一个数两次，结果还是拿个数。

38、三元运算符：格式：（条件表达式）？表达式1：表达式2；如果条件为true，运算后的结果是表达式1；如果条件为false，运算后的结果是表达式2。如：获取两个数中大数，int x=3,y=4,z;z=(x>y)?x:y//z变量存储的就是两个数的大数。

九、基础知识：if语句

39、程序流程控制：顺序结构，判断结构，选择结构，循环结构。

40、判断结构：if语句三种格式：一层判断：if(条件表达式){执行语句;}；两层判断：if(条件表达式){执行语句;}else{执行语句;}；多层判断：if(条件表达式){执行语句;}else if(条件表达式){执行语句;}else{执行语句;}。

41、if else结构间歇格式：变量=（条件表达式）？表达式1：表达式2；三元运算符：好处：可以简化if else代码；弊端：因为是一个运算符，所以运算完毕需要有一个结果。

42、解决DOS命令下，编译无法识别GDK码方法：方法一：使用-encoding参数指明编码方式：javac-encoding UTF-8 XX.java。方法二：保存java文件时，选择编码格式为ANSI。

十、基础知识：switch语句

43、选择结构：switch语句：格式：switch(表达式){case 取值1：执行语句；break；case 取值2：执行语句；break；„„default：执行语句；//break；}

44、switch（表达式）：表达式只接收四种类型：byte，short，int，char。

45、if语句与switch语句的区别：if除了能判断数值，还能判断具体区间，switch判断区间很累；对于数字是布尔型时，只有if能判断。

46、if语句与switch语句的用法：如果要对具体数字进行判断，数值不多，而且符合byte、short、int、char这四种类型，虽然两个语句都可以使用，建议用switch完成。因为效率稍高。其他情况一般用if。当结果为布尔型或区间时，用if完成。If的使用范围更广。2016年01月08日day03

一、基础知识：while语句

1、循环结构：代表语句：while、do while、for。

2、while语句格式：while（条件表达式）{执行语句；}。

3、do while语句格式：do{执行语句；}while（条件表达式）。Do while特点是条件无论是否满足，循环体至少被执行一次。

4、while和do while的区别：while：先判断条件，只有条件满足才执行循环体。do while：先执行循环体，再判断条件，条件满足，再继续执行循环体。简单一句话：do while：无论条件是否满足，循环体至少执行一次。

二、基础知识：for语句

5、for语句格式：for（初始化表达式；循环条件表达式；循环后的操作表达式）{执行语句；}。注意：a：for里面的连个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。b：while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。c：最简单无限循环格式：while（true），for（；；），无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。

6、for和while的区别：a：变量有自己的作用域。对于一个变量来将，如果这个变量仅仅用于控制循环的次数，用作循环增量时用for语句。循环结束时，该变量在内存被释放。用于优化内存。b：for和while可以进行互换，如果定义循环增量，用for更为合适。

7、什么时候使用循环结构？当要多某些语句执行很多次时，就是用循环结构。

8、循环注意：一定要明确哪些语句需要参与循环，哪些不需要。

9、两种思想：累加思想：原理：通过变量记录住每次变化的结果。通过循环的形式，进行累加动作。计数器思想：原理：通过一个变量记录住数据的状态变化。也通过循环完成。

10、循环嵌套：语句嵌套形式，其实就是语句中含有语句。

11、其他流程控制语句：break（跳出），continue（继续）。Break语句：应用范围：选择结构和循环结构。Continue语句：应用于循环结构。注意：a：这两个语句离开应用范围，存在是没有意义的。b：这两个语句单独存在下面都不可以有语句，因为执行不到。c：continue语句是结束本次循环继续下次循环。d：标号的出现，可以让这两个语句作用于指定的范围。

12、注意：标号只能用于循环语句上，给循环起名字。

13、continue：只能作用于循环结构。继续循环。特点：结束本次循环，继续下一次循环。

14、总结：a：break和continue语句作用的范围。b：break和continue单独存在时，下面可以有任何语句。因为都执行不到。

三、基础知识：函数

15、函数的定义：什么是函数？函数就是定义在类中的具有特定功能的一段独立小程序；函数也称为方法。

16、函数的格式：修饰符返回值类型函数名（参数类型形式参数1，参数类型形式参数2，„）{执行语句；return返回值；}。返回值类型：函数运行后的结果的数据类型。参数形式：是形式参数的数据类型。形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。实际参数：传递给形式参数的具体数值。Return：用于结束函数。返回值：该值会返回给调用者。

17、函数的特点：定义函数可以将功能代码进行封装；便于对该功能进行复用；函数只有被调用才会被执行；函数的出现提高了代码的复用性；对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。注意：函数中只能调用函数，不可以在函数内部定义函数；定义函数时，函数的结果应该返回给调用者，交由调用者处理。

18、重点：函数的应用。如何定义一个函数呢？a：既然函数是一个独立的功能，那么该功能的运算结果是什么先明确。因为这是在明确函数的返回值类型。b：再明确在定义该功能的过程中是否需要未知的内容参与运算。因为是在明确函数的参数列表（参数的类型和参数的个数）。

19、函数的重载（overload）：重载的概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。重载的特点：与返回值无关，只看参数列表。重载的好处：方便与阅读，优化了程序设计。重载示例：//返回两个整数的和int add(int x,int y){return x+y;}；//返回三个整数的和int add(int x,int y,int z){return x+y+z;}；//返回两个小数的和double add(double x,double y){return x+y;}。

20、什么时候用重载？当定义的功能相同，但参与运算的未知内容不同。那么，这时就定义一个函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分多个同名函数。

四、基础知识：数组

21、数组的定义：概念：同一种数据类型的集合。其实数组就是一个容器。数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。关键字：new：用来在内存中产生一个容器实体。格式一：元素类型[]数组名=new元素类型[元素个数或数组长度]；示例：int [] arr=new int[5]；格式二：元素类型[]数组名=new元素类型[]{元素，元素，„}；示例：int[] arr=new int[]{3,5,1,7}；int[] arr={3,5,1,7}。

22、内存结构：Java程序在运行时，需要在内存中分配空间。为了提高运行效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存的管理方式。A：栈内存（栈区）：用于存储局部变量，当数据使用完，所占空间会自动释放。B：堆内存（堆区）：数组和对象，通过new建立的实例都存放在堆内存中。每一个实体都有内存地址。实体中的变量都有默认初始化值。实体不在被使用，会在不确定的时间内被垃圾回收器回收。C：方法区，本地方法区，寄存器。2016年01月09日

day04

一、基础知识：数组

1、获取数组中的元素。通常会用到遍历。

2、数组中有一个属性可以直接获得到数组元素个数。length。使用方式：数组名称.length。

3、数组排序：选择排序：内循环结束一次，最值出现头角标位置。冒泡排序：第一圈：最值出现在了最后位。

4、java中排序工具：import.java.util.*；Array.sort(arr)。java中已经定义好的一种排序方式。开发中，对数组排序，要使用该句代码。

5、二维数组：数组中的数组：格式一：int[][] arr=new int[3][2]；定义了名称为arr的二维数组；二维数组中有3个一维数组；每一个一维数组中有2个元素；一维数组的名称分别为arr[0]，arr[1]，arr[2]；给第一个一维数组1脚标位赋值为78写法是：arr[0][1]=78。格式二：int[][] arr=new int[3][]；二维数组中有3个一维数组；每个一维数组都是默认初始值null；可以对这个三个一维数组分别进行初始化：arr[0]=new int[3]；arr[1]=new int[1]；arr[2]=new int[2]。

2016年01月10日

day05

一、面向对象：概述

1、理解面向对象：面向对象是相对面向过程而言；面向对象和面向过程都是一种思想；面向过程：强调的是功能行为；面向对象：将功能封装进对象，强调了具备了功能的对象；面向对象是基于面向过程的。让我们的角色从执行者变为指挥者。面向过程是面向对象的基础。

2、一切皆对象，境界：万物皆对象。

3、写程序时：先考虑对象。有对象时，直接用。没对象时，自己造一个对象。

4、人开门：名称提炼法。事物：人、门。示例：人{开门（门）{门。开（）；}}；门{开（）{操作门轴等。}}。

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

6、以后的开发：其实就是找对象使用。没有对象，就创建一个对象。

7、找对象，建立对象，使用对象，维护对象的关系。

8、类和对象的关系：类就是：对现实生活中事物的描述。对象：就是这类事物，实实在在的个体。映射到java中，描述就是class定义的类。具体对象就是对于java在堆内存中用new建立实体。

9、类与对象示例：图纸：汽车，汽车，汽车。可以理解为：类就是图纸；汽车就是堆内存中的对象。

10、描述事物其实就在是描述事物的属性和行为。

11、属性对应是类中的变量，行为对应的类中的函数（方法）。其实定义类，就是在描述事物，就是在定义属性和行为。属性和行为共同成为类中的成员（成员变量和成员函数（方法））。

12、引用变量：类类型变量。记住：类类型变量指向对象。

13、就需要该对象做使用，在java指挥方式是：对象.对象成员。

14、成员变量和局部变量：作用范围：成员变量作用于整个类中。局部变量作用于函数中，或者语句中。在内存中的位置：成员变量：在堆内存中，因为对象的存在，才在内存中存在。局部变量：存在栈内存中。

15、匿名对象：匿名对象是对象的简化形式；匿名对象两种使用情况：当对对象方法仅进行一次调用的时；匿名对象可以作为实际参数进行传递。

二、面向对象：封装

16、封装的定义：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

17、封装的好处：将变化隔离；便于使用；提高重用性；提高安全性。

18、封装原则：将不需要对外提供的内容隐藏起来；把属性都隐藏，提供公共方法对其访问。

19、函数是最小的封装体；类是较小的封装体；包是中级封装体；框架是较大的封装体。20、关键字private：私有，权限修饰符：用于修饰类中的成员（成员变量，成员函数）。在类中隐藏。私有只在本类中有效。

21、注意：私有仅仅是封装的一种表现形式。

22、之所以对外提供访问方式，就是因为可以在访问方式中加入逻辑判断语句。对访问的数据进行操作。提高代码健壮性。

23、关键字private：将成员变量私有化。对外提供对应的set，get方法对其进行访问。提高对数据访问的安全性。

三、面向对象：构造函数

24、构造函数的特点：函数名与类名相同；不用定义返回值类型；不可以写return语句。

25、构造函数的作用：给对象进行初始化。注意：默认构造函数的特点；多个构造函数是以重载的形式存在的。

26、构造函数：对象一建立就会调用与之对应的构造函数。构造函数的作用：可以用于给对象进行初始化。

27、构造函数的小细节：当一个类中没有定义构造函数时，那么系统会默认给该类假如一个空参数的构造函数。当在类中自定义了构造函数后，默认的构造函数就没有了。

28、构造函数和一般方法（函数）的区别：A：构造函数和一般函数在写法上有不同。B：在运行上也有不同。构造函数是在对象一建立就运行。就对象初始化。而一般方法是对象调用才执行，是给对象添加对象具备的功能。C：一个对象建立，构造函数只运行一次。而一般方法可以被该对象调用多次。

29、什么时候定义构造函数呢：当分析事物时，该事物存在具备一些特征或者行为，那么将这些内容定义在构造函数中。30、构造代码块：作用：给对象进行初始化。对象一建立就运行，而且优先于构造函数执行。

31、构造代码块和构造函数区别：构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象进行初始化。

32、构造代码块中定义的是不同对象共性的初始化内容。

四、面向对象：this关键字

33、关键字this：看上去，是用于区分局部变量和成员变量同名情况。

34、关键字this的特点：就代表本类的对象，到底代表哪一个呢？this代表它所在函数所属对象的引用。简单说：哪个对象在调用this所在的函数，this就代表哪个对象。

35、this的应用：当定义类中功能时，该函数内部要用到该函数的对象时，这时用this来表示这个对象。但凡本类功能内部使用到了本类对象，都用this代替。

36、this语句：用于构造函数之间函数互相调用。this语句：只能定义在构造函数的第一行。因为初始化要先执行。

37、this语句只能用于构造函数间，不能用于一般函数。

2016年01月11日

day06

一、面向对象：static关键字

1、static（静态）关键字：用于修饰成员（成员变量和成员函数）。被修饰后的成员具备以下特点：随着类的加载而加载；优先于对象存在；被所有对象所共享；可以直接被类名调用。使用注意：静态方法只能访问静态成员；静态方法中不可以写this，super关键字；主函数是静态的。

2、用法：是一个修饰符，用于修饰成员（成员变量，成员函数）。当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名用。类名.成员变量。

3、实例变量和类变量的区别：A，存放位置：类变量随着类的加载而存在于方法区中。实例变量随着对象的建立存在于堆内存中。B，生命周期：类变量生命周期最长，随着类的消失而消失。实例变量随着对象的消失而消失。

4、静态使用注意事项：A，静态方法只能访问静态成员。非静态方法既可以访问静态也可以访问非静态。B，静态方法中不可以定义thsi，super关键字。因为静态优先于对象存在，所有静态方法中不可以出现this。C，主函数是静态的。

5、静态优缺点：优：对对象的共享数据进行单独空间的存储，节省空间。没有必要每个对象中都存储一份。可以直接被类名调用。缺：生命周期过长。访问出现局限性。（静态虽好，只能访问静态。）

6、public static void main(String[] args)主函数：是一个特殊的函数，作用程序的入口，可以被jvm调用。

7、主函数的定义：public：代表着该函数访问权限是最大的。static：代表主函数随着类的加载就已经存在了。void：代表主函数没有具体的返回值。main：不是关键字，但是是一个特殊的单词，可以被jvm识别。（String[] args）：函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。

8、主函数是固定格式的：jvm识别。jvm在调用主函数时，传人的是new String[0]。

9、什么时候使用静态？要从两方面下手：因为静态修饰的内容有成员变量和函数。什么时候定义静态变量（类变量）呢？当对象中出现共享数据时，该数据静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。

10、什么时候定义静态函数呢？当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的。

11、静态的应用：A每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装。以便复用。B虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。但是：1，对象是用于封装数据的，可以ArrayTool对象并未封装特特有数据。2，操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。C这时就考虑，让程序更严谨，是不需要对象的。可以将ArrayTool中的方法都定义成static的，直接通过类名调用即可。D将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。为了更为严谨，强制让该类不能建立对象。可以通过将构成函数私有化完成。

12、接下来，将ArrayTool.class文件发送给其他人，其他人只要将该文件设置到classpath路径下，就可以使用该工具类。但是，很遗憾，该类中到底定义了多少个方法，对方不清楚。因为该类并没有使用说明书。开始制作程序的说明书。java的说明书通过文档注释来完成。

13、注释符号：/***/；@author作者；@version版本；@param参数；@return返回值。

14、静态代码块。格式：static{静态代码块中的执行语句。}。

15、静态代码块的特点：随着类的加载而执行，只执行一次,并优先于主函数。用于给类进行初始化的。

16、重点：对象的初始化过程：Person p=new Person(“zhangsan”,20);该句话都做了什么事情？A因为new用到了Person。Class。所有会先找到Person。Class文件并加载到内存中。B执行该类中的static代码块，如果有的话，给Person.class类进行初始化。C在堆内存中开辟空间，分配内存地址。D在堆内存中建立对象的特有属性，并进行默认初始化。E对属性进行显示初始化。F对对象进行构造代码块初始化。G对对象进行对应的构造函数初始化。H将内存地址付给栈内存中的p变量。

二、面向对象：单例设计模式

17、设计模式：解决某一类问题最行之有效的方法。java中23中设计模式：单例设计模式：解决一个类在内存只存在一个对象。

18、想要保证对象唯一。1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象。2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

19、这三步怎么用代码体现呢？1，将构造函数私有化。2，在类中创建一个本类对象。3，提供一个方法可以获取到该对象。

20、对于事物该怎么描述，还怎么描述。当需要将该事物的对象保证在内存中唯一时，就将以上的三部加上即可。

21、单例设计方法一：这个是先初始化对象。称为：饿汉式。Single类一进内存，就已经创建好了对象。开发一般用饿汉式：安全、简单。

22、单例设计方法二：对象被调用时，才初始化，也叫做对象的延时加载。称为：懒汉式。Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。

23、记住原则：定义单例，建议使用饿汉式。但面试时：考懒汉式的多。特别是如何解决懒汉式的缺点。2016年01月12日

day07

一、面向对象：继承

1、继承：1，提高代码的复用性。2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。关键字：extends。

2、注意：千万不要为了获取其他类的功能，简化代码而继承。必须是类与类之间有所属关系才可以继续。所属关系is a。

3、java语言中：java只支持单继承，不支持多继承。原因：因为多继承容易带来安全隐患：当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个。但是java保留这种机制，并用另一种体现形式来完成表示，多实现。

4、java支持多层继承。也就是一个继承体系。如何使用一个继承体系中的功能呢？想要使用体系，先查阅父类的描述，因为父类中定义的是该体系中共性功能。通过了解共性功能，就可以知道该体系的基本功能。那么这个体系已经可以基本使用了。

5、那么在具体调用时，要创建最子类的对象，为什么呢？一是因为有可能父类不能创建对象，二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。

6、简单一句话：查阅父类功能，创建子类对象使用功能。

7、this代表本类对象的引用，super代编父类对象的引用。

8、子父类出现后，类成员的特点：类中成员：A，变量。B，函数。C，构造函数。

9、子父类中的变量：如果子类中出现非私有的同名变量时，之类要访问本类中的同名变量，用this子类要访问父类中的同名变量，用super。super的使用和this的使用几乎一致。this代表的是本类对象的引用。super代表的是父类对象的引用。

10、子父类中的函数：当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容。如同父类的函数被覆盖一样。这种情况是函数的另一个特性：重写（覆盖）。

11、修改以往的源码绝对是灾难。

12、单子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致，这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。

13、注意：覆盖：子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。静态只能覆盖静态。

14、记住大家：重载：只看同名函数的参数列表。重写：子父类方法要一模一样。

15、子父类中的构造函数：发现在对子类对象进行初始化时，父类的构造函数也会运行。那是因为子类的构造函数默认第一行有一条隐式的语句super（）；super（）；会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super（）。

16、为什么子类一定要访问父类中的构造函数：因为父类中的数据子类可以直接获取，所有之类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所有之类在对象初始化时，要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。注意：super语句一定一定在子类构造函数第一行。

17、子类的实例化过程。结论：子类的所有的构造函数默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内的每一行都有一句隐式的super（）；当父类中没有空参数的构造函数时，子类必须手动通过super语句或者this语句形式来指定要访问父类中的构造函数。当然：子类的构造函数第一行也可以收到指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。

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

二、面向对象：抽象类

19、当多个类中出现相同功能，但是功能主体不同，这时也可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。20、抽象：看不懂。

21、抽象类的特点：A，抽象方法一定定义在抽象类中。B，抽象方法和抽象类都必须被abstract关键字修饰。C，抽象类不可以被new创建对象。因为调用抽象方法没意义。D，抽象类中的抽象方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用。

22、如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

23、抽象类和一般类没有太大的不同。该如何描述事物，就如何描述事物，只不过，该事物中出现了一些看不懂的东西。这些不确定的部分，也是该事物的功能，需要明确出现，但是无法定义主体。通过抽象方法来表示。

24、抽象类比一般类多了抽象方法（函数）。就是在类中可以定义抽象方法。抽象类不可以实例化（即不可以new）。特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

25、什么是模板方法呢？在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分。那么这时就将不确定的部分暴露出去。由该类的子类去实现。

三、面向对象：接口

26、接口：格式：interface{}。接口中的成员修饰符是固定的。成员常量：public static final；成员函数：public abstract。接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

26、接口：初期理解：可以认为是一个特殊的抽象类。当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。class用于定义类。interface用于定义接口。

27、接口：是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化。否则子类是一个抽象类。接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。用关键字：implements。

28、接口与接口之间支持多继承，类与类之间只支持单继承。

29、接口的特点：接口是对外暴露的规则；接口是程序的功能扩展；接口可以用来多实现；类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口；接口与接口之间可以有继承关系。2016年01月13日

day08

一、面向对象：多态

1、多态的定义：某一类事物的多种存在形态，例：动物中猫，狗。猫这个对象对应的类型是猫类型：猫x=new 猫（）；同时猫也是动物中的一种，也可以把猫称为动物。动物y=new 猫（）；动物是猫和狗具体事物中抽取出来的父类型；父类型引用指向了子类对象。

2、多态的体现：父类的引用指向了自己的子类对象。父类的引用也可以接收自己的子类对象。

3、多态的前提：必须是类与类之间有关系。要么继承，要么实现。通常还有一个前提：存在覆盖。

4、多态的弊端：提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5、多态的好处：多态的出现大大的提高了程序的扩展性。

6、引用数据类型转换：类型提升。向上转型。如果想要调用猫的特有方法时，如何操作？强制将父类的引用，转成子类类型。向下转型。注意：千万不要出现这样的操作，就是将父类对象转成子类类型。我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。多态自始至终都是子类对象在做着变量。

7、关键字：instanceof。判断引用数据类型是否一致。

8、在多态中成员函数的特点：在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。在运行时期：参阅对象所属的类中是否有调用的方法。简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

9、在多态中，成员变量的特点：无论编译和运行，都参考左边（引用型变量所属的类）。

10、object类：是所有对象的直接或者间接父类，传说中的上帝。该类中定义的肯定是所有对象都具备的功能。

11、Object类中已经提供了对对象是否相同的比较方法。如果自定义类中也有比较相同的功能，没有必要重新定义。只要沿袭父类中的功能，建立自己特有的比较内容即可。这就是覆盖。

2016年01月15日

day09

一、面向对象：内部类

1、内部类的定义：将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。

2、内部类访问特点：内部类可以直接访问外部类中的成员，包括私有成员。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式：外部类名.this。而外部类要访问内部类中的成员必须要建立内部类的对象。

3、访问格式：当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。格式：外部类名.内部类名变量名=外部类对象.内部类对象；Outer.Inner in=new Outer().new Inner()。

4、当内部类在成员位置上，就可以被成员修饰符所修饰。比如，private：将内部类在外部类中进行封装。static：内部类就具备了static的特性。当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

5、在外部其他类中，如何直接访问static内部类的非静态成员呢？new Outer.Inner().function()。在外部其他类中，如何直接访问static内部类的静态成员呢？Outer.Inner().function()。

6、注意：当内部类中定义了静态成员，该内部类必须是static的。当外部类中的静态方法访问内部类时，内部类也必须是static的。

7、当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事物在使用外部事物的内容。

8、内部类定义在局部时，1，不可以被成员修饰符修饰；2，可以直接访问外部类中的成员，因为还持有外部类中的引用；但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。

9、匿名内部类：1，匿名内部类其实就是内部类的简写格式。2，定义匿名内部类的前提：内部类必须继承一个类或者实现接口。3，匿名内部类的格式：new 父类或者接口（）{定义子类的内容}。4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。5，匿名内部类中定义的方法最好不要超过3个。

二、面向对象：异常

10、异常：异常的体系：Throwable：（Error：通常出现重大问题如：运行的类不存在或者内存溢出等；不编写针对代码对其处理。Exception：在运行时运行出现的一起情况，可以通过try catch finally）。Exception和Error的子类名称都是以父类名作为后缀。

11、异常：就是程序在运行时出现不正常情况。

12、异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述，并进行封装。其实就是java对不正常情况进行描述后的对象体现。

13、对于问题的划分：两种：一种是严重的问题。一种是非严重的问题。对于Error一般不编写针对性的代码对其进行处理。对于严重的，java通过Error类进行描述。对于非严重的，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。

14、无论Error或者Exception都具体有一些共性内容。比如：不正常情况的信息，引发原因等。

15、异常的处理：java提供了特有的语句进行处理。Try{需要被检测的代码；}catch{异常类变量}{处理异常的代码：（处理方式）}finally{一定会执行的语句；}。

15、throws Exception//在功能上通过throws的关键字声明了该功能有可能会出现问题。在函数上声明异常。便于提高安全性，让调用者进行处理。不处理编译失败。

16、对多异常的处理。1，声明异常时，建议声明更为具体的异常。这样处理得可以更具体。2，对声明几个异常，就对应有几个catch块。不要定义多余的catch块。如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。

17、建议在进行catch处理时，catch中一定要定义具体处理方式。不要简单定义一句 e.printStackTrace()，也不要简单的就书写一条输出语句。

18、自定义异常：因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。所有对于这些特有的问题可以按照java的对问题封装的思想。将特有的问题，进行自定义的异常封装。

19、当在函数内部出现了throw抛出了异常对象，那么就必须要给对应的处理动作。要么在内部try catch处理。要么在函数上声明让调用者处理。20、如何定义异常信息呢？因为父类中已经把异常信息的操作都完成了。所有子类只要在构造时，将异常信息传递给父类通过super语句。那么就可以直接通过getMessage方法获取自定义的异常信息。

21、自定义异常：必须是自定义类继承Exception。继承Exception原因：异常体系有一个特点：因为异常类和异常对象都被抛出。他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。

22、只有这个体系中的类和对象才可以被throws和throw操作。

23、throws和throw的区别：throws使用在函数上。throw使用在函数内。throws后面跟的异常类。可以跟多个。用逗号隔开。throw后跟的是异常对象。

24、Exception中有一个特殊的子类异常RuntimeException运行时异常。如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。如果在函数上声明了该异常。调用者可以不用进行处理，编译一样通过。

25、之所以不用在函数声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序。对代码进行修正。

26、自定义异常时：如果该异常的发生，无法在继续进行运算，就让自定义异常继承RuntimeException。

27、对于异常分两种：1，编译时被检测的异常。2，编译时不被检测的异常（运行时异常，RuntimeException以及其子类）。

2016年01月16日

day10

一、面向对象：异常

1、finally中存放的是一定会被执行的代码。

2、finally代码块：定义一定执行的代码。通常用于关闭资料。

3、记住一点：catch是用于处理异常。如果没有catch就代表没有被处理过，如果该异常时检测时的异常，就必须声明出去。

4、异常在子父类覆盖中的体现：A，子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。B，如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。C，如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常。就必须要进行try处理。绝对不能抛。

5、异常：是什么？是对问题的描述，将问题进行对象的封装。

6、异常体系：Throwable：|--Error；|--Exception（|--RuntimeException）。

7、异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。也就是说可以被throw和throws关键字所操作。只有异常体系具备这个特点。

8、throw和throws的用法：throw定义在函数内，用于抛出异常对象。throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。

9、当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，都在编译失败。注意：RuntimeException除外。也就是说，函数内如果抛出的RuntimeException异常，函数上可以不用声明。

10、如果函数声明了异常，调用者需要进行处理。处理方法可以throws和try。

11、异常有两种：编译时被检测异常：该异常在编译时，如果没有处理（没有抛也没有try），编译失败。该异常被标识，代表着可以被处理。运行时异常（编译时不检测）：在编译时，不需要处理，编译器不检查。该异常的发生，建立不处理，让程序停止。需要对代码进行修正。

12、异常处理语句：try（需要被检测的代码；）catch（处理异常的代码；）finally（一定会执行的代码；）。有三种结合格式：try catch；try finally；try catch finally。注意：A，finally中定义的通常是关闭资源代码。因为资源必须释放。B，finally只有一种情况不会执行。当执行到System.exit(0);finally不会执行。

13、自定义异常：定义类继续Exception或者RuntimeException。A，为了让该自定义类具备可抛性。B，让该类具备操作异常的共性方法。当要定义自定义异常的信息时，可以使用父类已经定义好的功能。异常异常信息传递给父类的构成函数。class MyException extends Exception{MyException(String message){super(message);}}。

14、自定义异常：按照java的面向对象思想，将程序中出现的特有问题进行封装。

15、异常的好处：A，将问题进行封装。B，将正常流程代码和问题处理代码相分离，方便于阅读。

16、异常的处理原则：A，处理方式有两种：try或者throws。B，调用到抛出异常的功能时，抛出几个，就处理几个。一个try对应多个catch。C，多个catch，父类的catch放到最下面。D，catch内需要定义针对性的处理方式。不要简单的定义printStackTrace,输出语句。也不要不写。当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。

17、异常的注意事项：在子父类覆盖时：A，子类抛出的异常必须是父类异常的子类或者子集。B，如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。

二、面向对象：包

18、包（package）：对类文件进行分类管理。给类提供多层命名空间。写在程序文件的第一行。类名的全称的格式是：包名.类名。包也是一种封装形式。

19、关键字protected：/*保护*/权限。权限修饰符。可用于修饰包里的父类。

20、总结：包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰。不同包中的子类还可以访问直接父类中被protected权限修饰的成员。

21、包与包之间可以使用的权限只有两种，public protected。

22、public

protected

default

private 同一个类中可以可以可以可以 同一个包中可以

可以可以 不可以 子类可以

可以不可以不可以 不同包中 可以不可以不可以不可以。

23、为了简化类名的书写，使用一个关键字import。import导入的是包中的类。建议，不要写通配符*，需要用到包中的哪个类，就导入哪个类。

24、建议定义包名不要重复，可以使用url来完成定义，url是唯一的。

25、jar包：java的压缩包：方便项目的携带。方便于使用，只要在classpath设置jar路径即可。数据库驱动，SSH框架等都以jar包体现的。2016年01月17日

day11

一、多线程：概述

1、进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。

2、线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。一个进程中至少有一个线程。

3、Java VM 启动的时候会有一个进程java.exe。该进程中至少有一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称之为主线程。扩展：其实更细节说明jvm，jvm启动不止一个线程，还有负责垃圾回收机制的线程。

4、如何在自定义的代码中，自定义一个线程呢？通过对API的查找，java已经提供了对线程这类事物的描述。就是Thread类。

5、创建线程的第一种方式：继承Thread类。步骤：1，定义类继承Thread。2，复写Thread类中的run方法。目的：将自定义代码存储在run方法中，让线程运行。3，调用线程的start方法，该方法有两个作用：启动线程；调用run方法。

6、发现运行结果每一次都不同：因为多个线程都获取cpu的执行权。cpu执行到谁，谁就运行。明确一点，在某一时刻，只能有一个程序在运行。（多核除外）cpu在做着快速的切换，以达到看上去是同时运行的效果。我们可以形象把多线程的运行形容为在互相抢夺cpu的执行权。这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长，cpu说了算。

7、为什么要覆盖run方法呢？Thread类用于描述线程。该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。也就是说Thread类中的run方法，用于存储线程要运行的代码。

8、原来线程都有自己默认的名称。Thread-编号。该编号从0开始。static Thread currentThread()：获取当前线程对象。getName()：获取线程名称。设置线程名称：setName或者构造函数。

9、创建线程的第二种方式：实现Runnable接口。

步骤：1，定义类实现Runnable接口。2，覆盖Runnable接口中的run方法。目的：将线程要运行的代码存放在run方法中。3，通过Thread类建立线程对象。4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。为什么要将Runnable接口的子类对象传递给Thread的构造函数？因为，自定义的run方法所属的对象时Runnable接口的子类对象。所有要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

10、实现方式和基础方法有什么区别呢？实现方式好处：避免了单继承的局限性。在定义线程时，建议使用实现方式。两种方式区别：继承Thread：线程代码存放在Thread子类run方法中。实现Runnable：线程代码存放在接口的子类的run方法中。

二、多线程：同步

11、多线程的运行出现了安全问题：问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，汗没有执行完，另一个线程参与进来执行。导致共享数据的错误。解决办法：对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程过，其他线程不可以参与执行。java对于多线程的安全问题提供了专业的解决方式。就是同步代码块。synchronized(对象){需要被同步的代码；}。

12、对象如同锁。持有锁的线程可以在同步中执行。没有锁的线程即使获取了cpu的执行权，也进不去，因为没有获取锁。

13、同步的前提：1，必须要有两个或者两个以上的线程。2，必须是多个线程使用同一个锁。必须保证同步中只能有一个线程在运行。

14、好处：解决了多线程的安全问题。弊端：多个线程需要判断锁，较为消耗资源。

15、多线程安全问题：如何找到问题：1，明确哪些代码是多线程运行代码。2，明确共享数据。3，明确多线程运行代码中哪些语句是操作共享数据的。

16、同步函数：将关键字synchronized放到函数名称前。即把synchronized当作修饰符使用。

17、同步函数用的是哪一个锁呢？函数需要被对象调用。那么函数都有一个所属对象引用。就是this。所有同步函数使用的锁是this。

18、如果同步函数被静态修饰后，使用的锁是什么呢？通过验证，发现不再是this。因为静态方法中也不可以定义this。静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。类名.class 该对象的类型是Class。静态的同步方法，使用的锁是该方法所在类的字节码文件对象。类名.class。

19、死锁：同步中嵌套同步。而锁却不同。

2016年01月18日

day12

一、多线程：线程间通信

1、wait()，notify()，notifyALL()，用来操作线程为什么定义在了Object类中？这些方法存在于同步中。使用这些方法时必须要标识所属的同步的锁。锁可以是任意对象，所以任意对象调用的方法一定定义Object类中。

2、wait()和sleep()有什么区别？wait()：释放资源，释放锁。sleep()：释放资源，不释放锁。

3、wait：notify：notifyALL：都被使用在同步中，因为要对持有监视器（锁）的线程操作。所有要使用在同步中，因为只有同步才具有锁。

4、为什么这些操作线程的方法要定义在Object类中呢？因为这些方法在操作同步中线程时，都必须要标识他们所操作线程只有的锁。只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。而锁可以是任意对象，所有可以被任意对象调用的方法定义在Object类中。

5、JDK1.5 中提供个多线程升级解决方案。将同步synchronized替换成现实Lock操作。将Object中的wait，notify，notifyAll，替换了condition对象。该对象可以Lock锁，进行获取。

二、多线程：其他操作

6、停止线程：A：定义循环结束标记：因为线程运行代码一般都是循环，只要控制了循环即可。B：使用interrupt（中断）方法：该方法时结束线程的冻结状态，使线程回到运行状态中来。注意：stop方法已经过时不再使用。

7、如何停止线程？只有一种，run方法结束。开启多线程运行，运行代码通常是循环结构。只要控制住循环，就可以让run方法结束，也就是线程结束。特殊情况：当线程处于了冻结状态。就不会读取到标记。那么线程就不会结束。

8、当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除。强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。Thread类中提供该方法：interrupt方法。

9、join方法：当A线程执行到了B线程的.join()方法时，A就会等待。等B线程都执行完，A才会执行。join可以用来临时加入线程执行。

2016年01月19日

day13

一、String类：概述

1、String类：字符串是一个特殊的对象。字符串一旦初始化就不可以被改变。String str=”abc”；String str1=new String(“abc”)。Str和str1的区别：str在内存中有一个对象。Str1在内存中有两个对象。

二、***重点：String类：常见操作

常见的操作有哪些？ “abcd” 1，获取。

1.1 字符串中包含的字符数，也就是字符串的长度。

int length()：获取长度。

1.2 根据位置获取位置上某个字符。

char charAt(int index)：获取位置上某个字符。

1.3 根据字符获取该字符在字符串中位置。

int indexOf(int ch)：获取该字符在字符串中位置。返回的是ch在字符串中第一次出现的位置。

int indexOf(int ch,int fromIndex)：从fromIndex指定位置开始，获取ch在字符串中出现的位置。

int indexOf(String str)：返回的是str在字符串中第一次出现的位置。

int indexOf(String str,int fromIndex)：从fromIndex指定位置开始，获取str在字符串中出现的位置。

int lastIndexOf(int ch)：反向索引。2，判断。

2.1 字符串中是否包含某一个子串。

boolean contains(str);

特殊之处：indexOf(str)：可以索引str第一次出现位置，如果返回-1,表示该str不在字符串中存在。

2.2 2.3 2.4 2.5 2.6 所以，也可以用于对指定判断是否包含。

if(str.indexOf(“aa”)!=-1)而且该方法既可以判断又可以获取出现的位置。字符串是否有内容。

boolean isEmpty(str)：原理就是判断长度是否为0。字符串是否是以指定内容开头。boolean startsWith(str);字符串是否是以指定内容结尾。boolean endsWith(str);判断字符串的内容是否相同。复写了Object类中的equals方法。boolean equals(str);判断内容是否相同，并忽略大小写。boolean equalsIgnoreCass();3，转换。

3.1 将字符数组转成字符串。

构造函数：String(char[])

String(char[],offset,count)：将字符数组中的一部分转成字符串。

静态方法：static String copyValueOf(char[]);

static String copyValueOf(char[] data,int offset,int count);

static String valueOf(char[]);

3.2 将字符串转成字符数组。//重点**。

char[] toCharArray();3.3 将字节数组转成字符串。

String(byte[])String(byte[],offset,count)：将字节数组中的一部分转成字符串。3.4 将字符串转成字节数组。

byte[] getBytes();3.5 将基本数据类型转成字符串。

static String valueOf(int)

static String valueOf(double)

//3+“";//String.valueOf(3);

特殊：字符串和字节数组在转换过程中，是可以指定编码表的。4，替换。

String replace(oldchar,newchar);5，切割。

String[] split(regex);6，子串。获取字符串中的一部分。

String substring(begin);String substring(begin,end);7，转换，去除空格，比较。

7.1 将字符串转成大写或者小写。

String toUpperCase();

String toLowerCase();7.2 将字符串两端的多个空格去除。

String trim();7.3 对两个字符串进行自然顺序的比较。

int compareTo(string);

三、String类：StringBuffer

8、StringBuffer类：字符串的注组成原理就是通过该类实现的。StringBuffer可以对字符串内容进行增删。StringBuffer是一个容器。很多方法与String相同。StringBuffer是可变长度的。

9、StringBuffer是字符串缓冲区。是一个容器。

10、缓冲区的特点：1，而且长度是可变化的。2，可以直接操作多个数据类型。3，最终会通过toString方法变成字符串。

11、StringBuffer常见操作： C create U update R read D delete 1，存储。

StringBuffer append()：将指定数据作为参数添加到已有数据的结尾处。

StringBuffer insert(index,数据)：可以将数据插入到指定index位置。2，删除。

StringBuffer delete(start,end)：删除缓冲区中的数据，包含start，不包含end。

StringBuffer deleteCharAt(index)：删除指定index位置的字符。3，获取。

char charAt(int index);int indexOf(String str);int lastIndexOf(String str);int length();String substring(int start,int end);4，修改。

StringBuffer replace(start,end,string);void setCharAt(int index,char ch);5，反转。

StringBuffer reverse();6，将缓冲区中指定数据存储到指定字符数组中。

void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)。

12、JDK1.5版本之后出现了StringBuilder。

StringBuffer是线程同步。单线程使用StringBuffer效率较低。多线程使用StringBuffer保证了安全性。

StringBuilder是线程不同步。单线程使用StringBuilder提高了效率。多线程使用StringBuilder可能存在安全问题，但可以通过自定义锁来解决安全问题。以后开发，建议使用StringBuilder。

13、升级三个因素：1，提高效率。2，简化书写。3，提高安全性。

四、基本数据类型对象包装类

14、基本数据类型对象包装类的最常见作用：就是用于基本数据类型和字符串类型之间做转换。

15、数据类型转换：

A：基本数据类型转成字符串。

基本数据类型+”“ 基本数据类型.toString(基本数据类型值);如：Integer.toString(34);//将34整数变成”34“。B：字符串转成基本数据类型。

静态：基本数据类型包装类.parseInt(字符串);如：xxx a=Xxx.parseXxx(String);

int a=Integer.parseInt(”123“);

double d=Double.parseDouble(”12.23“);

boolean b=Boolean.parseBoolean(”true“);非静态：

Integer i=new Integer(”123");

int num=i.intValue();C：十进制转成其他进制。

toBinaryString();toHexString();toOctalString();D：其他进制转成十进制。

parseInt(string,radix)。

2016年01月22日

day14

一、集合框架：概述

1、集合类：为什么会出现集合类？面向对象语言对事物的体现都是以对象的形式，所有为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

2、数组和集合类同是容器，有何不同？数组虽然也可以存储对象，但长度是固定的；集合长度是可变的，数组中可以存储基本数据类型，集合只能存储对象。

3、集合类的特点：集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

4、为什么会出现这么多的容器呢？因为每一个容器对数据的存储方式有所不同。这个存储方式称之为：数据结构。

5、add方法的参数类型是Object。以便于接收任意类型对象。集合中存储的都是对象的引用（地址）。

6、什么是迭代器呢？其实就是集合的取出元素的方式。

二、集合框架：List类

7、List: 特有方法。凡是可以操作角标的方法都是该体系特有的方法。增

add(index,element);addAll(index,Collection);删

remove(index);改

set(index,element);查

get(index);subList(from,to);listIterator();

8、List集合特有的迭代器。ListIterator是Iterator的子接口。在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所有，在迭代器时，只能用迭代器的方法操作元素，可以Iterator方法时优先的，只能对元素进行判断，取出，删除的操作，如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。该接口只能通过List集合的ListIterator方法获取。

9、Collection |--List:元素是有序的，元素可以重复。因为该集合体系有索引。

|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。

|--LinkedList:底层使用的是链表数据结构。特点：增删速度很快，查询速度稍慢。

|--Vector:底层是数据数据结构。线程同步。被ArrayList替代了。

|--Set:元素是无序的，元素不可以重复。

10、枚举就是Vector特有的取出方式。发现枚举和迭代器很像。其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所有被迭代器取代了。枚举郁郁而终了。

11、LinkedList：特有方法： addFirst();addLast();

getFirst();getLast();获取元素，但是不删除元素。如果集合中没有元素，会出现NoSuchElementException。

removeFirst();removeLast();获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException。

在JDK1.6出现了替代方法。offerFirst();offerLast();

peekFirst();peekLast();获取元素，但是不删除元素。如果集合中没有元素，会返回null。

pollFirst();pollLast();获取元素，但是元素被删除。如果集合中没有元素，会返回null。

三、集合框架：Set类

12、HaseSet是如何保证元素唯一性的呢？是通过元素的两个方法，hashCode和equals来完成。如果元素的hashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。

13、注意：对于判断元素是否存在，以及删除操作，依赖的方法时元素的hashcode和equals方法。

2016年1月23日

day15

一、集合框架：Set类

1、Set：无序，不可以重复元素。

|--HashSet：数据结构是哈希表。线程是非同步的。

保证元素唯一性的原理：判断元素的hashCode值是否相同。

如果相同，还会继续判断元素的equals方法，是否为true。

|--TreeSet：可以对Set集合中的元素进行排序。

底层数据结构是二叉树。

保证元素唯一性的依据：

compareTo方法和return 0。

2、TreeSet排序的第一种方式：让元素自身具备比较性。元素需要实现comparable接口，覆盖comparaeTo方法。这种方式也称为元素的自然顺序，或者默认顺序。

3、TreeSet排序的第二种方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。

4、当元素自身不具备比较性，或者具备的比较性不是所需要的。这时需要让容器自身具备比较性。定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

5、当两种排序都存在时，以比较器为主。定义一个类，实现Comparator接口，覆盖compare方法。

二、集合框架：泛型

6、泛型：JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。

7、泛型的好处：好处：1，将运行时期出现问题ClassCastException，转移到了编译时期。方便于程序员解决问题。让运行时期问题减少。更加安全。2，避免了强制转换麻烦。

8、泛型格式：通过<>来定义要操作的引用数据类型。在使用java提供的对象时，什么时候写泛型呢？通常在集合框架中很常见。只要见到<>就要定义泛型。其实<>就是用来接收类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到<>即可。

9、什么时候定义泛型类？当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展。现在定义泛型来完成扩展。

10、泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

11、特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。

12、? 通配符。也理解为占位符。泛型的限定：

？ extends E：可以接收E类型或者E的子类型。上限。？ super E：可以接收E类型或者E的父类型。下限。

2016年01月24日

day16

一、集合：Map概述

1、Map集合：该集合存储键值对。一对一对往里存，而且要保证键的唯一性。

2、Map框架：

1，添加。

put(K key,V value)

putAll(Map m)2，删除。

clear()

remove(Object key)3，判断。

containsValue(Object value)

containsKey(Object key)

isEmpty()4，获取。

get(Object key)

size()

values()

entrySet()

keySet()

3、Map |--HashTable：底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步的。JDK1.0。效率低。

|--HashMap：底层是哈希表数据结构，允许使用null键和null值，该集合是不同步的。JDK1.2。效率高。|--TreeMap：底层是二叉树数据结构，线程不同步，可以用于给map集合中的键进行排序。

4、和Set很像。其实大家，Set底层就是使用了Map集合。

5、map集合的两种取出方式：1，keySet：将map中所有的键存入到Set集合。因为Set具备迭代器。所以可以迭代方式取出所有的键，在根据get方法，获取每一个键对应的值。Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。2，Set> entrySet：将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry。

6、Map.Entey 其实Entry也是一个接口，它是Map接口中的一个内部接口。

7、什么时候使用map集合呢？当数据之间存在映射关系时，就要先想到map集合。

8、map扩展知识：map集合被使用是因为具备映射关系。

2016年01月26日

day17

一、集合：Collections

1、fill方法可以将list集合中所有元素替换成指定元素。

二、集合：Arrays

2、Arrays：用于操作数组的工具类。里面都是静态方法。

3、asList：将数组变成list集合。

4、把数组变成list集合有什么好处？可以使用集合的思想和方法来操作数组中的元素。注意：将数组变成集合，不可以使用集合的增删方法。因为数据的长度是固定的。如果你增删，那么会发生UnsupportedOperationException。

5、数组变集合：如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

6、集合变数组：指定类型的数组到底要定义多长呢？当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size。当指定类型的数组长度大于了集合的size，就不会新创建数组，而是使用传递进来的数组。所以创建一个刚刚好的数组最优。

7、为什么要讲集合变数组？为了限定对元素的操作。不需要进行增删了。

8、高级for循环：格式：for（数据类型变量名：被遍历的集合（Collection）或者数组）｛｝。

9、高级for循环、迭代器、ListIterator的区别：

高级for循环对集合进行遍历。只能获取集合元素，但是不能对集合进行操作。迭代器除了遍历，还可以进行remove集合中元素的动作。

如果使用ListIterator，还可以在遍历过程中对集合进行增删改查的操作。

10、传统for和高级for有什么区别呢？高级for有一个局限性：必须有被遍历的目标。建议在遍历数组的时候，还是希望使用传统for。因为传统for可以定义角标。

11、JDK1.5版本出现的新特性：可变参数：其实就是上一种数组参数的简写形式。不用每一次都手动的建立数组对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。

12、方法的可变参数。在使用时注意：可变参数一定要定义在参数列表最后面。

13、import static：静态导入：例如：import static java.lang.System.*;//导入了System类中所有静态成员。注意：当类名重名时，需要制定具体的包名。当方法重名时，指定具备所属的对象或者类。

2016年01月28日

day18

一、其他对象：System

1、System:类中的方法和属性都是静态的。out:标准输出，默认是控制台。int:标准输入，默认是键盘。描述系统一些信息。

2、获取系统属性信息：Properties getProperties()。因为Properties是Hashtable的子类，也就是Map集合的一个子类对象。那么可以通过map的方法取出该集合中的元素。该集合中存储都是字符串。没有泛型定义。

3、Runtime对象：该类并没有提供构造函数。说明不可以new对象。那么会直接想到该类中的方法都是静态的。发现该类中还有非静态方法。说明该类肯定会提供方法获取本类对象。而且该方法是静态的，并返回值类型是本类类型。由这个特点可以看出该类使用了单例设计模式完成。该方式的static Runtime getRuntime()。

4、Math类：ceil方法：返回大于指定数据的最小整数。floor方法：返回小于指定数据的最大整数。round方法：四舍五入。pow方法：幂运算。random：返回0-1之间的随机数。

二、IO流：概述

5、IO(Input Outpu)流：IO流用来处理设备之间的数据传输。Java对数据的操作是通过流的方式。Java用于操作流的对象都在IO包中。流按操作数据分为两种：字节流与字符流。流按流向分为：输入流，输出流。

6、IO流常用基类：字节流的抽象基类：InputStream，OutputStream。字节流的抽象基类：Reader，Writer。注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀（如：InputStream的子类FilelnputStream，如：Reader的子类FileReader。）。

7、字符流和字节流：字节流两个基类：InputStream

OutputStream。字符流两个基类：Reader Writer。先学习字符流的特点：既然IO流是用于操作数据的，那么数据的最常见体现形式是：文件。2016年01月30日

day19

一、IO流：Buffered缓冲区

1、字符流的缓冲区：缓冲区的出现提高了对数据的读写效率。对应类：BufferedWriter；BufferedReader。缓冲区要结合流才可以使用。在流的基础上对流的功能进行了增强。

2、缓冲区的出现是为了提高流的操作效率而出现的。所以在创建缓冲区之前，必须要先有流对象。该缓冲区中提供了一个跨平台的换行符。newLine()。

3、字符读取流缓冲区：该缓冲区提供了一次读一行的方法readLine()，方便于对文本数据的获取。当返回null时，表示读到文件末尾。

4、readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。

5、装饰设计模式：当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。那么自定义的该类称为装饰类。

6、装饰类通常会通过构造方法接收被装饰的对象。并基于被装饰的对象的功能，提供更强的功能。

7、装饰模式比继承要灵活，避免了继承体系臃肿。而且降低了类与类之间的关系。装饰类因为是增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。所以装饰类和被装饰类通常是都属于一个体系中的。

二、IO流：字节流

8、字符流： FileReader FileWriter BufferedReader BufferedWriter 字节流：

InputStream

OutputStream BufferedInputStream

BufferedOutputStream

9、流操作的基本规律：

最痛苦的就是流对象有很多，不知道该用哪一个。通过两个明确来完成。1，明确源和目的。

源：输入流。InputStream Reader。

目的：输出流。OutputStream Writer。2，明确操作的数据是否是纯文本。

是：字符流。

不是：字节流。

3，当体系明确后，再明确要使用哪个具体的对象。

通过设备来进行区分：

源设备：内存，硬盘，键盘。目的设备：内存，硬盘，控制台。

2016年01月31日

day20

一、IO流：File类

1、File类：用来将文件或者文件夹封装成对象。方便对文件与文件夹进行操作。File对象可以作为参数传递给流的构造函数。了解File类中的常用方法。

2、File类常见方法： 1，创建。

boolean createNewFile()；在指定位置创建文件，如果该文件已经存在，则不创建，返回false。

和输出流不一样，输出流对象一建立创建对象。而且文件已经存在，会覆盖。

boolean mkdir();创建一级文件夹。

boolean mkdirs();创建多级文件夹。2，删除。

boolean delete();删除失败返回false。

void deleteOnExit();在程序退出时删除指定文件。3，判断。

boolean exists();文件是否存在。

boolean isFile();判断是否是文件。

boolean isDirectory();判断是否是文件夹。

boolean isHidden();判断是否是隐藏文件。

boolean isAbsolute();判断是否是绝对路径。4，获取信息。

String getName();获取文件名称。

String getPath();获取文件相对路径。

String getParent();该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。

如果相对路径中有上一层目录那么该目录就是返回结果。

getAbsolute();获取文件绝对路径。

lastModified();返回文件最后一次被修改的时间。

length()。

3、因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。在列出过程中出现的还是目录的话，还可以再次调用本功能。也就是函数自身调用自身。这种表现形式，或者编程手法，称为递归。

递归要注意：1，限定条件。2，要注意递归的次数。尽量避免内存溢出。

4、练习：将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。建立一个java文件列表文件。思路：1，对指定的目录进行递归。2，获取递归过程所有的java文件的路径。3，将这些路径存储到集合中。4，将集合中的数据写入到一个文件中。

二、IO流：Properties类

5、Properties是hashtable的子类。也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。是集合中和IO技术相结合的集合容器，该对象的特点：可以用于键值对形式的配置文件。

6、那么在加载数据时，需要数据有固定格式：键=值。

三、IO流：其他类

7、打印流：PrintWriter与PrintStream：可以直接操作输入流和文件。打印流：

该流提供了打印方法，可以将各种数据类型的数据都原样打印。字节打印流：PrintStream 构造函数可以接收的参数类型： 1，file对象。File。

2，字符串路径。String。

3，字节输出流。OutputStream。字符打印流：PrintWriter 构造函数可以接收的参数类型： 1，file对象。File。

2，字符串路径。String。

3，字节输出流。OutputStream。4，字符数出来：Writer。

8、序列流：SequenceInputStream：对多个流进行合并。

9、操作对象：ObjectInputStream与ObjectOutputStream：被操作的对象需要实现Serializable（标记接口）。

2016年02月01日

day21

一、IO流：其他类

1、RandomAccessFile：随机访问文件，自身具备读写的方法。通过skipBytes(int x),seek(int x)来达到随机访问。

2、管道流：PipedInputStream和PipedOutputStream：输入输出可以直接进行连接，通过结合线程使用。

3、RandomAccessFile：该类不算是IO体系中子类。而是直接继承自Object。但是它是IO包中成员。因为它具备读和写功能。内部封装了一个数组，而且通过指针对数据的元素进行操作。可以通过getFilePointer获取指针位置。同时可以通过seek改变指针的位置。其实完成读写的原理就是内部封装了字节输入流和输出流。通过构造函数可以看出，该类只能操作文件。而且操作文件还有模式：只读r，读写rw等。

4、如果模式为只读r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。如果模式为读写rw。操作的文件不存在，会自动创建。如果存在则不会覆盖。

5、IO包中的其他类：

操作基本数据类型：DataInputStream与DataOutputStream。

操作字节数组：ByteArrayInputStream与ByteArrayOutputStream。操作字符数组：CharArrayReader与CharArrayWrite。操作字符串：StringReader与StringWriter。

6、用于操作字节数组的流对象。

ByteArrayInputStream ：在构造的时候，需要接收数据源，而且数据源是一个字节数组。ByteArrayOutputStream ：在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。这就是数据目的地。因为这两个流对象都操作的数组，并没有使用系统资源。所以，不用进行close关闭。在流操作规律讲解时： 源设备：

键盘 System.in，硬盘 FileStream，内存 ArrayStream。目的设备：

控制台 System.out，硬盘 FileStream，内存 ArrayStream。用流的读写思想来操作数组。

二、IO流：字符编码

7、字符编码：字符流的出现为了方便操作字符。更重要是的加入了编码转换。通过子类转换流来完成：InputStreamReader；OutputStreamWriter。在两个对象进行构造的时候可以加入字符集。

8、编码表的由来：计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机，让它可以识别各个国家的文字。就将各个国家的文字用数字来表示，并一一对应，形成一张表。这就是编码表。

9、常见的编码表：

ASCII：美国标准信息交换码。用一个字节的7位可以表示。ISO8859-1：拉丁码表。欧洲码表。用一个字节的8位表示。GBK2312：中国的中文编码表。用两个字节的16位来表示。GBK：中国的中文编码表升级，融合了更多的中文文字符号。

Unicode：国际标准码，融合了多种文字。所有文字都用两个字节来表示，Java语言使用的就是Unicode。

UTF-8：最多用三个字节来表示一个字符。„„

10、编码：字符串变成字节数组。解码：字节数组变成字符串。String-->byte[];str.getBytes(charsetName);byte[]-->String;new String(byte[],charsetName)。2016年02月02日

day22

一、GUI：概述

1、GUI：图形用户界面。

GUI：Graphical User Interface（图形用户接口）。用图形的方式，来显示计算机操作的界面，这样更方便跟直观。

CLI：Command line User Inteface（命令行用户接口）。就是常见的Dos命令行操作。需要记忆一些常用的命令，操作不直观。

举例：比如：创建文件夹，或者删除文件夹等。

Java为GUI提供的对象都存在java.Awt和javax.Swing两个包中。

2、Awt与Swing：

java.Awt：Abstract Window ToolKit（抽象窗口工具包），需调用本地系统方法实现功能。属重量级控件。

javax.Swing：在Awt的基础上，建立的一套图形界面系统，其中提供了更多的组件，而且完全由Java实现。增强了移植性，属轻量级控件。

3、继承关系图：

4、布局管理器：

容器中的组件的排放方式，就是布局。常见的布局管理器：

FlowLayout（流式布局管理器）

从左到右的顺序排列。

Panel默认的布局管理器。BorderLayout（边界布局管理器）

东，南，西，北，中。

Frame默认的布局管理器。GridLayout（网格布局管理器）

规则的矩阵。

CardLayout（卡片布局管理器）

选项卡。

GridBagLayout（网格包布局管理器）

非规则的矩阵。

5、创建图形化界面： 1，创建frame窗体。

2，对窗体进行基本设置。

比如：大小、位置、布局。3，定义组件。

4，将组件通过窗体的add方法添加到窗体中。5，让窗体显示，通过setVisible(true)来完成。

6、建立一个简单的窗体：

Container常用子类：Window Panel（面板，不能单独存在。）Window常用子类：Frame Dialog。简单的窗体创建过程：

Frame f = new Frame(“my window”);f.setLayout(new FlowLayout());f.setSize(500,400);//设置窗体大小。

f.setLocation(300,200);//设置窗体出现在屏幕的位置。f.setVisible(true)。

二、GUI：事件监听机制

7、事件监听机制组成：事件源（组件）；事件（Event）；监听器（Listener）；事件处理（引发事件后处理方式）。

8、事件监听机制流程图：

9、事件监听机制的特点： 1，事件源。2，事件。3，监听器。4，事件处理。

事件源：就是awt或者swing包中的那些图形界面组件。事件：每一个事件源都有自己特有的对应事件和共性事件。

监听器：将可以触发某一个事件的动作（不止一个动作）都已经封装到了监听器中。以上三者，在java中都已经定义好了。直接获取其对象来用就可以了。我们要做的事情是，就是对产生的动作进行处理。

2016年02月03日

day23

一、网络编程：概述

1、网络编程：

网络模型：OSI参考模型。TCP/IP参考模型。网络通讯要素：IP地址。端口号。传输协议。

2、网络参考模型：

3、网络通讯要素： IP地址：网络中设备的标识。不易记忆，可用主机名。本地回环地址：127.0.0.1主机名：localhost。端口号：用于标识进程的逻辑地址，不同进程的标识。有效端口：0~65535，其中0~1024系统使用或保留端口。

传输协议：通讯的规则。常见协议：TCP，UDP。

4、UDP和TCP： UDP：

将数据及源和目的封装成数据包中，不需要建立连接。每个数据报的大小在限制在64k内。因无连接，是不可靠协议。不需要建立连接，速度快。

特点：面向无连接。数据会被封包。不可靠。速度快。比如：聊天，视频会议，桌面共享。TCP：

建立连接，形成传输数据的通道。

在连接中进行大数据量传输。

通过三次握手完成连接，是可靠协议。

必须建立连接，效率会稍低。

特点：面向连接。可大数据量传输。比较可靠。稍微有点慢。比如：下载。

5、Socket：

Socket就是为网络服务提供的一种机制。通信的两端都有Socket。

网络通信其实就是Socket间的通信。数据在两个Socket间通过IO传输。

二、网络编程：UDP

6、UDP传输：

DatagramSocket与DatagramPacket。建立发送端，接收端。建立数据包。

调用Socket的发送接收方法。关闭Socket。

发送端与接收端是两个独立的运行程序。

三、网络编程：TCP

7、TCP传输：

Socket和ServerSocket。建立客户端和服务器端。

建立连接后，通过Socket中的IO流进行数据的传输。关闭socket。

同样，客户端与服务器端是两个独立的应用程序。2016年02月04日

day24

一、网络编程：浏览器客户端

1、视频演示讲解。

2016年02月6日

day25

一、正则表达式

1、正则表达式：符合一定规则的表达式。作用：用于专门操作字符串。

2、正则表达式：符合一定规则的表达式。

作用：用于专门操作字符串。

特点：用一些特定的符号来表示一些代码操作。这样就简化了书写。

所以学习正则表达式，就是在学习一些特殊符号的使用。

好处：可以简化对字符串的复杂操作。

弊端：符号定义越多，正则越长，阅读性越差。

3、具体操作功能：

1，匹配：String matchess();方法。用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false。2，切割：String split();3，替换：String replaceAll();4，获取：将字符串中符合规则的子串取出。

4、获取：操作步骤：

1，将正则表达式封装成对象。

2，让正则对象和要操作的字符串相关联。3，关联后，获取正则匹配引擎。

4，通过引擎对符合规则的子串进行操作，比如取出。

第二篇：JAVA基础知识点总结

1)开发Java语言的公司？ Sun（Sun Microsystems）太阳微电子公司开发 2)

Java的3个版本？

J2SE(Java2 Standard Edition)标准版

J2EE(Java 2 Platform,Enterprise Edition)企业版 J2ME(Java 2 Micro Edition)微小版

在5.0以后新版本中称作：JavaSE JavaEE JavaME 3)

Java语言的几个主要特点？平台无关性：能运行于不同的平台上

安全性：去掉了指针操作，内存由操作系统分配 面向对象：利用类使程序更加利于维护

分布式：可以使用网络文件和使用本机文件一样容易 健壮性：检查程序编译和运行的错误 4)

Java的三大核心机制

虚拟机机制：利用虚拟机解释字节码执行java程序实现跨平台 垃圾收集机制：自动内存回收

代码安全性机制：加载代码后校验代码后再执行代码 第2章Java语言的开发环境 1)

JDK是什么？

JDK(Java Development Kit)Java开发工具包。包括了JRE，是开发Java的人员必备的开发运行Java程序的工具。2)

JRE是什么？

JRE（Java Runtime Environment）Java运行环境，运行JAVA程序所必须的环境的集合，包含JVM标准实现及Java核心类库。3)

JVM是什么？

JVM(Java Virtual Machine)Java虚拟机，它是一个虚构出来的计算机,是通过在实际的计算机上仿真模拟各种计算机功能来实现的。4)

安装JDK的操作系统问题？

必须针对于不同的操作系统下载安装不同的JDK，例如windows下安装针对于windows的JDK，linux下安装针对于linux的JDK。

5)需要配置的相关环境变量？ path：用于搜索外部命令，例如编译程序的javac命令，执行程序的java命令

classpath：用于搜索类，即class文件，例如可以在不同的位置执行类文件 6)

配置环境变量的方式？ 有两种：临时配置和持久配置

临时配置：在命令行下用set 变量名=变量值，仅在当前命令行窗口有效

持久配置：在我的电脑——属性中配置，持久有效 7)可以编写Java程序的常见开发工具？ 记事本，EditPlus，ULTRAEDIT，Eclipse，Jbuilder，NetBeans 8)

Java文件的类型？

有两种：

扩展名为java的文件：是Java源文件，属于编译之前的纯文本文件，存储java源代码。

扩展名为class的文件：是Java类文件，属于编译之后的二进制文件，存储字节码。9)

Java的编译运行原理？

首先编写java源文件，然后编译成class类文件，然后通过虚拟机解释成机器码到硬件执行。

10)Java是编译型语言还是解释型的语言？

既不是完全编译型，也不是完全解释型，是半编译半解释的。第3章Java程序的基本结构 1)

Java语言区分大小写吗？

区分，不管是数据还是标识符或者关键字都区分大小写，例如public不能写成Public，“abc”不能写成“ABC”，int i不能写成INT I等等。2)main方法是作什么用处的？ 这是程序的入口方法，是由虚拟机自动调用的。

3)语句必须用分号结束吗？ 必须的，但是代码块{}可以用分号结束，也可以不用分号结束

4)

Java中有几种注释，各自的功能

有三种：

单行注释//：加在行首只能注释一行 多行注释/* */：注释多行，但不能嵌套使用

文档注释/***/：用于生成HTML形式的文档，需要配合javadoc命令实现 5)Java语言的数据类型是强类型还是弱类型？ 是强类型，意味着每一个变量都必须明确声明数据类型。6)

Java语言中数据类型的划分？有什么区别？ 分成基本类型和引用类型两大类。

基本类型：有8种，只能存储单一的值，不以对象的形式存在引用类型：除了基本类型之外其他的都是引用类型，能够存储复杂数据类型，以对象的形式存在 7)

基本类型都有哪8种类型？ 布尔类型：boolean 占1字节 字符类型：char 占2字节

整型：byte 占1字节 short 占2字节 int 占4字节 long 占8字节

浮点型：float 占4字节double 占8字节 8)

布尔值可不可以用0或者非0数代替？

不可以，布尔值只能是true和false，不能使用数字，这和C语言是不一样的。9)

直接写个整数10默认是什么类型的？

整型的直接量例如10，100等默认的数据类型都是int型 10)如何让一个整型的直接量变成long型的？ 在直接量后面加大写L后者小写l，例如10L 11)整型数据在程序中直接使用可以使用什么进制？ 10进制，8进制，16进制，但不能使用二进制 12)浮点运算在Java中有没有误差？ 有误差，所以精密运算请使用BigDecimal类 13)直接写一个3.14的直接量是什么数据类型的？

是double型，如果想表示是float的3.14必须写成3.14F或者3.14f，double型的3.14也可以写成3.14D 14)char型采取的是什么类型的字符集？

是Unicode全球统一编码，支持任何世界上官方的语言中的字符

15)常见的转义字符有哪些？ 转义序列 名称 b 退格 t 制表 n 换行 r

回车

” 双引号 ’ 单引号 反斜杠

16)常见的Unicode字符对应的编码？

大写的A到Z是对应65到90，小写的a到z是对应97到122，字符0到9是对应48到57

17)空字符是不是用’’（两个并列的单引号）来表示？ 不是，空字符用’u0000’来表示，两个并列的单引号什么也不是。

18)点,分号,花括号的各自的作用?

点的作用有两个：一个是使用类或对象中的成员，用对象.成员，再一个就是包名和子包名之间的分隔符，例如顶层包名.子包名 分号的作用是表示语句结束 花括号的作用是代表一个语句块

19)语句和关键字之间可以有任意的空白吗？ 可以的，例如System.out.println(100);就是正确的语句，但是关键字本身不能加空白或换行

20)标识符是什么？

标识符就是指在程序中给包，类，接口，方法，变量起的名字 21)标识符有什么起名规则？ 1． 应以字母、下划线、美元符开头 2． 后跟字母、下划线、美元符或数字 3． 不能用关键字和保留字

4． 严格区分大小写 5． 名称长度没有限制 22)中文的变量名可以吗？

是可以的，例如 int 数字 = 10;这个语句是正确的。因为java中采取Unicode字符集，所以任何的Unicode中的字符都可以作为标识符的名称，但考虑字符集的支持问题推荐还是使用英文字母命名。

23)关键字和保留字有区别吗？

在1.5后没有区别，都被称作关键字，但是1.5之前认为关键字是在Java中有特殊用途的不允许编程人员擅自改作其他用途，而保留字是在Java中没有特殊用途但不允许编程人员擅自改作其他用途，按此说法goto和const应该是此意义上的保留字。

24)true，false，null可以用作标识符命名吗？

不可以，这3个虽然不是关键字，但都是有特殊用途的值，也不能作为标识符命名

25)一条声明语句可以声明多个变量吗？ 可以的，例如以下声明都是正确的int i;int i,j;int i = 10,j;int i,j = 10;

int i = 10,j = 20;

26)变量在没有赋值的情况下可以使用吗？

不可以，变量没有赋值使用会报出变量未初始化的编译错误。27)常量有什么特点？

在声明变量的时候加上final修饰符即为常量，表示这个变量只能被赋一次值。

28)算数运算符有哪些？ 基本算数运算符有+-* / % ++--

29)单目运算符，双目运算符，三目运算符都是什么意思？ 其实也有叫一元运算符，双元操作符，三元操作符的，指的是

有几个操作数形成一个完整表达式，例如++就是一个单目运算符，只需要一个操作数就可以形成表达式，像i++，而+运算符就是双目运算符，需要两个操作数形成表达式，例如5 + 3，还有三目运算符，例如5 > 3 ? 0 :-1

30)++和--放在前面和放在后面有什么区别？

如果是在一个表达式中，那++放后面表示先运算表达式，然后再进行自增运算，如果在一个表达式中，++放前面，则表示先进行自增运算然后在运算表达式。--同样道理。例如： int i = 10;int j = i ++;//先进行赋值运算然后再进行自增运算j的结果是10

int i = 10;

int j = ++ i;//先进行自增运算然后再进行赋值运算

j的结果是11

31)-5 % 2等于几，5 %-2等于几？

-5 % 2等于-1，5%-2等于1，运算得到是正数还是负数取决于第一个操作数的符号 32)5 / 2 结果是不是2.5？

不是，是2，因为5和2都是int类型，所以不可能得到double型的结果。

33)比较运算符有哪些？

有><>=<===!= 六项基本比较运算 34)任何数据类型都可以使用> < >= <=运算符吗？

不是所有数据类型，例如true>false这个表达式就是编译错误，布尔类型和引用类型的表达式只能用==和！=两个比较运算，例如”abc” <= ”xyz” 这个表达式也是编译错误的 35)’a’ > ’b’这个表达式编译正确吗？

编译正确，’a’和’b’是字符类型，内部用Unicode编码表示的话a是97，b是98，所以实际上比较的是97>98，结果为false 36)逻辑运算符有哪些？

有 &逻辑与，|逻辑或，！逻辑非，^ 异或，&& 短路与，||短路或

37)逻辑与，逻辑或和短路与，短路或有什么区别？ 逻辑与和短路与的区别是： 

如果是逻辑与&，不管第一个表达式是true还是false，都会执行第二个表达式，例如a > b & x < y，即使a > b为false，也会执行x > y 

如果是短路与&&，如果第一个表达式为false，将不会执行第二个表达式

例如a > b && x < y，如果a > b为false，就不会执行x > y

以此类推，逻辑或和短路或的区别是：

 如果是逻辑或|，不管第一个表达式是true还是false，都会执行第二个表达式 

如果是短路或||，如果第一个表达式为true，将不会执行

第二个表达式

38)与或非三个逻辑运算符的优先级是怎么排列的？ “非”优先级最高，“与”其次，“或”优先级最低 39)原码，反码，补码分别是什么意思？ 

原码：将数字转换为二进制，第一位为符号位，正数为0，负数为1

例如：12的原码是00001100-12的原码是10001100 

反码：正数的反码和原码相同，负数的反码将原码符号位之外的位逐位取反

例如：12的反码是00001100-12的反码是11110011 

补码：正数的补码和原码相同，负数的补码将反码加1 例如：12的补码是00001100-12的补码是11110100 最后强调一点，计算机存储数据用补码形式来存储。40)位运算符都有哪些？

&与 |或 ^异或 ~非 >>右移 <<左移 >>>无符号右移 41)1<<35怎么理解？

1是int类型是32位，所以需要把35%32=3，所以事实上是和执行1<<3等价的42)数据类型转换需要遵循什么原则？

小类型向大类型转换，是自动转换的，或者说隐式转换的 大类型向小类型转换，是需要强制转换的，或者说显式转换例如：byte b = 1;

short s = b;//自动转换

b =(byte)s;//强制转换

43)byte b = 10这个语句是正确的，为什么10是int型比byte大还不需要强制转换呢？

因为在java中做了特殊处理，其中规定byte，short，char类型可以直接赋予int类型的直接量，例如： byte b = 10;short s = 10;char c = 10;

以上赋值语句都是正确的。

但是不能超出超出类型的范围，例如以下赋值就是错误的： byte b = 128;

如果超出范围，必须得作强制转换，例如以下语句是正确的： byte b =(byte)128;

需要强调的是，必须是int类型的直接量，以下语句就是错误的： byte b = 10L;

10L不是int类型的直接量。

44)byte b =(byte)300;强制转换后的结果是44，是按照什么规律得出来的？

是先把300转换成二进制，然后根据byte类型的大小截取了后8个位

300的补码是00000000 00000000 00000001 00101100

b的结果是：00000000 00000000 00000001 00101100 结果为44 45)byte b =(byte)true;这个转换成立吗？

不成立，布尔值和数字是不兼容的，不能作任何转换。

46)int i =(int)“100”;这个转换成立吗？

不成立，引用类型和基本类型是不能直接强制转换的，需要用包装类的方法来转换。

47)char型和short型哪个比较大？

不能说哪个大，哪个小，这两个类型char的取值是从0~65535，而short类型的取值是-32768~32767，这个两个类型之间的转换都需要强制转换。

48)字符串是不是基本类型？

不是，String是java.lang包中的一个类，是引用类型的，8种基本类型中没有一个是String类型。49)空字符串用什么来表示？

用””（两个并列的双引号）表示，代表0个长度的字符串对象。50)String s = “”;和String s = null;有什么区别？

第一个表示s被赋值，指向了一个字符串对象，第二个表示s没有指向任何对象实例，是真空

51)两个字符串用什么运算符可以连成一个字符串？ 用+运算符，例如”abc” + “xyz”最后的结果就是“abcxyz” 52)数学运算符加法和字符串连接符都是+，怎么区分？ 是通过运算符两边的操作数来判断的，如果两边的操作数都是数字型的基本类型，则进行数学运算，如果两边的操作数有一个是字符串，则把另一个操作数也转换为则进行字符串连接运算。例如：+ 4 的结果是9 “5” + 4的结果是54

53)判断字符串内容相同用什么方法？

用equals方法判断内容相同，==只能判断引用是否相同 54)提供用户输入使用哪个类 使用javav.util.Scanner类

55)if语句可以用if(-1)形式判断吗？ 不可以，数字不能代替布尔值

56)if语句和循环语句的花括号什么时候可以省略？

当执行的语句只有一句的时候 57)switch语句有哪些规则？

表达式expr的返回值必须是下述几种类型之一：int, byte, char, short或枚举常量；

case子句中的值必须是常量，且所有case子句中的值应是不同的，也必须是下述几种类型之一：int, byte, char, short或枚举常量

default子句是任选的；

break语句用来在执行完一个case分支后使程序跳出switch语句块；

58)对于退出循环break和continue有什么区别？ break是退出整个循环

continue是退出当前循环继续下一次循环 59)声明数组创建数组的方法？ 以下声明都是合法的： int [] a;int a[];String[] a;

以下创建数组对象都是合法的： int[] a = new int[3];int[] a = {1,2,3};int[] a = new int[] {1,2,3};

60)int[] x和String[] s这两个数组对象，哪个是基本类型，哪个是引用类型？

两个都是数组对象，都是引用类型的61)数组元素下标最小是多少，最大是多少，超出范围会怎么样？

最小是0，最大是数组元素个数减一，超出范围将会出现下标越界异常

62)得到数组长度用length属性还是length（）方法？ 是length属性，得到字符串长度才有length方法

63)声明int[][] a = new int[3][]，a是一个二维数组，a[0]本身

是什么类型的？

二维数组的元素都是一维数组，a[0]是int[]类型的 64)数组的大小一经创建可不可以改变大小了？ 不可以，数组是定长的，一经创建就不能再改变大小了 65)可以把2个int型，3个double型，4个String型的值放到一个数组中吗？

不可以，数组的元素类型必须是相同类型的。66)java中的多维数组必须是要形成矩阵排列吗？ 不一定，也可以是不规则的。67)操作数组比较方便的实用类？

java.util.Arrays类提供了很多关于数组的实用方法。第4章对象和类 1)OOP是什么意思？ Object Oriented Programming(面向对象编程)

2)

类和对象的区别？

类：对象的蓝图，生成对象的模板，是对一类事物的描述，是抽象的概念上的定义

对象：对象是实际存在的该类事物的每个个体，因而也称为实例 3)

类之间的3种关系？ 依赖关系（uses-a）聚集关系（has-a）继承关系（is-a）4)

一个java源文件可以写多个类吗？

可以，但必须只能有一个公有类，并且文件名和公有类的类名相同。5)类中有哪些成员？

有属性（数据域），方法，构造器（构造方法）

6)

构造方法和普通方法的区别？

构造方法没有返回值，方法名必须和类名相同，需要用new语句调用构造方法。7)

普通方法可不可以也类名作为方法名？

是可以的，因为调用普通方法的语法和调用构造器的语法不一样。8)

一个构造器调用另外一个构造器需要用什么语法？ 用this（）语法调用另外一个重载构造器，需要注意的是调用语句必须是构造器中的第一句 9)

什么时候虚拟机会自动添加一个默认构造器？

当类中没有显式定义任何构造器的时候，虚拟机会自动添加一个无参的构造器

10)实例成员和静态成员的区别？

实例成员：是属于对象实例的，用对象.成员名称语法调用 静态成员：和对象实例无关，是属于类本身的，用类名.成员名称语法调用

11)静态初始化块statci{}的执行时机是什么时候？ 在类被加载的时候，仅执行一次。

12)静态方法可不可以直接调用同一个类中的非静态方法？ 不可以，静态方法不能直接调用一个非静态成员，需要用对象调用。

13)包是什么？

包实际上就是物理上的文件夹，可以把类放到不同的包中。14)把一个类放到包中，需要在类中加上什么语句？ 需要加上包声明package语句，必须写在源文件的第一句。15)什么时候需要导入类？用什么语句？

当使用的类和当前类并不在同一个包中的时候，用import语句导入。

16)默认包中的类可以导入吗？

不可以，不在默认包中的类无法使用默认包中的类。17)java中哪个包中的类是自动导入的？ java.lang包

18)什么叫做完整类名？ 顶层包名.子包名.类名

19)静态导入语句有什么作用？

在使用类中的静态成员的时候前面不需要加类名前缀。

20)局部变量和全局变量的区别？ 区别 局部变量 全局变量

声明位置 方法或块内部 方法外类内部 访问权限修饰符 没有访问权限 有访问权限

默认值 没有默认值

有默认值

使用形式 直接使用 对象调用

作用域

在方法或语句块内部 整个类

生命周期 进入方法或语句块创建退出方法或语句块销毁 随着对象的创建而创建随着对象的销毁而销毁

21)赋值语句赋给目标的是值还是引用？

如果是基本类型则赋的是值本身，引用类型则赋的是引用地址 第5章继承和多态 1)类的继承是谁继承谁？

是子类继承了父类，子类也称为派生类，父类也称为超类或基

类 2)子类继承了父类的什么东西？

子类可以继承父类的数据域（属性），方法，但构造器不能继

承 3)

私有成员能被子类继承吗？

能继承，但是由于访问权限的控制，在子类中不能直接使用父类的私有成员 4)

Object是什么类？

这个所有类的根类，任何类如果没有写显式的继承语句，默认都是直接继承Object类的 5)java中是单继承还是多继承？

是单继承，一个子类只能有一个父类 6)

访问权限修饰符有几种，访问的范围又是多大？ 有四种：

private：私用 只能在被类中被访问 default：默认 只能被同一个包中的类访问

protected：受保护的 只能被同一个包中的类和不同包中的子类

访问

public：公有 可以被任何类访问 7)

覆盖方法的规则有哪些？

子类覆盖方法和父类被覆盖方法的方法返回类型，方法名称，参数列表必须相同

子类覆盖方法的访问权限必须大于等于父类的方法的访问权限

方法覆盖只能存在于子类和父类之间

子类覆盖方法不能比父类被覆盖方法抛出更多异常 8)

参数列表是否相同从哪几方面看？

从三方面看：参数个数，类型和顺序，需要注意的是参数的名字不相同是无所谓的 9)

覆盖方法的规则有哪些？ 方法名相同

方法的参数类型,个数,顺序至少有一项不同 方法的返回类型和修饰符均不受限制

10)可变长参数的声明格式是什么？实际上是什么类型的？ 类型 „ 变量，实际上是一个一维数组 11)this和super是作什么用处的？

this：本身代表当前的对象引用，可以用this.成员名称调用当前对象的属性和方法，如果属性和局部变量重名，可以用this.属性名和局部变量区分开。也可以用this（）语法调用本类重载构造器。

super：本事是一个特殊关键字，可以用super.成员名称调用从父类继承的属性和方法，也可以用super（）语法调用父类构造器。

12)super代表子类中的父类对象引用吗？

不，这个错误的说法，super不代表任何对象引用，仅仅是一个关键字

13)什么时候子类构造器会自动调用父类无参构造器？ 当子类构造器中没有任何显式构造器调用的时候，即既没有this（）调用也没有super（）调用的时候

14)一个父类类型的引用变量可以引用一个子类的实例吗？ 可以，这个引用变量是一个多态对象 15)多态对象有什么特点？

多态对象只能使用父类的成员，但如果多态对象使用了被子类覆盖的方法，则会动态绑定使用子类的成员，称为虚拟方法调用

16)引用类型之间的类型转换需要遵循哪些规则？ 自动转换：从子类到父类的类型可以自动转换 强制转换：从父类到子类的类型要强制转换 无继承关系的类型转换是非法的 17)instanceof操作符是作什么用处的？

可以判断一个对象的类型是否是某一个类的类型或子类，也可以判断这个对象的类型是否是一个接口的实现类 18)toString方法什么时候会自动被调用？

在打印语句中传入引用类型的对象或者对象和字符串作连接时

19)默认的equals方法实现的是比较内容还是比较引用地址？

在Object中是比较引用地址。

20)覆盖equals方法和hashCode方法有什么规则？ 必须保证当两个对象equals比较为true的时候，返回的hashCode相同，当比较为false的时候，返回的hashCode不同21)java中有几个包装类？

有8个包装类，正好对应8种基本数据类型。

分别是：Boolean Byte Short Integer Long Character Float Double 22)装箱和拆箱分别是什么意思？

装箱指的是把基本类型包装成包装类的引用类型 拆箱指的是把包装类形式的引用类型转换为基本类型 例如：

Integer objInt = new Integer(10);//装箱

int i = objInt.intValue();

//拆箱

23)JDK1.4和1.5的装箱和拆箱有什么区别?

自动拆装箱，例如： Integer intObj = 10;//自动装箱 int i = intObj + 5;//自动拆箱

24)final修饰符如何使用，使用了final修饰符有什么特点？ final修饰符可以修饰类，方法，变量 final类为最终类，不能被子类继承 final方法为最终方法，不能被子类覆盖 final变量为常量，只能赋一次值

25)abstract修饰符如何使用，使用了abstract修饰符有什么特点？

abstract修饰符可以修饰类和方法 abstract类为抽象类，是不能创建对象的abstract方法为抽象方法，只有方法的声明，没有具体的实现 需要注意的是：

有抽象方法的类一定是抽象类 抽象类不一定有抽象方法

抽象类也有构造器，但不能创建对象实例 26)abstract不能和哪些修饰符配合使用？ 不能和private，static，final一起使用 27)可以在非抽象方法中调用抽象方法吗？ 可以，模板方法设计模式就是典型的这种调用 第6章 泛型程序设计 1)泛型的特点是什么？ 主要特点是类型参数化，后期绑定数据类型 2)泛型支持基本类型吗？

不支持，只支持引用类型 3)如果没有传入类型参数，默认是什么类型？ 默认是Object类型

4)泛型方法有什么特点？

将泛型参数声明在方法中，调用方法的时候绑定泛型 5)

泛型类声明泛型参数的时候，表示什

么意思？

表示绑定的类型必须是A类型后者是A类型的子类或实现类 第7章 接口和内部类

1)声明一个接口的关键字是什么？ interface关键字

2)

接口中的成员有什么特点？

数据域必须是（public static final修饰）公有静态常量 方法必须是（public abstract修饰）公有抽象 没有构造方法 3)接口能创建对象实例吗？ 不能，接口没有构造器，不能创建对象

4)

接口和类的关系？

接口和类之间是实现关系，一个类用implements语句实现了某接口，这个类被称为接口的实现类，一个类可以实现多个接口，一个类实现了某接口，必须覆盖这个接口中的所以方法，否则这个类必须是个抽象类 5)

接口和接口的关系？

接口和接口之间是继承关系，一个接口用extends继承另外一个接口，称为这个接口的子接口。一个接口可以继承多个父接口 6)

内部类如何定义？

一个类声明在另一个类的里面，这个类就被称为内部类，而外面的类被称为外部类 7)

内部类可以分成几种？

实例内部类：声明在方法外边没有static修饰符 静态内部类：声明在方法外边有static修饰符 局部内部类：声明在方法里边 8)

如何创建实例内部类的对象实例？ 需要用外部类的对象来创建 例如： class A {class B {

}

}

如果像创建B类的实例，则必须用以下语句： A a = new A();A.B b = a.new B();9)

如何在实例内部类中访问外部类的成员？

在实例内部类中可以直接使用外部类的成员，不需要创建外部类的对象实例，但是如果在内部类中的成员名称屏蔽隐藏了外部类的成员（即外部类和内部类的成员名相同），则需要用“外部类名.this.成员名”访问外部类成员 第8章异常处理

1)异常的对象的根类是哪个类？ 是Throwable类

2)

Throwable类有哪两个分支？

分成Error类和Excepion类两个分支 Error类表示严重错误

Exception类表示可以在程序中处理的错误 3)

Exception类有哪两个分支？

分成运行时异常和非运行时异常（已检查异常）运行时异常编译不检查，在运行时才会发生异常

已检查异常编译时就会作检查，不处理异常则通不过编译 4)如果在try块中发生异常，那么程序将会跳转到哪？ 会跳转到catch语句块 5)catch语句可以用父类类型捕获子类异常吗？ 因为有多态特点，是可以的6)处理异常代码finally语句会在什么时候执行？ finally代码在任何时候都会执行，不管有没有发生异常。7)

如何声明已检查异常，由谁来处理这个异常？ 用throws语句来声明一个已检查异常，由方法的调用者来处理这个异常 8)

如何抛出一个异常？ 用throw语句抛出

9)如何创建一个自定义的异常类？ 创建一个类，只要让它继承任何一个现有的异常类就可以了 10)覆盖方法对于异常有什么要求？ 覆盖方法不能比父类方法抛出更多异常 第9章反射，代理，标注

1)

获得一个类型的Class对象有哪几种途径？

方法1：对象.getClass()方法2：类型名.class 方法3：Class.forName()2)

反射相关的类型都有哪些？ Class 代表一个运行时类 Field 代表一个类的属性 Method 代表一个类的方法 Constructor 代笔一个类的构造器 3)

如何声明一个自定义标注？ [<修饰符>] @interface <标注名>{ 返回值方法名称（）； 返回值方法名称（）； „„ } 例如：

public @interface MyComment { int id();String info();} 4)

java有几个内置标注？ 有3个

@Override——用于修饰此方法覆盖了父类的方法，而非重载。@Deprecated——用于修饰已经过时的方法。

@SuppressWarnings——用于通知Java编译器禁止特定的警告。第10章 java常用类 1)

字符串String是可变类还是不可变类？

是不可变类，一经创建就不能修改其内容了 2)

字符串的常用方法有哪些？ charAt方法：可以返回指定位置的字符 substring方法：可以截取子字符串 length方法：返回字符串长度 indexOf方法：查找子串的位置 lastIndexOf方法：反向搜索字串的位置 replaceAll方法：替换字符串 split方法：分解字符串

toLowerCase, toUpperCase方法：字符串大小写转换 3)StringBuffer类和String类有什么区别？ StringBuffer是可变类，String是不可变类

4)StringBuffer类和StringBuilder类有什么区别？ StringBuffer类是线程安全的，StringBuilder类是线程不安全的5)Math类主要提供了哪些方法？

Math类提供了大量的和数学运算相关的静态方法 6)Set集合和List集合共同的父接口是什么？ 是Collection集合7)

Set集合和List集合有什么区别？ Set: Collection的子接口，不记录元素的保存顺序，且不允许有重复元素

List: Collection的子接口，记录元素的保存顺序，且允许有重复元素 8)

ArrayList和LinkedList有什么不同？

ArrayList 的内部实现是基于内部数组Object[]，所以从概念上

讲它更像数组

LinkedList的内部实现是基于一组连接的记录，所以它更象一个链表 结构，所以它们在性能上有很大的差别。ArrayList 随机访问比较块，但插入和删除元素比较慢 LinkedList但插入和删除元素比较快，但随机访问比较慢 9)

HashTable和HashMap有什么不同？

HashTable是线程安全的，HashMap是线程不安全的10)Vector和ArrayList有什么不同？ Vector是线程安全的ArrayList是线程不安全的 第11章 IO流 1)

流分成哪两类？

按照单位划分分成字节流和字符流。按输入输出分成输入流和输出流 2)

和文件流相关的有那几个类？ FileInputStream文件输入字节流 FileOutputStream文件输出字节流 FileReader文件输入字符流 FileWriter文件输出字符流 3)

文件流操作应该用字节流还是字符流？ 如果是纯文本文件应该用字符流 如果是二进制文件应该用字节流 4)

文件操作用哪个类？ 用java.io.File类 第12章 线程 1)

创建一个线程类的两种方式？ 继承Thread类 实现Runnable接口 2)线程体应该放在哪个方法里面？ run方法 3)启动新的线程用什么方法？

用start方法

4)一个线程对象能够用start多次启动吗？ 不可以，一个线程方法只能start一次

5)线程有哪几种主要状态？ 有四种，分别是：新生状态，可运行状态，阻塞状态，死亡状

态 6)

线程的同步需要用什么方法？ 旧的方法是用synchronized关键字

新的方法是用ReentrantLock类的lock和unlock方法

第三篇：Java基础知识点总结-Ch1

Java基础知识点总结

第一章 Java语言概述

1.面性对象语言的基本特征。

Java语言的特点。最大优势。

Java语言是区分大小写的。

2.Java虚拟机的核心。

环境变量classpath设置中的“.；”是指可以加载应用程序当前目录及其子目录中的类。环境变量的变量值的最后是以“rt.jar；.；”结束。

3.编写源文件时不可以使用Word编辑器，因为他含有不可见字符。

要用记事本或Edit。源文件的扩展名是java。

4.一个Java应用程序的源文件必须有一个类含有public static void main(String args[ ])的方法，这样类的应用程序叫做主类。

5.源文件的名称必须与有public修饰的类的名称相同。

若源文件有多个类，那么只能有一个是public类；

若只有一个类是 public类，那么源文件的名字必须与这个类的名字完全相同，扩展名是.java；

若源文件没有public类，那么源文件的名字只要和某个类的名字相同即可，并且扩展名为.java。

6.编译时，Java编译器是什么。

进入某个文件夹的命令是“cd 目录名”；退出某个文件夹的命令是“cd..”。

7.编译源文件后将生成多个扩展名为.class的文件，每个扩展名是.class的文件夹存放一个类的字节码文件，文件名与该类的类名相同。这些字节码文件被存放在与源文件相同的目录中。

8.运行时，Java解释器是什么。

Java应用程序总是从主类的main方法开始执行。

9.在运行字节码文件是不可以带有扩展名。

当Java应用程序有多个类时，Java命令执行的类名必须是主类的名字（不带扩展名）。

10.例子：有一个源文件名字叫Apple.java，其中包括3个类，名字分别是Apple, Banana, Orange,有1个是主类,则主类名是什么，生成多少个字节码文件，字节码文件名称是什么，在编译，运行时语句分别是怎样的。

11.Application程序又称什么，Applet程序又称什么，哪一个是源文件编译时运行的程序。

12.J开发一个Java程序要经过的三个步骤。

13.单行注释，多行注释的标记分别是什么

14．javac *.java的意思。

15.Allmans风格又称什么，Kernighan风格又称什么，两者各自的意思是什么。

第四篇：Java学习_基础总结

现在学习JAVA的人越来越多！但是学的好的，能用到工作中去的却很少很少，下面就是我为大家总结归纳的一些JAVA学习基础，希望大家少走弯路，尽快投入到工作中去！

Java 学习基础总结归纳！

1、作用域public,private,protected,以及不写时的区别

答：区别如下：

作用域

当前类

同一package

子孙类

其他package public

√

√

√

√

protected

√

√

√

×

friendly

√

√

×

×

private

√

×

×

×

不写时默认为friendly

2、Anonymous Inner Class(匿名内部类)是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)

答：匿名的内部类是没有名字的内部类。不能extends(继承)其它类，但一个内部类可以作为一个接口，由另一个内部类实现

3、Static Nested Class 和 Inner Class的不同

答：Nested Class（一般是C++的说法），Inner Class(一般是JAVA的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。注： 静态内部类（Inner Class）意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象

4、&和&&的区别

答：&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）

5、Collection 和 Collections的区别

答：Collection是集合类的上级接口，继承与他的接口主要有Set 和List.Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作

6、什么时候用assert

答：assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的

7、String s = new String(“xyz”);创建了几个String Object

答：两个，一个字符对象，一个字符对象引用对象

8、Math.round(11.5)等於多少? Math.round(-11.5)等於多少

答: Math.round(11.5)==12;Math.round(-11.5)==-11;round方法返回与参数最接近的长整数，参数加1/2后求其floor

9、short s1 = 1;s1 = s1 + 1;有什么错? short s1 = 1;s1 += 1;有什么错

答：short s1 = 1;s1 = s1 + 1;（s1+1运算结果是int型，需要强制转换类型）short s1= 1;s1 += 1;（可以正确编译）

10、Java有没有goto

答：java中的保留字，现在没有在java中使用

11、数组有没有length()这个方法? String有没有length()这个方法

答：数组没有length()这个方法，有length的属性。String有有length()这个方法

12、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型

答：方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型

13、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别

答：Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等 equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值

14、给我一个你最常见到的runtime exception

答：常见的运行时异常有如下这些ArithmeticException, ArrayStoreException, BufferOverflowException, BufferUnderflowException, CannotRedoException, CannotUndoException, ClassCastException, CMMException, ConcurrentModificationException, DOMException, EmptyStackException, IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException, IllegalStateException, ImagingOpException, IndexOutOfBoundsException, MissingResourceException, NegativeArraySizeException, NoSuchElementException, NullPointerException, ProfileDataException, ProviderException, RasterFormatException, SecurityException, SystemException, UndeclaredThrowableException, UnmodifiableSetException, UnsupportedOperationException

15、error和exception有什么区别 答：error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况 exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况

16、List, Set, Map是否继承自Collection接口

答： List，Set是，Map不是

17、abstract class和interface有什么区别

答：声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口

18、abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized

答：都不能

19、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)

答：接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数

20、构造器Constructor是否可被override

答：构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading

21、是否可以继承String类

答：String类是final类故不可以继承

22、try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后

答：会执行，在return前执行

23、用最有效率的方法算出2乘以8等於几 答：2 << 3

24、两个对象值相同(x.equals(y)== true)，但却可有不同的hash code，这句话对不对

答：不对，有相同的hash code

25、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递

答：是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的

26、swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上

答：witch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、short、char 或者 byte。long,string 都不能作用于swtich

27、ArrayList和Vector的区别,HashMap和Hashtable的区别

答：就ArrayList与Vector主要从二方面来说.一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半就HashMap与HashTable主要从三方面来说。一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的三.值：只有HashMap可以让你将空值作为一个表的条目的key或value

28、char型变量中能不能存贮一个中文汉字?为什么? 答：是能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的

29、GC是什么? 为什么要有GC

答：GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。

30、float型float f=3.4是否正确?

答:不正确。精度不准确,应该用强制类型转换，如下所示：float f=(float)3.4

31、介绍JAVA中的Collection FrameWork(包括如何写自己的数据结构)?

答：Collection FrameWork如下： Collection ├List │├LinkedList │├ArrayList │└Vector │ └Stack └Set Map ├Hashtable ├HashMap └WeakHashMap Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）Map提供key到value的映射

32、抽象类与接口？

答：抽象类与接口都用于抽象，但是抽象类(JAVA中)可以有自己的部分实现，而接口则完全是一个标识(同时有多重继承的功能)。JAVA类实现序例化的方法是实现java.io.Serializable接口 Collection框架中实现比较要实现Comparable 接口和 Comparator 接口

33、String与StringBuffer的区别。

答：STRING的长度是不可变的，STRINGBUFFER的长度是可变的。如果你对字符串中的内容经常进行操作，特别是内容要修改时，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toString()方法

34、谈谈final, finally, finalize的区别

答：final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载 finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）finalize—方法名。Java 技术允许使用 finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize()方法以整理系统资源或者执行其他清理工作。finalize()方法是在垃圾收集器删除对象之前对这个对象调用的

35、面向对象的特征有哪些方面

答：主要有以下四方面：

1.抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

2.继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

3.封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。4.多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

36、String是最基本的数据类型吗

答：基本数据类型包括byte、int、char、long、float、double、boolean和short。java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类

37、int 和 Integer 有什么区别

答：Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。原始类型封装类

booleanBoolean,charCharacter,byteByte,shortShort,intInteger,longLong,floatFloat,doubleDouble 引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关

38、运行时异常与一般异常有何异同

答：异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

39、说出ArrayList,Vector, LinkedList的存储性能和特性

答：ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

40、HashMap和Hashtable的区别

答：HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高于Hashtable。HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

41、heap和stack有什么区别

答：栈是一种线形集合，其添加和删除元素的操作应在同一段完成。栈按照后进先出的方式进行处理。堆是栈的一个组成元素

42、Java的接口和C++的虚类的相同和不同处

答：由于Java不支持多继承，而有可能某个类或对象要使用分别在几个类或对象里面的方法或属性，现有的单继承机制就不能满足要求。与继承相比，接口有更高的灵活性，因为接口中没有任何实现代码。当一个类实现了接口以后，该类要实现接口里面所有的方法和属性，并且接口里面的属性在默认状态下面都是public static,所有方法默认情况下是public.一个类可以实现多个接口。

43、Java中的异常处理机制的简单原理和应用

答：当JAVA程序违反了JAVA的语义规则时，JAVA虚拟机就会将发生的错误表示为一个异常。违反语义规则包括2种情况。一种是JAVA类库内置的语义检查。例如数组下标越界,会引发IndexOutOfBoundsException;访问null的对象时会引发NullPointerException。另一种情况就是JAVA允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用throw关键字引发异常。所有的异常都是java.lang.Thowable的子类。

43、垃圾回收的优点和原理。并考虑2种回收机制

答：Java语言中一个显著的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考虑内存管理。由于有个垃圾回收机制，Java中的对象不再有“作用域”的概念，只有对象的引用才有“作用域”。垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。

44、你所知道的集合类都有哪些？主要方法？

答：最常用的集合类是 List 和 Map。List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。List 适用于按数值索引访问元素的情形。Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。

45、描述一下JVM加载class文件的原理机制?

答：JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。

46、排序都有哪几种方法？请列举

答： 排序的方法有：插入排序（直接插入排序、希尔排序），交换排序（冒泡排序、快速排序），选择排序（直接选择排序、堆排序），归并排序，分配排序（箱排序、基数排序）快速排序的伪代码。/ /使用快速排序方法对a[ 0 :n-1 ]排序从a[ 0 :n-1 ]中选择一个元素作为m i d d l e，该元素为支点把余下的元素分割为两段left 和r i g h t，使得l e f t中的元素都小于等于支点，而right 中的元素都大于等于支点递归地使用快速排序方法对left 进行排序递归地使用快速排序方法对right 进行排序所得结果为l e f t + m i d d l e + r i g h t

47、JAVA语言如何进行异常处理，关键字：throws，throw，try，catch，finally分别代表什么意义？在try块中可以抛出异常吗？

答：Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理。用try来指定一块预防所有“异常”的程序。紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的“异常”的类型。throw语句用来明确地抛出一个“异常”。throws用来标明一个成员函数可能抛出的各种“异常”。Finally为确保一段代码不管发生什么“异常”都被执行一段代码。可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句，“异常”的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种“异常”进行处理，堆栈就会展开，直到遇到有处理这种“异常”的try语句。

48、一个“.java”源文件中是否可以包括多个类（不是内部类）？有什么限制？

答：可以。必须只有一个类名与文件名相同。

49、java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？

答：字节流，字符流。字节流继承于InputStream OutputStream，字符流继承于InputStreamReader OutputStreamWriter。在java.io包中还有许多其他的流，主要是为了提高性能和使用方便。

50、java中会存在内存泄漏吗，请简单描述。

答：会。自己实现堆载的数据结构时有可能会出现内存泄露，可参看effective java.51、java中实现多态的机制是什么？

答：方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。

52、垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收

答：对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是“可达的”，哪些对象是“不可达的”。当GC确定一些对象为“不可达”时，GC就有责任回收这些内存空间。可以。程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。

53、静态变量和实例变量的区别？ 答：static i = 10;//常量 class A a;a.i =10;//可变

54、什么是java序列化，如何实现java序列化？

答：序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

55、是否可以从一个static方法内部发出对非static方法的调用？

答：不可以,如果其中包含对象的method()；不能保证对象初始化.56、写clone()方法时，通常都有一行代码，是什么？

答：Clone 有缺省行为，super.clone();他负责产生正确大小的空间，并逐位复制。

57、在JAVA中，如何跳出当前的多重嵌套循环？

答：用break;return 方法。

58、List、Map、Set三个接口，存取元素时，各有什么特点？

答：List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。

59、说出一些常用的类，包，接口，请各举5个

答：常用的类：BufferedReader BufferedWriter FileReader FileWirter String Integer 常用的包：java.lang java.awt java.io java.util java.sql 常用的接口：Remote List Map Document NodeList

第五篇：java知识点总结（定稿）

目录

目录................................................................................................................................................１ 基础篇............................................................................................................................................４

一、JDK常用的包................................................................................................................４

二、Get和Post的区别.......................................................................................................４

三、Java多态的具体体现...................................................................................................４

四、StringBuffer StringBuilder String 区别.......................................................................５

五、Hashtable与HashMap的区别....................................................................................５六、九大隐式对象...............................................................................................................５

七、Forword(请求转发)与Redirect(重定向).....................................................................６

八、JQurey总结....................................................................................................................６

九、XML和Json的特点....................................................................................................６

十、request.getSession()、reqeust.getSession(false)和

request.getSession(true)７

十一、Page和PageContext的区别....................................................................................７

十二、Ajax总结..................................................................................................................７

十三、JSP9大隐视对象中四个作用域的大小与作用范围................................................７

十四、List,Set,Collection,Collections..................................................................................８

十五、java的基本数据类型...............................................................................................８

十六、冒泡排序...................................................................................................................８ 十七、二分查找法.................................................................................................................９

十八、时间类型转换.............................................................................................................９

十九、阶乘.......................................................................................................................１０

二十、UE和UI的区别....................................................................................................１０ 二

十一、osi七层模型.......................................................................................................１０ 二

十二、线程和进程的区别.............................................................................................１１ 二

十三、jvm的内存结构.................................................................................................１１ 二

十四、内存泄露和内存溢出.........................................................................................１１ 二

十五、单例.....................................................................................................................１１ 二

十六、解析xml文件的几种技术.................................................................................１３ 二

十七、项目的生命周期.................................................................................................１４

１

二十八、OSCache的判断.................................................................................................１４ 二

十九、经常访问的技术网站.........................................................................................１５ 三

十、项目团队中交流的工具.........................................................................................１５ 三

十一、平时浏览的书籍.................................................................................................１５ 三

十二、java Exception体系结构....................................................................................１５ 三

十三、session和cookie的区别....................................................................................１６ 三

十四、字节流与字符流的区别.....................................................................................１６ 三

十五、final,finally,finalize 三者区别...........................................................................１７ 三

十六、Io流的层次结构................................................................................................１７ 三

十七、JAVA:..................................................................................................................１８ 三

十八、JavaSE JavaEE JavaME区别........................................................................１８ 三

十九、JDK JRE JVM的区别：.............................................................................１９ 四

十、报错的状态码：.....................................................................................................２０ 四

十一、协议以及默认的端口号.....................................................................................２０ 四

十二、抽象类与接口的区别.........................................................................................２０ 四

十三、修饰符的作用.....................................................................................................２０ 框架篇........................................................................................................................................２１

一、Struts1的运行原理..................................................................................................２３

二、Struts2的运行原理..................................................................................................２３

三、struts2的体系结构...................................................................................................２３

四、Spring MVC运行原理.............................................................................................２４

五、Struts1.x与Struts2.x的区别...................................................................................２５

六、Spring MVC、struts1和struts2区别......................................................................２５

七、Struts2中result中的type类型...............................................................................２５

八、Struts2标签..............................................................................................................２６

九、SSI整合....................................................................................................................２６

十、SSH整合..................................................................................................................２６

十、Spring MVC整合.....................................................................................................２７

十一、Hibernate 中get 和 load的区别.........................................................................２８

十二、Hibernate、Ibatis、Jdbc三者的区别..................................................................２８

十三、Hibernate的运行原理..........................................................................................２８

十四、Hibernate五大核心（类/接口）简述.................................................................２８

十五、Hibernate与JDBC的区别..................................................................................２９

十六、Hibernate中的两大配置文件................................................................................２９

十七、Hibernate事务处理..............................................................................................２９

十八、Hibernate的三种状态以及状态的转换..............................................................２９

十九、分页步骤...............................................................................................................３０

二十、hibernate缓存概述.................................................................................................３０ 二

十一、Ssh的概述：.....................................................................................................３０ 二

十二、防止表单重复提交.............................................................................................３１ 二

十三、JSP标签：........................................................................................................３１ 二

十四、过滤器.................................................................................................................３２ 二

十五、拦截器的理解.....................................................................................................３２ 二

十六、Spring融入框架................................................................................................３３

２

数据库篇.....................................................................................................................................３３

一、JDBC连接数据库步骤(以MYSQL为例).............................................................３３

二、数据库连接池...........................................................................................................３４

三、mysql的数据库导入导出........................................................................................３５

四、jdbc分段批量提交的时候出现异常怎么处理?.....................................................３５

五、jdbc批量处理数据...................................................................................................３５

六、Oracle分页...............................................................................................................３６

七、Oracle的基本数据类型...........................................................................................３６

八、id、rowid、rownum的区别....................................................................................３７

九、主键和唯一索引的区别？.......................................................................................３７

十、Preparedstatement和statement的区别...................................................................３７

十一、数据库三范式.......................................................................................................３８

十二、视图概述...............................................................................................................３８

十三、存储过程概述.......................................................................................................３８

十四、索引概述...............................................................................................................３９

十五、必背的sql语句....................................................................................................４１ 业务场景篇.................................................................................................................................４４

一、Spring的概述...........................................................................................................４４

二、事务概述...................................................................................................................４５

三、权限概述...................................................................................................................４６

四、OSCache业务场景...................................................................................................４６

五、线程概述...................................................................................................................４７

六、Ajax请求Session超时问题....................................................................................４７ 七：java线程池概述.........................................................................................................４８

八、OSCache概述...........................................................................................................４９

九、OSCache+autocomplete+单例业务场景..................................................................４９

十、缓存概述...................................................................................................................５０

十一、实现页面静态化业务场景...................................................................................５０

十二、servlet线程安全描述...........................................................................................５１

十三、(jbpm4)工作流引擎描述:.....................................................................................５１

十四、JPBM业务场景....................................................................................................５２

十五、Ant描述................................................................................................................５２

十六、FreeMarker描述...................................................................................................５３

十七、webService描述...................................................................................................５３

十八、oracle索引概述....................................................................................................５５

十九、oracle存储过程....................................................................................................５６

二十、Junit 业务场景.......................................................................................................５６ 二

十一、Apache+Tomcat 实现负载均衡及seesion复制...............................................５６ 二

十二、Ant业务场景......................................................................................................５７ 二

十三、maven业务场景.................................................................................................５７ 二

十四、Servlet的概述：................................................................................................５８ 优化篇........................................................................................................................................６４

一、代码优化...................................................................................................................６４

二、业务优化...................................................................................................................６４

３

三、sql优化.....................................................................................................................６５

四、防sql注入................................................................................................................６８

基础篇

一、JDK常用的包

java.lang： 这个是系统的基础类，比如String、Math、Integer、System和Thread，提供常用功能。

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

java.net: 这里面是与网络有关的类，比如URL,URLConnection等。java.util : 这个是系统辅助类，特别是集合类Collection,List,Map等。java.sql: 这个是数据库操作的类，Connection, Statememt，ResultSet等

二、Get和Post的区别

1.get是从服务器上获取数据，post是向服务器传送数据，2.get传送的数据量较小，不能大于2KB。post传送的数据量较大，一般被默认为不受限制。

3.get安全性非常低，post安全性较高。但是执行效率却比Post方法好。

4.在进行文件上传时只能使用post而不能是get。

三、Java多态的具体体现

面向对象编程有四个特征：抽象，封装，继承，多态。

多态有四种体现形式：

1.接口和接口的继承。2.类和类的继承。3.重载。4.重写。

其中重载和重写为核心。

重载：重载发生在同一个类中，在该类中如果存在多个同名方 法，但是方法的参数类型和个数不一样，那么说明该方法被重 载了。

重写：重写发生在子类继承父类的关系中，父类中的方法被子 类继承，方法名，返回值类型，参数完全一样，但是方法体不 一样，那么说明父类中的该方法被子类重写了。

４

四、StringBuffer StringBuilder String 区别

String

字符串常量

不可变

使用字符串拼接时是不同的2个空间

StringBuffer 字符串变量

可变

线程安全

字符串拼接直接在字符串后追加 StringBuilder 字符串变量

可变

非线程安全

字符串拼接直接在字符串后追加

1.StringBuilder执行效率高于StringBuffer高于String.2.String是一个常量，是不可变的，所以对于每一次+=赋值都会创建一个新的对象，StringBuffer和StringBuilder都是可变的，当进行字符串拼接时采用append方

法，在原来的基础上进行追加，所以性能比String要高，又因为StringBuffer 是

线程安全的而StringBuilder是线程非安全的，所以StringBuilder的效率高于

StringBuffer.3.对于大数据量的字符串的拼接，采用StringBuffer,StringBuilder.五、Hashtable与HashMap的区别

HashMap不是线程安全的，HashTable是线程安全。

HashMap允许空（null）的键和值（key），HashTable则不允许。

HashMap性能优于Hashtable。

Map 1.Map是一个以键值对存储的接口。Map下有两个具体的实现，分别是HashMap和HashTable.2.HashMap是线程非安全的，HashTable是线程安全的，所以HashMap的效率高于HashTable.3.HashMap允许键或值为空，而HashTable不允许键或值为空.六、九大隐式对象

输入/输出对象：

request

response

out 作用域通信对象： session application pageContext Servlet 对象：

page

config 错误对象：

exception

５

七、Forword(请求转发)与Redirect(重定向)

1、从数据共享上

Forword是一个请求的延续，可以共享request的数据

Redirect开启一个新的请求，不可以共享request的数据

2、从地址栏

Forword转发地址栏不发生变化

Redirect转发地址栏发生变化

八、JQurey总结

jquery是一个轻量级的js框架，具有跨浏览器的特性，兼容性好，并且封装了很多工具，方便使用。

常用的有: 选择器，dom操作，ajax(ajax不能跨域)，特效，工具类

九、XML和Json的特点

Xml特点：

1、有且只有一个根节点；

2、数据传输的载体

3、所有的标签都需要自定义

4、是纯文本文件

Json（JavaScript Object Notation）特点：

json分为两种格式:

json对象(就是在{}中存储键值对，键和值之间用冒号分隔，键 值 对之间用逗号分隔);

json数组(就是[]中存储多个json对象，json对象之间用逗号分隔)（两者间可以进行相互嵌套）数据传输的载体之一

区别：

传输同样格式的数据，xml需要使用更多的字符进行描述，流行的是基于json的数据传输。

xml的层次结构比json更清晰。

共同点：

xml和json都是数据传输的载体，并且具有跨平台跨语言的特性。

６

十、request.getSession()、reqeust.getSession(false)和

request.getSession(true)

getSession()/getSession(true)：当session存在时返回该session，否则新建一个

session并返回该对象

getSession(false)：当session存在时返回该session，否则返回null

十一、Page和PageContext的区别

Page是servlet对象；使用this关键字，它的作用范围是在同一页面。PageContext是作用域通信对象；通常使用setAttribute()和getAttribute()来设置和获取存放对象的值。

十二、Ajax总结

AJAX 全称： 异步JavaScript及 XML（Asynchronous JavaScript And XML）Ajax的核心是JavaScript对象XmlHttpRequest(XHR)。

Ajax的优点:

提高用户体验度(UE)

提高应用程序的性能

进行局部刷新

AJAX不是一种新的编程语言，而是一种用于创建更好更快以及交互性更强的 Web 应用程序的技术。

2.通过 AJAX，我们的 JavaScript 可使用JavaScript的XMLHttpRequest对象来直接与服务器进行通信。通过这个对象，我们的 JavaScript 可在不重载页面的情况与Web服务器交换数据，即可局部刷新。

3.AJAX 在浏览器与 Web 服务器之间使用异步数据传输（HTTP 请求），这样就可使网页从服务器请求少量的信息，而不是整个页面，减轻服务器的负担，提升站点的性能。

AJAX 可使因特网应用程序更小、更快，更友好，用户体验（UE）好。5.Ajax是基于标准化并被广泛支持的技术，并且不需要插件和下载小程序

十三、JSP9大隐视对象中四个作用域的大小与作用范围

四个作用域从大到小：appliaction>session>request>page application：全局作用范围，整个应用程序共享.生命周期为：应用程序启动到停止。

７

session：会话作用域，当用户首次访问时，产生一个新的会话，以后服务器就可以记

住这个会话状态。

request：请求作用域，就是客户端的一次请求。

page：一个JSP页面。

以上作用范围使越来越小，request和page的生命周期都是短暂的，他们之间的区别就是：一个request可以包含多个page页(include，forward)。

十四、List,Set,Collection,Collections

1.List和Set都是接口，他们都继承于接口Collection,List是一个有序的可重复的集合，而Set的无序的不可重复的集合。Collection是集合的顶层接口，Collections是一个封装了众多关于集合操作的静态方法的工具类,因为构造方法是私有的，所以不能实例化。

2.List接口实现类有ArrayList,LinkedList,Vector。ArrayList和Vector是基于数组实现的,所以查询的时候速度快，而在进行增加和删除的时候速度较慢LinkedList是基于链式存储结构，所以在进行查询的时候速度较慢但在进行增加和删除的时候速度较快。又因为Vector是线程安全的，所以他和ArrayList相比而言，查询效率要低。

十五、java的基本数据类型

数据类型 大小 byte(字节)1(8位)shot(短整型)2(16位)int(整型)4(32位)long(长整型)8(32位)float(浮点型)4(32位)double(双精度)8(64位)char(字符型)2(16位)boolean(布尔型)1位 附加：

String是基本数据类型吗?(String不是基本数据类型)String的长度是多少，有限制?(长度受内存大小的影响)

十六、冒泡排序

public class Sort { public static void sort(){

８

} Scanner input = new Scanner(System.in);int sort[] = new int[10];int temp;System.out.println(“请输入10个排序的数据：”);for(int i = 0;i < sort.length;i++){

sort[i] = input.nextInt();} for(int i = 0;i < sort.lengthi1)* num;

} } public static void main(String[] args){

System.out.println(multiply(10));} }

二十、UE和UI的区别

UE 是用户体验度

UI 界面原型（用户界面）（相当于买房时用的模型）

设计UI的作用：

1、帮助程序员工作（界面已由美工设计完成）

2、提前让用户对项目有个宏观的了解，知道效果是什么样子。

二十一、osi七层模型

第一层：物理层

第二层：数据链路层

第三层：网络层

第四层：传输层

第五层：会话层 第六层：表示层 第七层：应用层

１０

二十二、线程和进程的区别

1.线程(Thread)与进程（Process）

进程定义的是应用程序与应用程序之间的边界，通常来说一个进程就代表一个与之对应的应用程序。不同的进程之间不能共享代码和数据空间，而同一进程的不同线程可以共享代码和数据空间。

2.一个进程可以包括若干个线程，同时创建多个线程来完成某项任务，便是多线程。3.实现线程的两种方式：继承Thread类，实现Runable接口

二十三、jvm的内存结构

java虚拟机的内存结构分为堆(heap)和栈(stack),堆里面存放是对象实例也就是new出来的对象。栈里面存放的是基本数据类型以及引用数据类型的地址。

对于所谓的常量是存储在方法区的常量池里面。

二十四、内存泄露和内存溢出

内存泄露(memory leak)，是指应用程序在申请内存后，无法释放已经申请的内存空间.一次内存泄露危害可以忽略，但如果任其发展最终会导致内存溢出(out of memory).如读取文件后流要进行及时的关闭以及对数据库连接的释放。

内存溢出（out of memory）是指应用程序在申请内存时，没有足够的内存空间供其使用。

如我们在项目中对于大批量数据的导入，采用分段批量提交的方式。

二十五、单例

单例就是该类只能返回一个实例。单例所具备的特点： 1.私有化的构造函数 2.私有的静态的全局变量 3.公有的静态的方法

单例分为懒汉式、饿汉式和双层锁式

１１

饿汉式: public class Singleton1 {

private Singleton1(){};

private static Singleton1 single = new Singleton1();

public static Singleton1 getInstance(){

return single;

} }

懒汉式：

public class Singleton2 {

private Singleton2(){}

private static Singleton2 single=null;

public tatic Singleton2 getInstance(){

if(single == null){

single = new Singleton2();

}

return single;

} } 线程安全：

public class Singleton3 {

private Singleton3(){}

private static Singleton3 single;

public static Singleton3 getInstance(){

if(null == single){

synchronized(single){

if(null == single){

single = new Singleton3();

}

}

}

return single;

} }

参考：

通过双重判断来保证单列设计模式在多线程中的安全性，并且它在性能方面提高了很多。

１２

synchronized在方法上加锁(同步锁)

synchronized在代码块内部加锁（同步代码块）

synchronized(同步锁)

使用synchronized如何解决线程安全的问题？ 1.synchronized在方法上加锁 2.synchronized在代码块内部加锁

1.懒汉

2.饿汉

3.双重判断

二十六、解析xml文件的几种技术

1、解析xml的几种技术

1.dom4j

2.sax

3.jaxb

4.jdom

5.dom 1.dom4j

dom4j是一个Java的XML API，类似于jdom，用来读写XML文件的。dom4j是一个非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。

2.sax

SAX（simple API for XML）是一种XML解析的替代方法。相比于DOM，SAX是一种速度更快，更有效的方法。它逐行扫描文档，一边扫描一边解析。而且相比于DOM，SAX可以在解析文档的任意时刻停止解析，但任何事物都有其相反的一面，对于SAX来说就是操作复杂。

１３

3.jaxb

JAXB（Java Architecture for XML Binding)是一个业界的标准，是一项可以根据XML Schema产生Java类的技术。该过程中，JAXB也提供了将XML实例文档反向生成Java对象树的方法，并能将Java对象树的内容重新写到XML实例文档。从另一方面来讲，JAXB提供了快速而简便的方法将XML模式绑定到Java表示，从而使得Java开发者在Java应用程序中能方便地结合XML数据和处理函数。

2、dom4j 与 sax 之间的对比：【注：必须掌握！】

dom4j不适合大文件的解析，因为它是一下子将文件加载到内存中，所以有可能出现内存溢出，sax是基于事件来对xml进行解析的，所以他可以解析大文件的xml

也正是因为如此，所以dom4j可以对xml进行灵活的增删改查和导航，而sax没有这么强的灵活性

所以sax经常是用来解析大型xml文件，而要对xml文件进行一些灵活（crud）操作就用dom4j

二十七、项目的生命周期

1.需求分析

2.概要设计

3.详细设计(用例图，流程图，类图)4.数据库设计(powerdesigner)5.代码开发（编写）

6.单元测试（junit 白盒测试）(开发人员)svn版本管理工具(提交，更新代码，文档)7.集成测试（黑盒测试，loadrunner（编写测试脚本）(高级测试)）

8.上线试运行（用户自己体验）

9.压力测试（loadrunner）

10.正式上线

11.维护

二十八、OSCache的判断

Object obj = CacheManager.getInstance().getObj(“oaBrandList”);//从缓存中取数据 if(null == obj){

obj = brandDao.getBrandList();

//如果为空再从数据库获取数据

//获取之后放入缓存中

１４

CacheManager.getInstance().putObj(“oaBrandList”, obj);}

return(List)obj;

二十九、经常访问的技术网站

1.csdn(详细步骤的描述)2.iteye(详细步骤的描述)3.oschina（开源中国获取java开源方面的信息技术）

4.java开源大全 下载完毕，并且已经解析为DOM 树了，但很有可能图片还没有加载完毕，所以例如图片的高度和宽度这样的属性此时不一定有效。要解决这个问题，可以使用Jquery 中另一个关于页面加载的方法---load()方法。Load()方法会在元素的onload 事件中绑定一个处理函数。如果处理函数绑定给window 对象，则会在所有内容(包括窗口、框架、对象和图像等)加载完毕后触发，如果处理函数绑定在元素上，则会在元素的内容加载完毕后触发。Jquery 代码如下： $(window).load(function(){ // 编写代码 });等价于JavaScript 中的以下代码 Window.onload = function(){ // 编写代码 } 四

十五、switch默认接受的几种数据类型

Short, int, byte, char

２１

四

十六、request 跟session的区别

1.他们的生命周期不同，request对应的是一次请求，session对应的是一次会话

2.request占用资源比较少,相对来说缺乏持续性, 而session资源消耗比较大，所以通常使用request来保存信息

四

十七、找到解决svn冲突方法

对于svn冲突，可以采用手工处理将冲突的部分进行整合，之后备份最新整合后的文件，采用覆盖更新的方式处理完 冲突之后，再把最新整合后的文件进行提交。

四

十八、反射的描述

通过字符串可以动态创建java对象，并且可以动态访问方法，属性等。

我们在项目中的时候封装过数据库jdbc的持久层，其中就利用反射这项

技术来达到通用

和灵活的目的。

２２

框架篇

一、Struts1的运行原理

在启动时通过前端总控制器ActionServlet加载struts-config.xml并进行解析，当用户在jsp页面发送请求被struts1的核心控制器ActionServlet接收，ActionServlet在用户请求时将请求参数放到对应的ActionForm对象中的成员变量中，然后ActionServlet则会根据struts-config.xml中的映射关系找到相应的Action中的方法，将对应的ActionForm一并传给这个Action中的方法里，然后执行相应的业务逻辑操作，最后就根据ActionMapping的findforward方法返回一个ActionForward,之后在struts-config.xml中找到与之对应的forward标签，根据它的配置路径找到对应的jsp页面。

二、Struts2的运行原理

1、tomcat 启动的时候会加载 web.xml、核心控制器 FilterDispatcher 会加载并解析 struts.xml

2、客户端会发送一个请求到 action、FilterDispatcher 会根据后缀名进行拦截

3、FilterDispatcher根据 struts.xml 的配置文件信息 找到 某个action 对应的某个类里的指定方法

4、执行相关的业务逻辑最后返回 一个String

5、 里配置 name的属性值与返回的String 进行匹配,跳转到指定的jsp 页面

三、struts2的体系结构

1、客户端向Servlet容器（例如Tomcat）发送一个请求；

2、这个请求经过一系列的过滤器（Filter）；

3、接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请求是否需要调用某个Action；

4、如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy；

5、ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类；

6、ActionProxy创建一个ActionInvocation的实例。

7、ActionInvocation在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。

8、一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是jsp或者FreeMarker的模版。（体系结构图见下一页）

２３

四、Spring MVC运行原理

整个处理过程从一个HTTP请求开始：

1.Tomcat在启动时加载解析web.xml,找到spring mvc的前端总控制器DispatcherServlet,并且通过DispatcherServlet来加载相关的配置文件信息。

2.DispatcherServlet接收到客户端请求，找到对应HandlerMapping，根据映射规则，找到对应的处理器（Handler）。

3.调用相应处理器中的处理方法，处理该请求后，会返回一个ModelAndView。

4.DispatcherServlet根据得到的ModelAndView中的视图对象，找到一个合适的ViewResolver（视图解析器），根据视图解析器的配置，DispatcherServlet将要显示的数据传给对应的视图，最后显示给用户。

２４

五、Struts1.x与Struts2.x的区别

Struts 2以WebWork为核心，采用拦截器的机制来处理用户的请求，struts1严重依赖于servletAPI, 属于侵入性框架,struts2不严重依赖于servletAPI,属于非侵入型框架。线程模型方面：

Struts1的Action是单实例的, 一个Action的实例处理所有的请求。

Struts2的Action是一个请求对应一个实例（每次请求时都新new出一个对象）, 没有线程安全方面的问题 封装请求参数：

Struts1中强制使用ActionForm对象封装请求的参数。

Struts2可以选择使用POJO类来封装请求的参数，或者直接使用Action的属性。struts1的前端总控制器(核心总控制器)为ActionServlet, struts2的前端总控制器(核心总控制器)为FilterDispather

六、Spring MVC、struts1和struts2区别

1.spring mvc 单例 非线程安全

struts1单例 非线程安全

struts2线程安全对每个请求都产生一个实例 2.spring mvc的入口是servlet，而struts2是filter

spring 的前端总控制器为 DispatcherServlet

struts2 的前端总控制器为 FilterDispatcher

struts1 的前端总控制器为 actionServlet 3.参数传递：struts是在接受参数的时候，可以用属性来接受参数，这就说明参数是让多个方法共享的。springmvc 用方法来接受参数

4.spring mvc是基于方法的设计,而sturts是基于类

七、Struts2中result中的type类型

1.dispatcher：它是默认的，用来转向页面，通常处理JSP 2.redirect：将用户重定向到一个已配置好的URL 3.redirectAction：将用户重定向到一个已定义好的action 4.chain：将action和另外一个action链接起来 5.freemarker：呈现Freemarker模板

6.httpheader：返回一个已配置好的HTTP头信息响应

7.stream：向浏览器发送InputSream对象对下载的内容和图片非常有用 8.velocity：呈现Velocity模板

２５

9.xslt ：该XML可以通过XSL模板进行转换

10.plaintext：显示原始文件内容，例如文件源代码

八、Struts2标签

首先需要引用 <%@taglib prefix=“s” uri=“/struts-tags”%> 1. 判断标签 后面可跟 2. 迭代标签

3. 引入标签 可以把一个JSP页面或者servlet引入一

个页面中

4. 输出标签

5. 标签赋予变量一个特定范围内的值

6. 表单标签

7. 文本域标签

8. 下拉标签

9. 声明一个url的路径

最常用的是：

判断

循环

输出

九、SSI整合

1、Action继承于Actionsupport

2、引入struts-spring-plugin.jar包，从而完成struts和spring的整合

3、在struts2的action中注入service，保证service的名字和配置文件中的一致，并生成get,set方法

4、Dao层继承于SqlMapClientDaoSupport

5、在dao层的配置文件中注入sqlMapClient

十、SSH整合

1.首先在web.xml中通过ContextLoaderListener来融入spring，并加载spring的相关配置文件

2.同样配置sturts2的前端总控制器filterDispatcher来过滤相关的 请求并且加载struts.xml

２６

3.action继承ActionSupport，然后通过引入struts-spring-plugin.jar 包并且根据配置文件中service的id生成get,set方法来注入service层。

4.dao层继承于HibernateDaoSupport，并且在dao的配置文件中注入sessionFactory.5.通过spring中的配置文件加载hibernate.cfg.xml文件从而融入hibernate.在ssh框架中是怎么整合spring? 首先在web.xml中通过ContextLoaderListener来融入spring，并加载spring的相关配置文件

在ssh框架中是怎么整合hibernate? 通过spring中的配置文件加载hibernate.cfg.xml文件从而融入hibernate dao层继承于HibernateDaoSupport，并且在dao的配置文件中注入sessionFactory

在ssh框架中是怎么整合struts2? 配置sturts2的前端总控制器filterDispatcher来过滤相关的 请求并且加载struts.xml

十、Spring MVC整合

1.首先,要在web.xml里面配置SpringMVC的核心控制器,DispatcherServlet,对指定的后缀请求进行拦截。

2.Controller层要加 @Controller注解,表明该类是MVC的控制层。

3.创建Service接口,给接口加上注解 @Component或者 @Service 表明这是Service业务处理层

4.在Controller层声明Service变量(属性),给变量（属性）加上 @Autowired注解,通过自动绑定机制将Service注入到Controller。(注：@Autowired默认是ByType,如果想根据属性名注入,那么就再加上注解 @Resource(name=“属性名”))5.在Controller层的方法上加上注解 @RequestMapping(“requestAddress”)表明该方法的请求地址

6.Dao层要加上注解 @Repository 表明这是数据库持久层 7.同样将dao实例注入到service层中。

8.配置视图解析器 “InternalResourceViewResolver”,对处理后的跳转进行统一配置。

２７

十一、Hibernate 中get 和 load的区别

加载方式：

load为延迟加载(返回的是一个只有id属性的代理,只有使用该对象属性时,才

发出sql语句)；

get为立即加载(执行时,会立即向数据库发出sql语句)返回结果：

load检索不到记录时,会抛ObjectNotFoundException异常

get检索不到记录时,会返回null

十二、Hibernate、Ibatis、Jdbc三者的区别

Hibernate属于全自动，Ibatis属于半自动，Jdbc属于手动，从开发效率上讲hibernate较高，ibatis居中，jdbc较低，从执行效率上讲hibernate较低，ibatis居中，jdbc较高，因为jdbc是手工写sql语句，程序员对sql的控制能力更大，可以根据业务需要进行优化，而ibatis虽然也可以对sql进行优化，但是他里面将resultset封装为实体的过程中采用了反射机制所以一定程度上影响了性能，而hibernate因为高度封装所以开发效率相对较高，但正因为这个原因，所以程序员在对sql语句的控制和优化方面相对比较弱，而且在将resultset封装成实体的过程中也采用了反射机制，所以在性能方面较低

十三、Hibernate的运行原理

首先通过configuration去加载hibernate.cfg.xml这个配置文件，根据 配置文件的信息去创建sessionFactory,sessionFactory是线程安全的，是一个session工厂，用来创建session,session是线程不安全的，相当于

jdbc的connection，最后通过session去进行数据库的各种操作，在进行操作 的时候通过transaction进行事务的控制。

十四、Hibernate五大核心（类/接口）简述

1.Configuration接口的作用是对Hibernate进行配置，以及对它进行启动。（加载 hibernate.cfg.xml）并创建一个SessionFactory对象。2.SessionFactory接口

SessionFactory接口负责初始化Hibernate。它充当数据存储源的代理，并负责创建 Session对象。SessionFactory是线程安全的。3.Session接口

Session（会话）接口是Hibernate应用使用的主要接口。Session接口负责执行被持久化对象的CRUD操作(增删改查)。Session对象是非线程安全的。Session 相当于jdbc的connection 4.Query与Criteria接口

总之Query和Criteria接口负责执行各种数据库查询。5.Transaction接口

２８

Transaction（事务）负责操作相关的事务。

十五、Hibernate与JDBC的区别

1、hibernate和jdbc主要区别就是，hibernate先检索缓存中的映射对象(即hibernate操作的是对象)，而jdbc则是直接操作数据库.2、Hibernate是JDBC的轻量级的对象封装，它是一个独立的对象持久层框架。Hibernate可以用在任何JDBC可以使用的场合

3、Hibernate是一个和JDBC密切关联的框架，所以Hibernate的兼容性和JDBC驱动，和数据库都有一定的关系，但是和使用它的Java程序，和App Server没有任何关系，也不存在兼容性问题。

4、如果正确的使用JDBC技术,它的执行效率一定比hibernate要好,因为hibernate是基于jdbc的技术.5、JDBC使用的是SQL语句，Hibernate使用的是HQL语句，但是HQL语句最终还会隐式转换成SQL语句执行。

十六、Hibernate中的两大配置文件

*.hbm.xml：主键生成策略，映射关系，一对多，一对一的关系。

Hibernate.cfg.xml：方言(用哪个数据库)，数据库连接信息，包含*.hbm.xml内容，映射 文件，也可以配事务。

十七、Hibernate事务处理

开启事务 session.beginTransaction();执行相关的操作，如果成功则session.getTransaction().commit();执行操作失败则 session.getTransaction.rollback();

十八、Hibernate的三种状态以及状态的转换

Transient(临时)

new 一个初始化对象后，并没有在数据库里保存数据，处于临时状态； Persistent(持久化)

当执行save()方法，调用session.close()方法之前，内存中的对象与数据库有

对应关系处于持久化状态；

Detached(托管/游离)

当执行session.close()之后，处于托管状态； 状态的转换

处于托管状态下，调用update()方法后，转换为持久化状态；

在持久化状态下，执行delete()方法后，转换为临时状态；

在未初始化对象之前，调用get(),load(),find(),iterate()之后，直接进入持久化

状态。

２９

十九、分页步骤

①前台封装一个显示分页的组件 ②查询总条数

③后台封装分页工具类，计算开始位置、结束位置、总页数 ④后台写支持分页的sql语句

⑤前台包含分页组件，实现分页效果

注意: 查询总条数的where和查询列表信息的where条件要保证一致。

二十、hibernate缓存概述

hibernate分为一级缓存即session缓存也叫事务级别的缓存以及

二级缓存sessionFactory即应用级别的缓存,还有查询缓存即三级缓存.一级缓存的生命周期和session的生命周期保持一致，hibernate默认就启用了一级缓存，不能将其关闭，可以通过session.clear()和session.evict(object)来管理一级缓存。其中get,load,iterate都会使用一级缓存，一级缓存缓存的是对象。

二级缓存的生命周期和sessionFactory的生命周期保持一致，可以跨session,被多个session共享，hibernate3默认开启二级缓存,也可以手动开启并指定缓存插件如ehcache,oscache 等。二级缓存也只能缓存对象。

三级缓存也叫查询缓存，查询缓存是针对普通属性结果集的缓存, 对实体对象的结果集只缓存id。对query.list()起作用，query.iterate不起作用，也就是query.iterate不使用查询缓存

二十一、Ssh的概述：

ssh是web开发中常见的一种框架 s-struts s-spring h-hibernate 其中struts在框架中充当控制器，实现MVC，主要用来处理用户的请求，和跳转页面。使项目结构清晰，开发者只需要关注业务逻辑的实现即可。

spring在ssh充当粘合剂，粘合struts-sping-hibernate，主要用来进行事物的控制，hibernate-充当数据库持久层，主要用它来与数据库交互，提高开发效率，减轻程序员sql控制要求，而且hibernate通过反射机制，有灵活的映射性，还支持各种关系，一对一，一对多，多对多。

在进行ssh整合的时候，我们应该注意： 1.Action继承于ActionSupport 引入struts-spring-plugin.jar包，从而完成struts和spring的整合

在struts2的action中注入service，保证service的名字和配置文件中的一致，并生成get,set方法

３０

Dao层继承于hibernateDaoSupport 在dao层的配置文件中注入sessionFactory

二十二、防止表单重复提交

针对于重复提交的整体解决方案： 1.用redirect来解决重复提交的问题 2.点击一次之后，按钮失效 3.通过loading 4.自定义重复提交过滤器 5.解决struts2重复提交

可以结合s:token标签来解决重复提交问题

利用token的原理：

1.在前端的jsp页面中加入s:token标签，在访问该页面时就会生成 隐藏域，该隐藏域中包含一个随机生成的字符串，并把该字符串

存入session中

2.在struts2的配置文件中加入token拦截器后，当正常访问action 的时候，会从session中取出该字符串，然后和页面隐藏域中提交 字符串做对比，如果一致则正常执行并删除session中存储的字符串。

二十三、JSP标签：

1.JSP include动作

jsp:include 动作

以“ ” 结束 比如：

2.JSP指令：<%@ include%><%@

%>

以“<%@ ” 开始，以“%> ” 结束。比如：

<%@ include file = “ Filename” %> 3.JSP输出表达式：<%= %><%=Java表达式 %>

输出变量的值，后边不能加<%=;%> 4.JSP Scriptlet【脚本】:<%;%> <% Java 代码 %>

例子：

<% Calendar now = Calendar.getInstance();%> 5.JSP声明：<%!%> <%!函数或者方法 %>

例子：

<%!String getHello(String name){ return “Hi,” + name + “!”;}

%> 6.迭代标签： ３１

Jstl中的核心标签（core）7.JSP注释：

<%--这也是注释,但客户端不能查看到--%> 8.el表达式：${} 9.jsp:include动作是在运行时动态包含。

@include指令是在编译时包含。

它们两个都只能包含本项目的相关文件，不能包含其他项目的。

如果要包含其他项目的文件可以使用c:import 二

十四、过滤器

filter的概述: filter是一个过滤器，用来在请求前和响应后进行数据的处理。

filter的生命周期是: 实例化--->初始化(init)-->进行过滤(doFilter)--->销毁(destroy)-->释放资源

一个Filter必须实现javax.servlet.Filter接口

在项目中我们通常通过filter进行编码转换，进行安全验证，进行重复提交的判断。

了解(不需要主动说)filter 相当于 拦截器 相当于Spring AOP servlet+jsp+javabean+jdbc+filter encodingFilter org.leopard.filter.EncodingFilter

encode

utf-8 encodingFilter *

二十五、拦截器的理解

什么是拦截器：

拦截器是AOP中的概念，它本身是一段代码，可以通过定义“织入点”，来指定拦截器的代码在“织入点”的前后执行，从而起到拦截的作用

正如上面 Struts2的Reference中讲述的，Struts2的Interceptor，其拦截的对象是Action代码，可以定义在Action代码之前或者之后执行拦截器的代码。在项目中，我们经常用来拦截通过非正常程序而进行的访问

３２

Struts2的拦截器和Servlet过滤器类似。在执行Action的execute方法之前，Struts2会首先执行在struts.xml中引用的拦截器，在执行完所有引用的拦截器的intercept方法后，会执行Action的execute方法。

其中intercept方法是拦截器的核心方法，所有安装的拦截器都会调用之个方法。在Struts2中已经在struts-default.xml中预定义了一些自带的拦截器，如timer、params等。如果在

标签中继承struts-default，则当前package就会自动拥有struts-default.xml中的所有配置。代码如下：

...

拦截器是Struts2框架的核心，它主要完成解析请求参数、将请求参数赋值给Action属性、执行数据校验、文件上传等工作

在struts-default.xml中有一个默认的引用，在默认情况下（也就是中未引用拦截器时）会自动引用一些拦截器。struts2中默认的拦截器是defaultStack.自定义拦截器需要特别注意的是不要忘记引入struts2默认的拦截器。为了实现某些操作，我们可以自定义拦截器，自定义拦截器有三种方式定义。分别为实现Interceptor接口，继承抽象类AbstractInterceptor，继承MethodFilterInteceptor类。拦截器在项目中的运用：

同时可以减轻代码冗余，提高重用率。

如果要求用户密码、权限等的验证，就可以用自定义的拦截器进行密码验证和权限限制。对符合的登入者才跳转到正确页面。

二十六、Spring融入框架

我们通过在web.xml中配置ContextLoaderListener这个监听器也加载 spring的配置文件，从而融入到项目框架中。

二十七、项目的部署方式

1、如果项目单独部署到tomcat中的时候，应该看tomcat中的server.xml;

2、如果和eclipse结合使用进行项目部署的时候，应该看eclipse里面的server.xml.数据库篇

一、JDBC连接数据库步骤(以MYSQL为例)

1、加载JDBC驱动程序：

通过Class类的forName方法实现，并将驱动地址放进去

成功加载后，会将Driver类的实例注册到DriverManager类中。

３３

2、提供JDBC连接的URL、创建数据库的连接

•要连接数据库，需要向java.sql.DriverManager请求并获得Connection对象，该对象就代表一个数据库的连接。

•使用DriverManager的getConnectin()方法传入指定的欲连接的数据库的路径、数 据库的用户名和密码。

Connection con=DriverManager.getConnection(url , username , password);&&&:“jdbc:mysql://localhost/test?user=root&password=123&useUnicode=true&characterEncoding=utf-8”;

3、创建一个Statement

•要执行SQL语句，必须获得java.sql.Statement实例

•执行静态SQL语句。通常通过Statement实例实现。

•执行动态SQL语句。通常通过PreparedStatement实例实现。

String sql = “”;

Statement st = con.createStatement();

PreparedStatement pst = con.prepareStatement(sql);

4、执行SQL语句

Statement接口提供了executeQuery、executeUpdate、execute三种方法

executeQuery：执行select语句，返回ResultSet结果集

ResultSet rst = pst.executeQuery();

• executeUpdate：执行insert、update、delete语句

pst.executeUpdate();

5、关闭JDBC对象

操作完成以后要把所有使用的JDBC对象全都关闭，以释放JDBC资源。

二、数据库连接池

数据库连接池的优点运行原理: 在我们不使用数据库连接池的时候，每次访问数据库都需要创建连接，使用完成之后需要释放关闭连接，而这样是很耗费资源的。当我们使用 数据库连接池的时候，在tomcat启动的时候就创建了指定数量的连接，之后当我们程序使用的时候就直接从连接池里面取，而不需要创建，同理，当我们使用完的时候也不需要关闭连接，而是将连接返回到连接池中，供 其他请求继续使用。

DBCP：比较稳定。C3P0: 性能比较高。

３４

三、mysql的数据库导入导出

配置：

首先找到mysql的安装目录，进入bin目录下复制路径 将mysql的bin目录粘贴在计算机环境变量的path中 授权：

登录mysql 将某张表的某个权限赋给某个用户

grant [select,insert,update,delete,create,drop] on [databaseName].[tableName]

to [userName]@[userIP] identified by [„连接口令‟]

grant select,insert,update,delete,create,drop on oa_ssh.user to root@[IP] identified by 'root';将所有库的所有权限赋给某个用户

grant all privileges on *.* to [userName]@[userIp] identified by [„连接口令‟] grant all privileges on *.* to root@[IP] identified by „root';将所有库的所有权限赋给所有用户

grant all privileges on *.* to root@'%' identified by „root‟;

导出本地数据库：

mysqldump-u 用户名-p 数据库名 > 磁盘：导出的文件名(加后缀)

远程导出数据库：

mysqldump-h IP-u 用户名-p 数据库名称 >导出的文件名(加后缀)

远程导出数据表：

mysqldump-u root-p-d--add-drop-table 数据库名称 > 导出文件

名(加后缀)

导入数据：

mysql-u root-p登录成功后 ==》 source 磁盘：导入的文件名(加后缀)

四、jdbc分段批量提交的时候出现异常怎么处理?

通过Map来解决性能问题。首先在分段批量提交的时候，我们不采用事务，这样就保证了合法的数据就自动提交，不合法的数据就自己自动进行回滚，为了避免不合法数据影响后续合法数据的提交，采用定义业务规则字典表，实现对数据的验证，将不合法的数据记录下来，供用户进行后续处理，而合法的数据就全部提交。

五、jdbc批量处理数据

批量处理数据:(代码优化:提高程序执行性能)

３５

降低了java程序代码(客户端)和数据库之间的 网络通信的次数。

在jdbc中进行批量插入的核心API为 addBatch,executeBatch

大数据量的插入问题:（jdbc,hibernate,ibatis）

1.每次只插入一条和数据库交互多次(很耗时间)

2.批量插入和数据库只交互一次(内存溢出)

3.分段批量插入(推荐)

jdbc批量处理数据是通过PreparedStatement对象的 addbatch(), executebatch（）clearbatch()进行和数据库的交互。通常我们使用分段批量处理的方式 这样可以提高程序的性能，防止内存溢出。

1.每个sql语句都和数据库交互一次(非批量操作)2.只和数据库交互一次(批量操作)(内存溢出)当数据达到一定额度的时候就和数据库进行交互，分多次进行(分段批量操作)

(500或者1000)pst.addBatch();if(i > 0 && i%1000 == 0){

pst.executeBatch();

pst.clearBatch();}

六、Oracle分页

select * from(select * from(select s.*,rownum rn from student s)where rn<=5)where rn>0

七、Oracle的基本数据类型

Oracle的基本数据类型（常用）：

1、字符型

Char 固定长度字符串

占2000个字节 Varchar2 可变长度字符串 占4000个字节

Nvarchar2 占2000个字符（最多能存2000个字母/中文）

2、大对象型（lob）

Blob ：二进制数据 最大长度4G Blob 用于存一些图片，视频，文件。

３６

比如：当我们在进行文件上传时，我们一般把上传的文件存在硬盘上，可以不占用 数据库，下载时，如果项目迁移时，文件也要跟着迁移。因此我们可以把用blob把它存在数据库中。但这样也增加了数据库的负担。

Clob ：字符数据 最大长度4G，可以存大字符串

varchar2和nvarchar2都具有一定的局限性，它们长度有限，但数据库中无论用varchar2或nvarchar2类型，还是用clob，在java端都使用String接收。

3、数值型

Integer 整数类型，小的整数。Float 浮点数类型。Real 实数类型。

Number（p,s）包含小数位的数值类型。P表示精度，s表示小数后的位数。

Eg: number(10,2)表示小数点之前可有8位数字，小数点后有2位。

4、日期类型

Date 日期（日-月-年）DD-MM-YY(HH-MI-SS)Timestamp 跟date比 它可以精确到微秒。精确范围0~9 默认为6.八、id、rowid、rownum的区别

rowid物理位置的唯一标识。

而id是逻辑上的唯一标识，所以rowid查找速度要快于id,是目前最快的定位一条记录的方式

rowid和rownum都是”伪数列“ 所谓“伪数列”也就是默认隐藏的一个数列。rownum用于标记结果集中结果顺序的一个字段，它的特点是按顺序标记，而且是连续的，换句话说就是只有有rownum=1的记录，才可能有rownum=2的记录。rownum关键字只能和<或者<=直接关联 如果是>或者=则需要给他起个别名

九、主键和唯一索引的区别？

在创建主键的同时会生成对应的唯一索引，主键在保证数据唯一性的同时不允许为

空，而唯一可以有一个为空数据项，一个表中只能有一个主键，但是一个主键可以

有多个字段，一个表中可以有多个唯一索引。

十、Preparedstatement和statement的区别

用Prepared statement进行开发。Prepared statement是预编译的，而statement不是，在每次执行sql语句的增删改时，如果是一条数据两者没差距，但如果数据量大于1，那么每次执行sql语句statement都要重新编译一次，而Prepared statement不用，Prepared statement的运行效率大于statement；从代码的可维护性和可读性来说，虽然

３７

用Prepared statement来代替statement会使代码多出几行，但这样的代码无论从可读性还是可维护性来说，都比直接使用statement的代码高很多档次；最重要的一点，从安全角度来说，使用Prepared statement可以大大提高程序的安全性，因为Prepared statement是用„？‟传参,可以防止sql注入，具有安全性，而statement用的是„+‟字符串拼接，安全性较低。

十一、数据库三范式

第一范式：数据库表中的所有字段值都是不可分解的原子值。

第二范式：需要确保数据库表中的每一列都和主键相关，而不能只与主键的某一部

分相关（主要针对联合主键而言）

第三范式：需要确保数据表中的每一列数据都和主键直接相关，而不能间接相关

十二、视图概述

视图可以视为“虚拟表”或“存储的查询”

创建视图所依据的表称为“基表”

视图的优点：

提供了另外一种级别的表安全性:隐藏了一些关键的字段

简化的用户的SQL命令

隔离基表结构的改变

十三、存储过程概述

存储过程（Stored Procedure）

可以包含逻辑判断的sql语句集合。

是经过预编译，存在于数据库中。

通过调用指定存储过程的名字（可有参，可无参）来执行。优点：

简化了复杂的业务逻辑，根据需要可重复使用

屏蔽了底层细节，不暴露表信息即可完成操作

降低网络的通信量，多条语句可以封装成一个存储过程来执行

设置访问权限来提高安全性

提高执行效率，因为它是预编译以及存储在数据库中 缺点：

可移植性差，相同的存储过程并不能跨多个数据库进行操作

大量使用存储过程后，首先会使服务器压力增大，而且维护难度逐渐增加

存储过程的语法：

--下面是在oracle数据库下最基本的语法

３８

--仅创建一个名为testProcedure 的无参的存储过程--IS也可以是AS--如果已经存在名为 testProcedure 的存储过程，下面的语法会出现 名称已被使用的错误

--解决办法：

--第一句可以写成 create or replace procedure testProcedure--这样会替换原有的存储过程

--NULL表示任何可以正确执行的sql 语句，但至少一句

create procedure testProcedure IS BEGIN

NULL

END;

存储过程的参数的分类: IN OUT INOUT

注意：

存储过程之间可相互调用

存储过程一般修改后，立即生效。

十四、索引概述

1、索引的概念

索引就是为了提高数据的检索速度。

数据库的索引类似于书籍的索引。

在书籍中，索引允许用户不必翻阅完整个书就能迅速地找到所需要的信息。

在数据库中，索引也允许数据库程序迅速地找到表中的数据，2、索引的优点

３９ 而不必扫描整个数据库.1.创建唯一性索引，保证数据库表中每一行数据的唯一性

2.大大加快数据的检索速度，这也是创建索引的最主要的原因

3.减少磁盘IO（向字典一样可以直接定位）

3、索引的缺点

1.创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加

2.索引需要占用额外的物理空间

3.当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，降低了数据的维护速度

4、索引的分类

1.普通索引和唯一性索引

普通索引：CREATE INDEX mycolumn_index ON mytable(myclumn)

唯一性索引：保证在索引列中的全部数据是唯一的

CREATE unique INDEX mycolumn_index ON mytable(myclumn)

2.单个索引和复合索引

单个索引：对单个字段建立索引

复合索引：又叫组合索引，在索引建立语句中同时包含多个字段名，最多16个字段

CREATE INDEX name_index ON userInfo(firstname,lastname)

3.顺序索引，散列索引,位图索引

４０

十五、必背的sql语句

1：oracle 分页

select * from(select t.*, rownum rn from(select * from menu order by id desc)t where

rownum < 10)where rn >=5

2: mysql 分页

select * from music where id limit 5,5

3：oracle中如何快速将一张表的数据复制到另外一张表中(另外一张表不存在，另外一张

表存在，但数据为空)

1、.不存在另一张表时：

create table 新表

as select * from 将要复制的表

2、存在另一张表时：

insert into 新表名

select 字段

from 将要复制的表名

4：音乐专辑

查询出special 表中的id 专辑名 并下面有多少首歌曲

Select s.id , min(s.sname),count(m.mid)from special s inner

join ms m on s.id=m.id group by s.id

5：快速删除一张表（不可事物回滚，也就是没有日志记录）

TRUNCATE from 表名

6：inner join

select 查找信息 from 表名 1 inner join 表名2 on 表名1.列名 = 表名2.列名

7：left join

左外连接

select 查找信息 from 表名1 left join 表名2 on 表名1.列名 = 表名2.列名

8：right join

右外连接

select 查找信息 from 表名1 right join 表名2 on 表名1.列名 = 表名2.列名

４１

9：oracle中查询遍历树形结构（start with）

select * from extmenu

start with pid=1 connect by prior id = pid

快速删除父节点以及父节点下的所有节点： Delete from extmenu where id in(elect * from extmenu

start with pid=1 connect by prior id = pid)

10：查询出来60-70,80-90,95-100学生的信息

select * from stu where chengji between 60 and 70 or between 80 and 90 or between 95 and 100 select * from stu where chengji > 60 and chengji < 70 or chengji > 80 and chengji < 90 or chengji > 95 and chengji < 100

11：用exists替换in------进行联表查询

select * from dept where exists(select * from emp where emp.deptno=dept.deptno);或

select * from dept d inner join emp e on d.deptno = e.deptno(只查询出两表共同拥有的字段数据)

12：删除表中的重复数据：

delete from xin a where a.rowid!=（select max(b.rowid)from xin b

where a.name = b.name);13：row_number()，rank()over，dense_rank()over 按工资排序

select sal，row_number()over(order by sal desc)rank1，rank()over(order by sal desc)rank，dense_rank()over(order by sal desc)drank

from emp

14：select * from(select emp.* from(dense_rank()over(partition by departNo order by sal desc)rk from emp)Where rk=4

４２

十六、ibatis批量

this.getSqlMapClientTemplate().execute(new SqlMapClientCallback(){ public Object doInSqlMapClient（SqlMapExecutor executor)

throws SQLException {

executor.startBatch();

for(int i = 0, n = list.size();i < n;i++){

executor.insert（”productAttach.insertProductAttach“，list.get(i));

}

executor.executeBatch();

return null;} });

ibatis,jdbc,hibernate的分段的实现: 都应该在组装list的时候进行拆分（如：action层加入）if(list.size()% 1000 == 0){ productAttachService.addBatch(list);list.clear();}

if(list.size()> 0)productAttachService.addBatch(list);

４３

业务场景篇

一、Spring的概述

Spring 是完全面向接口的设计，降低程序耦合性，主要是事务控制并创建bean实例对象。在ssh整合时，充当黏合剂的作用。

IOC(Inversion of Control)控制反转/依赖注入，又称DI(Dependency Injection)(依赖注入)

IOC的作用：产生对象实例，所以它是基于工厂设计模式的

Spring IOC的注入

通过属性进行注入，通过构造函数进行注入，注入对象数组

注入List集合 注入Map集合注入Properties类型

Spring IOC 自动绑定模式：

可以设置autowire按以下方式进行绑定

按byType只要类型一致会自动寻找，按byName自动按属性名称进行自动查找匹配.AOP 面向方面（切面）编程

AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向方面(切面)编程。

注：OOP(Object-Oriented Programming)面向对象编程

AOP 主要应用于日志记录，性能统计，安全控制,事务处理（项目中使用的）等方面。

Spring中实现AOP技术：

在Spring中可以通过代理模式来实现AOP

代理模式分为

静态代理：一个接口，分别有一个真实实现和一个代理实现。

动态代理：通过代理类的代理，接口和实现类之间可以不直接发生联系，而

可以在运行期（Runtime）实现动态关联。

动态代理有两种实现方式，可以通过jdk的动态代理实现也可以通过cglib

来实现而AOP默认是通过jdk的动态代理来实现的。jdk的动态代理必须要有

接口的支持，而cglib不需要，它是基于类的。

Spring AOP事务的描述：

在spring-common.xml里通过里面先设定一个表达式，设定对service里那些方法

如：对add* ,delete*,update*等开头的方法进行事务拦截。我们需 ４４

要配置事务的传播（propagation=”REQUIRED“）特性,通常把增,删,改以外的操作需要配置成只读事务（read-only=”true“）.只读事务可以提高性能。之后引入tx:advice,在tx:advice引用 transactionManager（事务管理）,在事务管理里再引入sessionFactory,sessionFactory注入 dataSource，最后通过 引入txAdvice。

Spring实现ioc控制反转描述：

原来需要我们自己进行bean的创建以及注入，而现在交给 spring容器去完成bean的创建以及注入。

所谓的“控制反转”就是 对象控制权的转移，从程序代码本身转移到了外部容器。

官方解释: 控制反转即IoC(Inversion of Control)，它把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管理。

所谓的“控制反转”概念就是对组件对象控制权的转移，从程序代码本身转移到了外部容器。

二、事务概述

在数据库中,所谓事务是指一组逻辑操作单元即一组sql语句。当这个单元中的一部分操作失败,整个事务回滚，只有全部正确才完成提交。

事务的ACID属性

1.原子性（Atomicity）

原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。

2.一致性（Consistency）

事务必须使数据库从一个一致性状态变换到另外一个一致性状态。(数据不被破坏)

3.隔离性（Isolation）

事务的隔离性是指一个事务的执行不能被其他事务干扰.4.持久性（Durability）

持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的.在JDBC中，４５

事务默认是自动提交的，每次执行一个 SQL 语句时，如果执行成功，就会向数据库自动提交，而不能回滚

为了让多个 SQL 语句作为一个事务执行：

（1）执行语句前调用 Connection 对象的 setAutoCommit(false);

以取消自动提交事务

（2）在所有的 SQL 语句都成功执行后，调用 commit();方法提交事务（3）在出现异常时，调用 rollback();方法回滚事务。

三、权限概述

权限涉及到5张表：

用户表，角色表，权限表(菜单表)，用户角色关联表，角色权限关联表

当用户登录时，根据用户名和密码到用户表验证信息是否合法，如果合法 则获取用户信息，之后根据用户id再到用户角色关联表中得到相关连的角色

id集合,之后根据角色id再到角色权限关联表中获取该角色所拥有的权限id集合，然后再根据权限id集合到权限表（菜单表）中获取具体的菜单，展现给当前 登录用户，从而达到不同用用户看到不同的菜单权限。

我们通过ZTree来给角色赋权并且通过ZTree来展示菜单，以及通过ZTree来管 理菜单即增加和编辑菜单。

我们做的权限控制到url级别,为了防止用户不登录直接输入url访问的这个弊端，通过拦截器进行拦截验证。

四、OSCache业务场景

在我以前的项目中，我们考虑了系统性能问题，这个时候我们采用了Oscache缓存，刚开始把这个功能交给了项目组中的另外一个同事来做的，但是他做完的时候他发现缓存中明明已经缓存了数据，但是在取得时候发现没有数据，我们项目经理让我去帮忙看看这个问题，我阅读完他的代码之后，我发现了他每次缓存的时候都是调用一个新的缓存对象的方法，结果出现了明明已经走了缓存的方法而取不到数据的问题，通过我多年的工作经验，我就想到了应该用单例模式去封装一个单例工具类来调用oscache。但是，在后来的测试过程中，发现当并发访问的时候也会出现上述的问题，这个时候我直接采取的DCL（双重判定锁）单例模式封装了工具类，既解决了线程安全问题，相对的性能问题也考虑到了，这个问题才得到了完善的解决。

４６

五、线程概述

线程的状态以及状态之间的相互转换：

1、新建状态(New)：新创建了一个线程对象。

2、就绪状态(Runnable)：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。

3、运行状态(Running)：就绪状态的线程获取了CPU，执行程序代码。

4、阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

(一)、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。

(二)、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。

(三)、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

5、死亡状态(Dead)：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

实现线程的两种方式：

是继承Thread类或实现Runnable接口，但不管怎样，当new了这个对象后，线程就已经进入了初始状态 wait和sleep的区别：

线程访问：

锁池状态，之后等待锁释放，然后访问代码

wait

等待队列(释放资源)--->调用notify或者notifyall之后锁池状态--->(等待锁释放)--->可运行状态--->运行状态---->访问代码

sleep,join

不释放资源-->结束后直接进入可运行状态--->运行状态---->访问代码

一个java控制台程序，默认运行两个线程，一个主线程，一个垃圾回收线程。线程与进程的区别：

1.线程(Thread)与进程(Process)进程定义的是应用程序与应用程序之间的边界，通常来说一个进程就代表一个与之对应

的应用程序。不同的进程之间不能共享代码和数据空间，而同一进程的不同线程可以共

享代码和数据空间。

2.一个进程可以包括若干个线程，同时创建多个线程来完成某项任务，便是多线程。

六、Ajax请求Session超时问题

我在做项目时有时会遇到session超时问题，如果session超时，平常请求没有什么问题，通过拦截器可以正确跳到登陆页面，可是你如果用ajax请求的话这就出现问题了，因为ajax是异步的，局部刷新，所以登陆界面不会再全页面中显示，他只会显示到页面的一部分当中。所以根据我这几年的经验找到了我认为比较好的一种方法。因为那我用的框架是和struts2集成的，所以就在拦截器中进行设置：

４７

首先判断session是否为空就是判断session是否超时，如果超时就取出请求的head头信息request.getHeader(”x-requested-with“)，如果不为空就和XMLHttpRequest(Ajax标识)进行比较(request.getHeader(”x-requested-with“).equalsIgnoreCase(”XMLHttpRequest“)))如果相等说明此请求是ajax请求。

如果是ajax请求就可以用response.setHeader(”键“,”值“)来设置一个标识来告诉用户这是ajax请求并且session超时时发出的，这样我就可以在回调函数中取出自己设置的那个唯一标识：XMLHttpRequest.getResponseHeader(”“);如果取出的值是和自己在后台中设置的值一样的话，就证明session已经超时，这样就可以设置window.location.replace(”登陆界面")，来跳转到登陆界面了。

这样做虽然解决了问题，但是，会在每个回调函数中写入那些代码，这样的话代码就会显得特别零散，所以就想能不能定义一个全局的设置所以就找到了jqery的ajaxSetUp方法，通过ajaxSetUp对jqery的ajax进行全局的判断(ajaxSetUp就相当于ajax的拦截器)，通过设置ajaxSetUp里的complete，它就相当于回调函数，这样那就弥补了上一方法的不足。我做项目时还用到$(document).ajaxStart()，这是ajax请求时的事件；$(document).ajaxSuccess()，这是AJAX请求成功后的事件。我一般用他们来显示遮罩层和隐藏遮罩层用的加遮罩层是为了不让用户重复提交，更提高了用户体验度，让用户知道已经提交了。

七：java线程池概述

java线程池的工作原理和数据库连接池的差不多，因为每次重新创建线程 都是很耗资源的操作，所以我们可以建立一个线程池，这样当需要用到线程 进行某些操作时，就可以直接去线程池里面找到空闲的线程，这样就可以直接 使用，而不用等到用到的时候再去创建，用完之后可以把该线程重新放入线程池 供其他请求使用从而提高应用程序的性能。

线程池的核心流程: 1.构建一个 ThreadPoolExecutor 并指定默认要创建的线程的数量 2.通过 threadPool.execute()去添加一个个要执行的线程即实现了Runable接口的java类

3.在实现了Runable接口的java类的run方法中写入具体的业务代码 线程池的业务场景：

我在工作的时候，当时一个同事给我提了一个需求，目前有大量的图片 需要处理生产缩略图并进行加水印，因为按照普通的处理方法一个个的 进行处理太慢了，问我有没有好的解决方案，这个时候我就想到了java中 的线程池，我构建了一个线程数为5个线程池，然后采用分段批量提取的

方式每500条为一组数据进行图片信息的提取，然后再把这些通过Threadpool的 execute方法交给线程池中的线程进行处理，即充分使用了CPU硬件资源又加快 了大数据情况下程序的处理效率。

４８

我当时在工作的过程中，认识一个做电商的朋友，他们当时公司才起步，很多 技术都不成熟，所以就常常和我探讨一些技术问题，有次他向我请教一个问题，问我如何才能提高网站的性能，我根据自己在项目中的经验以及自己以前阅读的

关于优化方面的资料给他提出了很多建议，如用lucene进行全文检索，用memcached 进行分布式缓存，以及通过spring定时器结合freeMarker模板引擎来生成静态 页面，由于要生成的页面的数量比较多，考虑到程序的性能，我建议他结合 java的线程池进行工作，这样就可以充分使用了CPU硬件资源又加快 了大数据情况下程序的处理效率。

八、OSCache概述

oscache是一个高性能的j2ee框架，可以和任何java代码进行集成，并且还可以通过标签对页面内容进行缓存，还以缓存请求。

我们通常将那些频繁访问但是又不是经常改变的数据进行缓存。为了保证缓存数据的有效性，在数据发生改变的时候，我们要刷新缓存，避免脏数据的出现。刷新缓存的策略有两种，一种是定时刷新，一种手动刷新。

缓存数据的时机通常也分为两种，即在tomcat(web容器)启动时候加载数据进行缓存，另外也可以在用户第一次访问数据的时候进行缓存，这个相当于缓存的立即加载和按需加载。

缓存的层次如下:jsp-->action-->service-->dao,缓存越靠前对性能的提升越大

一个action里面可以有多个service,一个service中可以有多个dao或者多个service

任何类之间都可以进行相互调用，可以通过构造函数传参，set,get传参或者是方法传

参将相关的类连接起来。

九、OSCache+autocomplete+单例业务场景

在我以前做某项目的过程中，其中我们在做产品列表的查询的时候为了提高用户的体验度，我们使用了autocomplete插件来代替select进行品牌的选择，才开始的时候每次都要根据用户输入的信息去查询数据库进行模糊匹配返回结果，后来我们考虑到系统的性能，因此我们采用了oscache缓存，才开始这个功能是交给我们项目组中的另外一个同事来做的，但是他做完后，我们在使用这个工具类的时候，发现有时缓存中明明已经有时我们需要的数据，但是从缓存里面取的时候，发现没有，之后项目经理让我去帮这个同事看看这个问题，我经过阅读他的代码发现，它里面在使用缓存的时候，针对于每次方法的调用都产生一个新的实例，结果导致了上面的问题，这个时候我想起了可以使用设计模式中的单例模式来解决这个问题，才开始我直接采用了普通的单列模式，但是后来在测试的过程中，发现当用户并发量大的时候还是会出现上面的问题，之后我再次考虑了代码，最后发现是因为没有给单列模式加锁的原因，从而导致了大用户并发的时候，线程安全的问题，之后我便在方法上加上了synchronized关键字，解决上述的问题，但是后来测试人员反馈，觉的这段的性能有问题，我考虑之后便采用在方法体内加锁并结合双重判定的方式解决了上面的问题。

４９

我们是将数据在tomcat启动的时候加载到缓存中，之后用户进行查询的时候直接从缓存中获取数据，根据前缀匹配进行查询，将结果返回给用户。这样在提高用户体验度的同时也提高性能。

十、缓存概述

应用程序为了提高性能，可以通过使用缓存来达到目的，缓存的存储介质可以 内存或者硬盘，通常将数据存储在内存里，确切的说是jvm的内存中，缓存是 基于Map这种思想构建的，以键值对的方式进行存取，之所以还可以将

缓存的数据存储在硬盘中，是因为内存资源相当有限和宝贵，所以当内存资源 不足的时候，就可以将其存储到硬盘中，虽然硬盘的存取速度比内存要慢，但是 因为减少了网络通信量，所以还是提高程序的性能。缓存可以分为客户端缓存和 服务器端缓存，所谓的客户端缓存通常指的是IE浏览器的缓存，服务器端缓存指 的web服务器的缓存，通常可以通过第三方组件实现，如oscache,memcache

我们通常将那些频繁访问但是又不是经常改变的数据进行缓存。为了保证缓存数据的 有效性，在数据发生改变的时候，我们要刷新缓存，避免脏数据的出现。刷新缓存的 策略有两种，一种是定时刷新，一种手动刷新。

缓存的层次如下:jsp-->action-->service(通常放置在service)-->dao, 缓存越靠前对性能的提升越大

缓存的策略:(缓存空间不足需要进行清理的时候使用)LRU:最近最少使用原则.(理解:存储书)FIFO:先进先出的缓存策略.(理解:排队)

你来说说缓存？说说你对缓存的理解（如果遇到重复的，就可以省略）

我们在项目中使用缓存的目的是为了提高应用程序的性能，减少访问数据库 的次数，从而提高应用程序的吞吐量。我们通常将权限，菜单,组织机构

这些频繁访问但是不经常改变的基础数据进行缓存，其中我在做()某某项目的时候 就通过oscache对ZTree的树形菜单进行了缓存，并且在做的时候和单列设计 模式进行结合，考虑到多线程下的安全问题，还对单例模式加入了双重判定锁 的检查方式。

十一、实现页面静态化业务场景

我们在做某项目时，涉及到程序访问的性能问题，这时候我们想到可以通过静态化来提高用户访问时候的性能，所以我们就采用了freemarker模板引擎，考虑到页面也是要有动态的变化的，所以我们采用spring定时器在每天晚上2点钟的时候定时再次生成html静态

５０