Java（面试题准备（技术面））

Zachsj

已于 2022-08-22 21:05:15 修改

阅读量552

点赞数

分类专栏： Java（学习笔记） # Java（笔试面试）文章标签： java 面试题

于 2022-08-20 15:01:48 首次发布

本文链接：https://blog.csdn.net/Zachsj/article/details/126266707

版权

Java（学习笔记）同时被 2 个专栏收录

71 篇文章 0 订阅

订阅专栏

Java（笔试面试）

4 篇文章 0 订阅

订阅专栏

Java（面试题准备（技术面））

*** * * * 第一部分 * * * ***

1. 什么是同步？什么是异步？

同步是指多个线程在同一个时间只能有一个线程运行。
异步是指多个线程在同一个时间可以同时运行（并行）。

2. 什么是死锁？

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

3. sleep() 和 wait() 的异同？

相同点：
- 一旦执行方法，都可以使得当前线程进入阻塞状态。
不同点：
- 声明位置不同：Thread类中声明sleep()，Object类中声明wait()。
- 调用要求不同：sleep()可以在任何需要的场景下调用。wait()必须使用在 同步代码块或同步方法 中。
- 关于是否释放同步监视器：如果两个方法都使用在同步代码块或者同步方法中，sleep() 不会释放锁，wait() 会释放锁。

4. 释放锁的操作和不释放锁的操作

1. 释放锁的操作：

当前线程的同步方法、同步代码块执行结束。
当前线程在同步代码块、同步方法中遇到break、return终止了该代码块和该方法的继续执行。
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

2. 不释放锁的操作：

线程执行同步代码块、同步方法时，程序调用了Thread.sleep()、Thread.yield() 方法，暂停当前线程的执行。
线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）
- 应该尽量避免使用suspend()和resume()来控制线程。

5. 实现多线程的四种方式

1. 继承Thread类 创建线程

优点：
- 可以直接使用this获取当前线程。
缺点：
- 但是Java不支持多继承，如果继承Thread类就不能继承其他类。
- 任务与代码没有分离，如果多个线程执行一样的任务时需要多分任务代码。
- 没有返回值。

2. 实现Runnable接口 创建线程

优点：
- 多个线程可以共享一份task代码逻辑。
- RunnableTask可以继承其他类。
缺点：
- 没有返回值。

3. 实现Callable接口 通过FutureTask包装器来创建Thread线程

优点：
- 多个线程可以共享一份task代码逻辑。
- FutureTask可以继承其他类。
- call()方法有返回值。
- call()方法可以抛异常，而run()方法不可以抛异常。
- Callable接口支持泛型。
缺点：
- 主线程会堵塞。

4. 使用线程池

优点：
- 提高响应速度。（减少了创建新线程的时间）
- 降低资源消耗。（重复利用线程池中的线程，不需要每次都创建）
- 便于线程管理。
  - corePoolSize：核心池的大小
  - maximumPoolSize：最大线程数
  - keepAliveTime：线程没任务时最多保持多长时间后会终止

6. String和StringBuffer、StringBuilder之间的转换

String → StringBuffer、StringBuilder：
- 调用StringBuffer、StringBuilder构造器
StringBuffer、StringBuilder → String：
- 调用String构造器
- 调用StringBuffer、StringBuilder的toString()方法

7. 比较String、StringBuffer和StringBuilder的异同

https://blog.csdn.net/Zachsj/article/details/126265974
String不可变长、StringBuffer和StringBuilder可变长
StringBuffer是线程安全的，但是效率低，通常用在多线程中。
后来出现了StringBuilder，线程不安全，但是效率高，单线程中用的较多。

8. JVM中字符串常量池存放位置说明

JDK 1.6：字符串常量池在方法区（即永久代，后改名元空间）。
JDK 1.7：字符串常量池在堆空间。
JDK 1.8：字符串常量池在方法区（即元空间），但方法区在堆空间。

9. 翻转中间的字符串并输出

package com.zach.day05;

/**
 * @author : Zach
 * @date : 2022-08-17 14:55
 * @description : TODO
 * @modified by : Zach
 */

//翻转中间的字符串输出
public class Test02 {
    public static void main(String[] args) {
        String str = "ABCDEFG";
        String reverse = reverse(str,2,4);
        System.out.println(reverse);
    }

