Java初级程序员面试必备的基础知识总结

admin

java基础
( d4 V2 Q- q$ U( G+ L5 [" J8 `

• 简述Java的基本历史
  3 E8 R6 ?+ T, @4 {9 D+ V0 U: m* R$ n5 e

java起源于SUN公司的一个GREEN的项目，其原先目的是：为家用消费电子产品发送一个信息的分布式代码系统，通过发送信息控制电视机、冰箱等

5 o" W# A* p5 w: W7 ^

• 简单写出Java特点，写出5个以上，越多越好
  

简单的、面向对象的、分布式的、安全的、稳定的、与平台无关的、可解释的、多线的、动态的语言。

• 什么是Java?
  ' ]& l) X( D- F. e; g3 P  y

JAVA：一种编程语言

一种开发环境

一种应用环境

一种部署环境

7 F1 B6 q/ m6 h

• 请写出Java的版本分类，以及每种版本的应用方向
  8 i- t. c% ?- j/ I) x) F$ _

三种版本：

JME：是面向内存有限的移动终端. 为消费性产品设计的；

JSE： 是SUN公司针对桌面开发和低端商务计算方案开发的版本。为笔记本电脑、PC机设计的；

JEE： 是一种利用JAVA 2平台来简化企业解决方案的开发、部署和管理相关的复杂问题的体系结构。 为企业级的、服务器端的高端应用而设计的；

• 描述Java技术的主要特性
  # R6 L# J; F) t6 G

java虚拟机

垃圾回收

代码安全性

• 描述 Java虚拟机的功能
  5 ?, T. p7 @8 o; [% H

（1）通过 ClassLoader 寻找和装载 class 文件

（2）解释字节码成为指令并执行，提供 class 文件的运行环境

（3）进行运行期间垃圾回收

（4）提供与硬件交互的平台

• 简述Java代码安全性
  

（1）编译时的错误检验

（2）类装载检查，把本机上的类和网络资源类相分离，在调入类的时候进行检查，因而可以限制任何“特洛伊木马“的应用
& U0 J* H+ y5 E

（3）字节码校验

（4）沙箱机制，限定访问权限

6 V4 [2 ]. P5 w- w4 ~/ C

• 描述Java垃圾回收机制
  ; z' C% M; \. H4 Z; v, ?: L

Java 编程语言解除了程序员释放内存的责任。它可提供一种系统级线程以跟踪每一次内存的分配情况。在 Java 虚拟机的空闲周期，垃圾收集线程检查并释放那些可被释放的内存。垃圾收集在 Java 技术程序的生命周期中自动进行，它解除了释放内存的要求，这样能够有效避免内存漏洞和内存泄露（内存泄露就是程序运行期间，所占用的内存一直往上涨， 很容易造成系统资源耗尽而降低性能或崩溃 。
8 l9 C) N$ E3 a$ j5 ~3 i

垃圾回收有以下特点：
. L" U& Y! b0 M3 b# V, P# m

（1）垃圾回收是一个自动的系统行为，程序员不能控制垃圾回收的功能和行为。

（2）有一些跟垃圾回收相关的方法，比如：System.gc( ) ,调用这些方法，仅仅是在通知垃圾回收程序，至于垃圾回收程序运不运行，什么时候运行，都是无法控制的。

（3）程序员可以通过设置对象为 null，来标示某个对象不再被需要了， 这只是表示这个对象可以被回收了，并不是马上被回收。
1 X9 a& t8 }1 [2 p4 b7 k+ _% S

* S: z* g- Y, c5 T1 ^

• 简述Java代码的运行过程
  4 U7 Q6 f1 i/ l' @

（1）加载代码 通过类装载器装载CLASS文件

（2）校验代码 由字节码校验

（3）执行代码 由解释器将字节码转换成机器码

% s. ?( B+ C0 p; m$ A

• 简述如何搭建Java开发环境
  5 \/ `! Z2 u  s+ I

首先下载安装JDK 然后配置环境

（1）配置PATH，

（2）配置CLASSPATH

（3）配置JAVA_HOME

• 简述classpath，path，JAVA_HOME的意义和配置方法
  

path 操作系统运行环境的路径

classpath JAVA运行应用程序时所需要的类包的路径

JAVA_HOME 供需要运行JAVA的程序使用

) Q8 e6 l1 l8 ]5 o* j1 M4 y

• 请描述：一个完整的Java文件的代码分几个部分，每部分都起什么作用，大致的写法
  

package 当前类所在位置

import 当前类运行时所需要的包或类

public class 类名 {

属性定义;

方法定义:

构造方法定义;

public static void main(String args []) 例外{ 程序入口

语句;

}

}

//注释

9 {; ^9 p" [; z8 V

• Java代码的注释有几种？分别举例说明
  - \+ G) `6 [* @; q4 e* p: y" W

（1） // 单行注解

（2） /* */ 块注释

（3） /* *

* 文档注释

*/

4 q3 C# @8 l+ Q- I/ E6 U

• 什么是Java代码的语句，什么是Java代码的块，举例说明
  % p4 @3 {5 u& I) N4 s) I; f

语句 是一行以分号终止的代码,例：int a;

块 是以{ }为边界的一些语句的集合 例：public void tt( ){}

: V7 _2 |( }8 y5 a! t, a: W

• 什么是标示符？
  . \' A$ L( I0 D' ]* V; a7 c标识符：是赋予变量、类、方法的名称。
  

) _6 S) n2 T8 g5 L  ^+ x% G

• 标示符定义的规则？
  6 v7 E. S# v8 d5 i/ A9 ^$ I3 G
  • 首字母只能以字母、下划线、$开头,其后可以跟字母’下划线、$和数字配置CLASSPATH
  • 首字母小写中间用大写字母隔开
  • 标识符具有一定的含义
    6 w8 H1 v% s6 w. n5 U
• 什么是关键字？
  关键字就是编程语言与机器语言的编码约定
  

7 j3 o- [6 w6 Z/ h  w) j+ L

• true、false、null、sizeof、goto、const那些是Java关键字
  2 K1 I  x5 ?+ O/ Ktrue 、false 、null 为JAVA的关键字
• Java的基本数据类型有几种？分别是？
  6 m/ w* R- `, Fshort int long boolean float double char byte
  

% `* H2 r' j6 L1 H0 n# ~# z% ]

• 请写出每种基本类型的默认值？取值范围？分别给出一个定义的例子
  
  默认值         取值范围 示例
  
  

字节型 ： 0 -2^7—-2^7-1 byte b=10;

字符型 ： ‘ ′ 0—-2^16-1         char c=’c’ ;

short : 0 -2^15—-2^15-1 short s=10;

int : 0 -2^31—-2^31-1 int i=10;

long : 0 -2^63—-2^63-1     long o=10L;

float : 0.0f -2^31—-2^31-1 float f=10.0F

double : 0.0d -2^63—-2^63-1 double d=10.0;

boolean: false truealse boolean flag=true;

• 在基本类型中，如果不明确指定，整数型的默认是什么类型？带小数的默认是什么类型？
  

整数类型 默认为 int

带小数的默认为 double

$ K% U7 e1 l" e( L; ]4 f/ E. E

• 如何定义float类型和long型
  

float f = 1.2f

long l = 1.2L

" L* K  n( g/ ]  p% L7 [# f

• 什么是变量？
  4 I( ?; g, P. S& ?* c

变量是用来引用一块内存区域或一个值，用标识符来表示，可以通过操作变量来操作变量所对应的内存区域或值块的值。

• 变量的定义规则？
    [# a" {3 s& t# `2 d
  • 以字母、$、下划线开头，其后可以跟字母、下划线、$和数字；
  • 首字母小写，中间单词用大写字母隔开；
  • 名称具有一定含义；
    ; R9 e; G) Y: M: Q9 H# u: y7 q

• 请写出Java编码约定中对下列部分的要求：类、属性、方法、包、文件名、变量、常量、控制结构、语句行、注释
  9 @+ u: [& g8 K) P  l$ L

类： 一个类文件中类名要和文件名相同，类名一定要以大写字母开头，单词之间用大写字母分隔

属性： 属性名首字母小写，中间用大写字母隔开。

方法： 方法名首字母小写，中间用大写字母隔开。

包： 引用包必须写在类文件的开头,有且只能有一个包，全部用小写字母。

控制结构：当语句是控制结构的一部分时，即使是单个语句，也应使用大括号将语句封闭。

语句行：每行只写一个语句，并使用四个缩进的空格，使代码更易读，注意用分号结束。

注释： 用注释来说明那些不明显代码的段落。

常量： 常量名一般用大写字母，单词之间用下划线分隔，一旦赋值不允许修改。

/ R! R" @% N0 F% N

• 什么是Javadoc?
  0 t0 v% h4 w' Y# ~3 r

按照一定格式生成程序的文档的工具。

• 什么是引用类型？
  用户定义类型, 它可引用类和数组。
  

除去基本数据类型的其他类型都是引用数据类型。

• 什么是按值传递？什么是按引用传递？
  % M# N! S, W# c$ o$ n% K$ N- F! |

按值传递：就是将该值的副本传过去（基本数据类型+String类型的传递，就是按值传递）

按引用传递：就是将值的内存地址传过去（除基本数据类型+String以外类型的传递，就是引用传递）

• 如何创建一个新对象？如何使用对象中的属性和方法？
  , T2 H& Q' A7 Y- ^+ T) d, |. l

使用new 关键字来创建一个新的对象；

通过对象的实例用”.“(点)来调用对象中的属性和方法；

静态的方法和属性，也可以直接用类名”.“（点）来调用；

• 简述new关键字所做的工作
  . H, b% Q/ u1 t6 I; ^new 创建一个对象，并为对象分配一块内存。
    p0 Z# c- B& P

• 简述”=” 和”= =”的功能和区别
  ; A! t) B: f7 Q9 H0 Z

“=” 赋值,

“= =”当比较基本数据类型的时候，判断前后两个值是否相等；

当比较引用数据类型的时候，判断= =前后两个值的内存地址是否相等；

区别：

= ：为赋值表达式

= = ：为逻辑表达式

• 什么是实例变量？什么是局部变量？什么是类变量？什么是final变量？
    J' w+ O: U/ y" J6 ]8 [

实例变量：     类中定义的变量，即类成员变量，如果没有初始化，会有默认值；

局部变量：     在方法中定义的变量，必须初始化；

类变量：     用static修饰的属性；

final变量：     用final 修饰的变量，

• 简述上述各种变量的定义规则和使用规则？
  

实例变量：    不需要static关键字来声明，需要类的实例（对象）调用（用”.“）；

类变量：        用static修饰，可以用类名调用，也可以用类的实例调用；

局部变量：    在方法内任意定义变量即为局部变量；

final变量：    一旦赋值，不可以再修改的变量；

