/***********************************Java概论章节*************************************/

java跨平台原理解释:

java之所以可以跨平台执行，在于java虚拟机（JVM）的引入。java源代码都是先被编译成字节文件（也就是.class文件），然后放到不同平台上用虚拟机进行解释执行。不同的操作系统有与之对应的虚拟机，所以要在不同平台执行java.class文件就只需要安装对应的java虚拟机即可。具体可见下图：

1、java中几个常用的核心包和拓展包有哪些？

答：包名以 Java 开始的包是 Java 核心包 (Java Core Package) ；包名以 Javax 开始的包是 Java 扩展包 (Java Extension Package) ，例如 javax.swing 包；

 

常用的 Java 核心包 (Java Core Package)

1.       java.lang      Java 编程语言的基本类库

2.       java.applet     创建 applet 需要的所有类

3.       java.awt       创建用户界面以及绘制和管理图形、图像的类

4.       java.io        通过数据流、对象序列以及文件系统实现的系统输入、输出

5.       java.NET       用于实现网络通讯应用的所有类

6.       java.util       集合类、时间处理模式、日期时间工具等各类常用工具包

其它还有

7.       java.sql        访问和处理来自于 Java 标准数据源数据的类

8.       java.test       以一种独立于自然语言的方式处理文本、日期、数字和消息的类和接口

9.       java.security    设计网络安全方案需要的一些类

10.   java.beans     开发 Java Beans 需要的所有类

11.   java.math      简明的整数算术以及十进制算术的基本函数

12.   java.rmi       与远程方法调用相关的所有类

 

常用的 Java 扩展包 (Java Extension Package)

1.  javax.accessibility  定义了用户界面组件之间相互访问的一种机制

2.  javax.naming.*     为命名服务提供了一系列类和接口

3.  javax.swing.*       提供了一系列轻量级的用户界面组件，是目前 Java 用户界面常用的包

 

注 1 ：最重要且常用的是 1 和 6 ，已用黑体标出的为，需重点掌握

注 2 ：在使用 Java 时，除了 java.lang 外，其他的包都需要 import 语句引入之后才能使用。

重点讲解内容：java.lang和java.util。

java.lang 包

这个包称为 java 语言包，是由编译器自动引入的。程序中不必用 import 语句就可以使用。它所包含的类和接口对所有实际的 Java 程序都是必要的。

1.       object 类

2.       数学类 (Math)

3.       数据类型类

4.       线程类

5.       字符串类 (String 类和 StringBuffer 类 )

6.       系统及运行类 (System 类和 Runtime 类 )

7.       错误和异常处理类 (Throwable 、 Exception 、 Error)

8.       过程类 (process)

  

java.util 包

1. 日期类、日历类（ Data 、 Calendar 、 GregorianCalendar ）

2. 随机数类（ Random ）

3. 位运算类（ BitSet ）

4. 矢量类（ Vector ）

5. 数据结构类（ Stack ）

6. 散列表类（ Hashtable ）

7. StringTokenizer类

/***********************************java基础章节*************************************/

1、java中的数据类型有哪些？

答：

（1）类型分类：

java数据类型可以分为两类：基本数据类型和引用数据类型。具体内容如下：

如上图可知：java有8种基本数据类型，和3种引用数据类型；

8种基本数据类型，分别是byte,short,int,long,char,boolean,float,double，具体如下：

1、boolean：数据值只有true或false，适用于逻辑计算；

2、char：char型（字符型）数据在内存中占用16位，而C系列中占用8位；

3、byte：byte型（字节型）数据在内存中分配长度8位，表示的存储数据范围为：-128~127；（实际占用空间32位）

4、short：short型（短整型）数据在内存中分配长度16位；（实际占用空间32位）

5、int：int型（整型）数据在内存中占用32位；

6、long：long型（长整型）数据在内存中占用64位；

7、float：float型（单精度浮点型）数据在内存中占用32位（float精度为7-8位）；

8、double：double型（双精度浮点型）数据在内存中占用64位；

Java中所有的基本数据类型都有固定的存储范围和所占内存空间的大小，而不受具体操作系统的影响，来保证Java程序的可移植性。整形数据默认为int数据类型，浮点型默认为double数据类型，如果要表示long型数据或float型数据，要在相应的数值后面加上l、L或f、F，否则会出现编译问题。