    public static String reverse(String str, int startIndex, int endIndex){
        if (str != null){
            StringBuilder builder = new StringBuilder(str.length());
            //前部
            builder.append(str, 0, startIndex);
            //中部
            for (int i = endIndex; i >= startIndex; i--) {
                builder.append(str.charAt(i));
            }
            //后部
            builder.append(str.substring(endIndex+1));

            return builder.toString();
        }else {
            return null;
        }
    }
}

10. 比较throw 和 throws两者的异同

同：无
不同：
- throw：生成一个异常对象，并抛出。使用在方法内部 <-> 自动抛出异常对象。
- throws：处理异常的方式。使用在方法声明处的末尾 <-> try-catch-finally。

11. 比较ArrayList、LinkedList、Vector三者的异同

同：
- 三个类都实现了List接口，都是List接口的实现类，
- 三个类存储数据的特点相同：都是存储有序的，可重复的数据。
- ArrayList和Vector底层都使用数组Object[] elementData存储数据。
不同：
- ArrayList：
  - 作为List接口的主要实现类；
  - 底层使用数组存储数据，所以查询效率高，但插入和删除效率低；
  - 线程不安全，但效率高；
  - 需要线程安全时，会把数组方法放到SynchronizedList中。Collections.synchronizedList(new ArrayList());
- LinkedList：
  - 底层使用双向链表存储数据，所以对于频繁地插入和删除操作，效率比ArrayList高。
  - 没有下标属性，查询数据效率低。
- Vector：
  - 作为List接口的古老实现类；
  - 线程安全，但效率低。

12. 集合Collection中存储的如果是自定义类的对象，需要自定义类重写哪个方法？为什么？

equals()方法
方便后面需要使用contains()/remove()等方法…

13. 比较HashSet、LinkedHashSet、TreeSet的异同

存储无序的，不可重复的数据
HashSet：
- 作为Set接口的主要实现类；
- 线程是不安全的；
- 可以存储null值。
LinkedHashSet： 是HashSet的子类
- 作为HashSet的子类，遍历其内部数据时，可以按照添加的顺序遍历；
- 对于频繁的遍历操作，LinkedHashSet效率高于HashSet。
TreeSet： （红黑二叉树）
- 可以按照添加对象的指定属性，进行排序。
- 所以数据必须是同一个类创建的。

14. 比较HashMap、LinkedHashMap、TreeMap、Hashtable、Properties的异同

Map：双列数据，存储key-value对的数据，类似于高中的函数y=f(x)
- HashMap：作为Map的主要实现类：线程不安全的，但效率高；可存储null值的key、value
  - LinkedHashMap：保证在遍历map元素时，可以按照添加的顺序实现遍历。
    - 原因：在原有的HashMao底层结构基础上，添加了一对指针，指向前一个和后一个元素。
    - 对于频繁的遍历操作，效率高于HashMap
- TreeMap：保证按照添加的key-value对进行排序，实现排序遍历。（此时考虑key的自然排序或定制排序）
  - 底层使用红黑树
- Hashtable：作为古老的实现类：线程安全的，但效率低；不能存储null值的key、value
  - Properties：常用来处理配置文件。key和value都是String类型。

HashMap底层：
- 数组+链表（JDK7及以前）
- 数组+链表+红黑树（JDK8）

Map结构的理解：
- Map中的key：是无序的，且不可重复的，使用Set存储所有的key。
  - （key所在的类要重写equals()和hashCode()方法，以HashMao为例）
- Map中的value：是无序的，但可重复的，使用Collection存储所有的value
  - （value所在的类要重写equals()）
  - 一个键值对：key-value构成了一个Entry对象
- Map中的entry：是无序的，不可重复的，使用Set存储所有的entry

15. 简述HashMap的底层实现原理

HashMap的底层实现原理？ 以jdk7为例说明:
HashMap map = new HashMap():
在实例化以后，底层创建了长度是16的一维数组Entry[] table。
- …可能己经执行过多次put. . .
- map.put(key1,value1):
- 首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。
- 如果此位置上的数据为空，此时的key1-value1添加成功。----情况1
- 如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据的哈希值:
  - 如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。----情况2
  - 如果key1的哈希值和已经存在的某一个数据(key2-vaLue2)的哈希值相同，继续比较:调用key1所在类的equals(key2)：
    - 如果equals()返回false:此时key1-value1添加成功。----情况3
    - 如果equals()返回true:使用value1替换value2。
