1、为什么要配置环境变量？

jdk需要配置的环境变量一般有三个：JAVA_HOME、path和CLASSPATH

JAVA_HOME：它指向jdk的安装目录。作用：

一是为了方便引用，比如，JDK安装在C:jdk1.6.0目录里，则设置JAVA_HOME为该目录路径, 那么以后要使用这个路径的时候, 只需输入%JAVA_HOME%即可, 避免每次引用都输入很长的路径串;

二则是归一原则, 当JDK路径改变的时候, 仅需更改JAVA_HOME的变量值即可, 否则,就要更改任何用绝对路径引用JDK目录的文档, 要是万一没有改全, 某个程序找不到JDK,后果是可想而知的----系统崩溃!

三则是第三方软件会引用约定好的JAVA_HOME变量, 不然, 你不能正常使用该软件。

path：作用是指定命令的路径。即告诉操作系统javac和Java这些相关命令在哪个目录下放着。当设置好path这个环境变量的时候，就可以在任何目录下执行javac和Java命令了。

CLASSPATH：作用是指定类的搜索路径。 当我们在开发java程序时需要引用别人写好的类时，要让java解释器知道到哪里去找这个类。通常，sun为我们提供了一些额外的丰富的类包，一个是 dt.jar（也就是所谓的java内部包），一个是tools.jar，这两个jar包都位于jdklib目录下，所以通常我们都会把这两个jar包 加到我们的classpath环境变量中。（注意，CLASSPATH 中最前面是有个 “.”的，表示当前目录，这样当我们运行java AClass的时候，系统就会先在当前目录寻找AClass文件了。）

2、各种缩写

SDK: software development kit   软件开发工具包

JDK: Java Development Kit      java 开发工具包

JRE: Java Runtime Envirnment    Java运行环境

JVM: java virtual machine       java虚拟机

IDE: integrated developmentenvironment   集成开发环境

Java SE：javaPlatform Standard edition   标准版

Java EE：javaPlatform Enterprise edition 企业版

Java ME：javaPlatform Micro edition     微机版

API：applicationprogramming interface   应用程序编程接口

GC:     Garbage Collection               垃圾收集机制

ERP:  Enterprise Resource Planning       企业资源计划

3、java两种核心机制

JVM：因为是对字节码文件一条一条的解释执行，所以java又称为解释性语言。开发需要jdk，用户只需jre。

垃圾收集机制：与c/c++等不同，因为c/c++等语言中是由程序员负责回收无用的内存。而垃圾收集在java程序运行过程中自动运行，程序员不用管。

4、jdk、jre、JVM的关系

jdk=JRE+一堆Java工具（javac/java/jdb等）+Java基础的类库

JRE= JVM+java核心类库

JVM：它是整个java实现跨平台的最核心的部分，所有的java程序会首先被编译器（javac.exe）编译 为.class文件（字节码文件），字节码文件可以放到任意装有 JRE 的计算机运行，这也就是Java的厉害所在，即一次编译到处运行。

5、面向对象是什么意思

6、做过的项目具体描述

7、异常与错误的区别

8、异常处理可以不写catch，只写try ..finally!

Try{..}catch（）{}                     true

Try{..}finally{}                       true

Try{..}catch（）{}finally{}           true

其中finally未必非要被执行，要看情况

9、字符型char，初始化的时候必须用单引号，双引号表示字符串

char a= ‘s’;  true

char b= “s”;  false

10、异常与错误的区别

11、javascript与java的流程控制的异同点

switch（表达式）

{

case 常量值:

语句；

break；

default：

语句；

Break;

}

java的流程控制与上边一样，只是异同点在于开关语句的参数类型不同：

javascript中的switch（表达式）和case 常量值中的表达式和常量值的数据类型可以使javascript所支持的所有类型（类和对象除外）；

java允许的数据类型只有整型、字符型、字符串类型。