final属性只允许赋值一次，且只能通过构造方法赋值，定义后也就是一个常量；

final修饰的变量，只允许赋值一次

• a++和++a的区别？
  

a++ ： 先使用，后加1

++a ： 先加1，后使用

• 请描述instanceof、?:、&、&&各自的功能
  6 U# B" T# C: ]
  instanceof ：用来判断某个实例变量是否属于某种类的类型。
  
  " p7 W1 d, m1 c9 a( C( Z8 G0 j

? : 三目运算符：

表达式1?表达式2:表达式3

如果表达式1为true，执行表达式2，否则执行表达式3

&： 位运算：按位与 |

&&： 逻辑运算：逻辑与

• 请描述>>、<<、>>>的功能
  

10>>4 ：算术或符号右移位运算符

<< ：算术或符号左移位运算符

>>> ：逻辑或无符号右移位运算符

* y' g! `7 O" n" I. V

• 请描述什么是强制类型转换？什么是自动类型转换？什么是向上造型？并分别举例说明
  3 Q& `) E4 j8 @+ l8 U: m7 |. A
  强制类型转换：在一个类型前面加( )，来强制转换
  
  0 Q# p2 {9 ^' T+ R9 E' }

long l = 9L;

int i = (int)l;

自动类型转换：

int i = 5;

String str = “”+i;

向上造型：把范围小的造型为范围大的类型：

int i = 2;

long l = i;

• 请写出完整的if条件控制语句的结构
  

if(布尔表达式){

语句

}else{

语句

}

• 请写出完整的switch语句的结构
  + m1 D  }/ z% v/ c/ j& u
  switch(字符){
  
  . v, k+ Y( L  t# {1 N

case 字符: 语句

break;

case 字符: 语句

break;

default:语句

}

" K2 u( Z1 e) E- Z) v

• 请写出完整的for语句的结构
  

for(初始语句;条件语句;步长){

}

# `$ S4 A: G+ j

• 请写出完整的while语句的结构
  

while(boolean语句){

}

6 v7 z* Y: x- t% A$ W5 [8 c9 B+ j6 \

• 请写出完整的do while语句的结构
  $ d9 a; B, T2 G% \. B- \

do{

}while(boolean语句);

4 B6 R7 ?& Y- M

• 请描述break 和 continue的功能和用法
  8 N& U' _' o4 j; m) Y

break：终止（跳出）最近的循环

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

• 定义一个一维的int数组，先创建它，并初始化它，给它赋值，然后输出其中的一个值
  & n& Q# u; @! f: k3 N3 v6 a

public class Arr{

public static void main(String args[]){

int a[] = new int[5];

a={1,2,3,4,5};//错误 , 只能在初始化时这样做

a[0]=1;

a[1]=2;

System.out.println(a[0]);

}

}

2 X. m  g' L* m" u8 t0 ~

• 定义一个一维的A类型数组，直接定义并赋值，然后输出其中的一个值
  

public class A{

public static int i;

public static void main(String args[]){

A aa = new A( );

A bb = new A( );

A a[] = {aa,bb};

a[0].i=2;

System.out.println(a[0]);

}

}

8 m0 p6 t) N1 A; W3 p- G5 t3 x1 ]) ?

• 把上面的数组改成2维的数组
  

public class A{

public static int i;

public static void main(String args[]){

A a[ ][ ] = new A[5][5];

a[0][0].i=2;

System.out.println(a[0][0]);

}

}

• 举例说明数组拷贝方法的使用：arraycopy方法
  / h$ b/ h! s# w, a! N% N1 x, U
  public class A{
  
  

public static void main(String args[]){

int a[] = new int[5];

int b[] = new int[5];

System.arraycopy(a[5],0,b[5],0,a.length)

System.out.println(b[0][0]);

}

}

• 什么是构造和析构方法？功能是？
  0 _* D, A1 B6 y; \6 _6 g' \" [

构造方法：每个类至少有一个构造方法，类初始化时调用的方法

1．方法名和类名相同

2．无返回值类型

格式：访问权限 类名(参数列表) {}；

1．自己定义构造后，就没有默认的构造方法

2．无构造方法时，默认为空参的构造方法(无参数,方法体为空)
0 ^% _) J5 O- R5 G7 R$ N析构方法：finalize

类销毁时，自动调用方法

当对象在内存中被删除时,自动调用该方法

在此方法中可以写回收对象内部的动态空间的代码

• 简述Java的访问修饰符类型？分别有什么功能？
  # N* J5 `: m$ ^+ O6 {7 {) f4 `

public 公开的，任何一个类都有可以访问

protected 同包同类,只可被它的子类访问

default 只能被同一个包中类访问

private 私有的，只能在本类中被访问

# z' u$ o) t8 [" k" h/ ~6 H



! t/ O3 u$ @1 m! ]" g6 |
, K4 l* o' h4 s" E3 a2 t8 X
2 X. B% @: z* @& x- d


9 ~' N: G# V# O9 d% S# o5 H" B

• 分别说明：在类上、在属性上、在方法上能使用哪些访问修饰符
  2 j* o- V" u1 D( {2 S+ ~9 J

在类上：public default final

在方法上： 访问权限：public protected private default

方法修饰符：static

final

返回类型：void

在属性上：public protected private default

static

final

• 简述什么是包？包的功能
  

包：对所定义的多个JAVA类进行分组，将多个功能相关的类定义到一个包(文件)中。

功能：1.易于查找和使用适当的类

2.包不止包含类和接口,还可以包含其它包,形成层次的包空间

3.有助于避免命名冲突

5 G( O3 p* }; ~2 S9 i4 T9 ]

• 请写出5个以上的JDK中的包，以及他们的基本功能
  

java.awt： 包含构成抽象窗口工具集的多个类，用来构建和管理应用程序的图形用户界面

java.lang： 提供java编成语言的程序设计的基础类

java.io：　 包含提供多种输出输入功能的类，

java.net：　 包含执行与网络有关的类，如URL，SCOKET，SEVERSOCKET，

java.applet： 包含java小应用程序的类

java.util：　 包含一些实用性的类

• 什么是包装类？Java中都有哪些包装类
  在JDK中针对各种基本类型分别定义相应的引用类型 ————–称为封装类
  

Boolean Byte Short Integer Long Float Double Character

• OOP（面向对象）语言的三大特征是？
  9 b: K7 n' d* z( O' F/ p封装性，继承性，多态性
  

• 分别表述类的三大特性及其他们的功能
  

封装：隐藏类的实现细节、迫使用户去使用一个接口去访问数据、使代码更好维护

继承：子类可以直接继承使用父类的方法，程序员只需要做的是定义额外特征或规定将适用的变化

多态性：同一个行为具有多个不同表现形式或形态的能力

• 如何实现继承？继承的规则？
  

public class A extends B{

}

• 单继承性
• 构造方法不能继承
• super引用父类，调用父类的属性，方法
• 当子类中出现与父类的方法名，返回类型，参数列表相同的方法时要覆盖此方法
  ! P$ u! D! E5 A& o# u) x

• 简述this和super的功能和用法
  + |: R& a- i2 b

this ：

• 能访问除构造方法以外所有的属性、方法，通过this.　来调用方法和属性
• 不可以在静态方法中使用，
• 在调用其它构造方法时，必须放在该构造方法的第一行
• 在构造方法中使用this(参数列表)，相当于调用本类的其它构造方法，它必须作为构造方法的第一句
  

super ：访问父类

• super. 点取父类中被子类隐藏的方法和属性，
• 通过 super(参数列表) 来调用父类的属性和方法，在调用父类的构造方法时必须放在子类构造方法里的第一行；
  

• 如何确定在多态的调用中，究竟是调用的那个方法？
  # C: i/ K1 _$ W1 q( x: Hnew的是哪一个类就是调用的哪个类的方法。
  

6 s2 |1 b: s6 T3 w4 s# p

• 请描述方法定义的完整的语法结构
  1 _4 m9 b% e& U; |1 C4 |# i

权限修饰符 修饰符 返回类型 方法名(参数) 例外{

方法体;

}