以上8种基本数据类型自动类型转换是按优先级来的：byte→short→int→long→float→double。

（2）类型包装类

Java为了能将基本类型（primitive type）视为对象来处理，并能连接相关的方法，Java为每个节本类型都提供了相应的包装类，这样便能将基本类型转化为对象来处理。其对应关系表如下所示：

注意：java的关键字都是小写的，只有类名等才是大写，如上述基本类型都是小写，而类型包装类都是大写，还有就是String也是大写，表明String在Java中是一个类对象。

（3）装箱与拆箱

boxing：将基本数据类型包装成对应的包装类对象。

unboxing：将包装类对象转换成对应的基本数据类型。

Java编译器在编译时期会根据源代码的语法来决定是否进行装箱和拆箱。在运算时，也可以进行自动装箱和拆箱。

2、java中创建数组与C系列有什么不同？

答：java中定义数组：String[] arr或者String arr[]，注意不可以像C/C++中那样：string arr[10]直接为数组变量分配内存；

分配内存需要创建数组如: String[] arr=new String[10]，C#也和java一样。

3、对象作为参数传递给方法后会被修改吗？

答：会，因为对象在形参实参传递中实际传递的是对象地址，方法会根据地址找到对象并对其进行操作，所以一定会修改对象。举例如下：

结果应为：null 42 42；而不是：null null 42
注意：Byte与byte的区别。

/***********************************java类与对象章节*************************************/

1、java类声明修饰符有哪些？

答：修饰符有public、abstract和final。其中abstract表示该类是抽象类，不可以被实例化，只可以继承；final表示该类不可以被继承，即不能有子类。

2、Java中extends 与 implement 区别？

答：简单说： 

1）extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承，
2）JAVA中和C++不同，它不支持多重继承，但是可以用接口来实现，这样就要用到implements，

3）继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了 ,比如  class A extends B implements C,D,E 。

3、java中的继承性解释?

答;java中继承使用关键字extends，注意java只可以继承一个父类，即单继承。而C++是可以多继承的，java要实现某种程度上多继承只可以用接口方式。

4、java中的接口与抽象类是怎样的？

答：

接口（implements）：

通过关键字implements来实现类中接口，注意接口是可以有多个的。接口是一个特殊的抽象类，这种抽象类只包含常量和抽象方法，而没有变量和方法实现，也没有构造函数。

所以接口与类继承最大的不同在于：接口中的方法都是抽象方法，需要自己到类中实现该方法，而类继承则是直接使用现成的父类方法。

接口作用形象点就是：提供功能，但不管功能如何实现。

抽象类（extends，用于继承）：

包含抽象方法的类就是抽象类（当然抽象类不一定都包含抽象方法），抽象类必须在类前用abstract关键字修饰。抽象类就是为了继承而存在的，如果你定义了一个抽象类，却不去继承它，那么等于白白创建了这个抽象类，因为你不能用它来做任何事情。对于一个父类，如果它的某个方法在父类中实现出来没有任何意义，必须根据子类的实际需求来进行不同的实现，那么就可以将这个方法声明为abstract方法，此时这个类也就成为abstract类了。包含抽象方法的类称为抽象类，但并不意味着抽象类中只能有抽象方法，它和普通类一样，同样可以拥有成员变量和普通的成员方法。注意，抽象类和普通类的主要有三点区别：

　1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。

   2）抽象类不能用来创建对象，不能实例化，且抽象类可以没有抽象方法；

   3）如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。

   在其他方面，抽象类和普通的类并没有区别。

抽象方法：只有方法定义没有方法实现，且用abstract修饰的方法，且包含抽象方法的类一定是抽象类。

接口与抽象类的区别：

　　1）抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法；

　　2）抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的；

　　3）接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；

　　4）一个类只能继承一个抽象类，而一个类却可以实现多个接口。　

5、成员变量与局部变量有何区别？

答：

成员变量：定义在类中的变量，对于整个类有效。成员变量又分成两种类型：实例变量和静态变量。静态变量在定义时要使用static关键字；

局部变量：定义在方法中，仅对于所在方法有效；

两者区别：

1.成员变量在类中，局部变量在方法中；       