12、hashmap和hashtable的异同点

相同点：hashmap和hashtable都是java的集合类，都可以存放java对象。

区别：

同步性：hashmap是异步的，因此hashmap中的对象不是线程安全的。

Hashtable是线程同步的，这个类中的一些方法保证了hashtable中的对象时线程安全的。要求同步会影响效率。

放入值的要求：hashmap可以让你将空值作为一个表的条目的key或者vaule;而hashtable不可以放入空值的。

13、Arraylist和Vetor的异同点

相同点：Arraylist和Vetor都是java的集合类，都可以存放java对象，都是使用数组来空值集合中的对象的。

区别：

同步性：Arraylist是异步的，因此Arraylist中的对象不是线程安全的。

Vetor是线程同步的，这个类中的一些方法保证了Vetor中的对象时线程安全的。要求同步会影响效率。

数据的增长：当像这两种类型中增加元素的时候，元素的数目超过了内部数组目前的长度时，他们需要扩展内部数组的长度，vector自动增长为原来的两倍，即长出一倍的长度；arraylist变为原来的1.5倍，即增长一半。

14、为什么比较两个字符串不能用比较运算符“= =”

    因为“==”比较的是两个字符串的地址是否一样。及时两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然返回FALSE。

15、创建字符串的两种方式的不同点

第一种：

String a1=”abc”;

先在内存中创建了“abc”这个字符串，如果这是后再来一条语句String a2=”abc”;

这时JVM不再创建一个新的内存来存放这个“abc”，即a1和a2用的是同一块内存。

第二种：

String b1=new String(”abc”);

String b2=new String（”abc”）;

每次new一下，都会在内存中创建一块内存来存放，不论内容是否相同

System.out.println(a1==a2);             结果为TRUE
System.out.println(a1.equals(a2));        结果为TRUE
System.out.println(b1==b2);             结果为flase
System.out.println(b1.equals(b2));        结果为TRUE

在Java中，字符串可以直接赋值或者使用new来新建，直接赋值的话是编译阶段（.class文件）中就将该字符串值放到常量池中，以后如果有其他变量直接赋予同样的值的话就不再分配内存空间，而是直接给它个引用地址；而使用new来创建的话是在程序运行时才分配的空间，是一个新的引用地址，可以通过inter()方法将字符串加入的常量池中，如果在常量池中已经存在该字符串，则返回其引用。在String类中，==是比较两个字符串的引用地址是否相同，equals比较的是两者的值是否相同（在其他的引用类中==和equals也是同样意思）。

16、http://www.iteye.com/topic/774673

关于String b1=newString(”abc”); 会创建几个String型的对象的问题？

17、数组的长度和字符串的长度

JAVA中length（）可以获得字符串和数组的长度对不对

不对！字符串有成员函数length(),可以通过调用 str.length()来获得字符串的长度

数组的length是一个静态成员变量，不是方法，array.length就是数组的长度

18、Array和Arrays的区别

java.lang.reflect.Array：此类提供了动态创建和访问 Java 数组的方法。具体类

java.util.Arrays：此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。 工具类（后面带s的大多都是工具类）

JAVA API中的定义java.util.Arrays：This class contains various methods for manipulating arrays (such as sorting and searching). This class also contains a static factory that allows arrays to be viewed as lists. 

前者倾向于操作数组的单个元素，后者倾向于操作整个数组。

为什么需要Arrays这个类呢？

因为 Java中的数组虽然继承自Obect类,但是其自身对Object的扩展很少啊,除了length这个数据成员外,其它没有了.甚至连equals都用Object默认的equals方法.所以,有时用起来很不方便.所以 java语言提供一个工具类 Arrays辅助数组来实现一些功能.

19、二维数组的初始化

错误的：int a[][]={{3,67};{34,5};{1,2}};//中间应该用逗号，不是分号

正确的：int a[][]={{3,67},{34,5},{1,2}};

