JAVA面试题

1：什么是注释?注释分为几种?注释有什么作用?

注释就是对代码的解释说明性文字，分为三种：单行注释、多行注释、文档注释。注释可以对程序进行说明，给人看，还可以对程序进行排错。

2：什么是关键字?有什么特点?

关键字就是被java语言赋予了特殊含义的单词。特点就是所有的关键字都是小写。

3：什么是标识符?由哪些部分组成?常见的命名规则有哪些?

标识符就是给类、接口、方法、变量名起的名字。常见的规则有：有数字、字母、_以及$符号组成，不能以数字开头，不能是java中的关键字。

4：什么是常量?常量的分类?字面值常量表现形式有哪些?

在程序的运行过程中其值不发生改变的量。

字面值常量： 1 14

自定义常量： int MAX= 100;

5：什么是变量?变量的定义格式?要使用变量需要注意什么?

在程序运行过程中，其值是可以在某个范围内发生改变的量。

变量其实就是内存中一小块区域。

由3部分组成：

1，数据类型: 限定变量的取值

2，变量名：方便使用。

3，值：如果没有值就没有意义。

6：Java中的数据类型分几类?基本数据类型有哪些?

基本类型：4类8种。基本数据类型有：

整数(byte,short,int,long)、浮点数(float,double)、字符(char)、布尔(boolean)。

7：算术运算有哪些，各自的作用?

有：+，-，*，/，%，++，--。

+:正号,加法,字符串连接符

%:取得余数

++,--:

单独使用：在操作数据的前后效果一致。

参与操作使用：

在操作数据的前面，是先++或者--，然后参与操作。

在操作数据的后面，是先参与操作，后++或者--。

8：+运算符需要注意的问题?

当把+号作为加法和字符串连接符一起使用的时候，注意把运算的地方（）起来。

9：赋值运算符常见的有哪些，各自的作用?

=:把右边的内容赋值给左边

+=,-=,*=,/=,%=：把左边的和右边的操作后赋值给左边。

注意：

+=隐含了强制类型转换。

x+=y;等价与：x = (x的数据类型)(x + y);

10：逻辑运算符有哪些都有什么作用？

&:有false则false

|:有true则true

^:相同为false，不同为true。通过情侣关系来理解。

!:非false则true,非true则false。偶数次不改变以前的真假。

&&:和&的结果一样,但是具有短路效果。左边有false,右边不执行。

||:和|的结果一样,但是具有短路效果。左边有true,右边不执行。

11：位移运算符有什么不同？

要想操作，就必须把所有的数据转换为二进制。然后操作。

<<:把数据向左移动，后边补0。其实相当与乘以2的移动位数次幂。

>>:把数据向右移动，左边补是最高位的值。其实相当与除以2的移动位数次幂。

>>>:把数据向右移动，左边补0。其实相当于除以2的移动位数次幂。

12：什么是函数重载？

函数名相同，参数列表不同，跟返回值不关，就是函数重载。

13：类是什么?类的组成是哪些?

类是抽取了同类对象的共同属性和行为形成的对象或实体的"模版".

类是由成员变量,成员方法,构造函数组成

14：对象是什么?什么时候需要使用对象?

对象是现实世界中实体的描述,是其自身所具有的状态特征及可以对这些状态施加的操作结合在一起所

构成的独立实体.

需要描绘具体事物的时候要使用对象.

15：封装是什么?自己概述

隐藏对象的属性和具体的实现细节,仅对外提供公共的访问方式.

类、方法其实也是封装的体现。

16：继承是什么?自己概述

概念:把多个类中相同的内容抽取出来,单独定义到一个类(父类)中,再定义其他类(子类)的时候,继承父类即可.

好处:1.提高了代码的复用性,降低了代码的重复率.2.让类与类之间产生了关系,是多态的前提.

17：匿名对象是什么?应用场景是什么?

匿名对象就是没有名字的对象，由于没有指向，所以效率较高一些。

应用场景：A：调用方法。但是仅仅只限调用一次而已。B：匿名对象用作实际参数传递。

18：构造方法的作用是什么?构造方法的特点是什么?构造方法的注意事项是什么?

构造方法的作用是初始化数据。特点是：名称和类名一致，并且没有返回值类型的修饰和返回值。

注意：如果我们没有给构造方法，系统将给出一个无参构造方法。如果我们给出了构造方法，系统将不再提供构造方法。

19：给成员变量赋值有几种方式?

1，通过set/get方法。

2，通过带参构造。

20：方法重写和方法重载的区别?重载可以改变返回值类型吗?（*面试题）

方法重写：

子类中出现和父类中一模一样的方法声明的方法。

方法重载：

同一个类中，出现方法名相同，参数列表不同的方法。

跟返回值无关。

重载可以改变返回值类型，因为他跟返回值无关。

21：static关键字是什么?有什么特点?什么时候用呢?

static关键字：是静态的意思，可以修饰类中成员变量和成员方法。

静态的特点：随着类的加载而加载、优先与对象而存在、被所有对象所共享、可以通过类名.静态的内容调用。

22：this和super的区别,以及应用场景? (*面试题)

this:当前类的引用对象。谁调用代表谁。

super:父类的存储空间标识。可以理解为父类对象，谁调用代表谁父亲。

应用场景：

A:成员变量

this.成员变量 本类的成员变量

super.成员变量 父类的成员变量

B:构造方法

this(...) 本类的构造方法

super(...) 父类的构造方法

C:成员方法

this.成员方法() 本类的成员方法

super.成员方法() 父类的成员方法

23：代码块是什么?代码块的分类有哪些及每种代码块的作用是什么?

用{}括起来的代码，就叫代码快。

分为：

A：局部代码快： 就是在方法中用{}括起来的代码。作用是限定变量的生命周期，提高效率。

B：构造代码快：在类中，方法外。用{}括起来的代码。作用是把所有构造方法中相同的内容抽取出来，

定义到构造代码块中，将来在调用构造方法的时候，会去自动调用构造代码块。构造代码快优先于构造方法。

C：静态代码快：在类中、方法外。用{}括起来的代码。只不过加了staric修饰。

作用是：在整个系统中，只加载一次的代码。一般做整个系统的初始化。

24：一个类的实例化过程有哪些步骤？（*面试题）

Students = new Student(); 在内存中到底执行了哪些步骤。

1，加载Sutdent.class文件进内存(类加载器)

2，在栈内存为 s 变量申请一个空间

3，在堆内存为Student对象申请空间

4，对类中的成员变量进行默认初始化

5，对类中的成员变量进行显示初始化

6，有构造代码块就先执行构造代码块，如果没有，则省略

7，执行构造方法，通过构造方法对对对象数据进行初始化

8，堆内存中的数据初始化完毕，把内存值复制给 s 变量