• 什么是重载？
  在一个类中出现方法名相同，但参数列表不同时，这种情况就是重载。
  ( F% A( w! c0 A9 V- F

# G. i2 R2 V0 u5 n$ ~

• 简述重载的规则
  
  • 方法名称必须相同；
  • 参数列表必须不同（个数不同，或类型不同，或参数排列顺序不同）；
  • 与返回类型无关；
    & X2 H4 }( k+ [
• 什么是方法的覆盖？什么情况下出现？
  ( ~7 X7 L9 @  E* v) G. y( M

方法覆盖：

子类可以修改从父类继承过来的行为,也就是说子类可以创建一个与父类方法有不同功能的方法，但具有相同的：名称、返回类型名和参数列表。

在父子类的情况下出现时。

& c: ?6 a/ ^* b. ^2 X) J

• 方法覆盖的规则？
  3 r" `, g  K' g! a6 D
  • 方法名要和父类中被覆盖的方法名相同,返回类型相同，参数列表相同。
  • 访问权限要大于等于被覆盖方法的权限。
  • 例外列表要小于等于被覆盖方法的例外列表。
    3 O& b$ W* E3 _1 \

; m4 c  p2 t; ^$ n$ W" P

• static修饰符的功能是？可以用在什么地方？怎么访问？
  # h& A1 q+ w0 t$ [. j' d! `8 x
  static 修饰符功能:
  
  3 v) Y  l2 u$ e  n' u+ z
  • 共用一块内存区域，也就是用static修饰的变量或成员方法对所有类的实例都是相同的
  • 静态成员方法和静态变量的优点在于他们能在没有创建类的任何一个实例的情况下被引用。
  • 可以用在方法或属性上
    $ t+ ^& ~& ]# {. b

访问方式：

• 直接使用类名调用
• new 一个实例，用实例调用
  

4 M( f, q/ Q; [( x2 [! h

• static的基本规则
  
  • 类中的静态方法只可以调用静态的属性和方法，不允许调用非静态的属性和方法。
  • 静态变量为类变量，可以用类名直接调用静态的属性和方法。
  • 静态方法中不允许出现this和super
  • 构造方法不允许声明static
  • 非静态变量为实例变量，通过实例调用
  • 静态方法不能被非静态方法覆盖
    ' P& y/ G4 ?" ~& z. r/ J/ _6 C

' n. h) ]4 @6 m( i; {

• final修饰符的功能是？可以用在什么地方？
  

功能：final标记所有通用的功能,不能随意更改

可以用在类、属性和方法上

• final的基本规则
  
  • final修饰的类不能被继承
  • final修饰的成员变量只允许赋值一次，且只能通过构造方法里赋值。
  • final修饰的局部变量即为常量，只能赋值一次。
  • final修饰的方法不允许被子类覆盖。
    8 A  e" E' ~  i1 \+ L# z4 w

8 W( X' J5 l! _% \  t: n; l) _- D7 i' R

• 什么是抽象方法，什么是抽象类
  

用abstract修饰的方法，只有方法的声明，而没有方法的实现，就叫抽象方法。

用abstract修饰的类，就叫抽象类。

• 抽象类的规则
  
  • 抽象类内部可以没有抽象方法
  • 必须用abstract修饰
  • 不能够直接使用抽象类，必须通过子类继承并且实现
  • 抽象方法不允许被private修饰
    & h: G3 f. S9 G. @- b

• 什么情况下使用抽象类
  
  • 当一个类的一个或多个方法是抽象方法时；
  • 当类是一个抽象类的子类，并且不能为任何抽象方法提供任何实现细节或方法体时；
  • 当一个类实现一个接口，并且不能为任何抽象方法提供实现细节或方法体时；
    1 r, x) S* P$ r/ E7 S  |$ Q  q

6 H. U. I' m8 O

• equals方法和”= =”的功能和区别
  ) v* V: `! Q9 ^( n* e$ |4 q. z7 M' }& `

功能：判断对象是否相等

区别：

equals方法比较的是对象的值

= =:比较的是对象值的内存地址，对基本数据类型来说= =比较的是数值

• toString方法的功能和基本写法
  / z/ j# K! `9 @2 o0 o/ [

返回一个String类型

public String toString(){

return “”;

}

• String的方法的功能和基本使用方法，请描述5个以上
  ! z& l. ~! f8 v2 [* S

substring(参数1,参数2); 功能:取字符串中参数1到参数2的的所有字符; “String”.subString(0,1);

replace(参数1,参数2); 功能:用参数1中的值替换字符串中所有参数2的值 “String”.replace(ing,tt);

equals( ); 功能:判断两个字符串是否相等 “String”.equals(“tt”);

trim( ); 　 功能:去掉字符串两边的空格 “String”.trim();

indexof( ); 功能:查找字符串中参数所在位置,并返回字符串第一个出该参数的下标

“String”.indexOf(“ing”);

split( ); 功能:根据参数分割该字符串 “String”.split(“-”);

• 为什么使用StringBuffer类？有什么功能和优点？
  
  –只创建一个对象
  
  3 K: ^% t3 @; S* g7 k. C

–StringBuffer 对象的内容是可以被修改的

–除了字符的长度之外，还有容量的概念

–通过动态改变容量的大小，加速字符管理

1 j3 b! }9 ]* z
. L; H8 F1 B+ W

• 举例说明如何使用StringBuffer
  9 B) X7 W: U! U% v* _

StringBuffer sb = new StringBuffer();

sb.append(“aaa”);

• 如何使用Java读写系统属性？
  读：
  
  

Properties props = System.getProperties();
7 M$ E2 W, e# J- I

Enumeration prop_names = props.propertyNames();

while (prop_names.hasMoreElements()) {
: X% r1 g" v" i6 D# |3 \8 V7 V; D9 z

String prop_name = (String) prop_names.nextElement();

String property = props.getProperty(prop_name);
" |) K( C; a' j  b$ z$ _8 g

System.out.println(“Property ‘” + prop_name + “‘ is ‘”+ property + “‘”);
8 [: |/ U0 D# S, }/ [9 P

}

    写：

System.setProperties(props);
$ v) s8 C3 p- ~" g8 l9 C

• 简述properties文件的结构和基本用法
  6 n+ _' _! X3 ^
  结构：扩展名为properties的文件，内容为key、value的映射，例如”a=2″
  
  1 o9 L$ }' |+ p! d, A! Q' R; `' I8 r

用法：

public class Test {
4 ~1 X! P3 j& ^) f. f

public static void main(String args[]) {
2 X4 ^  g5 `) ?0 ^% W$ X2 m3 C

try {

String name = “test.properties”;
/ K5 z( n& ]. A3 N0 Y; f1 S, a- V1 x2 F" {

InputStream in = new BufferedInputStream(new FileInputStream(name));

Properties p = new Properties();

p.load(in);

System.out.println(“a的值==” + p.getProperty(“a”));

} catch (Exception err) {
: |! O) t% s' p8 G& ^& ?

err.printStackTrace();
$ x6 M3 O* O! @5 X

}
+ }3 L8 g, z( G* {4 }' C

}

}

# M" h* `# y1 U6 C. |

• 什么是接口？接口的定义规则？
  1 ]; S8 u& Y6 K% Z8 u

接口是抽象方法和常量值的定义的集合。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

public interface Tt {

public void outPut( );

public int tt( );

}

, t1 a4 h+ S# o$ I' g# k

• 接口的作用？为什么使用接口？
  
  多重继承
  
  

封装、隔离

功能,实现的分离

多态

便于后期维护

接口是可插入性的保证。

• 什么是多重接口
  就是一个类实现多个接口
  

• 描述接口的基本思想？
  # D0 N; U1 I9 P( T" `: m8 N% l

封装　隔离

接口及相关机制的最基本作用在于：通过接口可以实现不相关类的相同行为，

而不需考虑这些类之间的层次关系。

    根据接口可以了解对象的交互界面，而不需了解对象所属的类。

面向对象程序设计讲究”提高内聚，降低耦合”。

• 如何在代码中使用接口？
  

public class MyCast implements Tt{

public void outPut( ){}

public int tt( ){

return 0;

}

}

6 C8 G4 S) G& l' w) Z: q& T  W# e

• 举例说明如何把接口当作类型使用
  ) q- u1 T. E1 Z4 E% H5 N! j/ m" K( \

public interface Animal(){

public void tt( );

}

public class Dog implements Animal{

public void tt ( ){}

}

Animal ani = new Dog();

2 t' O, Y; y7 F& n9 ^7 V4 j. \

• 如何选择接口和抽象类？为什么？
  7 {3 ]9 W5 Y* b: J8 @) F( ~0 {优先选用接口，尽量少用抽象类
  

在下列情况下选择抽象类：需要定义子类的行为，又要为子类提供共性的功能。
) h- j$ s0 ]- k, X

- z) o* z; i6 g" _

• 什么是异常，异常的分类？
  & ~+ c0 o' M$ {9 u: |3 N程序中导致程序中断的一些情况叫做异常，一般程序员可以处理。
  9 b" K0 g4 M9 y7 r% w; }( M& o异常分为运行时异常和非运行时异常（一般异常）
  运行时异常是指因设计或实现方式不当导致的问题。也可以说，是程序员的原因导致的，本来可以避免发生的情况。例如：BufferOverflowException, ClassCastException，IndexOutOfBoundsException，ArithmeticException。出现这些异常的代码不需要try块包围。
  . X* f& d2 A1 Q9 B) Q非运行时异常是指除运行时异常以外所有的异常，出现这些异常的代码必须用try块包围。例如：FileNotFoundException,EOFException,
  : ~0 w% S$ Z' ?1 \" x: G+ Q) J

9 l8 T; O! ^3 W& s! G6 c, c) Q0 [5 P

• 简述处理异常的两种方式？
  ; P/ c+ s  ~* C$ X$ o( V抛出（throws）和catch语句处理
  ) j- B. y' ~$ `

" K8 r4 W# b4 Z' ~$ x4 }8 N' K

• 简述try块的功能和规则
  $ l/ E8 C" ~! f) i6 c$ W

try块内部一般写一些编程人员认为可能会出现异常的代码,使程序运行时不会因为出现异常而中断。

4 Z1 ?. X+ I4 g" z

• 简述catch块的功能和规则
    g; h) U. o  W  d( _  S+ V: b3 r

功能：可以截获所声明的异常，并在语句块内对其进行处理

规则：catch(Exeption e){

e.printStackTrace( );

     }

8 g$ K" b! M% c' q0 J

• 简述finally块的功能和规则
  

finally块一般写一些不论是否发生异常都必须执行一次的代码

例如关闭与数据库的连接等

• 简述throw和throws的功能和使用方法
  4 i" u0 M, K+ r* O

throw 指编程人员主动抛出一个异常

throw new NullPointerExeption( );

throws指程序遇到异常情况自动的被动抛出一个异常

    public void test( ) throws Exeption{}

) f7 L" K4 u$ W& S$ o2 `6 v

• 异常的分类？
  % ~8 @/ t; |0 Y! S

错误（Error）： JVM 系统内部错误、资源耗尽等严重情况，程序员不可控制

例外（Exception）：其它因编程错误或偶然的外在因素导致的一般性问题，程序可以控制

4 L( \( F& a% @+ s8 e. E, X, ^3 H

• 什么是预定义异常
  , B: _) a4 G- p( {" m" V) }( _$ P

java程序中预先定义好的异常叫做预定义异常

• 简述自定义异常的规则
  

写一个类继承Exception

用户自定义异常通常属Exception范畴，依据惯例，应以Exception结尾，应该由人工创建并抛出。

• 什么是断言？
  # O$ e( z! `5 a) `& P7 z. i

用来证明和测试程序的假设。

& [' Q: G' U, t

• 如何使用断言？举例说明
  

一种是assert<<布尔表达式>>；另一种是assert<<布尔表达式>>：<<细节描述>>。

assert a= =10 : “这里a等于10″;

admin

集合框架
/ Q9 I1 @! k7 c  F* n; E

• 什么是集合？什么是元素？
  & E0 s0 m- [( O3 n4 A8 g5 G

可以包含其他对象的简单对象就叫集合

集合框架中所包含的对象就叫做元素

• 描述出Java集合框架中集合的接口关系
  

Collection—-Set和List

Set—-HashSet和SortedSet

List—-ArrayList和LinkedList

Map—-HashMap、SortedMap和TreeMap

: U/ R; O, k) L' e1 r

• 代码示例：Collection接口的使用，包括如何定义、初始化、赋值、取值、修改值除值
  
  Collection col = new ArrayList();
  
  

String oldValue = “abcd”;

String newValue = “1234″;

//增加

col.add(oldValue);

Iterator it = col.iterator();

while(it.hasNext()){

//取值

String str = (String)it.next();

if(str.equals(oldValue)){

//删除

col.remove(oldValue);

//修改

col.add(newValue);

}

}

• 代码示例：List接口的使用，包括如何定义、初始化、赋值、取值、修改值、删值
  

List col = new ArrayList();

String oldValue = “abcd”;

String newValue = “1234″;

col.add(oldValue);

Iterator it = col.iterator();

while(it.hasNext()){

String str = (String)it.next();

if(str.equals(oldValue)){

col.remove(oldValue);

col.add(newValue);

}

}

• 代码示例：Set接口的使用，包括如何定义、初始化、赋值、取值、修改值、删值
  * F) k4 @( t- n/ c0 j- ]5 D

Set col = new HashSet();

String oldValue = “abcd”;

String newValue = “1234″;

col.add(oldValue);

Iterator it = col.iterator();

while(it.hasNext( )){

String str = (String)it.next();

if(str.equals(oldValue)){

col.remove(oldValue);

col.add(newValue);

}

}

' u% P- w, E. y6 x

• 代码示例：Map接口的使用，包括如何定义、初始化、赋值、取值、修改值、删
  ! R4 m5 J( Q  a) Z
  Map map = new HashMap();
  
  

String oldValue = “abcd”;

String newValue = “1234″;

//增加

map.put(“1″,oldValue);

Set set = map.keySet( );

Iterator it = set.iterator( );

while(it.hasNext( )){

String key = (String)it.next( );

//取值

String value = map.get(key);

}

//修改

map.put(“1″,newValue);

//删除

map.remove(“1″);

}

& l) }' ]8 w9 x! Q4 i+ X7 A