fill方法只能填充某一个数组的元素，你想把二维数组填满需要做for循环。

20、Arrays.copyOf()与System.arraycopy(···)区别

21.深复制和浅复制

　Java数组的复制操作可以分为<深复制>和<浅复制>。个人简单认为，深复制就是复制后的数组元素发生改变不会影响源数组，浅复制就是<对象引用的复制>。

今天写一个用二维数组存储图结构的程序，涉及到两个二维数组之间的深拷贝：

char[][] QPN = new char[30][30];

char[][] UQPN = new char[30][30];

System.arraycopy(this.QPN, 0, UQPN, 0,this.QPNNumber);//this.QPNNumber为图的节点个数，这里假设QPN已被赋值

当对UQPN进行操作并改变其元素的值之后，发现QPN的值也被改变，但以前也用过这个方法对数组进行深拷贝，而且成功，困惑... 上网查了一下：

JAVA中没有多维数组的概念，只有数组的数组，因此QPN是一个数组的数组，同理UQPN 也是。那么QPN 含有两个元素，分别指向两个数组的引用，而arrayCopy 就是负责把数组的内容copy 过去的，因此QPN的内容 (2 个引用) 被copy 到UQPN 中去了，因此对QPN做修改，QPN也会同样跟着变化.

在JAVA里面，可以用复制语句“A=B”给基本类型的数据传递值，但是如果A,B是两个同类型的数组，复制就相当于将一个数组变量的引用传递给另一个数组；如果一个数组发生改变，那么引用同一数组的变量也要发生改变。

JAVA中复制数组元素值的的方法指深拷贝

1 使用for循环，将数组的每个元素复制（需要将每个对象调用clone方法，才能实现真正的复制）

2 使用clone方法，得到数组的值，而不是引用

3 使用System.arraycopy方法

注意：

1.上面方法中arraycopy效率较高。

2. 以上所说的拷贝数组的方法，只是针对一维数组，对于多维数组，要在每一维用以上方法进行复制才能实现复制数组元素的值而不是引用。

3. clone 和 arraycopy对二维数组进行复制时，是浅拷贝，即

System.arraycopy(this.QPN, 0, UQPN, 0, this.QPNNumber);

这样做数组元素只复制了引用。新旧数组指向相同的内存地址，（不论对象数组，还是基本类型数组）。正确的方法为：

for(int i = 0; i < this.QPNNumber; i++)
{
     System.arraycopy(this.QPN[i], 0, UQPN[i], 0, this.QPNNumber);
}

22、GUI

  GUI全称Graphical User Interfaces，意为图形用户户界面，又称为图形用户接口，GUI指的就是采用图形方式显示的计算机操作用户界面，打个比方吧，我们点击QQ图标，就会弹出一个QQ登陆界面的对话框。这个QQ图标就可以被称作图形化的用户界面。

       实现GUI编程的必不可少的三个条件是组件、事件、事件监听。

      组件就是一些基本的图形元素，包含有两类组件，一类是像我们经常用到的按钮、文本框、文本域、多选按钮、单选按钮等；另一类是我们经常说到的容器，比如说窗体、Panel等，它的作用主要是用来组织界面上的组件或者单元。

AWT组件

       AWT组件是重量级组件，它依赖于本地操作系统的GUI，缺乏平台独立性。但是AWT组件简单稳定，兼容于任何一个JDK版本。AWT所涉及到的类一般在java.awt的包及其子包中。java.awt中的类负责与本地操作系统进行交互，让本地操作系统显示和操作组件。

       AWT中的两个核心类是Container（容器）和Component类

Component类

        Java图形用户界面最基本组成部分是Component，Component类及其子类的对象用来描述以图形化的方式显示在屏幕上并能够与用户进行交互的GUI元素（标签、按钮）。