26：继承是什么?继承的好处是什么?Java中的继承特点是什么?

继承就是：把多个类中相同的内容提取出来，定义到一个类中。

然后让这多个类和这个类产生一个关系，这多个类就具备该类的数据了。

这种关系叫：继承。

继承的好处是：提高代码的复用性，让类与类之间产生了一个关系，是多态的前提。

继承的特点是：Java中类只能够单继承，但是可以多层继承。

27：方法重写和重载有什么区别?重载可以改变返回值类型吗？（*面试题）

方法重写：子类中出现和父类一模一样的方法声明的方法。

方法重载：同一个类中，出现的方法名相同，参数列表不同的方法。

重载可以改变返回值类性，因为跟返回值无关。

28：子父类中构造方法的执行有什么特点?为什么要这样?

子类构造方法的执行，首先会去执行父类的构造方法。

因为子类中可能直接访问了父类的数据，父类的数据要优先于子类的数据进行初始化。

29：静态代码块，构造代码块，构造方法的执行顺序是什么?

静态代码块 -- 构造代码块 -- 构造方法

30：final关键字是什么，可以修饰什么，有什么特点?

final关键字：是最终意思，可以修饰类、方法、变量。

修饰类：类不可以被继承。

修饰方法：方法不可别重写

修饰变量：变量为常量。

31：多态是什么，前提是什么?

多态：对象在不同时刻表现出来的多种状态。是一种编译时期状态和运行时期状态不一致的现象。

成员变量：编译看左边，运行看左边。

成员方法：编译看左边，运行看右边。因为，普通成员方法可以重写，变量不可以。

静态方法：编译看左边，运行看左边。

前提：类与类之间要有继承关系。要有方法的重写。父类引用指向子类对象。

32：多态的好处及弊端？如何解决多态的弊端。

好处：提高了程序的可维护性(前提要有继承保证)，和扩展性。

弊端：不能使用子类的特有功能。

33：什么是抽象类？抽象类的特点和好处是什么?

相同的方法，有相同方法的声明，但是方法体不一样，只抽取方法声明的方法，叫做抽象方法，有抽象方法的类，叫做抽象类

特点：

A：类或者方法必须用abstract修饰。

B：具体类在继承抽象类的时候，要么本身也是抽象类，要么实现抽象类中的所有抽象方法。

C：抽象类不能被实例化。要想使用，必须按照多态的方式使用。

D：成员特点:

a：成员变量

可以是变量，也可以是常量。

b：构造方法

有构造方法，但是不能实例化。

用于子类访问父类数据的初始化。

c：成员方法

可以有抽象方法也可以有非抽象方法。

好处：

A：限定子类必须实现某些功能。

B：提高代码的复用性。

抽象类的几个问题：

A:抽象类不能实例化，构造方法有什么用。

用于子类访问父类数据的初始化。

B:抽象类没有抽象方法，有什么意义？

限制创建对象。

C:abstract不能和哪些关键字共存?

final: 冲突

private: 冲突

static: 无意义

34：什么是接口? 接口的特点?

如果一个抽象类中的方法全部是抽象方法，那么java就针对这种类型的抽象类，给出了一个更抽象的表达式：接口。

特点：

A：所有的方法，都是抽象方法。

B：类实现接口

要么本身是抽象类，要么重写接口中的抽象方法。

C：接口不能被实例化，要想使用，用多态。

D：成员特点

a:成员变量

只有常量，并且是静态常量。默认修饰符：publci staticfinal

b:构造方法

没有构造方法，子类数据的初始化默认走的是Ojbect类的构造方法

c:成员方法

全部是抽象的，有默认修饰符：public abstract

35：抽象类和接口的区别? （*面试题）

A：成员区别

抽象类：

成员变量:可以是变量，也可以是常量。

构造方法:有。

成员方法:有，可以是抽象的，也可以是非抽象的。

接口：

成员变量:只能是常量。默认修饰符：publcistatic final

构造方法:没有，子类数据的初始化默认走的是Ojbect类的构造方法。

成员方法:只能是抽象的，默认修饰符是:publciabstract

B：类与接口的关系区别

类与类：

继承关系，单继承。

类与接口：

实现关系，单实现、多实现。

接口与接口：

继承关系，单继承、多继承。

C：设计理念的区别

抽象类被继承体现的是：is a的关系。抽象类中一般定义的是整个继承结构的共性功能。

接口被实现体现的是：like a的关系。接口中一般定义的是整个继承结构的扩展功能。

36，什么是内部类？有什么特点？

把类定义在其他类的内部，就被称为内部类。

内部类的访问特点：

A：内部类可以直接访问外部类的成员，包括私有。

B：外部类要访问内部类的成员，必须创建对象。

37，为什么内部类访问局部变量必须加final修饰？(*面试题)

A:防止在使用后数据发生改变。

B:延长变量的生命周期。

38，什么是匿名内部类？本质是什么？

匿名内部类就是没有名字的内部类。

格式：

new类名或者接口名() {

重写方法;

};

本质：是继承类或者实现接口的子类匿名对象。

39，==和equals()的区别? (*面试题)

A:==

a:基本类型比较的是基本类型的值

b:引用类型比较的是引用类型的地址值

B:equals()

只能比较引用类型。

默认比较地址值。

40，什么是字符串？字符串的特点是什么？

字符串：由多个字符组成的一串数据。

特点：一旦被赋值就不能被改变。（*面试题）

注意：这里指的是字符串的内容不能发生改变。而字符串的引用是可以再次赋值的。

41：String s1 = new String("hello");和String s2 = "hello";的区别？（*面试题）

有区别，区别是：前者创建了两个对象，后者创建了一个对象。

42：String、StringBuffer、StringBuilder的区别？（*面试题）

String:字符长度是固定的。

StringBuffer/StringBuilder:字符长度是可变的。

StringBuffer:安全的，但效率较低一些。

StringBuilder:不安全的，但效率较高一些。

StringBuffer和StringBuilder兼容。

43：什么是基本数据包装类？

为了对基本类型的数据进行更多的操作的，java就针对每种基本类型的数据提供了对应的包装类类型。

对应的类型

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

44：什么是正则表达式？

正则表达式就是符合一定规则的字符串。

45：集合和数组有什么区别？（*面试题）

集合:

长度可以发生改变。

只能存储对象类型，引用类型。

可以存储任意类型的对象。

数组:

长度固定。

可以存储基本类 型，也可以存储对象类型。

只能存储同一种类型的元素。

46：集合有多少种？各自的特点是什么？

Collection

|--List有序(存入和取出的顺序一致)，元素可重复

|--ArrayList

底层数据结构是数组，查询快，增删慢。

线程不安全，效率高。