• 描述List接口、Set接口和Map接口的特点
    u/ j' j1 ]" ~, ~5 p0 A3 e

List接口中的对象按一定顺序排列，允许重复

Set接口中的对象没有顺序，但是不允许重复

Map接口中的对象是key、value的映射关系，key不允许重复

. r9 d. R  R' ^- b3 _, l

• 如何给集合排序？
  : [0 _( O8 d7 q

实现comparable接口

admin

IO
* @, u  B8 r9 K! O& E4 P4 j

• 什么是流？可画图说明
  # o3 u+ S  \' ^6 J' a0 C

流是要传输的数据在源和目的地之间运行的轨迹。

' U6 a1 ?4 ]+ t7 I6 I% A
! ^5 t. \, D: k

• 描述I/O流的基本接口和类的结构
  

$ K3 z9 `+ V5 d7 E9 V- z) x

• 代码示例：使用URL流，读取网页代码
  2 }% Q! }( p5 K1 Wimport java.io.*;
  import java.net.URL;
  import java.net.URLConnection;
  public class ReadURL {
  public static void main(String[] args) throws Exception {
  URL url = new URL(“http://bbs.tarena.com.cn”); //建立封装统一资源定位符的类
  URLConnection uc = url.openConnection(); //打开连接
  InputStreamReader isr = new InputStreamReader(uc.getInputStream());
  4 T. T! f5 p0 }; @  K) jBufferedReader br = new BufferedReader(isr);
  
  //传输数据
  ! V, h: v" g1 z7 z4 \" |" ], q. rwhile(true){
  * @; I) s" s) k& pString temp = br.readLine();
  if(temp==null){
  . ^) l8 `: o6 m$ F, f# sbreak;
  }
  ; ]8 q' n% F- i8 j' \System.out.println(temp);
  " u( ^7 {8 \' P7 j}
  br.close();
    f( ~* ~7 q  j  h$ y" J9 L}
  # J6 O0 K: F" D/ k5 {}
    I6 i4 g+ k2 W) J" M& Z9 n

& _* l0 i& u: P

• 什么是Unicode？
  

是一种字符的编码方式，占16位字节，Java 技术使用 Unicode 来表示字符串和字符。

$ }- J3 d; k% V+ P6 E8 s) ~+ l

• 代码示例：如何使用Reader和Writer来进行输入输出
  
  //Writer写入操作
  * C: N# b% k+ r  v; A  R* t
          FileOutputStream fos=new FileOutputStream(“a.txt”);
          OutputStreamWriter osw=new OutputStreamWriter(fos);
          BufferedWriter bw=new BufferedWriter(osw);
          bw.write(“欢迎来到java快车”);
          bw.close();
  
  & F5 ?. c; `" _8 p
          //Reader读取操作
  
          FileInputStream fis=new FileInputStream(“a.txt”);
          InputStreamReader isr=new InputStreamReader(fis);
          BufferedReader br=new BufferedReader(isr);
          String str=br.readLine();
          System.out.println(str);
  
  , C0 C  a) L% C9 T- v3 g

5 I4 U9 N9 g/ H& }- I
' w3 N# L& Y. h4 Q

• 什么叫保持？什么是可序列化？如何实现可序列化？
  ! G7 I, g( j; ~0 o

将一个对象存放在某种类型的永久存储器上（比如硬盘，光盘，软盘等），称为保持。

标识一个类可以被持久化，叫序列化，也叫串行化或持久化。表示这个类中的数据可以按流式输出。

实现可序列化的方法：实现java.io.Serializable接口。

• 代码示例：如何读写对象流
  

//读

try {

String str = “123″;

FileOutputStream f = new FileOutputStream(“test.txt”);

ObjectOutputStream s = new ObjectOutputStream(f);

s.writeObject(str);

f.close( );

}catch(Exception e) {

e.printStackTrace( );

}

//写

try {

FileInputStream f = new    FileInputStream(“test.txt”);

ObjectInputStream s = new    ObjectInputStream(f);

str =(String)s.readObject( );

f.close( );

}catch(Exception e){

e.printStackTrace( );

}

• 简述File类的基本功能
  

处理文件和获取文件信息；文件或文件夹的管理。

概括一句话就是：除了读写文件内容其他的都可以做。

• 代码示例：如何使用随机文件读写类来读写文件内容
  / D9 d" Q; B' D" Z, h

RW表示文件时可读写的

读：

try{

RandomAccessFile f = new RandomAccessFile(“test.txt”, “rw”);

long len = 0L;

long allLen = f.length();

int i = 0;

while (len < allLen) {

String s = f.readLine();

if (i > 0) {

col.add(s);

}

i++;

//游标

len = f.getFilePointer();

}

}catch(Exception err){

err.printStackTrace();

}

写：

try{

RandomAccessFile f = new RandomAccessFile(“test.txt”, “rw”);

StringBuffer buffer = new StringBuffer(“”);

Iterator it = col.iterator();

while (it.hasNext()) {

buffer.append(it.next() + “”);

}

f.writeUTF(buffer.toString());

}catch(Exception err){

err.printStackTrace();

}

• 代码示例：如何使用流的基本接口来读写文件内容
  

try{

DataInputStream in =

new DataInputStream(

new BufferedInputStream(

new FileInputStream(“Test.java”)

)

);

String currentLine=null;

while ((currentLine = in.readLine()) != null){

System.out.println(currentLine);

}

}catch (IOException e){

System.err.println(“Error: ” + e);

}

admin

多线程

• 什么是线程？
  
  

轻量级的进程

$ T6 g: b1 b' H3 o

• 线程的三个部分是？
  * c% w: S  O5 P
  5 N5 H: R' B7 m4 y2 X

处理机

代码

数据

• 为什么使用多线程
  1 N3 W/ G% ^9 y* Y% n' e: Z
  

使UI响应更快

利用多处理器系统

简化建模

/ I3 D6 v  t, o- y1 F  V

• 代码示例：Java中实现多线程的两种方式，包括如何定义多线程，如何使用多线程
  
  

实现Runnable接口

    class Thread1 implements Runnable{
# ^4 D- \% q% }6 I/ m

        public void run( ){
1 J) p+ P6 g# B# Y1 H0 X' }4 E

            //run里一般写一个while(true)循环
& G% P) n& B1 s

            System.out.println(“Runnable“);
' p9 N" n. ~' I& y: b& ?6 V

        }

    }
- C! ^% B' Q# ^! U5 E' F

public class Test{

        public static void main(String[] a){

            Thread1 r = new Thread1();
$ {' a' s' w" z- X( T7 B' U' i$ v

            Thread t1 = new Thread(r);
( r6 h2 u8 @) S. _

            Thread t2 = new Thread(r);

            t1.start();

            t2.start();

        }

    }

    继承Thread

    class Thread2 extends Thread{

        public void run(){
' B9 u3 u1 t! x$ w: ]

            System.out.println(“extends“);
4 I" k0 y( ]% X9 t- K+ |8 b

        }
' p. l( {: F( Q! c

    }

- C( w2 g6 u1 e1 I& Y

    public class Test{

        public static void main(String[] a){
) m6 s& O6 P& Z( o2 ~

            Thread t = new Thread2();
, ]: O+ f0 M0 B, s2 Q- _  \

            t.start();
) G3 }' ?6 q# j* l5 `. L; i

        }

        }

- m6 P% h& \3 R1 L% }3 ]

• 如何实现线程的调度？如何暂停一个线程的运行
  
  9 N7 x! ^1 ^( G* e& ~6 G

调度用wait和notify，

—-

sleep()

• 什么是线程的优先级
  ! V8 J5 W, @% P6 t+ v
  

判断哪个线程先执行的级别

• 简述sleep方法和wait方法的功能和区别
  1 \) @" C1 c  h: m: {
  

sleep是让线程休眠一段时间

wait是让线程挂起