Container类

        用来组织界面上的组件或者单元。有两种常用的Container（容器），一是Window，Window对象表示自由停泊的顶级窗口，另一个是Panel对象可作为容纳其他Component对象，但不能够独立存在，必须被添加到其他Container中，比如说Window或者Applet中。

        Container它有一定的范围和大小，一般都是矩形。也有一定的位置，这个位置可分相对位置和绝对位置。

        一个Container中可以包含其他Container，Container中可以嵌套Container，当Container显示时候，它里面的元素也被小时出来，当Container隐藏时或者关闭时，它包含的元素也被隐藏。 

Component类与Container类关系

       Component对象不能独立显示出来，必须放在某一Container对象中才可以显示出来。 

       Container是Component的子类，Container子类对象可以容纳别的Component对象。Container对象也可以被当作Component对象添加到其他Container对象中。 

        事件是指组件触发的动作事件，java中不同的事件由不同的监听器处理，组件是事件源对象，而监听器主要用来接收来自事件源对象产生的动作事件，然后对其处理。

事件监听

说明：

        事件实现过程中产生的对象：事件、事件源、监听器

        事件：用户在界面上的某一个操作，通常使用各种输入设备，如鼠标、键盘等。

        事件源：产生事件的组件，例如在一个按钮上的单击就是事件源

        监听器：包含事件处理器，负责检查事件是否发生，若发生则激活事件处理器对其处理

      监听过程： 当事件源对象产生某种事件时，先封装该事件的信息，然后向监听器传送此事件对象，监听器在接收到事件对象后，为了能让监听器检查组件是否发生了该事件，会向该事件源对象（即该组件）注册事件监听器，然后事件处理器会检查事件是否发生，如果发生了，那么激活事件处理器进行处理

 22、Java内存简单分析

 在Java中，内存的管理分为以下几个部分：                   

   Heap：堆区域，存放对象实例，凡是New出来的东西都存放在此。

    Stack：栈区域，存放基本数据类型、常量、局部变量、对象的引用地址

    Data Segment：数据段，存放静态变量和字符串常量

    Code Segment：代码段，存放代码

    一个程序的执行，先要从程序的存放地加载到内存区，然后找到内存区中的main方法执行，在这个执行过程中，内存就会对其进行管理。

23、this关键字的用处

在Java语言中规定使用this关键字来代表本类对象的引用。

This可以调用成员变量和成员方法，还可以作为方法的返回值；还可以调用类中的构造方法（但是使用这种方式需要注意的是只可以再无参数构造方法中的第一句话使用this调用有参数构造方法）。

例子1：

public class getBook()
{
return this;
}

例子2：

public  class  AnyThing{
         public  AnyThing()
{
this(“this调用有参构造方法”)；
System.out.println(“无参构造方法”);
}
         public  AnyThing(String  name)
{ 
System.out.println(“有参构造方法”);
}
}

24、static 和final修饰的区别

25、关键字的种类？限制修饰符、操作符是关键字吗？

Which are not Java keywords?

A. true B. sizeof C. const D. super E. void                    答案：A,B

解析:

A：不是，Java中有true,但是这也不是关键字而是字面量（literal）。
B： 不是，Java中不需要这个操作符，所有的类型（原始类型）的大小都是固定的。
C、D、E都是，需要说明的是const是java中未被使用的关键字。

Java的关键字，又叫保留字，是有特别意义的变量 ，对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。所有的关键字都是小写的。切记java中 true ,false, null在java中不是关键字，也不是保留字，它们只是显式常量值，但是你在程序中不能使用它们作为标识符。

Java语言规定关键字不能作为标识符。目前共有50个Java关键字，其中，"const"和"goto"这两个关键字在Java语言中并没有具体含义。Java语言把它们列为关键字，只是因为"const"和"goto"是其他某些计算机语言的关键字。

具体用法请参考：http://baike.baidu.com/link?url=SNKbrCx9oKvAo-JxkpD4R2jkwGNtngcyBh2lrld7P4xaWTyQIZdG7o8kgdiKaCPkQ-k2vKvId0ITvl7OeAwOfK