补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。
在不断的添加过程中，会涉及到扩容问题，当超出临界值（且要存放的位置非空）时，扩容。默认的扩容方式:扩容为原来容量的2倍，并将原有的数据复制过来。

JDK8相较于JDK7在底层实现方面的不同：
- new HashMap()：底层没有创建一个长度为16的数组
- JDK8底层的数组是：Node[],而非Entry[]
- 首次调用put()方法时，底层创建长度为16的数组（类似ArrayList在7和8的区别）
- JDK7底层结构只有：数组+链表。JDK8中底层结构：数组+链表+红黑树
  - 当数组的某一个索引位置上的元素以链表形式存在的数据个数>8，且当前数组长度>64时，此时此索引位置上的 所有数据改为使用红黑树存储。

16. Collection 和 Collections的区别？

Collections是操作Collection集合的工具类
Collection是存储单列数据的集合接口，常见子接口有List和Set

*** * * * 第二部分 * * * ***

17. Java中boolean类型到底占用多少字节？多少位？

占1位
- 由于boolean类型的值只有true和false两种逻辑值，在编译后会使用1和0来表示，而这两个数在内存中只需要1位，即1bit即可存储。位，是计算机最小的存储单位。
占1个字节
- 虽然在编译后1和0只占用1位空间，但是计算机处理数据的最小单位是1个字节，1个字节等于8位，所以实际存储方式为：用1个字节的最低位存储，其他7位用0填补。若值为true则存储的二进制为：0000 0001，若值为false则存储的二进制为：0000 0000。
占4个字节（单独使用）/1个字节（在数组中使用）
- 《Java虚拟机规范》一书中描述：“虽然定义了boolean这种数据类型，但是只对它提供了非常有限的支持。在Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达式所操作的boolean值，在编译之后都使用Java虚拟机中的int数据类型来代替，而boolean数组将会被编码成Java虚拟机的byte数组，那么每个boolean元素就占8位”。综上所述，boolean类型单独使用占4个字节，而在数组中使用却占1个字节。
显然第三种说法更有说服力，那为什么虚拟机要用int代替boolean，而不用byte或者short，不是更节省内存空间吗？经查阅资料发现，使用int的原因是，对于当下32位的处理器（cpu）来说，一次处理数据是32位（不是指32/64位系统，而是指cpu硬件层面），具有高效存取的特点。

18. HashMap和Hashtable的区别？

HashMap底层是数组+链表+红黑树（JDK8开始才有红黑树），效率高，但是线程不安全，且允许null值。
Hashtable底层是数组，线程安全的，不允许null值。

19. Java线程常见的基本状态？

就绪态
运行态
阻塞态
消亡态

20. 谈谈递归和迭代？

方法调用自身，称为递归
利用变量的原值推出新值，称为迭代
递归：
- 优点：代码精简，可读性好。
- 缺点：浪费空间，容易造成堆栈溢出。
迭代：
- 优点：效率好，没有额外的空间开销。
- 缺点：代码不如递归简洁，可读性差。

21. 描述"=="和"equals方法"的异同

首先，"=="和"equals方法"在超类Object类中默认比较的都是地址。
- （原因：因为equals方法底层默认实现"=="）
但是，当比较两个基本数据类型时，"=="和"equals方法"比较的都是数值，而不是地址。
- （可能原因一：假设基本数据类型没有地址。没有地址只能比较数据。）
- （可能原因二：假设基本数据类型是有地址的。那么，因为从类中创建的基本数据类型的数据都是在堆内存的常量池中的，而在方法中创建的基本数据类型的数据都是在栈内存中的。两者一个在堆中，一个在栈中，地址明显不同，但用"=="进行比较却显示true，那么就证明"=="在比较基本数据类型时，比较的不是地址，是数值。）
然后，当比较两个不同种类的基本数据类型时，小范围的类型会自动升级为大范围的类型，再与大范围的类型进行比较。
- 例如，int类型的数据会自动升级为double类型与之比较。但是，使用Objects.equals(a1, b1)这条语句进行比较时，一旦发现两者数据类型不同，则会直接返回false（原理不明）。
然后，当比较两个基本数据类型的封装类型时，"=="比较的是地址，equals方法比较的是数值。
- 而且，Integer包装类有一个缓存区IntegerCache，范围是[-128，127]，当数据在该范围内时，数据共用一个对象，超出范围才会创建一个新的对象。此时，相同的数据，地址会不同。
  - 例如，Integer a = 1; Integer b = 1;此时，a==b会返回true。而Integer a = 128; Integer b = 128;此时，a==b会返回false。如果想正确比较内容可以使用equals方法解决该问题，因为包装类覆写了equals方法。