2.声明成员变量时可以不初始化（被final修饰且没有static的必须显式赋值），而局部变量必须手动初始化，否则在后面使用时就会报错；

3.成员变量可以被public，protect，private，static等修饰符修饰，而局部变量不能被控制修饰符及static修饰；两者都可以定义成final型；

4.成员变量存储在堆，局部变量存储在栈；

5.存在时间不同 。

6、类变量、实例变量和局部变量的定义是什么？

答：

定义：
类变量是类中独立于方法之外的变量，用static 修饰。
实例变量也是类中独立于方法之外的变量，不过没有static修饰。
局部变量是类的方法中的变量。

实例变量也称为“域”；

成员变量在实体类或数据类中被称为“属性”或“字段”；

成员变量修饰符介绍：

包括static、final、transient、volatile，解释其中transient和volatile，前者表示瞬态变量，后者表示此变量可能被几个线程所控制。

7、final修饰符在java中的作用是？

答：在Java中，final关键字可以用来修饰类、方法和变量（包括成员变量和局部变量）。

修饰类：final修饰一个类时，表明这个类不能被继承；

修饰方法：final方法不能被重写，也不能被子类覆盖，现在不常用，但是private方法会被隐式指定为final。同时，final修饰的函数也可以表示内联函数，但是否真正被视作内联函数由编译器根据其函数体大小及调用环境等因素决定；

修饰变量：final修饰的变量表示常量，只能被赋值一次，赋值后值不再改变（C++中用const修饰常量）；

（1）修饰成员变量：final成员变量必须在声明的时候初始化或者在构造器中初始化，否则就会报编译错误；

（2）修饰局部变量：局部变量必须在声明时赋值，否则编译器会报错。

注意：

按照Java代码惯例，final变量就是常量，而且通常常量名要大写，如：

1	private final int COUNT = 10 ; ；

final和abstract这两个关键字是反相关的，final类不可被继承而abstract类就是用于继承的；

接口中声明的所有变量本身是final的；

匿名类中所有变量都必须是final变量。

8、static关键字的作用

答：类的成员变量和成员方法还可以进一步划分，有static修饰的是类变量或类方法（也就是静态成员变量与静态成员方法），无static修饰的是实例变量或实例方法。

区别：

类变量（静态成员变量）只在创建第一个对象时分配一次内存，其他对象共享该变量内存值；

实例变量（非静态成员变量）每个对象都会给它分配内存；

类方法（静态成员方法）只可以操作所在类的类变量（静态成员变量）；

实例方法（非静态成员方法）即可操作类变量（静态成员变量）也可操作实例变量（非静态成员变量）；

用static修饰的类（静态）变量和类（静态）方法都不可以实例化调用，无论在其他类还是在自身都只可以用类直接调用。

9、成员方法中的方法重载与构造方法介绍

答：

方法重载：多个方法名相同但参数个数或类型不同，作用在于简化程序实现。一般在大软件中都用，我自己没用过。

构造方法：方法名与类名同，作用是初始化新建的对象，记住不许有返回值。

10、对象自动释放（自动垃圾回收机制GC）

答：java会自动将没有被引用的对象视为垃圾，释放回收，这就是垃圾自动回收机制。

但是由于垃圾回收操作的优先级很低，有时也可以用命令来释放对象，具体如下：

system.gc()方法：要求垃圾回收，垃圾回收线程将优先得到运行。但是需要注意的是，调用System.gc()也仅仅是一个请求(建议)。

JVM接受这个消息后，并不是立即做垃圾回收，而只是对几个垃圾回收算法做了加权，使垃圾回收操作容易发生，或提早发生，或

回收较多而已。

finalize()方法：finalize()的主要用途是释放一些其他做法开辟的内存空间，以及做一些清理工作。之所以要使用finalize()，是存在着垃圾回收器不能处理的特殊情况，如局部变量是存在栈中，不是堆中，所以不可以用GC回收，此时只可以用finalize()。

GC触发条件：

1)当应用程序空闲时,即没有应用线程在运行时,GC会被调用。因为GC在优先级最低的线程中进行,所以当应用忙时,GC线程就不会被调用,但以下条件除外。

2)Java堆内存不足时,GC会被调用。

减少GC开销的措施：

(1)不要显式调用System.gc()；

(2)尽量减少临时对象的使用；