或者

访问控制:private 私有的、protected 受保护的、public 公共的

类、方法和变量修饰符：abstract 声明抽象、class 类、extends 扩允,继承、final 终极,不可改变的、implements实现、interface 接口、native 本地、new 新,创建、static 静态、strictfp 严格,精准、synchronized线程,同步、transient 短暂、volatile 易失

程序控制语句：break 跳出循环、continue继续、return 返回、do 运行、while 循环、if 如果、else 反之、for 循环、instanceof 实例、switch 开关、case 返回开关里的结果、default 默认

错误处理:catch 处理异常、finally 有没有异常都执行、throw 抛出一个异常对象、throws 声明一个异常可能被抛出、try 捕获异常

包相关：import 引入、package 包

基本类型：boolean 布尔型、byte 字节型、char 字符型、double 双精度、float 浮点、int 整型、long 长整型、short 短整型
变量引用：super 父类,超类、this 本类、void 无返回值

26、break , continue , return区别与联系

break :

(1).结束当前整个循环，执行当前循环下边的语句。忽略循环体中任何其它语句和循环条件测试。

(2).只能跳出一层循环，如果你的循环是嵌套循环，那么你需要按照你嵌套的层次，逐步使用break来跳出。[逐层判断，逐步跳出]

(3).break在循环体内，强行结束循环的执行，也就是结束整个循环过程，不在判断执行循环的条件是否成立，直接转向循环语句下面的语句。

(4).当break出现在循环体中的switch语句体内时，其作用只是跳出该switch语句体。总的来说：就近原则，结束当前的整个循环。

return：

(1).return 从当前的方法中退出,返回到该调用的方法的语句处,继续执行。

(2).return 返回一个值给调用该方法的语句，返回值的数据类型必须与方法的声明中的返回值的类型一致。

(3). return后面也可以不带参数，不带参数就是返回空，其实主要目的就是用于想中断函数执行，返回调用函数处。

continue：

(1).终止本次循环的执行，即跳过当前这次循环中continue语句后尚未执行的语句，接着进行下一次循环条件的判断。

(2).结束当前循环，进行下一次的循环判断。

(3).终止当前的循环过程，但他并不跳出循环,而是继续往下判断循环条件执行语句.他只能结束循环中的一次过程,但不能终止循环继续进行.

测试程序：

publicclass
publicstatic void
 new
        test.testBreak1(); 
        test.testContinue1();
        test.testBreak2();
        test.testContinue2();
}
  /*测试continue
     * continue用来结束本次循环
     */
publicvoid
"--------测试continue-------");
for (int i = 1; i <= 5;i++)  
     } 

     /** 
      * break用来结束整个循环体
      */ 
     public void testBreak1()  
     }  /** 测试带标签的break语句
      * 标签只能写在循环体之前，顺便学习一下java中语句标签的定义和使用   */
     public void testBreak2()  
     }     public void testContinue2()  
         } 
     } 
 }

运行结果:

--------测试break1-------
 i=1 
 i=2 
 --------测试continue-------
 i=1 
 i=2 
 i=4 
 i=5 
 --------测试break2-------
 i=1 ; k=4 
 i=2 ; k=3 
 i=3 ; k=2 
 i=4 ; k=1 
 --------测试continue2-------
 i=1 
 i=2 
 i=3 
 i=4 
 i=5 
 i=6 
 i=7 
 i=8 
 i=9

27、String.format()中的转换符与正则表达式的元字符

String类的format()方法用于创建格式化的字符串以及连接多个字符串对象。熟悉C语言的同学应该记得C语言的sprintf()方法，两者有类似之处。format()方法有两种重载形式：

format(String format, Object... args) 新字符串使用本地语言环境，制定字符串格式和参数生成格式化的新字符串。