• 什么是守候线程
    S: n0 s7 H) n4 p7 m6 H$ d5 ]. [
  ; Q3 U4 x( y0 s' Y( u

隐藏在后台持续运行的线程

• 什么是临界资源
  
  

指多个线程共享的资源

• 什么是互斥锁，Java中如何实现
  $ x3 K4 Q/ K2 g
  , U* S, T# e7 F3 k6 }

用来保证在任一时刻只能有一个线程来访问临界资源的那个标记

在Java中使用

用在对象前面限制一段代码的执行

用在方法声明中，表示整个方法为同步方法。

# A; J& a  v# t+ Z; A( m

• 什么是死锁？如何避免？
  $ s' |: }2 v) b4 A6 _
  

如果程序中有多个线程竞争多个资源，就可能会产生死锁。当一个线程等待由另一个线程持有的锁，而后者正在等待已被第一个线程持有的锁时，就会发生死锁。

要避免死锁，应该确保在获取多个锁时，在所有的线程中都以相同的顺序获取锁。尽量少用临界资源。

• 简述wait和notify,notifyAll的使用
  + z2 K' r5 U3 P7 A+ a
  

被锁定的对象可以调用wait( )方法，这将导致当前线程被阻塞并放弃该对象的互斥锁，即解除了wait( )方法的当前对象的锁定状态，其他的线程就有机会访问该对象。

notify使等待队列上的一个线程离开阻塞状态

notifyAll使等待队列上的所有线程离开阻塞状态

  h* k7 v1 k. y- ]

admin

Socket编程
: ~& ~0 u- g' C  p) Z什么是url？基本的格式是？
统一资源定位器
1 _% s1 P. p* z$ D& K! t4 T
Http://www.163.com:port

9 c2 [, K& P" y
, ^2 u% h- J# v4 ?
简述IP,Port,TCP的基本功能
IP代表网络位置
/ t; _+ r, l. L
Port代表端口号
/ X0 d% {; S- G$ Q# w# J. @  k
, M6 G2 F) d3 @" x3 k9 c+ G) ZTCP可保证不同厂家生产的计算机能在共同网络环境下运行，解决异构网通信问题，是目前网络通信的基本协议
4 C1 F3 r# A+ f, L9 [- N
简述Java网络模型的基本功能
+ j1 w1 L$ m; |( G0 j) _& }描述服务端和客户端的连接过程
! K# E9 `* F+ F: J' I4 P  F" M

3 c  l  n( f* N9 ]* R, [
7 C/ Z+ ]0 L( q8 C# i! `+ P简述Java网络编程究竟做些什么？如何做？
9 O  Z5 h$ {6 V% y1 G7 ~. c1.建立连接

4 E6 i  v- U0 z4 m2.准备输出的数据，流式输出

3.流式输入，编程业务需要的格式
$ o8 z8 |2 @* q3 M: p
4.关闭连接

3 _& A" i+ |5 c) M服务器分配一个端口号。如果客户请求一个连接，服务器使用accept( )方法打开socket连接。
" ^& l. V' A- d. q' z/ J0 C
客户在host的port端口建立连接。

# ]. u5 x. N2 @4 `服务器和客户使用InputStream和OutputStream进行通信。

# [, m4 Y0 r+ {# q1 R9 ~
% v9 v1 B8 j, G
7 T/ H9 n, R' p8 c( d

. I* d# _$ z) x8 Y& X9 v2 C& Z. ~0 Y
( l. Q" w$ N9 z; @
% r3 i! U" J4 M7 H; N5 v+ W代码示例：基于Socket编程
6 G  b, G  C5 h, itry {

ServerSocket s = new ServerSocket(8888);

while (true) {

- o4 Y$ |! r9 MSocket s1 = s.accept();
) r; S/ ^( L; |* g
/ `7 V5 l. B) D; u) JOutputStream os = s1.getOutputStream();
6 z; W6 g9 _9 o3 X8 ?; p2 ^
" ^- @* b/ c' G- o7 J0 W% GDataOutputStream dos = new DataOutputStream(os);
; R: \, Y  q1 V2 ?6 s, t& y
dos.writeUTF(“Hello,” +s1.getInetAddress() + “port#” + s1.getPort() + “\nbye!”);
3 y  A- u* D$ {& {
            dos.close();

" K- x& l6 Q8 A# v( H  q% Es1.close();
. F4 B* F9 X" s$ v  B. U
}
$ {- g; }7 r7 R+ x" B
}catch (IOException e) {
, L% [% ]5 J& n  e6 C
System.out.println(“程序运行出错:” + e);
! |% T1 d# ^) K' n. p
; v8 V4 _$ G( ?6 w# I( Y}

. A. {) |! H/ m6 p7 c+ x




& c5 k3 E# W' v/ h2 r- e

1 I4 Y3 |: l. v, J2 C
TCP和UDP区别
TCP（传输控制协议）和UDP（用户数据报协议）是传输层协议
' I& w* m7 l) e6 L
( U; E) A3 k5 nTCP是面向连接的可靠数据传输协议，能保证传输内容的完整和准确；数据传输的辅助开销大，效率低

. D1 T9 w# ?. t, L/ D0 V, i+ n$ dUDP: 是无连接的，不可靠地传输协议，不能保证传输内容的完整和准确，对信息的适时要求比较高

admin

设计模式
什么是设计模式？
就是经过实践验证的用来解决特定环境下特定问题的解决方案。


% d$ s, g& H" l6 S7 }( E


设计模式用来干什么？
8 b( O3 Y, Z# ?4 V8 t7 D  X寻找合适的对象
- L+ D7 `5 n; F$ g6 V) e9 `' B
8 {# m1 M( h" r: g! i, y决定对象的粒度

指定对象的接口
( X" H0 x0 V; A- u4 c
描述对象的实现
3 C1 l3 r1 W- ~( q  v  ^
$ U& s5 z; ?& I7 L) [+ M运用复用机制

' I1 K9 }& l2 D# x  ]; G8 T重复使用经过实践验证的正确的，用来解决某一类问题的解决方案来达到减少工作量、提高正确率等目的



# G4 c% f. h% C什么是对象粒度
对象中方法的大小就是粒度



基本的Java编程设计应遵循的规则？
面向接口编程，优先使用对象组合
' Q& S" L! s  O6 h" S
& Z1 L* ]/ f, f4 [, H+ S

设计模式的应用范围
所能解决的特定的一类问题中

, ]% Q1 A% _' u+ k/ t4 p/ ~
. I( x3 x7 ~! ~
简述什么是单例模式，以及解决的问题，应用的环境，解决的方案，应用时应注意什么？
0 _: g# O7 O' g解决的问题：在任何时间内只有一个类实例存在的模式。

应用环境：需要有一个从中进行全局访问和维护某种类型数据的区域的环境下使用单例模式。

9 b/ T, ~1 v0 ?# [解决方案：保证一个类只有一个类实例存在。
, K6 a0 X( C: G; w  P( q, g
& Y/ l: H7 P& m* A本质：控制实例的数量。

& d' s0 u) S/ R/ h注意：要合理的使用单例，避免单例成为瓶颈。

  I9 W  K7 n5 a
* J5 {6 i/ K4 ]4 y1 o7 v

" ]8 o- M& f% u# R4 T8 A) H: X


代码示例：单例模式的两种实现方法，并说明优缺点
public class Test{

    private static Test test = new Test();
: x5 M3 U7 Q% S9 _# I" L
, d( V# ?1 j7 [; e$ h& ^     public Test(){

        }
; ~' l& A9 a- l: @
% w7 M2 ^2 N7 @6 v- }3 Z2 D

     public static Test getInstance(){

         return test;
. t  E/ p: n3 s
1 ~3 M4 S; F, ]9 u2 b, G( k* [    }
' T' o' |: Z+ ^3 p/ ?' E6 _- p2 k5 L
8 t7 M' M( C7 S0 ?    }
# F4 v/ I; Y0 x/ g' x0 h6 M7 ?
: ?% i, {/ n5 t: X) Bpublic class Test{

     private static Test test = null;
3 ^; J8 h* E7 D8 r$ N7 x  t! n
& J) T4 i/ r. x$ ~) e; F        private Test(){

1 ?- j6 b/ t1 }8 y# G        }

        public static Test getInstance(){
7 E& N# F! H" m: a) e
            if(test==null){
- d2 x+ }1 u# L# g) _* D" y; y
6 |& Q& X" U9 m/ D7 I                test = new Test();

4 u  R. N, M1 h# ~' H9 A) V8 }3 T  {            }

2 h* L' J+ D6 t$ b- F5 m        return test;
& O" e2 ^6 o  N+ h9 T4 b3 e/ s2 u
8 H: g# z0 C* k" _        }

    }

第一种方式：装载类的时候就创建类的实例，用空间换时间。
, J) Q& f1 T! M& N! D0 K$ s
第二种方式：延迟装载，不需每次都创建一个类实例，而只是在第一次使用时创建，有效的利用资源，用时间换资源。
" |% h6 E" P( f. f% H

2 |; o6 }5 ]' v0 [/ i+ f: M
简述什么是工厂模式，以及他解决的问题，应用的环境，解决的方案，模式的本质
2 P/ U4 \  P8 c. ?: f利用工厂来解决接口选择的问题的模式。

应用环境：当一个类无法预料要创建哪种类的对象或是一个类需要由子类来指定，创建的对象时，就需要用到工厂模式。
) v. E; R- N3 e! T  [2 O+ _  ]" e
* X& |4 p' N" W$ ~, m7 {. ?解决方案：定义一个创建对象的类，在类的方法中决定具体实例化哪一个类。
4 W4 y- @. d) R
  W6 S9 |% D& x8 T2 f  z本质：就是根据不同的情况来选择不同的实现类，重在选择。


$ j- O6 S. y* V/ w" i5 c# G$ p
代码示例：工厂模式的实现方法
单独是使用工厂：
1 J8 L, O: V. ~. A+ s4 t, q/ j
. H( ]$ m$ O0 k8 p/ Z( @, h; U9 q3 ^public class Factory{
. ^; N; j4 A% x/ F- z) j
     public static Sample creator(int which){
- E" r, }' u5 |
         if (which==1){

             return new SampleA();

        }else if (which==2)
4 o0 l8 {8 j2 o2 I
             return new SampleB();

1 d9 @( g% p8 M         }

+ z  S8 u# ^5 t* m        }

     }

工厂+单例：

public class MyFactory{
7 l- L  |" B/ X! E0 E( ]
public static MyFactory f = null;

public MyFactory(){
, v4 @- _+ j) ]# I
  n. m; f: v+ E  ~}

public static MyFactory getInstance(){

if(f==null){

f=new MyFactory();
. _. n( e6 `/ c2 O
}
: V0 v6 q7 H2 P& T& F& r
# S, T6 j# F: u" M+ Q! u: F}

  S- N2 w" W# Y1 o$ wpublic DBDAO getDAO(){
, m/ u% Q( L3 \; s$ l* t/ L
. _, P5 z# q, P$ ?1 J+ \5 Qreturn new DBDAOImpl();

+ I9 s8 X/ D9 x% _- ~9 I5 u& h7 I}
3 b. _8 J7 ?  K; @" f# h; t, O! J* W
}

& n0 @0 p  \5 S. p
* E5 {# U9 L! Y2 u
简述什么是值对象模式，以及他解决的问题，应用的环境，解决的方案，模式的本质
' x' m6 v" K5 m; C  G用来把一组数据封装成一个对象的模式
2 u4 ^$ G: `# g
解决问题：在远程方法的调用次数增加的时候，相关的应用程序性能将会有很大的下降

" L$ f$ t7 s* ?2 _解决方案：使用值对象的时候，可以通过仅仅一次方法调用来取得整个对象，而不是使用多次方法调用以得到对象中每个域的数值

2 c: B, p# @; q0 l; p本质：封装数据。


8 [- s; g* D2 o6 i( C: V5 M
代码示例：值对象模式的实现方法
3 \# R7 k' E4 b, k步骤：


, K/ D0 @- E! e- z# L
public class UserModel{
) k1 \+ G* b, L' y& x6 V7 C8 e! t
  W7 p! v9 E) c. {" m         private String userId;

         private String userName;
" w) f" C3 y3 Q5 _
            public void setUserId(String id){
* Y+ D! Z. `, f% |
+ ?2 E4 {$ f* d; {0 d+ X             this.userId = id;

         }

, q% V. V, E( L( M; O8 e         public String getUserId(){
& A- \# ^# t2 {$ D' S( u/ n
             return userId;

         }
3 n4 B* P' M3 h% s8 l! B3 W. o& a8 C  w
         public void setUserName(String name){
) t8 W( Z+ b3 E+ J: ~# w. h7 c
             this.userName = name;

        }
, y+ b3 z' \) a# z& W
1 I9 J* H; w! B  L. |: j* E        public String getUserName(){

             return userName;
4 B7 c1 `% U# R, ^/ l  j/ Q
" k4 C* P4 w5 T5 @: o# ^% T$ L5 L         }
+ F& i0 e  ]4 i2 N# F
     }

  k8 d7 h# w- |
+ s! f% |3 u0 \' ^* M0 [+ m
简述什么是DAO模式，以及他解决的问题，应用的环境，解决的方案，模式的本质
! H: U6 F+ y& o, ]9 M数据访问对象

解决问题：根据数据源不同，数据访问也不同。根据存储的类型（关系数据库、面向对象数据库、纯文件等）和供应商实现不同，持久性存储（如数据库）的访问差别也很大。如何对存储层以外的模块屏蔽这些复杂性，以提供统一的调用存储实现。程序的分布式问题

2 P, T% i& ^3 n/ S% a/ a  p, q解决方案：将数据访问逻辑抽象为特殊的资源，也就是说将系统资源的接口从其底层访问机制中隔离出来；通过将数据访问的调用打包，数据访问对象可以促进对于不同数据库类型和模式的数据访问。

     本质：分层，是系统组件和数据源中间的适配器。（一层屏蔽一种变化）
% T8 _6 ]; S0 U, `( J  b9 P


8 |( d: w) H2 s4 E. j代码示例：DAO模式的实现方法

5 n" F" ~. |+ g: s! A

& @$ {# p- y4 I+ t
什么是框架？框架的优点？
/ y# ^; y) v1 Z( @3 U& a4 r2 q* n- b框架是能够完成一定功能的半成品
/ {7 b( y# e) G; R' v: r- v
１.优点：完成一定的功能、提供一个精良的应用程序架构
# q; E) }- U6 h+ P! X& K' ]6 F- i2 w
, d' e" s: v9 b8 g7 X# j２.框架都是以接口的形式出现
; T, I" R  A, q& Z' u& j; X& d7 _
３.应该了解框架完成的功能、框架的API接口、框架的功能是怎么实现的
) F8 c( t0 u/ @3 ~8 W5 p, Q
! {& R  K+ r4 ]3 B1 P+ s) `" Y4 G
  \" U; A* b+ f: a9 {5 y& o
$ H  t- f  Y( \* ~/ w8 L) g* ]什么是开放-封闭法则(OCP)
可扩展但是不可以更改已有的模块

对扩展是开放的，对修改是封闭
: b- c4 W9 f* ~+ J( K8 ]% t  E
' t" {: C( Q/ c: L, k' l: b

什么是替换法则(LSP)
+ e: c  E; g$ V3 h. P3 p& [9 T使用指向基类（超类）的引用的函数，必须能够在不知道具体派生类（子类）对象类型的情况下使用。

+ ?& E3 [, q6 o, E' M* g8 ?7 W' g
0 E# Z+ Q4 o) e) O. y/ r; W7 D
如何综合使用我们学过的设计模式来构建合理的应用程序结构
是采用接口进行隔离，然后同时暴露值对象和工厂类，如果是需要数据存储的功能，又会通过DAO 模式去与数据存储层交互。
- T9 j0 Y, s) s9 G
, e- N/ S" N; z6 `

0 D- V1 L& z& J! Z9 A1 s6 Z% j构建常用的合理的Java应用包结构
& Z, n3 o3 H( [. c9 }Ui(表现层)
8 H, {7 y* ~( C% r( S( u: N6 I* ]: w
business–factory,ebi,ebo

dao–factory,dao,impl

admin

awt、swing
什么是GUI中的容器？什么是GUI中的组件？
1 o/ G1 ^5 G3 u5 n3 J$ ^  Y容器：能包含其他container和其他component的component。

组件：在设计上能实现一定功能的封装体；
) L% {/ Y% P. n* Z

! G* M/ `- }! u, a1 r3 t8 g9 d
简述AWT中的Frame、Panel和组件的关系
- n  r0 l# {+ |% k& y( w9 \1 P% {组件放在Panel上，而多个Panel可以叠加到Frame上，Frame一般只有一个，各个Panel可以互相在Frame上切换

; M5 Z3 s( D2 v0 [* J

8 r' x9 p4 L* R9 R/ D! \. W简述如何使用一个组件
初始化，加到容器中，注冊事件，实现相应的事件
) j* z0 p: r( c6 Q+ g
Panel pan ＝ new Panel();
* x, ]# S0 x, u' b: g% j3 j; y% W
TextField td = new TextField();
& ~: t; L/ g7 [- o6 P) o9 H
9 f8 x( f2 i' z- V2 ~- utd.setText(“this is in a TextField.”);

pan.add(td);
- p; F9 D! M* R5 r' M: E

3 U& }+ ^( I9 Y
描述一个GUI界面的基本构成？
Frame，Panel，組件
. A" C" L& V& ^0 K# F, h8 ^
# I" W1 U5 a% f; c- OPopmenu



如何控制外观，如颜色、字体等？
1 k2 Y* a: X; l3 @可使用setColor()，setFont()方法

% S1 Y! \( b$ n, L* `1 M2 ]) X例如：
, q2 A) y7 i9 n2 ?' h* J6 E7 L6 H
* F) r. F8 T& a2 |0 H/ Z2 E2 {& tFrame f = new Frame();

, n3 L( R( }% }  e, F. u. jFont font = new Font(“TimesRoman”, Font.PLAIN, 14);
) F' i3 G) u! {& m1 O4 j
) u$ a  I- Z* W: a7 R0 r+ V* ]f.setColor(Color.red);
/ @) D, {. I2 K, G5 P1 X/ w
f.setFont(f);
5 \8 s$ n; X( P$ B; ?4 l


什么是布局管理器？
3 B# V) s' }) J( P$ E用来管理GUI界面中组件的分布情況，负责决定布局方针以及其容器的每一个子组件的大小



描述每种布局管理器的基本特点
FlowLayout 从左到右分布，排满推到下一行
) m* B' e1 O$ Q. s! A) W+ G/ B
8 d$ o2 U: u2 z" D+ h, [BorderLayout 上下左右中分布

CardLayout 卡片式分布

1 n' n8 t0 j7 ^! h% Y. l' a) P" uGridLayout 网格式分布
1 O# w" ]9 o% u: \
2 R  W& Z- ~& F/ S" C  \XYLayout 坐标分布


0 a" S" ~* i: j5 E8 W7 ^
. z+ r+ }0 W1 s8 c什么是JFC(Java基础类)？
$ `! h4 G0 l8 B! |6 l& i1 V是关于GUI组件和服务完整集合，
& s! h9 c+ y; P0 c
! o/ e% E; c& v" x" y" S主要包括5个API：

/ U" F4 N2 x" @AWT，JavaD,Accessibility,Drag&Drop,Swing
  L3 Y2 w3 [3 }
提供了帮助开发人员设计复杂应用程序的一整套应用程序开发包；
; U/ o; v( L) }: [9 j8 P


" k" Y, y+ R  z( ESwing和AWT的区别？
/ s: c6 |' d4 j( J; [6 L  jSwing提供了更完整的组件，引入了许多新的特性和能力。Swing API是围绕着实现AWT 各个部分的API 构筑的。

3 C: V, S9 ?+ F, uAWT 采用了与特定平台相关的实现，而绝大多数Swing 组件却不是这样做的，因此Swing 的外观和感觉是可客户化和可插的。

$ A5 ^: N  D3 Y/ N' L

什么是双缓冲？
# H& s( E! }2 `7 p: j, s1 s4 Q% S+ o在后台进行界面的更新，然后在前台进行界面交换
+ w* e6 C/ p) z8 ?
) d+ r, E; P" C4 G' l: c! J; _) c功能：双缓冲可以改善一个被频繁改变的组件的外观


% G7 U$ ^" O4 i6 J
7 G% L! J/ n1 u5 c描述GUI的事件机制
) ]2 O$ O5 C, p, y$ b, J) ~0 k事件源：是一个事件的产生者，或产生事件的组件对象

/ q# A. E0 l+ _# A' c4 i事件监听器：调用事件处理方法的对象

1 \3 K: n. r* J: a) ?" h7 [0 y事件处理器：就是一个接收事件、解释事件并处理用户交互的方法。
$ `& P% P4 G* w( M
8 e. L" `  y* F: a
& x; {/ B& u( W/ o
$ D" U" z- H# S! p7 v  j# j3 b, x: p描述Swing应用程序的基本结构？
组件定义

; T: p/ Z5 X0 s) I- \初始化界面
  W8 i6 n; j3 ?, X1 H% @8 t
" b5 D" o" e  j% A各种事件处理方法
  Q) c( p% f1 `  A$ s1 j3 K
+ H" x: i2 J; ]3 v; v各种适配类
' c& J8 a8 L$ K3 u$ q
8 E4 z7 N/ Y7 H3 C1 x0 G/ o

9 `( R' _# @+ u描述表现层的基本功能？
5 g' u- Q2 K3 @; j6 e2 M展示数据

3 |4 ~7 ~6 k# V$ F2 ]7 B) m) j/ `人机交互
% j3 [8 B3 ~7 ^  H9 C
收集参数、调用逻辑层api



描述在开发Swing应用程序中，一般都要写那些代码？都写到什么地方？
一般要在类的初始化的时候给组件赋值，写在jinit的方法里面
$ T% ~6 F% m& {# H+ e4 e
+ b. H1 D2 m9 c: u" E- S一般要在按扭的事件处理中写收集参数，组织参数，调用业务接口的方法


' @! k. q( B4 U
) ~# |! ~6 @/ j# F对于GUI组件而言，最主要的方法是哪些？
: ]) L; I* G3 L# `7 C3 }$ P初始化
8 S5 T' Z& f& U- T; L" z+ l( b
如何给组件初始化

如何从组件中取值

设计组件的属性


3 u5 |- h- `+ E8 \" f
8 ]3 ]+ R7 _5 _如何学习GUI组件的用法？
主要学会组件的定义、取值、赋值的方法

# }; s8 }2 k6 [9 {5 l4 \8 }类比学习

admin

JavaScript
8 n6 U7 X! T. Q" @1 ^1 o

什么是Javascript
JavaScript是一种基于对象(Object)和事件驱动(Event Driven)并具有安全性能的脚本语言。
2 g3 @3 U# ?5 p& N; c+ W


Java和Javascript的区别
) ^! w& N; m2 s/ }( `  q1、基于对象和面向对象

Java是一种真正的面向对象的语言，即使是开发简单的程序，必须设计对象。
- Y/ z) i% s1 x5 m9 m
2 N1 P) h5 y4 RJavaScript是种脚本语言，它可以用来制作与网络无关的，与用户交互作用的复杂软件。它是一种基于对象（Object Based）和事件驱动（Event Driver）的编程语言。因而它本身提供了非常丰富的内部对象供设计人员使用。