|--Vector

底层数据结构是数组，查询快，增删慢。

线程安全，效率低。

|--LinkedList

底层数据结构是链表，查询慢，增删快。

线程不安全，效率高。

|--Set无序的 元素唯一

|--HashSet

|--TreeSet

47：泛型是什么?有什么用?在哪里用?泛型有什么好处和弊端？

泛型是一种把明确数据类型的工作推迟到创建对象或者调用方法的时时候才去明确的特殊的数据类型。

能优化程序设计，解决了黄色警告线问题。

把运行时期的异常提前到了编译时间。

避免了强制类型转换。

好处：

优化了程序的设计，解决了黄色警告线的问题。

把运行时期的问题提前到了编译时期间解决了。

避免了强制类型转换。

弊端：让类型统一了，不能存储不同的数据类型了。

48：用迭代器遍历集合的时候，用集合修改集合有没有问题？如果有，怎么解决？（*面试题）

有问题，因为会出现并发修改异常。

解决方法有多种，比如，我们可以不通过集合来修改集合，而使用迭代器来修改集合。

像ListIterator迭代器就有添加方法。

49、HashSet如何保证元素唯一性的呢?

底层数据结构是哈希表(散列表)。具体的是由一个元素是单向链表的数组组成。

它依赖于两个方法：hashCode()和equals()方法。

执行顺序：

先判断hashCode()是否相同，

如果相同

继承执行equals()方法，看其返回值：

true:元素重复，不存储。

false:元素不重复，存储。

如果不同

存储。

记住：

看到HashXxx结构的集合，就要知道，被该集合存储的元素要重写hashCode()和equals()方法。

而且，是自动生成的。

50、TreeSet底层数据结构是什么？如何保证元素的唯一性的呢?

底层数据结构是二叉树。

根据比较的返回值是否是0来决定。

如何保证元素的排序的呢?

A:自然排序元素具备比较性

让集合中被存储的元素所属的类实现Comparable接口。

B:比较器排序集合具备比较性

在创建集合对象的时候，让构造方法接收一个Comparator接口的子类对象。

51、LinkedHashSet底层数据结构是什么？如何保证元素的唯一性的呢?

底层由链表和哈希表组成。

由链表保证有序。

由哈希表保证唯一。

52、什么是可变参数？

针对在写一个方法的时候，不知道具体要有多少个形式参数的时候。

java提供了可变参数的用法。

注意：

A:变量其实是该数据类型的一个数组。

B:形式参数如果有多个的话，可变参数只能是最后一个。

C:数据类型要一致。

53、Map和Collection集合的区别？(*面试题)

A:Map集合存储的是键值对形式的元素。

Collection集合存储的是单个的元素。

B:Map集合的键是唯一的。

Collection的儿子Set集合元素是唯一的。

C:Map集合的值是可以重复的。

Collection的儿子List集合的元素是可以重复的。

54、Hashtable和HashMap的区别?(面试题)

A:HashMap线程不安全，效率高。允许null键和null值。

B:Hashtable线程安全，效率低。不允许null键和null值。

55、Collection和Collections有什么区别？

Collection:是集合的顶层接口，定义了集合的通用方法。

Collections:是一个工具类，里面定义了对集合进行操作的一些常见方法。

56、什么是异常？异常有哪几种？各有什么特点？

程序出现了不正常的情况，就是异常。

异常的继承体系结构：

Throwable

|--Error 严重的问题，一般我们解决不了。

|--Exception

|--RuntimeException 运行时期异常，这种问题一般要修正代码。

|--非RuntimeException 编译时期异常，必须进行处理，否则代码不能够通过。

57、throws和throw的区别? （*面试题）

throws

位置：在方法()后面，跟的是类名。

如果后面根据的是RuntimeException及其子类，那么，该方法可以不用处理。

如果后面根据的是Exception及其子类，那么，必须要编写代码进行处理，或者调用的时候抛出。

throw

位置：在方法中，跟的对象名称。

如果方法中，有throw抛出RuntimeException及其子类，那么，声明上可以没有throws。

如果方法中，有throw抛出Exception及其子类，那么，声明上必须有throws。

58、final、finally、finalize的区别？（*面试题）

final：是最终的意思，用于修饰类、变量、和方法。修饰类的时候，类是最终类，不可以被继承。修饰变量的时候，变量为常量，不可以被改变。修饰方法的时候，方法不能被重写。

finally:是异常处理的一部分，它里面的代码永远会执行(前提:jvm没退出)，一般用于释放资源。

finalize:是object类的一个方法，用于垃圾处理

59、什么是递归？使用递归需要注意哪些？

递归就是方法定义中调用方法本身的现象。

A:递归一定要有出口，否则就是死递归。

B:递归的次数不能太多，否则内存溢出。

C:构造方法不能递归使用。

60、基本的IO流有哪些？(*面试题)

字节流：InputStream、OutputStream、FileInputStream、FileOutputStream、

字符流：Writer、Reader、FileWriter、FileReader、

高效字节流：BufferedInputStream、BufferedOutputStream

高效字符流：BufferedWriter、BufferedReader

最开始的时候，只有字节流，但是后来由于中文字符或者其他字符的出现，用两个字节才能表示。

如果用字节流也是可以读写字符文件的数据的，但是比较麻烦。为了简化这种操作，就提供了字符流。