然后，当比较String类型的对象（字符串）时，"=="就是默认的比较地址，equals方法则比较的是具体的字符串内容。
- 原因：因为String类重写（Override）了equals方法。
最后，当比较自定义类型的对象，且没有重写equals方法时，"=="和equals方法比较的都是地址。
- 原因：和超类Object类中默认的一样。
另外：数组创建时都会生成新的地址来存放数组，即使数组的内容相同，地址也是不同的，除非创建数组时是通过传递引用（传址）。
另外：当基本数据类型和对应包装类型进行比较时，包装类型会自动拆箱，而不是基本数据类型自动装箱。所以就相当于两个相同的基本数据类型在比较。
另外：Integer a = new Integer(1); Integer b = new Integer(1); a==b返回false，因为是new出来的，地址不同。

22. Java中如何跳出两层循环？

break outerLoop：
- 给外循环加上 outerLoop: 的标签，在想要跳出的位置写上break outerLoop;
return：
- 由于是直接结束了整个方法，自然也就跳出了该方法下所有的循环。
等待所有循环结束，自然就退出了所有的循环。
PS：由于用了 return 会跳过与循环语句平行的其他未执行语句，为了避免这种情况，可以将两层循环单独抽离成一个方法，在其他方法中进行调用即可。

*** * * * 第三部分 * * * ***

23. 面向对象的三大基本特征？

封装
继承
多态
（有时会提到抽象）

24. String是基本数据类型吗？

不是
一共有八大基本数据类型：
- byte、char、boolean、short
- int、long、float、double

25. int 和 Integer有什么区别？

int是原始数据类型，Integer是java为int提供的封装类。八大基本数据类型都有包装类。

26. & 和 &&的区别？

&是位运算符，表示按位与
&&是逻辑运算符，表示逻辑与

27. final、finally、finalize的区别？

final 用来声明属性、方法、类，表示属性不可变、方法不可覆盖、类不可继承
finally 是异常处理语句结构的一部分，表示总是执行
finalize是Object类的一个方法，在垃圾收集器执行的时候会用到

28. Overload和Override的区别？Overloaded的方法是否可以改变返回值的类型?

方法的重写Overriding和重载Overloading是Java多态性的不同表现。
- 重写Overriding是父类与子类之间多态性的一种表现，
- 重载Overloading是一个类中多态性的一种表现。
如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。
重载Overloaded的方法是可以改变返回值的类型的。

29. error和exception有什么区别?

error 表示一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。
exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

30. GC是什么? 为什么要有GC?

GC是垃圾收集的意思（Gabage Collection），内存处理是编程人员容易出现问题的地方。
忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃。
Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。

31. short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，需要强制转换类型）
short s1 = 1; s1 += 1;（可以正确编译）

32. Math.round(11.5)等于多少? Math.round(-11.5)等于多少?

Math.round(11.5)==12
Math.round(-11.5)==-11
round方法返回与参数最接近的长整数，参数加1/2后求其floor

33. String s = new String(“xyz”);创建了几个String Object?

如果常量池中有xyz，1个
如果没有，2个

34. Java有没有goto?

java中的保留字，现在没有在java中使用。

35. 启动一个线程是用run()还是start()?

启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。
run()方法可以产生必须退出的标志来停止一个线程。

36. 给我一个你最常见到的runtime exception？

IndexOutOfBoundsException
NoSuchElementException
NullPointerException
SecurityException，SystemException

37. 接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?