(3)对象不用时最好显式置为Null；

(4)尽量使用StringBuffer,而不用String来累加字符串；

(5)能用基本类型如Int,Long,就不用Integer,Long对象；

(6)尽量少用静态对象变量；

(7)分散对象创建或删除的时间。

GC中需要注意的：

垃圾回收时间不确定，都是随机的；

程序员无法控制垃圾回时间，最多用system.gc()建议垃圾回收；

GC只可以回收堆中的对象，不可以回收栈中的局部变量等。

11、java中的内存管理

（1）java中JVM的运行时数据区域包括以下几个方面，见下图：

上述运行时数据区包括5部分：堆、方法区、虚拟机栈、本地方法栈和程序计数器；

其中方法区和堆是共享的，栈和程序计数器是线程隔离（私有）的。

（1）程序计数器

程序计数器（Program Counter Register）是一块较小的内存空间，它可以看做是当前线程所执行的字节码的行号指示器。每条

线程都需要有一个独立的程序计数器，各条线程之间的计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存。如

果线程正在执行的是一个Java方法，这个计数器记录的是正在执行的虚拟机字节码指令的地址；如果正在执行的是Natvie方法，

这个计数器值则为空。此内存区域是唯一一个在Java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。

（2）java虚拟机栈 

在java中我们最关注的堆和栈基本都是指java虚拟机栈，它也是线程私有的，每个方法被执行的时候都会同时创建一个栈帧用于存储局部变量表、操作栈、动态链接、方法出口等信息。每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。与只对应的线程结束后，栈中的内存就会自动被释放。 

（3）本地方法栈

本地方法栈和虚拟机栈非常相似，其区别不过是虚拟机栈为虚拟机执行Java方法（也就是字节码）服务，而本地方法栈则是为虚拟机使用到的Native方法服务，有的直接将两者合并。

（4）java堆

Java堆（Heap）是Java虚拟机所管理的内存中最大的一块，此区域用于存放实例对象和数组对象。原则上，所有的对象实例

都在这分配内存。堆是线程共享区域，该区域中的对象实例需要垃圾回收机制进行释放。

（5）方法区

方法区（Method Area）与Java堆一样，是线程共享的，它用于存储类信息、常量、静态变量、即时编译器编译后的代码等数据。

下面专门比较堆内存与栈内存：

在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。 当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。

堆内存主要用来存放由new创建的对象和数组。 在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。 在堆中产生了一

个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量

就成了数组或对象的引用变量。

注：引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。

还有，java的内存管理和C++不同点：java是自动管理堆与栈，而C++内存管理需要程序员操作。

总结一下：方法区保存的就是一个类的模板，堆是放类的实例的，栈是一般来用来函数计算的。我们最关注的一般都是堆内存与栈内存，其中栈内存存储的数据在线程结束时就会被自动释放，故一般都用于局部变量和对象的引用等相关数据存储。而堆内存一般都是存储对象（实例对象和数组对象）的，这些对象很多都是线程共享的，故需要垃圾回收机制自行释放。

讨论：成员变量存储在堆还是栈？

答：经过查找资料，我认为是这样的：静态成员变量归属静态变量，故存储在方法区中；而非静态成员变量需要作用于整个类，因此和对象一样是存储在堆中的。

12、java中对象的三大特性分析

答：封装、继承与多态；

（1）说一下继承的两个知识点：

1）3个类A、B、C，其中C继承于B，B继承于A，且A中有一个公有函数test，那么B也就继承了test，同时C也继承了test；

2）super关键字表示访问父类，如super.show()表示调用自身父类的show()方法；

（2）多态性：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）

作用：消除类型之间的耦合关系；

多态存在的三个必要条件：
一、要有继承；
二、要有重写；
三、父类引用指向子类对象。

上述三个条件也许不好理解，举个常用的例子解释一下：

结果：

解释：

①②：由于A中没有定义show(object B/C)，故根据继承关系和向上转型可用show(object A)，结果为A and A；

③：简单，不解释；

④：这个a2就是父类引用指向子类，也是向上转型（解释一下：此时a2的权限是可以使用自己本身的所有方法，但其中如果有

被子类重写的方法就只可以使用子类重写的，最重要的是不可以调用自己没有但子类有的方法），所以调用A.show(object A)，但此