format(Locale locale, String format,Object... args) 使用指定的语言环境，制定字符串格式和参数生成格式化的字符串。

显示不同转换符实现不同数据类型到字符串的转换，如图所示。

测试用例

1. public static void main(String[] args) {  
2.     String str=null;  
3.     str=String.format("Hi,%s", "王力");  
4. 
5.     str=String.format("Hi,%s:%s.%s", "王南","王力","王张");            
6. 
7.     System.out.printf("字母a的大写是：%c %n", 'A');  
8.     System.out.printf("3>7的结果是：%b %n", 3>7);  
9.     System.out.printf("100的一半是：%d %n", 100/2);  
10.    System.out.printf("100的16进制数是：%x %n", 100);  
11.     System.out.printf("100的8进制数是：%o %n", 100);  
12.    System.out.printf("50元的书打8.5折扣是：%f 元%n", 50*0.85);  
13.     System.out.printf("上面价格的16进制数是：%a %n", 50*0.85);  
14.    System.out.printf("上面价格的指数表示：%e %n", 50*0.85);  
15.     System.out.printf("上面价格的指数和浮点数结果的长度较短的是：%g %n", 50*0.85);  
16.    System.out.printf("上面的折扣是%d%% %n", 85);  
17.     System.out.printf("字母A的散列码是：%h %n", 'A');  
18.}

输出结果 

1. Hi,王力  

2. Hi,王南:王力.王张  

3. 字母a的大写是：A   

4. 3>7的结果是：false   

5. 100的一半是：50   

6. 100的16进制数是：64   

7. 100的8进制数是：144   

8. 50元的书打8.5折扣是：42.500000 元  

9. 上面价格的16进制数是：0x1.54p5   

10.上面价格的指数表示：4.250000e+01   

11. 上面价格的指数和浮点数结果的长度较短的是：42.5000   

12.上面的折扣是85%   

13. 字母A的散列码是：41  

搭配转换符的标志，如图所示。

测试用例

1. public static void main(String[] args) {  
2.     String str=null;  
3.     //$使用
4.     str=String.format("格式参数$的使用：%1$d,%2$s", 99,"abc");             
5. 
6.     //+使用
7.     System.out.printf("显示正负数的符号：%+d与%d%n", 99,-99);  
8.     //补O使用
9.     System.out.printf("最牛的编号是：%03d%n", 7);  
10.    //空格使用
11.     System.out.printf("Tab键的效果是：% 8d%n", 7);  
12.    //.使用
13.     System.out.printf("整数分组的效果是：%,d%n", 9989997);  
14.    //空格和小数点后面个数
15.     System.out.printf("一本书的价格是：% 50.5f元%n", 49.8);  
16.  }  
17.  输出结果
1. 格式参数$的使用：99,abc  
2. 显示正负数的符号：+99与-99  
3. 最牛的编号是：007  
4. Tab键的效果是：       7  
5. 整数分组的效果是：9,989,997  
6. 一本书的价格是：                                          49.80000元

28、java、怎样简便的保留小数点后两位

有两种情况：

1、只要输出结果的时候可以用以下方法：
 double x1 = 0.026;
 System.out.println(String.format("%.2f", x1));
 结果：0.03
 2、使用数据转换（4种方法）
 //方案一:
 get_double = (double)(Math.round(result_value*100)/100.0) 想保留n位小数，就Math.round(a*10的n次方)/10的n次方。
 //方案二:
 DecimalFormat df = new DecimalFormat("#.##");
 get_double = Double.ParseDouble(df.format(result_value));
 //方案三:
 get_double = Double.ParseDouble(String.format("%.2f",result_value));
 //方案四:
 BigDecimal bd = new BigDecimalresult_value();
 BigDecimal bd2 = bd.setScale(2,BigDecimal .ROUND_HALF_UP);
 get_double = Double.ParseDouble(bd2.ToString());