接口可以继承接口。
抽象类可以实现(implements)接口。
抽象类可继承实体类，但前提是实体类必须有明确的构造函数。

38. List, Set, Map是否继承自Collection接口?

List，Set是，Map不是

39. abstract的method是否可同时是static，是否可同时是native，是否可同时是synchronized?

都不能

40. 数组有没有length()这个方法? String有没有length()这个方法？

数组没有 length()这个方法，有length的属性。
String有 length()这个方法。

41. Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?

Set里的元素是不能重复的
用iterator()方法来区分重复与否
用equals()来判读两个Set是否相等。
equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。

42. 构造器Constructor是否可被override?

构造器Constructor不能被继承，因此不能重写Overriding
但可以被重载Overloading。

43. 是否可以继承String类?

String类是final类，故不可以继承。

44. swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?

switch（expr1）中，expr1是一个整数表达式。
因此传递给 switch 和 case 语句的参数应该是 int、short、char 或者 byte。
long、string 都不能作用于swtich。

45. try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?

会执行，在return前执行。

46. 用最有效率的方法算出2乘以8等于几?

位运算，左移三位，2 << 3

47. 两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?

不对，相同内容的对象有相同的hash code。
但是有相同hash code的的对象，内容不一定相同。

48. 当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?

是值传递。Java 只有值传递。
当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。

49. 当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

不能，一个对象的一个synchronized方法只能由一个线程访问。

50. 单例模式的懒汉模式和饿汉模式代码实现，以及区别？

懒汉式一开始不会实例化，什么时候用就什么时候new，才进行实例化。
饿汉式在一开始类加载的时候就已经实例化，并且创建单例对象，以后只管用即可。

懒汉式

public class Singleton {
　	//默认不会实例化，什么时候用就什么时候new
    private static Singleton instance = null;
    private Singleton(){

    }
    public static synchronized Singleton getInstance(){
        if(instance == null){
　　　//什么时候用就什么时候new
            instance = new Singleton();
        }
        return instance;
    }
}

饿汉式

public class Singleton {
　	//一开始类加载的时候就实例化，创建单实例对象
    private static Singleton instance = new Singleton();
    private Singleton(){

    }
    public static Singleton getInstance(){
        return instance;
    }
}

懒汉式和饿汉式的安全和性能区别：
- 线程安全：
  - 饿汉式在线程还没出现之前就已经实例化了，所以 饿汉式是线程安全的。
  - 懒汉式加载是在使用时才会去new 实例的，那么你去new的时候是一个动态的过程，是放到方法中实现的，但是加同步锁后，也是安全的。
- 执行效率：
  - 饿汉式没有加任何的锁，因此执行效率比较高。
  - 懒汉式一般使用都会加同步锁，效率比饿汉式差。
- 内存使用：
  - 饿汉式在一开始类加载的时候就实例化，无论使用与否，都会实例化，所以会占据空间，浪费内存。
  - 懒汉式什么时候用就什么时候实例化，不浪费内存。

51. 请说出你所知道的线程同步的方法。

wait()：等待方法，使一个线程处于等待状态，并且释放所持有的对象的lock。
sleep()：睡眠方法，使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
notify()：唤醒方法，唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
Allnotity()：唤醒所有方法，唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

52. char型变量中能不能存储一个中文汉字?为什么?

可以，因为java中有unicode编码，一个char占16个字节，所以放一个中文是没问题的。

53. 什么情况下调用doGet()和doPost()？

Jsp页面中的form标签里的method属性为get时调用doGet()，为post时调用doPost()。

54. servlet的生命周期

web容器加载servlet，生命周期开始。
通过调用servlet的init()方法进行servlet的初始化。
通过调用service()方法实现，根据请求的不同调用不同的do***()方法。
结束服务，web容器调用servlet的destroy()方法。

55. 页面间对象传递的方法

request，
session，
application，
cookie
…

56. J2EE是技术还是平台还是框架？

J2EE本身是一个标准，一个为企业分布式应用的开发提供的标准平台。
J2EE也是一个框架，包括JDBC、JNDI、RMI、JMS、EJB、JTA等技术。

57. 简述synchronized和java.util.concurrent.locks.Lock的异同？

主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：
- Lock有比synchronized更精确的线程语义和更好的性能。
- synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。