61、flush()和close()的区别？(*面试题）

flush():刷新缓冲区，流对象还可以继续使用。

close():释放流资源，但是会先刷新一次缓冲区，操作完毕后，流对象不可以再使用。

62、什么是多线程？进程和线程的区别是什么？

多线程就是应用程序的多条执行路径。

进程：正在运行的应用程序，每个进程的具备独立的运行空间。

线程：是进程的执行单元，执行路径。如果是多个线程，那么，这多个线程共享同一个进程资源。

63、启动线程调用的是run()还是start()方法？run()和start()的区别是什么？（*面试题）

启动线程调用的是start()

run()封装了被线程执行的代码，start()是启动线程并调用run()方法。

64、多线程有几种实现方案？分别是什么？如何操作？（*面试题）

多线程有两种实现，分别是：

1，继承Thread类

自定义类继承Thread类，在类中重写run()方法，测试类中创建自定义类对象，并调用start()方法

2，实现Runnable接口

自定义类实现Runnable接口，重写run(）方法，测试类中创建自定义对象，

创建Thread对象，把自定义对象作为构造参数传递。调用Thread类的start()方法。

65、线程的生命周期？（*面试题）

新建： 创建线程对象

就绪： 具备cup执行资格，没有执行权，随时准备执行

运行： 具备执行资格，执行权，执行run()中的代码

堵塞： 是当线程运行到符合某个我们定义的条件时，它会停止下来等待唤醒

死亡： run()结束了

66、多线程为什么会出现安全问题？怎么解决呢？（*面试题）

如果满足以下条件，那么就会出现安全问题：

A：是多线程程序。

B：有共享的数据。

C：针对共享数据有多条语句操作。

只要我们把多线程环境中，把操作共享数据的操作，变成单线程就没有问题了。

Java针对这种情况，就提供了同步技术：

A：同步代码块

B：同步方法

C：JDK5以后的Lock锁

67、同步的锁对象分别是？（*面试题）

代码块：任意对象

方法：this

静态方法：类名.class

68、sleep()和wait()的区别？（*面试题）

sleep():必须指定时间，不释放锁对象。

wait():可以指定时间，也可以不指定。释放锁对象。

69、线程死锁是什么，为什么有死锁，怎么解决死锁？（*面试题)

为了解决程序因占用资源，出现资源争抢，而出现的程序进入等待的状态（死锁）。

举例：有A和B两个线程，有CD 两把锁， A和B嵌套CD锁，A线程中有C，D锁，B线程中有D C两把锁，当两个线程运行时，就可能会出现死锁导致

程序停滞的情况。

怎么解决：真正意义上来说，死锁是不能被解决的，死锁是多线程中的一个需要避免的重大的问题，当我们在编写程序时，可以给共享的资源加上另外一个把锁，控制资源的动态，同时可以设置线程的优先级使线程之间协调合理的利用CPU的时间。

70、线程间的通信是什么？

不同种类的线程针对同一个资源的操作。

71、什么是网络编程？

用编程语言来实现计算机的资源共享和信息传递，就叫做网络编程。

72、网络通信三要素是什么？（*面试题）

A:IP地址

计算机在网络中的唯一标识。

现在使用的是："点分十进制"

B:端口

应用程序的的标记。

C:协议

通信的规则。

73、UDP和TCP的区别？ （*面试题）

UDP:不建立连接，数据打包传输，数据有限制，数据不可靠，速度快。

TCP:建立连接，数据无限制，数据可靠，速度慢。

74、反射是什么？反射获取字节码文件的三种方式？反射的好处？（*面试题）

在运行状态下，通过class文件对象（Class的对象），去使用构造方法，成员变量，成员方法。就是反射。

3种方法：

A.用Object类的getClass方法得到。

B.用任意数据类型的静态class属性可以得到

C.用Class类的静态方法forName（String className）方法得到

好处：只要有一个类或者一个类的对象，就可以得到这个类或对象的所有属性和方法。包括私有的。

treeset的实现原理

集合的体系以及各子类的特点，多线程的两种创建方式，7k中用到的多线程的创建方式（Executors）什么是反射，字节码的三种获取方式，动态代理，单例的饿汉式和懒汉式，synchronized在单例中哪里用到了，什么是同步，为什么需要用同步，sleep和notify的区别.

多态的理解

if和 switch 怎么用

重载和重写怎么区分

JDK1.5新特性，可变参数带来什么好处，什么是自动装箱拆箱？

线程间怎么通信？线程池的理解？后面这个我不懂直接说7K里面那两个

多线程的两种创建方式

同步是什么？同步方式？什么是死锁

都学到了哪些设计模式，我说单例，装饰、享元，工厂，要说怎么理解装饰？

集合框架的理解

IO流的都有哪些

反射是什么？怎么用

动态代理的理解

编程

1.map集合添加元素，遍历，然后实现替换其中某个元素（紧张得把map的泛型写成collection的单列），替换了老半天，不懂怎么把键和值都替换，其实只能替换值，我又在那死脑筋，老师又叫我写个单列的替换，这题马虎算过

2.拷贝多级文件夹，第一题卡好久这题都没想就打印文件和文件夹，题意是想要文件夹名称，然后存进文本里，咦这题没过。（50分钟结束）

1.面向对象的理解。

2.面向对象与面向过程的区别。

3.abstract与哪些关键字不能共存，并且说明原因。

4.static，final修饰成员（变量，函数）的特点。

5.类与类，类与接口，接口与接口的关系。

6.final，finally，finalize的区别。

7.什么是多态，多态的好处和弊端。

8.wait()和sleep()的区别。

9.网络编程的三要素。

10.TCP和UDP的区别。

11.什么是暴力反射。

①函数的重载：传入不同的参数执行不同的操作。

②排序的方式：怎么也得记住一种的。

③对字符串的操作要熟练：lastIndexOf(),contains(CharSequences),StringBuffer的reverse()等等吧。

④递归！在一面中我做的用递归的那道题有点难，，，当时没想出来，，回来百度看了些才会的。

⑤多线程的两种实现方方式，线程间的通信。

⑥对集合的基本操作（重点记常用的ArrayList和TreeMap）：添加，删除，遍历等。

⑦IO部分：通过指定的目录获取满足条件的文件（字符流文件或字节流）并且高效的复制放入指定的目录。也就是要熟悉流的操作规律。

⑧单例设计模式的两种实现。

1,说一下堆和栈的区别?

栈的内存空间是由系统自动分配的。例如int a；系统就自动在栈里开辟个空间给a使用。

它存取速度比堆要快，而且栈里面的数据可以共享，存放的数据是一些基本类型的数据，特点是存放在栈里的数据被调用完立马消失。

堆的内存空间是由程序员自己申请（new）出来的。

堆内存主要用来存储引用类型，特点是堆里面的数据被调用完毕后不会马上消失，而是在某个不确定的时间后被垃圾回收器清理掉。

2，TreeSet的排序方式有几种，详细描述？

A.自然顺序

让对象所属的类去实现comparable接口，然后重写这个接口的comparto方法进行比较，根据这个比较的结果去进行排序。

B.比较器接口，comparator接口

在创建对象时使用带参构造传一个实现比较器接口的匿名内部类并重写它的方法就可以进行比较了。

3，线程生命周期,是怎么样的？

新建，就绪，运行，堵塞，死亡

新建是创建线程。

就绪是获得执行资格但是没有执行权。

运行不解释。

堵塞，就是当线程运行到符合某个我们定义的条件时，它会停止下来等待唤醒

死亡就是线程结束了。

4，线程死锁是什么，为什么有死锁，怎么解决死锁？

为了解决程序因占用资源，出现资源争抢，而出现的程序进入等待的状态（死锁）。

举例：有A和B两个线程，有CD 两把锁， A和B嵌套CD锁，A线程中有C，D锁，B线程中有D C两把锁，当两个线程运行时，就可能会出现死锁导致

程序停滞的情况。

怎么解决：真正意义上来说，死锁是不能被解决的，死锁是多线程中的一个需要避免的重大的问题，当我们在编写程序时，可以给共享的资源加上另外一

个把锁，控制资源的动态，同时可以设置线程的优先级使线程之间协调合理的利用CPU的时间。

5，类和对象是什么？

类是对某种事物的抽象统称，例如学生，是一个群体，他们有着共同的特征。

对象是类的实例，例如说在学生这个类里面有一个叫做小明的学生，他有着具体的特点，这个时候就把他叫做是这个学生类的对象。

6，集合包括哪些类？

list--|ArrayList

|Vector

|LinkedList

Set -| TreeSet

| HashSet

Map - |HashMap

|Hashtable

|Properties

|TreeMap

7,java有多继承吗？

有，接口可以多继承，因为接口只是一个功能的拓展，他多继承只是让本身具备更多的功能而已，而多继承之所以会出错的原因，比如说一个普

通类继承了多个类的时候，如果这多个类有些相同的方法时，这个类就不知道要去继承哪一个类的方法。而接口就没有这种错误，因为如果接口去继承其

他多个接口的话，哪怕其他接口有一些相同的方法，又因为接口中的方法都是抽象的没有方法体，所以在继承时也只会保留下来一个。

8、你是怎么理解面向对象的

他有3个特点：更符合思考习惯，让程序员从执行者变成指挥者，把复杂的事情简单化。

我是这样理解的，比如说我要得到某种结果或者完成某件事情的时候，我并不需要自己亲自的完成这一系列的过程，只需要找到能够帮助我完成

需求的工具就可以很高效的达成目标了，我觉得这个过程就叫面向对象。

9、接口跟抽象类的区别

成员特点 抽象类中可以有成员变量跟成员常量，有构造方法，除了抽象方法外也可以有非抽象方法。

接口中只有常量，默认修饰符是public static final，接口中只有抽象方法默认修饰符是public abstract。

关系特点 类跟类之间只能单继承跟多重继承。

类跟接口可以单实现、多实现，也可以在继承一个类的时候再实现一个或者多个接口。

接口跟接口可以单继承也可以多继承。

设计理念 继承体现的关系是is a 代表子类就是父类的一个延伸，就是说有地方用到父类的时候完全可以用子类替代。

接口体现的关系是like a 它定义的是整个体系的扩展内容。

10、说说你对异常的理解

异常就是在程序编译或者运行的时候会出现的一些错误，比如说我要往一个指定的文件写入数据，但是这个时候虚拟机又不敢确定在硬盘里有没

有这个文件，所以为了避免发生错误，就需要我们来指定当出现这种情况时虚拟机要做出什么动作。例如抛出异常让虚拟机处理，或者我们用try、catch

处理。

11、list跟set的区别

list是元素有序，并且可重复的。

这个有序说的是存放数据时的顺序是怎么样的那我们将来取出元素调用的时候就是怎么样的，而且多个相同的元素并不会影响储存。

set是元素无序，并且唯一的。

无序说的是我们在取出元素时不是按照我们当初存的顺序出来的，比如说我打印这些元素会发现每次打印，元素的位置都不一样。

但是通过实现comparable或者实现comparator接口也可以给元素排序。

12、基本的io流有哪些

字符流两种：FileWriter、FileReader

字节流两种：FileOutputStream、FileInputStream

高效字符流两种：BufferedWriter、BufferedReader

高效字节流两种：BufferedOutputStream、BufferedInputStream

打印流：printWriter、printReader

转换流：InputStreamReader、OutputStreamWriter

标准输入输出流：System.in、System.out

序列化流：ObjectInputStream、ObjectOutputStream

13、反射是什么？反射获取字节码文件的三种方式？反射的好处？

在运行状态下，通过class文件对象（Class的对象），去使用构造方法，成员变量，成员方法。就是反射。

3种方法：

A.用Object类的getClass方法得到。

B.用任意数据类型的静态class属性可以得到

C.用Class类的静态方法forName（String className）方法得到

好处：只要有一个类或者一个类的对象，就可以得到这个类或对象的所有属性和方法。包括私有的。

14、单例的两种模式

（这个我还没有透彻理解所以只给模式名）

饿汉式

懒汉式

16、内部类

（这个也是了解不深）

成员内部类，他是在class中又直接定义一个class

局部内部类，在方法中定义一个class

匿名内部类，他是没有名字的内部类，我用的最多的地方是在创建对象要带参的时候用到他。他是一次性的用完就不能用了。

17、map的特点，怎样获取键值

把数据按照键跟值的特点存储在集合里，使用的时候可以通过键得到值，键是唯一的，值却可以重复。

有个方法keySet可以得到集合里的键，有了键再遍历就可以获取值。

18、static的作用？

1.被static修饰的成员是被所有对象共享的。

2.随着类的加载而加载。

3.优先于对象存在。

4.可以直接被类名调用。

19、接口和抽象类的区别

1.接口里面都是抽象方法，只有常量；抽象类里面不一定都是抽象方法，可以有成员变量也可以有常量

2.接口是功能的扩展；而抽象类是抽取子类的共性功能，强制子类必须按照抽象类方法重写。

20、ArrayLIst和LinkedList的区别？为什么ArrayList查询快

ArrayList底层是数组结构，特点是查询快增删慢；LinkedList底层是链表结构，特点是增删块查询慢。

因为ArrayList底层是数组结构，通过数组的索引值我们就可以做到快速查询！

22、字节流和字符流的区别

字符流的底层是字节流，最早的时候只有字节流，后来为了能够支持文字所以开发出了字符流，字符流能更高效的处理文本数据；

同时如果要处理的是文本数据的话就可以用字符流，但如果要处理多媒体文件的时候就只能使用字节流。

因为java使用的编码是unicode编码，一个字符等于两个字节。

23、多线程的两种实现方式，它们有什么区别

两种，

1.对象对应的类继承Thread类，这种可以直接调用start方法开启多线程。

2.对象对应的类实现Runnable接口，这种要重新new一个Thread对象把对象作为参数传进去才能调用start方法。

开发一般用第二种，他避免单继承的局限性。实现资源与线程的分离

24、对网络通信协议的理解

（忘了）

25、线程开启调用什么方法

如果对象对应的类继承的是Thread类的话那么用对象调用start方法就可以开启线程；

如果对象对应的类是实现Runnable接口的话，就必须把这个对象转化成Thread类再调用start方法。转换方式就是new一个Thread对象并把实现Runnable接口的类的对象作为参数传进去就可以了。

编程题：

1.复制某盘下所有（包括子目录）“.java”后缀的文件到另一目录下。

2.把D盘下的所有.java文件改成.txt后缀并复制到另一个目录下，或者把绝对路径储存在.txt文档里

3.定义一个学生类，属性有名字，语文分数，数学分数，英语分数。键盘录入5个学生跟分数，按照总分先排序再写进txt文档，要求在文档里要清晰明了查看这些数据。

面试的时候都考哪些知识？是否还要做题？

A：面试的时候问的都是你在基础班学习或是自学的基础知识。其中“io流、反射、多线程、集合框架”是必问的。之后还会在说一说其他的基础。像、接口、抽象类、设计模式等。

面试的时候是会做两个编程题，难易程度同基础测试。时间为30分钟左右。

AVA相关基础知识

1、面向对象的特征有哪些方面

1.抽象：

抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

2.继承：

继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

3.封装：

封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

4. 多态性：

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

2、String是最基本的数据类型吗?

基本数据类型包括byte、int、char、long、float、double、boolean和short。

java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类

3、int 和 Integer 有什么区别

Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。

原始类型封装类

booleanBoolean

charCharacter

byteByte

shortShort

intInteger

longLong

floatFloat

doubleDouble

引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。

4、String 和StringBuffer的区别

JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。

5、运行时异常与一般异常有何异同？

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

6、说出Servlet的生命周期，并说出Servlet和CGI的区别。

Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法（doGet，doPost）等，当服务器决定将实例销毁的时候调用其destroy方法。

与cgi的区别在于servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。

7、说出ArrayList,Vector, LinkedList的存储性能和特性

ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

8、EJB是基于哪些技术实现的？并说出SessionBean和EntityBean的区别，StatefulBean和StatelessBean的区别。

EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技术实现。

SessionBean在J2EE应用程序中被用来完成一些服务器端的业务操作，例如访问数据库、调用其他EJB组件。EntityBean被用来代表应用系统中用到的数据。

对于客户机，SessionBean是一种非持久性对象，它实现某些在服务器上运行的业务逻辑。

对于客户机，EntityBean是一种持久性对象，它代表一个存储在持久性存储器中的实体的对象视图，或是一个由现有企业应用程序实现的实体。

Session Bean 还可以再细分为 Stateful Session Bean 与 Stateless Session Bean ，这两种的 Session Bean都可以将系统逻辑放在 method之中执行，不同的是 StatefulSession Bean 可以记录呼叫者的状态，因此通常来说，一个使用者会有一个相对应的 Stateful Session Bean 的实体。StatelessSession Bean 虽然也是逻辑组件，但是他却不负责记录使用者状态，也就是说当使用者呼叫 Stateless
Session Bean 的时候，EJB Container并不会找寻特定的 Stateless Session Bean 的实体来执行这个 method。换言之，很可能数个使用者在执行某个 Stateless Session Bean 的 methods 时，会是同一个 Bean 的 Instance 在执行。从内存方面来看，Stateful Session Bean 与 Stateless Session Bean 比较， Stateful Session Bean 会消耗 J2EE Server 较多的内存，然而
StatefulSession Bean 的优势却在于他可以维持使用者的状态。

9、Collection 和 Collections的区别。

　　Collection是集合类的上级接口，继承与他的接口主要有Set 和List.

Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

10、&和&&的区别。

&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）。

11、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 就必须为之提供外同步（如果是ArrayList：List lst =Collections.synchronizedList(newArrayList());如果是HashMap：Map map = Collections.synchronizedMap(new HashMap());）。

Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

12、final, finally, finalize的区别。

　　final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

13、sleep() 和 wait() 有什么区别?

sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。

wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

请介绍一下集合框架

请介绍一下IO

请说一下进程和线程的区别

需要注意的是,每问一个大块的知识点,老师会追问(要命....)

拿集合举例,先问了**(屏蔽)**,然后我的**(屏蔽)**可能没说的很清楚,然后老师就问我,**(屏蔽)**...

然后让介绍了IO,然后问我**(屏蔽)**(我回答read和readLine)

然后问我**(屏蔽)**......(最后失败的原因之二.....)

设计一个方法,用于获取一个字符串中指定子串出现的次数。这道题的思路是怎样的？

会让你写两道编程题的，难度用基础测试相当。时间在40分钟左右。提问的技术点的话：io流、反射、多线程、集合框架。这个四个点必问。剩下的就是一些基础的知识，像接口、抽象类、内部类、静态方法等

final,finally,finalize的区别

final:修饰类的时候，类不能被继承修饰方法的时候方法不能被重写

修饰变量的时候变量是常量，只能被赋值一次

finally是try……catch的一部分，它后面的东西一定会执行，但是有种特殊情况就是它前面有system.exit(0)的时候就不会执行finally后面的语句

finalize是java中的垃圾回收器

1.java中的main方法是静态方法，即方法中的代码是存储在静态存储区的。

2.任何静态代码块都会在main方法之前执行。

3.java程序的初始化顺序:原则:静态优先于非静态，且只初始化一次；父类优先于子类；按照成员定义顺序初始化。

例顺序：父类静态变量，父类静态代码块，子类静态变量，子类静态代码块，父类非静态变量，父类非静态代码块，父类构造函数，子类非静态变量，子类非静态代码块，子类构造函数。

4.java中一个文件可以定义多个类，但只能有一个类被public修饰,且访问的类名与文件名必须相同，每一个类都会生成一个字节码文件。

5.构造函数的特点:1)名字必须与类名相同;2)构造函数不能被继承，不能被覆盖，但是可以被重载;3)子类可以通过super关键字来显示的调用父类的构造函数，但当父类没有提供无参的构造函数时，子类的构造函数必须显示的调用父类的构造函数。