2、解释和编译

: J/ f2 n. g, E, d8 r% J2 C' y两种语言在其浏览器中所执行的方式不一样。Java的源代码在传递到客户端执行之前，必须经过编译，因而客户端上必须具有相应平台    上的仿真器或解释器，它可以通过编译器或解释器实现独立于某个特定的平台编译代码的束缚。
5 u: B$ D, |; g) \
JavaScript是一种解释性编程语言，其源代码在发往客户端执行之前不需经过编译，而是将文本格式的字符代码发送给客户编由浏览器    解释执行。
3 e/ S9 i5 f$ s& w$ C9 _
2 x( z- S' I) z; A- ?+ B3、强变量和弱变量
9 j/ R4 R3 e( w5 X# l- a
, {6 a0 ?7 W5 H两种语言所采取的变量是不一样的。
0 ?6 j5 }8 y) ^" ]; x. r
Java采用强类型变量检查，即所有变量在编译之前必须作声明。

; v5 S# M; F  Z3 g# gJavaScript中变量声明，采用其弱类型。即变量在使用前不需作声明，而是解释器在运行时检查其数据类型，
2 d( Z' C$ s5 b9 R3 X4 g, e7 V+ T
1 G2 Q; G+ r* v8 S5 e. ^4、代码格式不一样

Java是一种与HTML无关的格式，必须通过像HTML中引用外媒体那么进行装载，其代码以字节代码的形式保存在独立的文档中。

" Y2 H6 j' c- g& K: f( jJavaScript的代码是一种文本字符格式，可以直接嵌入HTML文档中，并且可动态装载。编写HTML文档就像编辑文本文件一样方便。
8 P3 i& }- J2 b8 ]# W
5、嵌入方式不一样
7 i( g" R6 r( j$ ?% E
在HTML文档中，两种编程语言的标识不同，JavaScript使用<Script>…</Script>来标识，而Java使用<applet>…</applet>来标识。

0 {+ Y( ^5 e3 S% D0 Y, ~3 ^6、静态联编和动态联编

, c" o6 q  g2 P! ?Java采用静态联编，即Java的对象引用必须在编译时的进行，以使编译器能够实现强类型检查。
( K( M% a9 w9 B
JavaScript采用动态联编，即JavaScript的对象引用在运行时进行检查，如不经编译则就无法实现对象引用的检查。
/ x' T1 Y+ t$ w5 s( g5 Y, |, |! ^
7 ]: s8 r. C  A, M- q

& v/ x( P7 S1 O: [5 gJavascript的运行环境
0 U6 q3 Y- U- K9 v+ `6 \+ w  {具备javascript运行器的



如何在web页面加入Javascript，请写出两种方式并示例
<script language=”javascript”>
) h3 H5 O* q: q/ t2 m2 a( e
5 X/ z7 `3 c8 ~9 m" O, b& Yalert(11);
; J) Q( a  B9 d7 c6 Z
0 e9 P: E: m. V' |3 \. C/ F9 o. Q</script>
8 D# S( o4 ^' K. y; P
或者

( [$ t$ e/ v2 G5 a1 z  }7 }<script language=”javascript” src=”/test.js”></script>
8 @$ }/ e2 G* V! A, o3 P


$ ?  ?! E. E+ v写出Javascript基本的数据类型
7 a- j; ^) U0 ]$ y0 S# Y7 B+ S整型
+ @) I1 q* o2 D) Y! A0 k0 q2 J
# P6 z0 O! J( ?# P5 T5 D2 c实型
$ M- H+ Q. F* U/ m0 c* ]6 U
布尔
( Q$ l3 C+ C' x! i
, T/ _; @3 z+ q3 d' E1 ?: P2 d字符型

  ^* R* ?: c4 M, x: C" F空值

    特殊字符



3 N- U1 g$ g; x/ O& ~. ZJavascript中如何定义变量，有何规则
必须是一个有效的变量，即变量以字母开头，中间可以出现数字如test1、text2等。除下划线（－）作为连字符外，变量名称不能有空格、（＋）、（－）、（，）或其它符号。

6 H, h* o& d* ~/ D# t不能使用javascript中的关键字
1 N( K% `0 ~/ t# I5 v0 I4 K8 h
, ?- s& D1 Y  s
! ^% v0 G6 T- u( e; C( t& ~, d4 s" {
代码示例：Javascript中的if控制语句的结构
+ w# d. M% i: v( M" H( `; @if(i>4){
8 y, p: M  G" G0 k: O' o( Q- q/ _
" ]7 C; O3 O0 k% I3 ualert(11);

" j9 f0 t# Z! W}


+ x" A1 q0 O% _4 V/ Q
% h/ C7 I/ G4 h: x3 h; H2 c代码示例：Javascript中的for、while循环语句的结构
for(var i=0;i<10;i++){
3 v! f( f% C# Z$ s
2 `; v, |5 C1 o# \9 E5 c5 \alert(11);

9 v' g: N- m% G9 m4 J6 `}
: ~, q/ i+ _% S; Y8 X3 o! R
& k( T( S# d# u- L, Twhile(i<10){

alert(22);
3 |' Y, d& c* \( q+ l7 k
}
$ f+ g- T5 [, _
* n) [" ~  p/ o# e( U5 I
* b# {) ?* z( K! G( i8 N0 M  M
简述break和continue的用法和功能
使用break语句使得循环从For或while中跳出，continue使得跳过循环内剩余的语句而进入下一次循环。
  G( l: V" n1 M( I6 p9 a


Javascript中如何定义类，如何定义属性，如何定义方法，请代码示例
# Q5 L6 d, ^1 O, Gfunction QuaryArgItem(){

this.keys = new Array();

5 q6 q  ~/ r, g# P# Hthis.values = new Array();
8 M6 ^8 m7 R9 l, N3 V+ a
) Q( i$ d3 @  |+ p- C    }
. _; [! t4 D0 a# f% |
: j* u2 `. A" R0 W% c6 x

; ^7 O0 p- o' J, J* L+ a    QuaryArgItem.prototype.push = function(key, value)

    {
% s" W) e8 X% k% \1 n( V
     key = (key == null) ? “” : “” + key;
, i. T; k+ U- Y! j: Y
     value = (value == null) ? “” : “” + value;

( ?, m  H2 `6 @7 l% q" h0 _$ F     this.keys.push(key.toUpperCase());

     this.values.push(value);

    }
1 a2 z; s! M& Z2 {6 g- P) Q% l- f
5 C" N  m: Q* b3 s; A, D    QuaryArgItem是类名

. U1 r7 x9 b3 Z1 |  t6 b    push相当于方法名

% j/ S! ]) M+ H% G# f    使用的时候
' ^: _; U; ~2 L; r  Q' O' ^：

        a = new QuaryArgItem();

- k: t3 y; N$ m9 F3 w        a.push();
/ h- U0 B7 e2 F' [2 t
, ^: ?) k5 o! {3 J* @

) U6 i+ G; _* P: k. {# j) Z2 o) kJavascript的function如何定义，有何规则
) t# z4 e/ E5 c+ f5 `, `Function 方法名 （参数,变元）{

6 ~: @& O. Y8 U- T5 I) N. w方法体;
, Q% M6 e8 |7 w  O6 N) V1 S
Return 表达式;

}