58. j2ee常用的设计模式？说明工厂模式。

Java中的23种设计模式：
- Factory（工厂模式）， Builder（建造模式）， Factory Method（工厂方法模式），
- Prototype（原始模型模式），Singleton（单例模式）， Facade（门面模式），
- Adapter（适配器模式）， Bridge（桥梁模式）， Composite（合成模式），
- Decorator（装饰模式）， Flyweight（享元模式）， Proxy（代理模式），
- Command（命令模式）， Interpreter（解释器模式）， Visitor（访问者模式），
- Iterator（迭代子模式）， Mediator（调停者模式）， Memento（备忘录模式），
- Observer（观察者模式）， State（状态模式）， Strategy（策略模式），
- Template Method（模板方法模式）， Chain Of Responsibleity（责任链模式）

工厂模式：（真被问到了）
- 工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。

59. 排序都有哪几种方法？请列举。用JAVA实现一个快速排序。

排序的方法有：
- 插入排序（直接插入排序、希尔排序），
- 交换排序（冒泡排序、快速排序），
- 选择排序（直接选择排序、堆排序），
- 归并排序，分配排序（箱排序、基数排序）
快速排序的伪代码。

/*使用快速排序方法对a[ 0 :n- 1 ]排序 
	从a[ 0 :n- 1 ]中选择一个元素作为m i d d l e，该元素为支点 
	把余下的元素分割为两段left 和r i g h t，使得l e f t中的元素都小于等于支点，而right 中的元素都大于等于支点 
	递归地使用快速排序方法对left 进行排序 
	递归地使用快速排序方法对right 进行排序 
	所得结果为l e f t + m i d d l e + r i g h t
*/

60. 一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？

可以。必须只有一个类名与文件名相同。

61. java中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？

有两种实现方法，分别是继承Thread类与实现Runnable接口
用synchronized关键字修饰同步方法
stop()方法，不安全。
suspend()方法，容易发生死锁。

62. java中有几种类型的流？

字节流，字符流。

62. java中会存在内存泄漏吗，请简单描述。

会。如：int i,i2; return (i-i2); //when i为足够大的正数,i2为足够大的负数。
结果会造成溢位，导致错误。

63. java中实现多态的机制是什么？

方法的重写Overriding和重载Overloading是Java多态性的不同表现。
重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。

64. 静态变量和实例变量的区别？

static i = 10; //常量，不可变
class A a; a.i =10; //变量，可变

65. 什么是java序列化，如何实现java序列化？

序列化就是一种用来处理对象流的机制，可以对流化后的对象进行读写操作。
序列化的实现：将需要被序列化的类实现Serializable接口。

66. 是否可以从一个static方法内部发出对非static方法的调用？

不可以，如果其中包含对象的method()；不能保证对象初始化.

67. 写clone()方法时，通常都有一行代码，是什么？

Clone 有缺省行为，super.clone();他负责产生正确大小的空间，并逐位复制。

68. 在JAVA中，如何跳出当前的多重嵌套循环？

用break; return方法。

69. J2EE是什么？

J2EE是 Sun公司提出的多层(multi-diered)，分布式(distributed)，基于组件(component-base)的 企业级应用模型。

70. Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?

可以继承其他类或完成其他接口，在swing编程中常用此方式。

71. BS与CS的联系与区别？

B/S是Brower/Server，需要用到浏览器。
C/S是Client/Server，需要用到客户端软件。

*** * * * 第四部分 * * * ***

72. 什么是 jdk、jre？

JDK是 Java开发工具包，是给程序员使用的
JDK包含了JRE，JRE是 Java的运行环境。

73. 封装的理解？

将对象的数据和行为组合在一起，把实现细节隐藏起来，不允许外部直接访问；
把方法暴露出来，让方法来操作这些数据。

74. 方法重写要求有哪些？

在父子类中，返回类型必须与被重写方法的返回类型相同。
重写方法不能比被重写方法限制有更严格的访问级别。
参数列表必须与被重写方法的相同。
重写方法不能抛出新的异常或者比被重写方法声明的检查异常更广的检查异常。但是可以抛出更少，更有限或者不抛出异常。

75. static 修饰方法和属性如何访问？

通过类名访问

76. 构造方法什么时候调用？