6.java中的接口常量默认使用public static final修饰。

7.java在处理基本数据类型时，都是按照值传递，其他的都是按照引用传递。

8.clone方法，深复制和浅复制的区别:深复制把复制的对象所引用的对象都复制了一遍;浅赋值仅仅赋值所考虑的对象，不复制他所引用的对象。

9.三种获取类的方法:1)class.forName(); 2)类名.class; 3)实例.getClass()。

10.四种创建对象的方法:1)通过new实例化;2)通过反射机制;3)通过clone()创建;4)通过反序列化的方式创建对象。

11.当子类中定义的成员变量和父类中定义的成员变量相同时，子类成员变量会覆盖父类的成员变量，不会继承。

12.java提供两种用于多态的机制，编译时多态和运行时多态。编译时多态是通过方法重载实现的，运行时多态是通过方法覆盖实现的。

13.方法重载和方法覆盖:覆盖是子类和父类之间的关系，是垂直关系；重载是同一个类中方法之间的关系，是水平关系。覆盖要求参数列表相同，重载要求参数列表不同。

14.抽象类和接口的异同:1)abstract只能用来修饰类或者方法，不能用来修饰属性。2)抽象类表示的是一个实体，而接口表示的是一个概念。

3)只要包含一个抽象方法的类就必须被声明为抽象类 4)子类为父类中的所有抽象方法提供具体的实现，否则他们也是抽象类。