方法在子类B中重写，那么结果就是使用B.show(object A)，结果为B and A。

⑤⑥：同上不解释；

⑦⑧：类似①②，不解释；

⑨：show(d)在B中本没有定义，但是B继承了A的所有方法，故结果为A and D。

Java中多态的实现方式：接口实现，继承父类进行方法重写，同一个类中进行方法重载。

13、instanceof运算符的作用

答：instance是java的二元运算符，用来判断他左边的对象是否为右面类（接口，抽象类，父类）的实例。

/***********************************java多线程章节*************************************/

1、线程生命周期介绍

答:线程生命周期分为：创建状态、就绪状态、运行状态、阻塞状态和死亡状态；

创建线程有两种方式：继承Thread类和应用Runnable接口；

阻塞状态：处于休眠、被挂起或者消息等待状态；

死亡状态：run线程运行结束或者调用System.exit()强制退出就进行入死亡状态。

2、java线程使用方式介绍

答：java多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现多线程，其中最后一种是带返回值的。

（1）继承Thread类实现多线程

先创建一个继承自Thread的类，并在类中重写run()方法，如下例子：

然后再合适的地方启动线程，如下：

（2）Runnable接口方式实现多线程
若自己的类已经extends另一个类，就无法直接extends Thread。此时须实现一个Runnable接口，并在类中实现run()方法，如下例子：

然后在合适地方实例化自己的类对象和一个Thread对象，并将自己的目标实例传入Thread对象，开启线程，如下：

（3） 用ExecutorService、Callable、Future实现有返回结果的多线程

答：这是一类有返回值的线程实现，这里不讲解了。详细内容见链接：http://blog.csdn.net/aboy123/article/details/38307539#

3、线程的同步

作用：在使用多线程操作共享资源时，由于可能出现一个线程正在被读取，另一个线程则在修改该数据，从而导致不可预料的结果。因此，我们在用

多线程操作共享数据时，常使用同步线程。

实现同步线程：我们常用synchronized关键字修饰操作共享资源的方法或者直接修饰run()方法，这样当一个线程进入到这个被修饰的方法时，synchronized就会锁定该方法直到该线程把方法运行结束再解锁。被锁定后，其他线程访问该方法时就会被监视器(Monitor)挂起处于等待状态。

注：

处于等待状态的线程是依次排队的，先进先出；

线程同步用到互斥锁机制；

举例如下：

wait()和notify()方法：

在Java的多线程应用中，方法wait()和notify()用于将某个线程置于等待状态或是唤醒某个线程。但是使用这两个方法时，一定要保证用到wait()的同时一定要用notify()，否则会出现永久等待的线程。

4、异常处理

定义：Java中把异常分为错误（error）和异常情况（Exception）两大类。

/***********************************java输入/输出流章节*************************************/

1、流的概念是什么？

答：流是数据从一种设备流向另一种设备的过程，分为输入流和输出流。

2、java数据流的概念是什么？

答：java中用java.io包提供输入输出流所需的各种类，主要包括4个基本类：InputStream、OutputStream及Reader、Writer类，其中InputStream和OutputStream用于处理字节流，Reader和Writer处理字符流。具体详

细分类如下图：

3、java中的文件流介绍

答：主要包括4个类：FileOutputStream、FileInputStream、FileReader及FileWriter。

4、java中的对象流与对象序列化是什么？

答：

定义：

对象序列化是指把Java对象转换为字节序列的过程。同理也有，反序列化是把字节序列恢复为Java对象的过程。

用途：

1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；

2） 在网络上传送对象的字节序列。

序列化API：

java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。只有实现了Serializable和Externalizable接口的类的对象才能被序列化。java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。

序列化内容：

每个 serializable 对象的类都被编码，编码内容包括类名和类签名、对象的字段值和数组值，以及从初始对象中引用的其他所有对象的闭包。

对象的 默认序列化 机制写入的内容是：对象的类，类签名，以及 非瞬态 和 非静态字段 的值。

java类中常见的serialVersionUID作用： 

序列化时为了保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。有两种生成方式：一个是默认的1L，比如：private static final long serialVersionUID = 1L;一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：private static final   long   serialVersionUID = xxxxL;

注意事项：

1）、使用transient修饰的变量不会被序列化；