创建对象new Class.forName(“”).newInstance()
创建子类对象

77. this 代表什么？Super 代表什么？

this 表示的是当前对象的引用，哪个对象调用了 this 所在的函数，this 就代表哪个对象；
super 表示的是当前类的父类。

78. 面向对象有几个特征？

封装、继承、多态

79. 接口和抽象类的区别？

抽象类可以提供成员方法的实现细节，而接口中只能存在 public abstract 方法；
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的；
接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；
一个类只能继承一个抽象类，而一个类却可以实现多个接口。

80. 什么是多态？

父类的引用指向子类的实例
class B extends A
A a = new B();
a 是 A 类型。即，使用多态后，对象仍然是父类类型

81. 数组的初始化方式有几种？

int[] i = new int[]{1,2,3,4,5};
int[] j = {1,2,3,4,5};
int[] k = new int[10];

82. 值传递和引用传递的区别？

Java中只有值传递，引用传递传的是地址值。

83. 线程中 sleep()和 wait()的区别？

在调用 sleep()方法的过程中，线程不会释放对象锁。
在调用 wait()方法的过程中，线程会释放对象锁。
在调用 sleep()方法，线程会自己醒来。
在调用 wait()方法，线程需要被其他线程唤醒。
在调用 sleep()方法前，不需要获取任何东西。
在调用 wait()方法前，要先获取调用 wait 方法的对象的对象锁。

84. 如果重写了一个类的 hashCode 方法，还要考虑什么？

考虑重写 equals 方法

85. Exception RuntimeException Error Throwable 之间的父子关系是什么样子的？

Throwable
- Exception
  - RuntimeException
- Error

86. 列出 String 中至少 15 个方法（非继承于 Object 的）。说明这些方法的作用？

charAt(int index)
contains(CharSequence s)
endsWith(String suffix)
equalsIgnoreCase(String anotherString)
getBytes()
indexOf(int ch)
isEmpty()
lastIndexOf(int ch)
length()
matches(String regex)
replace(char oldChar, char newChar)
replaceAll(String regex, String replacement)
split(String regex)
startsWith(String prefix)
substring(int beginIndex)
substring(int beginIndex, int endIndex)
toCharArray()
toLowerCase()
toUpperCase()
trim()

87. 什么是接口？

接口是一些方法特征的集合，接口是对抽象的抽象。
接口是规范，用于定义实现类中的方法，用于解耦合，分离方法的调用者和实现者。

88. 集合如何分类？

collection
- set
  - HashSet
  - TreeSet
- list
  - ArrayList
  - LinkedList
  - Vector
Map
- HashMap
- TreeMap
- Hashtable

89. 流如何分类？

按照输入的方向分，输入流和输出流
按照处理数据的单位不同分，字节流和字符流
按照功能的不同分，分节点流和包装流

90. 线程生命周期有哪些状态？什么情况下回进入该状态？

生命周期的 7 种状态
新建（new Thread）
- 当创建 Thread 类的一个实例（对象）时，此线程进入新建状态（未被启动）。
就绪（runnable）
- 线程已经被启动，
  正在等待被分配给CPU时间片，也就是说此时线程正在就绪队列中排队等候得到CPU资源。
运行（running）
- 线程获得 CPU 资源正在执行任务（run()方法），此时除非此线程自动放弃 CPU 资源或者有优先级更高的线程进入，线程将一直运行到结束。
死亡（dead）
- 当线程执行完毕或被其它线程杀死，线程就进入死亡状态，这时线程不可能再进入就绪状态等待执行。
堵塞（blocked）
- 由于某种原因导致正在运行的线程让出 CPU 并暂停自己的执行，即进入堵塞状态。
锁池
- 当线程没有获取到对象锁的时候，会进入锁池
等待池
- 调用 wait 方法的时候，会进入等待池

91. 什么是反射？通过反射能够获取一个类中的哪些信息？

反射定义：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取信息以及动态调用对象的方法的功能称为 java语言的反射机制。
能获取
- 类所在包,类名，父类，实现的接口
- 属性：
  - 修饰符，类型，名字，值
- 方法：
  - 修饰符，返回值类型，名字，抛出的异常、参数列表
- 构造方法：
  - 修饰符