相同点:1)接口和抽象类都不能被实例化 2)接口的实现类或者抽象类的子类只有实现了他们之中的抽象方法后才能被实例化。

不同点:1)接口只有定义，其方法不能再接口中实现，只有实现接口的类才能实现接口中定义的方法，而抽象类可以有定义与实现，即方法可以在抽象类中被实现

2)接口需要实现implements 但抽象类需要被继承extends，一个类可以实现多个接口，但是一个类智能继承一个抽象类。

3)接口强调特定功能的实现，设计理念为has-a；抽象类强调所属关系，其设计理念为is-a

4)接口中定义的成员变量默认为public static final，只能够有静态的不能被修改的数据成员，而且必须为其赋初值，所有成员方法必须是public和abstract的。

抽象类可以有自己的数据成员，也可以有费抽象的方法，成员默认为default的，也可以被定义为private，protected和public的。

当功能需要被积累时，使用抽象类，不需要积累时，使用接口。

5)接口被用于实现比较常用的功能，便于日后的维护或者添加删除方法，抽象类更倾向于充当公共类的角色。

接口可以继承接口，抽象类可以实现抽象类，抽象类也可以继承具体类，抽象类也可以有静态类的main方法。

15.内部类:主要分为四种 静态内部类；成员内部类 ；局部内部类 ；匿名内部类