' a2 i8 r# V; d3 }
' I& U7 y. H7 d5 i% G
如何触发Javascript的function
' [7 m6 I% V1 b' o2 nfunction test(){

alert(11);
/ Y$ v4 G' A+ Q( b  n7 U$ c  L
- H8 T- F9 k4 z4 k  C% o}
+ N( N) v: ]% E& ^. E
<input type=”button” onClick=”test();”>
( I& I! P$ ]4 j" H9 V7 D# g

* \4 @' ~% [; |, \: D9 u
, Q, ?( _  T) J) O说出下列String对象的方法的功能和用法：toLowerCase、indexOf、subString、toUpperCase
toLowerCase将指定字符串转化为小写
( K6 g3 o% Y3 M6 S% q
1 W- O' q* e! C- gindexOf判断是否包含某一字符或字符串

substring从字符串中取一段并返回
/ H) C" Z' h/ S0 ~# D2 R
# i$ \( c5 y" C6 n6 c* ~toUpperCase将指定字符串转化为大写


  B" o5 m1 Z4 T+ S5 U& i, X. P
Javascript的日期对象是？如何初始化日期对象？
提供一个有关日期和时间的对象Date
! }6 e  L' F5 J$ m) N
date = new Date();



说出下列Javascript系统方法的功能和用法：eval、unEscape、escape、parseFloat
eval：返回字符串表达式中的值
' P! L8 r6 F. J/ F. B5 G) L
unEscape：返回字符串ASCI码
0 ^) p! E  u( C  C8 _6 P
escape：返回字符的编码
" U0 G( M: X$ p9 e
) w) x( U1 P: U; P$ Z2 lparseFloat：返回实数
% H4 X/ N2 @( ~% \

( d* }, S( c& T) Q0 y
Javascript中如何定义数组？如何初始化？如何取值和赋值
var arrayName = new Array();
, `9 d! r: f: t# H) U6 q9 W. x
* H) L. ~9 w; v0 Y+ {5 ]7 W    Function arrayName(size){
' h6 n1 I# Q! x/ }3 Z( B3 W
        This.length=Size;

6 D) L' h" V  ?( h% c0 K& k  F3 V8 {        for(var x=; x<=size;x++){

            this[x]=0;

        }
' I$ o7 W' S" G1 h7 I. N& }
        Reture this;
) M7 [' w' B6 ~
    }


* c2 u$ m0 p  {( R) `; q% H' H7 P
6 E$ Y- h2 }3 x3 j: d  i- w; _0 @简要描述Javascript中下列内部对象的功能：Navigator、Window、Location、History、Document
Navagator：提供有关浏览器的信息
' j0 r  b, d+ }9 }7 h
Window：Window对象处于对象层次的最顶层，它提供了处理Navagator窗口的方法和属性
/ {; J( C: y  i% v, N
Location：提供了与当前打开的URL一起工作的方法和属性，是一个静态的对象
8 j$ o* [" m, Z( Y+ F* c. A4 D
# U5 f0 W  b6 ^' |& \History：提供了与历史清单有关的信息
3 p/ C- U- `+ O' C
2 X% n9 ?5 t; Q! kDocument：包含与文档元素一起工作的对象，它将这些元素封装起来供编程人员使用
# F  t$ k+ S% N# l


6 |2 g6 W4 l2 n# R8 z9 s如何利用Document来从页面上取值和赋值
4 @5 ^8 y  G( R* T/ N取值：var a = document.all(“text1″).value;

赋值：document.all(“text1″).value = ’123′;



简要描述Javascript对象层次结构
window–document–组件
  I! t0 N& J& [, `% y

% }' K/ r$ P# Q- H2 \6 G
5 u* @# b- t% M; `# `# t说出下列常见事件什么时候被触发：onFocus、onBlur、onSelect、onChange、onClick
2 Z2 N0 u, V7 {& C* Z5 @4 \; \2 KonBlur:当失去输入焦点后产生该事件

onFocus:当输入获得焦点后，产生该文件
0 F. E+ n+ L$ K6 X4 y8 u( S
# [7 S3 P' U, {7 D* r; U3 F" _onchange:当文字值改变时，产生该事件
" r* Y6 P; z  u% I$ n+ N
onselect:当文字加亮后，产生该事件
8 c( c9 Y7 O! w, d! H, C: o
8 e" p9 a) W9 }onClick：当组件被点击时产生的事件
+ ?5 {) g/ Y& b( }

1 R! E" w* w* L$ f- w1 M2 r+ t
代码示例：使用Frame作一个基本的三分页面
8 {* a5 Y4 D; d8 q<HTML>
+ d9 Y6 c* h0 b, h: v0 l1 Y0 n
<HEAD>
3 d0 c( {7 f( Y3 B: j; c
  D: R! |% g1 t</HEAD>

# f3 K8 \$ Q- b9 i8 u* ]5 T<Frameset Rows=”10%,90%”>

5 s1 l+ L* Y5 U<frame name=”top” src=”test1.htm”>

, u# f2 s' @$ T  t, V. k# N<Frameset Cols=”40%,60%”>

/ H* `/ q# Q; ]# a4 O6 w1 S& k  V- A3 g- G<frame name=”left” src=”test2.htm”>
4 L0 H0 R8 a3 B, {
5 m6 R( {; @2 _3 }+ f) H/ F2 ~4 j<frame name=”right” src=”test3.htm”>

8 \8 ?8 N6 J1 a/ P% K</Frameset>
( S, M7 ?' b2 e) l
2 Q" \# b! G1 n9 K3 F. C</Frameset>
1 j# D5 t3 c5 [3 S' k
</HTML>


" i& o9 j9 v$ K. E* F4 s2 V; b
框架如何载入页面
<frame name=”left” src=”test.htm”>

# k$ ]" G4 F; x# V6 u

如何从框架中的一个页面访问另一个页面中的组件
" o1 [2 [7 \% l: M4 R9 R  @2 d  Fvar value = parent.right.document.all(“text1″);

admin

CSS

0 L; g; C- g$ M8 G2 B
6 W4 Q4 k' J1 x$ U' b# _如何把样式表加入到html页面中
  `, d* Z6 t& o6 |6 C! I9 k7 N& S在文档<HEAD>中用<Style type=”text/css”></style>定义；

使用<LINK>元素链接到外部的样式表单。<LINK REL=”stylesheet” href=”style1.css”>；

/ D7 }0 x: v( c: l
9 D  Q. o* ]1 z% M0 s9 {
0 Y9 _9 N- @6 [# I8 b0 ?# R如何链接元素和样式，请写出4种方法，并代码示例
1、直接连接

; U4 R' N/ K2 Q9 v# B, m/ j) F; P) r2、class连接
4 S/ F5 m/ {3 {2 h( \
3、id连接

) ~; \- g& R* `! b3 X4、元素的style=””

admin

Xml
# I5 Q, [* Z0 t' O
  l# ]2 v6 [) x- T% b' S6 q
) l/ }* e7 C$ }* n7 n, BXML有几种解析方法，有什么区别？
6 N) L% y% h9 ]1 e, i3 H- K有XML DOM解析、SAX解析、StAX解析
7 p3 ^1 }/ ]5 u! K6 H4 e
0 E; k8 |& u0 }9 [8 L6 B4 ~XML DOM：（XML Document Object Model）处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问；
# i7 v- U0 \* @/ C1 e4 ?+ y
SAX：（Simple API for XML）不同于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问；
  `) \9 q3 q8 H/ ^& S& Y, _
! S7 V8 `7 @6 A4 _" @2 v' u4 \5 CStAX：（Streaming API for XML）与其他方法的区别就在于应用程序能够把 XML 作为一个事件流来处理，无论从性能还是可用性上都优于其他方法；

% c0 Z6 E: O4 g0 p
$ I2 I$ N2 `6 t: N, n6 O5 k
/ z8 V+ m! [5 f( \: M! f+ K9 n3 _  z1 HDOM解析代码如下：
* f: [% e3 c. Q  v9 q3 ?  A0 N
import java.io.*;
6 M+ `/ S( T7 O, |( ]
import java.util.*;

. l$ g; k6 l8 ^( ?" rimport javax.xml.parsers.*;
) K, z2 I% V8 F8 y5 [
$ [5 p" b- X0 U1 @( v# F& pimport javax.xml.transform.*;

import javax.xml.transform.dom.*;

, E- q' ?5 w: g. l# pimport javax.xml.transform.stream.*;
$ c" U& w1 b3 }- Z' p+ E
+ ]5 ?( V1 z* T. M8 |1 ~import org.w3c.dom.*;
. }1 \+ u! x1 G" Z% [7 V
. [+ T1 B& `1 ~4 p: U1 W( N+ Rpublic class Fuxi{

public Fuxi(){}
% F$ p9 V4 U( b$ ~) ]
' Y+ ?4 L9 {% y! h4 `7 [6 opublic void runXml(){
3 W; [) u  T9 I7 G# n$ |
# u' d; p) b5 c# b8 e! M/ v  ~File f = new File(“f:/test/xmltest/student.xml”);
0 U# C: ~7 ]0 m* u
; Y; @7 z. d+ @: g1 o, N' htry{

( S7 [4 h* R  S5 [" F8 C( w0 |//首先创建一个documentbuilderfoctory的工厂
. E) R4 W& U- i' E- O0 `! G
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
. P- x& b: V' E

/ Z4 d& O4 ]9 P
9 O2 N: ?+ i5 N0 v4 l9 \; u//利用工厂来创建documengbuilder

DocumentBuilder db = dbf.newDocumentBuilder();

//利用db的parse方法来解析xml文件

Document doc = db.parse(f);
9 j0 r8 R" V/ E; G
# g1 ]# w% t# t5 D- ?//将读出来的文件格式化
. `2 u+ S8 U1 m* ]& b9 `
- \# m7 m. `! U# B# t5 E* y; h$ v% ~5 Mdoc.normalize();
# x" g3 v; ]$ b& O3 b
6 W8 X, _) Y  y* [//定义一个nodelist数组来存放xml文件中的节点（标签）
% U! ?' O- D" y% m5 {: a
3 X: {# P9 |# @! m  I6 Y( yNodeList students = doc.getElementsByTagName(“student”);

//从xml文件中读取数据

" U6 o0 W3 e. V- C; v; G4 ofor(int i=0;i<students.getLength();i++){
2 k: A2 D5 V" D( L, z3 f- \
//定义一个元素
- @- _7 b& }! W$ ]0 c5 n; g
9 E( d. g, C8 QElement student = (Element)students.item(i);
$ n+ K) ~5 u8 Q* ?3 w3 J/ u
System.out.println(“stu_id :”+student.getElementsByTagName(“stu_id”).item(0).getFirstChild().getNodeValue());
4 X+ E! s2 }8 d
, m1 x7 ^; d" ~3 uSystem.out.println(“name :”+student.getElementsByTagName(“name”).item(0).getFirstChild().getNodeValue());

. T( L; o7 {( C$ n* [; pSystem.out.println(“age :”+student.getElementsByTagName(“age”).item(0).getFirstChild().getNodeValue());

. S/ N2 e  [* h3 ^* ]}

$ u! T1 a" C+ k# @/ e8 w3 d//向文件中写数据

+ J3 e! e4 `  A, T6 Z0 |( F; o3 I4 VString stu_id = “001″;
$ V% G) v2 m' v6 m3 @% p2 z# E! ~
String name = “xingxing”;
2 n9 j6 N: F( [  s( ~- W6 x" l
# T3 [# @3 `+ h* `1 ZString age = “22″;
3 f( U) w7 P( _/ i" ^  P( g
$ L; `3 {  P2 @8 ~2 }+ W: _! kText msg;
3 V3 {/ T( s/ U7 `; V% |2 M0 J
: {( C; y$ I* g! a% X# H8 }( M//创建元素
5 q& E6 A. G2 G7 r$ @+ v* Y; Z
3 F+ @4 L1 a# u5 e* S) G% LElement studentNew = doc.createElement(“student”);

7 p% {  T& J: ^+ r3 e4 m7 `//创建子元素
" G- Z/ ~% g" f$ s* q, N) N
7 ~( d1 R  \' q" t0 R6 mElement stuid = doc.createElement(“stu_id”);
2 M2 W/ C5 O* d( N
" n3 Q- `: A( r5 B4 W% b3 }//设置元素的值
8 ~& \* `- t, W- S+ h# z
msg = doc.createTextNode(stu_id);

: F" D5 C. P0 W//将值添加 给元素

stuid.appendChild(msg);
; j: c) V9 y8 ~# E! l% @
3 y/ n& O7 L( [//将元素添加到节点数组中

4 }& N/ A& }: S- G! J$ {! wstudentNew.appendChild(stuid);

: W1 }; e* B4 y+ DElement name1 = doc.createElement(“name”);

msg = doc.createTextNode(name);

name1.appendChild(msg);
+ X2 x, N7 V' ~* N" _
5 A8 H9 l* I; Y0 l# }studentNew.appendChild(name1);
' f8 I/ F, j3 `2 j* h
; v6 Z* j3 m" R) v+ s. G" a" n. oElement age1 = doc.createElement(“age”);

& C* @" c9 a# t. `! s) qmsg = doc.createTextNode(age);
, B! |) z0 D# q* p. ?
age1.appendChild(msg);

studentNew.appendChild(age1);

5 l2 @" C8 M% `' F//将元素studentnew添加到document树中


$ ~" P. B, p& o
doc.getDocumentElement().appendChild(studentNew);

+ N, s. X, T5 Q4 x( ~) _6 g//进行写操作
, k- b) Q9 b4 R
# T5 n% [8 E; \' NTransformerFactory tff = TransformerFactory.newInstance();
7 E( ~, _0 C" V9 e- @0 F% {9 y
Transformer tfor = tff.newTransformer();

DOMSource dos = new DOMSource(doc);

StreamResult result = new StreamResult(f);

$ i( [# P" {$ Gtfor.transform(dos,result);

}catch(Exception e){
5 D2 X6 a* u& k
System.out.println(e.toString());
: k& Q9 |0 w% {# x
3 r* d! W% a' v- K0 g0 _$ L. |+ S}

9 B( c0 K$ p# ~4 E5 \0 O! X}
4 M0 }* N! X7 U0 z6 H2 O" U: x
public static void main(String[] args){
: m) ]0 j! V" E6 c# I
" D- U0 y1 U/ H5 J$ U, eFuxi ff = new Fuxi();
. v& ~: Q9 D: m5 @3 L3 Q
ff.runXml();

  A' |6 i# `+ z% S, E}

5 W- p2 W; q& m  ^) L) Q. [& G}