1)静态内部类不能与外部类有相同的名字，不能访问外部类的普通成员变量，只能访问外部类中的静态成员和静态方法；非静态内部类不能有静态成员。

2)局部内部类像局部变量一样，不能被public protect private以及static修饰

3)匿名内部类是一种没有类名的内部类，不能使用关键字class extends implements 没有构造函数，他必须继承其他类或者实现其他接口。

16.this与super:this指针指向当前实例对象，super可以用来访问父类的方法或者成员变量。

17.当子类的构造函数需要调用父类的构造函数时super()必须为构造函数中的第一条语句。

18.final，finally，finalize区别:

final:1)final用于声明属性，方法，类，表示不可变属性，方法不可覆盖，类不可被继承。(不可变有两层含义:引用不可变；对象不可变。final指的是引用的不可变)

2)final类，该类不能被继承，所有的方法不能被重写，但是属性可变。一个类不能既被声明为abstract又被声明为final。

finally:作为异常处理的一部分，跟在try/catch后并且附带一个语句块，表示这段语句最终一定会被执行。

finalize:是object类的一个方法，在垃圾回收器执行时会调用被用于回收对象的finalize方法。

19.assert:作为一种软件调试方法，住要作用是对一个boolean表达式进行检查

与C语言中的assert异同:java是assert是关键字，C语言中使用的是库函数,assert是编译时开启,而java语言则是在运行时开启。

20.static关键字:主要作用:为某种特定的数据类型或者对象分配单一的存储空间；实现某个方法或属性与类而不是与对象关联在一起。

1)静态成员变量:静态成员变量属于类不属于某个对象，在内存中指有一个复制，另外，java中不能在成员函数内部定义静态变量。

2)静态成员方法:静态方法属于类不属于某个对象，静态方法中不能使用this和super关键字。static关键字一个很重要的用途就是用来实现单例模式。(单例模式:隐藏构造函数，提供一个静态创建对象的方法)

3)静态代码块:不在任何一个方法体内且只执行一次。

21.switch语句:支持int 或者int的包装类Integer ,一些能隐式转化成int类型的例如shortbyte 和 char 还有他们的包装类也支持。另外Java7中开始支持String类型。

22.volatile:是一个类型修饰符，他是被设计用来修饰不同线程访问和修改的变量。系统每次用到它的时候会从对应的内存当中提取。

23.instanceof:是java语言中的一个二元算符，他的作用是判断一个引用类型的变量所指向的对象是否是一个类的实例。

24.java中存在八种基本数据类型:byte short int long float double char boolean(需要注意java中默认声明的小数是double类型的,所以float a=1.1是不合法的)

25.不可变类:所有基本类型的包装类都是不可变类(引用不可变)。

创建一个不可变类五个原则:

1)类中所有成员变量被private所修饰。

2)类中没有写或者修改成员变量的方法，只提供构造函数一次生成。

3)确保类中的所有方法不会被子类覆盖(利用final达到目的)。

4)如果一个类成员不是不可变类，那么在成员初始化或者使用get方法获取该成员变量时，需要通过clone方法来确保类的不可变性。

5)如果有必要覆盖Object的equals和hashCode方法。

26.值传递和引用传递:1)在方法调用中，实参会把它的值传递给形参，形参知识用实参的值初始化一个临时的存储单元，形参虽然与实参有相同的值却有着不同的存储单元。

2) 原始数据类型在传递参数时都是按照值传递，而包装类型都是按照引用类型在传递。

27.不同数据类型的转换:

自动转化。

1)char类型会转换为高级类型,会专函为其对相应的asc码。

2)byte char short类型参与运算时会自动转换为int类型。但当使用+=时就不会产生类型转换。

3)基本数据类型和boolean类型时不能相互转化的。

当需要高级数据类型转化为低级数据类型时就需要进行强制类型转换。

28.round ceil floor方法:round方法表示四舍五入,ceil方法表示向上取整，floor方法表示向下取整。

29.i++表示先使用i在给i自增，++i表示先给i自增，在使用i。

30.>>与>>>:>>在执行右移操作时，若参与的数字为正数，则在高位补零，若为负数，则在高位补1。>>>则不同，无论运算的数字为正数或负数，在执行运算时都会在高位补0。

1、面向对象的理解

面向对象是基于面向过程的。在开发过程中，要完成特定的功能就去找相应的对象，如果找不到就创建相应的对象，使用对象，维护完善对象。

2、面向对象和面向过程的区别

面向过程强调的是功能行为；

面向对象将功能封装成对象，强调的是具备功能的对象

3、abstract与哪些关键字不能共存为什么

private：私有的方法是不可见的，无法被复写

final：被final修饰的方法是最终方法，无法被复写

static：被static修饰的方法，要随类加载到方法区，由于抽象方法没有方法体所以不能加载

4、static的特点

随着类的加载而加载；优先于对象存在；被所有对象所共享；可以直接被类名所调用。

静态方法只能访问静态成员，非静态方法既可以访问静态也可访问非静态

静态方法中不可以定义this、super关键字，因为静态优先于对象存在，所以静态方法中不可以出现this；

5、类与类、类与接口、接口与接口的关系

继承，继承或实现，继承

6、final、finally、finalize的区别

final：可以修饰类、方法和变量，被final修饰的类无法被继承，方法无法被复写，变量为常量只能赋值一次

finally：异常处理trycatch时使用，可以添加也可以不添加，用于执行一些必须执行的代码，如关闭资源等

finalize：Object类中的方法，其中定义了对象要被垃圾收集器回收之前要做的相关的清理工作

7、什么是多态，多态的好处和弊端

多态可以理解为事物存在的多种体现形态。父类的引用指向了自己的子类对象；父类的引用也可以接收自己子类的对象。

好处：提高了代码的扩展性

弊端：父类的引用只能访问父类中有的成员(父类引用无法调用子类中特有的方法)

8、wait()和sleep()的区别

(1)wait是Object类中的方法，sleep是Thread类中的方法

(2)sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

(3)wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用

　 (4)sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

9、网络编程的三要素

(1)IP：网络中设备的标识

(2)端口：用于标识设备中接收数据的网络应用程序具体是哪一个，有效端口0~65535，0~1024为系统端口及保留端口

(3)传输协议：UDP和TCP协议，信息通讯的规则

10、UDP和TCP的区别

UDP：不需要建立连接，是不可靠协议，将数据及源和目的封装到数据报中，每个数据报限制在64k以内，发送数据较少，速度快

TCP：通过三次握手建立连接通路，是可靠协议，可进行大量的数据传输，效率较低

11、什么是暴力反射

我们知道java的特性之一就是封装，将对象的属性和具体实现隐藏起来，只对外提供公共方法访问，private修饰的内部属性和方法对我们是不可见的。

我们通过正常的方法是无法获取以及修改的，可是通过反射却可以强制获取并做一些修改，这就破坏了封装性，这就是所谓的暴力反射

12、反射获取字节码对象方式、创建对象的两种方式

获取字节码方式三种：

(1)类名.class，例如：System.class

(2)对象.getClass()，例如：new Date().getClass();

(3)Class.forName("类名")，例如：Class.forName("java.util.Date");

创建对象的两种方式：

(1)直接用字节码创建对象，只能调用默认的构造方法：字节码.newInstance();

(2)获取构造方法Constructor，然后调用构造方法创建，可以通过参数不同调用不同的构造方式

13、怎么理解反射，反射的应用

反射就是把Java类中的各种成分映射成相应的Java类。

一般情况下我们要解决某个问题，先找到相关的类，创建该类的对象，然后通过该对象调用对应的方法来解决问题。

反射是一个正好相反的过程，开始可能并没有类可以解决这个问题，而我们却先用一个当时可能并不存在的方法解决了这个问题，后来才有的这个类。

这其实就是框架的原理，现有的框架再有的解决问题的类。框架描述了整体，制订了功能方法的规范，具体的实现之后按照这个规范编写。这些都需要靠反射来完成。

使用框架有良好的扩展性，某部分功能的优化不需要涉及程序整体，只需要修改特定的部分就好了，然后通过配置文件，获取对应的类名，就可以了。

14、对匿名内部类的理解

匿名内部类其实是内部类的简写形式。

内部类是定义在类中的类，就好比我们人类，我们人类都有心脏，而心脏又有自己独特组成，可以把心脏也抽象成一个类。

这个心脏类就是人类的内部类。如果要研究某一种心脏疾病，需要一个实例时，我们不需要知道这个患病的心脏到底是谁的，那找到的这个就是匿名的。

匿名内部类必须要继承一个类或实现一个接口，在使用时直接父类或接口的名称创建了一个子类对象并实现其中的方法，匿名内部类其实是一个匿名的子类对象。

15、IO体系

字节流InputStream/OutputStream

|--FileInputStream/FileOutputStream：文件字节流，用于文件的读写操作

|--BufferedInputStream/BufferedOutputStream：加缓冲区的字节流，用于提高效率

字符流Reader/Writer

|--FileReader/FileWriter：文件字符流，用于文本文件的读写操作

|--BufferedReader/BufferedWrite：加缓冲区的字符流，用于提高效率

转换流InputStreamReader/OutputStreamWriter：是字节流和字符流之间的桥梁

配置文件Properties

16、集合体系

|--Collection

|--List：元素是有序的，元素允许重复，因为该集合体系都具有索引

|--ArrayList：底层数据结构是数组，查询速度快，增删操作较慢，线程不同步

|--LinkedList：底层数据结构是链表，查询效率较低，增删操作快，线程不同步

|--Vector：功能同ArrayList类似，底层也是数组，不同是线程是同步的，效率较低

|--Set：元素是无序的，元素不允许重复，底层用到了Map

|--HashSet：底层hash表，存储的对象最好复写hashCode和equals方法，保证元素不会重复

|--TreeSet：底层二叉树，存储的对象具备比较性，有两种方法

|--Map：数据是以键值对的形式存储的，有的元素存在映射关系就可以使用该集合，元素不允许重复

|--HashMap：允许有null键或值，线程不同步

|--TreeMap

|--HashTable：类似HashMap，不允许有null键或值，线程同步

17、线程的创建方式，进程线程的理解

两种：继承Thread或实现Runnable

进程是一个执行中的程序，每一个程序都至少有一个执行顺序，该顺序是一个路径，或者叫一个控制单元。

线程是进程中的一个独立的控制单元，线程在控制着进程的执行。

18、局部变量和成员变量区别

成员变量：作用于整个类中，随对象存储在堆内存中，生命周期跟对象一样

局部变量：作用于方法或语句中，方法或语句结束则生命周期结束，存放在栈内存中。

19、同步函数与同步代码块的区别

它们的作用都是封装多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可参与进来。

同步代码块：位置比较灵活，封装了操作共享数据的语句，多个线程中只有持有锁的才可以操作共享数据，需要指定一个对象作为锁

同步方法：声明方法时加synchronized关键字修饰，同步函数使用的锁是this，持有锁的线程调用这个方法时其他线程无法调用。

20、数组和集合的区别

数组可以存储基本数据类型和对象，它是一个线性的序列，可以快速的访问其中的元素。数组创建之后，容量就固定了，而且在其生命周期里是不能改变的

集合只用于存储对象，集合的长度是可变的，集合可以存储不同类型的对象。集合的长度并不是固定的，可以便捷的添加删除。能够更加便捷的操作元素，功能更加强大

21、StringBuffer和StringBuilder的区别

StringBuffer是线程安全的，StringBuilder是线程不安全的，所以效率比起来StringBuilder要比StringBuffer快。

一般单线程的程序使用StringBuilder比较好，多线程的情况下可以自己加锁，也可以直接使用StringBuffer

22、String和StringBuffer区别

String对象一经创建就不会发生变化了，即便是赋新值也不是在原对象的基础上改变，而是创建一个新的字符串对象，将引用指向这个新的对象，会造成空间的浪费，效率较低

StringBuffer只创建一个对象，是在同一个实例的基础之上追加，效率更高，当需要用到String的时候toString就可以了